improve the logging

Author: behzad-mir

cns/cni-telemetry-sidecar/main.go

@@ -7,26 +7,46 @@ import (
 	"os/signal"
 	"syscall"
 
-	"github.com/Azure/azure-container-networking/cns/logger"
+	"github.com/Azure/azure-container-networking/cns/logger/v2"
+	cores "github.com/Azure/azure-container-networking/cns/logger/v2/cores"
+	"go.uber.org/zap"
 )
 
 var (
 	version    = "unknown"
 	configPath = flag.String("config", "/etc/cns/cns-config.json", "Path to CNS configuration file")
+	logLevel   = flag.String("log-level", "info", "Log level (debug, info, warn, error)")
 )
 
 func main() {
 	flag.Parse()
 
-	// Initialize logging for the CNI telemetry sidecar
-	logger.InitLogger("azure-cns-cni-telemetry-sidecar", 1, 1, "/var/log/azure-cns-telemetry")
-	defer logger.Close()
+	// Initialize main logger with correct path for shared volume
+	zapLogger, cleanup, err := logger.New(&logger.Config{
+		Level: *logLevel,
+		File: &cores.FileConfig{
+			Filepath: "/var/log/azure-cni-telemetry-sidecar.log", // This will write to host's /var/log/azure-cns/
+		},
+	})
+	if err != nil {
+		panic("Failed to initialize logger: " + err.Error())
+	}
+	defer cleanup()
 
-	logger.Printf("Starting Azure CNI Telemetry Sidecar v%s", version)
+	zapLogger.Info("Starting Azure CNI Telemetry Sidecar",
+		zap.String("version", version),
+		zap.String("configPath", *configPath),
+		zap.String("logLevel", *logLevel))
 
-	// Create telemetry sidecar service
+	// Create telemetry sidecar service and pass the logger
 	sidecar := NewTelemetrySidecar(*configPath)
 
+	// Set the logger for the sidecar to avoid nil pointer
+	if err := sidecar.SetLogger(zapLogger); err != nil {
+		zapLogger.Error("Failed to set logger for sidecar", zap.Error(err))
+		os.Exit(1)
+	}
+
 	// Setup graceful shutdown context
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
@@ -37,15 +57,17 @@ func main() {
 
 	go func() {
 		sig := <-sigCh
-		logger.Printf("Received shutdown signal %v, initiating graceful shutdown", sig)
+		zapLogger.Info("Received shutdown signal, initiating graceful shutdown",
+			zap.String("signal", sig.String()))
 		cancel()
 	}()
 
-	// Run the telemetry sidecar
+	// Run the telemetry sidecar (using the Run method from sidecar.go)
 	if err := sidecar.Run(ctx); err != nil {
-		logger.Errorf("Azure CNI Telemetry Sidecar failed: %v", err)
+		zapLogger.Error("Azure CNI Telemetry Sidecar failed",
+			zap.Error(err))
 		os.Exit(1)
 	}
 
-	logger.Printf("Azure CNI Telemetry Sidecar stopped gracefully")
+	zapLogger.Info("Azure CNI Telemetry Sidecar stopped gracefully")
 }

cns/cni-telemetry-sidecar/sidecar.go

@@ -7,8 +7,8 @@ import (
 
 	"github.com/Azure/azure-container-networking/aitelemetry"
 	"github.com/Azure/azure-container-networking/cns/configuration"
-	"github.com/Azure/azure-container-networking/cns/logger"
 	"github.com/Azure/azure-container-networking/telemetry"
+	"go.uber.org/zap"
 )
 
 const (
@@ -23,6 +23,7 @@ type TelemetrySidecar struct {
 	configPath      string
 	configManager   *ConfigManager
 	telemetryBuffer *telemetry.TelemetryBuffer
+	logger          *zap.Logger
 }
 
 // NewTelemetrySidecar creates a new telemetry sidecar instance
@@ -33,9 +34,22 @@ func NewTelemetrySidecar(configPath string) *TelemetrySidecar {
 	}
 }
 
+// SetLogger sets the zap logger for the sidecar
+func (s *TelemetrySidecar) SetLogger(logger *zap.Logger) error {
+	if logger == nil {
+		return fmt.Errorf("logger cannot be nil")
+	}
+	s.logger = logger
+	return nil
+}
+
 // Run starts the telemetry sidecar and manages its lifecycle
 func (s *TelemetrySidecar) Run(ctx context.Context) error {
-	logger.Printf("Initializing Azure CNI Telemetry Sidecar for azure-vnet-telemetry")
+	if s.logger == nil {
+		return fmt.Errorf("logger not initialized - call SetLogger() first")
+	}
+
+	s.logger.Info("Initializing Azure CNI Telemetry Sidecar for azure-vnet-telemetry")
 
 	// Load CNS configuration from shared mount
 	config, err := s.configManager.LoadConfig()
@@ -45,7 +59,7 @@ func (s *TelemetrySidecar) Run(ctx context.Context) error {
 
 	// Determine if telemetry should run based on configuration and environment
 	if !s.shouldRunTelemetry(config) {
-		logger.Printf("CNI Telemetry disabled, entering sleep mode")
+		s.logger.Info("CNI Telemetry disabled, entering sleep mode")
 		return s.sleepUntilShutdown(ctx)
 	}
 
@@ -55,7 +69,7 @@ func (s *TelemetrySidecar) Run(ctx context.Context) error {
 	}
 
 	// Start telemetry service mimicking azure-vnet-telemetry behavior
-	logger.Printf("Starting Azure VNet Telemetry service (CNI mode)")
+	s.logger.Info("Starting Azure VNet Telemetry service (CNI mode)")
 	return s.runCNITelemetryService(ctx)
 }
 
@@ -93,8 +107,10 @@ func (s *TelemetrySidecar) initializeCNITelemetry(config *configuration.CNSConfi
 		return fmt.Errorf("failed to create AI telemetry handle for CNI: %w", err)
 	}
 
-	logger.Printf("CNI Telemetry initialized with Application Insights (App: %s, Version: %s, BatchSize: %d)",
-		cniTelemetryAppName, cniTelemetryVersion, ts.TelemetryBatchSizeBytes)
+	s.logger.Info("CNI Telemetry initialized with Application Insights",
+		zap.String("app", cniTelemetryAppName),
+		zap.String("version", cniTelemetryVersion),
+		zap.Int("batchSize", ts.TelemetryBatchSizeBytes))
 	return nil
 }
 
@@ -108,19 +124,20 @@ func (s *TelemetrySidecar) runCNITelemetryService(ctx context.Context) error {
 		return fmt.Errorf("failed to start CNI telemetry server: %w", err)
 	}
 
-	logger.Printf("Azure VNet Telemetry server started successfully on socket: %s", telemetrySocket)
+	s.logger.Info("Azure VNet Telemetry server started successfully",
+		zap.String("socket", telemetrySocket))
 
 	// Start telemetry data collection in background (non-blocking)
 	go s.telemetryBuffer.PushData(ctx)
 
 	// Log readiness for CNI network event collection
-	logger.Printf("CNI Telemetry sidecar ready to collect Azure network interface events")
+	s.logger.Info("CNI Telemetry sidecar ready to collect Azure network interface events")
 
 	// Wait for context cancellation (graceful shutdown signal)
 	<-ctx.Done()
 
 	// Perform cleanup and graceful shutdown
-	logger.Printf("Shutting down Azure CNI Telemetry service")
+	s.logger.Info("Shutting down Azure CNI Telemetry service")
 	return s.shutdownTelemetry()
 }
 
