set parent endpoint as http client name and use otel state getter function for client transport

Author: dhontecillas

config/lura.go

@@ -35,9 +35,6 @@ func FromLura(srvCfg config.ServiceConfig) (*Config, error) {
 		return nil, err
 	}
 
-	// TODO: we might want to move these defaults to the config.go
-	// file, as is not specific to reading the config from the Lura
-	// config.
 	if cfg.Layers == nil {
 		cfg.Layers = &LayersOpts{}
 	}

example/server/main.go

@@ -74,7 +74,6 @@ func main() {
 		serviceConfig.Port = *port
 	}
 
-	// TODO: how to register the exporter factory
 	logger, _ := logging.NewLogger(*logLevel, os.Stdout, "[KRAKEND]")
 
 	obsConfig, err := kotelconfig.FromLura(serviceConfig)
@@ -89,17 +88,19 @@ func main() {
 		return
 	}
 
+	otelStateFn := state.GlobalState
+
 	bf := func(backendConfig *config.Backend) proxy.Proxy {
 		reqExec := lura.HTTPRequestExecutorFromConfig(client.NewHTTPClient,
-			backendConfig, obsConfig.Layers.Backend, obsConfig.SkipPaths)
+			backendConfig, obsConfig.Layers.Backend, obsConfig.SkipPaths, otelStateFn)
 		return proxy.NewHTTPProxyWithHTTPExecutor(backendConfig, reqExec, backendConfig.Decoder)
 	}
-	bf = lura.BackendFactory(bf, state.GlobalState, obsConfig.Layers.Backend, obsConfig.SkipPaths)
+	bf = lura.BackendFactory(bf, otelStateFn, obsConfig.Layers.Backend, obsConfig.SkipPaths)
 
 	defaultPF := proxy.NewDefaultFactory(bf, logger)
-	pf := lura.ProxyFactory(defaultPF, state.GlobalState, obsConfig.Layers.Pipe, obsConfig.SkipPaths)
+	pf := lura.ProxyFactory(defaultPF, otelStateFn, obsConfig.Layers.Pipe, obsConfig.SkipPaths)
 
