Influxdata
/
influxdb
mirror of https://github.com/influxdata/influxdb.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

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
pull/16137/head
Jacob Marble 2019-12-04 15:10:23 -08:00 committed by GitHub
parent 27e2531b0a
commit 5f19c6cace
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
174 changed files with 1331 additions and 1336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
authorizer/task.go
View File

@ -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()),

2
bolt/authorization_test.go
View File

@ -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)
}

14
bolt/bbolt.go
View File

@ -25,7 +25,7 @@ func getOp(op string) string {
type Client struct {
Path string
db *bolt.DB
Logger *zap.Logger
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
}

15
bolt/bbolt_test.go
View File

@ -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
}

2
bolt/bucket_test.go
View File

@ -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)
}

2
bolt/dashboard_test.go
View File

@ -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)
}

2
bolt/id.go
View File

@ -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

2
bolt/id_test.go
View File

@ -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)
}

2
bolt/keyvalue_log_test.go
View File

@ -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)
}

13
bolt/kv.go
View File

@ -17,15 +17,15 @@ import (
type KVStore struct {
path string
db *bolt.DB
logger *zap.Logger
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(),
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

2
bolt/kv_test.go
View File

@ -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)
}

2
bolt/lookup_service_test.go
View File

@ -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)
}

9
bolt/metrics_test.go
View File

@ -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()

2
bolt/onboarding_test.go
View File

@ -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)
}

2
bolt/organization_test.go
View File

@ -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)
}

2
bolt/passwords_test.go
View File

@ -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)
}

2
bolt/scraper_test.go
View File

@ -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)
}

2
bolt/secret_test.go
View File

@ -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)
}

2
bolt/session_test.go
View File

@ -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)
}

2
bolt/source_test.go
View File

@ -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)
}

2
bolt/telegraf_test.go
View File

@ -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)
}

2
bolt/user_resource_mapping_test.go
View File

@ -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)
}

2
bolt/user_test.go
View File

@ -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)
}

18
chronograf/oauth2/mux.go
View File

@ -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

5
cmd/influx/main.go
View File

@ -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
}

2
cmd/influx/pkg.go
View File

@ -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,

3
cmd/influx/pkg_test.go
View File

@ -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
}

4
cmd/influx_inspect/buildtsi/buildtsi.go
View File

@ -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()

5
cmd/influxd/generate/command.go
View File

@ -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
}

12
cmd/influxd/launcher/engine.go
View File

@ -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))
}
}

172
cmd/influxd/launcher/launcher.go
View File

@ -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

4
cmd/influxd/launcher/pkger_test.go
View File

@ -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

18
cmd/telemetryd/main.go
View File

@ -14,7 +14,7 @@ import (
)
var (
logger = influxlogger.New(os.Stdout)
log = influxlogger.New(os.Stdout)
addr string
)
@ -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()
}

3
example_test.go
View File

@ -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 {

8
gather/README.md
View File

@ -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
}
```

10
gather/handler.go
View File

@ -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
}

13
gather/recorder.go
View File

@ -38,7 +38,14 @@ type Recorder interface {
// 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))
}
}

12
gather/scheduler.go
View File

@ -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)
}
}

5
gather/scheduler_test.go
View File

@ -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)

76
http/api_handler.go
View File

@ -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
}

4
http/api_handler_test.go
View File

@ -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)

36
http/auth_service.go
View File

@ -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)
}

33
http/auth_test.go
View File

@ -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

8
http/authentication_middleware.go
View File

@ -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)
}

5
http/authentication_test.go
View File

@ -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

40
http/bucket_service.go
View File

@ -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
}
}

41
http/bucket_test.go
View File

@ -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,

54
http/check_service.go
View File

@ -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)
}

44
http/check_test.go
View File

@ -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 {

2
http/chronograf_handler.go
View File

@ -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",
}

60
http/dashboard_service.go
View File

@ -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
}
}

47
http/dashboard_test.go
View File

@ -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 {

14
http/delete_handler.go
View File

@ -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())),
)

10
http/delete_test.go
View File

@ -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))

38
http/document_service.go
View File

@ -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
}
}

18
http/document_test.go
View File

@ -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

11
http/handler.go
View File

@ -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))

15
http/handler_test.go
View File

@ -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")

28
http/label_service.go
View File

@ -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
}
}

15
http/label_test.go
View File

@ -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 {

4
http/middleware.go
View File

@ -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)

52
http/notification_endpoint.go
View File

@ -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)
}

41
http/notification_endpoint_test.go
View File

@ -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 {

52
http/notification_rule.go
View File

@ -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)
}

13
http/notification_rule_test.go
View File

@ -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{})

20
http/onboarding.go
View File

@ -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
}
}

15
http/onboarding_test.go
View File

@ -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

42
http/org_service.go
View File

@ -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
}
}

25
http/org_test.go
View File

@ -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,

3
http/pkger_http_server_test.go
View File

@ -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)

2
http/platform_handler.go
View File

@ -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

22
http/query_handler.go
View File

@ -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
}
}

16
http/query_handler_test.go
View File

@ -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

36
http/scraper_service.go
View File

@ -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
}
}

33
http/scraper_service_test.go
View File

@ -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{

19
http/server.go
View File

@ -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)
}

12
http/session_handler.go
View File

@ -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,

16
http/session_test.go
View File

@ -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)

32
http/source_service.go
View File

@ -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
}
}

9
http/swagger.go
View File

@ -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() {

14
http/swagger_noassets.go
View File

@ -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 ""
}

46
http/task_service.go
View File

@ -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
}
}

24
http/task_service_test.go
View File

@ -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,

42
http/telegraf.go
View File

@ -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)
}

15
http/telegraf_test.go
View File

@ -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)

8
http/usage_service.go
View File

@ -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
}
}

8
http/user_resource_mapping_service.go
View File

@ -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)
}

9
http/user_resource_mapping_test.go
View File

@ -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,

26
http/user_service.go
View File

@ -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)

20
http/user_test.go
View File

@ -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")

36
http/variable_service.go
View File

@ -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)
}

33
http/variable_test.go
View File

@ -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 {

22
http/write_handler.go
View File

@ -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",

2
http/write_handler_test.go
View File

@ -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(

3
inmem/task_test.go
View File

@ -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()

3
inmem/user_test.go
View File

@ -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 {

3
kit/prom/example_test.go
View File

@ -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()

7
kit/prom/promtest/promtest_test.go
View File

@ -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())

18
kit/prom/registry.go
View File

@ -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...)
}

8
kit/prom/registry_test.go
View File

@ -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)

Some files were not shown because too many files have changed in this diff Show More