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

feat(logging): add logging middleware to tenant service (#17320)

pull/17336/head
Alirie Gray 2020-03-17 15:24:57 -07:00 committed by GitHub
parent 8a027bccca
commit 82d88d52c4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 373 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
tenant/middleware_bucket_logging.go Normal file
View File

@ -0,0 +1,112 @@
package tenant
import (
"context"
"fmt"
"time"
"github.com/influxdata/influxdb"
"go.uber.org/zap"
)
type BucketLogger struct {
logger *zap.Logger
bucketService influxdb.BucketService
}
// NewBucketLogger returns a logging service middleware for the Bucket Service.
func NewBucketLogger(log *zap.Logger, s influxdb.BucketService) *BucketLogger {
return &BucketLogger{
logger: log,
bucketService: s,
}
}
var _ influxdb.BucketService = (*BucketLogger)(nil)
func (l *BucketLogger) CreateBucket(ctx context.Context, u *influxdb.Bucket) (err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
l.logger.Error("failed to create bucket", zap.Error(err), dur)
return
}
l.logger.Info("bucket create", dur)
}(time.Now())
return l.bucketService.CreateBucket(ctx, u)
}
func (l *BucketLogger) FindBucketByID(ctx context.Context, id influxdb.ID) (u *influxdb.Bucket, err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
msg := fmt.Sprintf("failed to find bucket with ID %v", id)
l.logger.Error(msg, zap.Error(err), dur)
return
}
l.logger.Info("bucket find by ID", dur)
}(time.Now())
return l.bucketService.FindBucketByID(ctx, id)
}
func (l *BucketLogger) FindBucketByName(ctx context.Context, orgID influxdb.ID, name string) (u *influxdb.Bucket, err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
msg := fmt.Sprintf("failed to find bucket with name %v in org %v", name, orgID)
l.logger.Error(msg, zap.Error(err), dur)
return
}
l.logger.Info("bucket find by name", dur)
}(time.Now())
return l.bucketService.FindBucketByName(ctx, orgID, name)
}
func (l *BucketLogger) FindBucket(ctx context.Context, filter influxdb.BucketFilter) (u *influxdb.Bucket, err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
l.logger.Error("failed to find bucket matching the given filter", zap.Error(err), dur)
return
}
l.logger.Info("bucket find", dur)
}(time.Now())
return l.bucketService.FindBucket(ctx, filter)
}
func (l *BucketLogger) FindBuckets(ctx context.Context, filter influxdb.BucketFilter, opt ...influxdb.FindOptions) (buckets []*influxdb.Bucket, n int, err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
l.logger.Error("failed to find bucket matching the given filter", zap.Error(err), dur)
return
}
l.logger.Info("buckets find", dur)
}(time.Now())
return l.bucketService.FindBuckets(ctx, filter)
}
func (l *BucketLogger) UpdateBucket(ctx context.Context, id influxdb.ID, upd influxdb.BucketUpdate) (u *influxdb.Bucket, err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
l.logger.Error("failed to update bucket", zap.Error(err), dur)
return
}
l.logger.Info("bucket update", dur)
}(time.Now())
return l.bucketService.UpdateBucket(ctx, id, upd)
}
func (l *BucketLogger) DeleteBucket(ctx context.Context, id influxdb.ID) (err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
msg := fmt.Sprintf("failed to delete bucket with ID %v", id)
l.logger.Error(msg, zap.Error(err), dur)
return
}
l.logger.Info("bucket delete", dur)
}(time.Now())
return l.bucketService.DeleteBucket(ctx, id)
}

99
tenant/middleware_org_logging.go Normal file
View File

