update loggerv2 configs, add custom Unmarshalling

Signed-off-by: Evan Baker <[email protected]>

Author: rbtr

cns/logger/log.go

@@ -7,8 +7,9 @@ import (
 )
 
 var (
-	Log        *CNSLogger
-	aiMetadata string // this var is set at build time.
+	Log             *CNSLogger
+	aiMetadata      string // this var is set at build time.
+	AppInsightsIKey = aiMetadata
 )
 
 // todo: the functions below should be removed. CNSLogger should be injected where needed and not used from package level scope.

cns/logger/v2/config.go

@@ -0,0 +1,50 @@
+package logger
+
+import (
+	"encoding/json"
+	"time"
+
+	loggerv1 "github.com/Azure/azure-container-networking/cns/logger"
+	cores "github.com/Azure/azure-container-networking/cns/logger/v2/cores"
+	"github.com/pkg/errors"
+	"go.uber.org/zap/zapcore"
+)
+
+//nolint:unused // will be used
+const (
+	defaultMaxBackups       = 10
+	defaultMaxSize          = 10 // MB
+	defaultMaxBatchInterval = 30 * time.Second
+	defaultMaxBatchSize     = 32000
+	defaultGracePeriod      = 30 * time.Second
+)
+
+//nolint:unused // will be used
+var defaultIKey = loggerv1.AppInsightsIKey
+
+type Config struct {
+	// Level is the general logging Level. If cores have more specific config it will override this.
+	Level       string                  `json:"level"`
+	level       zapcore.Level           `json:"-"`
+	AppInsights cores.AppInsightsConfig `json:"appInsights"`
+	File        cores.FileConfig        `json:"file"`
+}
+
+// UnmarshalJSON implements json.Unmarshaler for the Config.
+// It only differs from the default by parsing the
+// Level string into a zapcore.Level and setting the level field.
+func (c *Config) UnmarshalJSON(data []byte) error {
+	type Alias Config
+	aux := &struct {
+		*Alias
+	}{
+		Alias: (*Alias)(c),
+	}
+	if err := json.Unmarshal(data, &aux); err != nil {
+		return errors.Wrap(err, "failed to unmarshal Config")
+	}
+	if l, err := zapcore.ParseLevel(c.Level); err == nil {
+		c.level = l
+	}
+	return nil
+}

cns/logger/v2/cores/ai.go

