Merge branch 'main' into add-beholder-v2-auth-header-func

Author: hendoxc

observability-lib/grafana/panels.go

@@ -202,14 +202,15 @@ func setDefaults(options *PanelOptions) {
 
 type StatPanelOptions struct {
 	*PanelOptions
-	TextSize    float64
-	ValueSize   float64
-	JustifyMode common.BigValueJustifyMode
-	ColorMode   common.BigValueColorMode
-	GraphMode   common.BigValueGraphMode
-	TextMode    common.BigValueTextMode
-	Orientation common.VizOrientation
-	Mappings    []dashboard.ValueMapping
+	TextSize      float64
+	ValueSize     float64
+	JustifyMode   common.BigValueJustifyMode
+	ColorMode     common.BigValueColorMode
+	GraphMode     common.BigValueGraphMode
+	TextMode      common.BigValueTextMode
+	Orientation   common.VizOrientation
+	Mappings      []dashboard.ValueMapping
+	ReduceOptions *common.ReduceDataOptionsBuilder
 }
 
 func NewStatPanel(options *StatPanelOptions) *Panel {
@@ -231,6 +232,10 @@ func NewStatPanel(options *StatPanelOptions) *Panel {
 		options.Orientation = common.VizOrientationAuto
 	}
 
+	if options.ReduceOptions == nil {
+		options.ReduceOptions = common.NewReduceDataOptionsBuilder().Calcs([]string{"last"})
+	}
+
 	newPanel := stat.NewPanelBuilder().
 		Datasource(datasourceRef(options.Datasource)).
 		Title(*options.Title).
@@ -247,7 +252,7 @@ func NewStatPanel(options *StatPanelOptions) *Panel {
 		Orientation(options.Orientation).
 		JustifyMode(options.JustifyMode).
 		Mappings(options.Mappings).
-		ReduceOptions(common.NewReduceDataOptionsBuilder().Calcs([]string{"last"}))
+		ReduceOptions(options.ReduceOptions)
 
 	if options.Interval != "" {
 		newPanel.Interval(options.Interval)

pkg/logger/otelzap/otelzap.go

@@ -105,11 +105,13 @@ func (o OtelZapCore) Write(entry zapcore.Entry, fields []zapcore.Field) error {
 	// Start with encoder attributes
 	attributes := encoder.attributes
 
-	// Add exception metadata
+	// Add caller information if available
+	if entry.Caller.Defined {
+		attributes = append(attributes, attribute.String("caller", entry.Caller.String()))
+	}
+
+	// Add exception metadata for error levels
 	if entry.Level > zapcore.InfoLevel {
-		if entry.Caller.Defined {
-			attributes = append(attributes, semconv.ExceptionType(entry.Caller.String()))
-		}
 		if entry.Stack != "" {
 			attributes = append(attributes, semconv.ExceptionStacktrace(entry.Stack))
 		}

pkg/logger/otelzap/otelzap_test.go

@@ -2,8 +2,10 @@ package otelzap
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"math"
 	"testing"
 	"time"
@@ -228,7 +230,7 @@ func TestOtelZapCore_Write(t *testing.T) {
 			wantMessage: "fail",
 			wantAttrs: map[string]string{
 				"err":                  "fail",
-				"exception.type":       "file.go:42",
+				"caller":               "file.go:42",
 				"exception.stacktrace": "stacktrace",
 			},
 		},
@@ -490,3 +492,105 @@ func (t *testMixedArray) MarshalLogArray(enc zapcore.ArrayEncoder) error {
 	}
 	return nil
 }
+
+func TestCallerInfo(t *testing.T) {
+	// Setup OTEL exporter
+	var buf bytes.Buffer
+	exporter, err := stdoutlog.New(stdoutlog.WithWriter(&buf))
+	require.NoError(t, err)
+
+	// Setup OTEL provider
+	provider := sdklog.NewLoggerProvider(sdklog.WithProcessor(sdklog.NewBatchProcessor(exporter)))
+
+	// Create otel zap core
+	logger := provider.Logger("test")
+	core := NewCore(logger)
+
+	tests := []struct {
+		name       string
+		level      zapcore.Level
+		caller     zapcore.EntryCaller
+		wantCaller bool
+	}{
+		{
+			name:       "info with caller",
+			level:      zapcore.InfoLevel,
+			caller:     zapcore.EntryCaller{Defined: true, File: "test.go", Line: 123, Function: "TestFunc"},
+			wantCaller: true,
+		},
+		{
+			name:       "error with caller",
+			level:      zapcore.ErrorLevel,
+			caller:     zapcore.EntryCaller{Defined: true, File: "error.go", Line: 456, Function: "ErrorFunc"},
+			wantCaller: true,
+		},
+		{
+			name:       "debug without caller",
+			level:      zapcore.DebugLevel,
+			caller:     zapcore.EntryCaller{Defined: false},
+			wantCaller: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			buf.Reset()
+
+			entry := zapcore.Entry{
+				Message: "test message",
+				Level:   tt.level,
+				Time:    time.Now(),
+				Caller:  tt.caller,
+			}
+
+			err := core.Write(entry, nil)
+			require.NoError(t, err)
+
+			// Force flush
+			require.NoError(t, provider.ForceFlush(context.Background()))
+
+			if !tt.wantCaller {
+				// If no caller expected, we just check that no caller attributes exist
+				var logEntry struct {
+					Attributes []struct {
+						Key   string `json:"key"`
+						Value struct {
+							Value interface{} `json:"value"`
+						} `json:"value"`
+					} `json:"attributes"`
+				}
+				err = json.Unmarshal(buf.Bytes(), &logEntry)
+				require.NoError(t, err)
+
+				for _, attr := range logEntry.Attributes {
+					assert.NotContains(t, []string{"caller", "source.file", "source.line", "source.function"}, attr.Key)
+				}
+				return
+			}
+
+			// Parse JSON output and check for caller attributes
+			var logEntry struct {
+				Attributes []struct {
+					Key   string `json:"key"`
+					Value struct {
+						Value string `json:"value"`
+					} `json:"value"`
+				} `json:"attributes"`
+			}
+			err = json.Unmarshal(buf.Bytes(), &logEntry)
+			require.NoError(t, err, "failed to parse OTEL JSON log output")
+
+			got := map[string]string{}
+			for _, attr := range logEntry.Attributes {
+				got[attr.Key] = attr.Value.Value
+			}
+
+			// Check required caller attributes
+			assert.Contains(t, got, "caller")
+
+			expectedCaller := fmt.Sprintf("%s:%d", tt.caller.File, tt.caller.Line)
+			assert.Equal(t, expectedCaller, fmt.Sprintf("%v", got["caller"]))
+
+		})
+	}
+}

pkg/nodeauth/jwt/node_jwt_authenticator.go

@@ -3,6 +3,7 @@ package jwt
 import (
 	"context"
 	"crypto/ed25519"
+	"encoding/hex"
 	"fmt"
 	"log/slog"
 
@@ -62,21 +63,21 @@ func (v *NodeJWTAuthenticator) AuthenticateJWT(ctx context.Context, tokenString
 	isValid, err := v.nodeAuthProvider.IsNodePubKeyTrusted(ctx, publicKey)
 	if err != nil {
 		v.logger.Error("Node validation failed",
-			"csaPubKey", publicKey,
+			"csaPubKey", hex.EncodeToString(publicKey),
 			"error", err,
 		)
 		return false, claims, fmt.Errorf("node validation failed: %w", err)
 	}
 
 	if !isValid {
 		v.logger.Warn("Unauthorized node attempted access",
-			"csaPubKey", publicKey,
+			"csaPubKey", hex.EncodeToString(publicKey),
 		)
-		return false, claims, fmt.Errorf("unauthorized node: %s", publicKey)
+		return false, claims, fmt.Errorf("unauthorized node: %s", hex.EncodeToString(publicKey))
 	}
 
 	v.logger.Debug("JWT validation successful",
-		"csaPubKey", publicKey,
+		"csaPubKey", hex.EncodeToString(publicKey),
 	)
 
 	return true, claims, nil