@ -0,0 +1,99 @@
package tenant
import (
"context"
"fmt"
"time"
"github.com/influxdata/influxdb"
"go.uber.org/zap"
)
type OrgLogger struct {
logger *zap.Logger
orgService influxdb.OrganizationService
}
// NewOrgLogger returns a logging service middleware for the Organization Service.
func NewOrgLogger(log *zap.Logger, s influxdb.OrganizationService) *OrgLogger {
return &OrgLogger{
logger: log,
orgService: s,
}
}
var _ influxdb.OrganizationService = (*OrgLogger)(nil)
func (l *OrgLogger) CreateOrganization(ctx context.Context, u *influxdb.Organization) (err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
l.logger.Error("failed to create org", zap.Error(err), dur)
return
}
l.logger.Info("org create", dur)
}(time.Now())
return l.orgService.CreateOrganization(ctx, u)
}
func (l *OrgLogger) FindOrganizationByID(ctx context.Context, id influxdb.ID) (u *influxdb.Organization, err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
msg := fmt.Sprintf("failed to find org with ID %v", id)
l.logger.Error(msg, zap.Error(err), dur)
return
}
l.logger.Info("org find by ID", dur)
}(time.Now())
return l.orgService.FindOrganizationByID(ctx, id)
}
func (l *OrgLogger) FindOrganization(ctx context.Context, filter influxdb.OrganizationFilter) (u *influxdb.Organization, err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
l.logger.Error("failed to find org matching the given filter", zap.Error(err), dur)
return
}
l.logger.Info("org find", dur)
}(time.Now())
return l.orgService.FindOrganization(ctx, filter)
}
func (l *OrgLogger) FindOrganizations(ctx context.Context, filter influxdb.OrganizationFilter, opt ...influxdb.FindOptions) (orgs []*influxdb.Organization, n int, err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
l.logger.Error("failed to find org matching the given filter", zap.Error(err), dur)
return
}
l.logger.Info("orgs find", dur)
}(time.Now())
return l.orgService.FindOrganizations(ctx, filter)
}
func (l *OrgLogger) UpdateOrganization(ctx context.Context, id influxdb.ID, upd influxdb.OrganizationUpdate) (u *influxdb.Organization, err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
l.logger.Error("failed to update org", zap.Error(err), dur)
return
}
l.logger.Info("org update", dur)
}(time.Now())
return l.orgService.UpdateOrganization(ctx, id, upd)
}
func (l *OrgLogger) DeleteOrganization(ctx context.Context, id influxdb.ID) (err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
msg := fmt.Sprintf("failed to delete org with ID %v", id)
l.logger.Error(msg, zap.Error(err), dur)
return
}
l.logger.Info("org delete", dur)
}(time.Now())
return l.orgService.DeleteOrganization(ctx, id)
}

8
tenant/middleware_org_metrics.go
View File

@ -25,44 +25,36 @@ func NewOrgMetrics(reg *prom.Registry, s influxdb.OrganizationService) *OrgMetri
}
}
// Returns a single organization by ID.
func (m *OrgMetrics) FindOrganizationByID(ctx context.Context, id influxdb.ID) (*influxdb.Organization, error) {
rec := m.rec.Record("find_org_by_id")
org, err := m.orgService.FindOrganizationByID(ctx, id)
return org, rec(err)
}
// Returns the first organization that matches filter.
func (m *OrgMetrics) FindOrganization(ctx context.Context, filter influxdb.OrganizationFilter) (*influxdb.Organization, error) {
rec := m.rec.Record("find_org")
org, err := m.orgService.FindOrganization(ctx, filter)
return org, rec(err)
}
// Returns a list of organizations that match filter and the total count of matching organizations.
// Additional options provide pagination & sorting.
func (m *OrgMetrics) FindOrganizations(ctx context.Context, filter influxdb.OrganizationFilter, opt ...influxdb.FindOptions) ([]*influxdb.Organization, int, error) {
rec := m.rec.Record("find_orgs")
orgs, n, err := m.orgService.FindOrganizations(ctx, filter, opt...)
return orgs, n, rec(err)
}
// Creates a new organization and sets b.ID with the new identifier.
func (m *OrgMetrics) CreateOrganization(ctx context.Context, b *influxdb.Organization) error {
rec := m.rec.Record("create_org")
err := m.orgService.CreateOrganization(ctx, b)
return rec(err)
}
// Updates a single organization with changeset.
// Returns the new organization state after update.
func (m *OrgMetrics) UpdateOrganization(ctx context.Context, id influxdb.ID, upd influxdb.OrganizationUpdate) (*influxdb.Organization, error) {
rec := m.rec.Record("update_org")
updatedOrg, err := m.orgService.UpdateOrganization(ctx, id, upd)
return updatedOrg, rec(err)
}
// Removes a organization by ID.
func (m *OrgMetrics) DeleteOrganization(ctx context.Context, id influxdb.ID) error {
rec := m.rec.Record("delete_org")
err := m.orgService.DeleteOrganization(ctx, id)

62
tenant/middleware_urm_logging.go Normal file
View File

@ -0,0 +1,62 @@
package tenant
import (
"context"
"fmt"
"time"
"github.com/influxdata/influxdb"
"go.uber.org/zap"
)
type URMLogger struct {
logger *zap.Logger
urmService influxdb.UserResourceMappingService
}
// NewUrmLogger returns a logging service middleware for the User Resource Mapping Service.
func NewURMLogger(log *zap.Logger, s influxdb.UserResourceMappingService) *URMLogger {
return &URMLogger{
logger: log,
urmService: s,
}
}
var _ influxdb.UserResourceMappingService = (*URMLogger)(nil)
func (l *URMLogger) CreateUserResourceMapping(ctx context.Context, u *influxdb.UserResourceMapping) (err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
l.logger.Error("failed to create urm", zap.Error(err), dur)
return
}
l.logger.Info("urm create", dur)
}(time.Now())
return l.urmService.CreateUserResourceMapping(ctx, u)
}
func (l *URMLogger) FindUserResourceMappings(ctx context.Context, filter influxdb.UserResourceMappingFilter, opt ...influxdb.FindOptions) (urms []*influxdb.UserResourceMapping, n int, err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
l.logger.Error("failed to find urms matching the given filter", zap.Error(err), dur)
return
}
l.logger.Info("urm find", dur)
}(time.Now())
return l.urmService.FindUserResourceMappings(ctx, filter)
}
func (l *URMLogger) DeleteUserResourceMapping(ctx context.Context, resourceID, userID influxdb.ID) (err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
msg := fmt.Sprintf("failed to delete urm for resource %v and user %v", resourceID, userID)
l.logger.Error(msg, zap.Error(err), dur)
return
}
l.logger.Info("urm delete", dur)
}(time.Now())
return l.urmService.DeleteUserResourceMapping(ctx, resourceID, userID)
}