@@ -131,9 +148,10 @@ func (s *TelemetrySidecar) cleanupExistingInstances() {
 
 	// Use the same FdName that azure-vnet-telemetry uses for consistency
 	if err := tempBuffer.Cleanup(telemetry.FdName); err != nil {
-		logger.Printf("Warning: Failed to cleanup existing CNI telemetry instances: %v", err)
+		s.logger.Warn("Failed to cleanup existing CNI telemetry instances",
+			zap.Error(err))
 	} else {
-		logger.Printf("Successfully cleaned up existing CNI telemetry instances")
+		s.logger.Info("Successfully cleaned up existing CNI telemetry instances")
 	}
 }
 
@@ -142,7 +160,7 @@ func (s *TelemetrySidecar) shutdownTelemetry() error {
 	if s.telemetryBuffer != nil {
 		// Close telemetry buffer (ensures data is flushed to Azure)
 		s.telemetryBuffer.Close()
-		logger.Printf("CNI Telemetry buffer closed and remaining data flushed to Azure")
+		s.logger.Info("CNI Telemetry buffer closed and remaining data flushed to Azure")
 	}
 	return nil
 }
@@ -151,30 +169,30 @@ func (s *TelemetrySidecar) shutdownTelemetry() error {
 func (s *TelemetrySidecar) shouldRunTelemetry(config *configuration.CNSConfig) bool {
 	// Check global telemetry disable flag in CNS configuration
 	if config.TelemetrySettings.DisableAll {
-		logger.Printf("CNI Telemetry disabled globally in CNS configuration")
+		s.logger.Info("CNI Telemetry disabled globally in CNS configuration")
 		return false
 	}
 
 	// Check CNI telemetry specific enable flag (replaces old "ts" option)
 	cniTelemetryEnabled := os.Getenv("CNI_TELEMETRY_ENABLED")
 	if cniTelemetryEnabled != "true" {
-		logger.Printf("CNI Telemetry not enabled via CNI_TELEMETRY_ENABLED environment variable")
+		s.logger.Info("CNI Telemetry not enabled via CNI_TELEMETRY_ENABLED environment variable")
 		return false
 	}
 
 	// Validate Application Insights key availability
 	if config.TelemetrySettings.AppInsightsInstrumentationKey == "" {
-		logger.Printf("No Application Insights instrumentation key configured for CNI telemetry")
+		s.logger.Info("No Application Insights instrumentation key configured for CNI telemetry")
 		return false
 	}
 
-	logger.Printf("CNI Telemetry enabled - will collect Azure network interface events")
+	s.logger.Info("CNI Telemetry enabled - will collect Azure network interface events")
 	return true
 }
 
 // sleepUntilShutdown keeps the container running when telemetry is disabled
 func (s *TelemetrySidecar) sleepUntilShutdown(ctx context.Context) error {
-	logger.Printf("CNI Telemetry sidecar sleeping until shutdown signal received")
+	s.logger.Info("CNI Telemetry sidecar sleeping until shutdown signal received")
 	<-ctx.Done()
 	return ctx.Err()
 }