gRPC Integration
Instrument gRPC services across Go, Java, Node.js, Python, and Rust. Client and server interceptor tracing with metadata propagation and streaming RPC visibility — end-to-end.
How It Works
Install the Package
Install the TigerOps gRPC package for your language: npm install @tigerops/grpc-js for Node.js, pip install tigerops[grpc] for Python, add io.tigerops:tigerops-grpc for Java/Kotlin, or tigerops = { features = ["tonic"] } for Rust tonic.
Add Server & Client Interceptors
Attach TigerOpsServerInterceptor to your gRPC server and TigerOpsClientInterceptor to your channel. Both implement the standard gRPC interceptor interface. W3C trace context is propagated via gRPC metadata headers automatically.
Set Environment Variables
Set TIGEROPS_API_KEY, TIGEROPS_SERVICE_NAME, and TIGEROPS_ENVIRONMENT before starting your gRPC server. The interceptors read configuration from environment variables and support all major gRPC server frameworks across languages.
Traces, Metadata & Streaming RPC Visibility
Within seconds TigerOps receives unary RPC spans, server-streaming and client-streaming message counts, bidirectional stream duration, deadline exceeded events, and gRPC status codes from your distributed gRPC services.
What You Get Out of the Box
Server Interceptor Tracing
TigerOpsServerInterceptor creates a root span for every incoming RPC call with the fully qualified method name (/package.Service/Method), peer address, gRPC status code, and response time. Error responses capture the status detail message.
Client Interceptor Tracing
TigerOpsClientInterceptor creates a child span for every outgoing RPC call and injects the W3C traceparent as a gRPC metadata entry. The span records the target authority, method name, response status, and round-trip latency.
gRPC Metadata Propagation
Trace context is serialized into gRPC metadata using the standard grpc-trace-bin (binary) and traceparent (ASCII) keys. Both formats are written on outbound calls and read from inbound calls for compatibility with all gRPC tracing implementations.
Streaming RPC Visibility
Server-streaming, client-streaming, and bidirectional-streaming RPCs are traced as single long-lived spans with message_sent_count and message_received_count as span attributes. Individual message sizes are tracked as histogram metrics.
Deadline & Timeout Monitoring
gRPC call deadlines are recorded on every span. Calls that exceed their deadline create a DEADLINE_EXCEEDED span event with remaining deadline at cancellation time. Deadline propagation across service chains is visualized in the trace waterfall.
Multi-Language Interceptor Support
TigerOps provides consistent interceptor APIs for gRPC-Go, grpc-java, grpc-node (@grpc/grpc-js), grpc-python, and tonic (Rust). Trace IDs are compatible across all language implementations so polyglot gRPC services trace end-to-end.
Install & Initialize
One interceptor on server and client. Full gRPC distributed tracing.
# Install the TigerOps gRPC package (Node.js)
npm install @tigerops/grpc-js
# Set environment variables
export TIGEROPS_API_KEY="your-api-key"
export TIGEROPS_SERVICE_NAME="my-grpc-service"
export TIGEROPS_ENVIRONMENT="production"
// server.ts
import * as grpc from '@grpc/grpc-js'
import { tigeropsServerInterceptor } from '@tigerops/grpc-js'
import { OrderServiceService } from './generated/orders_grpc_pb'
const server = new grpc.Server({
interceptors: [tigeropsServerInterceptor()], // <-- add interceptor
})
server.addService(OrderServiceService, {
createOrder: async (call, callback) => {
// Active span is available via context
const span = TigerOps.currentSpan()
span?.setAttribute('order.customer_id', call.request.getCustomerId())
const order = await processOrder(call.request)
callback(null, order)
},
})
// client.ts — instrument outbound calls
import { tigeropsClientInterceptor } from '@tigerops/grpc-js'
const channel = new grpc.Channel('localhost:50051',
grpc.credentials.createInsecure(),
{ interceptors: [tigeropsClientInterceptor()] } // <-- add interceptor
)
const client = new OrderServiceClient('localhost:50051',
grpc.credentials.createInsecure(),
{ channelOverride: channel }
)Common Questions
Which gRPC versions and languages are supported?
gRPC-Go 1.60+, grpc-java 1.60+, @grpc/grpc-js 1.9+, grpcio 1.59+ (Python), and tonic 0.11+ (Rust) are all fully supported. The interceptor API follows each language's idiomatic interceptor pattern so no wrapper types are needed.
How does TigerOps handle gRPC-Web calls from browsers?
The gRPC-Web proxy (Envoy or grpc-gateway) passes W3C traceparent headers through to the backend gRPC server as metadata. TigerOps reads these on the server side and links browser-originated calls to server-side spans correctly.
Can I redact sensitive fields from request messages captured in spans?
TigerOps does not capture request or response message contents by default. To record specific non-sensitive fields, use the interceptor's spanEnricher callback to extract field values from the request message and add them as span attributes manually.
How does TigerOps instrument reflection-based gRPC services using protobuf descriptors?
Reflection-based services (using grpc.ServerReflection) are instrumented identically to code-generated services. The interceptor reads the full method descriptor from the ServerInfo object so service and method names are always fully qualified.
Does TigerOps support gRPC health checks (grpc.health.v1.Health)?
Health check RPCs (/grpc.health.v1.Health/Check and /grpc.health.v1.Health/Watch) are excluded from tracing by default to avoid high-cardinality noise. They can be re-included by setting traceHealthChecks: true in the interceptor options.
Full gRPC Observability Across Every Language
Server and client interceptor traces, metadata propagation, streaming RPC visibility, and deadline monitoring — polyglot tracing out of the box.