5
tenant/middleware_urm_metrics.go
View File

@ -17,7 +17,7 @@ type UrmMetrics struct {
var _ influxdb.UserResourceMappingService = (*UrmMetrics)(nil)
// NewUrmMetrics returns a metrics service middleware for the URM Service.
// NewUrmMetrics returns a metrics service middleware for the User Resource Mapping Service.
func NewUrmMetrics(reg *prom.Registry, s influxdb.UserResourceMappingService) *UrmMetrics {
return &UrmMetrics{
rec: metric.New(reg, "urm"),
@ -25,21 +25,18 @@ func NewUrmMetrics(reg *prom.Registry, s influxdb.UserResourceMappingService) *U
}
}
// FindUserResourceMappings returns a list of UserResourceMappings that match filter and the total count of matching mappings.
func (m *UrmMetrics) FindUserResourceMappings(ctx context.Context, filter influxdb.UserResourceMappingFilter, opt ...influxdb.FindOptions) ([]*influxdb.UserResourceMapping, int, error) {
rec := m.rec.Record("find_urms")
urms, n, err := m.urmService.FindUserResourceMappings(ctx, filter, opt...)
return urms, n, rec(err)
}
// CreateUserResourceMapping creates a user resource mapping.
func (m *UrmMetrics) CreateUserResourceMapping(ctx context.Context, urm *influxdb.UserResourceMapping) error {
rec := m.rec.Record("create_urm")
err := m.urmService.CreateUserResourceMapping(ctx, urm)
return rec(err)
}
// DeleteUserResourceMapping deletes a user resource mapping.
func (m *UrmMetrics) DeleteUserResourceMapping(ctx context.Context, resourceID, userID influxdb.ID) error {
rec := m.rec.Record("delete_urm")
err := m.urmService.DeleteUserResourceMapping(ctx, resourceID, userID)

99
tenant/middleware_user_logging.go Normal file
View File

@ -0,0 +1,99 @@
package tenant
import (
"context"
"fmt"
"time"
"github.com/influxdata/influxdb"
"go.uber.org/zap"
)
type UserLogger struct {
logger *zap.Logger
userService influxdb.UserService
}
// NewUserLogger returns a logging service middleware for the User Service.
func NewUserLogger(log *zap.Logger, s influxdb.UserService) *UserLogger {
return &UserLogger{
logger: log,
userService: s,
}
}
var _ influxdb.UserService = (*UserLogger)(nil)
func (l *UserLogger) CreateUser(ctx context.Context, u *influxdb.User) (err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
l.logger.Error("failed to create user", zap.Error(err), dur)
return
}
l.logger.Info("user create", dur)
}(time.Now())
return l.userService.CreateUser(ctx, u)
}
func (l *UserLogger) FindUserByID(ctx context.Context, id influxdb.ID) (u *influxdb.User, err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
msg := fmt.Sprintf("failed to find user with ID %v", id)
l.logger.Error(msg, zap.Error(err), dur)
return
}
l.logger.Info("user find by ID", dur)
}(time.Now())
return l.userService.FindUserByID(ctx, id)
}
func (l *UserLogger) FindUser(ctx context.Context, filter influxdb.UserFilter) (u *influxdb.User, err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
l.logger.Error("failed to find user matching the given filter", zap.Error(err), dur)
return
}
l.logger.Info("user find", dur)
}(time.Now())
return l.userService.FindUser(ctx, filter)
}
func (l *UserLogger) FindUsers(ctx context.Context, filter influxdb.UserFilter, opt ...influxdb.FindOptions) (users []*influxdb.User, n int, err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
l.logger.Error("failed to find users matching the given filter", zap.Error(err), dur)
return
}
l.logger.Info("users find", dur)
}(time.Now())
return l.userService.FindUsers(ctx, filter)
}
func (l *UserLogger) UpdateUser(ctx context.Context, id influxdb.ID, upd influxdb.UserUpdate) (u *influxdb.User, err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
l.logger.Error("failed to update user", zap.Error(err), dur)
return
}
l.logger.Info("user update", dur)
}(time.Now())
return l.userService.UpdateUser(ctx, id, upd)
}
func (l *UserLogger) DeleteUser(ctx context.Context, id influxdb.ID) (err error) {
defer func(start time.Time) {
dur := zap.Duration("took", time.Since(start))
if err != nil {
msg := fmt.Sprintf("failed to delete user with ID %v", id)
l.logger.Error(msg, zap.Error(err), dur)
return
}
l.logger.Info("user create", dur)
}(time.Now())
return l.userService.DeleteUser(ctx, id)
}

