From ff75f4a0d2dd44759f62ed092e631c0d82464d4a Mon Sep 17 00:00:00 2001 From: jonny rhea Date: Sat, 3 Jan 2026 10:43:07 -0600 Subject: [PATCH] renamed otel to rpc tracing --- cmd/geth/config.go | 10 +++---- cmd/geth/main.go | 9 ++---- cmd/utils/flags.go | 24 ++++++--------- cmd/utils/{otel.go => rpc_tracing.go} | 42 +++++++++++++-------------- 4 files changed, 37 insertions(+), 48 deletions(-) rename cmd/utils/{otel.go => rpc_tracing.go} (69%) diff --git a/cmd/geth/config.go b/cmd/geth/config.go index cbbe26be44..d2430e17b0 100644 --- a/cmd/geth/config.go +++ b/cmd/geth/config.go @@ -242,13 +242,13 @@ func makeFullNode(ctx *cli.Context) *node.Node { // Start metrics export if enabled utils.SetupMetrics(&cfg.Metrics) - // Setup OpenTelemetry tracing if enabled - otelService, err := utils.SetupOTEL(ctx) + // Setup RPC tracing if enabled + rpcTracingService, err := utils.SetupRPCTracing(ctx) if err != nil { - utils.Fatalf("failed to setup OpenTelemetry: %v", err) + utils.Fatalf("failed to setup rpc tracing: %v", err) } - if otelService != nil { - utils.RegisterOTELService(otelService, stack) + if rpcTracingService != nil { + utils.RegisterRPCTracingService(rpcTracingService, stack) } backend, eth := utils.RegisterEthService(stack, &cfg.Eth) diff --git a/cmd/geth/main.go b/cmd/geth/main.go index e267e30edd..0d19a0c869 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -196,6 +196,8 @@ var ( utils.RPCTxSyncDefaultTimeoutFlag, utils.RPCTxSyncMaxTimeoutFlag, utils.RPCGlobalRangeLimitFlag, + utils.RPCTracingFlag, + utils.RPCTracingEndpointFlag, } metricsFlags = []cli.Flag{ @@ -215,12 +217,6 @@ var ( utils.MetricsInfluxDBOrganizationFlag, utils.StateSizeTrackingFlag, } - - otelFlags = []cli.Flag{ - utils.OTELEnabledFlag, - utils.OTELEndpointFlag, - utils.OTELServiceNameFlag, - } ) var app = flags.NewApp("the go-ethereum command line interface") @@ -271,7 +267,6 @@ func init() { consoleFlags, debug.Flags, metricsFlags, - otelFlags, ) flags.AutoEnvVars(app.Flags, "GETH") diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index 6e822d7d16..fe240a15c1 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -1043,23 +1043,17 @@ Please note that --` + MetricsHTTPFlag.Name + ` must be set to start the server. Category: flags.MetricsCategory, } - OTELEnabledFlag = &cli.BoolFlag{ - Name: "otel.enabled", - Usage: "Enable OpenTelemetry tracing", - Category: flags.LoggingCategory, + // RPC Tracing + RPCTracingFlag = &cli.BoolFlag{ + Name: "rpc.tracing", + Usage: "Enable RPC tracing", + Category: flags.APICategory, } - OTELEndpointFlag = &cli.StringFlag{ - Name: "otel.endpoint", - Usage: "Defines where OpenTelemetry traces are sent (e.g., http://localhost:4318)", - Category: flags.LoggingCategory, - } - - OTELServiceNameFlag = &cli.StringFlag{ - Name: "otel.service-name", - Usage: "Service name for OpenTelemetry traces", - Value: "geth", - Category: flags.LoggingCategory, + RPCTracingEndpointFlag = &cli.StringFlag{ + Name: "rpc.tracing.endpoint", + Usage: "Defines where RPC traces are sent (e.g., http://localhost:4318)", + Category: flags.APICategory, } ) diff --git a/cmd/utils/otel.go b/cmd/utils/rpc_tracing.go similarity index 69% rename from cmd/utils/otel.go rename to cmd/utils/rpc_tracing.go index f519296207..a85ba5fd71 100644 --- a/cmd/utils/otel.go +++ b/cmd/utils/rpc_tracing.go @@ -35,38 +35,37 @@ import ( semconv "go.opentelemetry.io/otel/semconv/v1.24.0" ) -// otelService wraps the OpenTelemetry TracerProvider to implement node.Lifecycle. -type otelService struct { +// rpcTracingService wraps the OpenTelemetry TracerProvider to implement node.Lifecycle. +type rpcTracingService struct { tracerProvider *sdktrace.TracerProvider } // Start implements node.Lifecycle. -func (o *otelService) Start() error { +func (r *rpcTracingService) Start() error { return nil // Provider is already started during setup } // Stop implements node.Lifecycle -func (o *otelService) Stop() error { +func (r *rpcTracingService) Stop() error { ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() - if err := o.tracerProvider.Shutdown(ctx); err != nil { - log.Error("Failed to stop OTEL Service", "err", err) + if err := r.tracerProvider.Shutdown(ctx); err != nil { + log.Error("Failed to stop RPC Tracing Service", "err", err) return err } - log.Info("OTEL Service stopped") + log.Info("RPC Tracing Service stopped") return nil } -// SetupOTEL initializes OpenTelemetry tracing based on CLI flags. -func SetupOTEL(ctx *cli.Context) (*otelService, error) { - if !ctx.Bool(OTELEnabledFlag.Name) { +// SetupRPCTracing initializes OpenTelemetry tracing based on CLI flags. +func SetupRPCTracing(ctx *cli.Context) (*rpcTracingService, error) { + if !ctx.Bool(RPCTracingFlag.Name) { return nil, nil } - endpoint := ctx.String(OTELEndpointFlag.Name) + endpoint := ctx.String(RPCTracingEndpointFlag.Name) if endpoint == "" { return nil, nil } - serviceName := ctx.String(OTELServiceNameFlag.Name) setupCtx := ctx.Context if setupCtx == nil { setupCtx = context.Background() @@ -75,7 +74,7 @@ func SetupOTEL(ctx *cli.Context) (*otelService, error) { // Create exporter based on endpoint URL u, err := url.Parse(endpoint) if err != nil { - return nil, fmt.Errorf("invalid otel endpoint URL: %w", err) + return nil, fmt.Errorf("invalid rpc tracing endpoint URL: %w", err) } var exporter sdktrace.SpanExporter @@ -92,17 +91,17 @@ func SetupOTEL(ctx *cli.Context) (*otelService, error) { } exporter, err = otlptracehttp.New(setupCtx, opts...) default: - return nil, fmt.Errorf("unsupported otel url scheme: %s", u.Scheme) + return nil, fmt.Errorf("unsupported rpc tracing url scheme: %s", u.Scheme) } if err != nil { - return nil, fmt.Errorf("failed to create otel exporter: %w", err) + return nil, fmt.Errorf("failed to create rpc tracing exporter: %w", err) } // Create resource with service information res := resource.NewWithAttributes( semconv.SchemaURL, - semconv.ServiceName(serviceName), + semconv.ServiceName("geth"), attribute.String("client.name", version.ClientName("geth")), ) @@ -122,11 +121,12 @@ func SetupOTEL(ctx *cli.Context) (*otelService, error) { propagation.Baggage{}, )) - log.Info("OpenTelemetry tracing enabled", "endpoint", endpoint, "service", serviceName) - return &otelService{tracerProvider: tp}, nil + log.Info("RPC tracing enabled", "endpoint", endpoint) + return &rpcTracingService{tracerProvider: tp}, nil } -// RegisterOTELService registers the otelService with the node so its lifecycle is managed by the node. -func RegisterOTELService(otelService *otelService, stack *node.Node) { - stack.RegisterLifecycle(otelService) +// RegisterRPCTracingService registers the rpcTracingService with the node +// so its lifecycle is managed by the node. +func RegisterRPCTracingService(rpcTracingService *rpcTracingService, stack *node.Node) { + stack.RegisterLifecycle(rpcTracingService) }