feat(otel,metrics): comprehensive tracing + metrics coverage and correctness fixes

.golangci.yml

@@ -163,6 +163,10 @@ linters:
       - linters:
           - gosec
         text: "G118"
+      - linters:
+          - gosec
+        text: "G124"
+        path: service/http/client/handler\.go
       - linters:
           - revive
         text: "unexported-return"

Makefile

@@ -69,6 +69,11 @@ otel-up:
 otel-down:
 	cd tests && docker-compose down
 
+# otel-e2e starts only Jaeger and runs the OTLP round-trip test (needs docker).
+otel-e2e:
+	cd tests && docker-compose up -d jaeger
+	go test -tags integration -run TestOTLP_TracesReachJaeger ./tests/ -timeout 120s
+
 # Wippy CLI build targets
 WIPPY_VERSION ?= $(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
 WIPPY_COMMIT ?= $(shell git rev-parse --short HEAD 2>/dev/null || echo "unknown")

api/metrics/metrics.go

@@ -6,7 +6,8 @@ package metrics
 // MetricType constants.
 const (
 	TypeCounter   MetricType = "counter"
-	TypeGauge     MetricType = "gauge"
+	TypeGauge     MetricType = "gauge"     // absolute set (GaugeSet)
+	TypeGaugeAdd  MetricType = "gauge_add" // relative delta (GaugeInc/GaugeDec)
 	TypeHistogram MetricType = "histogram"
 )
 

boot/components/dispatchers/sql_dispatcher.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/wippyai/runtime/api/boot"
 	dispatcherapi "github.com/wippyai/runtime/api/dispatcher"
+	metricsapi "github.com/wippyai/runtime/api/metrics"
 	"github.com/wippyai/runtime/service/sql"
 )
 
@@ -20,6 +21,7 @@ func SQL() boot.Component {
 				return ctx, ErrDispatcherNotFound
 			}
 			svc := sql.NewDispatcher()
+			svc.SetCollector(metricsapi.GetCollector(ctx))
 			svc.RegisterAll(reg.Register)
 			return ctx, nil
 		},

boot/components/metrics/all.go

@@ -7,6 +7,7 @@ import "github.com/wippyai/runtime/api/boot"
 func All() []boot.Component {
 	return []boot.Component{
 		Metrics(),
-		// MetricsInterceptor(),
+		Interceptor(),
+		Process(),
 	}
 }

boot/components/metrics/constants.go

@@ -6,3 +6,17 @@ import "github.com/wippyai/runtime/api/boot"
 
 // Name is the component name for metrics.
 const Name boot.Name = "metrics"
+
+// InterceptorName is the component name for the function-call metrics interceptor.
+const InterceptorName boot.Name = "metrics-interceptor"
+
+// ProcessName is the component name for the process lifecycle metrics handler.
+const ProcessName boot.Name = "metrics-process"
+
+// interceptorName is the external dependency name of the function interceptor
+// registry component (boot/components/system.Interceptor).
+const interceptorName boot.Name = "interceptor"
+
+// lifecycleName is the external dependency name of the process lifecycle
+// registry component (boot/components/system.LifecycleName).
+const lifecycleName boot.Name = "system.lifecycle"

boot/components/metrics/interceptor.go

@@ -1,3 +1,60 @@
 // SPDX-License-Identifier: MPL-2.0
 
 package metrics
+
+import (
+	"context"
+
+	"github.com/wippyai/runtime/api/boot"
+	apiinterceptor "github.com/wippyai/runtime/api/function"
+	metricsapi "github.com/wippyai/runtime/api/metrics"
+	metricsinterceptor "github.com/wippyai/runtime/service/metrics/interceptor"
+)
+
+// Interceptor wires the function-call metrics interceptor
+// (wippy_function_calls / wippy_function_duration / wippy_function_in_flight)
+// into the function interceptor registry. It runs at order 50 so the duration
+// timer wraps the full call, including the OTel tracing interceptor (order 100).
+func Interceptor() boot.Component {
+	return boot.New(boot.P{
+		Name:      InterceptorName,
+		DependsOn: []boot.Name{Name, interceptorName},
+		Load: func(ctx context.Context) (context.Context, error) {
+			if !loadInterceptorEnabled(ctx) {
+				return ctx, nil
+			}
+
+			collector := metricsapi.GetCollector(ctx)
+			if collector == nil {
+				return ctx, nil
+			}
+
+			registry := apiinterceptor.GetInterceptorRegistry(ctx)
+			if registry == nil {
+				return ctx, nil
+			}
+
+			if err := registry.Register("metrics", metricsinterceptor.NewFunctionInterceptor(collector, true), 50); err != nil {
+				return ctx, err
+			}
+
+			return ctx, nil
+		},
+	})
+}
+
+// loadInterceptorEnabled reads metrics.interceptor.enabled, defaulting to true
+// so function-call metrics emit out of the box.
+func loadInterceptorEnabled(ctx context.Context) bool {
+	bootCfg := boot.GetConfig(ctx)
+	if bootCfg == nil {
+		return true
+	}
+
+	metricsCfg := bootCfg.Sub("metrics")
+	if metricsCfg == nil {
+		return true
+	}
+
+	return metricsCfg.GetBool("interceptor.enabled", true)
+}