8
tenant/middleware_user_metrics.go
View File

@ -25,44 +25,36 @@ func NewUserMetrics(reg *prom.Registry, s influxdb.UserService) *UserMetrics {
}
}
// Returns a single user by ID.
func (m *UserMetrics) FindUserByID(ctx context.Context, id influxdb.ID) (*influxdb.User, error) {
rec := m.rec.Record("find_user_by_id")
user, err := m.userService.FindUserByID(ctx, id)
return user, rec(err)
}
// Returns the first user that matches filter.
func (m *UserMetrics) FindUser(ctx context.Context, filter influxdb.UserFilter) (*influxdb.User, error) {
rec := m.rec.Record("find_user")
user, err := m.userService.FindUser(ctx, filter)
return user, rec(err)
}
// Returns a list of users that match filter and the total count of matching users.
// Additional options provide pagination & sorting.
func (m *UserMetrics) FindUsers(ctx context.Context, filter influxdb.UserFilter, opt ...influxdb.FindOptions) ([]*influxdb.User, int, error) {
rec := m.rec.Record("find_users")
users, n, err := m.userService.FindUsers(ctx, filter, opt...)
return users, n, rec(err)
}
// Creates a new user and sets u.ID with the new identifier.
func (m *UserMetrics) CreateUser(ctx context.Context, u *influxdb.User) error {
rec := m.rec.Record("create_user")
err := m.userService.CreateUser(ctx, u)
return rec(err)
}
// Updates a single user with changeset.
// Returns the new user state after update.
func (m *UserMetrics) UpdateUser(ctx context.Context, id influxdb.ID, upd influxdb.UserUpdate) (*influxdb.User, error) {
rec := m.rec.Record("update_user")
updatedUser, err := m.userService.UpdateUser(ctx, id, upd)
return updatedUser, rec(err)
}
// Removes a user by ID.
func (m *UserMetrics) DeleteUser(ctx context.Context, id influxdb.ID) error {
rec := m.rec.Record("delete_user")
err := m.userService.DeleteUser(ctx, id)