make changes as per the doc

core/module/handler/stdHandler.go

@@ -9,11 +9,11 @@ import (
 	"net/http/httputil"
 
 	"github.com/beckn-one/beckn-onix/pkg/log"
-	"github.com/beckn-one/beckn-onix/pkg/metrics"
 	"github.com/beckn-one/beckn-onix/pkg/model"
 	"github.com/beckn-one/beckn-onix/pkg/plugin"
 	"github.com/beckn-one/beckn-onix/pkg/plugin/definition"
 	"github.com/beckn-one/beckn-onix/pkg/response"
+	"github.com/beckn-one/beckn-onix/pkg/telemetry"
 )
 
 // stdHandler orchestrates the execution of defined processing steps.
@@ -30,6 +30,7 @@ type stdHandler struct {
 	SubscriberID    string
 	role            model.Role
 	httpClient      *http.Client
+	moduleName      string
 }
 
 // newHTTPClient creates a new HTTP client with a custom transport configuration.
@@ -52,19 +53,17 @@ func newHTTPClient(cfg *HttpClientConfig) *http.Client {
 		transport.ResponseHeaderTimeout = cfg.ResponseHeaderTimeout
 	}
 
-	// Wrap transport with metrics tracking for outbound requests
-	wrappedTransport := metrics.WrapHTTPTransport(transport)
-
-	return &http.Client{Transport: wrappedTransport}
+	return &http.Client{Transport: transport}
 }
 
 // NewStdHandler initializes a new processor with plugins and steps.
-func NewStdHandler(ctx context.Context, mgr PluginManager, cfg *Config) (http.Handler, error) {
+func NewStdHandler(ctx context.Context, mgr PluginManager, cfg *Config, moduleName string) (http.Handler, error) {
 	h := &stdHandler{
 		steps:        []definition.Step{},
 		SubscriberID: cfg.SubscriberID,
 		role:         cfg.Role,
 		httpClient:   newHTTPClient(&cfg.HttpClientConfig),
+		moduleName:   moduleName,
 	}
 	// Initialize plugins.
 	if err := h.initPlugins(ctx, mgr, &cfg.Plugins); err != nil {
@@ -79,12 +78,8 @@ func NewStdHandler(ctx context.Context, mgr PluginManager, cfg *Config) (http.Ha
 
 // ServeHTTP processes an incoming HTTP request and executes defined processing steps.
 func (h *stdHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	// Track inbound request
-	host := r.Host
-	if host == "" {
-		host = r.URL.Host
-	}
-	metrics.RecordInboundRequest(r.Context(), host)
+	r.Header.Set("X-Module-Name", h.moduleName)
+	r.Header.Set("X-Role", string(h.role))
 
 	ctx, err := h.stepCtx(r, w.Header())
 	if err != nil {
@@ -94,35 +89,14 @@ func (h *stdHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 	log.Request(r.Context(), r, ctx.Body)
 
-	// Track validation steps
-	signValidated := false
-	schemaValidated := false
-
 	// Execute processing steps.
 	for _, step := range h.steps {
-		stepName := fmt.Sprintf("%T", step)
-		// Check if this is a validation step
-		if stepName == "*step.validateSignStep" {
-			signValidated = true
-		}
-		if stepName == "*step.validateSchemaStep" {
-			schemaValidated = true
-		}
-
 		if err := step.Run(ctx); err != nil {
 			log.Errorf(ctx, err, "%T.run(%v):%v", step, ctx, err)
 			response.SendNack(ctx, w, err)
 			return
 		}
 	}
-
-	// Record validation metrics after successful execution
-	if signValidated {
-		metrics.RecordInboundSignValidation(ctx, host)
-	}
-	if schemaValidated {
-		metrics.RecordInboundSchemaValidation(ctx, host)
-	}
 	// Restore request body before forwarding or publishing.
 	r.Body = io.NopCloser(bytes.NewReader(ctx.Body))
 	if ctx.Route == nil {
@@ -130,6 +104,10 @@ func (h *stdHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// These headers are only needed for internal instrumentation; avoid leaking them downstream.
+	r.Header.Del("X-Module-Name")
+	r.Header.Del("X-Role")
+
 	// Handle routing based on the defined route type.
 	route(ctx, r, w, h.publisher, h.httpClient)
 }
@@ -320,7 +298,13 @@ func (h *stdHandler) initSteps(ctx context.Context, mgr PluginManager, cfg *Conf
 		if err != nil {
 			return err
 		}
-		h.steps = append(h.steps, s)
+		instrumentedStep, wrapErr := telemetry.NewInstrumentedStep(s, step, h.moduleName)
+		if wrapErr != nil {
+			log.Warnf(ctx, "Failed to instrument step %s: %v", step, wrapErr)
+			h.steps = append(h.steps, s)
+			continue
+		}
+		h.steps = append(h.steps, instrumentedStep)
 	}
 	log.Infof(ctx, "Processor steps initialized: %v", cfg.Steps)
 	return nil