boot/components/metrics/interceptor_test.go

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: MPL-2.0
+
+package metrics
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/wippyai/runtime/api/boot"
+	ctxapi "github.com/wippyai/runtime/api/context"
+	"github.com/wippyai/runtime/api/function"
+	logapi "github.com/wippyai/runtime/api/logs"
+	metricsapi "github.com/wippyai/runtime/api/metrics"
+	"github.com/wippyai/runtime/api/registry"
+	"github.com/wippyai/runtime/api/runtime"
+	"github.com/wippyai/runtime/internal/telemetrytest"
+	metricsinterceptor "github.com/wippyai/runtime/service/metrics/interceptor"
+	"go.uber.org/zap"
+)
+
+type mockInterceptorRegistry struct {
+	registrations []registeredInterceptor
+}
+
+type registeredInterceptor struct {
+	interceptor function.Interceptor
+	name        string
+	order       int
+}
+
+func (m *mockInterceptorRegistry) Register(name string, i function.Interceptor, order int) error {
+	m.registrations = append(m.registrations, registeredInterceptor{name: name, interceptor: i, order: order})
+	return nil
+}
+
+func (m *mockInterceptorRegistry) Unregister(string) error { return nil }
+
+func (m *mockInterceptorRegistry) Execute(ctx context.Context, f function.Func, task runtime.Task) (*runtime.Result, error) {
+	return f(ctx, task)
+}
+
+func TestMetricsInterceptor_RegistersWhenEnabled(t *testing.T) {
+	component := Interceptor()
+	assert.Equal(t, InterceptorName, component.Name())
+
+	ctx := ctxapi.NewRootContext()
+	ctx = logapi.WithLogger(ctx, zap.NewNop())
+	ctx = boot.WithConfig(ctx, boot.NewConfig(boot.WithSection("metrics", map[string]any{
+		"interceptor.enabled": true,
+	})))
+	rec := telemetrytest.NewRecorder()
+	ctx = metricsapi.WithCollector(ctx, rec)
+	reg := &mockInterceptorRegistry{}
+	ctx = function.WithInterceptorRegistry(ctx, reg)
+
+	newCtx, err := component.Load(ctx)
+	require.NoError(t, err)
+	require.NotNil(t, newCtx)
+	require.Len(t, reg.registrations, 1)
+
+	r := reg.registrations[0]
+	assert.Equal(t, "metrics", r.name)
+	assert.Equal(t, 50, r.order)
+
+	fi, ok := r.interceptor.(*metricsinterceptor.FunctionInterceptor)
+	require.True(t, ok, "registered interceptor must be *FunctionInterceptor")
+
+	funcID := registry.NewID("ns", "test_func")
+	task := runtime.Task{ID: funcID}
+	next := func(_ context.Context, _ runtime.Task) (*runtime.Result, error) {
+		return &runtime.Result{}, nil
+	}
+	_, err = fi.Handle(context.Background(), task, next)
+	require.NoError(t, err)
+	assert.Equal(t, 1.0, rec.CounterValue(metricsinterceptor.FunctionCalls,
+		metricsapi.Labels{"function_id": funcID.String(), "status": "success"}))
+}
+
+func TestMetricsInterceptor_NotRegisteredWhenDisabled(t *testing.T) {
+	component := Interceptor()
+
+	ctx := ctxapi.NewRootContext()
+	ctx = logapi.WithLogger(ctx, zap.NewNop())
+	ctx = boot.WithConfig(ctx, boot.NewConfig(boot.WithSection("metrics", map[string]any{
+		"interceptor.enabled": false,
+	})))
+	ctx = metricsapi.WithCollector(ctx, telemetrytest.NewRecorder())
+	reg := &mockInterceptorRegistry{}
+	ctx = function.WithInterceptorRegistry(ctx, reg)
+
+	_, err := component.Load(ctx)
+	require.NoError(t, err)
+	assert.Empty(t, reg.registrations)
+}
+
+func TestMetricsInterceptor_NoCollector(t *testing.T) {
+	component := Interceptor()
+
+	ctx := ctxapi.NewRootContext()
+	ctx = logapi.WithLogger(ctx, zap.NewNop())
+	ctx = boot.WithConfig(ctx, boot.NewConfig(boot.WithSection("metrics", map[string]any{
+		"interceptor.enabled": true,
+	})))
+	reg := &mockInterceptorRegistry{}
+	ctx = function.WithInterceptorRegistry(ctx, reg)
+
+	_, err := component.Load(ctx)
+	require.NoError(t, err)
+	assert.Empty(t, reg.registrations, "no registration without a collector")
+}