@@ -1,7 +1,7 @@
 package logger
 
 import (
-	"runtime"
+	"encoding/json"
 	"time"
 
 	"github.com/Azure/azure-container-networking/zapai"
@@ -11,17 +11,40 @@ import (
 	"go.uber.org/zap/zapcore"
 )
 
-type AIConfig struct {
-	GracePeriod      time.Duration
-	IKey             string
-	Level            zapcore.Level
-	MaxBatchInterval time.Duration
-	MaxBatchSize     int
+type AppInsightsConfig struct {
+	GracePeriod      time.Duration   `json:"grace_period"`
+	IKey             string          `json:"ikey"`
+	Level            string          `json:"level"`
+	level            zapcore.Level   `json:"-"` // Zero value is default Info level.
+	MaxBatchInterval time.Duration   `json:"max_batch_interval"`
+	MaxBatchSize     int             `json:"max_batch_size"`
+	Fields           []zapcore.Field `json:"fields"`
+}
+
+// UnmarshalJSON implements json.Unmarshaler for the Config.
+// It only differs from the default by parsing the
+// Level string into a zapcore.Level and setting the level field.
+func (c *AppInsightsConfig) UnmarshalJSON(data []byte) error {
+	type Alias AppInsightsConfig
+	aux := &struct {
+		*Alias
+	}{
+		Alias: (*Alias)(c),
+	}
+	if err := json.Unmarshal(data, &aux); err != nil {
+		return errors.Wrap(err, "failed to unmarshal AppInsightsConfig")
+	}
+	lvl, err := zapcore.ParseLevel(c.Level)
+	if err != nil {
+		return errors.Wrap(err, "failed to parse AppInsightsConfig Level")
+	}
+	c.level = lvl
+	return nil
 }
 
 // ApplicationInsightsCore builds a zapcore.Core that sends logs to Application Insights.
 // The first return is the core, the second is a function to close the sink.
-func ApplicationInsightsCore(cfg *AIConfig) (zapcore.Core, func(), error) {
+func ApplicationInsightsCore(cfg *AppInsightsConfig) (zapcore.Core, func(), error) {
 	// build the AI config
 	aicfg := *appinsights.NewTelemetryConfiguration(cfg.IKey)
 	aicfg.MaxBatchSize = cfg.MaxBatchSize
@@ -36,23 +59,9 @@ func ApplicationInsightsCore(cfg *AIConfig) (zapcore.Core, func(), error) {
 		return nil, aiclose, errors.Wrap(err, "failed to open AI sink")
 	}
 	// build the AI core
-	core := zapai.NewCore(cfg.Level, sink)
+	core := zapai.NewCore(cfg.level, sink)
 	core = core.WithFieldMappers(zapai.DefaultMappers)
 	// add normalized fields for the built-in AI Tags
 	// TODO(rbtr): move to the caller
-	return core.With([]zapcore.Field{
-		zap.String("user_id", runtime.GOOS),
-		zap.String("operation_id", ""),
-		zap.String("parent_id", "v0.0.0"),
-		zap.String("version", "v0.0.0"),
-		zap.String("account", "SubscriptionID"),
-		zap.String("anonymous_user_id", "VMName"),
-		zap.String("session_id", "VMID"),
-		zap.String("AppName", "name"),
-		zap.String("Region", "Location"),
-		zap.String("ResourceGroup", "ResourceGroupName"),
-		zap.String("VMSize", "VMSize"),
-		zap.String("OSVersion", "OSVersion"),
-		zap.String("VMID", "VMID"),
-	}), aiclose, nil
+	return core.With(cfg.Fields), aiclose, nil
 }

cns/logger/v2/cores/file.go

@@ -1,28 +1,53 @@
 package logger
 
 import (
+	"encoding/json"
+
+	"github.com/pkg/errors"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
 	"gopkg.in/natefinch/lumberjack.v2"
 )
 
 type FileConfig struct {
-	Filepath   string
-	Level      zapcore.Level
-	MaxBackups int
-	MaxSize    int
+	Filepath   string        `json:"filepath"`
+	Level      string        `json:"level"`
+	level      zapcore.Level `json:"-"`
+	MaxBackups int           `json:"maxBackups"`
+	MaxSize    int           `json:"maxSize"`
+}
+
+// UnmarshalJSON implements json.Unmarshaler for the Config.
+// It only differs from the default by parsing the
+// Level string into a zapcore.Level and setting the level field.
+func (cfg *FileConfig) UnmarshalJSON(data []byte) error {
+	type Alias FileConfig
+	aux := &struct {
+		*Alias
+	}{
+		Alias: (*Alias)(cfg),
+	}
+	if err := json.Unmarshal(data, &aux); err != nil {
+		return errors.Wrap(err, "failed to unmarshal FileConfig")
+	}
+	lvl, err := zapcore.ParseLevel(cfg.Level)
+	if err != nil {
+		return errors.Wrap(err, "failed to parse FileConfig Level")
+	}
+	cfg.level = lvl
+	return nil
 }
 
 // FileCore builds a zapcore.Core that writes to a file.
 // The first return is the core, the second is a function to close the file.
 func FileCore(cfg *FileConfig) (zapcore.Core, func(), error) {
 	filesink := &lumberjack.Logger{
 		Filename:   cfg.Filepath,
-		MaxSize:    cfg.MaxSize, // MegaBytes
+		MaxSize:    cfg.MaxSize, // MB
 		MaxBackups: cfg.MaxBackups,
 	}
 	encoderConfig := zap.NewProductionEncoderConfig()
 	encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
 	jsonEncoder := zapcore.NewJSONEncoder(encoderConfig)
-	return zapcore.NewCore(jsonEncoder, zapcore.AddSync(filesink), cfg.Level), func() { _ = filesink.Close() }, nil
+	return zapcore.NewCore(jsonEncoder, zapcore.AddSync(filesink), cfg.level), func() { _ = filesink.Close() }, nil
 }

cns/logger/v2/logger.go

@@ -6,13 +6,6 @@ import (
 	"go.uber.org/zap/zapcore"
 )
 
-type Config struct {
-	// Level is the general logging Level. If cores have more specific config it will override this.
-	Level      zapcore.Level
-	AIConfig   cores.AIConfig
-	FileConfig cores.FileConfig
-}
-
 type compoundCloser []func()
 
 func (c compoundCloser) Close() {
@@ -22,14 +15,14 @@ func (c compoundCloser) Close() {
 }
 
 func New(cfg *Config) (*zap.Logger, func(), error) {
-	stdoutCore := cores.StdoutCore(cfg.Level)
+	stdoutCore := cores.StdoutCore(cfg.level)
 	closer := compoundCloser{}
-	fileCore, fileCloser, err := cores.FileCore(&cfg.FileConfig)
+	fileCore, fileCloser, err := cores.FileCore(&cfg.File)
 	closer = append(closer, fileCloser)
 	if err != nil {
 		return nil, closer.Close, err //nolint:wrapcheck // it's an internal pkg
 	}
-	aiCore, aiCloser, err := cores.ApplicationInsightsCore(&cfg.AIConfig)
+	aiCore, aiCloser, err := cores.ApplicationInsightsCore(&cfg.AppInsights)
 	closer = append(closer, aiCloser)
 	if err != nil {
 		return nil, closer.Close, err //nolint:wrapcheck // it's an internal pkg

cns/logger/v2/logger_linux.go

@@ -4,6 +4,8 @@ import (
 	"go.uber.org/zap/zapcore"
 )
 
+const defaultFilePath = "/var/log/azure-cns.log"
+
 // platformCore returns a no-op core for Linux.
 func platformCore(*Config) (zapcore.Core, func(), error) {
 	return zapcore.NewNopCore(), func() {}, nil

cns/logger/v2/logger_windows.go

@@ -5,11 +5,13 @@ import (
 	"go.uber.org/zap/zapcore"
 )
 
+const defaultFilePath = "/k/azurecns/azure-cns.log"
+
 // platformCore returns a zapcore.Core that sends logs to ETW.
 func platformCore(cfg *Config) (zapcore.Core, func(), error) {
 	return cores.ETWCore(&cores.ETWConfig{ //nolint:wrapcheck // ignore
 		EventName:    "AzureCNS",
-		Level:        cfg.Level,
+		Level:        cfg.level,
 		ProviderName: "ACN-Monitoring",
 	})
 }