feat(logger): migrate to Go's slog structured logger

Permify · Oct 13, 2023 · 7ac181c · 7ac181c
1 parent 8f35897
commit 7ac181c
Show file tree

Hide file tree

Showing 27 changed files with 223 additions and 390 deletions.
diff --git a/internal/engines/keys/keys.go b/internal/engines/keys/keys.go
@@ -14,7 +14,6 @@ import (
 	"github.com/Permify/permify/internal/storage"
 	"github.com/Permify/permify/pkg/attribute"
 	"github.com/Permify/permify/pkg/cache"
-	"github.com/Permify/permify/pkg/logger"
 	base "github.com/Permify/permify/pkg/pb/base/v1"
 	"github.com/Permify/permify/pkg/tuple"
 )
@@ -25,17 +24,15 @@ type CheckEngineWithKeys struct {
 	schemaReader storage.SchemaReader
 	checker      invoke.Check
 	cache        cache.Cache
-	l            *logger.Logger
 }
 
 // NewCheckEngineWithKeys creates a new instance of EngineKeyManager by initializing an EngineKeys
 // struct with the provided cache.Cache instance.
-func NewCheckEngineWithKeys(checker invoke.Check, schemaReader storage.SchemaReader, cache cache.Cache, l *logger.Logger) invoke.Check {
+func NewCheckEngineWithKeys(checker invoke.Check, schemaReader storage.SchemaReader, cache cache.Cache) invoke.Check {
 	return &CheckEngineWithKeys{
 		schemaReader: schemaReader,
 		checker:      checker,
 		cache:        cache,
-		l:            l,
 	}
 }
 

diff --git a/internal/factories/storage.go b/internal/factories/storage.go
@@ -7,110 +7,109 @@ import (
 	"github.com/Permify/permify/pkg/database"
 	MMDatabase "github.com/Permify/permify/pkg/database/memory"
 	PQDatabase "github.com/Permify/permify/pkg/database/postgres"
-	"github.com/Permify/permify/pkg/logger"
 )
 
 // DataReaderFactory creates and returns a DataReader based on the database engine type.
-func DataReaderFactory(db database.Database, logger logger.Interface) (repo storage.DataReader) {
+func DataReaderFactory(db database.Database) (repo storage.DataReader) {
 	switch db.GetEngineType() {
 	case "postgres":
 		// If the database engine is Postgres, create a new DataReader using the Postgres implementation
-		return PQRepository.NewDataReader(db.(*PQDatabase.Postgres), logger)
+		return PQRepository.NewDataReader(db.(*PQDatabase.Postgres))
 	case "memory":
 		// If the database engine is in-memory, create a new DataReader using the in-memory implementation
-		return MMRepository.NewDataReader(db.(*MMDatabase.Memory), logger)
+		return MMRepository.NewDataReader(db.(*MMDatabase.Memory))
 	default:
 		// For any other type, use the in-memory implementation as a default
-		return MMRepository.NewDataReader(db.(*MMDatabase.Memory), logger)
+		return MMRepository.NewDataReader(db.(*MMDatabase.Memory))
 	}
 }
 
 // DataWriterFactory creates and returns a DataWriter based on the database engine type.
-func DataWriterFactory(db database.Database, logger logger.Interface) (repo storage.DataWriter) {
+func DataWriterFactory(db database.Database) (repo storage.DataWriter) {
 	switch db.GetEngineType() {
 	case "postgres":
 		// If the database engine is Postgres, create a new DataWriter using the Postgres implementation
-		return PQRepository.NewDataWriter(db.(*PQDatabase.Postgres), logger)
+		return PQRepository.NewDataWriter(db.(*PQDatabase.Postgres))
 	case "memory":
 		// If the database engine is in-memory, create a new DataWriter using the in-memory implementation
-		return MMRepository.NewDataWriter(db.(*MMDatabase.Memory), logger)
+		return MMRepository.NewDataWriter(db.(*MMDatabase.Memory))
 	default:
 		// For any other type, use the in-memory implementation as a default
-		return MMRepository.NewDataWriter(db.(*MMDatabase.Memory), logger)
+		return MMRepository.NewDataWriter(db.(*MMDatabase.Memory))
 	}
 }
 
 // SchemaReaderFactory creates and returns a SchemaReader based on the database engine type.
-func SchemaReaderFactory(db database.Database, logger logger.Interface) (repo storage.SchemaReader) {
+func SchemaReaderFactory(db database.Database) (repo storage.SchemaReader) {
 	switch db.GetEngineType() {
 	case "postgres":
 		// If the database engine is Postgres, create a new SchemaReader using the Postgres implementation
-		return PQRepository.NewSchemaReader(db.(*PQDatabase.Postgres), logger)
+		return PQRepository.NewSchemaReader(db.(*PQDatabase.Postgres))
 	case "memory":
 		// If the database engine is in-memory, create a new SchemaReader using the in-memory implementation
-		return MMRepository.NewSchemaReader(db.(*MMDatabase.Memory), logger)
+		return MMRepository.NewSchemaReader(db.(*MMDatabase.Memory))
 	default:
 		// For any other type, use the in-memory implementation as a default
-		return MMRepository.NewSchemaReader(db.(*MMDatabase.Memory), logger)
+		return MMRepository.NewSchemaReader(db.(*MMDatabase.Memory))
 	}
 }
 
 // WatcherFactory creates and returns a Watcher based on the database engine type.
-func WatcherFactory(db database.Database, logger logger.Interface) (repo storage.Watcher) {
+func WatcherFactory(db database.Database) (repo storage.Watcher) {
 	switch db.GetEngineType() {
 	case "postgres":
 		// If the database engine is Postgres, create a new Watcher using the Postgres implementation
-		return PQRepository.NewWatcher(db.(*PQDatabase.Postgres), logger)
+		return PQRepository.NewWatcher(db.(*PQDatabase.Postgres))
 	case "memory":
 		// If the database engine is in-memory, create a new Watcher using the in-memory implementation
-		return MMRepository.NewWatcher(db.(*MMDatabase.Memory), logger)
+		return MMRepository.NewWatcher(db.(*MMDatabase.Memory))
 	default:
 		// For any other type, use the in-memory implementation as a default
-		return MMRepository.NewWatcher(db.(*MMDatabase.Memory), logger)
+		return MMRepository.NewWatcher(db.(*MMDatabase.Memory))
 	}
 }
 
 // SchemaWriterFactory creates and returns a SchemaWriter based on the database engine type.
-func SchemaWriterFactory(db database.Database, logger logger.Interface) (repo storage.SchemaWriter) {
+func SchemaWriterFactory(db database.Database) (repo storage.SchemaWriter) {
 	switch db.GetEngineType() {
 	case "postgres":
 		// If the database engine is Postgres, create a new SchemaWriter using the Postgres implementation
-		return PQRepository.NewSchemaWriter(db.(*PQDatabase.Postgres), logger)
+		return PQRepository.NewSchemaWriter(db.(*PQDatabase.Postgres))
 	case "memory":
 		// If the database engine is in-memory, create a new SchemaWriter using the in-memory implementation
-		return MMRepository.NewSchemaWriter(db.(*MMDatabase.Memory), logger)
+		return MMRepository.NewSchemaWriter(db.(*MMDatabase.Memory))
 	default:
 		// For any other type, use the in-memory implementation as a default
-		return MMRepository.NewSchemaWriter(db.(*MMDatabase.Memory), logger)
+		return MMRepository.NewSchemaWriter(db.(*MMDatabase.Memory))
 	}
 }
 
 // TenantReaderFactory creates and returns a TenantReader based on the database engine type.
-func TenantReaderFactory(db database.Database, logger logger.Interface) (repo storage.TenantReader) {
+func TenantReaderFactory(db database.Database) (repo storage.TenantReader) {
 	switch db.GetEngineType() {
 	case "postgres":
 		// If the database engine is Postgres, create a new TenantReader using the Postgres implementation
-		return PQRepository.NewTenantReader(db.(*PQDatabase.Postgres), logger)
+		return PQRepository.NewTenantReader(db.(*PQDatabase.Postgres))
 	case "memory":
 		// If the database engine is in-memory, create a new TenantReader using the in-memory implementation
-		return MMRepository.NewTenantReader(db.(*MMDatabase.Memory), logger)
+		return MMRepository.NewTenantReader(db.(*MMDatabase.Memory))
 	default:
 		// For any other type, use the in-memory implementation as a default
-		return MMRepository.NewTenantReader(db.(*MMDatabase.Memory), logger)
+		return MMRepository.NewTenantReader(db.(*MMDatabase.Memory))
 	}
 }
 
 // TenantWriterFactory creates and returns a TenantWriter based on the database engine type.
-func TenantWriterFactory(db database.Database, logger logger.Interface) (repo storage.TenantWriter) {
+func TenantWriterFactory(db database.Database) (repo storage.TenantWriter) {
 	switch db.GetEngineType() {
 	case "postgres":
 		// If the database engine is Postgres, create a new TenantWriter using the Postgres implementation
-		return PQRepository.NewTenantWriter(db.(*PQDatabase.Postgres), logger)
+		return PQRepository.NewTenantWriter(db.(*PQDatabase.Postgres))
 	case "memory":
 		// If the database engine is in-memory, create a new TenantWriter using the in-memory implementation
-		return MMRepository.NewTenantWriter(db.(*MMDatabase.Memory), logger)
+		return MMRepository.NewTenantWriter(db.(*MMDatabase.Memory))
 	default:
 		// For any other type, use the in-memory implementation as a default
-		return MMRepository.NewTenantWriter(db.(*MMDatabase.Memory), logger)
+		return MMRepository.NewTenantWriter(db.(*MMDatabase.Memory))
 	}
 }
diff --git a/internal/servers/dataServer.go b/internal/servers/dataServer.go
@@ -1,6 +1,8 @@
 package servers
 
 import (
+	"log/slog"
+
 	"google.golang.org/grpc/status"
 
 	otelCodes "go.opentelemetry.io/otel/codes"
@@ -9,32 +11,28 @@ import (
 	"github.com/Permify/permify/internal/storage"
 	"github.com/Permify/permify/internal/validation"
 	"github.com/Permify/permify/pkg/database"
-	"github.com/Permify/permify/pkg/logger"
 	v1 "github.com/Permify/permify/pkg/pb/base/v1"
 )
 
 // DataServer - Structure for Data Server
 type DataServer struct {
 	v1.UnimplementedDataServer
 
-	sr     storage.SchemaReader
-	dr     storage.DataReader
-	dw     storage.DataWriter
-	logger logger.Interface
+	sr storage.SchemaReader
+	dr storage.DataReader
+	dw storage.DataWriter
 }
 
 // NewDataServer - Creates new Data Server
 func NewDataServer(
 	dr storage.DataReader,
 	dw storage.DataWriter,
 	sr storage.SchemaReader,
-	l logger.Interface,
 ) *DataServer {
 	return &DataServer{
-		dr:     dr,
-		dw:     dw,
-		sr:     sr,
-		logger: l,
+		dr: dr,
+		dw: dw,
+		sr: sr,
 	}
 }
 
@@ -70,7 +68,7 @@ func (r *DataServer) ReadRelationships(ctx context.Context, request *v1.Relation
 	if err != nil {
 		span.RecordError(err)
 		span.SetStatus(otelCodes.Error, err.Error())
-		r.logger.Error(err.Error())
+		slog.Error(err.Error())
 		return nil, status.Error(GetStatus(err), err.Error())
 	}
 
@@ -112,7 +110,7 @@ func (r *DataServer) ReadAttributes(ctx context.Context, request *v1.AttributeRe
 	if err != nil {
 		span.RecordError(err)
 		span.SetStatus(otelCodes.Error, err.Error())
-		r.logger.Error(err.Error())
+		slog.Error(err.Error())
 		return nil, status.Error(GetStatus(err), err.Error())
 	}
 
@@ -187,7 +185,7 @@ func (r *DataServer) Write(ctx context.Context, request *v1.DataWriteRequest) (*
 	if err != nil {
 		span.RecordError(err)
 		span.SetStatus(otelCodes.Error, err.Error())
-		r.logger.Error(err.Error())
+		slog.Error(err.Error())
 		return nil, status.Error(GetStatus(err), err.Error())
 	}
 
@@ -241,7 +239,7 @@ func (r *DataServer) WriteRelationships(ctx context.Context, request *v1.Relatio
 	if err != nil {
 		span.RecordError(err)
 		span.SetStatus(otelCodes.Error, err.Error())
-		r.logger.Error(err.Error())
+		slog.Error(err.Error())
 		return nil, status.Error(GetStatus(err), err.Error())
 	}
 
@@ -269,7 +267,7 @@ func (r *DataServer) Delete(ctx context.Context, request *v1.DataDeleteRequest)
 	if err != nil {
 		span.RecordError(err)
 		span.SetStatus(otelCodes.Error, err.Error())
-		r.logger.Error(err.Error())
+		slog.Error(err.Error())
 		return nil, status.Error(GetStatus(err), err.Error())
 	}
 
@@ -297,7 +295,7 @@ func (r *DataServer) DeleteRelationships(ctx context.Context, request *v1.Relati
 	if err != nil {
 		span.RecordError(err)
 		span.SetStatus(otelCodes.Error, err.Error())
-		r.logger.Error(err.Error())
+		slog.Error(err.Error())
 		return nil, status.Error(GetStatus(err), err.Error())
 	}
 

diff --git a/internal/servers/permissionServer.go b/internal/servers/permissionServer.go
@@ -1,12 +1,13 @@
 package servers
 
 import (
+	"log/slog"
+
 	otelCodes "go.opentelemetry.io/otel/codes"
 	"golang.org/x/net/context"
 	"google.golang.org/grpc/status"
 
 	"github.com/Permify/permify/internal/invoke"
-	"github.com/Permify/permify/pkg/logger"
 	v1 "github.com/Permify/permify/pkg/pb/base/v1"
 )
 
@@ -15,14 +16,12 @@ type PermissionServer struct {
 	v1.UnimplementedPermissionServer
 
 	invoker invoke.Invoker
-	logger  logger.Interface
 }
 
 // NewPermissionServer - Creates new Permission Server
-func NewPermissionServer(i invoke.Invoker, l logger.Interface) *PermissionServer {
+func NewPermissionServer(i invoke.Invoker) *PermissionServer {
 	return &PermissionServer{
 		invoker: i,
-		logger:  l,
 	}
 }
 
@@ -40,7 +39,7 @@ func (r *PermissionServer) Check(ctx context.Context, request *v1.PermissionChec
 	if err != nil {
 		span.RecordError(err)
 		span.SetStatus(otelCodes.Error, err.Error())
-		r.logger.Error(err.Error())
+		slog.Error(err.Error())
 		return nil, status.Error(GetStatus(err), err.Error())
 	}
 
@@ -61,7 +60,7 @@ func (r *PermissionServer) Expand(ctx context.Context, request *v1.PermissionExp
 	if err != nil {
 		span.RecordError(err)
 		span.SetStatus(otelCodes.Error, err.Error())
-		r.logger.Error(err.Error())
+		slog.Error(err.Error())
 		return nil, status.Error(GetStatus(err), err.Error())
 	}
 
@@ -82,7 +81,7 @@ func (r *PermissionServer) LookupEntity(ctx context.Context, request *v1.Permiss
 	if err != nil {
 		span.RecordError(err)
 		span.SetStatus(otelCodes.Error, err.Error())
-		r.logger.Error(err.Error())
+		slog.Error(err.Error())
 		return nil, status.Error(GetStatus(err), err.Error())
 	}
 
@@ -103,7 +102,7 @@ func (r *PermissionServer) LookupEntityStream(request *v1.PermissionLookupEntity
 	if err != nil {
 		span.RecordError(err)
 		span.SetStatus(otelCodes.Error, err.Error())
-		r.logger.Error(err.Error())
+		slog.Error(err.Error())
 		return status.Error(GetStatus(err), err.Error())
 	}
 
@@ -124,7 +123,7 @@ func (r *PermissionServer) LookupSubject(ctx context.Context, request *v1.Permis
 	if err != nil {
 		span.RecordError(err)
 		span.SetStatus(otelCodes.Error, err.Error())
-		r.logger.Error(err.Error())
+		slog.Error(err.Error())
 		return nil, status.Error(GetStatus(err), err.Error())
 	}
 
@@ -145,7 +144,7 @@ func (r *PermissionServer) SubjectPermission(ctx context.Context, request *v1.Pe
 	if err != nil {
 		span.RecordError(err)
 		span.SetStatus(otelCodes.Error, err.Error())
-		r.logger.Error(err.Error())
+		slog.Error(err.Error())
 		return nil, status.Error(GetStatus(err), err.Error())
 	}