refactor: added more documentation, upgraded dependencies, and substituted go-logger by slog

Author: ralvarezdev

cloud/gcloud/loader.go

@@ -10,6 +10,15 @@ import (
 )
 
 // LoadGoogleCredentials loads the Google credentials
+//
+// Parameters:
+//
+//   - ctx: context.Context
+//
+// Returns:
+//
+//   - *google.Credentials: Google credentials
+//   - error: error if any
 func LoadGoogleCredentials(ctx context.Context) (*google.Credentials, error) {
 	credentials, err := google.FindDefaultCredentials(ctx)
 	if err != nil {
@@ -19,6 +28,17 @@ func LoadGoogleCredentials(ctx context.Context) (*google.Credentials, error) {
 }
 
 // LoadServiceAccountCredentials loads the service account credentials
+//
+// Parameters:
+//
+//   - ctx: context.Context
+//   - url: string
+//   - credentials: *google.Credentials
+//
+// Returns:
+//
+//   - *oauth.TokenSource: OAuth2 token source
+//   - error: error if any
 func LoadServiceAccountCredentials(
 	ctx context.Context, url string, credentials *google.Credentials,
 ) (*oauth.TokenSource, error) {

cloud/gcloud/logger.go

@@ -1,52 +1,50 @@
 package gcloud
 
 import (
-	gologgermode "github.com/ralvarezdev/go-logger/mode"
-	gologgermodenamed "github.com/ralvarezdev/go-logger/mode/named"
+	"log/slog"
+
 	"google.golang.org/grpc/credentials/oauth"
 )
 
-// Logger is the logger for Google Cloud
-type Logger struct {
-	logger gologgermodenamed.Logger
-}
-
-// NewLogger is the logger for Google Cloud
-func NewLogger(header string, modeLogger gologgermode.Logger) (*Logger, error) {
-	// Initialize the mode named logger
-	namedLogger, err := gologgermodenamed.NewDefaultLogger(header, modeLogger)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Logger{logger: namedLogger}, nil
-}
-
 // FailedToLoadTokenSource logs the failed to load token source
-func (l *Logger) FailedToLoadTokenSource(err error) {
-	l.logger.Error(
-		"failed to load token source",
-		err,
-	)
+//
+// Parameters:
+//
+//   - err: the error
+//   - logger: the logger
+func FailedToLoadTokenSource(err error, logger *slog.Logger) {
+	if logger != nil {
+		logger.Error(
+			"failed to load token source",
+			slog.String("error", err.Error()),
+		)
+	}
 }
 
 // LoadedTokenSource logs the loaded token source
-func (l *Logger) LoadedTokenSource(tokenSource *oauth.TokenSource) {
+//
+// Parameters:
+//
+//   - tokenSource: the token source
+//   - logger: the logger
+func LoadedTokenSource(tokenSource *oauth.TokenSource, logger *slog.Logger) {
 	// Check if the token source is nil
 	if tokenSource == nil {
-		l.FailedToLoadTokenSource(ErrNilTokenSource)
+		FailedToLoadTokenSource(ErrNilTokenSource, logger)
 		return
 	}
 
 	// Get the access token from the token source
 	token, err := tokenSource.Token()
 	if err != nil {
-		l.FailedToLoadTokenSource(err)
+		FailedToLoadTokenSource(err, logger)
 		return
 	}
 
-	l.logger.Debug(
-		"loaded token source",
-		token.AccessToken,
-	)
+	if logger != nil {
+		logger.Debug(
+			"loaded token source",
+			slog.String("access_token", token.AccessToken),
+		)
+	}
 }

env/errors.go

@@ -1,12 +1,17 @@
 package env
 
-import "errors"
+import (
+	"errors"
+)
+
+const (
+	ErrNilDestination              = "destination cannot be nil for the given key: %v"
+	ErrEnvironmentVariableNotFound = "environment variable not found: %v"
+	ErrInvalidDuration             = "invalid key '%v' duration value: %v"
+	ErrInvalidInteger              = "invalid key '%v' integer value: %v"
+)
 
 var (
 	ErrNilLoader                        = errors.New("loader cannot be nil")
-	ErrNilDestination                   = "destination cannot be nil for the given key: %v"
-	ErrEnvironmentVariableNotFound      = "environment variable not found: %v"
 	ErrFailedToLoadEnvironmentVariables = errors.New("failed to load environment variables")
-	ErrInvalidDuration                  = "invalid key '%v' duration value: %v"
-	ErrInvalidInteger                   = "invalid key '%v' integer value: %v"
 )

env/interfaces.go

@@ -0,0 +1,15 @@
+package env
+
+import (
+	"time"
+)
+
+type (
+	// Loader interface for loading environment variables
+	Loader interface {
+		LoadVariable(key string, dest *string) error
+		LoadDurationVariable(key string, dest *time.Duration) error
+		LoadSecondsVariable(key string, dest *float64) error
+		LoadIntVariable(key string, dest *int) error
+	}
+)

env/loader.go

@@ -2,28 +2,31 @@ package env
 
 import (
 	"fmt"
+	"log/slog"
 	"os"
 	"strconv"
 	"time"
 )
 
 type (
-	// Loader interface for loading environment variables
-	Loader interface {
-		LoadVariable(key string, dest *string) error
-		LoadDurationVariable(key string, dest *time.Duration) error
-		LoadSecondsVariable(key string, dest *float64) error
-		LoadIntVariable(key string, dest *int) error
-	}
-
 	// DefaultLoader struct
 	DefaultLoader struct {
-		logger *Logger
+		logger *slog.Logger
 	}
 )
 
 // NewDefaultLoader creates a new default environment variable loader
-func NewDefaultLoader(loadFn func() error, logger *Logger) (
+//
+// Parameters:
+//
+//   - loadFn: function to load the environment variables (e.g., from a file)
+//   - logger: logger instance for logging
+//
+// Returns:
+//
+//   - *DefaultLoader: instance of DefaultLoader
+//   - error: error if any occurred during loading
+func NewDefaultLoader(loadFn func() error, logger *slog.Logger) (
 	*DefaultLoader,
 	error,
 ) {
@@ -33,11 +36,25 @@ func NewDefaultLoader(loadFn func() error, logger *Logger) (
 			return nil, ErrFailedToLoadEnvironmentVariables
 		}
 	}
+
+	// Prepare the logger
+	if logger != nil {
+		logger = logger.With("component", "env_loader")
+	}
 	return &DefaultLoader{logger}, nil
 }
 
 // LoadVariable load variable from environment variables
-func (d *DefaultLoader) LoadVariable(key string, dest *string) error {
+//
+// Parameters:
+//
+//   - key: environment variable key
+//   - dest: pointer to the destination string where the value will be stored
+//
+// Returns:
+//
+//   - error: error if any occurred during loading or parsing
+func (d DefaultLoader) LoadVariable(key string, dest *string) error {
 	// Check if the destination is nil
 	if dest == nil {
 		return fmt.Errorf(ErrNilDestination, key)
@@ -51,15 +68,22 @@ func (d *DefaultLoader) LoadVariable(key string, dest *string) error {
 	*dest = variable
 
 	// Log the environment variable
-	if d.logger != nil {
-		d.logger.EnvironmentVariableLoaded(key)
-	}
+	EnvironmentVariableLoaded(d.logger, key)
 
 	return nil
 }
 
 // LoadDurationVariable load duration variable from environment variables
-func (d *DefaultLoader) LoadDurationVariable(
+//
+// Parameters:
+//
+//   - key: environment variable key
+//   - dest: pointer to the destination time.Duration where the value will be stored
+//
+// Returns:
+//
+//   - error: error if any occurred during loading or parsing
+func (d DefaultLoader) LoadDurationVariable(
 	key string,
 	dest *time.Duration,
 ) error {
@@ -84,7 +108,16 @@ func (d *DefaultLoader) LoadDurationVariable(
 }
 
 // LoadSecondsVariable load duration variable in seconds from environment variables
-func (d *DefaultLoader) LoadSecondsVariable(key string, dest *float64) error {
+//
+// Parameters:
+//
+//   - key: environment variable key
+//   - dest: pointer to the destination float64 where the value in seconds will be stored
+//
+// Returns:
+//
+//   - error: error if any occurred during loading or parsing
+func (d DefaultLoader) LoadSecondsVariable(key string, dest *float64) error {
 	// Check if the destination is nil
 	if dest == nil {
 		return fmt.Errorf(ErrNilDestination, key)
@@ -100,7 +133,16 @@ func (d *DefaultLoader) LoadSecondsVariable(key string, dest *float64) error {
 }
 
 // LoadIntVariable load integer variable from environment variables
-func (d *DefaultLoader) LoadIntVariable(key string, dest *int) error {
+//
+// Parameters:
+//
+//   - key: environment variable key
+//   - dest: pointer to the destination int where the value will be stored
+//
+// Returns:
+//
+//   - error: error if any occurred during loading or parsing
+func (d DefaultLoader) LoadIntVariable(key string, dest *int) error {
 	// Check if the destination is nil
 	if dest == nil {
 		return fmt.Errorf(ErrNilDestination, key)

env/logger.go

@@ -1,30 +1,20 @@
 package env
 
 import (
-	gologgermode "github.com/ralvarezdev/go-logger/mode"
-	gologgermodenamed "github.com/ralvarezdev/go-logger/mode/named"
+	"log/slog"
 )
 
-// Logger is the environment logger
-type Logger struct {
-	logger gologgermodenamed.Logger
-}
-
-// NewLogger creates a new environment logger
-func NewLogger(header string, modeLogger gologgermode.Logger) (*Logger, error) {
-	// Initialize the mode named logger
-	namedLogger, err := gologgermodenamed.NewDefaultLogger(header, modeLogger)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Logger{logger: namedLogger}, nil
-}
-
 // EnvironmentVariableLoaded logs a message when an environment variable is loaded
-func (l *Logger) EnvironmentVariableLoaded(variablesName ...string) {
-	l.logger.Debug(
-		"environment variable loaded",
-		variablesName...,
-	)
+//
+// Parameters:
+//
+//   - logger: The slog.Logger instance to use for logging.
+//   - variablesName: A variadic list of environment variable names that were loaded.
+func EnvironmentVariableLoaded(logger *slog.Logger, variablesName ...string) {
+	if logger != nil {
+		logger.Debug(
+			"environment variable loaded",
+			slog.Any("variables", variablesName),
+		)
+	}
 }

filesystem/errors.go

@@ -4,7 +4,10 @@ import (
 	"errors"
 )
 
-var (
+const (
 	ErrUnableToReadFile = "unable to read file: %v"
-	ErrNilFile          = errors.New("file cannot be nil")
+)
+
+var (
+	ErrNilFile = errors.New("file cannot be nil")
 )