wehub-resource-sync
e071084ebe
govulncheck / govulncheck (push) Has been cancelled
Lint / golangci-lint (push) Has been cancelled
Run Tests / Unit Tests (push) Has been cancelled
Run Tests / Etcd Integration Tests (push) Has been cancelled
Harness (E2E) / Harnesses (mock LLM) (push) Has been cancelled
Harness (E2E) / Provider harnesses (live LLM conformance) (push) Has been cancelled
116 lines
3.4 KiB
Go
116 lines
3.4 KiB
Go
package mcp
|
|
|
|
import (
|
|
"context"
|
|
|
|
"go-micro.dev/v6/metadata"
|
|
"go.opentelemetry.io/otel"
|
|
"go.opentelemetry.io/otel/attribute"
|
|
"go.opentelemetry.io/otel/codes"
|
|
"go.opentelemetry.io/otel/propagation"
|
|
"go.opentelemetry.io/otel/trace"
|
|
)
|
|
|
|
const instrumentationName = "go-micro.dev/v6/gateway/mcp"
|
|
|
|
// Span and attribute names for MCP OpenTelemetry integration.
|
|
const (
|
|
spanNameToolCall = "mcp.tool.call"
|
|
|
|
// AttrToolName is the tool being called (e.g. "blog.Blog.Create").
|
|
AttrToolName = "mcp.tool.name"
|
|
// AttrTransport is the transport type ("http" or "stdio").
|
|
AttrTransport = "mcp.transport"
|
|
// AttrAccountID is the authenticated account ID.
|
|
AttrAccountID = "mcp.account.id"
|
|
// AttrTraceID is the MCP-specific UUID trace ID (kept for compatibility).
|
|
AttrTraceID = "mcp.trace_id"
|
|
// AttrAuthAllowed records whether auth was granted.
|
|
AttrAuthAllowed = "mcp.auth.allowed"
|
|
// AttrAuthDeniedReason records why auth was denied.
|
|
AttrAuthDeniedReason = "mcp.auth.denied_reason"
|
|
// AttrScopesRequired lists the scopes required by the tool.
|
|
AttrScopesRequired = "mcp.auth.scopes_required"
|
|
// AttrRateLimited records whether the call was rate-limited.
|
|
AttrRateLimited = "mcp.rate_limited"
|
|
)
|
|
|
|
// tracer returns the OTel tracer from the configured provider.
|
|
// If no TraceProvider is set, returns a noop tracer.
|
|
func (s *Server) tracer() trace.Tracer {
|
|
if s.opts.TraceProvider != nil {
|
|
return s.opts.TraceProvider.Tracer(instrumentationName)
|
|
}
|
|
return trace.NewNoopTracerProvider().Tracer(instrumentationName)
|
|
}
|
|
|
|
// startToolSpan creates a new server span for an MCP tool call.
|
|
// It extracts any incoming trace context from metadata and injects
|
|
// the new span's context back into metadata for downstream propagation.
|
|
func (s *Server) startToolSpan(ctx context.Context, toolName, transport, mcpTraceID string) (context.Context, trace.Span) {
|
|
if s.opts.TraceProvider == nil {
|
|
return ctx, trace.SpanFromContext(ctx)
|
|
}
|
|
|
|
// Extract incoming trace context from go-micro metadata (if any).
|
|
md, ok := metadata.FromContext(ctx)
|
|
if ok {
|
|
carrier := metadataCarrier(md)
|
|
ctx = otel.GetTextMapPropagator().Extract(ctx, carrier)
|
|
}
|
|
|
|
ctx, span := s.tracer().Start(ctx, spanNameToolCall,
|
|
trace.WithSpanKind(trace.SpanKindServer),
|
|
trace.WithAttributes(
|
|
attribute.String(AttrToolName, toolName),
|
|
attribute.String(AttrTransport, transport),
|
|
attribute.String(AttrTraceID, mcpTraceID),
|
|
),
|
|
)
|
|
|
|
// Inject OTel trace context back into metadata so downstream
|
|
// RPC calls (via client wrappers) continue the trace.
|
|
if md == nil {
|
|
md = make(metadata.Metadata)
|
|
}
|
|
carrier := make(propagation.MapCarrier)
|
|
otel.GetTextMapPropagator().Inject(ctx, carrier)
|
|
for k, v := range carrier {
|
|
md.Set(k, v)
|
|
}
|
|
ctx = metadata.NewContext(ctx, md)
|
|
|
|
return ctx, span
|
|
}
|
|
|
|
// setSpanOK marks a span as successful.
|
|
func setSpanOK(span trace.Span) {
|
|
span.SetStatus(codes.Ok, "")
|
|
}
|
|
|
|
// setSpanError records an error on the span.
|
|
func setSpanError(span trace.Span, err error) {
|
|
span.RecordError(err)
|
|
span.SetStatus(codes.Error, err.Error())
|
|
}
|
|
|
|
// metadataCarrier adapts go-micro metadata to OTel's TextMapCarrier.
|
|
type metadataCarrier metadata.Metadata
|
|
|
|
func (c metadataCarrier) Get(key string) string {
|
|
v, _ := metadata.Metadata(c).Get(key)
|
|
return v
|
|
}
|
|
|
|
func (c metadataCarrier) Set(key, value string) {
|
|
metadata.Metadata(c).Set(key, value)
|
|
}
|
|
|
|
func (c metadataCarrier) Keys() []string {
|
|
keys := make([]string, 0, len(c))
|
|
for k := range c {
|
|
keys = append(keys, k)
|
|
}
|
|
return keys
|
|
}
|