make changes as per the doc

pkg/plugin/implementation/cache/cache.go

@@ -7,7 +7,11 @@ import (
 	"os"
 	"time"
 
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/metric"
+
 	"github.com/beckn-one/beckn-onix/pkg/log"
+	"github.com/beckn-one/beckn-onix/pkg/telemetry"
 	"github.com/redis/go-redis/extra/redisotel/v9"
 	"github.com/redis/go-redis/v9"
 )
@@ -32,7 +36,8 @@ type Config struct {
 
 // Cache wraps a Redis client to provide basic caching operations.
 type Cache struct {
-	Client RedisClient
+	Client  RedisClient
+	metrics *telemetry.Metrics
 }
 
 // Error variables to describe common failure modes.
@@ -92,26 +97,66 @@ func New(ctx context.Context, cfg *Config) (*Cache, func() error, error) {
 		}
 	}
 
+	metrics, _ := telemetry.GetMetrics(ctx)
+
 	log.Infof(ctx, "Cache connection to Redis established successfully")
-	return &Cache{Client: client}, client.Close, nil
+	return &Cache{Client: client, metrics: metrics}, client.Close, nil
 }
 
 // Get retrieves the value for the specified key from Redis.
 func (c *Cache) Get(ctx context.Context, key string) (string, error) {
-	return c.Client.Get(ctx, key).Result()
+	result, err := c.Client.Get(ctx, key).Result()
+	if c.metrics != nil {
+		attrs := []attribute.KeyValue{
+			telemetry.AttrOperation.String("get"),
+		}
+		switch {
+		case err == redis.Nil:
+			c.metrics.CacheMissesTotal.Add(ctx, 1, metric.WithAttributes(attrs...))
+			c.metrics.CacheOperationsTotal.Add(ctx, 1,
+				metric.WithAttributes(append(attrs, telemetry.AttrStatus.String("miss"))...))
+		case err != nil:
+			c.metrics.CacheOperationsTotal.Add(ctx, 1,
+				metric.WithAttributes(append(attrs, telemetry.AttrStatus.String("error"))...))
+		default:
+			c.metrics.CacheHitsTotal.Add(ctx, 1, metric.WithAttributes(attrs...))
+			c.metrics.CacheOperationsTotal.Add(ctx, 1,
+				metric.WithAttributes(append(attrs, telemetry.AttrStatus.String("hit"))...))
+		}
+	}
+	return result, err
 }
 
 // Set stores the given key-value pair in Redis with the specified TTL (time to live).
 func (c *Cache) Set(ctx context.Context, key, value string, ttl time.Duration) error {
-	return c.Client.Set(ctx, key, value, ttl).Err()
+	err := c.Client.Set(ctx, key, value, ttl).Err()
+	c.recordOperation(ctx, "set", err)
+	return err
 }
 
 // Delete removes the specified key from Redis.
 func (c *Cache) Delete(ctx context.Context, key string) error {
-	return c.Client.Del(ctx, key).Err()
+	err := c.Client.Del(ctx, key).Err()
+	c.recordOperation(ctx, "delete", err)
+	return err
 }
 
 // Clear removes all keys in the currently selected Redis database.
 func (c *Cache) Clear(ctx context.Context) error {
 	return c.Client.FlushDB(ctx).Err()
 }
+
+func (c *Cache) recordOperation(ctx context.Context, op string, err error) {
+	if c.metrics == nil {
+		return
+	}
+	status := "success"
+	if err != nil {
+		status = "error"
+	}
+	c.metrics.CacheOperationsTotal.Add(ctx, 1,
+		metric.WithAttributes(
+			telemetry.AttrOperation.String(op),
+			telemetry.AttrStatus.String(status),
+		))
+}

pkg/plugin/implementation/otelmetrics/cmd/plugin.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/beckn-one/beckn-onix/pkg/plugin/implementation/otelmetrics"
+)
+
+type middlewareProvider struct{}
+
+func (middlewareProvider) New(ctx context.Context, cfg map[string]string) (func(http.Handler) http.Handler, error) {
+	mw, err := otelmetrics.New(ctx, cfg)
+	if err != nil {
+		return nil, err
+	}
+	return mw.Handler, nil
+}
+
+// Provider is exported for plugin loader.
+var Provider = middlewareProvider{}

pkg/plugin/implementation/otelmetrics/otelmetrics.go

