chore: Remove several instances of WithLogger (#15996)

* chore: Remove several instances of WithLogger

* chore: unexport Logger fields

* chore: unexport some more Logger fields

* chore: go fmt

chore: fix test

chore: s/logger/log

chore: fix test

chore: revert http.Handler.Handler constructor initialization

* refactor: integrate review feedback, fix all test nop loggers

* refactor: capitalize all log messages

* refactor: rename two logger to log

authorizer/task.go

@@ -35,15 +35,15 @@ var (
 
 type taskServiceValidator struct {
 	influxdb.TaskService
-	logger *zap.Logger
+	log *zap.Logger
 }
 
 // TaskService wraps ts and checks appropriate permissions before calling requested methods on ts.
 // Authorization failures are logged to the logger.
-func NewTaskService(logger *zap.Logger, ts influxdb.TaskService) influxdb.TaskService {
+func NewTaskService(log *zap.Logger, ts influxdb.TaskService) influxdb.TaskService {
 	return &taskServiceValidator{
 		TaskService: ts,
-		logger:      logger,
+		log:         log,
 	}
 }
 
@@ -79,7 +79,7 @@ func (ts *taskServiceValidator) FindTasks(ctx context.Context, filter influxdb.T
 	// We are getting a list of tasks that may be a superset of what the user is allowed to view.
 	auth, err := platcontext.GetAuthorizer(ctx)
 	if err != nil {
-		ts.logger.Info("Failed to retrieve authorizer from context", zap.String("method", "FindTasks"))
+		ts.log.Info("Failed to retrieve authorizer from context", zap.String("method", "FindTasks"))
 		return nil, 0, err
 	}
 
@@ -322,12 +322,12 @@ func (ts *taskServiceValidator) ForceRun(ctx context.Context, taskID influxdb.ID
 func (ts *taskServiceValidator) validatePermission(ctx context.Context, perm influxdb.Permission, loggerFields ...zap.Field) error {
 	auth, err := platcontext.GetAuthorizer(ctx)
 	if err != nil {
-		ts.logger.With(loggerFields...).Info("Failed to retrieve authorizer from context")
+		ts.log.With(loggerFields...).Info("Failed to retrieve authorizer from context")
 		return err
 	}
 
 	if !auth.Allowed(perm) {
-		ts.logger.With(loggerFields...).Info("Authorization failed",
+		ts.log.With(loggerFields...).Info("Authorization failed",
 			zap.String("user_id", auth.GetUserID().String()),
 			zap.String("auth_kind", auth.Kind()),
 			zap.String("auth_id", auth.Identifier().String()),

bolt/authorization_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func initAuthorizationService(f platformtesting.AuthorizationFields, t *testing.T) (platform.AuthorizationService, string, func()) {
-	c, closeFn, err := NewTestClient()
+	c, closeFn, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new bolt client: %v", err)
 	}

bolt/bbolt.go

@@ -23,9 +23,9 @@ func getOp(op string) string {
 
 // Client is a client for the boltDB data store.
 type Client struct {
-	Path   string
-	db     *bolt.DB
-	Logger *zap.Logger
+	Path string
+	db   *bolt.DB
+	log  *zap.Logger
 
 	IDGenerator    platform.IDGenerator
 	TokenGenerator platform.TokenGenerator
@@ -33,9 +33,9 @@ type Client struct {
 }
 
 // NewClient returns an instance of a Client.
-func NewClient() *Client {
+func NewClient(log *zap.Logger) *Client {
 	return &Client{
-		Logger:         zap.NewNop(),
+		log:            log,
 		IDGenerator:    snowflake.NewIDGenerator(),
 		TokenGenerator: rand.NewTokenGenerator(64),
 		TimeGenerator:  platform.RealTimeGenerator{},
@@ -47,12 +47,6 @@ func (c *Client) DB() *bolt.DB {
 	return c.db
 }
 
-// WithLogger sets the logger an a client. It should not be called after
-// the client has been open.
-func (c *Client) WithLogger(l *zap.Logger) {
-	c.Logger = l
-}
-
 // Open / create boltDB file.
 func (c *Client) Open(ctx context.Context) error {
 	// Ensure the required directory structure exists.
@@ -75,7 +69,7 @@ func (c *Client) Open(ctx context.Context) error {
 		return err
 	}
 
-	c.Logger.Info("Resources opened", zap.String("path", c.Path))
+	c.log.Info("Resources opened", zap.String("path", c.Path))
 	return nil
 }
 

bolt/bbolt_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/influxdata/influxdb/bolt"
+	"go.uber.org/zap/zaptest"
 	"golang.org/x/crypto/bcrypt"
 )
 
@@ -16,8 +17,8 @@ func init() {
 	bolt.HashCost = bcrypt.MinCost
 }
 
-func NewTestClient() (*bolt.Client, func(), error) {
-	c, closeFn, err := newTestClient()
+func NewTestClient(t *testing.T) (*bolt.Client, func(), error) {
+	c, closeFn, err := newTestClient(t)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -28,8 +29,8 @@ func NewTestClient() (*bolt.Client, func(), error) {
 	return c, closeFn, nil
 }
 
-func newTestClient() (*bolt.Client, func(), error) {
-	c := bolt.NewClient()
+func newTestClient(t *testing.T) (*bolt.Client, func(), error) {
+	c := bolt.NewClient(zaptest.NewLogger(t))
 
 	f, err := ioutil.TempFile("", "influxdata-platform-bolt-")
 	if err != nil {
@@ -61,7 +62,7 @@ func TestClientOpen(t *testing.T) {
 
 	boltFile := filepath.Join(tempDir, "test", "bolt.db")
 
-	c := bolt.NewClient()
+	c := bolt.NewClient(zaptest.NewLogger(t))
 	c.Path = boltFile
 
 	if err := c.Open(context.Background()); err != nil {
@@ -73,7 +74,7 @@ func TestClientOpen(t *testing.T) {
 	}
 }
 
-func NewTestKVStore() (*bolt.KVStore, func(), error) {
+func NewTestKVStore(t *testing.T) (*bolt.KVStore, func(), error) {
 	f, err := ioutil.TempFile("", "influxdata-platform-bolt-")
 	if err != nil {
 		return nil, nil, errors.New("unable to open temporary boltdb file")
@@ -81,7 +82,7 @@ func NewTestKVStore() (*bolt.KVStore, func(), error) {
 	f.Close()
 
 	path := f.Name()
-	s := bolt.NewKVStore(path)
+	s := bolt.NewKVStore(zaptest.NewLogger(t), path)
 	if err := s.Open(context.TODO()); err != nil {
 		return nil, nil, err
 	}

bolt/bucket_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func initBucketService(f platformtesting.BucketFields, t *testing.T) (platform.BucketService, string, func()) {
-	c, closeFn, err := NewTestClient()
+	c, closeFn, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new bolt client: %v", err)
 	}

bolt/dashboard_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func initDashboardService(f platformtesting.DashboardFields, t *testing.T) (platform.DashboardService, string, func()) {
-	c, closeFn, err := NewTestClient()
+	c, closeFn, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new bolt client: %v", err)
 	}

bolt/id.go

@@ -52,7 +52,7 @@ func (c *Client) ID() platform.ID {
 	})
 
 	if err != nil {
-		c.Logger.Error("unable to load id", zap.Error(err))
+		c.log.Error("Unable to load id", zap.Error(err))
 	}
 
 	return id

bolt/id_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 func TestID(t *testing.T) {
-	c, closeFn, err := newTestClient()
+	c, closeFn, err := newTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new bolt client: %v", err)
 	}

bolt/keyvalue_log_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func initKeyValueLog(f platformtesting.KeyValueLogFields, t *testing.T) (platform.KeyValueLog, func()) {
-	c, closeFn, err := NewTestClient()
+	c, closeFn, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new bolt client: %v", err)
 	}

bolt/kv.go

@@ -15,17 +15,17 @@ import (
 
 // KVStore is a kv.Store backed by boltdb.
 type KVStore struct {
-	path   string
-	db     *bolt.DB
-	logger *zap.Logger
+	path string
+	db   *bolt.DB
+	log  *zap.Logger
 }
 
 // NewKVStore returns an instance of KVStore with the file at
 // the provided path.
-func NewKVStore(path string) *KVStore {
+func NewKVStore(log *zap.Logger, path string) *KVStore {
 	return &KVStore{
-		path:   path,
-		logger: zap.NewNop(),
+		path: path,
+		log:  log,
 	}
 }
 
@@ -50,7 +50,7 @@ func (s *KVStore) Open(ctx context.Context) error {
 	}
 	s.db = db
 
-	s.logger.Info("Resources opened", zap.String("path", s.path))
+	s.log.Info("Resources opened", zap.String("path", s.path))
 	return nil
 }
 
@@ -89,11 +89,6 @@ func (s *KVStore) cleanBucket(tx *bolt.Tx, b *bolt.Bucket) {
 	}
 }
 
-// WithLogger sets the logger on the store.
-func (s *KVStore) WithLogger(l *zap.Logger) {
-	s.logger = l
-}
-
 // WithDB sets the boltdb on the store.
 func (s *KVStore) WithDB(db *bolt.DB) {
 	s.db = db

bolt/kv_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func initKVStore(f platformtesting.KVStoreFields, t *testing.T) (kv.Store, func()) {
-	s, closeFn, err := NewTestKVStore()
+	s, closeFn, err := NewTestKVStore(t)
 	if err != nil {
 		t.Fatalf("failed to create new kv store: %v", err)
 	}

bolt/lookup_service_test.go

@@ -232,7 +232,7 @@ func TestClient_Name(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c, done, err := NewTestClient()
+			c, done, err := NewTestClient(t)
 			if err != nil {
 				t.Fatalf("unable to create bolt test client: %v", err)
 			}

bolt/metrics_test.go

@@ -7,16 +7,17 @@ import (
 	platform "github.com/influxdata/influxdb"
 	"github.com/influxdata/influxdb/kit/prom"
 	"github.com/influxdata/influxdb/kit/prom/promtest"
+	"go.uber.org/zap/zaptest"
 )
 
 func TestInitialMetrics(t *testing.T) {
-	client, teardown, err := NewTestClient()
+	client, teardown, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("unable to setup bolt client: %v", err)
 	}
 	defer teardown()
 
-	reg := prom.NewRegistry()
+	reg := prom.NewRegistry(zaptest.NewLogger(t))
 	reg.MustRegister(client)
 
 	mfs, err := reg.Gather()
@@ -41,13 +42,13 @@ func TestInitialMetrics(t *testing.T) {
 }
 
 func TestMetrics_Onboarding(t *testing.T) {
-	client, teardown, err := NewTestClient()
+	client, teardown, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("unable to setup bolt client: %v", err)
 	}
 	defer teardown()
 
-	reg := prom.NewRegistry()
+	reg := prom.NewRegistry(zaptest.NewLogger(t))
 	reg.MustRegister(client)
 
 	ctx := context.Background()

bolt/onboarding_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func initOnboardingService(f platformtesting.OnboardingFields, t *testing.T) (platform.OnboardingService, func()) {
-	c, closeFn, err := NewTestClient()
+	c, closeFn, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new bolt client: %v", err)
 	}

bolt/organization_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func initOrganizationService(f platformtesting.OrganizationFields, t *testing.T) (platform.OrganizationService, string, func()) {
-	c, closeFn, err := NewTestClient()
+	c, closeFn, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new bolt client: %v", err)
 	}

bolt/passwords_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func initPasswordsService(f platformtesting.PasswordFields, t *testing.T) (platform.PasswordsService, func()) {
-	c, closeFn, err := NewTestClient()
+	c, closeFn, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new bolt client: %v", err)
 	}

bolt/scraper_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func initScraperTargetStoreService(f platformtesting.TargetFields, t *testing.T) (platform.ScraperTargetStoreService, string, func()) {
-	c, closeFn, err := NewTestClient()
+	c, closeFn, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new bolt client: %v", err)
 	}

bolt/secret_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func initSecretService(f platformtesting.SecretServiceFields, t *testing.T) (platform.SecretService, func()) {
-	c, closeFn, err := NewTestClient()
+	c, closeFn, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new bolt client: %v", err)
 	}

bolt/session_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func initSessionService(f platformtesting.SessionFields, t *testing.T) (platform.SessionService, string, func()) {
-	c, closeFn, err := NewTestClient()
+	c, closeFn, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new bolt client: %v", err)
 	}

bolt/source_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func initSourceService(f platformtesting.SourceFields, t *testing.T) (platform.SourceService, string, func()) {
-	c, closeFn, err := NewTestClient()
+	c, closeFn, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new bolt client: %v", err)
 	}

bolt/telegraf_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func initTelegrafConfigStore(f platformtesting.TelegrafConfigFields, t *testing.T) (platform.TelegrafConfigStore, func()) {
-	c, closeFn, err := NewTestClient()
+	c, closeFn, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new bolt client: %v", err)
 	}

bolt/user_resource_mapping_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func initUserResourceMappingService(f platformtesting.UserResourceFields, t *testing.T) (platform.UserResourceMappingService, func()) {
-	c, closeFn, err := NewTestClient()
+	c, closeFn, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new bolt client: %v", err)
 	}

bolt/user_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 func initUserService(f influxdbtesting.UserFields, t *testing.T) (influxdb.UserService, string, func()) {
-	svc, closeFn, err := NewTestClient()
+	svc, closeFn, err := NewTestClient(t)
 	if err != nil {
 		t.Fatalf("failed to create new kv store: %v", err)
 	}

chronograf/oauth2/mux.go

@@ -119,43 +119,43 @@ func (j *AuthMux) Callback() http.Handler {
 		}
 
 		if token.Extra("id_token") != nil && !j.UseIDToken {
-			log.Info("found an extra id_token, but option --useidtoken is not set")
+			log.Info("Found an extra id_token, but option --useidtoken is not set")
 		}
 
 		// if we received an extra id_token, inspect it
 		var id string
 		var group string
 		if j.UseIDToken && token.Extra("id_token") != nil && token.Extra("id_token") != "" {
-			log.Debug("found an extra id_token")
+			log.Debug("Found an extra id_token")
 			if provider, ok := j.Provider.(ExtendedProvider); ok {
-				log.Debug("provider implements PrincipalIDFromClaims()")
+				log.Debug("Provider implements PrincipalIDFromClaims()")
 				tokenString, ok := token.Extra("id_token").(string)
 				if !ok {
-					log.Error("cannot cast id_token as string")
+					log.Error("Cannot cast id_token as string")
 					http.Redirect(w, r, j.FailureURL, http.StatusTemporaryRedirect)
 					return
 				}
 				claims, err := j.Tokens.GetClaims(tokenString)
 				if err != nil {
-					log.Error("parsing extra id_token failed:", err)
+					log.Error("Parsing extra id_token failed:", err)
 					http.Redirect(w, r, j.FailureURL, http.StatusTemporaryRedirect)
 					return
 				}
-				log.Debug("found claims: ", claims)
+				log.Debug("Found claims: ", claims)
 				id, err = provider.PrincipalIDFromClaims(claims)
 				if err != nil {
-					log.Error("requested claim not found in id_token:", err)
+					log.Error("Requested claim not found in id_token:", err)
 					http.Redirect(w, r, j.FailureURL, http.StatusTemporaryRedirect)
 					return
 				}
 				group, err = provider.GroupFromClaims(claims)
 				if err != nil {
-					log.Error("requested claim not found in id_token:", err)
+					log.Error("Requested claim not found in id_token:", err)
 					http.Redirect(w, r, j.FailureURL, http.StatusTemporaryRedirect)
 					return
 				}
 			} else {
-				log.Debug("provider does not implement PrincipalIDFromClaims()")
+				log.Debug("Provider does not implement PrincipalIDFromClaims()")
 			}
 		} else {
 			// otherwise perform an additional lookup

cmd/influx/main.go

@@ -16,6 +16,7 @@ import (
 	"github.com/influxdata/influxdb/kv"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	"go.uber.org/zap"
 )
 
 const maxTCPConnections = 128
@@ -215,10 +216,10 @@ func newLocalKVService() (*kv.Service, error) {
 		return nil, err
 	}
 
-	store := bolt.NewKVStore(boltFile)
+	store := bolt.NewKVStore(zap.NewNop(), boltFile)
 	if err := store.Open(context.Background()); err != nil {
 		return nil, err
 	}
 
-	return kv.NewService(store), nil
+	return kv.NewService(zap.NewNop(), store), nil
 }

cmd/influx/pkg.go

@@ -24,6 +24,7 @@ import (
 	"github.com/olekukonko/tablewriter"
 	"github.com/spf13/cobra"
 	input "github.com/tcnksm/go-input"
+	"go.uber.org/zap"
 	"gopkg.in/yaml.v3"
 )
 
@@ -481,6 +482,7 @@ func createPkgBuf(pkg *pkger.Pkg, outPath string) (*bytes.Buffer, error) {
 
 func newPkgerSVC(cliReqOpts httpClientOpts) (pkger.SVC, error) {
 	return pkger.NewService(
+		zap.NewNop(),
 		pkger.WithBucketSVC(&ihttp.BucketService{
 			Addr:               cliReqOpts.addr,
 			Token:              cliReqOpts.token,

cmd/influx/pkg_test.go

@@ -17,6 +17,7 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/zap/zaptest"
 )
 
 func Test_Pkg(t *testing.T) {
@@ -87,7 +88,7 @@ func Test_Pkg(t *testing.T) {
 		}
 
 		cmdFn := func() *cobra.Command {
-			builder := newCmdPkgBuilder(fakeSVCFn(pkger.NewService()), in(new(bytes.Buffer)))
+			builder := newCmdPkgBuilder(fakeSVCFn(pkger.NewService(zaptest.NewLogger(t))), in(new(bytes.Buffer)))
 			cmd := builder.cmdPkgNew()
 			return cmd
 		}

cmd/influx_inspect/buildtsi/buildtsi.go

@@ -24,7 +24,7 @@ func IndexShard(sfile *tsdb.SeriesFile, indexPath, dataDir, walDir string, maxLo
 	// Check if shard already has a TSI index.
 	log.Info("Checking index path", zap.String("path", indexPath))
 	if _, err := os.Stat(indexPath); !os.IsNotExist(err) {
-		log.Info("tsi1 index already exists, skipping", zap.String("path", indexPath))
+		log.Info("TSI1 index already exists, skipping", zap.String("path", indexPath))
 		return nil
 	}
 
@@ -129,7 +129,7 @@ func IndexShard(sfile *tsdb.SeriesFile, indexPath, dataDir, walDir string, maxLo
 	}
 
 	// Attempt to compact the index & wait for all compactions to complete.
-	log.Info("compacting index")
+	log.Info("Compacting index")
 	tsiIndex.Compact()
 	tsiIndex.Wait()
 

cmd/influxd/generate/command.go

@@ -12,6 +12,7 @@ import (
 	"github.com/influxdata/influxdb/kv"
 	"github.com/influxdata/influxdb/pkg/data/gen"
 	"github.com/spf13/cobra"
+	"go.uber.org/zap"
 )
 
 var Command = &cobra.Command{
@@ -84,12 +85,12 @@ func assignOrgBucket(spec *gen.Spec) error {
 		return err
 	}
 
-	store := bolt.NewKVStore(boltFile)
+	store := bolt.NewKVStore(zap.NewNop(), boltFile)
 	if err = store.Open(context.Background()); err != nil {
 		return err
 	}
 
-	s := kv.NewService(store)
+	s := kv.NewService(zap.NewNop(), store)
 	if err = s.Initialize(context.Background()); err != nil {
 		return err
 	}

cmd/influxd/launcher/engine.go

@@ -52,7 +52,7 @@ type TemporaryEngine struct {
 
 	engine *storage.Engine
 
-	logger *zap.Logger
+	log *zap.Logger
 }
 
 // NewTemporaryEngine creates a new engine that places the storage engine files into
@@ -61,7 +61,7 @@ func NewTemporaryEngine(c storage.Config, options ...storage.Option) *TemporaryE
 	return &TemporaryEngine{
 		config:  c,
 		options: options,
-		logger:  zap.NewNop(),
+		log:     zap.NewNop(),
 	}
 }
 
@@ -81,7 +81,7 @@ func (t *TemporaryEngine) Open(ctx context.Context) error {
 
 	t.path = path
 	t.engine = storage.NewEngine(path, t.config, t.options...)
-	t.engine.WithLogger(t.logger)
+	t.engine.WithLogger(t.log)
 
 	if err := t.engine.Open(ctx); err != nil {
 		_ = os.RemoveAll(path)
@@ -126,7 +126,7 @@ func (t *TemporaryEngine) DeleteBucket(ctx context.Context, orgID, bucketID infl
 
 // WithLogger sets the logger on the engine. It must be called before Open.
 func (t *TemporaryEngine) WithLogger(log *zap.Logger) {
-	t.logger = log.With(zap.String("service", "temporary_engine"))
+	t.log = log.With(zap.String("service", "temporary_engine"))
 }
 
 // PrometheusCollectors returns all the prometheus collectors associated with
@@ -158,10 +158,10 @@ func (t *TemporaryEngine) TagValues(ctx context.Context, orgID, bucketID influxd
 // Flush will remove the time-series files and re-open the engine.
 func (t *TemporaryEngine) Flush(ctx context.Context) {
 	if err := t.Close(); err != nil {
-		t.logger.Fatal("unable to close engine", zap.Error(err))
+		t.log.Fatal("unable to close engine", zap.Error(err))
 	}
 
 	if err := t.Open(ctx); err != nil {
-		t.logger.Fatal("unable to open engine", zap.Error(err))
+		t.log.Fatal("unable to open engine", zap.Error(err))
 	}
 }

cmd/influxd/launcher/launcher.go

@@ -92,9 +92,8 @@ func NewCommand() *cobra.Command {
 
 			var wg sync.WaitGroup
 			if !l.ReportingDisabled() {
-				reporter := telemetry.NewReporter(l.Registry())
+				reporter := telemetry.NewReporter(l.Log(), l.Registry())
 				reporter.Interval = 8 * time.Hour
-				reporter.Logger = l.Logger()
 				wg.Add(1)
 				go func() {
 					defer wg.Done()
@@ -314,7 +313,7 @@ type Launcher struct {
 	taskControlService taskbackend.TaskControlService
 
 	jaegerTracerCloser io.Closer
-	logger             *zap.Logger
+	log                *zap.Logger
 	reg                *prom.Registry
 
 	Stdin      io.Reader
@@ -348,9 +347,9 @@ func (m *Launcher) Registry() *prom.Registry {
 	return m.reg
 }
 
-// Logger returns the launchers logger.
-func (m *Launcher) Logger() *zap.Logger {
-	return m.logger
+// Log returns the launchers logger.
+func (m *Launcher) Log() *zap.Logger {
+	return m.log
 }
 
 // URL returns the URL to connect to the HTTP server.
@@ -373,40 +372,40 @@ func (m *Launcher) Engine() Engine {
 func (m *Launcher) Shutdown(ctx context.Context) {
 	m.httpServer.Shutdown(ctx)
 
-	m.logger.Info("Stopping", zap.String("service", "task"))
+	m.log.Info("Stopping", zap.String("service", "task"))
 	if m.EnableNewScheduler {
 		m.treeScheduler.Stop()
 	} else {
 		m.scheduler.Stop()
 	}
 
-	m.logger.Info("Stopping", zap.String("service", "nats"))
+	m.log.Info("Stopping", zap.String("service", "nats"))
 	m.natsServer.Close()
 
-	m.logger.Info("Stopping", zap.String("service", "bolt"))
+	m.log.Info("Stopping", zap.String("service", "bolt"))
 	if err := m.boltClient.Close(); err != nil {
-		m.logger.Info("failed closing bolt", zap.Error(err))
+		m.log.Info("Failed closing bolt", zap.Error(err))
 	}
 
-	m.logger.Info("Stopping", zap.String("service", "query"))
+	m.log.Info("Stopping", zap.String("service", "query"))
 	if err := m.queryController.Shutdown(ctx); err != nil && err != context.Canceled {
-		m.logger.Info("Failed closing query service", zap.Error(err))
+		m.log.Info("Failed closing query service", zap.Error(err))
 	}
 
-	m.logger.Info("Stopping", zap.String("service", "storage-engine"))
+	m.log.Info("Stopping", zap.String("service", "storage-engine"))
 	if err := m.engine.Close(); err != nil {
-		m.logger.Error("failed to close engine", zap.Error(err))
+		m.log.Error("Failed to close engine", zap.Error(err))
 	}
 
 	m.wg.Wait()
 
 	if m.jaegerTracerCloser != nil {
 		if err := m.jaegerTracerCloser.Close(); err != nil {
-			m.logger.Warn("failed to closer Jaeger tracer", zap.Error(err))
+			m.log.Warn("Failed to closer Jaeger tracer", zap.Error(err))
 		}
 	}
 
-	m.logger.Sync()
+	m.log.Sync()
 }
 
 // Cancel executes the context cancel on the program. Used for testing.
@@ -445,13 +444,13 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 		Format: "auto",
 		Level:  lvl,
 	}
-	m.logger, err = logconf.New(m.Stdout)
+	m.log, err = logconf.New(m.Stdout)
 	if err != nil {
 		return err
 	}
 
 	info := platform.GetBuildInfo()
-	m.logger.Info("Welcome to InfluxDB",
+	m.log.Info("Welcome to InfluxDB",
 		zap.String("version", info.Version),
 		zap.String("commit", info.Commit),
 		zap.String("build_date", info.Date),
@@ -459,34 +458,31 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 
 	switch m.tracingType {
 	case LogTracing:
-		m.logger.Info("tracing via zap logging")
-		tracer := new(pzap.Tracer)
-		tracer.Logger = m.logger
-		tracer.IDGenerator = snowflake.NewIDGenerator()
+		m.log.Info("Tracing via zap logging")
+		tracer := pzap.NewTracer(m.log, snowflake.NewIDGenerator())
 		opentracing.SetGlobalTracer(tracer)
 
 	case JaegerTracing:
-		m.logger.Info("tracing via Jaeger")
+		m.log.Info("Tracing via Jaeger")
 		cfg, err := jaegerconfig.FromEnv()
 		if err != nil {
-			m.logger.Error("failed to get Jaeger client config from environment variables", zap.Error(err))
+			m.log.Error("Failed to get Jaeger client config from environment variables", zap.Error(err))
 			break
 		}
 		tracer, closer, err := cfg.NewTracer()
 		if err != nil {
-			m.logger.Error("failed to instantiate Jaeger tracer", zap.Error(err))
+			m.log.Error("Failed to instantiate Jaeger tracer", zap.Error(err))
 			break
 		}
 		opentracing.SetGlobalTracer(tracer)
 		m.jaegerTracerCloser = closer
 	}
 
-	m.boltClient = bolt.NewClient()
+	m.boltClient = bolt.NewClient(m.log.With(zap.String("service", "bolt")))
 	m.boltClient.Path = m.boltPath
-	m.boltClient.WithLogger(m.logger.With(zap.String("service", "bolt")))
 
 	if err := m.boltClient.Open(ctx); err != nil {
-		m.logger.Error("failed opening bolt", zap.Error(err))
+		m.log.Error("Failed opening bolt", zap.Error(err))
 		return err
 	}
 
@@ -497,36 +493,34 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 	flushers := flushers{}
 	switch m.storeType {
 	case BoltStore:
-		store := bolt.NewKVStore(m.boltPath)
+		store := bolt.NewKVStore(m.log.With(zap.String("service", "kvstore-bolt")), m.boltPath)
 		store.WithDB(m.boltClient.DB())
-		m.kvService = kv.NewService(store, serviceConfig)
+		m.kvService = kv.NewService(m.log.With(zap.String("store", "kv")), store, serviceConfig)
 		if m.testing {
 			flushers = append(flushers, store)
 		}
 	case MemoryStore:
 		store := inmem.NewKVStore()
-		m.kvService = kv.NewService(store, serviceConfig)
+		m.kvService = kv.NewService(m.log.With(zap.String("store", "kv")), store, serviceConfig)
 		if m.testing {
 			flushers = append(flushers, store)
 		}
 	default:
 		err := fmt.Errorf("unknown store type %s; expected bolt or memory", m.storeType)
-		m.logger.Error("failed opening bolt", zap.Error(err))
+		m.log.Error("Failed opening bolt", zap.Error(err))
 		return err
 	}
 
-	m.kvService.Logger = m.logger.With(zap.String("store", "kv"))
 	if err := m.kvService.Initialize(ctx); err != nil {
-		m.logger.Error("failed to initialize kv service", zap.Error(err))
+		m.log.Error("Failed to initialize kv service", zap.Error(err))
 		return err
 	}
 
-	m.reg = prom.NewRegistry()
+	m.reg = prom.NewRegistry(m.log.With(zap.String("service", "prom_registry")))
 	m.reg.MustRegister(
 		prometheus.NewGoCollector(),
 		infprom.NewInfluxCollector(m.boltClient, info),
 	)
-	m.reg.WithLogger(m.logger)
 	m.reg.MustRegister(m.boltClient)
 
 	var (
@@ -561,19 +555,19 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 		// https://www.vaultproject.io/docs/commands/index.html#environment-variables
 		svc, err := vault.NewSecretService(vault.WithConfig(vaultConfig))
 		if err != nil {
-			m.logger.Error("failed initializing vault secret service", zap.Error(err))
+			m.log.Error("Failed initializing vault secret service", zap.Error(err))
 			return err
 		}
 		secretSvc = svc
 	default:
 		err := fmt.Errorf("unknown secret service %q, expected \"bolt\" or \"vault\"", m.secretStore)
-		m.logger.Error("failed setting secret service", zap.Error(err))
+		m.log.Error("Failed setting secret service", zap.Error(err))
 		return err
 	}
 
 	chronografSvc, err := server.NewServiceV2(ctx, m.boltClient.DB())
 	if err != nil {
-		m.logger.Error("failed creating chronograf service", zap.Error(err))
+		m.log.Error("Failed creating chronograf service", zap.Error(err))
 		return err
 	}
 
@@ -585,9 +579,9 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 	} else {
 		m.engine = storage.NewEngine(m.enginePath, m.StorageConfig, storage.WithRetentionEnforcer(bucketSvc))
 	}
-	m.engine.WithLogger(m.logger)
+	m.engine.WithLogger(m.log)
 	if err := m.engine.Open(ctx); err != nil {
-		m.logger.Error("failed to open engine", zap.Error(err))
+		m.log.Error("Failed to open engine", zap.Error(err))
 		return err
 	}
 	// The Engine's metrics must be registered after it opens.
@@ -615,7 +609,7 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 		nil,
 	)
 	if err != nil {
-		m.logger.Error("Failed to get query controller dependencies", zap.Error(err))
+		m.log.Error("Failed to get query controller dependencies", zap.Error(err))
 		return err
 	}
 
@@ -623,11 +617,11 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 		ConcurrencyQuota:         concurrencyQuota,
 		MemoryBytesQuotaPerQuery: int64(memoryBytesQuotaPerQuery),
 		QueueSize:                QueueSize,
-		Logger:                   m.logger.With(zap.String("service", "storage-reads")),
+		Logger:                   m.log.With(zap.String("service", "storage-reads")),
 		ExecutorDependencies:     []flux.Dependency{deps},
 	})
 	if err != nil {
-		m.logger.Error("Failed to create query controller", zap.Error(err))
+		m.log.Error("Failed to create query controller", zap.Error(err))
 		return err
 	}
 
@@ -638,17 +632,17 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 	{
 		// create the task stack:
 		// validation(coordinator(analyticalstore(kv.Service)))
-		combinedTaskService := taskbackend.NewAnalyticalStorage(m.logger.With(zap.String("service", "task-analytical-store")), m.kvService, m.kvService, m.kvService, pointsWriter, query.QueryServiceBridge{AsyncQueryService: m.queryController})
+		combinedTaskService := taskbackend.NewAnalyticalStorage(m.log.With(zap.String("service", "task-analytical-store")), m.kvService, m.kvService, m.kvService, pointsWriter, query.QueryServiceBridge{AsyncQueryService: m.queryController})
 		if m.EnableNewScheduler {
 			executor, executorMetrics := taskexecutor.NewExecutor(
-				m.logger.With(zap.String("service", "task-executor")),
+				m.log.With(zap.String("service", "task-executor")),
 				query.QueryServiceBridge{AsyncQueryService: m.queryController},
 				authSvc,
 				combinedTaskService,
 				combinedTaskService,
 			)
 			m.reg.MustRegister(executorMetrics.PrometheusCollectors()...)
-			schLogger := m.logger.With(zap.String("service", "task-scheduler"))
+			schLogger := m.log.With(zap.String("service", "task-scheduler"))
 
 			sch, sm, err := scheduler.NewScheduler(
 				executor,
@@ -662,11 +656,11 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 				}),
 			)
 			if err != nil {
-				m.logger.Fatal("could not start task scheduler", zap.Error(err))
+				m.log.Fatal("could not start task scheduler", zap.Error(err))
 			}
 			m.treeScheduler = sch
 			m.reg.MustRegister(sm.PrometheusCollectors()...)
-			coordLogger := m.logger.With(zap.String("service", "task-coordinator"))
+			coordLogger := m.log.With(zap.String("service", "task-coordinator"))
 			taskCoord := coordinator.NewCoordinator(
 				coordLogger,
 				sch,
@@ -684,28 +678,28 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 					return err
 				},
 				coordLogger); err != nil {
-				m.logger.Error("failed to resume existing tasks", zap.Error(err))
+				m.log.Error("Failed to resume existing tasks", zap.Error(err))
 			}
 		} else {
 
 			// define the executor and build analytical storage middleware
-			executor := taskexecutor.NewAsyncQueryServiceExecutor(m.logger.With(zap.String("service", "task-executor")), m.queryController, authSvc, combinedTaskService)
+			executor := taskexecutor.NewAsyncQueryServiceExecutor(m.log.With(zap.String("service", "task-executor")), m.queryController, authSvc, combinedTaskService)
 
 			// create the scheduler
-			m.scheduler = taskbackend.NewScheduler(combinedTaskService, executor, time.Now().UTC().Unix(), taskbackend.WithTicker(ctx, 100*time.Millisecond), taskbackend.WithLogger(m.logger))
+			m.scheduler = taskbackend.NewScheduler(m.log.With(zap.String("svc", "taskd/scheduler")), combinedTaskService, executor, time.Now().UTC().Unix(), taskbackend.WithTicker(ctx, 100*time.Millisecond))
 			m.scheduler.Start(ctx)
 			m.reg.MustRegister(m.scheduler.PrometheusCollectors()...)
 
-			logger := m.logger.With(zap.String("service", "task-coordinator"))
+			logger := m.log.With(zap.String("service", "task-coordinator"))
 			coordinator := coordinator.New(logger, m.scheduler)
 
 			// resume existing task claims from task service
-			if err := taskbackend.NotifyCoordinatorOfExisting(ctx, combinedTaskService, coordinator, logger); err != nil {
-				logger.Error("failed to resume existing tasks", zap.Error(err))
+			if err := taskbackend.NotifyCoordinatorOfExisting(ctx, logger, combinedTaskService, coordinator); err != nil {
+				logger.Error("Failed to resume existing tasks", zap.Error(err))
 			}
 
 			taskSvc = middleware.New(combinedTaskService, coordinator)
-			taskSvc = authorizer.NewTaskService(m.logger.With(zap.String("service", "task-authz-validator")), taskSvc)
+			taskSvc = authorizer.NewTaskService(m.log.With(zap.String("service", "task-authz-validator")), taskSvc)
 			m.taskControlService = combinedTaskService
 		}
 
@@ -713,13 +707,13 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 
 	var checkSvc platform.CheckService
 	{
-		coordinator := coordinator.New(m.logger, m.scheduler)
+		coordinator := coordinator.New(m.log, m.scheduler)
 		checkSvc = middleware.NewCheckService(m.kvService, m.kvService, coordinator)
 	}
 
 	var notificationRuleSvc platform.NotificationRuleStore
 	{
-		coordinator := coordinator.New(m.logger, m.scheduler)
+		coordinator := coordinator.New(m.log, m.scheduler)
 		notificationRuleSvc = middleware.NewNotificationRuleStore(m.kvService, m.kvService, coordinator)
 	}
 
@@ -755,44 +749,39 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 	m.natsPort = int(nextPort)
 
 	if err := m.natsServer.Open(); err != nil {
-		m.logger.Error("failed to start nats streaming server", zap.Error(err))
+		m.log.Error("Failed to start nats streaming server", zap.Error(err))
 		return err
 	}
 
-	publisher := nats.NewAsyncPublisher(fmt.Sprintf("nats-publisher-%d", m.natsPort), m.NatsURL())
+	publisher := nats.NewAsyncPublisher(m.log, fmt.Sprintf("nats-publisher-%d", m.natsPort), m.NatsURL())
 	if err := publisher.Open(); err != nil {
-		m.logger.Error("failed to connect to streaming server", zap.Error(err))
+		m.log.Error("Failed to connect to streaming server", zap.Error(err))
 		return err
 	}
 
 	// TODO(jm): this is an example of using a subscriber to consume from the channel. It should be removed.
 	subscriber := nats.NewQueueSubscriber(fmt.Sprintf("nats-subscriber-%d", m.natsPort), m.NatsURL())
 	if err := subscriber.Open(); err != nil {
-		m.logger.Error("failed to connect to streaming server", zap.Error(err))
+		m.log.Error("Failed to connect to streaming server", zap.Error(err))
 		return err
 	}
 
-	subscriber.Subscribe(gather.MetricsSubject, "metrics", &gather.RecorderHandler{
-		Logger: m.logger,
-		Recorder: gather.PointWriter{
-			Writer: pointsWriter,
-		},
-	})
-	scraperScheduler, err := gather.NewScheduler(10, m.logger, scraperTargetSvc, publisher, subscriber, 10*time.Second, 30*time.Second)
+	subscriber.Subscribe(gather.MetricsSubject, "metrics", gather.NewRecorderHandler(m.log, gather.PointWriter{Writer: pointsWriter}))
+	scraperScheduler, err := gather.NewScheduler(m.log, 10, scraperTargetSvc, publisher, subscriber, 10*time.Second, 30*time.Second)
 	if err != nil {
-		m.logger.Error("failed to create scraper subscriber", zap.Error(err))
+		m.log.Error("Failed to create scraper subscriber", zap.Error(err))
 		return err
 	}
 
 	m.wg.Add(1)
-	go func(logger *zap.Logger) {
+	go func(log *zap.Logger) {
 		defer m.wg.Done()
-		logger = logger.With(zap.String("service", "scraper"))
+		log = log.With(zap.String("service", "scraper"))
 		if err := scraperScheduler.Run(ctx); err != nil {
-			logger.Error("failed scraper service", zap.Error(err))
+			log.Error("Failed scraper service", zap.Error(err))
 		}
-		logger.Info("Stopping")
-	}(m.logger)
+		log.Info("Stopping")
+	}(m.log)
 
 	m.httpServer = &nethttp.Server{
 		Addr: m.httpBindAddress,
@@ -801,7 +790,7 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 	m.apibackend = &http.APIBackend{
 		AssetsPath:           m.assetsPath,
 		HTTPErrorHandler:     http.ErrorHandler(0),
-		Logger:               m.logger,
+		Logger:               m.log,
 		SessionRenewDisabled: m.sessionRenewDisabled,
 		NewBucketService:     source.NewBucketService,
 		NewQueryService:      source.NewQueryService,
@@ -847,7 +836,7 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 	{
 		b := m.apibackend
 		pkgSVC = pkger.NewService(
-			pkger.WithLogger(m.logger.With(zap.String("service", "pkger"))),
+			m.log.With(zap.String("service", "pkger")),
 			pkger.WithBucketSVC(authorizer.NewBucketService(b.BucketService)),
 			pkger.WithDashboardSVC(authorizer.NewDashboardService(b.DashboardService)),
 			pkger.WithLabelSVC(authorizer.NewLabelService(b.LabelService)),
@@ -861,21 +850,20 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 	}
 
 	// HTTP server
-	platformHandler := http.NewPlatformHandler(m.apibackend, http.WithResourceHandler(pkgHTTPServer))
-	m.reg.MustRegister(platformHandler.PrometheusCollectors()...)
-
-	h := http.NewHandlerFromRegistry("platform", m.reg)
-	h.Handler = platformHandler
-	httpLogger := m.logger.With(zap.String("service", "http"))
+	var platformHandler nethttp.Handler = http.NewPlatformHandler(m.apibackend, http.WithResourceHandler(pkgHTTPServer))
+	m.reg.MustRegister(platformHandler.(*http.PlatformHandler).PrometheusCollectors()...)
+	httpLogger := m.log.With(zap.String("service", "http"))
 	if logconf.Level == zap.DebugLevel {
-		h.Handler = http.LoggingMW(httpLogger)(h.Handler)
+		platformHandler = http.LoggingMW(httpLogger)(platformHandler)
 	}
-	h.Logger = httpLogger
 
-	m.httpServer.Handler = h
+	handler := http.NewHandlerFromRegistry(httpLogger, "platform", m.reg)
+	handler.Handler = platformHandler
+
+	m.httpServer.Handler = handler
 	// If we are in testing mode we allow all data to be flushed and removed.
 	if m.testing {
-		m.httpServer.Handler = http.DebugFlush(ctx, h, flushers)
+		m.httpServer.Handler = http.DebugFlush(ctx, handler, flushers)
 	}
 
 	ln, err := net.Listen("tcp", m.httpBindAddress)
@@ -907,20 +895,20 @@ func (m *Launcher) run(ctx context.Context) (err error) {
 	}
 
 	m.wg.Add(1)
-	go func(logger *zap.Logger) {
+	go func(log *zap.Logger) {
 		defer m.wg.Done()
-		logger.Info("Listening", zap.String("transport", transport), zap.String("addr", m.httpBindAddress), zap.Int("port", m.httpPort))
+		log.Info("Listening", zap.String("transport", transport), zap.String("addr", m.httpBindAddress), zap.Int("port", m.httpPort))
 
 		if cer.Certificate != nil {
 			if err := m.httpServer.ServeTLS(ln, m.httpTLSCert, m.httpTLSKey); err != nethttp.ErrServerClosed {
-				logger.Error("failed https service", zap.Error(err))
+				log.Error("Failed https service", zap.Error(err))
 			}
 		} else {
 			if err := m.httpServer.Serve(ln); err != nethttp.ErrServerClosed {
-				logger.Error("failed http service", zap.Error(err))
+				log.Error("Failed http service", zap.Error(err))
 			}
 		}
-		logger.Info("Stopping")
+		log.Info("Stopping")
 	}(httpLogger)
 
 	return nil

cmd/influxd/launcher/pkger_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/influxdata/influxdb/pkger"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/zap/zaptest"
 )
 
 func TestLauncher_Pkger(t *testing.T) {
@@ -19,6 +20,7 @@ func TestLauncher_Pkger(t *testing.T) {
 	defer l.ShutdownOrFail(t, ctx)
 
 	svc := pkger.NewService(
+		zaptest.NewLogger(t),
 		pkger.WithBucketSVC(l.BucketService()),
 		pkger.WithDashboardSVC(l.DashboardService()),
 		pkger.WithLabelSVC(l.LabelService()),
@@ -43,6 +45,7 @@ func TestLauncher_Pkger(t *testing.T) {
 
 	t.Run("errors incurred during application of package rolls back to state before package", func(t *testing.T) {
 		svc := pkger.NewService(
+			zaptest.NewLogger(t),
 			pkger.WithBucketSVC(l.BucketService()),
 			pkger.WithDashboardSVC(l.DashboardService()),
 			pkger.WithLabelSVC(&fakeLabelSVC{
@@ -312,6 +315,7 @@ func TestLauncher_Pkger(t *testing.T) {
 			require.NoError(t, err)
 
 			svc := pkger.NewService(
+				zaptest.NewLogger(t),
 				pkger.WithBucketSVC(&fakeBucketSVC{
 					BucketService: l.BucketService(),
 					killCount:     0, // kill on first update for bucket

cmd/telemetryd/main.go

@@ -14,8 +14,8 @@ import (
 )
 
 var (
-	logger = influxlogger.New(os.Stdout)
-	addr   string
+	log  = influxlogger.New(os.Stdout)
+	addr string
 )
 
 func main() {
@@ -36,10 +36,10 @@ func main() {
 	var exitCode int
 	if err := cmd.Execute(); err != nil {
 		exitCode = 1
-		logger.Error("Command returned error", zap.Error(err))
+		log.Error("Command returned error", zap.Error(err))
 	}
 
-	if err := logger.Sync(); err != nil {
+	if err := log.Sync(); err != nil {
 		exitCode = 1
 		fmt.Fprintf(os.Stderr, "Error syncing logs: %v\n", err)
 	}
@@ -48,21 +48,19 @@ func main() {
 }
 
 func run() error {
-	logger := logger.With(zap.String("service", "telemetryd"))
-	store := &telemetry.LogStore{
-		Logger: logger,
-	}
-	svc := telemetry.NewPushGateway(logger, store)
+	log := log.With(zap.String("service", "telemetryd"))
+	store := telemetry.NewLogStore(log)
+	svc := telemetry.NewPushGateway(log, store)
 	// Print data as line protocol
 	svc.Encoder = &prometheus.LineProtocol{}
 
 	handler := http.HandlerFunc(svc.Handler)
-	logger.Info("starting telemetryd server", zap.String("addr", addr))
+	log.Info("Starting telemetryd server", zap.String("addr", addr))
 
 	srv := http.Server{
 		Addr:     addr,
 		Handler:  handler,
-		ErrorLog: zap.NewStdLog(logger),
+		ErrorLog: zap.NewStdLog(log),
 	}
 	return srv.ListenAndServe()
 }

example_test.go

@@ -7,10 +7,11 @@ import (
 
 	platform "github.com/influxdata/influxdb"
 	"github.com/influxdata/influxdb/bolt"
+	"go.uber.org/zap"
 )
 
 func ExampleKeyValueLog() {
-	c := bolt.NewClient()
+	c := bolt.NewClient(zap.NewNop())
 	c.Path = "example.bolt"
 	ctx := context.Background()
 	if err := c.Open(ctx); err != nil {

gather/README.md

@@ -6,19 +6,19 @@
 // NATS streaming server
 m.natsServer = nats.NewServer(nats.Config{FilestoreDir: m.natsPath})
 if err := m.natsServer.Open(); err != nil {
-    m.logger.Error("failed to start nats streaming server", zap.Error(err))
+    m.logger.Error("Failed to start nats streaming server", zap.Error(err))
     return err
 }
 
 publisher := nats.NewAsyncPublisher("nats-publisher")
 if err := publisher.Open(); err != nil {
-    m.logger.Error("failed to connect to streaming server", zap.Error(err))
+    m.logger.Error("Failed to connect to streaming server", zap.Error(err))
     return err
 }
 
 subscriber := nats.NewQueueSubscriber("nats-subscriber")
 if err := subscriber.Open(); err != nil {
-    m.logger.Error("failed to connect to streaming server", zap.Error(err))
+    m.logger.Error("Failed to connect to streaming server", zap.Error(err))
     return err
 }
 ```
@@ -47,7 +47,7 @@ subscriber.Subscribe(MetricsSubject, "", &RecorderHandler{
 ```go
 scraperScheduler, err := gather.NewScheduler(10, m.logger, scraperTargetSvc, publisher, subscriber, 0, 0)
 if err != nil {
-    m.logger.Error("failed to create scraper subscriber", zap.Error(err))
+    m.logger.Error("Failed to create scraper subscriber", zap.Error(err))
     return err
 }
 ```

gather/handler.go

@@ -14,7 +14,7 @@ import (
 type handler struct {
 	Scraper   Scraper
 	Publisher nats.Publisher
-	Logger    *zap.Logger
+	log       *zap.Logger
 }
 
 // Process consumes scraper target from scraper target queue,
@@ -25,25 +25,25 @@ func (h *handler) Process(s nats.Subscription, m nats.Message) {
 	req := new(influxdb.ScraperTarget)
 	err := json.Unmarshal(m.Data(), req)
 	if err != nil {
-		h.Logger.Error("unable to unmarshal json", zap.Error(err))
+		h.log.Error("Unable to unmarshal json", zap.Error(err))
 		return
 	}
 
 	ms, err := h.Scraper.Gather(context.TODO(), *req)
 	if err != nil {
-		h.Logger.Error("unable to gather", zap.Error(err))
+		h.log.Error("Unable to gather", zap.Error(err))
 		return
 	}
 
 	// send metrics to recorder queue
 	buf := new(bytes.Buffer)
 	if err := json.NewEncoder(buf).Encode(ms); err != nil {
-		h.Logger.Error("unable to marshal json", zap.Error(err))
+		h.log.Error("Unable to marshal json", zap.Error(err))
 		return
 	}
 
 	if err := h.Publisher.Publish(MetricsSubject, buf); err != nil {
-		h.Logger.Error("unable to publish scraper metrics", zap.Error(err))
+		h.log.Error("Unable to publish scraper metrics", zap.Error(err))
 		return
 	}
 

gather/recorder.go

@@ -31,14 +31,21 @@ func (s PointWriter) Record(collected MetricsCollection) error {
 
 // Recorder record the metrics of a time based.
 type Recorder interface {
-	//Subscriber nats.Subscriber
+	// Subscriber nats.Subscriber
 	Record(collected MetricsCollection) error
 }
 
 // RecorderHandler implements nats.Handler interface.
 type RecorderHandler struct {
 	Recorder Recorder
-	Logger   *zap.Logger
+	log      *zap.Logger
+}
+
+func NewRecorderHandler(log *zap.Logger, recorder Recorder) *RecorderHandler {
+	return &RecorderHandler{
+		Recorder: recorder,
+		log:      log,
+	}
 }
 
 // Process consumes job queue, and use recorder to record.
@@ -47,11 +54,11 @@ func (h *RecorderHandler) Process(s nats.Subscription, m nats.Message) {
 	collected := new(MetricsCollection)
 	err := json.Unmarshal(m.Data(), &collected)
 	if err != nil {
-		h.Logger.Error("recorder handler error", zap.Error(err))
+		h.log.Error("Recorder handler error", zap.Error(err))
 		return
 	}
 	err = h.Recorder.Record(*collected)
 	if err != nil {
-		h.Logger.Error("recorder handler error", zap.Error(err))
+		h.log.Error("Recorder handler error", zap.Error(err))
 	}
 }

gather/scheduler.go

@@ -30,15 +30,15 @@ type Scheduler struct {
 	// Publisher will send the gather requests and gathered metrics to the queue.
 	Publisher nats.Publisher
 
-	Logger *zap.Logger
+	log *zap.Logger
 
 	gather chan struct{}
 }
 
 // NewScheduler creates a new Scheduler and subscriptions for scraper jobs.
 func NewScheduler(
+	log *zap.Logger,
 	numScrapers int,
-	l *zap.Logger,
 	targets influxdb.ScraperTargetStoreService,
 	p nats.Publisher,
 	s nats.Subscriber,
@@ -56,7 +56,7 @@ func NewScheduler(
 		Interval:  interval,
 		Timeout:   timeout,
 		Publisher: p,
-		Logger:    l,
+		log:       log,
 		gather:    make(chan struct{}, 100),
 	}
 
@@ -64,7 +64,7 @@ func NewScheduler(
 		err := s.Subscribe(promTargetSubject, "metrics", &handler{
 			Scraper:   new(prometheusScraper),
 			Publisher: p,
-			Logger:    l,
+			log:       log,
 		})
 		if err != nil {
 			return nil, err
@@ -109,13 +109,13 @@ func (s *Scheduler) doGather(ctx context.Context) {
 
 	targets, err := s.Targets.ListTargets(ctx, influxdb.ScraperTargetFilter{})
 	if err != nil {
-		s.Logger.Error("cannot list targets", zap.Error(err))
+		s.log.Error("Cannot list targets", zap.Error(err))
 		tracing.LogError(span, err)
 		return
 	}
 	for _, target := range targets {
 		if err := requestScrape(target, s.Publisher); err != nil {
-			s.Logger.Error("json encoding error", zap.Error(err))
+			s.log.Error("JSON encoding error", zap.Error(err))
 			tracing.LogError(span, err)
 		}
 	}

gather/scheduler_test.go

@@ -43,12 +43,11 @@ func TestScheduler(t *testing.T) {
 	}
 
 	subscriber.Subscribe(MetricsSubject, "", &RecorderHandler{
-		Logger:   logger,
+		log:      logger,
 		Recorder: storage,
 	})
 
-	scheduler, err := NewScheduler(10, logger,
-		storage, publisher, subscriber, time.Millisecond, time.Microsecond)
+	scheduler, err := NewScheduler(logger, 10, storage, publisher, subscriber, time.Millisecond, time.Microsecond)
 
 	go func() {
 		err = scheduler.run(ctx)

http/api_handler.go

@@ -140,86 +140,86 @@ func NewAPIHandler(b *APIBackend, opts ...APIHandlerOptFn) *APIHandler {
 	internalURM := b.UserResourceMappingService
 	b.UserResourceMappingService = authorizer.NewURMService(b.OrgLookupService, b.UserResourceMappingService)
 
-	documentBackend := NewDocumentBackend(b)
+	documentBackend := NewDocumentBackend(b.Logger.With(zap.String("handler", "document")), b)
 	h.DocumentHandler = NewDocumentHandler(documentBackend)
 
-	sessionBackend := newSessionBackend(b)
-	h.SessionHandler = NewSessionHandler(sessionBackend)
+	sessionBackend := newSessionBackend(b.Logger.With(zap.String("handler", "session")), b)
+	h.SessionHandler = NewSessionHandler(b.Logger, sessionBackend)
 
-	bucketBackend := NewBucketBackend(b)
+	bucketBackend := NewBucketBackend(b.Logger.With(zap.String("handler", "bucket")), b)
 	bucketBackend.BucketService = authorizer.NewBucketService(b.BucketService)
-	h.BucketHandler = NewBucketHandler(bucketBackend)
+	h.BucketHandler = NewBucketHandler(b.Logger, bucketBackend)
 
-	orgBackend := NewOrgBackend(b)
+	orgBackend := NewOrgBackend(b.Logger.With(zap.String("handler", "org")), b)
 	orgBackend.OrganizationService = authorizer.NewOrgService(b.OrganizationService)
-	h.OrgHandler = NewOrgHandler(orgBackend)
+	h.OrgHandler = NewOrgHandler(b.Logger, orgBackend)
 
-	userBackend := NewUserBackend(b)
+	userBackend := NewUserBackend(b.Logger.With(zap.String("handler", "user")), b)
 	userBackend.UserService = authorizer.NewUserService(b.UserService)
 	userBackend.PasswordsService = authorizer.NewPasswordService(b.PasswordsService)
-	h.UserHandler = NewUserHandler(userBackend)
+	h.UserHandler = NewUserHandler(b.Logger, userBackend)
 
-	dashboardBackend := NewDashboardBackend(b)
+	dashboardBackend := NewDashboardBackend(b.Logger.With(zap.String("handler", "dashboard")), b)
 	dashboardBackend.DashboardService = authorizer.NewDashboardService(b.DashboardService)
-	h.DashboardHandler = NewDashboardHandler(dashboardBackend)
+	h.DashboardHandler = NewDashboardHandler(b.Logger, dashboardBackend)
 
-	variableBackend := NewVariableBackend(b)
+	variableBackend := NewVariableBackend(b.Logger.With(zap.String("handler", "variable")), b)
 	variableBackend.VariableService = authorizer.NewVariableService(b.VariableService)
-	h.VariableHandler = NewVariableHandler(variableBackend)
+	h.VariableHandler = NewVariableHandler(b.Logger, variableBackend)
 
-	authorizationBackend := NewAuthorizationBackend(b)
+	authorizationBackend := NewAuthorizationBackend(b.Logger.With(zap.String("handler", "authorization")), b)
 	authorizationBackend.AuthorizationService = authorizer.NewAuthorizationService(b.AuthorizationService)
-	h.AuthorizationHandler = NewAuthorizationHandler(authorizationBackend)
+	h.AuthorizationHandler = NewAuthorizationHandler(b.Logger, authorizationBackend)
 
-	scraperBackend := NewScraperBackend(b)
+	scraperBackend := NewScraperBackend(b.Logger.With(zap.String("handler", "scraper")), b)
 	scraperBackend.ScraperStorageService = authorizer.NewScraperTargetStoreService(b.ScraperTargetStoreService,
 		b.UserResourceMappingService,
 		b.OrganizationService)
-	h.ScraperHandler = NewScraperHandler(scraperBackend)
+	h.ScraperHandler = NewScraperHandler(b.Logger, scraperBackend)
 
-	sourceBackend := NewSourceBackend(b)
+	sourceBackend := NewSourceBackend(b.Logger.With(zap.String("handler", "source")), b)
 	sourceBackend.SourceService = authorizer.NewSourceService(b.SourceService)
 	sourceBackend.BucketService = authorizer.NewBucketService(b.BucketService)
-	h.SourceHandler = NewSourceHandler(sourceBackend)
+	h.SourceHandler = NewSourceHandler(b.Logger, sourceBackend)
 
-	setupBackend := NewSetupBackend(b)
-	h.SetupHandler = NewSetupHandler(setupBackend)
+	setupBackend := NewSetupBackend(b.Logger.With(zap.String("handler", "setup")), b)
+	h.SetupHandler = NewSetupHandler(b.Logger, setupBackend)
 
-	taskBackend := NewTaskBackend(b)
-	h.TaskHandler = NewTaskHandler(taskBackend)
+	taskBackend := NewTaskBackend(b.Logger.With(zap.String("handler", "task")), b)
+	h.TaskHandler = NewTaskHandler(b.Logger, taskBackend)
 	h.TaskHandler.UserResourceMappingService = internalURM
 
-	telegrafBackend := NewTelegrafBackend(b)
+	telegrafBackend := NewTelegrafBackend(b.Logger.With(zap.String("handler", "telegraf")), b)
 	telegrafBackend.TelegrafService = authorizer.NewTelegrafConfigService(b.TelegrafService, b.UserResourceMappingService)
-	h.TelegrafHandler = NewTelegrafHandler(telegrafBackend)
+	h.TelegrafHandler = NewTelegrafHandler(b.Logger, telegrafBackend)
 
-	notificationRuleBackend := NewNotificationRuleBackend(b)
+	notificationRuleBackend := NewNotificationRuleBackend(b.Logger.With(zap.String("handler", "notification_rule")), b)
 	notificationRuleBackend.NotificationRuleStore = authorizer.NewNotificationRuleStore(b.NotificationRuleStore,
 		b.UserResourceMappingService, b.OrganizationService)
-	h.NotificationRuleHandler = NewNotificationRuleHandler(notificationRuleBackend)
+	h.NotificationRuleHandler = NewNotificationRuleHandler(b.Logger, notificationRuleBackend)
 
-	notificationEndpointBackend := NewNotificationEndpointBackend(b)
+	notificationEndpointBackend := NewNotificationEndpointBackend(b.Logger.With(zap.String("handler", "notificationEndpoint")), b)
 	notificationEndpointBackend.NotificationEndpointService = authorizer.NewNotificationEndpointService(b.NotificationEndpointService,
 		b.UserResourceMappingService, b.OrganizationService)
-	h.NotificationEndpointHandler = NewNotificationEndpointHandler(notificationEndpointBackend)
+	h.NotificationEndpointHandler = NewNotificationEndpointHandler(notificationEndpointBackend.Logger(), notificationEndpointBackend)
 
-	checkBackend := NewCheckBackend(b)
+	checkBackend := NewCheckBackend(b.Logger.With(zap.String("handler", "check")), b)
 	checkBackend.CheckService = authorizer.NewCheckService(b.CheckService,
 		b.UserResourceMappingService, b.OrganizationService)
-	h.CheckHandler = NewCheckHandler(checkBackend)
+	h.CheckHandler = NewCheckHandler(b.Logger, checkBackend)
 
-	writeBackend := NewWriteBackend(b)
-	h.WriteHandler = NewWriteHandler(writeBackend)
+	writeBackend := NewWriteBackend(b.Logger.With(zap.String("handler", "write")), b)
+	h.WriteHandler = NewWriteHandler(b.Logger, writeBackend)
 
-	deleteBackend := NewDeleteBackend(b)
-	h.DeleteHandler = NewDeleteHandler(deleteBackend)
+	deleteBackend := NewDeleteBackend(b.Logger.With(zap.String("handler", "delete")), b)
+	h.DeleteHandler = NewDeleteHandler(b.Logger, deleteBackend)
 
-	fluxBackend := NewFluxBackend(b)
-	h.QueryHandler = NewFluxHandler(fluxBackend)
+	fluxBackend := NewFluxBackend(b.Logger.With(zap.String("handler", "query")), b)
+	h.QueryHandler = NewFluxHandler(b.Logger, fluxBackend)
 
 	h.ChronografHandler = NewChronografHandler(b.ChronografService, b.HTTPErrorHandler)
 	h.SwaggerHandler = newSwaggerLoader(b.Logger.With(zap.String("service", "swagger-loader")), b.HTTPErrorHandler)
-	h.LabelHandler = NewLabelHandler(authorizer.NewLabelService(b.LabelService), b.HTTPErrorHandler)
+	h.LabelHandler = NewLabelHandler(b.Logger, authorizer.NewLabelService(b.LabelService), b.HTTPErrorHandler)
 
 	return h
 }

http/api_handler_test.go

@@ -6,7 +6,7 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest"
 )
 
 func TestAPIHandler_NotFound(t *testing.T) {
@@ -51,8 +51,8 @@ func TestAPIHandler_NotFound(t *testing.T) {
 
 			b := &APIBackend{
 				HTTPErrorHandler: ErrorHandler(0),
+				Logger:           zaptest.NewLogger(t),
 			}
-			b.Logger = zap.NewNop()
 
 			h := NewAPIHandler(b)
 			h.ServeHTTP(w, r)

http/auth_service.go

@@ -21,7 +21,7 @@ import (
 // the AuthorizationHandler.
 type AuthorizationBackend struct {
 	platform.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	AuthorizationService platform.AuthorizationService
 	OrganizationService  platform.OrganizationService
@@ -30,10 +30,10 @@ type AuthorizationBackend struct {
 }
 
 // NewAuthorizationBackend returns a new instance of AuthorizationBackend.
-func NewAuthorizationBackend(b *APIBackend) *AuthorizationBackend {
+func NewAuthorizationBackend(log *zap.Logger, b *APIBackend) *AuthorizationBackend {
 	return &AuthorizationBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "authorization")),
+		log:              log,
 
 		AuthorizationService: b.AuthorizationService,
 		OrganizationService:  b.OrganizationService,
@@ -46,7 +46,7 @@ func NewAuthorizationBackend(b *APIBackend) *AuthorizationBackend {
 type AuthorizationHandler struct {
 	*httprouter.Router
 	platform.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	OrganizationService  platform.OrganizationService
 	UserService          platform.UserService
@@ -55,11 +55,11 @@ type AuthorizationHandler struct {
 }
 
 // NewAuthorizationHandler returns a new instance of AuthorizationHandler.
-func NewAuthorizationHandler(b *AuthorizationBackend) *AuthorizationHandler {
+func NewAuthorizationHandler(log *zap.Logger, b *AuthorizationBackend) *AuthorizationHandler {
 	h := &AuthorizationHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger,
+		log:              log,
 
 		AuthorizationService: b.AuthorizationService,
 		OrganizationService:  b.OrganizationService,
@@ -231,10 +231,10 @@ func (h *AuthorizationHandler) handlePostAuthorization(w http.ResponseWriter, r
 		return
 	}
 
-	h.Logger.Debug("auth created ", zap.String("auth", fmt.Sprint(auth)))
+	h.log.Debug("Auth created ", zap.String("auth", fmt.Sprint(auth)))
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, newAuthResponse(auth, org, user, perms)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -336,7 +336,7 @@ func (h *AuthorizationHandler) handleGetAuthorizations(w http.ResponseWriter, r
 	ctx := r.Context()
 	req, err := decodeGetAuthorizationsRequest(ctx, r)
 	if err != nil {
-		h.Logger.Info("failed to decode request", zap.String("handler", "getAuthorizations"), zap.Error(err))
+		h.log.Info("Failed to decode request", zap.String("handler", "getAuthorizations"), zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -352,13 +352,13 @@ func (h *AuthorizationHandler) handleGetAuthorizations(w http.ResponseWriter, r
 	for _, a := range as {
 		o, err := h.OrganizationService.FindOrganizationByID(ctx, a.OrgID)
 		if err != nil {
-			h.Logger.Info("failed to get organization", zap.String("handler", "getAuthorizations"), zap.String("orgID", a.OrgID.String()), zap.Error(err))
+			h.log.Info("Failed to get organization", zap.String("handler", "getAuthorizations"), zap.String("orgID", a.OrgID.String()), zap.Error(err))
 			continue
 		}
 
 		u, err := h.UserService.FindUserByID(ctx, a.UserID)
 		if err != nil {
-			h.Logger.Info("failed to get user", zap.String("handler", "getAuthorizations"), zap.String("userID", a.UserID.String()), zap.Error(err))
+			h.log.Info("Failed to get user", zap.String("handler", "getAuthorizations"), zap.String("userID", a.UserID.String()), zap.Error(err))
 			continue
 		}
 
@@ -371,7 +371,7 @@ func (h *AuthorizationHandler) handleGetAuthorizations(w http.ResponseWriter, r
 		auths = append(auths, newAuthResponse(a, o, u, ps))
 	}
 
-	h.Logger.Debug("auths retrieved ", zap.String("auths", fmt.Sprint(auths)))
+	h.log.Debug("Auths retrieved ", zap.String("auths", fmt.Sprint(auths)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newAuthsResponse(auths)); err != nil {
 		h.HandleHTTPError(ctx, err, w)
@@ -433,7 +433,7 @@ func (h *AuthorizationHandler) handleGetAuthorization(w http.ResponseWriter, r *
 	ctx := r.Context()
 	req, err := decodeGetAuthorizationRequest(ctx, r)
 	if err != nil {
-		h.Logger.Info("failed to decode request", zap.String("handler", "getAuthorization"), zap.Error(err))
+		h.log.Info("Failed to decode request", zap.String("handler", "getAuthorization"), zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -463,7 +463,7 @@ func (h *AuthorizationHandler) handleGetAuthorization(w http.ResponseWriter, r *
 		return
 	}
 
-	h.Logger.Debug("auth retrieved ", zap.String("auth", fmt.Sprint(a)))
+	h.log.Debug("Auth retrieved ", zap.String("auth", fmt.Sprint(a)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newAuthResponse(a, o, u, ps)); err != nil {
 		h.HandleHTTPError(ctx, err, w)
@@ -500,7 +500,7 @@ func (h *AuthorizationHandler) handleUpdateAuthorization(w http.ResponseWriter,
 	ctx := r.Context()
 	req, err := decodeUpdateAuthorizationRequest(ctx, r)
 	if err != nil {
-		h.Logger.Info("failed to decode request", zap.String("handler", "updateAuthorization"), zap.Error(err))
+		h.log.Info("Failed to decode request", zap.String("handler", "updateAuthorization"), zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -534,7 +534,7 @@ func (h *AuthorizationHandler) handleUpdateAuthorization(w http.ResponseWriter,
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("auth updated", zap.String("auth", fmt.Sprint(a)))
+	h.log.Debug("Auth updated", zap.String("auth", fmt.Sprint(a)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newAuthResponse(a, o, u, ps)); err != nil {
 		h.HandleHTTPError(ctx, err, w)
@@ -578,7 +578,7 @@ func (h *AuthorizationHandler) handleDeleteAuthorization(w http.ResponseWriter,
 	ctx := r.Context()
 	req, err := decodeDeleteAuthorizationRequest(ctx, r)
 	if err != nil {
-		h.Logger.Info("failed to decode request", zap.String("handler", "deleteAuthorization"), zap.Error(err))
+		h.log.Info("Failed to decode request", zap.String("handler", "deleteAuthorization"), zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -589,7 +589,7 @@ func (h *AuthorizationHandler) handleDeleteAuthorization(w http.ResponseWriter,
 		return
 	}
 
-	h.Logger.Debug("auth deleted", zap.String("authID", fmt.Sprint(req.ID)))
+	h.log.Debug("Auth deleted", zap.String("authID", fmt.Sprint(req.ID)))
 
 	w.WriteHeader(http.StatusNoContent)
 }

http/auth_test.go

@@ -10,21 +10,20 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"go.uber.org/zap"
-
+	"github.com/influxdata/httprouter"
 	platform "github.com/influxdata/influxdb"
 	pcontext "github.com/influxdata/influxdb/context"
 	"github.com/influxdata/influxdb/inmem"
 	"github.com/influxdata/influxdb/kv"
 	"github.com/influxdata/influxdb/mock"
 	platformtesting "github.com/influxdata/influxdb/testing"
-	"github.com/influxdata/httprouter"
+	"go.uber.org/zap/zaptest"
 )
 
 // NewMockAuthorizationBackend returns a AuthorizationBackend with mock services.
-func NewMockAuthorizationBackend() *AuthorizationBackend {
+func NewMockAuthorizationBackend(t *testing.T) *AuthorizationBackend {
 	return &AuthorizationBackend{
-		Logger: zap.NewNop().With(zap.String("handler", "authorization")),
+		log: zaptest.NewLogger(t),
 
 		AuthorizationService: mock.NewAuthorizationService(),
 		OrganizationService:  mock.NewOrganizationService(),
@@ -331,12 +330,12 @@ func TestService_handleGetAuthorizations(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			authorizationBackend := NewMockAuthorizationBackend()
+			authorizationBackend := NewMockAuthorizationBackend(t)
 			authorizationBackend.HTTPErrorHandler = ErrorHandler(0)
 			authorizationBackend.AuthorizationService = tt.fields.AuthorizationService
 			authorizationBackend.UserService = tt.fields.UserService
 			authorizationBackend.OrganizationService = tt.fields.OrganizationService
-			h := NewAuthorizationHandler(authorizationBackend)
+			h := NewAuthorizationHandler(zaptest.NewLogger(t), authorizationBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -516,13 +515,13 @@ func TestService_handleGetAuthorization(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			authorizationBackend := NewMockAuthorizationBackend()
+			authorizationBackend := NewMockAuthorizationBackend(t)
 			authorizationBackend.HTTPErrorHandler = ErrorHandler(0)
 			authorizationBackend.AuthorizationService = tt.fields.AuthorizationService
 			authorizationBackend.UserService = tt.fields.UserService
 			authorizationBackend.OrganizationService = tt.fields.OrganizationService
 			authorizationBackend.LookupService = tt.fields.LookupService
-			h := NewAuthorizationHandler(authorizationBackend)
+			h := NewAuthorizationHandler(zaptest.NewLogger(t), authorizationBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -696,13 +695,13 @@ func TestService_handlePostAuthorization(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			authorizationBackend := NewMockAuthorizationBackend()
+			authorizationBackend := NewMockAuthorizationBackend(t)
 			authorizationBackend.HTTPErrorHandler = ErrorHandler(0)
 			authorizationBackend.AuthorizationService = tt.fields.AuthorizationService
 			authorizationBackend.UserService = tt.fields.UserService
 			authorizationBackend.OrganizationService = tt.fields.OrganizationService
 			authorizationBackend.LookupService = tt.fields.LookupService
-			h := NewAuthorizationHandler(authorizationBackend)
+			h := NewAuthorizationHandler(zaptest.NewLogger(t), authorizationBackend)
 
 			req, err := newPostAuthorizationRequest(tt.args.authorization)
 			if err != nil {
@@ -810,12 +809,12 @@ func TestService_handleDeleteAuthorization(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			authorizationBackend := NewMockAuthorizationBackend()
+			authorizationBackend := NewMockAuthorizationBackend(t)
 			authorizationBackend.HTTPErrorHandler = ErrorHandler(0)
 			authorizationBackend.AuthorizationService = tt.fields.AuthorizationService
 			authorizationBackend.UserService = tt.fields.UserService
 			authorizationBackend.OrganizationService = tt.fields.OrganizationService
-			h := NewAuthorizationHandler(authorizationBackend)
+			h := NewAuthorizationHandler(zaptest.NewLogger(t), authorizationBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -869,7 +868,7 @@ func initAuthorizationService(f platformtesting.AuthorizationFields, t *testing.
 		t.Skip("HTTP authorization service does not required a user id on the authentication struct.  We get the user from the session token.")
 	}
 
-	svc := kv.NewService(inmem.NewKVStore())
+	svc := kv.NewService(zaptest.NewLogger(t), inmem.NewKVStore())
 	svc.IDGenerator = f.IDGenerator
 	svc.TokenGenerator = f.TokenGenerator
 	svc.TimeGenerator = f.TimeGenerator
@@ -904,7 +903,7 @@ func initAuthorizationService(f platformtesting.AuthorizationFields, t *testing.
 		},
 	}
 
-	authorizationBackend := NewMockAuthorizationBackend()
+	authorizationBackend := NewMockAuthorizationBackend(t)
 	authorizationBackend.HTTPErrorHandler = ErrorHandler(0)
 	authorizationBackend.AuthorizationService = svc
 	authorizationBackend.UserService = mus
@@ -921,8 +920,8 @@ func initAuthorizationService(f platformtesting.AuthorizationFields, t *testing.
 		},
 	}
 
-	authZ := NewAuthorizationHandler(authorizationBackend)
-	authN := NewAuthenticationHandler(ErrorHandler(0))
+	authZ := NewAuthorizationHandler(zaptest.NewLogger(t), authorizationBackend)
+	authN := NewAuthenticationHandler(zaptest.NewLogger(t), ErrorHandler(0))
 	authN.AuthorizationService = svc
 	authN.Handler = authZ
 	authN.UserService = mus

http/authentication_middleware.go

@@ -17,7 +17,7 @@ import (
 // AuthenticationHandler is a middleware for authenticating incoming requests.
 type AuthenticationHandler struct {
 	platform.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	AuthorizationService platform.AuthorizationService
 	SessionService       platform.SessionService
@@ -33,9 +33,9 @@ type AuthenticationHandler struct {
 }
 
 // NewAuthenticationHandler creates an authentication handler.
-func NewAuthenticationHandler(h platform.HTTPErrorHandler) *AuthenticationHandler {
+func NewAuthenticationHandler(log *zap.Logger, h platform.HTTPErrorHandler) *AuthenticationHandler {
 	return &AuthenticationHandler{
-		Logger:           zap.NewNop(),
+		log:              log,
 		HTTPErrorHandler: h,
 		Handler:          http.DefaultServeMux,
 		TokenParser:      jsonweb.NewTokenParser(jsonweb.EmptyKeyStore),
@@ -71,7 +71,7 @@ func ProbeAuthScheme(r *http.Request) (string, error) {
 }
 
 func (h *AuthenticationHandler) unauthorized(ctx context.Context, w http.ResponseWriter, err error) {
-	h.Logger.Info("unauthorized", zap.Error(err))
+	h.log.Info("Unauthorized", zap.Error(err))
 	UnauthorizedError(ctx, h, w)
 }
 

http/authentication_test.go

@@ -14,6 +14,7 @@ import (
 	platformhttp "github.com/influxdata/influxdb/http"
 	"github.com/influxdata/influxdb/jsonweb"
 	"github.com/influxdata/influxdb/mock"
+	"go.uber.org/zap/zaptest"
 )
 
 const token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJjbG91ZDIuaW5mbHV4ZGF0YS5jb20iLCJhdWQiOiJnYXRld2F5LmluZmx1eGRhdGEuY29tIiwiaWF0IjoxNTY4NjI4OTgwLCJraWQiOiJzb21lLWtleSIsInBlcm1pc3Npb25zIjpbeyJhY3Rpb24iOiJ3cml0ZSIsInJlc291cmNlIjp7InR5cGUiOiJidWNrZXRzIiwiaWQiOiIwMDAwMDAwMDAwMDAwMDAxIiwib3JnSUQiOiIwMDAwMDAwMDAwMDAwMDAyIn19XX0.74vjbExiOd702VSIMmQWaDT_GFvUI0-_P-SfQ_OOHB0"
@@ -208,7 +209,7 @@ func TestAuthenticationHandler(t *testing.T) {
 				w.WriteHeader(http.StatusOK)
 			})
 
-			h := platformhttp.NewAuthenticationHandler(platformhttp.ErrorHandler(0))
+			h := platformhttp.NewAuthenticationHandler(zaptest.NewLogger(t), platformhttp.ErrorHandler(0))
 			h.AuthorizationService = tt.fields.AuthorizationService
 			h.SessionService = tt.fields.SessionService
 			h.UserService = &mock.UserService{
@@ -375,7 +376,7 @@ func TestAuthenticationHandler_NoAuthRoutes(t *testing.T) {
 				w.WriteHeader(http.StatusOK)
 			})
 
-			h := platformhttp.NewAuthenticationHandler(platformhttp.ErrorHandler(0))
+			h := platformhttp.NewAuthenticationHandler(zaptest.NewLogger(t), platformhttp.ErrorHandler(0))
 			h.AuthorizationService = mock.NewAuthorizationService()
 			h.SessionService = mock.NewSessionService()
 			h.Handler = handler

http/bucket_service.go

@@ -19,7 +19,7 @@ import (
 // BucketBackend is all services and associated parameters required to construct
 // the BucketHandler.
 type BucketBackend struct {
-	Logger *zap.Logger
+	log *zap.Logger
 	influxdb.HTTPErrorHandler
 
 	BucketService              influxdb.BucketService
@@ -31,10 +31,10 @@ type BucketBackend struct {
 }
 
 // NewBucketBackend returns a new instance of BucketBackend.
-func NewBucketBackend(b *APIBackend) *BucketBackend {
+func NewBucketBackend(log *zap.Logger, b *APIBackend) *BucketBackend {
 	return &BucketBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "bucket")),
+		log:              log,
 
 		BucketService:              b.BucketService,
 		BucketOperationLogService:  b.BucketOperationLogService,
@@ -49,7 +49,7 @@ func NewBucketBackend(b *APIBackend) *BucketBackend {
 type BucketHandler struct {
 	*httprouter.Router
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	BucketService              influxdb.BucketService
 	BucketOperationLogService  influxdb.BucketOperationLogService
@@ -72,11 +72,11 @@ const (
 )
 
 // NewBucketHandler returns a new instance of BucketHandler.
-func NewBucketHandler(b *BucketBackend) *BucketHandler {
+func NewBucketHandler(log *zap.Logger, b *BucketBackend) *BucketHandler {
 	h := &BucketHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger,
+		log:              log,
 
 		BucketService:              b.BucketService,
 		BucketOperationLogService:  b.BucketOperationLogService,
@@ -95,7 +95,7 @@ func NewBucketHandler(b *BucketBackend) *BucketHandler {
 
 	memberBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               influxdb.BucketsResourceType,
 		UserType:                   influxdb.Member,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -107,7 +107,7 @@ func NewBucketHandler(b *BucketBackend) *BucketHandler {
 
 	ownerBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               influxdb.BucketsResourceType,
 		UserType:                   influxdb.Owner,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -119,7 +119,7 @@ func NewBucketHandler(b *BucketBackend) *BucketHandler {
 
 	labelBackend := &LabelBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "label")),
+		log:              b.log.With(zap.String("handler", "label")),
 		LabelService:     b.LabelService,
 		ResourceType:     influxdb.BucketsResourceType,
 	}
@@ -331,10 +331,10 @@ func (h *BucketHandler) handlePostBucket(w http.ResponseWriter, r *http.Request)
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("bucket created", zap.String("bucket", fmt.Sprint(bucket)))
+	h.log.Debug("Bucket created", zap.String("bucket", fmt.Sprint(bucket)))
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, newBucketResponse(bucket, []*influxdb.Label{})); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -414,10 +414,10 @@ func (h *BucketHandler) handleGetBucket(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	h.Logger.Debug("bucket retrieved", zap.String("bucket", fmt.Sprint(b)))
+	h.log.Debug("Bucket retrieved", zap.String("bucket", fmt.Sprint(b)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newBucketResponse(b, labels)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -445,10 +445,10 @@ func (h *BucketHandler) handleGetBucketLog(w http.ResponseWriter, r *http.Reques
 		return
 	}
 
-	h.Logger.Debug("bucket log retrived", zap.String("bucket", fmt.Sprint(log)))
+	h.log.Debug("Bucket log retrived", zap.String("bucket", fmt.Sprint(log)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newBucketLogResponse(req.BucketID, log)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -532,7 +532,7 @@ func (h *BucketHandler) handleDeleteBucket(w http.ResponseWriter, r *http.Reques
 		return
 	}
 
-	h.Logger.Debug("bucket deleted", zap.String("bucketID", req.BucketID.String()))
+	h.log.Debug("Bucket deleted", zap.String("bucketID", req.BucketID.String()))
 
 	w.WriteHeader(http.StatusNoContent)
 }
@@ -579,10 +579,10 @@ func (h *BucketHandler) handleGetBuckets(w http.ResponseWriter, r *http.Request)
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("buckets retrieved", zap.String("buckets", fmt.Sprint(bs)))
+	h.log.Debug("Buckets retrieved", zap.String("buckets", fmt.Sprint(bs)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newBucketsResponse(ctx, req.opts, req.filter, bs, h.LabelService)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -650,10 +650,10 @@ func (h *BucketHandler) handlePatchBucket(w http.ResponseWriter, r *http.Request
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("bucket updated", zap.String("bucket", fmt.Sprint(b)))
+	h.log.Debug("Bucket updated", zap.String("bucket", fmt.Sprint(b)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newBucketResponse(b, labels)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }

http/bucket_test.go

@@ -11,19 +11,20 @@ import (
 	"testing"
 	"time"
 
+	"github.com/influxdata/httprouter"
 	platform "github.com/influxdata/influxdb"
 	"github.com/influxdata/influxdb/inmem"
 	"github.com/influxdata/influxdb/kv"
 	"github.com/influxdata/influxdb/mock"
 	platformtesting "github.com/influxdata/influxdb/testing"
-	"github.com/influxdata/httprouter"
 	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest"
 )
 
 // NewMockBucketBackend returns a BucketBackend with mock services.
-func NewMockBucketBackend() *BucketBackend {
+func NewMockBucketBackend(t *testing.T) *BucketBackend {
 	return &BucketBackend{
-		Logger: zap.NewNop().With(zap.String("handler", "bucket")),
+		log: zaptest.NewLogger(t).With(zap.String("handler", "bucket")),
 
 		BucketService:              mock.NewBucketService(),
 		BucketOperationLogService:  mock.NewBucketOperationLogService(),
@@ -195,10 +196,10 @@ func TestService_handleGetBuckets(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			bucketBackend := NewMockBucketBackend()
+			bucketBackend := NewMockBucketBackend(t)
 			bucketBackend.BucketService = tt.fields.BucketService
 			bucketBackend.LabelService = tt.fields.LabelService
-			h := NewBucketHandler(bucketBackend)
+			h := NewBucketHandler(zaptest.NewLogger(t), bucketBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -320,10 +321,10 @@ func TestService_handleGetBucket(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			bucketBackend := NewMockBucketBackend()
+			bucketBackend := NewMockBucketBackend(t)
 			bucketBackend.HTTPErrorHandler = ErrorHandler(0)
 			bucketBackend.BucketService = tt.fields.BucketService
-			h := NewBucketHandler(bucketBackend)
+			h := NewBucketHandler(zaptest.NewLogger(t), bucketBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -434,10 +435,10 @@ func TestService_handlePostBucket(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			bucketBackend := NewMockBucketBackend()
+			bucketBackend := NewMockBucketBackend(t)
 			bucketBackend.BucketService = tt.fields.BucketService
 			bucketBackend.OrganizationService = tt.fields.OrganizationService
-			h := NewBucketHandler(bucketBackend)
+			h := NewBucketHandler(zaptest.NewLogger(t), bucketBackend)
 
 			b, err := json.Marshal(newBucket(tt.args.bucket))
 			if err != nil {
@@ -532,10 +533,10 @@ func TestService_handleDeleteBucket(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			bucketBackend := NewMockBucketBackend()
+			bucketBackend := NewMockBucketBackend(t)
 			bucketBackend.HTTPErrorHandler = ErrorHandler(0)
 			bucketBackend.BucketService = tt.fields.BucketService
-			h := NewBucketHandler(bucketBackend)
+			h := NewBucketHandler(zaptest.NewLogger(t), bucketBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -835,10 +836,10 @@ func TestService_handlePatchBucket(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			bucketBackend := NewMockBucketBackend()
+			bucketBackend := NewMockBucketBackend(t)
 			bucketBackend.HTTPErrorHandler = ErrorHandler(0)
 			bucketBackend.BucketService = tt.fields.BucketService
-			h := NewBucketHandler(bucketBackend)
+			h := NewBucketHandler(zaptest.NewLogger(t), bucketBackend)
 
 			upd := platform.BucketUpdate{}
 			if tt.args.name != "" {
@@ -951,9 +952,9 @@ func TestService_handlePostBucketMember(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			bucketBackend := NewMockBucketBackend()
+			bucketBackend := NewMockBucketBackend(t)
 			bucketBackend.UserService = tt.fields.UserService
-			h := NewBucketHandler(bucketBackend)
+			h := NewBucketHandler(zaptest.NewLogger(t), bucketBackend)
 
 			b, err := json.Marshal(tt.args.user)
 			if err != nil {
@@ -1045,9 +1046,9 @@ func TestService_handlePostBucketOwner(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			bucketBackend := NewMockBucketBackend()
+			bucketBackend := NewMockBucketBackend(t)
 			bucketBackend.UserService = tt.fields.UserService
-			h := NewBucketHandler(bucketBackend)
+			h := NewBucketHandler(zaptest.NewLogger(t), bucketBackend)
 
 			b, err := json.Marshal(tt.args.user)
 			if err != nil {
@@ -1080,7 +1081,7 @@ func TestService_handlePostBucketOwner(t *testing.T) {
 }
 
 func initBucketService(f platformtesting.BucketFields, t *testing.T) (platform.BucketService, string, func()) {
-	svc := kv.NewService(inmem.NewKVStore())
+	svc := kv.NewService(zaptest.NewLogger(t), inmem.NewKVStore())
 	svc.IDGenerator = f.IDGenerator
 	svc.OrgBucketIDs = f.OrgBucketIDs
 	svc.TimeGenerator = f.TimeGenerator
@@ -1104,11 +1105,11 @@ func initBucketService(f platformtesting.BucketFields, t *testing.T) (platform.B
 		}
 	}
 
-	bucketBackend := NewMockBucketBackend()
+	bucketBackend := NewMockBucketBackend(t)
 	bucketBackend.HTTPErrorHandler = ErrorHandler(0)
 	bucketBackend.BucketService = svc
 	bucketBackend.OrganizationService = svc
-	handler := NewBucketHandler(bucketBackend)
+	handler := NewBucketHandler(zaptest.NewLogger(t), bucketBackend)
 	server := httptest.NewServer(handler)
 	client := BucketService{
 		Addr:     server.URL,

http/check_service.go

@@ -18,7 +18,7 @@ import (
 // the CheckBackendHandler.
 type CheckBackend struct {
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	TaskService                influxdb.TaskService
 	CheckService               influxdb.CheckService
@@ -29,10 +29,10 @@ type CheckBackend struct {
 }
 
 // NewCheckBackend returns a new instance of CheckBackend.
-func NewCheckBackend(b *APIBackend) *CheckBackend {
+func NewCheckBackend(log *zap.Logger, b *APIBackend) *CheckBackend {
 	return &CheckBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "check")),
+		log:              log,
 
 		TaskService:                b.TaskService,
 		CheckService:               b.CheckService,
@@ -47,7 +47,7 @@ func NewCheckBackend(b *APIBackend) *CheckBackend {
 type CheckHandler struct {
 	*httprouter.Router
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	TaskService                influxdb.TaskService
 	CheckService               influxdb.CheckService
@@ -70,11 +70,11 @@ const (
 )
 
 // NewCheckHandler returns a new instance of CheckHandler.
-func NewCheckHandler(b *CheckBackend) *CheckHandler {
+func NewCheckHandler(log *zap.Logger, b *CheckBackend) *CheckHandler {
 	h := &CheckHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger,
+		log:              log,
 
 		CheckService:               b.CheckService,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -93,7 +93,7 @@ func NewCheckHandler(b *CheckBackend) *CheckHandler {
 
 	memberBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               influxdb.ChecksResourceType,
 		UserType:                   influxdb.Member,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -105,7 +105,7 @@ func NewCheckHandler(b *CheckBackend) *CheckHandler {
 
 	ownerBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               influxdb.ChecksResourceType,
 		UserType:                   influxdb.Owner,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -117,7 +117,7 @@ func NewCheckHandler(b *CheckBackend) *CheckHandler {
 
 	labelBackend := &LabelBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "label")),
+		log:              b.log.With(zap.String("handler", "label")),
 		LabelService:     b.LabelService,
 		ResourceType:     influxdb.TelegrafsResourceType,
 	}
@@ -219,7 +219,7 @@ func (h *CheckHandler) newChecksResponse(ctx context.Context, chks []influxdb.Ch
 		labels, _ := labelService.FindResourceLabels(ctx, influxdb.LabelMappingFilter{ResourceID: chk.GetID()})
 		cr, err := h.newCheckResponse(ctx, chk, labels)
 		if err != nil {
-			h.Logger.Info("Failed to retrieve task associated with check", zap.String("checkID", chk.GetID().String()))
+			h.log.Info("Failed to retrieve task associated with check", zap.String("checkID", chk.GetID().String()))
 			continue
 		}
 
@@ -248,7 +248,7 @@ func (h *CheckHandler) handleGetChecks(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	filter, opts, err := decodeCheckFilter(ctx, r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -257,10 +257,10 @@ func (h *CheckHandler) handleGetChecks(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("checks retrieved", zap.String("checks", fmt.Sprint(chks)))
+	h.log.Debug("Checks retrieved", zap.String("checks", fmt.Sprint(chks)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, h.newChecksResponse(ctx, chks, h.LabelService, filter, *opts)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -282,9 +282,9 @@ func (h *CheckHandler) handleGetCheckQuery(w http.ResponseWriter, r *http.Reques
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("check query retrieved", zap.String("check query", flux))
+	h.log.Debug("Check query retrieved", zap.String("check query", flux))
 	if err := encodeResponse(ctx, w, http.StatusOK, newFluxResponse(flux)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -311,7 +311,7 @@ func (h *CheckHandler) handleGetCheck(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("check retrieved", zap.String("check", fmt.Sprint(chk)))
+	h.log.Debug("Check retrieved", zap.String("check", fmt.Sprint(chk)))
 
 	labels, err := h.LabelService.FindResourceLabels(ctx, influxdb.LabelMappingFilter{ResourceID: chk.GetID()})
 	if err != nil {
@@ -326,7 +326,7 @@ func (h *CheckHandler) handleGetCheck(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, cr); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -516,7 +516,7 @@ func (h *CheckHandler) handlePostCheck(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	chk, err := decodePostCheckRequest(ctx, r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -531,7 +531,7 @@ func (h *CheckHandler) handlePostCheck(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("check created", zap.String("check", fmt.Sprint(chk)))
+	h.log.Debug("Check created", zap.String("check", fmt.Sprint(chk)))
 
 	labels := h.mapNewCheckLabels(ctx, chk.CheckCreate, chk.Labels)
 
@@ -542,7 +542,7 @@ func (h *CheckHandler) handlePostCheck(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, cr); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -584,7 +584,7 @@ func (h *CheckHandler) handlePutCheck(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	chk, err := decodePutCheckRequest(ctx, r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -600,7 +600,7 @@ func (h *CheckHandler) handlePutCheck(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("check replaced", zap.String("check", fmt.Sprint(c)))
+	h.log.Debug("Check replaced", zap.String("check", fmt.Sprint(c)))
 
 	cr, err := h.newCheckResponse(ctx, c, labels)
 	if err != nil {
@@ -609,7 +609,7 @@ func (h *CheckHandler) handlePutCheck(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, cr); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -619,7 +619,7 @@ func (h *CheckHandler) handlePatchCheck(w http.ResponseWriter, r *http.Request)
 	ctx := r.Context()
 	req, err := decodePatchCheckRequest(ctx, r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -635,7 +635,7 @@ func (h *CheckHandler) handlePatchCheck(w http.ResponseWriter, r *http.Request)
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("check patch", zap.String("check", fmt.Sprint(chk)))
+	h.log.Debug("Check patch", zap.String("check", fmt.Sprint(chk)))
 
 	cr, err := h.newCheckResponse(ctx, chk, labels)
 	if err != nil {
@@ -644,7 +644,7 @@ func (h *CheckHandler) handlePatchCheck(w http.ResponseWriter, r *http.Request)
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, cr); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -661,7 +661,7 @@ func (h *CheckHandler) handleDeleteCheck(w http.ResponseWriter, r *http.Request)
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("check deleted", zap.String("checkID", fmt.Sprint(i)))
+	h.log.Debug("Check deleted", zap.String("checkID", fmt.Sprint(i)))
 
 	w.WriteHeader(http.StatusNoContent)
 }

http/check_test.go

@@ -13,19 +13,19 @@ import (
 	"github.com/influxdata/flux/parser"
 	pcontext "github.com/influxdata/influxdb/context"
 	"github.com/influxdata/influxdb/notification"
+	"go.uber.org/zap/zaptest"
 
+	"github.com/influxdata/httprouter"
 	"github.com/influxdata/influxdb"
 	"github.com/influxdata/influxdb/mock"
 	"github.com/influxdata/influxdb/notification/check"
 	influxTesting "github.com/influxdata/influxdb/testing"
-	"github.com/influxdata/httprouter"
-	"go.uber.org/zap"
 )
 
 // NewMockCheckBackend returns a CheckBackend with mock services.
-func NewMockCheckBackend() *CheckBackend {
+func NewMockCheckBackend(t *testing.T) *CheckBackend {
 	return &CheckBackend{
-		Logger: zap.NewNop().With(zap.String("handler", "check")),
+		log: zaptest.NewLogger(t),
 
 		CheckService:               mock.NewCheckService(),
 		UserResourceMappingService: mock.NewUserResourceMappingService(),
@@ -267,7 +267,7 @@ func TestService_handleGetChecks(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			checkBackend := NewMockCheckBackend()
+			checkBackend := NewMockCheckBackend(t)
 			checkBackend.CheckService = tt.fields.CheckService
 			checkBackend.LabelService = tt.fields.LabelService
 			checkBackend.TaskService = &mock.TaskService{
@@ -275,7 +275,7 @@ func TestService_handleGetChecks(t *testing.T) {
 					return &influxdb.Task{Status: "active"}, nil
 				},
 			}
-			h := NewCheckHandler(checkBackend)
+			h := NewCheckHandler(zaptest.NewLogger(t), checkBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -420,7 +420,7 @@ func TestService_handleGetCheckQuery(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			checkBackend := NewMockCheckBackend()
+			checkBackend := NewMockCheckBackend(t)
 			checkBackend.HTTPErrorHandler = ErrorHandler(0)
 			checkBackend.CheckService = tt.fields.CheckService
 			checkBackend.TaskService = &mock.TaskService{
@@ -428,7 +428,7 @@ func TestService_handleGetCheckQuery(t *testing.T) {
 					return &influxdb.Task{}, nil
 				},
 			}
-			h := NewCheckHandler(checkBackend)
+			h := NewCheckHandler(zaptest.NewLogger(t), checkBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -572,7 +572,7 @@ func TestService_handleGetCheck(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			checkBackend := NewMockCheckBackend()
+			checkBackend := NewMockCheckBackend(t)
 			checkBackend.HTTPErrorHandler = ErrorHandler(0)
 			checkBackend.CheckService = tt.fields.CheckService
 			checkBackend.TaskService = &mock.TaskService{
@@ -580,7 +580,7 @@ func TestService_handleGetCheck(t *testing.T) {
 					return &influxdb.Task{Status: "active"}, nil
 				},
 			}
-			h := NewCheckHandler(checkBackend)
+			h := NewCheckHandler(zaptest.NewLogger(t), checkBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -736,7 +736,7 @@ func TestService_handlePostCheck(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			checkBackend := NewMockCheckBackend()
+			checkBackend := NewMockCheckBackend(t)
 			checkBackend.CheckService = tt.fields.CheckService
 			checkBackend.OrganizationService = tt.fields.OrganizationService
 			checkBackend.TaskService = &mock.TaskService{
@@ -744,7 +744,7 @@ func TestService_handlePostCheck(t *testing.T) {
 					return &influxdb.Task{Status: "active"}, nil
 				},
 			}
-			h := NewCheckHandler(checkBackend)
+			h := NewCheckHandler(zaptest.NewLogger(t), checkBackend)
 
 			b, err := json.Marshal(tt.args.check)
 			if err != nil {
@@ -839,7 +839,7 @@ func TestService_handleDeleteCheck(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			checkBackend := NewMockCheckBackend()
+			checkBackend := NewMockCheckBackend(t)
 			checkBackend.HTTPErrorHandler = ErrorHandler(0)
 			checkBackend.CheckService = tt.fields.CheckService
 			checkBackend.TaskService = &mock.TaskService{
@@ -847,7 +847,7 @@ func TestService_handleDeleteCheck(t *testing.T) {
 					return &influxdb.Task{}, nil
 				},
 			}
-			h := NewCheckHandler(checkBackend)
+			h := NewCheckHandler(zaptest.NewLogger(t), checkBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -1002,7 +1002,7 @@ func TestService_handlePatchCheck(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			checkBackend := NewMockCheckBackend()
+			checkBackend := NewMockCheckBackend(t)
 			checkBackend.HTTPErrorHandler = ErrorHandler(0)
 			checkBackend.CheckService = tt.fields.CheckService
 			checkBackend.TaskService = &mock.TaskService{
@@ -1010,7 +1010,7 @@ func TestService_handlePatchCheck(t *testing.T) {
 					return &influxdb.Task{Status: "active"}, nil
 				},
 			}
-			h := NewCheckHandler(checkBackend)
+			h := NewCheckHandler(zaptest.NewLogger(t), checkBackend)
 
 			upd := influxdb.CheckUpdate{}
 			if tt.args.name != "" {
@@ -1189,7 +1189,7 @@ func TestService_handleUpdateCheck(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			checkBackend := NewMockCheckBackend()
+			checkBackend := NewMockCheckBackend(t)
 			checkBackend.HTTPErrorHandler = ErrorHandler(0)
 			checkBackend.CheckService = tt.fields.CheckService
 			checkBackend.TaskService = &mock.TaskService{
@@ -1197,7 +1197,7 @@ func TestService_handleUpdateCheck(t *testing.T) {
 					return &influxdb.Task{Status: "active"}, nil
 				},
 			}
-			h := NewCheckHandler(checkBackend)
+			h := NewCheckHandler(zaptest.NewLogger(t), checkBackend)
 
 			b, err := json.Marshal(tt.args.chk)
 			if err != nil {
@@ -1301,14 +1301,14 @@ func TestService_handlePostCheckMember(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			checkBackend := NewMockCheckBackend()
+			checkBackend := NewMockCheckBackend(t)
 			checkBackend.UserService = tt.fields.UserService
 			checkBackend.TaskService = &mock.TaskService{
 				FindTaskByIDFn: func(ctx context.Context, id influxdb.ID) (*influxdb.Task, error) {
 					return &influxdb.Task{}, nil
 				},
 			}
-			h := NewCheckHandler(checkBackend)
+			h := NewCheckHandler(zaptest.NewLogger(t), checkBackend)
 
 			b, err := json.Marshal(tt.args.user)
 			if err != nil {
@@ -1400,9 +1400,9 @@ func TestService_handlePostCheckOwner(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			checkBackend := NewMockCheckBackend()
+			checkBackend := NewMockCheckBackend(t)
 			checkBackend.UserService = tt.fields.UserService
-			h := NewCheckHandler(checkBackend)
+			h := NewCheckHandler(zaptest.NewLogger(t), checkBackend)
 
 			b, err := json.Marshal(tt.args.user)
 			if err != nil {

http/chronograf_handler.go

@@ -97,7 +97,7 @@ func NewChronografHandler(s *server.Service, he influxdb.HTTPErrorHandler) *Chro
 
 	allRoutes := &server.AllRoutes{
 		// TODO(desa): what to do here
-		//Logger:      opts.Logger,
+		//logger:      opts.logger,
 		//CustomLinks: opts.CustomLinks,
 		StatusFeed: "https://www.influxdata.com/feed/json",
 	}

http/dashboard_service.go

@@ -17,7 +17,7 @@ import (
 // the DashboardHandler.
 type DashboardBackend struct {
 	platform.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	DashboardService             platform.DashboardService
 	DashboardOperationLogService platform.DashboardOperationLogService
@@ -27,10 +27,10 @@ type DashboardBackend struct {
 }
 
 // NewDashboardBackend creates a backend used by the dashboard handler.
-func NewDashboardBackend(b *APIBackend) *DashboardBackend {
+func NewDashboardBackend(log *zap.Logger, b *APIBackend) *DashboardBackend {
 	return &DashboardBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "dashboard")),
+		log:              log,
 
 		DashboardService:             b.DashboardService,
 		DashboardOperationLogService: b.DashboardOperationLogService,
@@ -45,7 +45,7 @@ type DashboardHandler struct {
 	*httprouter.Router
 
 	platform.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	DashboardService             platform.DashboardService
 	DashboardOperationLogService platform.DashboardOperationLogService
@@ -70,11 +70,11 @@ const (
 )
 
 // NewDashboardHandler returns a new instance of DashboardHandler.
-func NewDashboardHandler(b *DashboardBackend) *DashboardHandler {
+func NewDashboardHandler(log *zap.Logger, b *DashboardBackend) *DashboardHandler {
 	h := &DashboardHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger,
+		log:              log,
 
 		DashboardService:             b.DashboardService,
 		DashboardOperationLogService: b.DashboardOperationLogService,
@@ -100,7 +100,7 @@ func NewDashboardHandler(b *DashboardBackend) *DashboardHandler {
 
 	memberBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               platform.DashboardsResourceType,
 		UserType:                   platform.Member,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -112,7 +112,7 @@ func NewDashboardHandler(b *DashboardBackend) *DashboardHandler {
 
 	ownerBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               platform.DashboardsResourceType,
 		UserType:                   platform.Owner,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -124,7 +124,7 @@ func NewDashboardHandler(b *DashboardBackend) *DashboardHandler {
 
 	labelBackend := &LabelBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "label")),
+		log:              b.log.With(zap.String("handler", "label")),
 		LabelService:     b.LabelService,
 		ResourceType:     platform.DashboardsResourceType,
 	}
@@ -376,10 +376,10 @@ func (h *DashboardHandler) handleGetDashboards(w http.ResponseWriter, r *http.Re
 		return
 	}
 
-	h.Logger.Debug("dashboards retrieved", zap.String("dashboards", fmt.Sprint(dashboards)))
+	h.log.Debug("Dashboards retrieved", zap.String("dashboards", fmt.Sprint(dashboards)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newGetDashboardsResponse(ctx, dashboards, req.filter, req.opts, h.LabelService)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -472,7 +472,7 @@ func (h *DashboardHandler) handlePostDashboard(w http.ResponseWriter, r *http.Re
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, newDashboardResponse(pd, []*platform.Label{})); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -597,10 +597,10 @@ func (h *DashboardHandler) handleGetDashboard(w http.ResponseWriter, r *http.Req
 		return
 	}
 
-	h.Logger.Debug("dashboard retrieved", zap.String("dashboard", fmt.Sprint(dashboard)))
+	h.log.Debug("Dashboard retrieved", zap.String("dashboard", fmt.Sprint(dashboard)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newDashboardResponse(dashboard, labels)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -644,10 +644,10 @@ func (h *DashboardHandler) handleGetDashboardLog(w http.ResponseWriter, r *http.
 		return
 	}
 
-	h.Logger.Debug("dashboard log retrieved", zap.String("log", fmt.Sprint(log)))
+	h.log.Debug("Dashboard log retrieved", zap.String("log", fmt.Sprint(log)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newDashboardLogResponse(req.DashboardID, log)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -697,7 +697,7 @@ func (h *DashboardHandler) handleDeleteDashboard(w http.ResponseWriter, r *http.
 		return
 	}
 
-	h.Logger.Debug("dashboard deleted", zap.String("dashboardID", req.DashboardID.String()))
+	h.log.Debug("Dashboard deleted", zap.String("dashboardID", req.DashboardID.String()))
 
 	w.WriteHeader(http.StatusNoContent)
 }
@@ -746,10 +746,10 @@ func (h *DashboardHandler) handlePatchDashboard(w http.ResponseWriter, r *http.R
 		return
 	}
 
-	h.Logger.Debug("dashboard updated", zap.String("dashboard", fmt.Sprint(dashboard)))
+	h.log.Debug("Dashboard updated", zap.String("dashboard", fmt.Sprint(dashboard)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newDashboardResponse(dashboard, labels)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -884,10 +884,10 @@ func (h *DashboardHandler) handlePostDashboardCell(w http.ResponseWriter, r *htt
 		return
 	}
 
-	h.Logger.Debug("dashboard cell created", zap.String("dashboardID", req.dashboardID.String()), zap.String("cell", fmt.Sprint(cell)))
+	h.log.Debug("Dashboard cell created", zap.String("dashboardID", req.dashboardID.String()), zap.String("cell", fmt.Sprint(cell)))
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, newDashboardCellResponse(req.dashboardID, cell)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -934,10 +934,10 @@ func (h *DashboardHandler) handlePutDashboardCells(w http.ResponseWriter, r *htt
 		return
 	}
 
-	h.Logger.Debug("dashboard cell replaced", zap.String("dashboardID", req.dashboardID.String()), zap.String("cells", fmt.Sprint(req.cells)))
+	h.log.Debug("Dashboard cell replaced", zap.String("dashboardID", req.dashboardID.String()), zap.String("cells", fmt.Sprint(req.cells)))
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, newDashboardCellsResponse(req.dashboardID, req.cells)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -1018,10 +1018,10 @@ func (h *DashboardHandler) handleGetDashboardCellView(w http.ResponseWriter, r *
 		return
 	}
 
-	h.Logger.Debug("dashboard cell view retrieved", zap.String("dashboardID", req.dashboardID.String()), zap.String("cellID", req.cellID.String()), zap.String("view", fmt.Sprint(view)))
+	h.log.Debug("Dashboard cell view retrieved", zap.String("dashboardID", req.dashboardID.String()), zap.String("cellID", req.cellID.String()), zap.String("view", fmt.Sprint(view)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newDashboardCellViewResponse(req.dashboardID, req.cellID, view)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -1072,10 +1072,10 @@ func (h *DashboardHandler) handlePatchDashboardCellView(w http.ResponseWriter, r
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("dashboard cell view updated", zap.String("dashboardID", req.dashboardID.String()), zap.String("cellID", req.cellID.String()), zap.String("view", fmt.Sprint(view)))
+	h.log.Debug("Dashboard cell view updated", zap.String("dashboardID", req.dashboardID.String()), zap.String("cellID", req.cellID.String()), zap.String("view", fmt.Sprint(view)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newDashboardCellViewResponse(req.dashboardID, req.cellID, view)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -1092,7 +1092,7 @@ func (h *DashboardHandler) handleDeleteDashboardCell(w http.ResponseWriter, r *h
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("dashboard cell deleted", zap.String("dashboardID", req.dashboardID.String()), zap.String("cellID", req.cellID.String()))
+	h.log.Debug("Dashboard cell deleted", zap.String("dashboardID", req.dashboardID.String()), zap.String("cellID", req.cellID.String()))
 
 	w.WriteHeader(http.StatusNoContent)
 }
@@ -1157,10 +1157,10 @@ func (h *DashboardHandler) handlePatchDashboardCell(w http.ResponseWriter, r *ht
 		return
 	}
 
-	h.Logger.Debug("dashboard cell updated", zap.String("dashboardID", req.dashboardID.String()), zap.String("cell", fmt.Sprint(cell)))
+	h.log.Debug("Dashboard cell updated", zap.String("dashboardID", req.dashboardID.String()), zap.String("cell", fmt.Sprint(cell)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newDashboardCellResponse(req.dashboardID, cell)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }

http/dashboard_test.go

@@ -11,8 +11,6 @@ import (
 	"testing"
 	"time"
 
-	"go.uber.org/zap"
-
 	"github.com/google/go-cmp/cmp"
 	"github.com/influxdata/httprouter"
 	platform "github.com/influxdata/influxdb"
@@ -21,12 +19,13 @@ import (
 	platformtesting "github.com/influxdata/influxdb/testing"
 	"github.com/yudai/gojsondiff"
 	"github.com/yudai/gojsondiff/formatter"
+	"go.uber.org/zap/zaptest"
 )
 
 // NewMockDashboardBackend returns a DashboardBackend with mock services.
-func NewMockDashboardBackend() *DashboardBackend {
+func NewMockDashboardBackend(t *testing.T) *DashboardBackend {
 	return &DashboardBackend{
-		Logger: zap.NewNop().With(zap.String("handler", "dashboard")),
+		log: zaptest.NewLogger(t),
 
 		DashboardService:             mock.NewDashboardService(),
 		DashboardOperationLogService: mock.NewDashboardOperationLogService(),
@@ -331,11 +330,11 @@ func TestService_handleGetDashboards(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			dashboardBackend := NewMockDashboardBackend()
+			dashboardBackend := NewMockDashboardBackend(t)
 			dashboardBackend.HTTPErrorHandler = ErrorHandler(0)
 			dashboardBackend.LabelService = tt.fields.LabelService
 			dashboardBackend.DashboardService = tt.fields.DashboardService
-			h := NewDashboardHandler(dashboardBackend)
+			h := NewDashboardHandler(zaptest.NewLogger(t), dashboardBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -743,10 +742,10 @@ func TestService_handleGetDashboard(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			dashboardBackend := NewMockDashboardBackend()
+			dashboardBackend := NewMockDashboardBackend(t)
 			dashboardBackend.HTTPErrorHandler = ErrorHandler(0)
 			dashboardBackend.DashboardService = tt.fields.DashboardService
-			h := NewDashboardHandler(dashboardBackend)
+			h := NewDashboardHandler(zaptest.NewLogger(t), dashboardBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -1008,10 +1007,10 @@ func TestService_handlePostDashboard(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			dashboardBackend := NewMockDashboardBackend()
+			dashboardBackend := NewMockDashboardBackend(t)
 			dashboardBackend.HTTPErrorHandler = ErrorHandler(0)
 			dashboardBackend.DashboardService = tt.fields.DashboardService
-			h := NewDashboardHandler(dashboardBackend)
+			h := NewDashboardHandler(zaptest.NewLogger(t), dashboardBackend)
 
 			b, err := json.Marshal(tt.args.dashboard)
 			if err != nil {
@@ -1104,10 +1103,10 @@ func TestService_handleDeleteDashboard(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			dashboardBackend := NewMockDashboardBackend()
+			dashboardBackend := NewMockDashboardBackend(t)
 			dashboardBackend.HTTPErrorHandler = ErrorHandler(0)
 			dashboardBackend.DashboardService = tt.fields.DashboardService
-			h := NewDashboardHandler(dashboardBackend)
+			h := NewDashboardHandler(zaptest.NewLogger(t), dashboardBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -1288,10 +1287,10 @@ func TestService_handlePatchDashboard(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			dashboardBackend := NewMockDashboardBackend()
+			dashboardBackend := NewMockDashboardBackend(t)
 			dashboardBackend.HTTPErrorHandler = ErrorHandler(0)
 			dashboardBackend.DashboardService = tt.fields.DashboardService
-			h := NewDashboardHandler(dashboardBackend)
+			h := NewDashboardHandler(zaptest.NewLogger(t), dashboardBackend)
 
 			upd := platform.DashboardUpdate{}
 			if tt.args.name != "" {
@@ -1469,10 +1468,10 @@ func TestService_handlePostDashboardCell(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			dashboardBackend := NewMockDashboardBackend()
+			dashboardBackend := NewMockDashboardBackend(t)
 			dashboardBackend.HTTPErrorHandler = ErrorHandler(0)
 			dashboardBackend.DashboardService = tt.fields.DashboardService
-			h := NewDashboardHandler(dashboardBackend)
+			h := NewDashboardHandler(zaptest.NewLogger(t), dashboardBackend)
 			buf := new(bytes.Buffer)
 			_, _ = buf.WriteString(tt.args.body)
 			r := httptest.NewRequest("POST", "http://any.url", buf)
@@ -1553,10 +1552,10 @@ func TestService_handleDeleteDashboardCell(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			dashboardBackend := NewMockDashboardBackend()
+			dashboardBackend := NewMockDashboardBackend(t)
 			dashboardBackend.HTTPErrorHandler = ErrorHandler(0)
 			dashboardBackend.DashboardService = tt.fields.DashboardService
-			h := NewDashboardHandler(dashboardBackend)
+			h := NewDashboardHandler(zaptest.NewLogger(t), dashboardBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -1668,10 +1667,10 @@ func TestService_handlePatchDashboardCell(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			dashboardBackend := NewMockDashboardBackend()
+			dashboardBackend := NewMockDashboardBackend(t)
 			dashboardBackend.HTTPErrorHandler = ErrorHandler(0)
 			dashboardBackend.DashboardService = tt.fields.DashboardService
-			h := NewDashboardHandler(dashboardBackend)
+			h := NewDashboardHandler(zaptest.NewLogger(t), dashboardBackend)
 
 			upd := platform.CellUpdate{}
 			if tt.args.x != 0 {
@@ -1763,10 +1762,10 @@ func initDashboardService(f platformtesting.DashboardFields, t *testing.T) (plat
 		}
 	}
 
-	dashboardBackend := NewMockDashboardBackend()
+	dashboardBackend := NewMockDashboardBackend(t)
 	dashboardBackend.HTTPErrorHandler = ErrorHandler(0)
 	dashboardBackend.DashboardService = svc
-	h := NewDashboardHandler(dashboardBackend)
+	h := NewDashboardHandler(zaptest.NewLogger(t), dashboardBackend)
 	server := httptest.NewServer(h)
 	client := DashboardService{
 		Addr:     server.URL,
@@ -1848,10 +1847,10 @@ func TestService_handlePostDashboardLabel(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			dashboardBackend := NewMockDashboardBackend()
+			dashboardBackend := NewMockDashboardBackend(t)
 			dashboardBackend.HTTPErrorHandler = ErrorHandler(0)
 			dashboardBackend.LabelService = tt.fields.LabelService
-			h := NewDashboardHandler(dashboardBackend)
+			h := NewDashboardHandler(zaptest.NewLogger(t), dashboardBackend)
 
 			b, err := json.Marshal(tt.args.labelMapping)
 			if err != nil {

http/delete_handler.go

@@ -19,7 +19,7 @@ import (
 // DeleteBackend is all services and associated parameters required to construct
 // the DeleteHandler.
 type DeleteBackend struct {
-	Logger *zap.Logger
+	log *zap.Logger
 	influxdb.HTTPErrorHandler
 
 	DeleteService       influxdb.DeleteService
@@ -28,9 +28,9 @@ type DeleteBackend struct {
 }
 
 // NewDeleteBackend returns a new instance of DeleteBackend
-func NewDeleteBackend(b *APIBackend) *DeleteBackend {
+func NewDeleteBackend(log *zap.Logger, b *APIBackend) *DeleteBackend {
 	return &DeleteBackend{
-		Logger: b.Logger.With(zap.String("handler", "delete")),
+		log: log,
 
 		HTTPErrorHandler:    b.HTTPErrorHandler,
 		DeleteService:       b.DeleteService,
@@ -44,7 +44,7 @@ type DeleteHandler struct {
 	influxdb.HTTPErrorHandler
 	*httprouter.Router
 
-	Logger *zap.Logger
+	log *zap.Logger
 
 	DeleteService       influxdb.DeleteService
 	BucketService       influxdb.BucketService
@@ -56,11 +56,11 @@ const (
 )
 
 // NewDeleteHandler creates a new handler at /api/v2/delete to recieve delete requests.
-func NewDeleteHandler(b *DeleteBackend) *DeleteHandler {
+func NewDeleteHandler(log *zap.Logger, b *DeleteBackend) *DeleteHandler {
 	h := &DeleteHandler{
 		HTTPErrorHandler: b.HTTPErrorHandler,
 		Router:           NewRouter(b.HTTPErrorHandler),
-		Logger:           b.Logger,
+		log:              log,
 
 		BucketService:       b.BucketService,
 		DeleteService:       b.DeleteService,
@@ -126,7 +126,7 @@ func (h *DeleteHandler) handleDelete(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("deleted",
+	h.log.Debug("Deleted",
 		zap.String("orgID", fmt.Sprint(dr.Org.ID.String())),
 		zap.String("buketID", fmt.Sprint(dr.Bucket.ID.String())),
 	)

http/delete_test.go

@@ -12,13 +12,13 @@ import (
 	pcontext "github.com/influxdata/influxdb/context"
 	"github.com/influxdata/influxdb/mock"
 	influxtesting "github.com/influxdata/influxdb/testing"
-	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest"
 )
 
 // NewMockDeleteBackend returns a DeleteBackend with mock services.
-func NewMockDeleteBackend() *DeleteBackend {
+func NewMockDeleteBackend(t *testing.T) *DeleteBackend {
 	return &DeleteBackend{
-		Logger: zap.NewNop().With(zap.String("handler", "delete")),
+		log: zaptest.NewLogger(t),
 
 		DeleteService:       mock.NewDeleteService(),
 		BucketService:       mock.NewBucketService(),
@@ -337,12 +337,12 @@ func TestDelete(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			deleteBackend := NewMockDeleteBackend()
+			deleteBackend := NewMockDeleteBackend(t)
 			deleteBackend.HTTPErrorHandler = ErrorHandler(0)
 			deleteBackend.DeleteService = tt.fields.DeleteService
 			deleteBackend.OrganizationService = tt.fields.OrganizationService
 			deleteBackend.BucketService = tt.fields.BucketService
-			h := NewDeleteHandler(deleteBackend)
+			h := NewDeleteHandler(zaptest.NewLogger(t), deleteBackend)
 
 			r := httptest.NewRequest("POST", "http://any.tld", bytes.NewReader(tt.args.body))
 

http/document_service.go

@@ -15,7 +15,7 @@ import (
 // DocumentBackend is all services and associated parameters required to construct
 // the DocumentHandler.
 type DocumentBackend struct {
-	Logger *zap.Logger
+	log *zap.Logger
 	influxdb.HTTPErrorHandler
 
 	DocumentService influxdb.DocumentService
@@ -23,10 +23,10 @@ type DocumentBackend struct {
 }
 
 // NewDocumentBackend returns a new instance of DocumentBackend.
-func NewDocumentBackend(b *APIBackend) *DocumentBackend {
+func NewDocumentBackend(log *zap.Logger, b *APIBackend) *DocumentBackend {
 	return &DocumentBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "document")),
+		log:              log,
 		DocumentService:  b.DocumentService,
 		LabelService:     b.LabelService,
 	}
@@ -36,7 +36,7 @@ func NewDocumentBackend(b *APIBackend) *DocumentBackend {
 type DocumentHandler struct {
 	*httprouter.Router
 
-	Logger *zap.Logger
+	log *zap.Logger
 	influxdb.HTTPErrorHandler
 
 	DocumentService influxdb.DocumentService
@@ -56,7 +56,7 @@ func NewDocumentHandler(b *DocumentBackend) *DocumentHandler {
 	h := &DocumentHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger,
+		log:              b.log,
 
 		DocumentService: b.DocumentService,
 		LabelService:    b.LabelService,
@@ -143,10 +143,10 @@ func (h *DocumentHandler) handlePostDocument(w http.ResponseWriter, r *http.Requ
 		return
 	}
 
-	h.Logger.Debug("document created", zap.String("document", fmt.Sprint(req.Document)))
+	h.log.Debug("Document created", zap.String("document", fmt.Sprint(req.Document)))
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, newDocumentResponse(req.Namespace, req.Document)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -229,10 +229,10 @@ func (h *DocumentHandler) handleGetDocuments(w http.ResponseWriter, r *http.Requ
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("documents retrieved", zap.String("documents", fmt.Sprint(ds)))
+	h.log.Debug("Documents retrieved", zap.String("documents", fmt.Sprint(ds)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newDocumentsResponse(req.Namespace, ds)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -301,10 +301,10 @@ func (h *DocumentHandler) handlePostDocumentLabel(w http.ResponseWriter, r *http
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("document label created", zap.String("label", fmt.Sprint(label)))
+	h.log.Debug("Document label created", zap.String("label", fmt.Sprint(label)))
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, newLabelResponse(label)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -341,7 +341,7 @@ func (h *DocumentHandler) handleDeleteDocumentLabel(w http.ResponseWriter, r *ht
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("document label deleted", zap.String("mapping", fmt.Sprint(mapping)))
+	h.log.Debug("Document label deleted", zap.String("mapping", fmt.Sprint(mapping)))
 
 	w.WriteHeader(http.StatusNoContent)
 }
@@ -353,10 +353,10 @@ func (h *DocumentHandler) handleGetDocumentLabel(w http.ResponseWriter, r *http.
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("document label retrieved", zap.String("labels", fmt.Sprint(d.Labels)))
+	h.log.Debug("Document label retrieved", zap.String("labels", fmt.Sprint(d.Labels)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newLabelsResponse(d.Labels)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -399,10 +399,10 @@ func (h *DocumentHandler) handleGetDocument(w http.ResponseWriter, r *http.Reque
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("document retrieved", zap.String("document", fmt.Sprint(d)))
+	h.log.Debug("Document retrieved", zap.String("document", fmt.Sprint(d)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newDocumentResponse(namspace, d)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -470,7 +470,7 @@ func (h *DocumentHandler) handleDeleteDocument(w http.ResponseWriter, r *http.Re
 		return
 	}
 
-	h.Logger.Debug("document deleted", zap.String("documentID", fmt.Sprint(req.ID)))
+	h.log.Debug("Document deleted", zap.String("documentID", fmt.Sprint(req.ID)))
 
 	w.WriteHeader(http.StatusNoContent)
 }
@@ -555,10 +555,10 @@ func (h *DocumentHandler) handlePutDocument(w http.ResponseWriter, r *http.Reque
 
 	d := ds[0]
 
-	h.Logger.Debug("document updated", zap.String("document", fmt.Sprint(d)))
+	h.log.Debug("Document updated", zap.String("document", fmt.Sprint(d)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newDocumentResponse(req.Namespace, d)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }

http/document_test.go

@@ -10,12 +10,12 @@ import (
 	"testing"
 	"time"
 
+	"github.com/influxdata/httprouter"
 	"github.com/influxdata/influxdb"
 	pcontext "github.com/influxdata/influxdb/context"
 	"github.com/influxdata/influxdb/mock"
 	influxtesting "github.com/influxdata/influxdb/testing"
-	"github.com/influxdata/httprouter"
-	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest"
 )
 
 var (
@@ -180,9 +180,9 @@ var (
 )
 
 // NewMockDocumentBackend returns a DocumentBackend with mock services.
-func NewMockDocumentBackend() *DocumentBackend {
+func NewMockDocumentBackend(t *testing.T) *DocumentBackend {
 	return &DocumentBackend{
-		Logger: zap.NewNop().With(zap.String("handler", "document")),
+		log: zaptest.NewLogger(t),
 
 		DocumentService: mock.NewDocumentService(),
 		LabelService:    mock.NewLabelService(),
@@ -290,7 +290,7 @@ func TestService_handleDeleteDocumentLabel(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			documentBackend := NewMockDocumentBackend()
+			documentBackend := NewMockDocumentBackend(t)
 			documentBackend.HTTPErrorHandler = ErrorHandler(0)
 			documentBackend.DocumentService = tt.fields.DocumentService
 			documentBackend.LabelService = tt.fields.LabelService
@@ -476,7 +476,7 @@ func TestService_handlePostDocumentLabel(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			documentBackend := NewMockDocumentBackend()
+			documentBackend := NewMockDocumentBackend(t)
 			documentBackend.HTTPErrorHandler = ErrorHandler(0)
 			documentBackend.DocumentService = tt.fields.DocumentService
 			documentBackend.LabelService = tt.fields.LabelService
@@ -581,7 +581,7 @@ func TestService_handleGetDocumentLabels(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			documentBackend := NewMockDocumentBackend()
+			documentBackend := NewMockDocumentBackend(t)
 			documentBackend.HTTPErrorHandler = ErrorHandler(0)
 			documentBackend.DocumentService = tt.fields.DocumentService
 			documentBackend.LabelService = tt.fields.LabelService
@@ -705,7 +705,7 @@ func TestService_handleGetDocuments(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			documentBackend := NewMockDocumentBackend()
+			documentBackend := NewMockDocumentBackend(t)
 			documentBackend.HTTPErrorHandler = ErrorHandler(0)
 			documentBackend.DocumentService = tt.fields.DocumentService
 			h := NewDocumentHandler(documentBackend)
@@ -905,7 +905,7 @@ func TestService_handlePostDocuments(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			documentBackend := NewMockDocumentBackend()
+			documentBackend := NewMockDocumentBackend(t)
 			documentBackend.HTTPErrorHandler = ErrorHandler(0)
 			documentBackend.DocumentService = tt.fields.DocumentService
 			documentBackend.LabelService = tt.fields.LabelService

http/handler.go

@@ -45,8 +45,8 @@ type Handler struct {
 	requests   *prometheus.CounterVec
 	requestDur *prometheus.HistogramVec
 
-	// Logger if set will log all HTTP requests as they are served
-	Logger *zap.Logger
+	// log logs all HTTP requests as they are served
+	log *zap.Logger
 }
 
 // NewHandler creates a new handler with the given name.
@@ -68,13 +68,14 @@ func NewHandler(name string) *Handler {
 // NewHandlerFromRegistry creates a new handler with the given name,
 // and sets the /metrics endpoint to use the metrics from the given registry,
 // after self-registering h's metrics.
-func NewHandlerFromRegistry(name string, reg *prom.Registry) *Handler {
+func NewHandlerFromRegistry(log *zap.Logger, name string, reg *prom.Registry) *Handler {
 	h := &Handler{
 		name:           name,
 		MetricsHandler: reg.HTTPHandler(),
 		ReadyHandler:   http.HandlerFunc(ReadyHandler),
 		HealthHandler:  http.HandlerFunc(HealthHandler),
 		DebugHandler:   http.DefaultServeMux,
+		log:            log,
 	}
 	h.initMetrics()
 	reg.MustRegister(h.PrometheusCollectors()...)
@@ -169,11 +170,11 @@ func (h *Handler) initMetrics() {
 	}, []string{"handler", "method", "path", "status", "user_agent"})
 }
 
-func logEncodingError(logger *zap.Logger, r *http.Request, err error) {
+func logEncodingError(log *zap.Logger, r *http.Request, err error) {
 	// If we encounter an error while encoding the response to an http request
 	// the best thing we can do is log that error, as we may have already written
 	// the headers for the http request in question.
-	logger.Info("error encoding response",
+	log.Info("Error encoding response",
 		zap.String("path", r.URL.Path),
 		zap.String("method", r.Method),
 		zap.Error(err))

http/handler_test.go

@@ -9,13 +9,14 @@ import (
 	"github.com/influxdata/influxdb/kit/prom"
 	"github.com/influxdata/influxdb/kit/prom/promtest"
 	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest"
 )
 
 func TestHandler_ServeHTTP(t *testing.T) {
 	type fields struct {
 		name    string
-		Handler http.Handler
-		Logger  *zap.Logger
+		handler http.Handler
+		log     *zap.Logger
 	}
 	type args struct {
 		w *httptest.ResponseRecorder
@@ -30,8 +31,8 @@ func TestHandler_ServeHTTP(t *testing.T) {
 			name: "should record metrics when http handling",
 			fields: fields{
 				name:    "test",
-				Handler: http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}),
-				Logger:  zap.NewNop(),
+				handler: http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}),
+				log:     zaptest.NewLogger(t),
 			},
 			args: args{
 				r: httptest.NewRequest(http.MethodGet, "/", nil),
@@ -43,11 +44,11 @@ func TestHandler_ServeHTTP(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			h := &Handler{
 				name:    tt.fields.name,
-				Handler: tt.fields.Handler,
-				Logger:  tt.fields.Logger,
+				Handler: tt.fields.handler,
+				log:     tt.fields.log,
 			}
 			h.initMetrics()
-			reg := prom.NewRegistry()
+			reg := prom.NewRegistry(zaptest.NewLogger(t))
 			reg.MustRegister(h.PrometheusCollectors()...)
 
 			tt.args.r.Header.Set("User-Agent", "ua1")

http/label_service.go

@@ -19,7 +19,7 @@ import (
 type LabelHandler struct {
 	*httprouter.Router
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	LabelService influxdb.LabelService
 }
@@ -30,11 +30,11 @@ const (
 )
 
 // NewLabelHandler returns a new instance of LabelHandler
-func NewLabelHandler(s influxdb.LabelService, he influxdb.HTTPErrorHandler) *LabelHandler {
+func NewLabelHandler(log *zap.Logger, s influxdb.LabelService, he influxdb.HTTPErrorHandler) *LabelHandler {
 	h := &LabelHandler{
 		Router:           NewRouter(he),
 		HTTPErrorHandler: he,
-		Logger:           zap.NewNop(),
+		log:              log,
 		LabelService:     s,
 	}
 
@@ -61,9 +61,9 @@ func (h *LabelHandler) handlePostLabel(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("label created", zap.String("label", fmt.Sprint(req.Label)))
+	h.log.Debug("Label created", zap.String("label", fmt.Sprint(req.Label)))
 	if err := encodeResponse(ctx, w, http.StatusCreated, newLabelResponse(req.Label)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -120,7 +120,7 @@ func (h *LabelHandler) handleGetLabels(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("labels retrived", zap.String("labels", fmt.Sprint(labels)))
+	h.log.Debug("Labels retrived", zap.String("labels", fmt.Sprint(labels)))
 	err = encodeResponse(ctx, w, http.StatusOK, newLabelsResponse(labels))
 	if err != nil {
 		h.HandleHTTPError(ctx, err, w)
@@ -164,9 +164,9 @@ func (h *LabelHandler) handleGetLabel(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("label retrieved", zap.String("label", fmt.Sprint(l)))
+	h.log.Debug("Label retrieved", zap.String("label", fmt.Sprint(l)))
 	if err := encodeResponse(ctx, w, http.StatusOK, newLabelResponse(l)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -209,7 +209,7 @@ func (h *LabelHandler) handleDeleteLabel(w http.ResponseWriter, r *http.Request)
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("label deleted", zap.String("labelID", fmt.Sprint(req.LabelID)))
+	h.log.Debug("Label deleted", zap.String("labelID", fmt.Sprint(req.LabelID)))
 	w.WriteHeader(http.StatusNoContent)
 }
 
@@ -252,9 +252,9 @@ func (h *LabelHandler) handlePatchLabel(w http.ResponseWriter, r *http.Request)
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("label updated", zap.String("label", fmt.Sprint(l)))
+	h.log.Debug("Label updated", zap.String("label", fmt.Sprint(l)))
 	if err := encodeResponse(ctx, w, http.StatusOK, newLabelResponse(l)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -330,7 +330,7 @@ func newLabelsResponse(ls []*influxdb.Label) *labelsResponse {
 // LabelBackend is all services and associated parameters required to construct
 // label handlers.
 type LabelBackend struct {
-	Logger *zap.Logger
+	log *zap.Logger
 	influxdb.HTTPErrorHandler
 	LabelService influxdb.LabelService
 	ResourceType influxdb.ResourceType
@@ -354,7 +354,7 @@ func newGetLabelsHandler(b *LabelBackend) http.HandlerFunc {
 		}
 
 		if err := encodeResponse(ctx, w, http.StatusOK, newLabelsResponse(labels)); err != nil {
-			logEncodingError(b.Logger, r, err)
+			logEncodingError(b.log, r, err)
 			return
 		}
 	}
@@ -414,7 +414,7 @@ func newPostLabelHandler(b *LabelBackend) http.HandlerFunc {
 		}
 
 		if err := encodeResponse(ctx, w, http.StatusCreated, newLabelResponse(label)); err != nil {
-			logEncodingError(b.Logger, r, err)
+			logEncodingError(b.log, r, err)
 			return
 		}
 	}

http/label_test.go

@@ -6,14 +6,15 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
-	http "net/http"
+	"net/http"
 	"net/http/httptest"
 	"testing"
 
+	"github.com/influxdata/httprouter"
 	platform "github.com/influxdata/influxdb"
 	"github.com/influxdata/influxdb/mock"
 	platformtesting "github.com/influxdata/influxdb/testing"
-	"github.com/influxdata/httprouter"
+	"go.uber.org/zap/zaptest"
 )
 
 func TestService_handleGetLabels(t *testing.T) {
@@ -108,7 +109,7 @@ func TestService_handleGetLabels(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			h := NewLabelHandler(tt.fields.LabelService, ErrorHandler(0))
+			h := NewLabelHandler(zaptest.NewLogger(t), tt.fields.LabelService, ErrorHandler(0))
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -216,7 +217,7 @@ func TestService_handleGetLabel(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			h := NewLabelHandler(tt.fields.LabelService, ErrorHandler(0))
+			h := NewLabelHandler(zaptest.NewLogger(t), tt.fields.LabelService, ErrorHandler(0))
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -311,7 +312,7 @@ func TestService_handlePostLabel(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			h := NewLabelHandler(tt.fields.LabelService, ErrorHandler(0))
+			h := NewLabelHandler(zaptest.NewLogger(t), tt.fields.LabelService, ErrorHandler(0))
 
 			l, err := json.Marshal(tt.args.label)
 			if err != nil {
@@ -402,7 +403,7 @@ func TestService_handleDeleteLabel(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			h := NewLabelHandler(tt.fields.LabelService, ErrorHandler(0))
+			h := NewLabelHandler(zaptest.NewLogger(t), tt.fields.LabelService, ErrorHandler(0))
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -541,7 +542,7 @@ func TestService_handlePatchLabel(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			h := NewLabelHandler(tt.fields.LabelService, ErrorHandler(0))
+			h := NewLabelHandler(zaptest.NewLogger(t), tt.fields.LabelService, ErrorHandler(0))
 
 			upd := platform.LabelUpdate{}
 			if len(tt.args.properties) > 0 {

http/middleware.go

@@ -16,7 +16,7 @@ import (
 type Middleware func(http.Handler) http.Handler
 
 // LoggingMW middleware for logging inflight http requests.
-func LoggingMW(logger *zap.Logger) Middleware {
+func LoggingMW(log *zap.Logger) Middleware {
 	return func(next http.Handler) http.Handler {
 		fn := func(w http.ResponseWriter, r *http.Request) {
 			srw := &statusResponseWriter{
@@ -62,7 +62,7 @@ func LoggingMW(logger *zap.Logger) Middleware {
 					fields = append(fields, zap.ByteString("body", buf.Bytes()))
 				}
 
-				logger.Debug("Request", fields...)
+				log.Debug("Request", fields...)
 			}(time.Now())
 
 			next.ServeHTTP(srw, r)

http/notification_endpoint.go

@@ -18,7 +18,7 @@ import (
 // the NotificationEndpointBackendHandler.
 type NotificationEndpointBackend struct {
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	NotificationEndpointService influxdb.NotificationEndpointService
 	UserResourceMappingService  influxdb.UserResourceMappingService
@@ -29,10 +29,10 @@ type NotificationEndpointBackend struct {
 }
 
 // NewNotificationEndpointBackend returns a new instance of NotificationEndpointBackend.
-func NewNotificationEndpointBackend(b *APIBackend) *NotificationEndpointBackend {
+func NewNotificationEndpointBackend(log *zap.Logger, b *APIBackend) *NotificationEndpointBackend {
 	return &NotificationEndpointBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "notificationEndpoint")),
+		log:              log,
 
 		NotificationEndpointService: b.NotificationEndpointService,
 		UserResourceMappingService:  b.UserResourceMappingService,
@@ -43,11 +43,15 @@ func NewNotificationEndpointBackend(b *APIBackend) *NotificationEndpointBackend
 	}
 }
 
+func (b *NotificationEndpointBackend) Logger() *zap.Logger {
+	return b.log
+}
+
 // NotificationEndpointHandler is the handler for the notificationEndpoint service
 type NotificationEndpointHandler struct {
 	*httprouter.Router
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	NotificationEndpointService influxdb.NotificationEndpointService
 	UserResourceMappingService  influxdb.UserResourceMappingService
@@ -69,11 +73,11 @@ const (
 )
 
 // NewNotificationEndpointHandler returns a new instance of NotificationEndpointHandler.
-func NewNotificationEndpointHandler(b *NotificationEndpointBackend) *NotificationEndpointHandler {
+func NewNotificationEndpointHandler(log *zap.Logger, b *NotificationEndpointBackend) *NotificationEndpointHandler {
 	h := &NotificationEndpointHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger,
+		log:              log,
 
 		NotificationEndpointService: b.NotificationEndpointService,
 		UserResourceMappingService:  b.UserResourceMappingService,
@@ -91,7 +95,7 @@ func NewNotificationEndpointHandler(b *NotificationEndpointBackend) *Notificatio
 
 	memberBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               influxdb.NotificationEndpointResourceType,
 		UserType:                   influxdb.Member,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -103,7 +107,7 @@ func NewNotificationEndpointHandler(b *NotificationEndpointBackend) *Notificatio
 
 	ownerBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               influxdb.NotificationEndpointResourceType,
 		UserType:                   influxdb.Owner,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -115,7 +119,7 @@ func NewNotificationEndpointHandler(b *NotificationEndpointBackend) *Notificatio
 
 	labelBackend := &LabelBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "label")),
+		log:              b.log.With(zap.String("handler", "label")),
 		LabelService:     b.LabelService,
 		ResourceType:     influxdb.TelegrafsResourceType,
 	}
@@ -220,7 +224,7 @@ func (h *NotificationEndpointHandler) handleGetNotificationEndpoints(w http.Resp
 	ctx := r.Context()
 	filter, opts, err := decodeNotificationEndpointFilter(ctx, r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -229,10 +233,10 @@ func (h *NotificationEndpointHandler) handleGetNotificationEndpoints(w http.Resp
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("notificationEndpoints retrieved", zap.String("notificationEndpoints", fmt.Sprint(edps)))
+	h.log.Debug("NotificationEndpoints retrieved", zap.String("notificationEndpoints", fmt.Sprint(edps)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newNotificationEndpointsResponse(ctx, edps, h.LabelService, filter, *opts)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -249,7 +253,7 @@ func (h *NotificationEndpointHandler) handleGetNotificationEndpoint(w http.Respo
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("notificationEndpoint retrieved", zap.String("notificationEndpoint", fmt.Sprint(edp)))
+	h.log.Debug("NotificationEndpoint retrieved", zap.String("notificationEndpoint", fmt.Sprint(edp)))
 
 	labels, err := h.LabelService.FindResourceLabels(ctx, influxdb.LabelMappingFilter{ResourceID: edp.GetID()})
 	if err != nil {
@@ -258,7 +262,7 @@ func (h *NotificationEndpointHandler) handleGetNotificationEndpoint(w http.Respo
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newNotificationEndpointResponse(edp, labels)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -412,7 +416,7 @@ func (h *NotificationEndpointHandler) handlePostNotificationEndpoint(w http.Resp
 	ctx := r.Context()
 	edp, err := decodePostNotificationEndpointRequest(ctx, r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -442,10 +446,10 @@ func (h *NotificationEndpointHandler) handlePostNotificationEndpoint(w http.Resp
 
 	labels := h.mapNewNotificationEndpointLabels(ctx, edp.NotificationEndpoint, edp.Labels)
 
-	h.Logger.Debug("notificationEndpoint created", zap.String("notificationEndpoint", fmt.Sprint(edp)))
+	h.log.Debug("NotificationEndpoint created", zap.String("notificationEndpoint", fmt.Sprint(edp)))
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, newNotificationEndpointResponse(edp, labels)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -486,7 +490,7 @@ func (h *NotificationEndpointHandler) handlePutNotificationEndpoint(w http.Respo
 	ctx := r.Context()
 	edp, err := decodePutNotificationEndpointRequest(ctx, r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -520,10 +524,10 @@ func (h *NotificationEndpointHandler) handlePutNotificationEndpoint(w http.Respo
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("notificationEndpoint replaced", zap.String("notificationEndpoint", fmt.Sprint(edp)))
+	h.log.Debug("NotificationEndpoint replaced", zap.String("notificationEndpoint", fmt.Sprint(edp)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newNotificationEndpointResponse(edp, labels)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -533,7 +537,7 @@ func (h *NotificationEndpointHandler) handlePatchNotificationEndpoint(w http.Res
 	ctx := r.Context()
 	req, err := decodePatchNotificationEndpointRequest(ctx, r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -549,10 +553,10 @@ func (h *NotificationEndpointHandler) handlePatchNotificationEndpoint(w http.Res
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("notificationEndpoint patch", zap.String("notificationEndpoint", fmt.Sprint(edp)))
+	h.log.Debug("NotificationEndpoint patch", zap.String("notificationEndpoint", fmt.Sprint(edp)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newNotificationEndpointResponse(edp, labels)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -588,7 +592,7 @@ func (h *NotificationEndpointHandler) handleDeleteNotificationEndpoint(w http.Re
 		}, w)
 		return
 	}
-	h.Logger.Debug("notificationEndpoint deleted", zap.String("notificationEndpointID", fmt.Sprint(i)))
+	h.log.Debug("NotificationEndpoint deleted", zap.String("notificationEndpointID", fmt.Sprint(i)))
 
 	w.WriteHeader(http.StatusNoContent)
 }

http/notification_endpoint_test.go

@@ -11,20 +11,19 @@ import (
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
-
+	"github.com/influxdata/httprouter"
 	"github.com/influxdata/influxdb"
 	pcontext "github.com/influxdata/influxdb/context"
 	"github.com/influxdata/influxdb/mock"
 	"github.com/influxdata/influxdb/notification/endpoint"
 	influxTesting "github.com/influxdata/influxdb/testing"
-	"github.com/influxdata/httprouter"
-	"go.uber.org/zap"
+	"go.uber.org/zap/zaptest"
 )
 
 // NewMockNotificationEndpointBackend returns a NotificationEndpointBackend with mock services.
-func NewMockNotificationEndpointBackend() *NotificationEndpointBackend {
+func NewMockNotificationEndpointBackend(t *testing.T) *NotificationEndpointBackend {
 	return &NotificationEndpointBackend{
-		Logger: zap.NewNop().With(zap.String("handler", "notification endpoint")),
+		log: zaptest.NewLogger(t),
 
 		NotificationEndpointService: &mock.NotificationEndpointService{},
 		UserResourceMappingService:  mock.NewUserResourceMappingService(),
@@ -217,10 +216,10 @@ func TestService_handleGetNotificationEndpoints(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			notificationEndpointBackend := NewMockNotificationEndpointBackend()
+			notificationEndpointBackend := NewMockNotificationEndpointBackend(t)
 			notificationEndpointBackend.NotificationEndpointService = tt.fields.NotificationEndpointService
 			notificationEndpointBackend.LabelService = tt.fields.LabelService
-			h := NewNotificationEndpointHandler(notificationEndpointBackend)
+			h := NewNotificationEndpointHandler(zaptest.NewLogger(t), notificationEndpointBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -354,10 +353,10 @@ func TestService_handleGetNotificationEndpoint(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			notificationEndpointBackend := NewMockNotificationEndpointBackend()
+			notificationEndpointBackend := NewMockNotificationEndpointBackend(t)
 			notificationEndpointBackend.HTTPErrorHandler = ErrorHandler(0)
 			notificationEndpointBackend.NotificationEndpointService = tt.fields.NotificationEndpointService
-			h := NewNotificationEndpointHandler(notificationEndpointBackend)
+			h := NewNotificationEndpointHandler(zaptest.NewLogger(t), notificationEndpointBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -500,11 +499,11 @@ func TestService_handlePostNotificationEndpoint(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			secrets = tt.fields.Secrets
-			notificationEndpointBackend := NewMockNotificationEndpointBackend()
+			notificationEndpointBackend := NewMockNotificationEndpointBackend(t)
 			notificationEndpointBackend.NotificationEndpointService = tt.fields.NotificationEndpointService
 			notificationEndpointBackend.OrganizationService = tt.fields.OrganizationService
 			notificationEndpointBackend.SecretService = tt.fields.SecretService
-			h := NewNotificationEndpointHandler(notificationEndpointBackend)
+			h := NewNotificationEndpointHandler(zaptest.NewLogger(t), notificationEndpointBackend)
 
 			b, err := json.Marshal(tt.args.endpoint)
 			if err != nil {
@@ -625,11 +624,11 @@ func TestService_handleDeleteNotificationEndpoint(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			secrets = tt.fields.Secrets
 
-			notificationEndpointBackend := NewMockNotificationEndpointBackend()
+			notificationEndpointBackend := NewMockNotificationEndpointBackend(t)
 			notificationEndpointBackend.HTTPErrorHandler = ErrorHandler(0)
 			notificationEndpointBackend.NotificationEndpointService = tt.fields.NotificationEndpointService
 			notificationEndpointBackend.SecretService = tt.fields.SecretService
-			h := NewNotificationEndpointHandler(notificationEndpointBackend)
+			h := NewNotificationEndpointHandler(zaptest.NewLogger(t), notificationEndpointBackend)
 
 			r := httptest.NewRequest("GET", "http://any.url", nil)
 
@@ -772,10 +771,10 @@ func TestService_handlePatchNotificationEndpoint(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			notificationEndpointBackend := NewMockNotificationEndpointBackend()
+			notificationEndpointBackend := NewMockNotificationEndpointBackend(t)
 			notificationEndpointBackend.HTTPErrorHandler = ErrorHandler(0)
 			notificationEndpointBackend.NotificationEndpointService = tt.fields.NotificationEndpointService
-			h := NewNotificationEndpointHandler(notificationEndpointBackend)
+			h := NewNotificationEndpointHandler(zaptest.NewLogger(t), notificationEndpointBackend)
 
 			upd := influxdb.NotificationEndpointUpdate{}
 			if tt.args.name != "" {
@@ -936,11 +935,11 @@ func TestService_handleUpdateNotificationEndpoint(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			secrets = tt.fields.Secrets
-			notificationEndpointBackend := NewMockNotificationEndpointBackend()
+			notificationEndpointBackend := NewMockNotificationEndpointBackend(t)
 			notificationEndpointBackend.HTTPErrorHandler = ErrorHandler(0)
 			notificationEndpointBackend.NotificationEndpointService = tt.fields.NotificationEndpointService
 			notificationEndpointBackend.SecretService = tt.fields.SecretService
-			h := NewNotificationEndpointHandler(notificationEndpointBackend)
+			h := NewNotificationEndpointHandler(zaptest.NewLogger(t), notificationEndpointBackend)
 
 			b, err := json.Marshal(tt.args.edp)
 			if err != nil {
@@ -1046,9 +1045,9 @@ func TestService_handlePostNotificationEndpointMember(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			notificationEndpointBackend := NewMockNotificationEndpointBackend()
+			notificationEndpointBackend := NewMockNotificationEndpointBackend(t)
 			notificationEndpointBackend.UserService = tt.fields.UserService
-			h := NewNotificationEndpointHandler(notificationEndpointBackend)
+			h := NewNotificationEndpointHandler(zaptest.NewLogger(t), notificationEndpointBackend)
 
 			b, err := json.Marshal(tt.args.user)
 			if err != nil {
@@ -1141,9 +1140,9 @@ func TestService_handlePostNotificationEndpointOwner(t *testing.T) {
 
 	for _, tt := range cases {
 		t.Run(tt.name, func(t *testing.T) {
-			notificationEndpointBackend := NewMockNotificationEndpointBackend()
+			notificationEndpointBackend := NewMockNotificationEndpointBackend(t)
 			notificationEndpointBackend.UserService = tt.fields.UserService
-			h := NewNotificationEndpointHandler(notificationEndpointBackend)
+			h := NewNotificationEndpointHandler(zaptest.NewLogger(t), notificationEndpointBackend)
 
 			b, err := json.Marshal(tt.args.user)
 			if err != nil {

http/notification_rule.go

@@ -22,7 +22,7 @@ type statusDecode struct {
 // the NotificationRuleBackendHandler.
 type NotificationRuleBackend struct {
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	NotificationRuleStore       influxdb.NotificationRuleStore
 	NotificationEndpointService influxdb.NotificationEndpointService
@@ -34,10 +34,10 @@ type NotificationRuleBackend struct {
 }
 
 // NewNotificationRuleBackend returns a new instance of NotificationRuleBackend.
-func NewNotificationRuleBackend(b *APIBackend) *NotificationRuleBackend {
+func NewNotificationRuleBackend(log *zap.Logger, b *APIBackend) *NotificationRuleBackend {
 	return &NotificationRuleBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "notification_rule")),
+		log:              log,
 
 		NotificationRuleStore:       b.NotificationRuleStore,
 		NotificationEndpointService: b.NotificationEndpointService,
@@ -53,7 +53,7 @@ func NewNotificationRuleBackend(b *APIBackend) *NotificationRuleBackend {
 type NotificationRuleHandler struct {
 	*httprouter.Router
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	NotificationRuleStore       influxdb.NotificationRuleStore
 	NotificationEndpointService influxdb.NotificationEndpointService
@@ -77,11 +77,11 @@ const (
 )
 
 // NewNotificationRuleHandler returns a new instance of NotificationRuleHandler.
-func NewNotificationRuleHandler(b *NotificationRuleBackend) *NotificationRuleHandler {
+func NewNotificationRuleHandler(log *zap.Logger, b *NotificationRuleBackend) *NotificationRuleHandler {
 	h := &NotificationRuleHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger,
+		log:              log,
 
 		NotificationRuleStore:       b.NotificationRuleStore,
 		NotificationEndpointService: b.NotificationEndpointService,
@@ -101,7 +101,7 @@ func NewNotificationRuleHandler(b *NotificationRuleBackend) *NotificationRuleHan
 
 	memberBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               influxdb.NotificationRuleResourceType,
 		UserType:                   influxdb.Member,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -113,7 +113,7 @@ func NewNotificationRuleHandler(b *NotificationRuleBackend) *NotificationRuleHan
 
 	ownerBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               influxdb.NotificationRuleResourceType,
 		UserType:                   influxdb.Owner,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -125,7 +125,7 @@ func NewNotificationRuleHandler(b *NotificationRuleBackend) *NotificationRuleHan
 
 	labelBackend := &LabelBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "label")),
+		log:              b.log.With(zap.String("handler", "label")),
 		LabelService:     b.LabelService,
 		ResourceType:     influxdb.TelegrafsResourceType,
 	}
@@ -242,7 +242,7 @@ func (h *NotificationRuleHandler) handleGetNotificationRules(w http.ResponseWrit
 	ctx := r.Context()
 	filter, opts, err := decodeNotificationRuleFilter(ctx, r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -251,7 +251,7 @@ func (h *NotificationRuleHandler) handleGetNotificationRules(w http.ResponseWrit
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("notification rules retrieved", zap.String("notificationRules", fmt.Sprint(nrs)))
+	h.log.Debug("Notification rules retrieved", zap.String("notificationRules", fmt.Sprint(nrs)))
 
 	res, err := h.newNotificationRulesResponse(ctx, nrs, h.LabelService, filter, *opts)
 	if err != nil {
@@ -260,7 +260,7 @@ func (h *NotificationRuleHandler) handleGetNotificationRules(w http.ResponseWrit
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, res); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -291,9 +291,9 @@ func (h *NotificationRuleHandler) handleGetNotificationRuleQuery(w http.Response
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("notification rule query retrieved", zap.String("notificationRuleQuery", fmt.Sprint(flux)))
+	h.log.Debug("Notification rule query retrieved", zap.String("notificationRuleQuery", fmt.Sprint(flux)))
 	if err := encodeResponse(ctx, w, http.StatusOK, newFluxResponse(flux)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -310,7 +310,7 @@ func (h *NotificationRuleHandler) handleGetNotificationRule(w http.ResponseWrite
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("notification rule retrieved", zap.String("notificationRule", fmt.Sprint(nr)))
+	h.log.Debug("Notification rule retrieved", zap.String("notificationRule", fmt.Sprint(nr)))
 
 	labels, err := h.LabelService.FindResourceLabels(ctx, influxdb.LabelMappingFilter{ResourceID: nr.GetID()})
 	if err != nil {
@@ -325,7 +325,7 @@ func (h *NotificationRuleHandler) handleGetNotificationRule(w http.ResponseWrite
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, res); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -530,7 +530,7 @@ func (h *NotificationRuleHandler) handlePostNotificationRule(w http.ResponseWrit
 	ctx := r.Context()
 	nr, err := decodePostNotificationRuleRequest(ctx, r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -545,7 +545,7 @@ func (h *NotificationRuleHandler) handlePostNotificationRule(w http.ResponseWrit
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("notification rule created", zap.String("notificationRule", fmt.Sprint(nr)))
+	h.log.Debug("Notification rule created", zap.String("notificationRule", fmt.Sprint(nr)))
 
 	labels := h.mapNewNotificationRuleLabels(ctx, nr.NotificationRuleCreate, nr.Labels)
 
@@ -556,7 +556,7 @@ func (h *NotificationRuleHandler) handlePostNotificationRule(w http.ResponseWrit
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, res); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -597,7 +597,7 @@ func (h *NotificationRuleHandler) handlePutNotificationRule(w http.ResponseWrite
 	ctx := r.Context()
 	nrc, err := decodePutNotificationRuleRequest(ctx, r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -618,7 +618,7 @@ func (h *NotificationRuleHandler) handlePutNotificationRule(w http.ResponseWrite
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("notification rule updated", zap.String("notificationRule", fmt.Sprint(nr)))
+	h.log.Debug("Notification rule updated", zap.String("notificationRule", fmt.Sprint(nr)))
 
 	res, err := h.newNotificationRuleResponse(ctx, nr, labels)
 	if err != nil {
@@ -627,7 +627,7 @@ func (h *NotificationRuleHandler) handlePutNotificationRule(w http.ResponseWrite
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, res); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -637,7 +637,7 @@ func (h *NotificationRuleHandler) handlePatchNotificationRule(w http.ResponseWri
 	ctx := r.Context()
 	req, err := decodePatchNotificationRuleRequest(ctx, r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -653,7 +653,7 @@ func (h *NotificationRuleHandler) handlePatchNotificationRule(w http.ResponseWri
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("notification rule patch", zap.String("notificationRule", fmt.Sprint(nr)))
+	h.log.Debug("Notification rule patch", zap.String("notificationRule", fmt.Sprint(nr)))
 
 	res, err := h.newNotificationRuleResponse(ctx, nr, labels)
 	if err != nil {
@@ -662,7 +662,7 @@ func (h *NotificationRuleHandler) handlePatchNotificationRule(w http.ResponseWri
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, res); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -679,7 +679,7 @@ func (h *NotificationRuleHandler) handleDeleteNotificationRule(w http.ResponseWr
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("notification rule deleted", zap.String("notificationRuleID", fmt.Sprint(i)))
+	h.log.Debug("Notification rule deleted", zap.String("notificationRuleID", fmt.Sprint(i)))
 
 	w.WriteHeader(http.StatusNoContent)
 }

http/notification_rule_test.go

@@ -5,18 +5,17 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/influxdata/influxdb/notification"
-	"go.uber.org/zap"
-
 	"github.com/influxdata/influxdb"
 	"github.com/influxdata/influxdb/mock"
+	"github.com/influxdata/influxdb/notification"
 	"github.com/influxdata/influxdb/notification/rule"
 	influxTesting "github.com/influxdata/influxdb/testing"
+	"go.uber.org/zap/zaptest"
 )
 
-func NewMockNotificationRuleBackend() *NotificationRuleBackend {
+func NewMockNotificationRuleBackend(t *testing.T) *NotificationRuleBackend {
 	return &NotificationRuleBackend{
-		Logger: zap.NewNop().With(zap.String("handler", "check")),
+		log: zaptest.NewLogger(t),
 
 		UserResourceMappingService: mock.NewUserResourceMappingService(),
 		LabelService:               mock.NewLabelService(),
@@ -177,7 +176,7 @@ func Test_newNotificationRuleResponses(t *testing.T) {
 }`,
 		},
 	}
-	handler := NewNotificationRuleHandler(NewMockNotificationRuleBackend())
+	handler := NewNotificationRuleHandler(zaptest.NewLogger(t), NewMockNotificationRuleBackend(t))
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			ctx := context.Background()
@@ -292,7 +291,7 @@ func Test_newNotificationRuleResponse(t *testing.T) {
 }`,
 		},
 	}
-	handler := NewNotificationRuleHandler(NewMockNotificationRuleBackend())
+	handler := NewNotificationRuleHandler(zaptest.NewLogger(t), NewMockNotificationRuleBackend(t))
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			res, err := handler.newNotificationRuleResponse(context.Background(), tt.args.nr, []*influxdb.Label{})

http/onboarding.go

@@ -16,15 +16,15 @@ import (
 // the SetupHandler.
 type SetupBackend struct {
 	platform.HTTPErrorHandler
-	Logger            *zap.Logger
+	log               *zap.Logger
 	OnboardingService platform.OnboardingService
 }
 
 // NewSetupBackend returns a new instance of SetupBackend.
-func NewSetupBackend(b *APIBackend) *SetupBackend {
+func NewSetupBackend(log *zap.Logger, b *APIBackend) *SetupBackend {
 	return &SetupBackend{
 		HTTPErrorHandler:  b.HTTPErrorHandler,
-		Logger:            b.Logger.With(zap.String("handler", "setup")),
+		log:               log,
 		OnboardingService: b.OnboardingService,
 	}
 }
@@ -33,7 +33,7 @@ func NewSetupBackend(b *APIBackend) *SetupBackend {
 type SetupHandler struct {
 	*httprouter.Router
 	platform.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	OnboardingService platform.OnboardingService
 }
@@ -43,11 +43,11 @@ const (
 )
 
 // NewSetupHandler returns a new instance of SetupHandler.
-func NewSetupHandler(b *SetupBackend) *SetupHandler {
+func NewSetupHandler(log *zap.Logger, b *SetupBackend) *SetupHandler {
 	h := &SetupHandler{
 		Router:            NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler:  b.HTTPErrorHandler,
-		Logger:            b.Logger,
+		log:               log,
 		OnboardingService: b.OnboardingService,
 	}
 	h.HandlerFunc("POST", setupPath, h.handlePostSetup)
@@ -67,10 +67,10 @@ func (h *SetupHandler) isOnboarding(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("onboarding eligibility check finished", zap.String("result", fmt.Sprint(result)))
+	h.log.Debug("Onboarding eligibility check finished", zap.String("result", fmt.Sprint(result)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, isOnboardingResponse{result}); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -88,10 +88,10 @@ func (h *SetupHandler) handlePostSetup(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("onboarding setup completed", zap.String("results", fmt.Sprint(results)))
+	h.log.Debug("Onboarding setup completed", zap.String("results", fmt.Sprint(results)))
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, newOnboardingResponse(results)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }

http/onboarding_test.go

@@ -5,26 +5,25 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"github.com/influxdata/influxdb/mock"
-	"go.uber.org/zap"
-
 	platform "github.com/influxdata/influxdb"
 	"github.com/influxdata/influxdb/inmem"
 	"github.com/influxdata/influxdb/kv"
+	"github.com/influxdata/influxdb/mock"
 	platformtesting "github.com/influxdata/influxdb/testing"
+	"go.uber.org/zap/zaptest"
 )
 
 // NewMockSetupBackend returns a SetupBackend with mock services.
-func NewMockSetupBackend() *SetupBackend {
+func NewMockSetupBackend(t *testing.T) *SetupBackend {
 	return &SetupBackend{
-		Logger:            zap.NewNop().With(zap.String("handler", "scraper")),
+		log:               zaptest.NewLogger(t),
 		OnboardingService: mock.NewOnboardingService(),
 	}
 }
 
 func initOnboardingService(f platformtesting.OnboardingFields, t *testing.T) (platform.OnboardingService, func()) {
 	t.Helper()
-	svc := kv.NewService(inmem.NewKVStore())
+	svc := kv.NewService(zaptest.NewLogger(t), inmem.NewKVStore())
 	svc.IDGenerator = f.IDGenerator
 	svc.OrgBucketIDs = f.IDGenerator
 	svc.TokenGenerator = f.TokenGenerator
@@ -38,10 +37,10 @@ func initOnboardingService(f platformtesting.OnboardingFields, t *testing.T) (pl
 		t.Fatalf("failed to set new onboarding finished: %v", err)
 	}
 
-	setupBackend := NewMockSetupBackend()
+	setupBackend := NewMockSetupBackend(t)
 	setupBackend.HTTPErrorHandler = ErrorHandler(0)
 	setupBackend.OnboardingService = svc
-	handler := NewSetupHandler(setupBackend)
+	handler := NewSetupHandler(zaptest.NewLogger(t), setupBackend)
 	server := httptest.NewServer(handler)
 	client := struct {
 		*SetupService

http/org_service.go

@@ -19,7 +19,7 @@ import (
 // the OrgHandler.
 type OrgBackend struct {
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	OrganizationService             influxdb.OrganizationService
 	OrganizationOperationLogService influxdb.OrganizationOperationLogService
@@ -30,10 +30,10 @@ type OrgBackend struct {
 }
 
 // NewOrgBackend is a datasource used by the org handler.
-func NewOrgBackend(b *APIBackend) *OrgBackend {
+func NewOrgBackend(log *zap.Logger, b *APIBackend) *OrgBackend {
 	return &OrgBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "org")),
+		log:              log,
 
 		OrganizationService:             b.OrganizationService,
 		OrganizationOperationLogService: b.OrganizationOperationLogService,
@@ -48,7 +48,7 @@ func NewOrgBackend(b *APIBackend) *OrgBackend {
 type OrgHandler struct {
 	*httprouter.Router
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	OrganizationService             influxdb.OrganizationService
 	OrganizationOperationLogService influxdb.OrganizationOperationLogService
@@ -96,11 +96,11 @@ func checkOrganziationExists(handler *OrgHandler) Middleware {
 }
 
 // NewOrgHandler returns a new instance of OrgHandler.
-func NewOrgHandler(b *OrgBackend) *OrgHandler {
+func NewOrgHandler(log *zap.Logger, b *OrgBackend) *OrgHandler {
 	h := &OrgHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           zap.NewNop(),
+		log:              log,
 
 		OrganizationService:             b.OrganizationService,
 		OrganizationOperationLogService: b.OrganizationOperationLogService,
@@ -119,7 +119,7 @@ func NewOrgHandler(b *OrgBackend) *OrgHandler {
 
 	memberBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               influxdb.OrgsResourceType,
 		UserType:                   influxdb.Member,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -131,7 +131,7 @@ func NewOrgHandler(b *OrgBackend) *OrgHandler {
 
 	ownerBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               influxdb.OrgsResourceType,
 		UserType:                   influxdb.Owner,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -148,7 +148,7 @@ func NewOrgHandler(b *OrgBackend) *OrgHandler {
 
 	labelBackend := &LabelBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "label")),
+		log:              b.log.With(zap.String("handler", "label")),
 		LabelService:     b.LabelService,
 		ResourceType:     influxdb.OrgsResourceType,
 	}
@@ -235,10 +235,10 @@ func (h *OrgHandler) handlePostOrg(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("org created", zap.String("org", fmt.Sprint(req.Org)))
+	h.log.Debug("Org created", zap.String("org", fmt.Sprint(req.Org)))
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, newOrgResponse(req.Org)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -272,10 +272,10 @@ func (h *OrgHandler) handleGetOrg(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("org retrieved", zap.String("org", fmt.Sprint(b)))
+	h.log.Debug("Org retrieved", zap.String("org", fmt.Sprint(b)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newOrgResponse(b)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -320,10 +320,10 @@ func (h *OrgHandler) handleGetOrgs(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("orgs retrieved", zap.String("org", fmt.Sprint(orgs)))
+	h.log.Debug("Orgs retrieved", zap.String("org", fmt.Sprint(orgs)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newOrgsResponse(orgs)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -364,7 +364,7 @@ func (h *OrgHandler) handleDeleteOrg(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("org deleted", zap.String("orgID", fmt.Sprint(req.OrganizationID)))
+	h.log.Debug("Org deleted", zap.String("orgID", fmt.Sprint(req.OrganizationID)))
 
 	w.WriteHeader(http.StatusNoContent)
 }
@@ -412,10 +412,10 @@ func (h *OrgHandler) handlePatchOrg(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("org updated", zap.String("org", fmt.Sprint(o)))
+	h.log.Debug("Org updated", zap.String("org", fmt.Sprint(o)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newOrgResponse(o)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -468,7 +468,7 @@ func (h *OrgHandler) handleGetSecrets(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newSecretsResponse(req.orgID, ks)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -854,10 +854,10 @@ func (h *OrgHandler) handleGetOrgLog(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("org logs retrieved", zap.String("log", fmt.Sprint(log)))
+	h.log.Debug("Org logs retrieved", zap.String("log", fmt.Sprint(log)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newOrganizationLogResponse(req.OrganizationID, log)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }

http/org_test.go

@@ -10,19 +10,18 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"go.uber.org/zap"
-
 	platform "github.com/influxdata/influxdb"
 	"github.com/influxdata/influxdb/inmem"
 	"github.com/influxdata/influxdb/kv"
 	"github.com/influxdata/influxdb/mock"
 	platformtesting "github.com/influxdata/influxdb/testing"
+	"go.uber.org/zap/zaptest"
 )
 
 // NewMockOrgBackend returns a OrgBackend with mock services.
-func NewMockOrgBackend() *OrgBackend {
+func NewMockOrgBackend(t *testing.T) *OrgBackend {
 	return &OrgBackend{
-		Logger: zap.NewNop().With(zap.String("handler", "org")),
+		log: zaptest.NewLogger(t),
 
 		OrganizationService:             mock.NewOrganizationService(),
 		OrganizationOperationLogService: mock.NewOrganizationOperationLogService(),
@@ -35,7 +34,7 @@ func NewMockOrgBackend() *OrgBackend {
 
 func initOrganizationService(f platformtesting.OrganizationFields, t *testing.T) (platform.OrganizationService, string, func()) {
 	t.Helper()
-	svc := kv.NewService(inmem.NewKVStore())
+	svc := kv.NewService(zaptest.NewLogger(t), inmem.NewKVStore())
 	svc.IDGenerator = f.IDGenerator
 	svc.OrgBucketIDs = f.OrgBucketIDs
 	svc.TimeGenerator = f.TimeGenerator
@@ -54,10 +53,10 @@ func initOrganizationService(f platformtesting.OrganizationFields, t *testing.T)
 		}
 	}
 
-	orgBackend := NewMockOrgBackend()
+	orgBackend := NewMockOrgBackend(t)
 	orgBackend.HTTPErrorHandler = ErrorHandler(0)
 	orgBackend.OrganizationService = svc
-	handler := NewOrgHandler(orgBackend)
+	handler := NewOrgHandler(zaptest.NewLogger(t), orgBackend)
 	server := httptest.NewServer(handler)
 	client := OrganizationService{
 		Addr:     server.URL,
@@ -181,10 +180,10 @@ func TestSecretService_handleGetSecrets(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			orgBackend := NewMockOrgBackend()
+			orgBackend := NewMockOrgBackend(t)
 			orgBackend.HTTPErrorHandler = ErrorHandler(0)
 			orgBackend.SecretService = tt.fields.SecretService
-			h := NewOrgHandler(orgBackend)
+			h := NewOrgHandler(zaptest.NewLogger(t), orgBackend)
 
 			u := fmt.Sprintf("http://any.url/api/v2/orgs/%s/secrets", tt.args.orgID)
 			r := httptest.NewRequest("GET", u, nil)
@@ -257,10 +256,10 @@ func TestSecretService_handlePatchSecrets(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			orgBackend := NewMockOrgBackend()
+			orgBackend := NewMockOrgBackend(t)
 			orgBackend.HTTPErrorHandler = ErrorHandler(0)
 			orgBackend.SecretService = tt.fields.SecretService
-			h := NewOrgHandler(orgBackend)
+			h := NewOrgHandler(zaptest.NewLogger(t), orgBackend)
 
 			b, err := json.Marshal(tt.args.secrets)
 			if err != nil {
@@ -339,10 +338,10 @@ func TestSecretService_handleDeleteSecrets(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			orgBackend := NewMockOrgBackend()
+			orgBackend := NewMockOrgBackend(t)
 			orgBackend.HTTPErrorHandler = ErrorHandler(0)
 			orgBackend.SecretService = tt.fields.SecretService
-			h := NewOrgHandler(orgBackend)
+			h := NewOrgHandler(zaptest.NewLogger(t), orgBackend)
 
 			b, err := json.Marshal(deleteSecretsRequest{
 				Secrets: tt.args.secrets,

http/pkger_http_server_test.go

@@ -16,6 +16,7 @@ import (
 	"github.com/influxdata/influxdb/pkger"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/zap/zaptest"
 	"gopkg.in/yaml.v3"
 )
 
@@ -28,7 +29,7 @@ func TestPkgerHTTPServer(t *testing.T) {
 					ID: id,
 				}, nil
 			}
-			svc := pkger.NewService(pkger.WithLabelSVC(fakeLabelSVC))
+			svc := pkger.NewService(zaptest.NewLogger(t), pkger.WithLabelSVC(fakeLabelSVC))
 			pkgHandler := fluxTTP.NewHandlerPkg(fluxTTP.ErrorHandler(0), svc)
 			svr := newMountedHandler(pkgHandler)
 

http/platform_handler.go

@@ -24,7 +24,7 @@ func setCORSResponseHeaders(w http.ResponseWriter, r *http.Request) {
 
 // NewPlatformHandler returns a platform handler that serves the API and associated assets.
 func NewPlatformHandler(b *APIBackend, opts ...APIHandlerOptFn) *PlatformHandler {
-	h := NewAuthenticationHandler(b.HTTPErrorHandler)
+	h := NewAuthenticationHandler(b.Logger, b.HTTPErrorHandler)
 	h.Handler = NewAPIHandler(b, opts...)
 	h.AuthorizationService = b.AuthorizationService
 	h.SessionService = b.SessionService

http/query_handler.go

@@ -38,7 +38,7 @@ const (
 // the FluxHandler.
 type FluxBackend struct {
 	influxdb.HTTPErrorHandler
-	Logger             *zap.Logger
+	log                *zap.Logger
 	QueryEventRecorder metric.EventRecorder
 
 	OrganizationService influxdb.OrganizationService
@@ -46,10 +46,10 @@ type FluxBackend struct {
 }
 
 // NewFluxBackend returns a new instance of FluxBackend.
-func NewFluxBackend(b *APIBackend) *FluxBackend {
+func NewFluxBackend(log *zap.Logger, b *APIBackend) *FluxBackend {
 	return &FluxBackend{
 		HTTPErrorHandler:   b.HTTPErrorHandler,
-		Logger:             b.Logger.With(zap.String("handler", "query")),
+		log:                log,
 		QueryEventRecorder: b.QueryEventRecorder,
 
 		ProxyQueryService:   b.FluxService,
@@ -66,7 +66,7 @@ type HTTPDialect interface {
 type FluxHandler struct {
 	*httprouter.Router
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	Now                 func() time.Time
 	OrganizationService influxdb.OrganizationService
@@ -76,12 +76,12 @@ type FluxHandler struct {
 }
 
 // NewFluxHandler returns a new handler at /api/v2/query for flux queries.
-func NewFluxHandler(b *FluxBackend) *FluxHandler {
+func NewFluxHandler(log *zap.Logger, b *FluxBackend) *FluxHandler {
 	h := &FluxHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		Now:              time.Now,
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger,
+		log:              log,
 
 		ProxyQueryService:   b.ProxyQueryService,
 		OrganizationService: b.OrganizationService,
@@ -169,7 +169,7 @@ func (h *FluxHandler) handleQuery(w http.ResponseWriter, r *http.Request) {
 			h.HandleHTTPError(ctx, err, w)
 			return
 		}
-		h.Logger.Info("Error writing response to client",
+		h.log.Info("Error writing response to client",
 			zap.String("handler", "flux"),
 			zap.Error(err),
 		)
@@ -218,7 +218,7 @@ func (h *FluxHandler) postFluxAST(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, res); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -246,7 +246,7 @@ func (h *FluxHandler) postQueryAnalyze(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	if err := encodeResponse(ctx, w, http.StatusOK, a); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -298,7 +298,7 @@ func (h *FluxHandler) getFluxSuggestions(w http.ResponseWriter, r *http.Request)
 	res := suggestionsResponse{Functions: functions}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, res); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -320,7 +320,7 @@ func (h *FluxHandler) getFluxSuggestion(w http.ResponseWriter, r *http.Request)
 
 	res := suggestionResponse{Name: name, Params: suggestion.Params}
 	if err := encodeResponse(ctx, w, http.StatusOK, res); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }

http/query_handler_test.go

@@ -324,7 +324,7 @@ func TestFluxHandler_PostQuery_Errors(t *testing.T) {
 	i := inmem.NewService()
 	b := &FluxBackend{
 		HTTPErrorHandler:    ErrorHandler(0),
-		Logger:              zaptest.NewLogger(t),
+		log:                 zaptest.NewLogger(t),
 		QueryEventRecorder:  noopEventRecorder{},
 		OrganizationService: i,
 		ProxyQueryService: &mock.ProxyQueryService{
@@ -336,7 +336,7 @@ func TestFluxHandler_PostQuery_Errors(t *testing.T) {
 			},
 		},
 	}
-	h := NewFluxHandler(b)
+	h := NewFluxHandler(zaptest.NewLogger(t), b)
 
 	t.Run("missing authorizer", func(t *testing.T) {
 		ts := httptest.NewServer(h)
@@ -478,18 +478,18 @@ func TestFluxService_Query_gzip(t *testing.T) {
 
 	fluxBackend := &FluxBackend{
 		HTTPErrorHandler:    ErrorHandler(0),
-		Logger:              zaptest.NewLogger(t),
+		log:                 zaptest.NewLogger(t),
 		QueryEventRecorder:  noopEventRecorder{},
 		OrganizationService: orgService,
 		ProxyQueryService:   queryService,
 	}
 
-	fluxHandler := NewFluxHandler(fluxBackend)
+	fluxHandler := NewFluxHandler(zaptest.NewLogger(t), fluxBackend)
 
 	// fluxHandling expects authorization to be on the request context.
 	// AuthenticationHandler extracts the token from headers and places
 	// the auth on context.
-	auth := NewAuthenticationHandler(ErrorHandler(0))
+	auth := NewAuthenticationHandler(zaptest.NewLogger(t), ErrorHandler(0))
 	auth.AuthorizationService = authService
 	auth.Handler = fluxHandler
 	auth.UserService = &influxmock.UserService{
@@ -614,18 +614,18 @@ func benchmarkQuery(b *testing.B, disableCompression bool) {
 
 	fluxBackend := &FluxBackend{
 		HTTPErrorHandler:    ErrorHandler(0),
-		Logger:              zaptest.NewLogger(b),
+		log:                 zaptest.NewLogger(b),
 		QueryEventRecorder:  noopEventRecorder{},
 		OrganizationService: orgService,
 		ProxyQueryService:   queryService,
 	}
 
-	fluxHandler := NewFluxHandler(fluxBackend)
+	fluxHandler := NewFluxHandler(zaptest.NewLogger(b), fluxBackend)
 
 	// fluxHandling expects authorization to be on the request context.
 	// AuthenticationHandler extracts the token from headers and places
 	// the auth on context.
-	auth := NewAuthenticationHandler(ErrorHandler(0))
+	auth := NewAuthenticationHandler(zaptest.NewLogger(b), ErrorHandler(0))
 	auth.AuthorizationService = authService
 	auth.Handler = fluxHandler
 

http/scraper_service.go

@@ -18,7 +18,7 @@ import (
 // the ScraperHandler.
 type ScraperBackend struct {
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	ScraperStorageService      influxdb.ScraperTargetStoreService
 	BucketService              influxdb.BucketService
@@ -29,10 +29,10 @@ type ScraperBackend struct {
 }
 
 // NewScraperBackend returns a new instance of ScraperBackend.
-func NewScraperBackend(b *APIBackend) *ScraperBackend {
+func NewScraperBackend(log *zap.Logger, b *APIBackend) *ScraperBackend {
 	return &ScraperBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "scraper")),
+		log:              log,
 
 		ScraperStorageService:      b.ScraperTargetStoreService,
 		BucketService:              b.BucketService,
@@ -47,7 +47,7 @@ func NewScraperBackend(b *APIBackend) *ScraperBackend {
 type ScraperHandler struct {
 	*httprouter.Router
 	influxdb.HTTPErrorHandler
-	Logger                     *zap.Logger
+	log                        *zap.Logger
 	UserService                influxdb.UserService
 	UserResourceMappingService influxdb.UserResourceMappingService
 	LabelService               influxdb.LabelService
@@ -67,11 +67,11 @@ const (
 )
 
 // NewScraperHandler returns a new instance of ScraperHandler.
-func NewScraperHandler(b *ScraperBackend) *ScraperHandler {
+func NewScraperHandler(log *zap.Logger, b *ScraperBackend) *ScraperHandler {
 	h := &ScraperHandler{
 		Router:                     NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger,
+		log:                        log,
 		UserService:                b.UserService,
 		UserResourceMappingService: b.UserResourceMappingService,
 		LabelService:               b.LabelService,
@@ -87,7 +87,7 @@ func NewScraperHandler(b *ScraperBackend) *ScraperHandler {
 
 	memberBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               influxdb.ScraperResourceType,
 		UserType:                   influxdb.Member,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -99,7 +99,7 @@ func NewScraperHandler(b *ScraperBackend) *ScraperHandler {
 
 	ownerBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               influxdb.ScraperResourceType,
 		UserType:                   influxdb.Owner,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -111,7 +111,7 @@ func NewScraperHandler(b *ScraperBackend) *ScraperHandler {
 
 	labelBackend := &LabelBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "label")),
+		log:              b.log.With(zap.String("handler", "label")),
 		LabelService:     b.LabelService,
 		ResourceType:     influxdb.ScraperResourceType,
 	}
@@ -141,7 +141,7 @@ func (h *ScraperHandler) handlePostScraperTarget(w http.ResponseWriter, r *http.
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("scraper created", zap.String("scraper", fmt.Sprint(req)))
+	h.log.Debug("Scraper created", zap.String("scraper", fmt.Sprint(req)))
 
 	resp, err := h.newTargetResponse(ctx, *req)
 	if err != nil {
@@ -149,7 +149,7 @@ func (h *ScraperHandler) handlePostScraperTarget(w http.ResponseWriter, r *http.
 		return
 	}
 	if err := encodeResponse(ctx, w, http.StatusCreated, resp); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -167,7 +167,7 @@ func (h *ScraperHandler) handleDeleteScraperTarget(w http.ResponseWriter, r *htt
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("scraper deleted", zap.String("scraperTargetID", fmt.Sprint(id)))
+	h.log.Debug("Scraper deleted", zap.String("scraperTargetID", fmt.Sprint(id)))
 
 	w.WriteHeader(http.StatusNoContent)
 }
@@ -192,7 +192,7 @@ func (h *ScraperHandler) handlePatchScraperTarget(w http.ResponseWriter, r *http
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("scraper updated", zap.String("scraper", fmt.Sprint(target)))
+	h.log.Debug("Scraper updated", zap.String("scraper", fmt.Sprint(target)))
 
 	resp, err := h.newTargetResponse(ctx, *target)
 	if err != nil {
@@ -201,7 +201,7 @@ func (h *ScraperHandler) handlePatchScraperTarget(w http.ResponseWriter, r *http
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, resp); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -218,7 +218,7 @@ func (h *ScraperHandler) handleGetScraperTarget(w http.ResponseWriter, r *http.R
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("scraper retrieved", zap.String("scraper", fmt.Sprint(target)))
+	h.log.Debug("Scraper retrieved", zap.String("scraper", fmt.Sprint(target)))
 
 	resp, err := h.newTargetResponse(ctx, *target)
 	if err != nil {
@@ -227,7 +227,7 @@ func (h *ScraperHandler) handleGetScraperTarget(w http.ResponseWriter, r *http.R
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, resp); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -280,7 +280,7 @@ func (h *ScraperHandler) handleGetScraperTargets(w http.ResponseWriter, r *http.
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("scrapers retrieved", zap.String("scrapers", fmt.Sprint(targets)))
+	h.log.Debug("Scrapers retrieved", zap.String("scrapers", fmt.Sprint(targets)))
 
 	resp, err := h.newListTargetsResponse(ctx, targets)
 	if err != nil {
@@ -289,7 +289,7 @@ func (h *ScraperHandler) handleGetScraperTargets(w http.ResponseWriter, r *http.
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, resp); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }

http/scraper_service_test.go

@@ -10,15 +10,14 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"go.uber.org/zap"
-
+	"github.com/influxdata/httprouter"
 	"github.com/influxdata/influxdb"
 	platcontext "github.com/influxdata/influxdb/context"
 	httpMock "github.com/influxdata/influxdb/http/mock"
 	"github.com/influxdata/influxdb/inmem"
 	"github.com/influxdata/influxdb/mock"
 	platformtesting "github.com/influxdata/influxdb/testing"
-	"github.com/influxdata/httprouter"
+	"go.uber.org/zap/zaptest"
 )
 
 const (
@@ -32,9 +31,9 @@ var (
 )
 
 // NewMockScraperBackend returns a ScraperBackend with mock services.
-func NewMockScraperBackend() *ScraperBackend {
+func NewMockScraperBackend(t *testing.T) *ScraperBackend {
 	return &ScraperBackend{
-		Logger: zap.NewNop().With(zap.String("handler", "scraper")),
+		log: zaptest.NewLogger(t),
 
 		ScraperStorageService:      &mock.ScraperTargetStoreService{},
 		BucketService:              mock.NewBucketService(),
@@ -206,12 +205,12 @@ func TestService_handleGetScraperTargets(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			scraperBackend := NewMockScraperBackend()
+			scraperBackend := NewMockScraperBackend(t)
 			scraperBackend.HTTPErrorHandler = ErrorHandler(0)
 			scraperBackend.ScraperStorageService = tt.fields.ScraperTargetStoreService
 			scraperBackend.OrganizationService = tt.fields.OrganizationService
 			scraperBackend.BucketService = tt.fields.BucketService
-			h := NewScraperHandler(scraperBackend)
+			h := NewScraperHandler(zaptest.NewLogger(t), scraperBackend)
 
 			r := httptest.NewRequest("GET", "http://any.tld", nil)
 
@@ -343,12 +342,12 @@ func TestService_handleGetScraperTarget(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			scraperBackend := NewMockScraperBackend()
+			scraperBackend := NewMockScraperBackend(t)
 			scraperBackend.HTTPErrorHandler = ErrorHandler(0)
 			scraperBackend.ScraperStorageService = tt.fields.ScraperTargetStoreService
 			scraperBackend.OrganizationService = tt.fields.OrganizationService
 			scraperBackend.BucketService = tt.fields.BucketService
-			h := NewScraperHandler(scraperBackend)
+			h := NewScraperHandler(zaptest.NewLogger(t), scraperBackend)
 
 			r := httptest.NewRequest("GET", "http://any.tld", nil)
 
@@ -451,10 +450,10 @@ func TestService_handleDeleteScraperTarget(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			scraperBackend := NewMockScraperBackend()
+			scraperBackend := NewMockScraperBackend(t)
 			scraperBackend.HTTPErrorHandler = ErrorHandler(0)
 			scraperBackend.ScraperStorageService = tt.fields.Service
-			h := NewScraperHandler(scraperBackend)
+			h := NewScraperHandler(zaptest.NewLogger(t), scraperBackend)
 
 			r := httptest.NewRequest("GET", "http://any.tld", nil)
 
@@ -582,12 +581,12 @@ func TestService_handlePostScraperTarget(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			scraperBackend := NewMockScraperBackend()
+			scraperBackend := NewMockScraperBackend(t)
 			scraperBackend.HTTPErrorHandler = ErrorHandler(0)
 			scraperBackend.ScraperStorageService = tt.fields.ScraperTargetStoreService
 			scraperBackend.OrganizationService = tt.fields.OrganizationService
 			scraperBackend.BucketService = tt.fields.BucketService
-			h := NewScraperHandler(scraperBackend)
+			h := NewScraperHandler(zaptest.NewLogger(t), scraperBackend)
 
 			st, err := json.Marshal(tt.args.target)
 			if err != nil {
@@ -760,12 +759,12 @@ func TestService_handlePatchScraperTarget(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			scraperBackend := NewMockScraperBackend()
+			scraperBackend := NewMockScraperBackend(t)
 			scraperBackend.HTTPErrorHandler = ErrorHandler(0)
 			scraperBackend.ScraperStorageService = tt.fields.ScraperTargetStoreService
 			scraperBackend.OrganizationService = tt.fields.OrganizationService
 			scraperBackend.BucketService = tt.fields.BucketService
-			h := NewScraperHandler(scraperBackend)
+			h := NewScraperHandler(zaptest.NewLogger(t), scraperBackend)
 
 			var err error
 			st := make([]byte, 0)
@@ -836,7 +835,7 @@ func initScraperService(f platformtesting.TargetFields, t *testing.T) (influxdb.
 		}
 	}
 
-	scraperBackend := NewMockScraperBackend()
+	scraperBackend := NewMockScraperBackend(t)
 	scraperBackend.HTTPErrorHandler = ErrorHandler(0)
 	scraperBackend.ScraperStorageService = svc
 	scraperBackend.OrganizationService = svc
@@ -849,7 +848,7 @@ func initScraperService(f platformtesting.TargetFields, t *testing.T) (influxdb.
 		},
 	}
 
-	handler := NewScraperHandler(scraperBackend)
+	handler := NewScraperHandler(zaptest.NewLogger(t), scraperBackend)
 	server := httptest.NewServer(httpMock.NewAuthMiddlewareHandler(
 		handler,
 		&influxdb.Authorization{

http/server.go

@@ -27,22 +27,19 @@ type Server struct {
 
 	srv     *http.Server
 	signals map[os.Signal]struct{}
-	logger  *zap.Logger
+	log     *zap.Logger
 	wg      sync.WaitGroup
 }
 
 // NewServer returns a new server struct that can be used.
-func NewServer(handler http.Handler, logger *zap.Logger) *Server {
-	if logger == nil {
-		logger = zap.NewNop()
-	}
+func NewServer(log *zap.Logger, handler http.Handler) *Server {
 	return &Server{
 		ShutdownTimeout: DefaultShutdownTimeout,
 		srv: &http.Server{
 			Handler:  handler,
-			ErrorLog: zap.NewStdLog(logger),
+			ErrorLog: zap.NewStdLog(log),
 		},
-		logger: logger,
+		log: log,
 	}
 }
 
@@ -79,7 +76,7 @@ func (s *Server) serve(listener net.Listener) <-chan error {
 }
 
 func (s *Server) shutdown(signalCh <-chan os.Signal) error {
-	s.logger.Info("Shutting down server", logger.DurationLiteral("timeout", s.ShutdownTimeout))
+	s.log.Info("Shutting down server", logger.DurationLiteral("timeout", s.ShutdownTimeout))
 
 	// The shutdown needs to succeed in 20 seconds or less.
 	ctx, cancel := context.WithTimeout(context.Background(), s.ShutdownTimeout)
@@ -94,7 +91,7 @@ func (s *Server) shutdown(signalCh <-chan os.Signal) error {
 		defer s.wg.Done()
 		select {
 		case <-signalCh:
-			s.logger.Info("Initializing hard shutdown")
+			s.log.Info("Initializing hard shutdown")
 			cancel()
 		case <-done:
 		}
@@ -135,13 +132,13 @@ func (s *Server) notifyOnSignals() (_ <-chan os.Signal, cancel func()) {
 // ListenAndServe is a convenience method for opening a listener using the address
 // and then serving the handler on that address. This method sets up the typical
 // signal handlers.
-func ListenAndServe(addr string, handler http.Handler, logger *zap.Logger) error {
+func ListenAndServe(log *zap.Logger, addr string, handler http.Handler) error {
 	l, err := net.Listen("tcp", addr)
 	if err != nil {
 		return err
 	}
 
-	server := NewServer(handler, logger)
+	server := NewServer(log, handler)
 	server.ListenForSignals(os.Interrupt, syscall.SIGTERM)
 	return server.Serve(l)
 }

http/session_handler.go

@@ -12,7 +12,7 @@ import (
 // SessionBackend is all services and associated parameters required to construct
 // the SessionHandler.
 type SessionBackend struct {
-	Logger *zap.Logger
+	log *zap.Logger
 	platform.HTTPErrorHandler
 
 	PasswordsService platform.PasswordsService
@@ -21,10 +21,10 @@ type SessionBackend struct {
 }
 
 // newSessionBackend creates a new SessionBackend with associated logger.
-func newSessionBackend(b *APIBackend) *SessionBackend {
+func newSessionBackend(log *zap.Logger, b *APIBackend) *SessionBackend {
 	return &SessionBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "session")),
+		log:              log,
 
 		PasswordsService: b.PasswordsService,
 		SessionService:   b.SessionService,
@@ -36,7 +36,7 @@ func newSessionBackend(b *APIBackend) *SessionBackend {
 type SessionHandler struct {
 	*httprouter.Router
 	platform.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	PasswordsService platform.PasswordsService
 	SessionService   platform.SessionService
@@ -44,11 +44,11 @@ type SessionHandler struct {
 }
 
 // NewSessionHandler returns a new instance of SessionHandler.
-func NewSessionHandler(b *SessionBackend) *SessionHandler {
+func NewSessionHandler(log *zap.Logger, b *SessionBackend) *SessionHandler {
 	h := &SessionHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger,
+		log:              log,
 
 		PasswordsService: b.PasswordsService,
 		SessionService:   b.SessionService,

http/session_test.go

@@ -1,4 +1,4 @@
-package http_test
+package http
 
 import (
 	"context"
@@ -7,21 +7,19 @@ import (
 	"testing"
 	"time"
 
-	"go.uber.org/zap"
-
 	platform "github.com/influxdata/influxdb"
-	platformhttp "github.com/influxdata/influxdb/http"
 	"github.com/influxdata/influxdb/mock"
+	"go.uber.org/zap/zaptest"
 )
 
 // NewMockSessionBackend returns a SessionBackend with mock services.
-func NewMockSessionBackend() *platformhttp.SessionBackend {
+func NewMockSessionBackend(t *testing.T) *SessionBackend {
 	userSVC := mock.NewUserService()
 	userSVC.FindUserFn = func(_ context.Context, f platform.UserFilter) (*platform.User, error) {
 		return &platform.User{ID: 1}, nil
 	}
-	return &platformhttp.SessionBackend{
-		Logger: zap.NewNop(),
+	return &SessionBackend{
+		log: zaptest.NewLogger(t),
 
 		SessionService:   mock.NewSessionService(),
 		PasswordsService: mock.NewPasswordsService(),
@@ -82,10 +80,10 @@ func TestSessionHandler_handleSignin(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			b := NewMockSessionBackend()
+			b := NewMockSessionBackend(t)
 			b.PasswordsService = tt.fields.PasswordsService
 			b.SessionService = tt.fields.SessionService
-			h := platformhttp.NewSessionHandler(b)
+			h := NewSessionHandler(zaptest.NewLogger(t), b)
 
 			w := httptest.NewRecorder()
 			r := httptest.NewRequest("POST", "http://localhost:9999/api/v2/signin", nil)

http/source_service.go

@@ -79,7 +79,7 @@ func newSourcesResponse(srcs []*platform.Source) *sourcesResponse {
 // the SourceHandler.
 type SourceBackend struct {
 	platform.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	SourceService   platform.SourceService
 	LabelService    platform.LabelService
@@ -88,10 +88,10 @@ type SourceBackend struct {
 }
 
 // NewSourceBackend returns a new instance of SourceBackend.
-func NewSourceBackend(b *APIBackend) *SourceBackend {
+func NewSourceBackend(log *zap.Logger, b *APIBackend) *SourceBackend {
 	return &SourceBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "source")),
+		log:              log,
 
 		SourceService:   b.SourceService,
 		LabelService:    b.LabelService,
@@ -104,7 +104,7 @@ func NewSourceBackend(b *APIBackend) *SourceBackend {
 type SourceHandler struct {
 	*httprouter.Router
 	platform.HTTPErrorHandler
-	Logger        *zap.Logger
+	log           *zap.Logger
 	SourceService platform.SourceService
 	LabelService  platform.LabelService
 	BucketService platform.BucketService
@@ -115,11 +115,11 @@ type SourceHandler struct {
 }
 
 // NewSourceHandler returns a new instance of SourceHandler.
-func NewSourceHandler(b *SourceBackend) *SourceHandler {
+func NewSourceHandler(log *zap.Logger, b *SourceBackend) *SourceHandler {
 	h := &SourceHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger,
+		log:              log,
 
 		SourceService:   b.SourceService,
 		LabelService:    b.LabelService,
@@ -244,7 +244,7 @@ func (h *SourceHandler) handleGetSourcesBuckets(w http.ResponseWriter, r *http.R
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newBucketsResponse(ctx, req.opts, req.filter, bs, h.LabelService)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -284,9 +284,9 @@ func (h *SourceHandler) handlePostSource(w http.ResponseWriter, r *http.Request)
 	}
 
 	res := newSourceResponse(req.Source)
-	h.Logger.Debug("source created", zap.String("source", fmt.Sprint(res)))
+	h.log.Debug("Source created", zap.String("source", fmt.Sprint(res)))
 	if err := encodeResponse(ctx, w, http.StatusCreated, res); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -322,10 +322,10 @@ func (h *SourceHandler) handleGetSource(w http.ResponseWriter, r *http.Request)
 	}
 
 	res := newSourceResponse(s)
-	h.Logger.Debug("source retrieved", zap.String("source", fmt.Sprint(res)))
+	h.log.Debug("Source retrieved", zap.String("source", fmt.Sprint(res)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, res); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -392,7 +392,7 @@ func (h *SourceHandler) handleDeleteSource(w http.ResponseWriter, r *http.Reques
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("source deleted", zap.String("sourceID", fmt.Sprint(req.SourceID)))
+	h.log.Debug("Source deleted", zap.String("sourceID", fmt.Sprint(req.SourceID)))
 
 	w.WriteHeader(http.StatusNoContent)
 }
@@ -438,10 +438,10 @@ func (h *SourceHandler) handleGetSources(w http.ResponseWriter, r *http.Request)
 	}
 
 	res := newSourcesResponse(srcs)
-	h.Logger.Debug("sources retrieved", zap.String("sources", fmt.Sprint(res)))
+	h.log.Debug("Sources retrieved", zap.String("sources", fmt.Sprint(res)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, res); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -469,10 +469,10 @@ func (h *SourceHandler) handlePatchSource(w http.ResponseWriter, r *http.Request
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("source updated", zap.String("source", fmt.Sprint(b)))
+	h.log.Debug("Source updated", zap.String("source", fmt.Sprint(b)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, b); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }

http/swagger.go

@@ -17,7 +17,7 @@ var _ http.Handler = (*swaggerLoader)(nil)
 // swaggerLoader manages loading the swagger asset and serving it as JSON.
 type swaggerLoader struct {
 	influxdb.HTTPErrorHandler
-	logger *zap.Logger
+	log *zap.Logger
 
 	// Ensure we only call initialize once.
 	once sync.Once
@@ -29,8 +29,11 @@ type swaggerLoader struct {
 	loadErr error
 }
 
-func newSwaggerLoader(logger *zap.Logger, h influxdb.HTTPErrorHandler) *swaggerLoader {
-	return &swaggerLoader{logger: logger, HTTPErrorHandler: h}
+func newSwaggerLoader(log *zap.Logger, h influxdb.HTTPErrorHandler) *swaggerLoader {
+	return &swaggerLoader{
+		log:              log,
+		HTTPErrorHandler: h,
+	}
 }
 
 func (s *swaggerLoader) initialize() {

http/swagger_noassets.go

@@ -24,7 +24,7 @@ func (s *swaggerLoader) asset(swaggerData []byte, _ error) ([]byte, error) {
 		return swaggerData, nil
 	}
 
-	path := findSwaggerPath(s.logger)
+	path := findSwaggerPath(s.log)
 	if path == "" {
 		// Couldn't find it.
 		return nil, errors.New("this developer binary not built with assets, and could not locate swagger.yml on disk")
@@ -32,18 +32,18 @@ func (s *swaggerLoader) asset(swaggerData []byte, _ error) ([]byte, error) {
 
 	b, err := ioutil.ReadFile(path)
 	if err != nil {
-		s.logger.Info("Unable to load swagger.yml from disk", zap.String("path", path), zap.Error(err))
+		s.log.Info("Unable to load swagger.yml from disk", zap.String("path", path), zap.Error(err))
 		return nil, errors.New("this developer binary not built with assets, and unable to load swagger.yml from disk")
 	}
 
-	s.logger.Info("Successfully loaded swagger.yml", zap.String("path", path))
+	s.log.Info("Successfully loaded swagger.yml", zap.String("path", path))
 
 	return b, nil
 }
 
 // findSwaggerPath makes a best-effort to find the path of the swagger file on disk.
 // If it can't find the path, it returns the empty string.
-func findSwaggerPath(logger *zap.Logger) string {
+func findSwaggerPath(log *zap.Logger) string {
 	// First, look for environment variable pointing at swagger.
 	path := os.Getenv("INFLUXDB_VALID_SWAGGER_PATH")
 	if path != "" {
@@ -51,13 +51,13 @@ func findSwaggerPath(logger *zap.Logger) string {
 		return path
 	}
 
-	logger.Info("INFLUXDB_VALID_SWAGGER_PATH not set; falling back to checking relative paths")
+	log.Info("INFLUXDB_VALID_SWAGGER_PATH not set; falling back to checking relative paths")
 
 	// Get the path to the executable so we can do a relative lookup.
 	execPath, err := os.Executable()
 	if err != nil {
 		// Give up.
-		logger.Info("Can't determine path of currently running executable", zap.Error(err))
+		log.Info("Can't determine path of currently running executable", zap.Error(err))
 		return ""
 	}
 
@@ -87,6 +87,6 @@ func findSwaggerPath(logger *zap.Logger) string {
 		}
 	}
 
-	logger.Info("Couldn't guess path to swagger definition")
+	log.Info("Couldn't guess path to swagger definition")
 	return ""
 }

http/task_service.go

@@ -26,7 +26,7 @@ import (
 // the TaskHandler.
 type TaskBackend struct {
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	TaskService                influxdb.TaskService
 	AuthorizationService       influxdb.AuthorizationService
@@ -38,10 +38,10 @@ type TaskBackend struct {
 }
 
 // NewTaskBackend returns a new instance of TaskBackend.
-func NewTaskBackend(b *APIBackend) *TaskBackend {
+func NewTaskBackend(log *zap.Logger, b *APIBackend) *TaskBackend {
 	return &TaskBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "task")),
+		log:                        log,
 		TaskService:                b.TaskService,
 		AuthorizationService:       b.AuthorizationService,
 		OrganizationService:        b.OrganizationService,
@@ -56,7 +56,7 @@ func NewTaskBackend(b *APIBackend) *TaskBackend {
 type TaskHandler struct {
 	*httprouter.Router
 	influxdb.HTTPErrorHandler
-	logger *zap.Logger
+	log *zap.Logger
 
 	TaskService                influxdb.TaskService
 	AuthorizationService       influxdb.AuthorizationService
@@ -84,11 +84,11 @@ const (
 )
 
 // NewTaskHandler returns a new instance of TaskHandler.
-func NewTaskHandler(b *TaskBackend) *TaskHandler {
+func NewTaskHandler(log *zap.Logger, b *TaskBackend) *TaskHandler {
 	h := &TaskHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		logger:           b.Logger,
+		log:              log,
 
 		TaskService:                b.TaskService,
 		AuthorizationService:       b.AuthorizationService,
@@ -111,7 +111,7 @@ func NewTaskHandler(b *TaskBackend) *TaskHandler {
 
 	memberBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               influxdb.TasksResourceType,
 		UserType:                   influxdb.Member,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -123,7 +123,7 @@ func NewTaskHandler(b *TaskBackend) *TaskHandler {
 
 	ownerBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               influxdb.TasksResourceType,
 		UserType:                   influxdb.Owner,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -141,7 +141,7 @@ func NewTaskHandler(b *TaskBackend) *TaskHandler {
 
 	labelBackend := &LabelBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "label")),
+		log:              b.log.With(zap.String("handler", "label")),
 		LabelService:     b.LabelService,
 		ResourceType:     influxdb.TasksResourceType,
 	}
@@ -440,9 +440,9 @@ func (h *TaskHandler) handleGetTasks(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.logger.Debug("tasks retrived", zap.String("tasks", fmt.Sprint(tasks)))
+	h.log.Debug("Tasks retrived", zap.String("tasks", fmt.Sprint(tasks)))
 	if err := encodeResponse(ctx, w, http.StatusOK, newTasksResponse(ctx, tasks, req.filter, h.LabelService)); err != nil {
-		logEncodingError(h.logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -566,7 +566,7 @@ func (h *TaskHandler) handlePostTask(w http.ResponseWriter, r *http.Request) {
 	task, err := h.TaskService.CreateTask(ctx, req.TaskCreate)
 	if err != nil {
 		if e, ok := err.(AuthzError); ok {
-			h.logger.Error("failed authentication", zap.Errors("error messages", []error{err, e.AuthzError()}))
+			h.log.Error("Failed authentication", zap.Errors("error messages", []error{err, e.AuthzError()}))
 		}
 
 		// if the error is not already a influxdb.error then make it into one
@@ -583,7 +583,7 @@ func (h *TaskHandler) handlePostTask(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, newTaskResponse(*task, []*influxdb.Label{})); err != nil {
-		logEncodingError(h.logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -650,9 +650,9 @@ func (h *TaskHandler) handleGetTask(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.logger.Debug("task retrived", zap.String("tasks", fmt.Sprint(task)))
+	h.log.Debug("Task retrieved", zap.String("tasks", fmt.Sprint(task)))
 	if err := encodeResponse(ctx, w, http.StatusOK, newTaskResponse(*task, labels)); err != nil {
-		logEncodingError(h.logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -717,9 +717,9 @@ func (h *TaskHandler) handleUpdateTask(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.logger.Debug("tasks updated", zap.String("task", fmt.Sprint(task)))
+	h.log.Debug("Tasks updated", zap.String("task", fmt.Sprint(task)))
 	if err := encodeResponse(ctx, w, http.StatusOK, newTaskResponse(*task, labels)); err != nil {
-		logEncodingError(h.logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -783,7 +783,7 @@ func (h *TaskHandler) handleDeleteTask(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.logger.Debug("tasks deleted", zap.String("taskID", fmt.Sprint(req.TaskID)))
+	h.log.Debug("Tasks deleted", zap.String("taskID", fmt.Sprint(req.TaskID)))
 	w.WriteHeader(http.StatusNoContent)
 }
 
@@ -862,7 +862,7 @@ func (h *TaskHandler) handleGetLogs(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, &getLogsResponse{Events: logs}); err != nil {
-		logEncodingError(h.logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -954,7 +954,7 @@ func (h *TaskHandler) handleGetRuns(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newRunsResponse(runs, req.filter.Task)); err != nil {
-		logEncodingError(h.logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -1057,7 +1057,7 @@ func (h *TaskHandler) handleForceRun(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	if err := encodeResponse(ctx, w, http.StatusCreated, newRunResponse(*run)); err != nil {
-		logEncodingError(h.logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -1157,7 +1157,7 @@ func (h *TaskHandler) handleGetRun(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newRunResponse(*run)); err != nil {
-		logEncodingError(h.logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -1313,7 +1313,7 @@ func (h *TaskHandler) handleRetryRun(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	if err := encodeResponse(ctx, w, http.StatusOK, newRunResponse(*run)); err != nil {
-		logEncodingError(h.logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }

http/task_service_test.go

@@ -13,6 +13,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/influxdata/httprouter"
 	platform "github.com/influxdata/influxdb"
 	pcontext "github.com/influxdata/influxdb/context"
 	"github.com/influxdata/influxdb/inmem"
@@ -20,7 +21,6 @@ import (
 	_ "github.com/influxdata/influxdb/query/builtin"
 	"github.com/influxdata/influxdb/task/backend"
 	platformtesting "github.com/influxdata/influxdb/testing"
-	"github.com/influxdata/httprouter"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zaptest"
 )
@@ -28,7 +28,7 @@ import (
 // NewMockTaskBackend returns a TaskBackend with mock services.
 func NewMockTaskBackend(t *testing.T) *TaskBackend {
 	return &TaskBackend{
-		Logger: zaptest.NewLogger(t).With(zap.String("handler", "task")),
+		log: zaptest.NewLogger(t).With(zap.String("handler", "task")),
 
 		AuthorizationService: mock.NewAuthorizationService(),
 		TaskService:          &mock.TaskService{},
@@ -395,7 +395,7 @@ func TestTaskHandler_handleGetTasks(t *testing.T) {
 			taskBackend.HTTPErrorHandler = ErrorHandler(0)
 			taskBackend.TaskService = tt.fields.taskService
 			taskBackend.LabelService = tt.fields.labelService
-			h := NewTaskHandler(taskBackend)
+			h := NewTaskHandler(zaptest.NewLogger(t), taskBackend)
 			h.handleGetTasks(w, r)
 
 			res := w.Result()
@@ -561,7 +561,7 @@ func TestTaskHandler_handlePostTasks(t *testing.T) {
 			taskBackend := NewMockTaskBackend(t)
 			taskBackend.HTTPErrorHandler = ErrorHandler(0)
 			taskBackend.TaskService = tt.fields.taskService
-			h := NewTaskHandler(taskBackend)
+			h := NewTaskHandler(zaptest.NewLogger(t), taskBackend)
 			h.handlePostTask(w, r)
 
 			res := w.Result()
@@ -675,7 +675,7 @@ func TestTaskHandler_handleGetRun(t *testing.T) {
 			taskBackend := NewMockTaskBackend(t)
 			taskBackend.HTTPErrorHandler = ErrorHandler(0)
 			taskBackend.TaskService = tt.fields.taskService
-			h := NewTaskHandler(taskBackend)
+			h := NewTaskHandler(zaptest.NewLogger(t), taskBackend)
 			h.handleGetRun(w, r)
 
 			res := w.Result()
@@ -793,7 +793,7 @@ func TestTaskHandler_handleGetRuns(t *testing.T) {
 			taskBackend := NewMockTaskBackend(t)
 			taskBackend.HTTPErrorHandler = ErrorHandler(0)
 			taskBackend.TaskService = tt.fields.taskService
-			h := NewTaskHandler(taskBackend)
+			h := NewTaskHandler(zaptest.NewLogger(t), taskBackend)
 			h.handleGetRuns(w, r)
 
 			res := w.Result()
@@ -823,7 +823,7 @@ func TestTaskHandler_NotFoundStatus(t *testing.T) {
 	im := inmem.NewService()
 	taskBackend := NewMockTaskBackend(t)
 	taskBackend.HTTPErrorHandler = ErrorHandler(0)
-	h := NewTaskHandler(taskBackend)
+	h := NewTaskHandler(zaptest.NewLogger(t), taskBackend)
 	h.UserResourceMappingService = im
 	h.LabelService = im
 	h.UserService = im
@@ -1173,7 +1173,7 @@ func TestService_handlePostTaskLabel(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			taskBE := NewMockTaskBackend(t)
 			taskBE.LabelService = tt.fields.LabelService
-			h := NewTaskHandler(taskBE)
+			h := NewTaskHandler(zaptest.NewLogger(t), taskBE)
 
 			b, err := json.Marshal(tt.args.labelMapping)
 			if err != nil {
@@ -1248,8 +1248,8 @@ func TestTaskHandler_CreateTaskWithOrgName(t *testing.T) {
 		},
 	}
 
-	h := NewTaskHandler(&TaskBackend{
-		Logger: zaptest.NewLogger(t),
+	h := NewTaskHandler(zaptest.NewLogger(t), &TaskBackend{
+		log: zaptest.NewLogger(t),
 
 		TaskService:                ts,
 		AuthorizationService:       i,
@@ -1344,9 +1344,9 @@ func TestTaskHandler_Sessions(t *testing.T) {
 	})
 
 	newHandler := func(t *testing.T, ts *mock.TaskService) *TaskHandler {
-		return NewTaskHandler(&TaskBackend{
+		return NewTaskHandler(zaptest.NewLogger(t), &TaskBackend{
 			HTTPErrorHandler: ErrorHandler(0),
-			Logger:           zaptest.NewLogger(t),
+			log:              zaptest.NewLogger(t),
 
 			TaskService:                ts,
 			AuthorizationService:       i,

http/telegraf.go

@@ -23,7 +23,7 @@ import (
 // the TelegrafHandler.
 type TelegrafBackend struct {
 	platform.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	TelegrafService            platform.TelegrafConfigStore
 	UserResourceMappingService platform.UserResourceMappingService
@@ -33,10 +33,10 @@ type TelegrafBackend struct {
 }
 
 // NewTelegrafBackend returns a new instance of TelegrafBackend.
-func NewTelegrafBackend(b *APIBackend) *TelegrafBackend {
+func NewTelegrafBackend(log *zap.Logger, b *APIBackend) *TelegrafBackend {
 	return &TelegrafBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "telegraf")),
+		log:              log,
 
 		TelegrafService:            b.TelegrafService,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -50,7 +50,7 @@ func NewTelegrafBackend(b *APIBackend) *TelegrafBackend {
 type TelegrafHandler struct {
 	*httprouter.Router
 	platform.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	TelegrafService            platform.TelegrafConfigStore
 	UserResourceMappingService platform.UserResourceMappingService
@@ -71,11 +71,11 @@ const (
 )
 
 // NewTelegrafHandler returns a new instance of TelegrafHandler.
-func NewTelegrafHandler(b *TelegrafBackend) *TelegrafHandler {
+func NewTelegrafHandler(log *zap.Logger, b *TelegrafBackend) *TelegrafHandler {
 	h := &TelegrafHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger,
+		log:              log,
 
 		TelegrafService:            b.TelegrafService,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -91,7 +91,7 @@ func NewTelegrafHandler(b *TelegrafBackend) *TelegrafHandler {
 
 	memberBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               platform.TelegrafsResourceType,
 		UserType:                   platform.Member,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -103,7 +103,7 @@ func NewTelegrafHandler(b *TelegrafBackend) *TelegrafHandler {
 
 	ownerBackend := MemberBackend{
 		HTTPErrorHandler:           b.HTTPErrorHandler,
-		Logger:                     b.Logger.With(zap.String("handler", "member")),
+		log:                        b.log.With(zap.String("handler", "member")),
 		ResourceType:               platform.TelegrafsResourceType,
 		UserType:                   platform.Owner,
 		UserResourceMappingService: b.UserResourceMappingService,
@@ -115,7 +115,7 @@ func NewTelegrafHandler(b *TelegrafBackend) *TelegrafHandler {
 
 	labelBackend := &LabelBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "label")),
+		log:              b.log.With(zap.String("handler", "label")),
 		LabelService:     b.LabelService,
 		ResourceType:     platform.TelegrafsResourceType,
 	}
@@ -242,7 +242,7 @@ func (h *TelegrafHandler) handleGetTelegrafs(w http.ResponseWriter, r *http.Requ
 	ctx := r.Context()
 	filter, err := decodeTelegrafConfigFilter(ctx, r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -251,10 +251,10 @@ func (h *TelegrafHandler) handleGetTelegrafs(w http.ResponseWriter, r *http.Requ
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("telegrafs retrieved", zap.String("telegrafs", fmt.Sprint(tcs)))
+	h.log.Debug("Telegrafs retrieved", zap.String("telegrafs", fmt.Sprint(tcs)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newTelegrafResponses(ctx, tcs, h.LabelService)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -271,7 +271,7 @@ func (h *TelegrafHandler) handleGetTelegraf(w http.ResponseWriter, r *http.Reque
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("telegraf retrieved", zap.String("telegraf", fmt.Sprint(tc)))
+	h.log.Debug("Telegraf retrieved", zap.String("telegraf", fmt.Sprint(tc)))
 
 	offers := []string{"application/toml", "application/json", "application/octet-stream"}
 	defaultOffer := "application/toml"
@@ -290,7 +290,7 @@ func (h *TelegrafHandler) handleGetTelegraf(w http.ResponseWriter, r *http.Reque
 		}
 
 		if err := encodeResponse(ctx, w, http.StatusOK, newTelegrafResponse(tc, labels)); err != nil {
-			logEncodingError(h.Logger, r, err)
+			logEncodingError(h.log, r, err)
 			return
 		}
 	case "application/toml":
@@ -356,7 +356,7 @@ func (h *TelegrafHandler) handlePostTelegraf(w http.ResponseWriter, r *http.Requ
 	ctx := r.Context()
 	tc, err := decodePostTelegrafRequest(r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -370,10 +370,10 @@ func (h *TelegrafHandler) handlePostTelegraf(w http.ResponseWriter, r *http.Requ
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("telegraf created", zap.String("telegraf", fmt.Sprint(tc)))
+	h.log.Debug("Telegraf created", zap.String("telegraf", fmt.Sprint(tc)))
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, newTelegrafResponse(tc, []*platform.Label{})); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -383,7 +383,7 @@ func (h *TelegrafHandler) handlePutTelegraf(w http.ResponseWriter, r *http.Reque
 	ctx := r.Context()
 	tc, err := decodePutTelegrafRequest(ctx, r)
 	if err != nil {
-		h.Logger.Debug("failed to decode request", zap.Error(err))
+		h.log.Debug("Failed to decode request", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -404,10 +404,10 @@ func (h *TelegrafHandler) handlePutTelegraf(w http.ResponseWriter, r *http.Reque
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("telegraf updated", zap.String("telegraf", fmt.Sprint(tc)))
+	h.log.Debug("Telegraf updated", zap.String("telegraf", fmt.Sprint(tc)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newTelegrafResponse(tc, labels)); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -424,7 +424,7 @@ func (h *TelegrafHandler) handleDeleteTelegraf(w http.ResponseWriter, r *http.Re
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("telegraf deleted", zap.String("telegrafID", fmt.Sprint(i)))
+	h.log.Debug("Telegraf deleted", zap.String("telegrafID", fmt.Sprint(i)))
 
 	w.WriteHeader(http.StatusNoContent)
 }

http/telegraf_test.go

@@ -10,18 +10,17 @@ import (
 	"strings"
 	"testing"
 
-	"go.uber.org/zap"
-
 	platform "github.com/influxdata/influxdb"
 	"github.com/influxdata/influxdb/mock"
 	"github.com/influxdata/influxdb/telegraf/plugins/inputs"
 	"github.com/influxdata/influxdb/telegraf/plugins/outputs"
+	"go.uber.org/zap/zaptest"
 )
 
 // NewMockTelegrafBackend returns a TelegrafBackend with mock services.
-func NewMockTelegrafBackend() *TelegrafBackend {
+func NewMockTelegrafBackend(t *testing.T) *TelegrafBackend {
 	return &TelegrafBackend{
-		Logger: zap.NewNop().With(zap.String("handler", "telegraf")),
+		log: zaptest.NewLogger(t),
 
 		TelegrafService:            &mock.TelegrafConfigStore{},
 		UserResourceMappingService: mock.NewUserResourceMappingService(),
@@ -186,9 +185,9 @@ func TestTelegrafHandler_handleGetTelegrafs(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			w := httptest.NewRecorder()
-			telegrafBackend := NewMockTelegrafBackend()
+			telegrafBackend := NewMockTelegrafBackend(t)
 			telegrafBackend.TelegrafService = tt.svc
-			h := NewTelegrafHandler(telegrafBackend)
+			h := NewTelegrafHandler(zaptest.NewLogger(t), telegrafBackend)
 			h.ServeHTTP(w, tt.r)
 
 			res := w.Result()
@@ -726,9 +725,9 @@ func TestTelegrafHandler_handleGetTelegraf(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			tt.r.Header.Set("Accept", tt.acceptHeader)
 			w := httptest.NewRecorder()
-			telegrafBackend := NewMockTelegrafBackend()
+			telegrafBackend := NewMockTelegrafBackend(t)
 			telegrafBackend.TelegrafService = tt.svc
-			h := NewTelegrafHandler(telegrafBackend)
+			h := NewTelegrafHandler(zaptest.NewLogger(t), telegrafBackend)
 
 			h.ServeHTTP(w, tt.r)
 

http/usage_service.go

@@ -15,16 +15,16 @@ import (
 type UsageHandler struct {
 	*httprouter.Router
 	platform.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	UsageService platform.UsageService
 }
 
 // NewUsageHandler returns a new instance of UsageHandler.
-func NewUsageHandler(he platform.HTTPErrorHandler) *UsageHandler {
+func NewUsageHandler(log *zap.Logger, he platform.HTTPErrorHandler) *UsageHandler {
 	h := &UsageHandler{
 		Router: NewRouter(he),
-		Logger: zap.NewNop(),
+		log:    log,
 	}
 
 	h.HandlerFunc("GET", "/api/v2/usage", h.handleGetUsage)
@@ -48,7 +48,7 @@ func (h *UsageHandler) handleGetUsage(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if err := encodeResponse(ctx, w, http.StatusOK, b); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }

http/user_resource_mapping_service.go

@@ -56,7 +56,7 @@ func newResourceUsersResponse(opts influxdb.FindOptions, f influxdb.UserResource
 // member handler.
 type MemberBackend struct {
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	ResourceType influxdb.ResourceType
 	UserType     influxdb.UserType
@@ -92,7 +92,7 @@ func newPostMemberHandler(b MemberBackend) http.HandlerFunc {
 			b.HandleHTTPError(ctx, err, w)
 			return
 		}
-		b.Logger.Debug("member/owner created", zap.String("mapping", fmt.Sprint(mapping)))
+		b.log.Debug("Member/owner created", zap.String("mapping", fmt.Sprint(mapping)))
 
 		if err := encodeResponse(ctx, w, http.StatusCreated, newResourceUserResponse(user, b.UserType)); err != nil {
 			b.HandleHTTPError(ctx, err, w)
@@ -175,7 +175,7 @@ func newGetMembersHandler(b MemberBackend) http.HandlerFunc {
 
 			users = append(users, user)
 		}
-		b.Logger.Debug("members/owners retrieved", zap.String("users", fmt.Sprint(users)))
+		b.log.Debug("Members/owners retrieved", zap.String("users", fmt.Sprint(users)))
 
 		if err := encodeResponse(ctx, w, http.StatusOK, newResourceUsersResponse(opts, filter, users)); err != nil {
 			b.HandleHTTPError(ctx, err, w)
@@ -225,7 +225,7 @@ func newDeleteMemberHandler(b MemberBackend) http.HandlerFunc {
 			b.HandleHTTPError(ctx, err, w)
 			return
 		}
-		b.Logger.Debug("member deleted", zap.String("resourceID", req.ResourceID.String()), zap.String("memberID", req.MemberID.String()))
+		b.log.Debug("Member deleted", zap.String("resourceID", req.ResourceID.String()), zap.String("memberID", req.MemberID.String()))
 
 		w.WriteHeader(http.StatusNoContent)
 	}

http/user_resource_mapping_test.go

@@ -10,11 +10,10 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"go.uber.org/zap"
-
+	"github.com/influxdata/httprouter"
 	platform "github.com/influxdata/influxdb"
 	"github.com/influxdata/influxdb/mock"
-	"github.com/influxdata/httprouter"
+	"go.uber.org/zap/zaptest"
 )
 
 func TestUserResourceMappingService_GetMembersHandler(t *testing.T) {
@@ -197,7 +196,7 @@ func TestUserResourceMappingService_GetMembersHandler(t *testing.T) {
 
 				w := httptest.NewRecorder()
 				memberBackend := MemberBackend{
-					Logger:                     zap.NewNop().With(zap.String("handler", "member")),
+					log:                        zaptest.NewLogger(t),
 					ResourceType:               resourceType,
 					UserType:                   tt.args.userType,
 					UserResourceMappingService: tt.fields.userResourceMappingService,
@@ -358,7 +357,7 @@ func TestUserResourceMappingService_PostMembersHandler(t *testing.T) {
 
 				w := httptest.NewRecorder()
 				memberBackend := MemberBackend{
-					Logger:                     zap.NewNop().With(zap.String("handler", "member")),
+					log:                        zaptest.NewLogger(t),
 					ResourceType:               resourceType,
 					UserType:                   tt.args.userType,
 					UserResourceMappingService: tt.fields.userResourceMappingService,

http/user_service.go

@@ -18,17 +18,17 @@ import (
 // the UserHandler.
 type UserBackend struct {
 	influxdb.HTTPErrorHandler
-	Logger                  *zap.Logger
+	log                     *zap.Logger
 	UserService             influxdb.UserService
 	UserOperationLogService influxdb.UserOperationLogService
 	PasswordsService        influxdb.PasswordsService
 }
 
 // NewUserBackend creates a UserBackend using information in the APIBackend.
-func NewUserBackend(b *APIBackend) *UserBackend {
+func NewUserBackend(log *zap.Logger, b *APIBackend) *UserBackend {
 	return &UserBackend{
 		HTTPErrorHandler:        b.HTTPErrorHandler,
-		Logger:                  b.Logger.With(zap.String("handler", "user")),
+		log:                     log,
 		UserService:             b.UserService,
 		UserOperationLogService: b.UserOperationLogService,
 		PasswordsService:        b.PasswordsService,
@@ -39,7 +39,7 @@ func NewUserBackend(b *APIBackend) *UserBackend {
 type UserHandler struct {
 	*httprouter.Router
 	influxdb.HTTPErrorHandler
-	Logger                  *zap.Logger
+	log                     *zap.Logger
 	UserService             influxdb.UserService
 	UserOperationLogService influxdb.UserOperationLogService
 	PasswordsService        influxdb.PasswordsService
@@ -55,11 +55,11 @@ const (
 )
 
 // NewUserHandler returns a new instance of UserHandler.
-func NewUserHandler(b *UserBackend) *UserHandler {
+func NewUserHandler(log *zap.Logger, b *UserBackend) *UserHandler {
 	h := &UserHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger,
+		log:              log,
 
 		UserService:             b.UserService,
 		UserOperationLogService: b.UserOperationLogService,
@@ -148,7 +148,7 @@ func (h *UserHandler) handlePutUserPassword(w http.ResponseWriter, r *http.Reque
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("user password updated")
+	h.log.Debug("User password updated")
 	w.WriteHeader(http.StatusNoContent)
 }
 
@@ -201,7 +201,7 @@ func (h *UserHandler) handlePostUser(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("user created", zap.String("user", fmt.Sprint(req.User)))
+	h.log.Debug("User created", zap.String("user", fmt.Sprint(req.User)))
 
 	if err := encodeResponse(ctx, w, http.StatusCreated, newUserResponse(req.User)); err != nil {
 		h.HandleHTTPError(ctx, err, w)
@@ -261,7 +261,7 @@ func (h *UserHandler) handleGetUser(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("user retrieved", zap.String("user", fmt.Sprint(b)))
+	h.log.Debug("User retrieved", zap.String("user", fmt.Sprint(b)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newUserResponse(b)); err != nil {
 		h.HandleHTTPError(ctx, err, w)
@@ -308,7 +308,7 @@ func (h *UserHandler) handleDeleteUser(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("user deleted", zap.String("userID", fmt.Sprint(req.UserID)))
+	h.log.Debug("User deleted", zap.String("userID", fmt.Sprint(req.UserID)))
 
 	w.WriteHeader(http.StatusNoContent)
 }
@@ -393,7 +393,7 @@ func (h *UserHandler) handleGetUsers(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("users retrieved", zap.String("users", fmt.Sprint(users)))
+	h.log.Debug("Users retrieved", zap.String("users", fmt.Sprint(users)))
 
 	err = encodeResponse(ctx, w, http.StatusOK, newUsersResponse(users))
 	if err != nil {
@@ -439,7 +439,7 @@ func (h *UserHandler) handlePatchUser(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("users updated", zap.String("user", fmt.Sprint(b)))
+	h.log.Debug("Users updated", zap.String("user", fmt.Sprint(b)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newUserResponse(b)); err != nil {
 		h.HandleHTTPError(ctx, err, w)
@@ -747,7 +747,7 @@ func (h *UserHandler) handleGetUserLog(w http.ResponseWriter, r *http.Request) {
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("user log retrieved", zap.String("log", fmt.Sprint(log)))
+	h.log.Debug("User log retrieved", zap.String("log", fmt.Sprint(log)))
 
 	if err := encodeResponse(ctx, w, http.StatusOK, newUserLogResponse(req.UserID, log)); err != nil {
 		h.HandleHTTPError(ctx, err, w)

http/user_test.go

@@ -10,21 +10,19 @@ import (
 	"path"
 	"testing"
 
-	"github.com/stretchr/testify/require"
-
-	"github.com/influxdata/influxdb/pkg/testttp"
-
 	platform "github.com/influxdata/influxdb"
 	"github.com/influxdata/influxdb/inmem"
 	"github.com/influxdata/influxdb/mock"
+	"github.com/influxdata/influxdb/pkg/testttp"
 	platformtesting "github.com/influxdata/influxdb/testing"
-	"go.uber.org/zap"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap/zaptest"
 )
 
 // NewMockUserBackend returns a UserBackend with mock services.
-func NewMockUserBackend() *UserBackend {
+func NewMockUserBackend(t *testing.T) *UserBackend {
 	return &UserBackend{
-		Logger:                  zap.NewNop(),
+		log:                     zaptest.NewLogger(t),
 		UserService:             mock.NewUserService(),
 		UserOperationLogService: mock.NewUserOperationLogService(),
 		PasswordsService:        mock.NewPasswordsService(),
@@ -44,10 +42,10 @@ func initUserService(f platformtesting.UserFields, t *testing.T) (platform.UserS
 		}
 	}
 
-	userBackend := NewMockUserBackend()
+	userBackend := NewMockUserBackend(t)
 	userBackend.HTTPErrorHandler = ErrorHandler(0)
 	userBackend.UserService = svc
-	handler := NewUserHandler(userBackend)
+	handler := NewUserHandler(zaptest.NewLogger(t), userBackend)
 	server := httptest.NewServer(handler)
 	client := UserService{
 		Addr:     server.URL,
@@ -65,7 +63,7 @@ func TestUserService(t *testing.T) {
 }
 
 func TestUserHandler_SettingPassword(t *testing.T) {
-	be := NewMockUserBackend()
+	be := NewMockUserBackend(t)
 	fakePassSVC := mock.NewPasswordsService()
 
 	userID := platform.ID(1)
@@ -80,7 +78,7 @@ func TestUserHandler_SettingPassword(t *testing.T) {
 	}
 	be.PasswordsService = fakePassSVC
 
-	h := NewUserHandler(be)
+	h := NewUserHandler(zaptest.NewLogger(t), be)
 
 	body := newReqBody(t, passwordSetRequest{Password: "newpassword"})
 	addr := path.Join("/api/v2/users", userID.String(), "/password")

http/variable_service.go

@@ -21,16 +21,16 @@ const (
 // the VariableHandler.
 type VariableBackend struct {
 	platform.HTTPErrorHandler
-	Logger          *zap.Logger
+	log             *zap.Logger
 	VariableService platform.VariableService
 	LabelService    platform.LabelService
 }
 
 // NewVariableBackend creates a backend used by the variable handler.
-func NewVariableBackend(b *APIBackend) *VariableBackend {
+func NewVariableBackend(log *zap.Logger, b *APIBackend) *VariableBackend {
 	return &VariableBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "variable")),
+		log:              log,
 		VariableService:  b.VariableService,
 		LabelService:     b.LabelService,
 	}
@@ -41,18 +41,18 @@ type VariableHandler struct {
 	*httprouter.Router
 
 	platform.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	VariableService platform.VariableService
 	LabelService    platform.LabelService
 }
 
 // NewVariableHandler creates a new VariableHandler
-func NewVariableHandler(b *VariableBackend) *VariableHandler {
+func NewVariableHandler(log *zap.Logger, b *VariableBackend) *VariableHandler {
 	h := &VariableHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger,
+		log:              log,
 
 		VariableService: b.VariableService,
 		LabelService:    b.LabelService,
@@ -71,7 +71,7 @@ func NewVariableHandler(b *VariableBackend) *VariableHandler {
 
 	labelBackend := &LabelBackend{
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger.With(zap.String("handler", "label")),
+		log:              b.log.With(zap.String("handler", "label")),
 		LabelService:     b.LabelService,
 		ResourceType:     platform.DashboardsResourceType,
 	}
@@ -158,10 +158,10 @@ func (h *VariableHandler) handleGetVariables(w http.ResponseWriter, r *http.Requ
 		}, w)
 		return
 	}
-	h.Logger.Debug("variables retrieved", zap.String("vars", fmt.Sprint(variables)))
+	h.log.Debug("Variables retrieved", zap.String("vars", fmt.Sprint(variables)))
 	err = encodeResponse(ctx, w, http.StatusOK, newGetVariablesResponse(ctx, variables, req.filter, req.opts, h.LabelService))
 	if err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -203,10 +203,10 @@ func (h *VariableHandler) handleGetVariable(w http.ResponseWriter, r *http.Reque
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("variable retrieved", zap.String("var", fmt.Sprint(variable)))
+	h.log.Debug("Variable retrieved", zap.String("var", fmt.Sprint(variable)))
 	err = encodeResponse(ctx, w, http.StatusOK, newVariableResponse(variable, labels))
 	if err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -253,9 +253,9 @@ func (h *VariableHandler) handlePostVariable(w http.ResponseWriter, r *http.Requ
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("variable created", zap.String("var", fmt.Sprint(req.variable)))
+	h.log.Debug("Variable created", zap.String("var", fmt.Sprint(req.variable)))
 	if err := encodeResponse(ctx, w, http.StatusCreated, newVariableResponse(req.variable, []*platform.Label{})); err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -312,10 +312,10 @@ func (h *VariableHandler) handlePatchVariable(w http.ResponseWriter, r *http.Req
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("variable updated", zap.String("var", fmt.Sprint(variable)))
+	h.log.Debug("Variable updated", zap.String("var", fmt.Sprint(variable)))
 	err = encodeResponse(ctx, w, http.StatusOK, newVariableResponse(variable, labels))
 	if err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -379,10 +379,10 @@ func (h *VariableHandler) handlePutVariable(w http.ResponseWriter, r *http.Reque
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("variable replaced", zap.String("var", fmt.Sprint(req.variable)))
+	h.log.Debug("Variable replaced", zap.String("var", fmt.Sprint(req.variable)))
 	err = encodeResponse(ctx, w, http.StatusOK, newVariableResponse(req.variable, labels))
 	if err != nil {
-		logEncodingError(h.Logger, r, err)
+		logEncodingError(h.log, r, err)
 		return
 	}
 }
@@ -433,7 +433,7 @@ func (h *VariableHandler) handleDeleteVariable(w http.ResponseWriter, r *http.Re
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
-	h.Logger.Debug("variable deleted", zap.String("variableID", fmt.Sprint(id)))
+	h.log.Debug("Variable deleted", zap.String("variableID", fmt.Sprint(id)))
 	w.WriteHeader(http.StatusNoContent)
 }
 

http/variable_test.go

@@ -11,20 +11,19 @@ import (
 	"testing"
 	"time"
 
-	"go.uber.org/zap"
-
+	"github.com/influxdata/httprouter"
 	platform "github.com/influxdata/influxdb"
 	"github.com/influxdata/influxdb/mock"
 	platformtesting "github.com/influxdata/influxdb/testing"
-	"github.com/influxdata/httprouter"
+	"go.uber.org/zap/zaptest"
 )
 
 var faketime = time.Date(2006, 5, 4, 1, 2, 3, 0, time.UTC)
 
 // NewMockVariableBackend returns a VariableBackend with mock services.
-func NewMockVariableBackend() *VariableBackend {
+func NewMockVariableBackend(t *testing.T) *VariableBackend {
 	return &VariableBackend{
-		Logger:          zap.NewNop().With(zap.String("handler", "variable")),
+		log:             zaptest.NewLogger(t),
 		VariableService: mock.NewVariableService(),
 		LabelService:    mock.NewLabelService(),
 	}
@@ -294,11 +293,11 @@ func TestVariableService_handleGetVariables(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			variableBackend := NewMockVariableBackend()
+			variableBackend := NewMockVariableBackend(t)
 			variableBackend.HTTPErrorHandler = ErrorHandler(0)
 			variableBackend.LabelService = tt.fields.LabelService
 			variableBackend.VariableService = tt.fields.VariableService
-			h := NewVariableHandler(variableBackend)
+			h := NewVariableHandler(zaptest.NewLogger(t), variableBackend)
 
 			r := httptest.NewRequest("GET", "http://howdy.tld", nil)
 
@@ -426,10 +425,10 @@ func TestVariableService_handleGetVariable(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			variableBackend := NewMockVariableBackend()
+			variableBackend := NewMockVariableBackend(t)
 			variableBackend.HTTPErrorHandler = ErrorHandler(0)
 			variableBackend.VariableService = tt.fields.VariableService
-			h := NewVariableHandler(variableBackend)
+			h := NewVariableHandler(zaptest.NewLogger(t), variableBackend)
 			r := httptest.NewRequest("GET", "http://howdy.tld", nil)
 			r = r.WithContext(context.WithValue(
 				context.TODO(),
@@ -565,10 +564,10 @@ func TestVariableService_handlePostVariable(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			variableBackend := NewMockVariableBackend()
+			variableBackend := NewMockVariableBackend(t)
 			variableBackend.HTTPErrorHandler = ErrorHandler(0)
 			variableBackend.VariableService = tt.fields.VariableService
-			h := NewVariableHandler(variableBackend)
+			h := NewVariableHandler(zaptest.NewLogger(t), variableBackend)
 			r := httptest.NewRequest("GET", "http://howdy.tld", bytes.NewReader([]byte(tt.args.variable)))
 			w := httptest.NewRecorder()
 
@@ -665,10 +664,10 @@ func TestVariableService_handlePatchVariable(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			variableBackend := NewMockVariableBackend()
+			variableBackend := NewMockVariableBackend(t)
 			variableBackend.HTTPErrorHandler = ErrorHandler(0)
 			variableBackend.VariableService = tt.fields.VariableService
-			h := NewVariableHandler(variableBackend)
+			h := NewVariableHandler(zaptest.NewLogger(t), variableBackend)
 			r := httptest.NewRequest("GET", "http://howdy.tld", bytes.NewReader([]byte(tt.args.update)))
 			r = r.WithContext(context.WithValue(
 				context.TODO(),
@@ -759,10 +758,10 @@ func TestVariableService_handleDeleteVariable(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			variableBackend := NewMockVariableBackend()
+			variableBackend := NewMockVariableBackend(t)
 			variableBackend.HTTPErrorHandler = ErrorHandler(0)
 			variableBackend.VariableService = tt.fields.VariableService
-			h := NewVariableHandler(variableBackend)
+			h := NewVariableHandler(zaptest.NewLogger(t), variableBackend)
 			r := httptest.NewRequest("GET", "http://howdy.tld", nil)
 			r = r.WithContext(context.WithValue(
 				context.TODO(),
@@ -852,10 +851,10 @@ func TestService_handlePostVariableLabel(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			variableBackend := NewMockVariableBackend()
+			variableBackend := NewMockVariableBackend(t)
 			variableBackend.HTTPErrorHandler = ErrorHandler(0)
 			variableBackend.LabelService = tt.fields.LabelService
-			h := NewVariableHandler(variableBackend)
+			h := NewVariableHandler(zaptest.NewLogger(t), variableBackend)
 
 			b, err := json.Marshal(tt.args.labelMapping)
 			if err != nil {

http/write_handler.go

@@ -25,7 +25,7 @@ import (
 // the WriteHandler.
 type WriteBackend struct {
 	influxdb.HTTPErrorHandler
-	Logger             *zap.Logger
+	log                *zap.Logger
 	WriteEventRecorder metric.EventRecorder
 
 	PointsWriter        storage.PointsWriter
@@ -34,10 +34,10 @@ type WriteBackend struct {
 }
 
 // NewWriteBackend returns a new instance of WriteBackend.
-func NewWriteBackend(b *APIBackend) *WriteBackend {
+func NewWriteBackend(log *zap.Logger, b *APIBackend) *WriteBackend {
 	return &WriteBackend{
 		HTTPErrorHandler:   b.HTTPErrorHandler,
-		Logger:             b.Logger.With(zap.String("handler", "write")),
+		log:                log,
 		WriteEventRecorder: b.WriteEventRecorder,
 
 		PointsWriter:        b.PointsWriter,
@@ -50,7 +50,7 @@ func NewWriteBackend(b *APIBackend) *WriteBackend {
 type WriteHandler struct {
 	*httprouter.Router
 	influxdb.HTTPErrorHandler
-	Logger *zap.Logger
+	log *zap.Logger
 
 	BucketService       influxdb.BucketService
 	OrganizationService influxdb.OrganizationService
@@ -67,11 +67,11 @@ const (
 )
 
 // NewWriteHandler creates a new handler at /api/v2/write to receive line protocol.
-func NewWriteHandler(b *WriteBackend) *WriteHandler {
+func NewWriteHandler(log *zap.Logger, b *WriteBackend) *WriteHandler {
 	h := &WriteHandler{
 		Router:           NewRouter(b.HTTPErrorHandler),
 		HTTPErrorHandler: b.HTTPErrorHandler,
-		Logger:           b.Logger,
+		log:              log,
 
 		PointsWriter:        b.PointsWriter,
 		BucketService:       b.BucketService,
@@ -134,12 +134,12 @@ func (h *WriteHandler) handleWrite(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	logger := h.Logger.With(zap.String("org", req.Org), zap.String("bucket", req.Bucket))
+	log := h.log.With(zap.String("org", req.Org), zap.String("bucket", req.Bucket))
 
 	var org *influxdb.Organization
 	org, err = queryOrganization(ctx, r, h.OrganizationService)
 	if err != nil {
-		logger.Info("Failed to find organization", zap.Error(err))
+		log.Info("Failed to find organization", zap.Error(err))
 		h.HandleHTTPError(ctx, err, w)
 		return
 	}
@@ -204,7 +204,7 @@ func (h *WriteHandler) handleWrite(w http.ResponseWriter, r *http.Request) {
 	span.LogKV("request_bytes", len(data))
 	span.Finish()
 	if err != nil {
-		logger.Error("Error reading body", zap.Error(err))
+		log.Error("Error reading body", zap.Error(err))
 		h.HandleHTTPError(ctx, &influxdb.Error{
 			Code: influxdb.EInternal,
 			Op:   "http/handleWrite",
@@ -231,7 +231,7 @@ func (h *WriteHandler) handleWrite(w http.ResponseWriter, r *http.Request) {
 	span.LogKV("values_total", len(points))
 	span.Finish()
 	if err != nil {
-		logger.Error("Error parsing points", zap.Error(err))
+		log.Error("Error parsing points", zap.Error(err))
 		h.HandleHTTPError(ctx, &influxdb.Error{
 			Code: influxdb.EInvalid,
 			Msg:  err.Error(),
@@ -240,7 +240,7 @@ func (h *WriteHandler) handleWrite(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if err := h.PointsWriter.WritePoints(ctx, points); err != nil {
-		logger.Error("Error writing points", zap.Error(err))
+		log.Error("Error writing points", zap.Error(err))
 		h.HandleHTTPError(ctx, &influxdb.Error{
 			Code: influxdb.EInternal,
 			Op:   "http/handleWrite",

http/write_handler_test.go

@@ -275,7 +275,7 @@ func TestWriteHandler_handleWrite(t *testing.T) {
 				PointsWriter:        &mock.PointsWriter{Err: tt.state.writeErr},
 				WriteEventRecorder:  &metric.NopEventRecorder{},
 			}
-			writeHandler := NewWriteHandler(NewWriteBackend(b))
+			writeHandler := NewWriteHandler(zaptest.NewLogger(t), NewWriteBackend(zaptest.NewLogger(t), b))
 			handler := httpmock.NewAuthMiddlewareHandler(writeHandler, tt.request.auth)
 
 			r := httptest.NewRequest(

inmem/task_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/influxdata/influxdb/inmem"
 	"github.com/influxdata/influxdb/kv"
 	"github.com/influxdata/influxdb/snowflake"
+	"go.uber.org/zap/zaptest"
 )
 
 var (
@@ -28,7 +29,7 @@ func BenchmarkFindTaskByID_CursorHints(b *testing.B) {
 		return nil
 	})
 
-	s := kv.NewService(kvs)
+	s := kv.NewService(zaptest.NewLogger(b), kvs)
 	_ = s.Initialize(ctx)
 
 	b.ResetTimer()

inmem/user_test.go

@@ -7,11 +7,12 @@ import (
 	"github.com/influxdata/influxdb"
 	"github.com/influxdata/influxdb/kv"
 	influxdbtesting "github.com/influxdata/influxdb/testing"
+	"go.uber.org/zap/zaptest"
 )
 
 func initUserService(f influxdbtesting.UserFields, t *testing.T) (influxdb.UserService, string, func()) {
 	s := NewKVStore()
-	svc := kv.NewService(s)
+	svc := kv.NewService(zaptest.NewLogger(t), s)
 	svc.IDGenerator = f.IDGenerator
 	ctx := context.Background()
 	if err := svc.Initialize(ctx); err != nil {

kit/prom/example_test.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/influxdata/influxdb/kit/prom"
 	"github.com/prometheus/client_golang/prometheus"
+	"go.uber.org/zap"
 )
 
 // RandomHandler implements an HTTP endpoint that prints a random float,
@@ -66,7 +67,7 @@ func Example() {
 	}
 
 	// Use a local registry, not the global registry in the prometheus package.
-	reg := prom.NewRegistry()
+	reg := prom.NewRegistry(zap.NewNop())
 
 	// Build the mux out of handlers from above.
 	mux := http.NewServeMux()

kit/prom/promtest/promtest_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/influxdata/influxdb/kit/prom/promtest"
 	"github.com/prometheus/client_golang/prometheus"
 	dto "github.com/prometheus/client_model/go"
+	"go.uber.org/zap/zaptest"
 )
 
 func helperCollectors() []prometheus.Collector {
@@ -36,7 +37,7 @@ func helperCollectors() []prometheus.Collector {
 }
 
 func TestFindMetric(t *testing.T) {
-	reg := prom.NewRegistry()
+	reg := prom.NewRegistry(zaptest.NewLogger(t))
 	reg.MustRegister(helperCollectors()...)
 
 	mfs, err := reg.Gather()
@@ -88,7 +89,7 @@ func (t *fakeT) Fatalf(format string, args ...interface{}) {
 }
 
 func TestMustFindMetric(t *testing.T) {
-	reg := prom.NewRegistry()
+	reg := prom.NewRegistry(zaptest.NewLogger(t))
 	reg.MustRegister(helperCollectors()...)
 
 	mfs, err := reg.Gather()
@@ -177,7 +178,7 @@ func TestMustGather(t *testing.T) {
 }
 
 func TestFromHTTPResponse(t *testing.T) {
-	reg := prom.NewRegistry()
+	reg := prom.NewRegistry(zaptest.NewLogger(t))
 	reg.MustRegister(helperCollectors()...)
 
 	s := httptest.NewServer(reg.HTTPHandler())

kit/prom/registry.go

@@ -23,23 +23,17 @@ type PrometheusCollector interface {
 type Registry struct {
 	*prometheus.Registry
 
-	logger *zap.Logger
+	log *zap.Logger
 }
 
 // NewRegistry returns a new registry.
-func NewRegistry() *Registry {
+func NewRegistry(log *zap.Logger) *Registry {
 	return &Registry{
 		Registry: prometheus.NewRegistry(),
-		logger:   zap.NewNop(),
+		log:      log,
 	}
 }
 
-// WithLogger sets the logger for the Registry.
-// The logger will print any errors that occur while serving metrics over HTTP.
-func (r *Registry) WithLogger(l *zap.Logger) {
-	r.logger = l.With(zap.String("service", "prom_registry"))
-}
-
 // HTTPHandler returns an http.Handler for the registry,
 // so that the /metrics HTTP handler is uniformly configured across all apps in the platform.
 func (r *Registry) HTTPHandler() http.Handler {
@@ -50,7 +44,7 @@ func (r *Registry) HTTPHandler() http.Handler {
 	return promhttp.HandlerFor(r.Registry, opts)
 }
 
-// promLogger satisfies the promhttp.Logger interface with the registry.
+// promLogger satisfies the promhttp.logger interface with the registry.
 // Because normal usage is that WithLogger is called after HTTPHandler,
 // we refer to the Registry rather than its logger.
 type promLogger struct {
@@ -59,7 +53,7 @@ type promLogger struct {
 
 var _ promhttp.Logger = (*promLogger)(nil)
 
-// Println implements promhttp.Logger.
+// Println implements promhttp.logger.
 func (pl promLogger) Println(v ...interface{}) {
-	pl.r.logger.Sugar().Info(v...)
+	pl.r.log.Sugar().Info(v...)
 }

kit/prom/registry_test.go

@@ -14,17 +14,13 @@ import (
 )
 
 func TestRegistry_Logger(t *testing.T) {
-	reg := prom.NewRegistry()
+	core, logs := observer.New(zap.DebugLevel)
+	reg := prom.NewRegistry(zap.New(core))
 
 	// Normal use: HTTP handler is created immediately...
 	s := httptest.NewServer(reg.HTTPHandler())
 	defer s.Close()
 
-	// ... and then WithLogger is called.
-	core, logs := observer.New(zap.DebugLevel)
-	logger := zap.New(core)
-	reg.WithLogger(logger)
-
 	// Force an error with a fake collector.
 	reg.MustRegister(errorCollector{})
 	resp, err := http.Get(s.URL)