boot/components/metrics/process.go

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MPL-2.0
+
+package metrics
+
+import (
+	"context"
+
+	"github.com/wippyai/runtime/api/boot"
+	metricsapi "github.com/wippyai/runtime/api/metrics"
+	processapi "github.com/wippyai/runtime/api/process"
+	impl "github.com/wippyai/runtime/service/metrics"
+)
+
+// Process registers the process lifecycle metrics handler, which emits
+// wippy_process_started_total / wippy_process_terminated_total /
+// wippy_process_active alongside the existing OTel lifecycle spans.
+func Process() boot.Component {
+	return boot.New(boot.P{
+		Name:      ProcessName,
+		DependsOn: []boot.Name{Name, lifecycleName},
+		Load: func(ctx context.Context) (context.Context, error) {
+			coll := metricsapi.GetCollector(ctx)
+			if coll == nil {
+				return ctx, nil
+			}
+
+			reg := processapi.GetLifecycleRegistry(ctx)
+			if reg == nil {
+				return ctx, nil
+			}
+
+			reg.Register("metrics", impl.NewProcessLifecycle(coll))
+			return ctx, nil
+		},
+	})
+}

boot/components/otel/otel.go

@@ -9,10 +9,13 @@ import (
 	logapi "github.com/wippyai/runtime/api/logs"
 	otelapi "github.com/wippyai/runtime/api/service/otel"
 	"github.com/wippyai/runtime/service/otel"
+	"go.opentelemetry.io/otel/trace"
 	"go.uber.org/zap"
 )
 
 func OTel() boot.Component {
+	var tp trace.TracerProvider
+
 	return boot.New(boot.P{
 		Name: Name,
 		Load: func(ctx context.Context) (context.Context, error) {
@@ -35,7 +38,8 @@ func OTel() boot.Component {
 				return ctx, nil
 			}
 
-			tp, err := otel.InitializeProvider(ctx, cfg, logger)
+			var err error
+			tp, err = otel.InitializeProvider(ctx, cfg, logger)
 			if err != nil {
 				return ctx, NewOTELInitError(err)
 			}
@@ -53,8 +57,12 @@ func OTel() boot.Component {
 		Start: func(_ context.Context) error {
 			return nil
 		},
-		Stop: func(_ context.Context) error {
-			return nil
+		Stop: func(ctx context.Context) error {
+			logger := logapi.GetLogger(ctx).Named("otel")
+			if tp == nil {
+				return nil
+			}
+			return otel.ShutdownTracerProvider(ctx, tp, logger)
 		},
 	})
 }

boot/components/otel/otel_temporal.go

@@ -4,16 +4,16 @@ package otel
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/wippyai/runtime/api/boot"
 	logapi "github.com/wippyai/runtime/api/logs"
 	otelapi "github.com/wippyai/runtime/api/service/otel"
 	temporalapi "github.com/wippyai/runtime/api/service/temporal"
 	temporalboot "github.com/wippyai/runtime/boot/components/service/temporal"
 	"github.com/wippyai/runtime/service/otel"
-	"go.opentelemetry.io/otel/propagation"
+	gootel "go.opentelemetry.io/otel"
 	temporalotel "go.temporal.io/sdk/contrib/opentelemetry"
-	"go.uber.org/zap"
 )
 
 // Temporal creates the OTEL tracing interceptor for Temporal workflows and activities.
@@ -60,17 +60,15 @@ func Temporal() boot.Component {
 				return ctx, nil
 			}
 
-			// Create Temporal tracing interceptor with the shared tracer
+			// Create Temporal tracing interceptor with the shared tracer and the
+			// globally-configured propagator so Temporal follows the same W3C
+			// propagation settings as every other surface.
 			tracingInterceptor, err := temporalotel.NewTracingInterceptor(temporalotel.TracerOptions{
-				Tracer: tracer,
-				TextMapPropagator: propagation.NewCompositeTextMapPropagator(
-					propagation.TraceContext{},
-					propagation.Baggage{},
-				),
+				Tracer:            tracer,
+				TextMapPropagator: gootel.GetTextMapPropagator(),
 			})
 			if err != nil {
-				logger.Error("failed to create Temporal tracing interceptor", zap.Error(err))
-				return ctx, nil
+				return ctx, fmt.Errorf("failed to create Temporal tracing interceptor: %w", err)
 			}
 
 			// Register with both client and worker registries

boot/components/queue/consumers.go

@@ -9,6 +9,7 @@ import (
 	"github.com/wippyai/runtime/api/event"
 	"github.com/wippyai/runtime/api/function"
 	logapi "github.com/wippyai/runtime/api/logs"
+	metricsapi "github.com/wippyai/runtime/api/metrics"
 	"github.com/wippyai/runtime/api/payload"
 	queueapi "github.com/wippyai/runtime/api/queue"
 	regapi "github.com/wippyai/runtime/api/registry"
@@ -34,6 +35,7 @@ func Consumers() boot.Component {
 			handlers := bootpkg.GetHandlerRegistry(ctx)
 			queueMgr := queueapi.GetManager(ctx)
 			funcReg := function.GetRegistry(ctx)
+			coll := metricsapi.GetCollector(ctx)
 
 			if reg := regapi.GetRegistry(ctx); reg != nil {
 				consumerPatterns := []regapi.DependencyPattern{
@@ -53,6 +55,7 @@ func Consumers() boot.Component {
 				funcReg,
 				dtt,
 				logger.Named("queue.consumer"),
+				coll,
 			)
 
 			handlers.RegisterListener("queue.consumer", manager)