fix and improve sentry integration with logger (#50)

operator/cmd/main.go

@@ -74,27 +74,28 @@ func main() {
 }
 
 func mainWithError() error {
-	zapLogger, err := tfLogger.NewLogger("dev")
-	if err != nil {
-		setupLog.Error(err, "unable to create logger")
-	}
-
 	// Initialize Sentry
 	sentryDsn := os.Getenv("SENTRY_DSN")
+	sentryEnabled := sentryDsn != ""
 
-	if sentryDsn != "" {
-		zapLogger.Info("Initializing Sentry")
-		if err = sentry.Init(sentry.ClientOptions{
+	if sentryEnabled {
+		fmt.Println("Initializing Sentry")
+		if err := sentry.Init(sentry.ClientOptions{
 			Dsn:              sentryDsn,
 			EnableTracing:    true,
 			TracesSampleRate: 1.0,
 			Environment:      os.Getenv("SENTRY_ENVIRONMENT"),
 		}); err != nil {
-			zapLogger.Error("Sentry initialization failed")
+			fmt.Println("ERROR: Sentry initialization failed")
 		}
 		defer sentry.Flush(2 * time.Second)
 	}
 
+	zapLogger, err := tfLogger.NewLogger("dev", sentryEnabled)
+	if err != nil {
+		setupLog.Error(err, "unable to create logger")
+	}
+
 	var metricsAddr string
 	var enableLeaderElection bool
 	var probeAddr string

operator/internal/controller/elastiservice_controller.go

@@ -90,7 +90,7 @@ func (r *ElastiServiceReconciler) Reconcile(ctx context.Context, req ctrl.Reques
 	// If the ElastiService is being deleted, we need to clean up the resources
 	if isDeleted, err := r.finalizeCRDIfDeleted(ctx, es, req); err != nil {
 		r.Logger.Error("Failed to check if CRD is deleted", zap.String("es", req.String()), zap.Error(err))
-		sentry.CaptureException(esErr)
+		sentry.CaptureException(err)
 		return res, err
 	} else if isDeleted {
 		r.Logger.Info("[CRD is deleted successfully]", zap.String("es", req.String()))
@@ -100,15 +100,15 @@ func (r *ElastiServiceReconciler) Reconcile(ctx context.Context, req ctrl.Reques
 	// We also check if the CRD has finalizer, and if not, we add the finalizer
 	if err := r.addCRDFinalizer(ctx, es); err != nil {
 		r.Logger.Error("Failed to finalize CRD", zap.String("es", req.String()), zap.Error(err))
-		sentry.CaptureException(esErr)
+		sentry.CaptureException(err)
 		return res, err
 	}
 	r.Logger.Info("Finalizer added to CRD", zap.String("es", req.String()))
 
 	// Add watch for public service, so when the public service is modified, we can update the private service
 	if err := r.watchScaleTargetRef(ctx, es, req); err != nil {
 		r.Logger.Error("Failed to add watch for ScaleTargetRef", zap.String("es", req.String()), zap.Any("scaleTargetRef", es.Spec.ScaleTargetRef), zap.Error(err))
-		sentry.CaptureException(esErr)
+		sentry.CaptureException(err)
 		return res, err
 	}
 	r.Logger.Info("Watch added for ScaleTargetRef", zap.String("es", req.String()), zap.Any("scaleTargetRef", es.Spec.ScaleTargetRef))
@@ -127,7 +127,10 @@ func (r *ElastiServiceReconciler) SetupWithManager(mgr ctrl.Manager) error {
 	err := ctrl.NewControllerManagedBy(mgr).
 		For(&v1alpha1.ElastiService{}).
 		Complete(r)
-	return fmt.Errorf("SetupWithManager: %w", err)
+	if err != nil {
+		return fmt.Errorf("SetupWithManager: %w", err)
+	}
+	return nil
 }
 
 func (r *ElastiServiceReconciler) getMutexForReconcile(key string) *sync.Mutex {

pkg/logger/logger.go

@@ -2,25 +2,41 @@ package logger
 
 import (
 	"fmt"
+	"github.com/getsentry/sentry-go"
 	"os"
 
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
 )
 
-func NewLogger(env string) (*zap.Logger, error) {
+func NewLogger(env string, sentryEnabled bool) (*zap.Logger, error) {
+	var logger *zap.Logger
+
 	if env == "prod" {
-		logger, err := zap.NewProduction()
+		var err error
+		logger, err = zap.NewProduction()
 		if err != nil {
 			return nil, fmt.Errorf("failed to create logger: %w", err)
 		}
-		return logger, nil
+	} else {
+		encoderConfig := zap.NewDevelopmentEncoderConfig()
+		encoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
+		encoderConfig.EncodeTime = zapcore.RFC3339TimeEncoder
+		encoderConfig.EncodeDuration = zapcore.StringDurationEncoder
+		consoleEncoder := zapcore.NewConsoleEncoder(encoderConfig)
+
+		core := zapcore.NewCore(consoleEncoder, zapcore.AddSync(os.Stdout), zapcore.DebugLevel)
+		logger = zap.New(core)
 	}
-	encoderConfig := zap.NewDevelopmentEncoderConfig()
-	encoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
-	encoderConfig.EncodeTime = zapcore.RFC3339TimeEncoder
-	encoderConfig.EncodeDuration = zapcore.StringDurationEncoder
-	consoleEncoder := zapcore.NewConsoleEncoder(encoderConfig)
-	core := zapcore.NewCore(consoleEncoder, zapcore.AddSync(os.Stdout), zapcore.DebugLevel)
-	return zap.New(core), nil
+
+	if sentryEnabled {
+		logger = logger.WithOptions(zap.Hooks(func(entry zapcore.Entry) error {
+			if entry.Level == zapcore.ErrorLevel {
+				sentry.CaptureMessage(entry.Message)
+			}
+			return nil
+		}))
+	}
+
+	return logger, nil
 }

resolver/cmd/main.go

@@ -1,11 +1,12 @@
 package main
 
 import (
+	"fmt"
+	"github.com/getsentry/sentry-go"
 	"log"
 	"net/http"
 	"time"
 
-	"github.com/getsentry/sentry-go"
 	sentryhttp "github.com/getsentry/sentry-go/http"
 
 	"github.com/truefoundry/elasti/resolver/internal/handler"
@@ -52,33 +53,36 @@ const (
 )
 
 func main() {
-	logger, err := logger.NewLogger("dev")
-	if err != nil {
-		log.Fatal("Failed to get logger: ", err)
-	}
 	var env config
 	if err := envconfig.Process("", &env); err != nil {
 		log.Fatal("Failed to process env: ", err)
 	}
-	logger.Info("config", zap.Any("env", env))
-	config, err := rest.InClusterConfig()
-	if err != nil {
-		logger.Fatal("Error fetching cluster config", zap.Error(err))
-	}
 
-	if env.SentryDsn != "" {
-		logger.Info("Initializing Sentry")
-		if err = sentry.Init(sentry.ClientOptions{
+	sentryEnabled := env.SentryDsn != ""
+
+	if sentryEnabled {
+		fmt.Println("Initializing Sentry")
+		if err := sentry.Init(sentry.ClientOptions{
 			Dsn:              env.SentryDsn,
 			EnableTracing:    true,
 			TracesSampleRate: 1.0,
 			Environment:      env.SentryEnv,
 		}); err != nil {
-			logger.Error("Sentry initialization failed:", zap.Error(err))
+			fmt.Println("Sentry initialization failed:", err)
 		}
 		defer sentry.Flush(2 * time.Second)
 	}
 
+	logger, err := logger.NewLogger("dev", sentryEnabled)
+	if err != nil {
+		log.Fatal("Failed to get logger: ", err)
+	}
+
+	config, err := rest.InClusterConfig()
+	if err != nil {
+		logger.Fatal("Error fetching cluster config", zap.Error(err))
+	}
+
 	// Get components required for the handler
 	k8sUtil := k8shelper.NewOps(logger, config)
 	newOperatorRPC := operator.NewOperatorClient(logger, time.Duration(env.OperatorRetryDuration)*time.Second)