chaning sidecar code

Author: behzad-mir

Makefile

@@ -36,8 +36,8 @@ ACN_VERSION							?= $(shell git describe --exclude "azure-ip-masq-merger*" --ex
 IPV6_HP_BPF_VERSION					?= $(notdir $(shell git describe --match "ipv6-hp-bpf*" --tags --always))
 AZURE_IPAM_VERSION					?= $(notdir $(shell git describe --match "azure-ipam*" --tags --always))
 AZURE_IP_MASQ_MERGER_VERSION		?= $(notdir $(shell git describe --match "azure-ip-masq-merger*" --tags --always))
-CNI_VERSION							?= $(ACN_VERSION)
-CNS_VERSION							?= $(ACN_VERSION)
+CNI_VERSION							?= $(ACN_VERSION)-9
+CNS_VERSION							?= $(ACN_VERSION)-9
 NPM_VERSION							?= $(ACN_VERSION)
 ZAPAI_VERSION						?= $(notdir $(shell git describe --match "zapai*" --tags --always))
 
@@ -219,9 +219,14 @@ azure-vnet-telemetry-binary:
 	cd $(CNI_TELEMETRY_DIR) && CGO_ENABLED=0 go build -v -o $(CNI_BUILD_DIR)/azure-vnet-telemetry$(EXE_EXT) -ldflags "-X main.version=$(CNI_VERSION) -X $(CNI_AI_PATH)=$(CNI_AI_ID)" -gcflags="-dwarflocationlists=true"
 
 # Build the Azure CNI Telemetry Sidecar binary.
-cni-telemetry-sidecar-binary:
-	cd $(CNI_TELEMETRY_SIDECAR_DIR) && CGO_ENABLED=0 go build -v -o $(CNI_TELEMETRY_SIDECAR_BUILD_DIR)/azure-cni-telemetry-sidecar$(EXE_EXT) -ldflags "-X main.version=$(CNI_TELEMETRY_SIDECAR_VERSION) -X $(CNI_AI_PATH)=$(CNI_TELEMETRY_SIDECAR_AI_ID)" -gcflags="-dwarflocationlists=true"
-
+cni-telemetry-sidecar-binary: ## build cni-telemetry-sidecar binary.
+	$(MKDIR) $(CNI_TELEMETRY_SIDECAR_BUILD_DIR)
+	cd $(CNI_TELEMETRY_SIDECAR_DIR) && CGO_ENABLED=0 go build \
+    	-v \
+    	-o $(CNI_TELEMETRY_SIDECAR_BUILD_DIR)/azure-cni-telemetry-sidecar$(EXE_EXT) \
+    	-ldflags "-X main.version=$(CNI_TELEMETRY_SIDECAR_VERSION) -X $(CNI_AI_PATH)=$(CNI_TELEMETRY_SIDECAR_AI_ID)" \
+    	-gcflags="-dwarflocationlists=true" \
+    	.
 # Build the Azure CLI network binary.
 acncli-binary:
 	cd $(ACNCLI_DIR) && CGO_ENABLED=0 go build -v -o $(ACNCLI_BUILD_DIR)/acn$(EXE_EXT) -ldflags "-X main.version=$(ACN_VERSION)" -gcflags="-dwarflocationlists=true"
@@ -564,7 +569,7 @@ cni-telemetry-sidecar-image: ## build cni-telemetry-sidecar container image.
 	$(MAKE) container \
         DOCKERFILE=cns/cni-telemetry-sidecar/Dockerfile \
         IMAGE=$(CNI_TELEMETRY_SIDECAR_IMAGE) \
-        EXTRA_BUILD_ARGS='--build-arg CNI_AI_PATH=$(CNI_AI_PATH) --build-arg CNI_AI_ID=$(CNI_TELEMETRY_SIDECAR_AI_ID)' \
+        EXTRA_BUILD_ARGS='--build-arg CNI_AI_PATH=$(CNI_AI_PATH) --build-arg CNI_AI_ID=$(CNI_TELEMETRY_SIDECAR_AI_ID) --build-arg VERSION=$(CNI_TELEMETRY_SIDECAR_VERSION)' \
         PLATFORM=$(PLATFORM) \
         TAG=$(CNI_TELEMETRY_SIDECAR_PLATFORM_TAG) \
         TARGET=$(OS) \

cns/cni-telemetry-sidecar/Dockerfile

@@ -1,59 +1,44 @@
-# Azure CNI Telemetry Sidecar Dockerfile
-# Based on proven CNI Dockerfile pattern from azure-container-networking
 ARG ARCH
 ARG OS_VERSION
 ARG OS
 
-# Use the same proven base images as CNI
-# mcr.microsoft.com/oss/go/microsoft/golang:1.23-azurelinux3.0
 FROM --platform=linux/${ARCH} mcr.microsoft.com/oss/go/microsoft/golang@sha256:8f60e85f4b2f567c888d0b3a4cd12dc74bee534d94c528655546452912d90c74 AS go
 
-# mcr.microsoft.com/azurelinux/base/core:3.0
-FROM --platform=linux/${ARCH} mcr.microsoft.com/azurelinux/base/core@sha256:9948138108a3d69f1dae62104599ac03132225c3b7a5ac57b85a214629c8567d AS mariner-core
-
-FROM go AS azure-cni-telemetry-sidecar
+FROM go AS cni-telemetry-sidecar
 ARG OS
 ARG VERSION
 ARG CNI_AI_PATH
 ARG CNI_AI_ID
 
+# Add debug output to verify build args are received
+RUN echo "=== Dockerfile Build Debug ==="
+RUN echo "VERSION = $VERSION"
+RUN echo "CNI_AI_ID = $CNI_AI_ID"
+RUN echo "CNI_AI_PATH = $CNI_AI_PATH"
+
 WORKDIR /azure-container-networking
 COPY . .
 
-# Debug: Check if the source file exists and show Go version
-RUN ls -la cns/cni-telemetry-sidecar/ && go version
-
-# Build the Azure CNI telemetry sidecar binary for Linux
-RUN CGO_ENABLED=0 GOOS=linux go build \
-    -a \
-    -o /go/bin/azure-cni-telemetry-sidecar \
-    -trimpath \
-    -ldflags "-X main.version=${VERSION:-unknown} -X ${CNI_AI_PATH:-main.aiMetadata}=${CNI_AI_ID:-unknown}" \
-    -gcflags="-dwarflocationlists=true" \
-    ./cns/cni-telemetry-sidecar/
-
-# Build the Azure CNI telemetry sidecar binary for Windows
-RUN CGO_ENABLED=0 GOOS=windows go build \
-    -a \
-    -o /go/bin/azure-cni-telemetry-sidecar.exe \
+# Build the telemetry sidecar with embedded AppInsights key using CNI_AI_PATH
+RUN GOOS=$OS CGO_ENABLED=0 go build -a -o /go/bin/azure-cni-telemetry-sidecar \
     -trimpath \
-    -ldflags "-X main.version=${VERSION:-unknown} -X ${CNI_AI_PATH:-main.aiMetadata}=${CNI_AI_ID:-unknown}" \
+    -ldflags "-X main.version=$VERSION -X $CNI_AI_PATH=$CNI_AI_ID" \
     -gcflags="-dwarflocationlists=true" \
-    ./cns/cni-telemetry-sidecar/
+    ./cns/cni-telemetry-sidecar
 
-# Verify both binaries were built
-RUN ls -la /go/bin/azure-cni-telemetry-sidecar*
+# Verify the key is embedded in the telemetry.aiMetadata variable
+RUN echo "=== Binary Debug ==="
+RUN strings /go/bin/azure-cni-telemetry-sidecar | grep "5515a1eb" || echo "AI key NOT found in binary!"
+RUN ls -la /go/bin/azure-cni-telemetry-sidecar
 
 FROM scratch AS bins
-COPY --from=azure-cni-telemetry-sidecar /go/bin/* /
+COPY --from=cni-telemetry-sidecar /go/bin/azure-cni-telemetry-sidecar /
 
-FROM scratch AS linux
-COPY --from=azure-cni-telemetry-sidecar /go/bin/azure-cni-telemetry-sidecar /azure-cni-telemetry-sidecar
-ENTRYPOINT [ "/azure-cni-telemetry-sidecar" ]
+FROM mcr.microsoft.com/azurelinux/base/core:3.0 AS linux
+COPY --from=cni-telemetry-sidecar /go/bin/azure-cni-telemetry-sidecar /usr/local/bin/
 
-# Windows support following CNI pattern
-FROM --platform=windows/${ARCH} mcr.microsoft.com/oss/kubernetes/windows-host-process-containers-base-image@sha256:b4c9637e032f667c52d1eccfa31ad8c63f1b035e8639f3f48a510536bf34032b AS hpc
+# Create directories for logs and config
+RUN mkdir -p /var/log /etc/azure-cns /var/run
 
-FROM hpc AS windows
-COPY --from=azure-cni-telemetry-sidecar /go/bin/azure-cni-telemetry-sidecar.exe /azure-cni-telemetry-sidecar.exe
-ENTRYPOINT [ "/azure-cni-telemetry-sidecar.exe" ]
+ENTRYPOINT ["/usr/local/bin/azure-cni-telemetry-sidecar"]
+CMD ["--config=/etc/azure-cns/cns_config.json", "--log-level=info"]

cns/cni-telemetry-sidecar/configmanager.go

@@ -29,7 +29,6 @@ func (cm *ConfigManager) SetLogger(logger *zap.Logger) {
 
 // LoadConfig loads the CNS configuration from file
 func (cm *ConfigManager) LoadConfig() (*configuration.CNSConfig, error) {
-	// Use zap logger if available, otherwise create a default config
 	if cm.logger != nil {
 		cm.logger.Debug("Loading CNS configuration", zap.String("path", cm.configPath))
 	}
@@ -40,22 +39,7 @@ func (cm *ConfigManager) LoadConfig() (*configuration.CNSConfig, error) {
 			cm.logger.Info("CNS config file not found, using default configuration",
 				zap.String("path", cm.configPath))
 		}
-
-		// Return default configuration
-		return &configuration.CNSConfig{
-			TelemetrySettings: configuration.TelemetrySettings{
-				DisableAll:                    false,
-				TelemetryBatchSizeBytes:       16384,
-				TelemetryBatchIntervalInSecs:  15,
-				RefreshIntervalInSecs:         15,
-				DisableMetadataRefreshThread:  false,
-				DebugMode:                     false,
-				DisableTrace:                  false,
-				DisableMetric:                 false,
-				DisableEvent:                  false,
-				AppInsightsInstrumentationKey: "", // Will be set by environment or config
-			},
-		}, nil
+		return cm.createDefaultConfig(), nil
 	}
 
 	// Read the config file
@@ -80,22 +64,96 @@ func (cm *ConfigManager) LoadConfig() (*configuration.CNSConfig, error) {
 		return nil, fmt.Errorf("failed to parse config file: %w", err)
 	}
 
+	// Apply defaults and environment variable overrides
+	cm.setConfigDefaults(&config)
+
+	if cm.logger != nil {
+		cm.logger.Info("Successfully loaded CNS configuration",
+			zap.String("path", cm.configPath),
+			zap.Bool("telemetryDisabled", config.TelemetrySettings.DisableAll),
+			zap.Bool("cniTelemetryEnabled", config.TelemetrySettings.EnableCNITelemetry),
+			zap.String("socketPath", config.TelemetrySettings.CNITelemetrySocketPath),
+			zap.Bool("hasAppInsightsKey", config.TelemetrySettings.AppInsightsInstrumentationKey != ""))
+	}
+
+	return &config, nil
+}
+
+// createDefaultConfig creates a default configuration
+func (cm *ConfigManager) createDefaultConfig() *configuration.CNSConfig {
+	config := &configuration.CNSConfig{
+		TelemetrySettings: configuration.TelemetrySettings{
+			DisableAll:                   false,
+			TelemetryBatchSizeBytes:      defaultBatchSizeInBytes,
+			TelemetryBatchIntervalInSecs: defaultBatchIntervalInSecs,
+			RefreshIntervalInSecs:        defaultRefreshTimeoutInSecs,
+			DisableMetadataRefreshThread: false,
+			DebugMode:                    false,
+			DisableTrace:                 false,
+			DisableMetric:                false,
+			DisableEvent:                 false,
+			EnableCNITelemetry:           false, // Default to false
+			CNITelemetrySocketPath:       "/var/run/azure-vnet-telemetry.sock",
+		},
+	}
+
+	// Set AppInsights key from environment variables
+	cm.setAppInsightsKey(&config.TelemetrySettings)
+
+	return config
+}
+
+// setConfigDefaults applies default values and environment variable overrides
+func (cm *ConfigManager) setConfigDefaults(config *configuration.CNSConfig) {
 	// Set default values for telemetry settings if not specified
 	if config.TelemetrySettings.TelemetryBatchSizeBytes == 0 {
-		config.TelemetrySettings.TelemetryBatchSizeBytes = 16384
+		config.TelemetrySettings.TelemetryBatchSizeBytes = defaultBatchSizeInBytes
 	}
 	if config.TelemetrySettings.TelemetryBatchIntervalInSecs == 0 {
-		config.TelemetrySettings.TelemetryBatchIntervalInSecs = 15
+		config.TelemetrySettings.TelemetryBatchIntervalInSecs = defaultBatchIntervalInSecs
 	}
 	if config.TelemetrySettings.RefreshIntervalInSecs == 0 {
-		config.TelemetrySettings.RefreshIntervalInSecs = 15
+		config.TelemetrySettings.RefreshIntervalInSecs = defaultRefreshTimeoutInSecs
 	}
 
-	if cm.logger != nil {
-		cm.logger.Info("Successfully loaded CNS configuration",
-			zap.String("path", cm.configPath),
-			zap.Bool("telemetryDisabled", config.TelemetrySettings.DisableAll))
+	// Set default CNI telemetry socket path
+	if config.TelemetrySettings.CNITelemetrySocketPath == "" {
+		config.TelemetrySettings.CNITelemetrySocketPath = "/var/run/azure-vnet-telemetry.sock"
 	}
 
-	return &config, nil
+	// Handle AppInsights instrumentation key from environment variables
+	cm.setAppInsightsKey(&config.TelemetrySettings)
+}
+
+// setAppInsightsKey sets the AppInsights instrumentation key from environment variables
+func (cm *ConfigManager) setAppInsightsKey(ts *configuration.TelemetrySettings) {
+	// Try multiple environment variable names
+	envKeys := []string{
+		"APPINSIGHTS_INSTRUMENTATIONKEY",
+		"APPLICATIONINSIGHTS_CONNECTION_STRING",
+		"AI_INSTRUMENTATION_KEY",
+	}
+
+	// If no key is set in config, try environment variables
+	if ts.AppInsightsInstrumentationKey == "" {
+		for _, envKey := range envKeys {
+			if key := os.Getenv(envKey); key != "" {
+				ts.AppInsightsInstrumentationKey = key
+				if cm.logger != nil {
+					cm.logger.Info("Using AppInsights key from environment variable",
+						zap.String("envVar", envKey))
+				}
+				break
+			}
+		}
+	}
+
+	// Log the status
+	if cm.logger != nil {
+		if ts.AppInsightsInstrumentationKey != "" {
+			cm.logger.Info("AppInsights instrumentation key configured for CNI telemetry")
+		} else {
+			cm.logger.Warn("No AppInsights instrumentation key found - telemetry will work locally but not send to Azure")
+		}
+	}
 }

cns/cni-telemetry-sidecar/main.go

@@ -7,67 +7,94 @@ import (
 	"os/signal"
 	"syscall"
 
-	"github.com/Azure/azure-container-networking/cns/logger/v2"
-	cores "github.com/Azure/azure-container-networking/cns/logger/v2/cores"
+	"github.com/Azure/azure-container-networking/telemetry"
 	"go.uber.org/zap"
 )
 
 var (
-	version    = "unknown"
-	configPath = flag.String("config", "/etc/cns/cns-config.json", "Path to CNS configuration file")
+	configPath = flag.String("config", "/etc/azure-cns/cns_config.json", "Path to CNS configuration file")
 	logLevel   = flag.String("log-level", "info", "Log level (debug, info, warn, error)")
+
+	// This variable is set at build time via ldflags from Makefile
+	version = "1.0.0" // -X main.version=$(CNI_TELEMETRY_SIDECAR_VERSION)
 )
 
 func main() {
 	flag.Parse()
 
-	// 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/
-		},
-	})
+	// Initialize logger
+	logger, err := initializeLogger(*logLevel)
 	if err != nil {
-		panic("Failed to initialize logger: " + err.Error())
+		panic(err)
 	}
-	defer cleanup()
+	defer logger.Sync()
 
-	zapLogger.Info("Starting Azure CNI Telemetry Sidecar",
+	// DEBUG: Check if aiMetadata was set at build time via ldflags
+	currentAIMetadata := telemetry.GetAIMetadata()
+	logger.Info("Starting Azure CNI Telemetry Sidecar",
 		zap.String("version", version),
 		zap.String("configPath", *configPath),
-		zap.String("logLevel", *logLevel))
+		zap.String("logLevel", *logLevel),
+		zap.Bool("hasBuiltInAIKey", currentAIMetadata != ""),
+		zap.String("aiKeyPrefix", maskAIKey(currentAIMetadata)))
 
-	// Create telemetry sidecar service and pass the logger
+	// Create and configure telemetry sidecar
+	// Pass the configPath to NewTelemetrySidecar (it expects a string parameter)
 	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))
+	if err := sidecar.SetLogger(logger); err != nil {
+		logger.Error("Failed to set logger", zap.Error(err))
 		os.Exit(1)
 	}
 
-	// Setup graceful shutdown context
+	// Log which AI key source we're using
+	if currentAIMetadata != "" {
+		logger.Info("Using build-time embedded AppInsights key (from Makefile)")
+	} else {
+		logger.Info("No build-time AppInsights key found - will check config/environment")
+	}
+
+	// Create context with cancellation for graceful shutdown
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	// Handle OS signals for graceful shutdown
-	sigCh := make(chan os.Signal, 1)
-	signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
-
+	// Handle shutdown signals
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
 	go func() {
-		sig := <-sigCh
-		zapLogger.Info("Received shutdown signal, initiating graceful shutdown",
-			zap.String("signal", sig.String()))
+		sig := <-sigChan
+		logger.Info("Received shutdown signal", zap.String("signal", sig.String()))
 		cancel()
 	}()
 
-	// Run the telemetry sidecar (using the Run method from sidecar.go)
-	if err := sidecar.Run(ctx); err != nil {
-		zapLogger.Error("Azure CNI Telemetry Sidecar failed",
-			zap.Error(err))
+	// Run the sidecar
+	if err := sidecar.Run(ctx); err != nil && err != context.Canceled {
+		logger.Error("Sidecar execution failed", zap.Error(err))
 		os.Exit(1)
 	}
 
-	zapLogger.Info("Azure CNI Telemetry Sidecar stopped gracefully")
+	logger.Info("Azure CNI Telemetry Sidecar shutdown complete")
+}
+
+// initializeLogger creates a zap logger with the specified level
+func initializeLogger(level string) (*zap.Logger, error) {
+	var zapLevel zap.AtomicLevel
+	switch level {
+	case "debug":
+		zapLevel = zap.NewAtomicLevelAt(zap.DebugLevel)
+	case "info":
+		zapLevel = zap.NewAtomicLevelAt(zap.InfoLevel)
+	case "warn":
+		zapLevel = zap.NewAtomicLevelAt(zap.WarnLevel)
+	case "error":
+		zapLevel = zap.NewAtomicLevelAt(zap.ErrorLevel)
+	default:
+		zapLevel = zap.NewAtomicLevelAt(zap.InfoLevel)
+	}
+
+	config := zap.NewProductionConfig()
+	config.Level = zapLevel
+	config.DisableStacktrace = true
+	config.DisableCaller = false
+
+	return config.Build()
 }