fixing vet issues ... most relating to the Examples

auth/DOC.md

@@ -4,6 +4,7 @@
 * [Overview](#pkg-overview)
 * [Imported Packages](#pkg-imports)
 * [Index](#pkg-index)
+* [Examples](#pkg-examples)
 
 ## <a name="pkg-overview">Overview</a>
 `grpc_auth` a generic server-side auth middleware for gRPC.
@@ -20,6 +21,59 @@ It also allows for per-service implementation overrides of `AuthFunc`. See `Serv
 
 Please see examples for simple examples of use.
 
+#### Example:
+
+<details>
+<summary>Click to expand code.</summary>
+
+```go
+package grpc_auth_test
+
+import (
+    "github.com/grpc-ecosystem/go-grpc-middleware/auth"
+    "github.com/grpc-ecosystem/go-grpc-middleware/tags"
+    "golang.org/x/net/context"
+    "google.golang.org/grpc"
+    "google.golang.org/grpc/codes"
+)
+
+var (
+    cc *grpc.ClientConn
+)
+
+func parseToken(token string) (struct{}, error) {
+    return struct{}{}, nil
+}
+
+func userClaimFromToken(struct{}) string {
+    return "foobar"
+}
+
+// Simple example of server initialization code.
+func Example_serverConfig() {
+    exampleAuthFunc := func(ctx context.Context) (context.Context, error) {
+        token, err := grpc_auth.AuthFromMD(ctx, "bearer")
+        if err != nil {
+            return nil, err
+        }
+        tokenInfo, err := parseToken(token)
+        if err != nil {
+            return nil, grpc.Errorf(codes.Unauthenticated, "invalid auth token: %v", err)
+        }
+        grpc_ctxtags.Extract(ctx).Set("auth.sub", userClaimFromToken(tokenInfo))
+        newCtx := context.WithValue(ctx, "tokenInfo", tokenInfo)
+        return newCtx, nil
+    }
+
+    _ = grpc.NewServer(
+        grpc.StreamInterceptor(grpc_auth.StreamServerInterceptor(exampleAuthFunc)),
+        grpc.UnaryInterceptor(grpc_auth.UnaryServerInterceptor(exampleAuthFunc)),
+    )
+}
+```
+
+</details>
+
 ## <a name="pkg-imports">Imported Packages</a>
 
 - [github.com/grpc-ecosystem/go-grpc-middleware](./..)
@@ -35,6 +89,9 @@ Please see examples for simple examples of use.
 * [type AuthFunc](#AuthFunc)
 * [type ServiceAuthFuncOverride](#ServiceAuthFuncOverride)
 
+#### <a name="pkg-examples">Examples</a>
+* [Package (ServerConfig)](#example__serverConfig)
+
 #### <a name="pkg-files">Package files</a>
 [auth.go](./auth.go) [doc.go](./doc.go) [metadata.go](./metadata.go) 
 

auth/auth_test.go

@@ -110,7 +110,7 @@ func (s *AuthTestSuite) TestUnary_PassesAuth() {
 }
 
 func (s *AuthTestSuite) TestUnary_PassesWithPerRpcCredentials() {
-	grpcCreds := oauth.TokenSource{&fakeOAuth2TokenSource{accessToken: commonAuthToken}}
+	grpcCreds := oauth.TokenSource{TokenSource: &fakeOAuth2TokenSource{accessToken: commonAuthToken}}
 	client := s.NewClient(grpc.WithPerRPCCredentials(grpcCreds))
 	_, err := client.Ping(s.SimpleCtx(), goodPing)
 	require.NoError(s.T(), err, "no error must occur")
@@ -141,7 +141,7 @@ func (s *AuthTestSuite) TestStream_PassesAuth() {
 }
 
 func (s *AuthTestSuite) TestStream_PassesWithPerRpcCredentials() {
-	grpcCreds := oauth.TokenSource{&fakeOAuth2TokenSource{accessToken: commonAuthToken}}
+	grpcCreds := oauth.TokenSource{TokenSource: &fakeOAuth2TokenSource{accessToken: commonAuthToken}}
 	client := s.NewClient(grpc.WithPerRPCCredentials(grpcCreds))
 	stream, err := client.PingList(s.SimpleCtx(), goodPing)
 	require.NoError(s.T(), err, "should not fail on establishing the stream")

auth/examples_test.go

@@ -21,7 +21,7 @@ func userClaimFromToken(struct{}) string {
 }
 
 // Simple example of server initialization code.
-func Example_ServerConfig() {
+func Example_serverConfig() {
 	exampleAuthFunc := func(ctx context.Context) (context.Context, error) {
 		token, err := grpc_auth.AuthFromMD(ctx, "bearer")
 		if err != nil {

logging/logrus/DOC.md

@@ -75,6 +75,63 @@ Note - due to implementation ZAP differs from Logrus in the "grpc.request.conten
 
 Please see examples and tests for examples of use.
 
+#### Example:
+
+<details>
+<summary>Click to expand code.</summary>
+
+```go
+// Logrus entry is used, allowing pre-definition of certain fields by the user.
+logrusEntry := logrus.NewEntry(logrusLogger)
+// Shared options for the logger, with a custom gRPC code to log level function.
+opts := []grpc_logrus.Option{
+    grpc_logrus.WithLevels(customFunc),
+}
+// Make sure that log statements internal to gRPC library are logged using the zapLogger as well.
+grpc_logrus.ReplaceGrpcLogger(logrusEntry)
+// Create a server, make sure we put the grpc_ctxtags context before everything else.
+_ = grpc.NewServer(
+    grpc_middleware.WithUnaryServerChain(
+        grpc_ctxtags.UnaryServerInterceptor(grpc_ctxtags.WithFieldExtractor(grpc_ctxtags.CodeGenRequestFieldExtractor)),
+        grpc_logrus.UnaryServerInterceptor(logrusEntry, opts...),
+    ),
+    grpc_middleware.WithStreamServerChain(
+        grpc_ctxtags.StreamServerInterceptor(grpc_ctxtags.WithFieldExtractor(grpc_ctxtags.CodeGenRequestFieldExtractor)),
+        grpc_logrus.StreamServerInterceptor(logrusEntry, opts...),
+    ),
+)
+```
+
+</details>
+
+#### Example:
+
+<details>
+<summary>Click to expand code.</summary>
+
+```go
+// Logrus entry is used, allowing pre-definition of certain fields by the user.
+logrusEntry := logrus.NewEntry(logrusLogger)
+// Shared options for the logger, with a custom duration to log field function.
+opts := []grpc_logrus.Option{
+    grpc_logrus.WithDurationField(func(duration time.Duration) (key string, value interface{}) {
+        return "grpc.time_ns", duration.Nanoseconds()
+    }),
+}
+_ = grpc.NewServer(
+    grpc_middleware.WithUnaryServerChain(
+        grpc_ctxtags.UnaryServerInterceptor(),
+        grpc_logrus.UnaryServerInterceptor(logrusEntry, opts...),
+    ),
+    grpc_middleware.WithStreamServerChain(
+        grpc_ctxtags.StreamServerInterceptor(),
+        grpc_logrus.StreamServerInterceptor(logrusEntry, opts...),
+    ),
+)
+```
+
+</details>
+
 ## <a name="pkg-imports">Imported Packages</a>
 
 - [github.com/golang/protobuf/jsonpb](https://godoc.org/github.com/golang/protobuf/jsonpb)
@@ -115,7 +172,10 @@ Please see examples and tests for examples of use.
   * [func WithLevels(f CodeToLevel) Option](#WithLevels)
 
 #### <a name="pkg-examples">Examples</a>
+* [Extract (Unary)](#example_Extract_unary)
 * [WithDecider](#example_WithDecider)
+* [Package (Initialization)](#example__initialization)
+* [Package (InitializationWithDurationFieldOverride)](#example__initializationWithDurationFieldOverride)
 
 #### <a name="pkg-files">Package files</a>
 [client_interceptors.go](./client_interceptors.go) [context.go](./context.go) [doc.go](./doc.go) [grpclogger.go](./grpclogger.go) [options.go](./options.go) [payload_interceptors.go](./payload_interceptors.go) [server_interceptors.go](./server_interceptors.go) 
@@ -180,6 +240,25 @@ func Extract(ctx context.Context) *logrus.Entry
 Extract takes the call-scoped logrus.Entry from grpc_logrus middleware.
 Deprecated: should use the ctxlogrus.Extract instead
 
+#### Example:
+
+<details>
+<summary>Click to expand code.</summary>
+
+```go
+_ = func(ctx context.Context, ping *pb_testproto.PingRequest) (*pb_testproto.PingResponse, error) {
+    // Add fields the ctxtags of the request which will be added to all extracted loggers.
+    grpc_ctxtags.Extract(ctx).Set("custom_tags.string", "something").Set("custom_tags.int", 1337)
+    // Extract a single request-scoped logrus.Logger and log messages.
+    l := ctx_logrus.Extract(ctx)
+    l.Info("some ping")
+    l.Info("another ping")
+    return &pb_testproto.PingResponse{Value: ping.Value}, nil
+}
+```
+
+</details>
+
 ## <a name="PayloadStreamClientInterceptor">func</a> [PayloadStreamClientInterceptor](./payload_interceptors.go#L74)
 ``` go
 func PayloadStreamClientInterceptor(entry *logrus.Entry, decider grpc_logging.ClientPayloadLoggingDecider) grpc.StreamClientInterceptor

logging/logrus/ctxlogrus/DOC.md

@@ -4,6 +4,7 @@
 * [Overview](#pkg-overview)
 * [Imported Packages](#pkg-imports)
 * [Index](#pkg-index)
+* [Examples](#pkg-examples)
 
 ## <a name="pkg-overview">Overview</a>
 `ctxlogrus` is a ctxlogger that is backed by logrus
@@ -29,6 +30,9 @@ Please see examples and tests for examples of use.
 * [func Extract(ctx context.Context) \*logrus.Entry](#Extract)
 * [func ToContext(ctx context.Context, entry \*logrus.Entry) context.Context](#ToContext)
 
+#### <a name="pkg-examples">Examples</a>
+* [Extract (Unary)](#example_Extract_unary)
+
 #### <a name="pkg-files">Package files</a>
 [context.go](./context.go) [doc.go](./doc.go) [noop.go](./noop.go) 
 
@@ -47,6 +51,37 @@ Extract takes the call-scoped logrus.Entry from ctx_logrus middleware.
 If the ctx_logrus middleware wasn't used, a no-op `logrus.Entry` is returned. This makes it safe to
 use regardless.
 
+#### Example:
+
+<details>
+<summary>Click to expand code.</summary>
+
+```go
+package ctxlogrus_test
+
+import (
+    "github.com/grpc-ecosystem/go-grpc-middleware/logging/logrus/ctxlogrus"
+    "github.com/grpc-ecosystem/go-grpc-middleware/tags"
+    "github.com/sirupsen/logrus"
+    "golang.org/x/net/context"
+)
+
+var logrusLogger *logrus.Logger
+
+// Simple unary handler that adds custom fields to the requests's context. These will be used for all log statements.
+func ExampleExtract_unary() {
+    ctx := context.Background()
+    // setting tags will be added to the loggerr as log fields
+    grpc_ctxtags.Extract(ctx).Set("custom_tags.string", "something").Set("custom_tags.int", 1337)
+    // Extract a single request-scoped logrus.Logger and log messages.
+    l := ctxlogrus.Extract(ctx)
+    l.Info("some ping")
+    l.Info("another ping")
+}
+```
+
+</details>
+
 ## <a name="ToContext">func</a> [ToContext](./context.go#L59)
 ``` go
 func ToContext(ctx context.Context, entry *logrus.Entry) context.Context

logging/logrus/ctxlogrus/examples_test.go

@@ -3,22 +3,19 @@ package ctxlogrus_test
 import (
 	"github.com/grpc-ecosystem/go-grpc-middleware/logging/logrus/ctxlogrus"
 	"github.com/grpc-ecosystem/go-grpc-middleware/tags"
-	pb_testproto "github.com/grpc-ecosystem/go-grpc-middleware/testing/testproto"
 	"github.com/sirupsen/logrus"
 	"golang.org/x/net/context"
 )
 
 var logrusLogger *logrus.Logger
 
 // Simple unary handler that adds custom fields to the requests's context. These will be used for all log statements.
-func Example_HandlerUsageUnaryPing() {
-	_ = func(ctx context.Context, ping *pb_testproto.PingRequest) (*pb_testproto.PingResponse, error) {
-		// Add fields the ctxtags of the request which will be added to all extracted loggers.
-		grpc_ctxtags.Extract(ctx).Set("custom_tags.string", "something").Set("custom_tags.int", 1337)
-		// Extract a single request-scoped logrus.Logger and log messages.
-		l := ctxlogrus.Extract(ctx)
-		l.Info("some ping")
-		l.Info("another ping")
-		return &pb_testproto.PingResponse{Value: ping.Value}, nil
-	}
+func ExampleExtract_unary() {
+	ctx := context.Background()
+	// setting tags will be added to the loggerr as log fields
+	grpc_ctxtags.Extract(ctx).Set("custom_tags.string", "something").Set("custom_tags.int", 1337)
+	// Extract a single request-scoped logrus.Logger and log messages.
+	l := ctxlogrus.Extract(ctx)
+	l.Info("some ping")
+	l.Info("another ping")
 }

logging/logrus/examples_test.go

@@ -19,7 +19,7 @@ var (
 )
 
 // Initialization shows a relatively complex initialization sequence.
-func Example_Initialization() {
+func Example_initialization() {
 	// Logrus entry is used, allowing pre-definition of certain fields by the user.
 	logrusEntry := logrus.NewEntry(logrusLogger)
 	// Shared options for the logger, with a custom gRPC code to log level function.
@@ -41,7 +41,7 @@ func Example_Initialization() {
 	)
 }
 
-func Example_InitializationWithDurationFieldOverride() {
+func Example_initializationWithDurationFieldOverride() {
 	// Logrus entry is used, allowing pre-definition of certain fields by the user.
 	logrusEntry := logrus.NewEntry(logrusLogger)
 	// Shared options for the logger, with a custom duration to log field function.
@@ -63,7 +63,7 @@ func Example_InitializationWithDurationFieldOverride() {
 }
 
 // Simple unary handler that adds custom fields to the requests's context. These will be used for all log statements.
-func Example_HandlerUsageUnaryPing() {
+func ExampleExtract_unary() {
 	_ = func(ctx context.Context, ping *pb_testproto.PingRequest) (*pb_testproto.PingResponse, error) {
 		// Add fields the ctxtags of the request which will be added to all extracted loggers.
 		grpc_ctxtags.Extract(ctx).Set("custom_tags.string", "something").Set("custom_tags.int", 1337)