-	handlerF := otelgin.New(krakendgin.EndpointHandler, state.GlobalState,
+	handlerF := otelgin.New(krakendgin.EndpointHandler, otelStateFn,
 		obsConfig.Layers.Router, obsConfig.SkipPaths)
 	// setup the krakend router
 	routerFactory := krakendgin.NewFactory(krakendgin.Config{

http/client/client.go

@@ -42,7 +42,8 @@ import (
 // InstrumentedHTTPClient creates a new instrumented http client with the options provided.
 // If the provided options are nil, the default options (with everything enabled) will be used.
 // Check the [TransportOptions] struct for details..
-func InstrumentedHTTPClient(c *http.Client, t *TransportOptions, clientName string) (*http.Client, error) {
+func InstrumentedHTTPClient(c *http.Client, t *TransportOptions, clientName string,
+	getState state.GetterFn) (*http.Client, error) {
 	// the default options is to have everything activated
 	// TODO: we might want to return the provided client if no transport options are provided ?
 	// TODO: we might want to return an error if no transport options are provided ?
@@ -57,7 +58,7 @@ func InstrumentedHTTPClient(c *http.Client, t *TransportOptions, clientName stri
 			ReadPayload:        true,
 			DetailedConnection: false,
 		},
-		OTELInstance: state.GlobalState,
+		OTELInstance: getState,
 	}
 	if t != nil {
 		opts = *t

http/client/transport.go

@@ -59,9 +59,6 @@ type Transport struct {
 	// TODO:
 	// StartOptions trace.StartOptions
 
-	// TODO: probably combine the ENDPOINT URL + URL PATTER
-	spanName string // the name for this span (we can use the URL Pattern
-
 	tracesOpts      TransportTracesOptions
 	metricsOpts     TransportMetricsOptions
 	getOTELInstance state.GetterFn
@@ -109,17 +106,17 @@ func readWrapperBuilder(metricsOpts *TransportMetricsOptions, tracesOpts *Transp
 
 // NewRoundTripper creates an instrumented round tripper.
 func NewRoundTripper(base http.RoundTripper, metricsOpts TransportMetricsOptions,
-	tracesOpts TransportTracesOptions, spanName string, stateGetter state.GetterFn,
+	tracesOpts TransportTracesOptions, clientName string, stateGetter state.GetterFn,
 ) http.RoundTripper {
-	rt := newTransport(base, metricsOpts, tracesOpts, spanName, stateGetter)
+	rt := newTransport(base, metricsOpts, tracesOpts, clientName, stateGetter)
 	if rt == nil {
 		return base
 	}
 	return rt
 }
 
 func newTransport(base http.RoundTripper, metricsOpts TransportMetricsOptions,
-	tracesOpts TransportTracesOptions, spanName string, stateGetter state.GetterFn,
+	tracesOpts TransportTracesOptions, clientName string, stateGetter state.GetterFn,
 ) *Transport {
 	if !tracesOpts.Enabled() && !metricsOpts.Enabled() {
 		return nil
@@ -146,12 +143,11 @@ func newTransport(base http.RoundTripper, metricsOpts TransportMetricsOptions,
 	return &Transport{
 		base:            base,
 		propagator:      otel.GetTextMapPropagator(),
-		spanName:        spanName,
 		getOTELInstance: stateGetter,
 		tracesOpts:      tracesOpts,
 		metricsOpts:     metricsOpts,
-		metrics:         newTransportMetrics(&metricsOpts, meter),
-		traces:          newTransportTraces(&tracesOpts, tracer, spanName),
+		metrics:         newTransportMetrics(&metricsOpts, meter, clientName),
+		traces:          newTransportTraces(&tracesOpts, tracer, clientName),
 		readerWrapper:   readWrapperBuilder(&metricsOpts, &tracesOpts, meter, tracer),
 	}
 }

http/client/transport_metrics.go

@@ -66,9 +66,12 @@ type transportMetrics struct {
 	getConnLatency metric.Float64Histogram
 	dnsLatency     metric.Float64Histogram
 	tlsLatency     metric.Float64Histogram
+
+	// to identify the source of the request (in KrakenD the front facing endpoint)
+	clientName string
 }
 
-func newTransportMetrics(metricsOpts *TransportMetricsOptions, meter metric.Meter) *transportMetrics {
+func newTransportMetrics(metricsOpts *TransportMetricsOptions, meter metric.Meter, clientName string) *transportMetrics {
 	if meter == nil {
 		return nil
 	}
@@ -98,15 +101,14 @@ func (m *transportMetrics) report(rtt *roundTripTracking, attrs []attribute.KeyV
 		return
 	}
 
-	var attrM []attribute.KeyValue
+	attrM := make([]attribute.KeyValue, len(attrs), len(attrs)+2)
+	copy(attrM, attrs)
+	if len(m.clientName) > 0 {
+		attrM = append(attrM, attribute.Key("clientname").String(m.clientName))
+	}
 	if rtt.err == nil {
-		attrM = make([]attribute.KeyValue, len(attrs), len(attrs)+1)
-		copy(attrM, attrs)
-		attrM = append(attrM, semconv.HTTPResponseStatusCode(int(rtt.resp.StatusCode)))
-	} else {
 		// if we fail on the client side, we do not have a status code ..
-		// attrM = append(attrM, semconv.HTTPResponseStatusCode(int(0))
-		attrM = attrs
+		attrM = append(attrM, semconv.HTTPResponseStatusCode(int(rtt.resp.StatusCode)))
 	}
 	attrOpt := metric.WithAttributeSet(attribute.NewSet(attrM...))
 

lura/backend.go

@@ -12,6 +12,7 @@ import (
 
 	otelconfig "github.com/krakend/krakend-otel/config"
 	clienthttp "github.com/krakend/krakend-otel/http/client"
+	otelstate "github.com/krakend/krakend-otel/state"
 )
 
 var defaultOpts = otelconfig.BackendOpts{
@@ -35,7 +36,8 @@ var defaultOpts = otelconfig.BackendOpts{
 // for the backend requests.
 func HTTPRequestExecutorFromConfig(clientFactory transport.HTTPClientFactory,
 	cfg *config.Backend, opts *otelconfig.BackendOpts, skipPaths []string,
-) transport.HTTPRequestExecutor {
+	getState otelstate.GetterFn) transport.HTTPRequestExecutor {
+
 	for _, sp := range skipPaths {
 		if cfg.ParentEndpoint == sp {
 			// TODO: check if there might be some othe executor that is
@@ -87,8 +89,7 @@ func HTTPRequestExecutorFromConfig(clientFactory transport.HTTPClientFactory,
 	}
 
 	// TODO: check how we want to deal with this "clientName"
-	endpoint := "" // we need to have the endpoint accessible in the backend config structure
-	clientName := endpoint + urlPattern
+	clientName := cfg.ParentEndpoint + "." + urlPattern
 
 	t := clienthttp.TransportOptions{
 		MetricsOpts: clienthttp.TransportMetricsOptions{
@@ -106,7 +107,7 @@ func HTTPRequestExecutorFromConfig(clientFactory transport.HTTPClientFactory,
 	}
 
 	return func(ctx context.Context, req *http.Request) (*http.Response, error) {
-		c, err := clienthttp.InstrumentedHTTPClient(clientFactory(ctx), &t, clientName)
+		c, err := clienthttp.InstrumentedHTTPClient(clientFactory(ctx), &t, clientName, getState)
 		if err != nil {
 			return nil, err
 		}