@@ -0,0 +1,134 @@
+package otelmetrics
+
+import (
+	"context"
+	"net/http"
+	"strings"
+	"time"
+
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/metric"
+
+	"github.com/beckn-one/beckn-onix/pkg/log"
+	"github.com/beckn-one/beckn-onix/pkg/telemetry"
+)
+
+// Middleware instruments inbound HTTP handlers with OpenTelemetry metrics.
+type Middleware struct {
+	metrics *telemetry.Metrics
+	enabled bool
+}
+
+// New constructs middleware based on plugin configuration.
+func New(ctx context.Context, cfg map[string]string) (*Middleware, error) {
+	enabled := cfg["enabled"] != "false"
+
+	metrics, err := telemetry.GetMetrics(ctx)
+	if err != nil {
+		log.Warnf(ctx, "OpenTelemetry metrics unavailable: %v", err)
+	}
+
+	return &Middleware{
+		metrics: metrics,
+		enabled: enabled,
+	}, nil
+}
+
+// Handler returns an http.Handler middleware compatible with plugin expectations.
+func (m *Middleware) Handler(next http.Handler) http.Handler {
+	if !m.enabled || m.metrics == nil {
+		return next
+	}
+
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		ctx := r.Context()
+		action := extractAction(r.URL.Path)
+		module := r.Header.Get("X-Module-Name")
+		role := r.Header.Get("X-Role")
+
+		attrs := []attribute.KeyValue{
+			telemetry.AttrModule.String(module),
+			telemetry.AttrRole.String(role),
+			telemetry.AttrAction.String(action),
+			telemetry.AttrHTTPMethod.String(r.Method),
+		}
+
+		m.metrics.HTTPRequestsInFlight.Add(ctx, 1, metric.WithAttributes(attrs...))
+		defer m.metrics.HTTPRequestsInFlight.Add(ctx, -1, metric.WithAttributes(attrs...))
+
+		if r.ContentLength > 0 {
+			m.metrics.HTTPRequestSize.Record(ctx, r.ContentLength, metric.WithAttributes(attrs...))
+		}
+
+		rw := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
+		start := time.Now()
+		next.ServeHTTP(rw, r)
+		duration := time.Since(start).Seconds()
+
+		status := "success"
+		if rw.statusCode >= 400 {
+			status = "error"
+		}
+
+		statusAttrs := append(attrs,
+			telemetry.AttrHTTPStatus.Int(rw.statusCode),
+			telemetry.AttrStatus.String(status),
+		)
+
+		m.metrics.HTTPRequestsTotal.Add(ctx, 1, metric.WithAttributes(statusAttrs...))
+		m.metrics.HTTPRequestDuration.Record(ctx, duration, metric.WithAttributes(statusAttrs...))
+		if rw.bytesWritten > 0 {
+			m.metrics.HTTPResponseSize.Record(ctx, int64(rw.bytesWritten), metric.WithAttributes(statusAttrs...))
+		}
+
+		if isBecknAction(action) {
+			m.metrics.BecknMessagesTotal.Add(ctx, 1,
+				metric.WithAttributes(
+					telemetry.AttrAction.String(action),
+					telemetry.AttrRole.String(role),
+					telemetry.AttrStatus.String(status),
+				))
+		}
+	})
+}
+
+type responseWriter struct {
+	http.ResponseWriter
+	statusCode   int
+	bytesWritten int
+}
+
+func (rw *responseWriter) WriteHeader(code int) {
+	rw.statusCode = code
+	rw.ResponseWriter.WriteHeader(code)
+}
+
+func (rw *responseWriter) Write(b []byte) (int, error) {
+	n, err := rw.ResponseWriter.Write(b)
+	rw.bytesWritten += n
+	return n, err
+}
+
+func extractAction(path string) string {
+	trimmed := strings.Trim(path, "/")
+	if trimmed == "" {
+		return "root"
+	}
+	parts := strings.Split(trimmed, "/")
+	return parts[len(parts)-1]
+}
+
+func isBecknAction(action string) bool {
+	actions := []string{
+		"discover", "select", "init", "confirm", "status", "track",
+		"cancel", "update", "rating", "support",
+		"on_discover", "on_select", "on_init", "on_confirm", "on_status",
+		"on_track", "on_cancel", "on_update", "on_rating", "on_support",
+	}
+	for _, a := range actions {
+		if a == action {
+			return true
+		}
+	}
+	return false
+}

pkg/plugin/implementation/router/router_test.go

@@ -681,4 +681,4 @@ func TestExcludeActionWithNonURLTargetTypes(t *testing.T) {
 			}
 		})
 	}
-}
+}