Responder views inherit span of initiator. Span names are prefixed wi…

platform/view/core/manager/manager.go

@@ -55,8 +55,9 @@ type manager struct {
 	initiators map[string]string
 	factories  map[string]driver.Factory
 
-	viewTracer trace.Tracer
-	m          *Metrics
+	viewTracer    trace.Tracer
+	respondTracer trace.Tracer
+	m             *Metrics
 }
 
 func New(serviceProvider driver.ServiceProvider, commLayer CommLayer, endpointService driver.EndpointService, identityProvider driver.IdentityProvider, provider trace.TracerProvider, metricsProvider metrics.Provider) *manager {
@@ -75,6 +76,9 @@ func New(serviceProvider driver.ServiceProvider, commLayer CommLayer, endpointSe
 			Namespace:  "fsc",
 			LabelNames: []string{SuccessLabel, ViewLabel, InitiatorViewLabel},
 		})),
+		respondTracer: provider.Tracer("respond", tracing.WithMetricsOpts(tracing.MetricsOpts{
+			Namespace: "fsc",
+		})),
 		m: newMetrics(metricsProvider),
 	}
 }
@@ -436,6 +440,7 @@ func (cm *manager) newContext(id view.Identity, msg *view.Message) (view.Context
 		if ctx == nil {
 			ctx = context.Background()
 		}
+		ctx = trace.ContextWithSpanContext(ctx, trace.SpanContextFromContext(msg.Ctx))
 		newCtx, err := NewContext(ctx, cm.sp, contextID, cm.commLayer, cm.endpointService, id, backend, caller, cm.viewTracer)
 		if err != nil {
 			return nil, false, err
@@ -474,6 +479,9 @@ func (cm *manager) existResponder(msg *view.Message) (view.View, view.Identity,
 }
 
 func (cm *manager) callView(msg *view.Message) {
+	newCtx, span := cm.respondTracer.Start(msg.Ctx, "view_responder")
+	msg.Ctx = newCtx
+	defer span.End()
 	responder, id, err := cm.existResponder(msg)
 	if err != nil {
 		// TODO: No responder exists for this message
@@ -485,6 +493,7 @@ func (cm *manager) callView(msg *view.Message) {
 		id = cm.me()
 	}
 
+	span.AddEvent("respond_view")
 	ctx, _, err := cm.respond(responder, id, msg)
 	if err != nil {
 		logger.Errorf("failed responding [%v, %v], err: [%s]", getIdentifier(responder), msg.String(), err)

platform/view/sdk/dig/sdk.go

@@ -124,11 +124,14 @@ func (p *SDK) Install() error {
 			return operations.NewMetricsProvider(o.Metrics, l, true)
 		}),
 		p.C.Provide(func(metricsProvider metrics2.Provider, configService driver.ConfigService) (trace.TracerProvider, error) {
-			if tp, err := tracing2.NewTracerProvider(configService); err != nil {
+			base, err := tracing2.NewTracerProvider(configService)
+			if err != nil {
 				return nil, err
-			} else {
-				return tracing2.NewWrappedTracerProvider(tracing.NewTracerProviderWithBackingProvider(tp, metricsProvider)), nil
 			}
+			enhanced := tracing.NewTracerProviderWithBackingProvider(base, metricsProvider)
+			nodeName := configService.GetString("fsc.id")
+			named := tracing.NewProviderWithNodeName(enhanced, nodeName)
+			return tracing2.NewWrappedTracerProvider(named), nil
 		}),
 		p.C.Provide(view3.NewMetrics),
 		p.C.Provide(view3.NewAccessControlChecker, dig.As(new(view3.PolicyChecker))),

platform/view/services/session/json.go

@@ -15,8 +15,11 @@ import (
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/hash"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/view"
 	"github.com/pkg/errors"
+	"go.opentelemetry.io/otel/trace"
 )
 
+const defaultReceiveTimeout = 10 * time.Second
+
 var logger = flogging.MustGetLogger("view-sdk.session.json")
 
 type Session interface {
@@ -41,50 +44,38 @@ func JSON(context view.Context) *jsonSession {
 }
 
 func (j *jsonSession) Receive(state interface{}) error {
-	timeout := time.NewTimer(time.Second * 10)
-	defer timeout.Stop()
-
-	ch := j.s.Receive()
-	var raw []byte
-	select {
-	case msg := <-ch:
-		if msg.Status == view.ERROR {
-			return errors.Errorf("received error from remote [%s]", string(msg.Payload))
-		}
-		raw = msg.Payload
-	case <-timeout.C:
-		return errors.New("time out reached")
-	case <-j.context.Done():
-		return errors.Errorf("context done [%s]", j.context.Err())
-	}
-	logger.Debugf("json session, received message [%s]", hash.Hashable(raw).String())
-	return json.Unmarshal(raw, state)
+	return j.ReceiveWithTimeout(state, defaultReceiveTimeout)
 }
 
 func (j *jsonSession) ReceiveWithTimeout(state interface{}, d time.Duration) error {
+	span := trace.SpanFromContext(j.context)
 	timeout := time.NewTimer(d)
 	defer timeout.Stop()
 
 	// TODO: use opts
+	span.AddEvent("wait_receive")
 	ch := j.s.Receive()
 	var raw []byte
 	select {
 	case msg := <-ch:
+		span.AddEvent("received_message")
 		if msg.Status == view.ERROR {
 			return errors.Errorf("received error from remote [%s]", string(msg.Payload))
 		}
 		raw = msg.Payload
 	case <-timeout.C:
+		span.AddEvent("timeout")
 		return errors.New("time out reached")
 	case <-j.context.Done():
 		return errors.Errorf("context done [%s]", j.context.Err())
 	}
-	logger.Debugf("json session, received message [%s]", hash.Hashable(raw).String())
+	logger.Debugf("json session, received message [%s]", hash.Hashable(raw))
+	span.AddEvent("unmarshal_response")
 	return json.Unmarshal(raw, state)
 }
 
 func (j *jsonSession) Send(state interface{}) error {
-	return j.SendWithContext(context.TODO(), state)
+	return j.SendWithContext(j.context, state)
 }
 
 func (j *jsonSession) SendWithContext(ctx context.Context, state interface{}) error {

platform/view/services/tracing/config.go

@@ -14,6 +14,7 @@ import (
 const (
 	namespaceKey  = "namespace"
 	labelNamesKey = "label_names"
+	nodeNameKey   = "node_name"
 )
 
 type LabelName = string
@@ -36,6 +37,9 @@ func extractMetricsOpts(attrs attribute.Set) MetricsOpts {
 	if val, ok := attrs.Value(namespaceKey); ok {
 		o.Namespace = val.AsString()
 	}
+	if val, ok := attrs.Value(nodeNameKey); ok {
+		o.Namespace = val.AsString() + "_" + o.Namespace
+	}
 	if val, ok := attrs.Value(labelNamesKey); ok {
 		o.LabelNames = val.AsStringSlice()
 	}

platform/view/services/tracing/provider.go

@@ -11,8 +11,9 @@ import (
 	"strings"
 
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/driver"
-	tracing2 "github.com/hyperledger-labs/fabric-smart-client/platform/view/sdk/tracing"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/view/sdk/tracing"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/metrics"
+	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/trace"
 	"go.opentelemetry.io/otel/trace/embedded"
 )
@@ -22,8 +23,27 @@ type metricsProvider interface {
 	NewHistogram(opts metrics.HistogramOpts) metrics.Histogram
 }
 
+type providerWithNodeName struct {
+	trace.TracerProvider
+	nodeName string
+}
+
+func NewProviderWithNodeName(p trace.TracerProvider, nodeName string) trace.TracerProvider {
+	return &providerWithNodeName{
+		TracerProvider: p,
+		nodeName:       nodeName,
+	}
+}
+
+func (p *providerWithNodeName) Tracer(name string, options ...trace.TracerOption) trace.Tracer {
+	c := trace.NewTracerConfig(options...)
+
+	attrs := c.InstrumentationAttributes()
+	return p.TracerProvider.Tracer(name, append(options, trace.WithInstrumentationAttributes(append(attrs.ToSlice(), attribute.String(nodeNameKey, p.nodeName))...))...)
+}
+
 func NewTracerProvider(confService driver.ConfigService, metricsProvider metrics.Provider) (trace.TracerProvider, error) {
-	backingProvider, err := tracing2.NewTracerProvider(confService)
+	backingProvider, err := tracing.NewTracerProvider(confService)
 	if err != nil {
 		return nil, err
 	}
@@ -47,6 +67,7 @@ func (p *tracerProvider) Tracer(name string, options ...trace.TracerOption) trac
 	opts := extractMetricsOpts(c.InstrumentationAttributes())
 	return &tracer{
 		backingTracer: p.backingProvider.Tracer(name, options...),
+		namespace:     opts.Namespace,
 		labelNames:    opts.LabelNames,
 		operations: p.metricsProvider.NewCounter(metrics.CounterOpts{
 			Namespace:    opts.Namespace,

platform/view/services/tracing/tracer.go

@@ -14,17 +14,20 @@ import (
 	"go.opentelemetry.io/otel/trace/embedded"
 )
 
+const namespaceLabel LabelName = "namespace"
+
 type tracer struct {
 	embedded.Tracer
 	backingTracer trace.Tracer
 
+	namespace  string
 	labelNames []LabelName
 	operations metrics.Counter
 	duration   metrics.Histogram
 }
 
 func (t *tracer) Start(ctx context.Context, spanName string, opts ...trace.SpanStartOption) (context.Context, trace.Span) {
-	newCtx, backingSpan := t.backingTracer.Start(ctx, spanName, opts...)
+	newCtx, backingSpan := t.backingTracer.Start(ctx, spanName, append(opts, WithAttributes(String(namespaceLabel, t.namespace)))...)
 
 	return newCtx, newSpan(backingSpan, t.labelNames, t.operations, t.duration, opts...)
 }