feat(tracing): Add Store, P2P and Config tracing

execution/grpc/go.mod

@@ -7,8 +7,8 @@ require (
 	connectrpc.com/grpcreflect v1.3.0
 	github.com/evstack/ev-node v1.0.0-beta.11
 	github.com/evstack/ev-node/core v1.0.0-beta.5
-	golang.org/x/net v0.49.0
-	google.golang.org/protobuf v1.36.11
+	golang.org/x/net v0.47.0
+	google.golang.org/protobuf v1.36.10
 )
 
-require golang.org/x/text v0.33.0 // indirect
+require golang.org/x/text v0.31.0 // indirect

execution/grpc/go.sum

@@ -8,9 +8,9 @@ github.com/evstack/ev-node/core v1.0.0-beta.5 h1:lgxE8XiF3U9pcFgh7xuKMgsOGvLBGRy
 github.com/evstack/ev-node/core v1.0.0-beta.5/go.mod h1:n2w/LhYQTPsi48m6lMj16YiIqsaQw6gxwjyJvR+B3sY=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o=
-golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=
-golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE=
-golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8=
-google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
-google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
+golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
+golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
+golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
+google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
+google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=

pkg/rpc/server/server.go

@@ -378,9 +378,15 @@ func NewServiceHandler(
 	config config.Config,
 	bestKnown BestKnownHeightProvider,
 ) (http.Handler, error) {
-	storeServer := NewStoreServer(store, headerStore, dataStore, logger)
-	p2pServer := NewP2PServer(peerManager)
-	configServer := NewConfigServer(config, proposerAddress, logger)
+	var storeServer rpc.StoreServiceHandler = NewStoreServer(store, headerStore, dataStore, logger)
+	var p2pServer rpc.P2PServiceHandler = NewP2PServer(peerManager)
+	var configServer rpc.ConfigServiceHandler = NewConfigServer(config, proposerAddress, logger)
+
+	if config.Instrumentation.IsTracingEnabled() {
+		storeServer = WithTracingStoreServer(storeServer)
+		p2pServer = WithTracingP2PServer(p2pServer)
+		configServer = WithTracingConfigServer(configServer)
+	}
 
 	mux := http.NewServeMux()
 

pkg/rpc/server/tracing.go

@@ -0,0 +1,270 @@
+package server
+
+import (
+	"context"
+	"encoding/hex"
+
+	"connectrpc.com/connect"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/codes"
+	"go.opentelemetry.io/otel/trace"
+	"google.golang.org/protobuf/types/known/emptypb"
+
+	pb "github.com/evstack/ev-node/types/pb/evnode/v1"
+	"github.com/evstack/ev-node/types/pb/evnode/v1/v1connect"
+)
+
+// tracedStoreServer decorates a StoreServiceHandler with OpenTelemetry spans.
+type tracedStoreServer struct {
+	inner  v1connect.StoreServiceHandler
+	tracer trace.Tracer
+}
+
+// WithTracingStoreServer decorates the provided store service handler with tracing spans.
+func WithTracingStoreServer(inner v1connect.StoreServiceHandler) v1connect.StoreServiceHandler {
+	return &tracedStoreServer{
+		inner:  inner,
+		tracer: otel.Tracer("ev-node/store-service"),
+	}
+}
+
+func (t *tracedStoreServer) GetBlock(
+	ctx context.Context,
+	req *connect.Request[pb.GetBlockRequest],
+) (*connect.Response[pb.GetBlockResponse], error) {
+	var attrs []attribute.KeyValue
+	switch identifier := req.Msg.Identifier.(type) {
+	case *pb.GetBlockRequest_Height:
+		attrs = append(attrs, attribute.Int64("height", int64(identifier.Height)))
+	case *pb.GetBlockRequest_Hash:
+		if identifier.Hash != nil {
+			attrs = append(attrs, attribute.String("hash", hex.EncodeToString(identifier.Hash)))
+		}
+	}
+
+	ctx, span := t.tracer.Start(ctx, "StoreService.GetBlock", trace.WithAttributes(attrs...))
+	defer span.End()
+
+	res, err := t.inner.GetBlock(ctx, req)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
+	}
+
+	span.SetAttributes(
+		attribute.Bool("found", res.Msg.Block != nil),
+	)
+	if res.Msg.Block != nil && res.Msg.Block.Data != nil {
+		totalSize := 0
+		for _, tx := range res.Msg.Block.Data.Txs {
+			totalSize += len(tx)
+		}
+		span.SetAttributes(
+			attribute.Int("block_size_bytes", totalSize),
+			attribute.Int("tx_count", len(res.Msg.Block.Data.Txs)),
+		)
+	}
+	return res, nil
+}
+
+func (t *tracedStoreServer) GetState(
+	ctx context.Context,
+	req *connect.Request[emptypb.Empty],
+) (*connect.Response[pb.GetStateResponse], error) {
+	ctx, span := t.tracer.Start(ctx, "StoreService.GetState")
+	defer span.End()
+
+	res, err := t.inner.GetState(ctx, req)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
+	}
+
+	if res.Msg.State != nil {
+		span.SetAttributes(
+			attribute.Int64("height", int64(res.Msg.State.LastBlockHeight)),
+			attribute.String("app_hash", hex.EncodeToString(res.Msg.State.AppHash)),
+			attribute.Int64("da_height", int64(res.Msg.State.DaHeight)),
+		)
+	}
+	return res, nil
+}
+
+func (t *tracedStoreServer) GetMetadata(
+	ctx context.Context,
+	req *connect.Request[pb.GetMetadataRequest],
+) (*connect.Response[pb.GetMetadataResponse], error) {
+	ctx, span := t.tracer.Start(ctx, "StoreService.GetMetadata",
+		trace.WithAttributes(
+			attribute.String("key", req.Msg.Key),
+		),
+	)
+	defer span.End()
+
+	res, err := t.inner.GetMetadata(ctx, req)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
+	}
+
+	span.SetAttributes(
+		attribute.Int("value_size_bytes", len(res.Msg.Value)),
+	)
+	return res, nil
+}
+
+func (t *tracedStoreServer) GetGenesisDaHeight(
+	ctx context.Context,
+	req *connect.Request[emptypb.Empty],
+) (*connect.Response[pb.GetGenesisDaHeightResponse], error) {
+	ctx, span := t.tracer.Start(ctx, "StoreService.GetGenesisDaHeight")
+	defer span.End()
+
+	res, err := t.inner.GetGenesisDaHeight(ctx, req)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
+	}
+
+	span.SetAttributes(
+		attribute.Int64("genesis_da_height", int64(res.Msg.Height)),
+	)
+	return res, nil
+}
+
+func (t *tracedStoreServer) GetP2PStoreInfo(
+	ctx context.Context,
+	req *connect.Request[emptypb.Empty],
+) (*connect.Response[pb.GetP2PStoreInfoResponse], error) {
+	ctx, span := t.tracer.Start(ctx, "StoreService.GetP2PStoreInfo")
+	defer span.End()
+
+	res, err := t.inner.GetP2PStoreInfo(ctx, req)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
+	}
+
+	span.SetAttributes(
+		attribute.Int("store_count", len(res.Msg.Stores)),
+	)
+	return res, nil
+}
+
+// tracedP2PServer decorates a P2PServiceHandler with OpenTelemetry spans.
+type tracedP2PServer struct {
+	inner  v1connect.P2PServiceHandler
+	tracer trace.Tracer
+}
+
+// WithTracingP2PServer decorates the provided P2P service handler with tracing spans.
+func WithTracingP2PServer(inner v1connect.P2PServiceHandler) v1connect.P2PServiceHandler {
+	return &tracedP2PServer{
+		inner:  inner,
+		tracer: otel.Tracer("ev-node/p2p-service"),
+	}
+}
+
+func (t *tracedP2PServer) GetPeerInfo(
+	ctx context.Context,
+	req *connect.Request[emptypb.Empty],
+) (*connect.Response[pb.GetPeerInfoResponse], error) {
+	ctx, span := t.tracer.Start(ctx, "P2PService.GetPeerInfo")
+	defer span.End()
+
+	res, err := t.inner.GetPeerInfo(ctx, req)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
+	}
+
+	span.SetAttributes(
+		attribute.Int("peer_count", len(res.Msg.Peers)),
+	)
+	return res, nil
+}
+
+func (t *tracedP2PServer) GetNetInfo(
+	ctx context.Context,
+	req *connect.Request[emptypb.Empty],
+) (*connect.Response[pb.GetNetInfoResponse], error) {
+	ctx, span := t.tracer.Start(ctx, "P2PService.GetNetInfo")
+	defer span.End()
+
+	res, err := t.inner.GetNetInfo(ctx, req)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
+	}
+
+	if res.Msg.NetInfo != nil {
+		span.SetAttributes(
+			attribute.String("node_id", res.Msg.NetInfo.Id),
+			attribute.Int("listen_address_count", len(res.Msg.NetInfo.ListenAddresses)),
+		)
+	}
+	return res, nil
+}
+
+// tracedConfigServer decorates a ConfigServiceHandler with OpenTelemetry spans.
+type tracedConfigServer struct {
+	inner  v1connect.ConfigServiceHandler
+	tracer trace.Tracer
+}
+
+// WithTracingConfigServer decorates the provided config service handler with tracing spans.
+func WithTracingConfigServer(inner v1connect.ConfigServiceHandler) v1connect.ConfigServiceHandler {
+	return &tracedConfigServer{
+		inner:  inner,
+		tracer: otel.Tracer("ev-node/config-service"),
+	}
+}
+
+func (t *tracedConfigServer) GetNamespace(
+	ctx context.Context,
+	req *connect.Request[emptypb.Empty],
+) (*connect.Response[pb.GetNamespaceResponse], error) {
+	ctx, span := t.tracer.Start(ctx, "ConfigService.GetNamespace")
+	defer span.End()
+
+	res, err := t.inner.GetNamespace(ctx, req)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
+	}
+
+	span.SetAttributes(
+		attribute.String("header_namespace", res.Msg.HeaderNamespace),
+		attribute.String("data_namespace", res.Msg.DataNamespace),
+	)
+	return res, nil
+}
+
+func (t *tracedConfigServer) GetSignerInfo(
+	ctx context.Context,
+	req *connect.Request[emptypb.Empty],
+) (*connect.Response[pb.GetSignerInfoResponse], error) {
+	ctx, span := t.tracer.Start(ctx, "ConfigService.GetSignerInfo")
+	defer span.End()
+
+	res, err := t.inner.GetSignerInfo(ctx, req)
+	if err != nil {
+		span.RecordError(err)
+		span.SetStatus(codes.Error, err.Error())
+		return nil, err
+	}
+
+	span.SetAttributes(
+		attribute.String("signer_address", hex.EncodeToString(res.Msg.Address)),
+	)
+	return res, nil
+}