|
1 | 1 | // Copyright (c) The go-grpc-middleware Authors. |
2 | 2 | // Licensed under the Apache License 2.0. |
3 | 3 |
|
4 | | -package zap_test |
| 4 | +package examplezap_test |
5 | 5 |
|
6 | 6 | import ( |
7 | 7 | "context" |
8 | | - "fmt" |
| 8 | + examplezap "github.com/grpc-ecosystem/go-grpc-middleware/interceptors/logging/examples/zap" |
| 9 | + "runtime" |
| 10 | + "strings" |
| 11 | + "testing" |
9 | 12 |
|
10 | 13 | "github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/logging" |
| 14 | + "github.com/grpc-ecosystem/go-grpc-middleware/v2/testing/testpb" |
| 15 | + "github.com/stretchr/testify/assert" |
| 16 | + "github.com/stretchr/testify/require" |
| 17 | + "github.com/stretchr/testify/suite" |
11 | 18 | "go.uber.org/zap" |
| 19 | + "go.uber.org/zap/zaptest/observer" |
12 | 20 | "google.golang.org/grpc" |
13 | 21 | ) |
14 | 22 |
|
15 | | -// InterceptorLogger adapts zap logger to interceptor logger. |
16 | | -// This code is simple enough to be copied and not imported. |
17 | | -func InterceptorLogger(l *zap.Logger) logging.Logger { |
18 | | - return logging.LoggerFunc(func(ctx context.Context, lvl logging.Level, msg string, fields ...any) { |
19 | | - f := make([]zap.Field, 0, len(fields)/2) |
20 | | - |
21 | | - for i := 0; i < len(fields); i += 2 { |
22 | | - key := fields[i] |
23 | | - value := fields[i+1] |
| 23 | +type zapExampleTestSuite struct { |
| 24 | + *testpb.InterceptorTestSuite |
| 25 | + observedLogs *observer.ObservedLogs |
| 26 | +} |
24 | 27 |
|
25 | | - switch v := value.(type) { |
26 | | - case string: |
27 | | - f = append(f, zap.String(key.(string), v)) |
28 | | - case int: |
29 | | - f = append(f, zap.Int(key.(string), v)) |
30 | | - case bool: |
31 | | - f = append(f, zap.Bool(key.(string), v)) |
32 | | - default: |
33 | | - f = append(f, zap.Any(key.(string), v)) |
34 | | - } |
35 | | - } |
| 28 | +func TestSuite(t *testing.T) { |
| 29 | + if strings.HasPrefix(runtime.Version(), "go1.7") { |
| 30 | + t.Skipf("Skipping due to json.RawMessage incompatibility with go1.7") |
| 31 | + return |
| 32 | + } |
| 33 | + observedZapCore, observedLogs := observer.New(zap.DebugLevel) |
| 34 | + logger := examplezap.InterceptorLogger(zap.New(observedZapCore)) |
| 35 | + s := &zapExampleTestSuite{ |
| 36 | + InterceptorTestSuite: &testpb.InterceptorTestSuite{ |
| 37 | + TestService: &testpb.TestPingService{}, |
| 38 | + }, |
| 39 | + observedLogs: observedLogs, |
| 40 | + } |
36 | 41 |
|
37 | | - logger := l.WithOptions(zap.AddCallerSkip(1)).With(f...) |
| 42 | + s.InterceptorTestSuite.ServerOpts = []grpc.ServerOption{ |
| 43 | + grpc.StreamInterceptor(logging.StreamServerInterceptor(logger)), |
| 44 | + grpc.UnaryInterceptor(logging.UnaryServerInterceptor(logger)), |
| 45 | + } |
38 | 46 |
|
39 | | - switch lvl { |
40 | | - case logging.LevelDebug: |
41 | | - logger.Debug(msg) |
42 | | - case logging.LevelInfo: |
43 | | - logger.Info(msg) |
44 | | - case logging.LevelWarn: |
45 | | - logger.Warn(msg) |
46 | | - case logging.LevelError: |
47 | | - logger.Error(msg) |
48 | | - default: |
49 | | - panic(fmt.Sprintf("unknown level %v", lvl)) |
50 | | - } |
51 | | - }) |
| 47 | + suite.Run(t, s) |
52 | 48 | } |
53 | 49 |
|
54 | | -func ExampleInterceptorLogger() { |
55 | | - logger := zap.NewExample() |
| 50 | +func (s *zapExampleTestSuite) TestPing() { |
| 51 | + ctx := context.Background() |
| 52 | + _, err := s.Client.Ping(ctx, testpb.GoodPing) |
| 53 | + assert.NoError(s.T(), err, "there must be not be an on a successful call") |
| 54 | + require.Equal(s.T(), 2, s.observedLogs.Len()) |
| 55 | + line := s.observedLogs.All()[0] |
56 | 56 |
|
57 | | - opts := []logging.Option{ |
58 | | - logging.WithLogOnEvents(logging.StartCall, logging.FinishCall), |
59 | | - // Add any other option (check functions starting with logging.With). |
60 | | - } |
| 57 | + contextMap := line.ContextMap() |
| 58 | + require.Equal(s.T(), zap.InfoLevel, line.Level) |
| 59 | + require.Equal(s.T(), "started call", line.Entry.Message) |
61 | 60 |
|
62 | | - // You can now create a server with logging instrumentation that e.g. logs when the unary or stream call is started or finished. |
63 | | - _ = grpc.NewServer( |
64 | | - grpc.ChainUnaryInterceptor( |
65 | | - logging.UnaryServerInterceptor(InterceptorLogger(logger), opts...), |
66 | | - // Add any other interceptor you want. |
67 | | - ), |
68 | | - grpc.ChainStreamInterceptor( |
69 | | - logging.StreamServerInterceptor(InterceptorLogger(logger), opts...), |
70 | | - // Add any other interceptor you want. |
71 | | - ), |
72 | | - ) |
73 | | - // ...user server. |
| 61 | + require.Equal(s.T(), "Ping", contextMap["grpc.method"]) |
| 62 | + require.Equal(s.T(), "grpc", contextMap["protocol"]) |
| 63 | + require.Equal(s.T(), "server", contextMap["grpc.component"]) |
74 | 64 |
|
75 | | - // Similarly you can create client that will log for the unary and stream client started or finished calls. |
76 | | - _, _ = grpc.Dial( |
77 | | - "some-target", |
78 | | - grpc.WithChainUnaryInterceptor( |
79 | | - logging.UnaryClientInterceptor(InterceptorLogger(logger), opts...), |
80 | | - // Add any other interceptor you want. |
81 | | - ), |
82 | | - grpc.WithChainStreamInterceptor( |
83 | | - logging.StreamClientInterceptor(InterceptorLogger(logger), opts...), |
84 | | - // Add any other interceptor you want. |
85 | | - ), |
86 | | - ) |
87 | | - // Output: |
| 65 | + require.Contains(s.T(), contextMap["peer.address"], "127.0.0.1") |
| 66 | + require.NotEmpty(s.T(), contextMap["grpc.start_time"]) |
| 67 | + require.NotEmpty(s.T(), contextMap["grpc.time_ms"]) |
88 | 68 | } |
0 commit comments