Observability | Roy Gabriel

MCP Servers in Production: Hardening, Backpressure, and Observability (Go)

Sat, 31 Jan 2026 09:00:00 -0500

As-of note: MCP is evolving. This article references the MCP specification versioned 2025-11-25 and related docs; verify details against the current spec before shipping changes. [1][2][4]

Why this matters

Most “agent demos” fail in production for boring reasons: missing timeouts, unbounded concurrency, ambiguous tool interfaces, and logging that accidentally turns into data exfiltration.

An MCP server isn’t “just an integration.” It’s a capability boundary between an LLM host (IDE, desktop app, agent runner) and the real world: files, APIs, databases, tickets, home automation, and anything else you wire up. MCP uses JSON-RPC 2.0 messages over transports like stdio (local) and Streamable HTTP (remote). [1][2][5]

That means an MCP server is:

an API gateway for tools
a policy enforcement point (whether you intended it or not)
a reliability hotspot (tool calls are where latency and failure concentrate)
a security hotspot (tools are where “read” becomes “exfil” and “write” becomes “impact”)

This post is a pragmatic checklist + a set of Go patterns to harden an MCP server so it keeps working when it’s under real load, and remains safe when the model gets “creative.”

TL;DR

Treat tool inputs as untrusted. Validate and constrain everything.
Put budgets everywhere: timeouts, concurrency limits, rate limits, and payload caps.
Build for partial failure: retries, idempotency keys, circuit breaking, fallbacks.
Log like a security engineer: structured, redacted, auditable, and useful. [11]
Instrument with traces/metrics early; “we’ll add telemetry later” is a trap. [13]
Prefer Go for MCP servers because deployment and operational behavior are predictable: single binary, fast startup, structured concurrency via context, and a strong standard library.

A production mental model for MCP servers
Threat model: what actually goes wrong
Hardening layer 1: identity and authorization
Hardening layer 2: tool contracts that resist ambiguity
Hardening layer 3: budgets and backpressure
Hardening layer 4: safe networking and SSRF containment
Hardening layer 5: observability without leaking secrets
Hardening layer 6: versioning and rollout discipline
A production checklist
References

A production mental model for MCP servers

MCP’s docs describe a host (the AI application), a client (connector inside the host), and servers (capabilities/providers). Servers can be “local” (stdio) or “remote” (Streamable HTTP). [2][3]

Here’s the production mental model that matters:

Your MCP server is a tool gateway.
Every tool is effectively an RPC method exposed to an agent. MCP uses JSON-RPC 2.0 semantics for requests/responses/notifications. [1][5]
LLM tool arguments are not trustworthy.
Even if the LLM is “helpful,” arguments can be malformed, overbroad, or dangerous, especially under prompt injection or user-provided hostile input.
The host UI is not a security boundary.
The spec emphasizes user consent and tool safety, but the protocol can’t enforce your policy for you. You still need server-side controls. [1]
Transport changes your blast radius, not your responsibilities.
Stdio reduces network exposure, but doesn’t remove safety requirements. Streamable HTTP adds multi-client/multi-tenant concerns and requires real auth. [2][3]

If you remember nothing else: treat the MCP server like a production API you’d be willing to put on call for.

Threat model: what actually goes wrong

When MCP servers cause incidents, it’s usually one of these:

1) Input ambiguity → destructive actions

A “delete” tool with optional filters
A “run command” tool with free-form strings
A “sync” tool that can touch thousands of objects

Mitigation: schema + semantic validation, safe defaults, two-phase commit patterns (preview then apply), and explicit “danger gates.”

2) Prompt injection → tool misuse

The model can be tricked into calling tools with attacker-provided arguments. If your tool can read internal data or call internal APIs, you’ve created an exfil path.

Mitigation: least privilege, allowlists, strong auth, egress controls, and redaction.

3) SSRF / network pivoting

Any tool that fetches URLs, loads webhooks, or calls dynamic endpoints can be abused to hit internal networks or metadata endpoints. OWASP treats SSRF as a major category for a reason. [10]

Mitigation: deny-by-default networking (CIDR blocks, DNS/IP resolution checks, allowlisted destinations).

4) Unbounded concurrency → resource collapse

Agents can fire tools in parallel. Without limits you’ll blow up:

API quotas
DB connections
CPU/memory
downstream latency

Mitigation: per-tenant rate limiting, concurrency caps, queues, and backpressure.

5) “Helpful logs” → data leak

Tool arguments and tool responses often contain secrets, tokens, or private data. If you log everything, you’ve built an involuntary data lake.

Mitigation: structured + redacted logging, security logging guidelines, and minimal retention. [11][12]

Hardening layer 1: identity and authorization

If you run Streamable HTTP, assume:

multiple clients
untrusted networks
tokens will leak eventually

MCP’s architecture guidance recommends standard HTTP authentication methods and mentions OAuth as a recommended way to obtain tokens for remote servers. [2][3]

Practical rules

Authenticate every request.
Use bearer tokens or mTLS depending on environment.
Authorize per tool.
“Authenticated” ≠ “allowed to run delete_everything”.
Prefer short-lived tokens and rotate them. [12]
Multi-tenant? Put the tenant identity into:
- auth token claims, or
- an explicit, validated tenant header (signed), then
- enforce it everywhere.

Go pattern: a minimal auth middleware skeleton (HTTP transport)

This is not a full MCP implementation, just the hardening pattern you’ll wrap around your MCP handler.

// Pseudocode-ish middleware skeleton. Replace verifyToken with your auth logic.
func authMiddleware(next http.Handler) http.Handler {
 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 token := strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")
 if token == "" {
 http.Error(w, "missing auth", http.StatusUnauthorized)
 return
 }

 ident, err := verifyToken(r.Context(), token) // includes tenant + scopes
 if err != nil {
 http.Error(w, "invalid auth", http.StatusUnauthorized)
 return
 }

 ctx := context.WithValue(r.Context(), ctxKeyIdentity{}, ident)
 next.ServeHTTP(w, r.WithContext(ctx))
 })
}

Key point: authorization should happen after you parse the requested tool name, but before you execute anything.

Hardening layer 2: tool contracts that resist ambiguity

Most MCP tool failures are self-inflicted: tool interfaces are too vague.

Design tools like production APIs

Bad tool signature:

run(command: string)

Better:

run_command(program: enum, args: string[], cwd: string, timeout_ms: int, dry_run: bool)

Why it’s better:

forces structure
allows you to enforce allowlists
gives you timeouts and safe defaults

Add a “preview → apply” flow for risky tools

For any tool that writes data or triggers side effects, do a two-step approach:

plan_* returns a machine-readable plan + a plan_id
apply_* requires plan_id and optional user confirmation token

This mirrors how we run infra changes (plan/apply) and dramatically reduces accidental blast radius.

Hardening layer 3: budgets and backpressure

Production systems are budget systems.

If you don’t set explicit budgets, your MCP server will eventually allocate them for you via outages.

Budget checklist

Server timeouts (header read, request read, write, idle)
Request body caps
Outbound timeouts to dependencies
Concurrency caps per tool and per tenant
Rate limits per tenant and per identity
Queue limits (bounded channels) to avoid memory blowups
Circuit breaking for flaky downstream dependencies

Go: server timeouts are not optional

Go’s net/http provides explicit server timeouts; leaving them at zero is a common footgun. [6][7]

srv := &http.Server{
 Addr: ":8080",
 Handler: handler, // your MCP handler + middleware
 ReadHeaderTimeout: 5 * time.Second,
 ReadTimeout: 30 * time.Second,
 WriteTimeout: 30 * time.Second,
 IdleTimeout: 60 * time.Second,
}
log.Fatal(srv.ListenAndServe())

Go: propagate cancellation everywhere with `context`

context.Context is the backbone of “structured concurrency” in Go: deadlines and cancellation signals flow through your call stack. [8][9]

Rule: every tool execution must accept a context.Context, and every outbound call must honor it.

func (s *Server) toolCall(ctx context.Context, req ToolRequest) (ToolResponse, error) {
 ctx, cancel := context.WithTimeout(ctx, 15*time.Second)
 defer cancel()

 // ... outbound calls use ctx
 return s.integration.Do(ctx, req)
}

Go: per-tenant rate limiting with `x/time/rate`

golang.org/x/time/rate implements a token bucket limiter. [9]

type limiters struct {
 mu sync.Mutex
 m map[string]*rate.Limiter
}

func (l *limiters) get(key string) *rate.Limiter {
 l.mu.Lock()
 defer l.mu.Unlock()
 if l.m == nil { l.m = map[string]*rate.Limiter{} }
 if lim, ok := l.m[key]; ok { return lim }

 // Example: 5 req/sec with bursts up to 10
 lim := rate.NewLimiter(5, 10)
 l.m[key] = lim
 return lim
}

func rateLimitMiddleware(lims *limiters, next http.Handler) http.Handler {
 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 ident := mustIdentity(r.Context())
 if !lims.get(ident.TenantID).Allow() {
 http.Error(w, "rate limited", http.StatusTooManyRequests)
 return
 }
 next.ServeHTTP(w, r)
 })
}

Backpressure: choose a policy

When you’re overloaded, you need a policy. Pick one explicitly:

Fail fast with 429 / “busy” (simplest, safest)
Queue with bounded depth (more complex; must cap memory)
Degrade by disabling expensive tools first

The “fail fast” approach is often correct for tool gateways.

Hardening layer 4: safe networking and SSRF containment

If any tool can fetch a user-provided URL or call a user-influenced endpoint, SSRF is on the table. [10]

SSRF containment strategies that actually work

OWASP’s SSRF guidance boils down to a few themes: don’t trust user-controlled URLs, use allowlists, and enforce network controls. [10]

In practice, for MCP servers:

Prefer allowlists over blocklists.
“Only these domains” beats “block internal IPs.” Attackers are creative.
Resolve and validate IPs before dialing.
DNS can be weaponized. Validate the final destination IP (and re-validate on redirects).
Disable redirects or re-validate each hop.
Redirect chains are SSRF’s favorite tool.
Enforce egress policy at the network layer too.
Kubernetes NetworkPolicies / firewall rules are your last line of defense.

Go pattern: an outbound HTTP client with strict timeouts

client := &http.Client{
 Timeout: 10 * time.Second, // whole request budget
 Transport: &http.Transport{
 Proxy: http.ProxyFromEnvironment,
 DialContext: (&net.Dialer{
 Timeout: 5 * time.Second,
 KeepAlive: 30 * time.Second,
 }).DialContext,
 TLSHandshakeTimeout: 5 * time.Second,
 ResponseHeaderTimeout: 5 * time.Second,
 ExpectContinueTimeout: 1 * time.Second,
 MaxIdleConns: 100,
 IdleConnTimeout: 90 * time.Second,
 },
}

Then wrap URL validation around any request creation. Keep it boring and strict.

Hardening layer 5: observability without leaking secrets

Telemetry is how you prove:

you’re within budgets
tools behave as expected
failures are localized
incidents can be diagnosed without “ssh and guess”

But logging is also where teams accidentally leak sensitive data.

OWASP’s logging guidance emphasizes logging that supports detection/response while avoiding sensitive data exposure. [11] Pair that with secrets management discipline. [12]

What to measure (minimum viable MCP telemetry)

Counters

tool_calls_total{tool, tenant, status}
auth_failures_total{reason}
rate_limited_total{tenant}

Histograms

tool_latency_seconds{tool}
outbound_latency_seconds{dependency}

Gauges

in_flight_tool_calls{tool}
queue_depth{tool}

Trace boundaries

Instrument:

request → tool routing
tool execution span
downstream calls span

OpenTelemetry’s Go docs show how to add instrumentation and emit traces/metrics. [13]

Logging rules that save you later

Use structured logging (JSON).
Add correlation IDs (trace IDs) to logs.
Redact:
- Authorization headers
- tokens
- cookies
- tool payload fields known to contain secrets
Log events, not raw payloads:
- “tool X called”
- “resource Y read”
- “write operation requested (dry_run=true)”

Audit logs

For high-impact tools, write an append-only audit record:
- who (identity)
- what (tool + parameters summary)
- when
- result (success/failure)
- plan_id / idempotency_key

Audit logs should be treated as security data.

Hardening layer 6: versioning and rollout discipline

MCP uses string-based version identifiers like YYYY-MM-DD to represent the last date of backwards-incompatible changes. [4]

That’s helpful, but it doesn’t solve the operational problem:

clients upgrade at different times
schema changes drift
hosts differ in which capabilities they support

Practical compatibility rules

Pin your server’s supported protocol version and expose it in health or diagnostics.
Add contract tests that run against:
- one “current” client
- one “previous” client version
Support additive changes first:
- new tools
- new optional fields
Use feature flags for risky tools.

Rollout like a platform team

Canaries for remote servers
“Shadow mode” for new tools (log what would happen)
Slow ramp with budget monitoring

A production checklist

If you’re building (or inheriting) an MCP server, run this checklist:

Safety

Tool contracts are structured (no free-form “do anything” strings).
Every tool has a safe default (dry_run=true, limit required, etc.).
Destructive tools require a plan/apply step (or explicit confirmation gates).
Tool inputs are validated and bounded (length, ranges, enums).

Identity & access

Remote transport requires authentication and per-tool authorization.
Tokens are short-lived and rotated; secrets are not in source control. [12]
Tenant identity is enforced at every access point (not “best effort”).

Budgets & resilience

HTTP server timeouts are configured. [6][7]
Outbound clients have timeouts and connection limits.
Rate limiting exists per tenant/identity. [9]
Concurrency caps exist per tool; overload behavior is explicit (fail fast / queue).
Retries are bounded and idempotent where side effects exist.

Networking

URL fetch tools have allowlists and SSRF protections. [10]
Redirect policies are explicit (disabled or re-validated).
Egress is constrained at the network layer (not only in code).

Observability

Metrics cover tool calls, latency, errors, and rate limiting.
Tracing exists across tool execution and downstream calls. [13]
Logs are structured, correlated, and redacted. [11]
Audit logging exists for high-impact tools.

Operations

Health checks and readiness checks exist.
Configuration is explicit and validated on startup.
Versioning strategy is documented and tested. [4]

References

Model Context Protocol (MCP) Specification (version 2025-11-25): https://modelcontextprotocol.io/specification/2025-11-25
MCP Architecture Overview (participants, transports, concepts): https://modelcontextprotocol.io/docs/learn/architecture
MCP Transport details (Streamable HTTP transport overview): https://modelcontextprotocol.io/specification/2025-03-26/basic/transports
MCP Versioning: https://modelcontextprotocol.io/specification/versioning
JSON-RPC 2.0 Specification: https://www.jsonrpc.org/specification
Go net/http package documentation: https://pkg.go.dev/net/http
Cloudflare: “The complete guide to Go net/http timeouts”: https://blog.cloudflare.com/the-complete-guide-to-golang-net-http-timeouts/
Go context package documentation: https://pkg.go.dev/context
Go x/time/rate documentation: https://pkg.go.dev/golang.org/x/time/rate
OWASP SSRF Prevention Cheat Sheet / SSRF category references:

OWASP Logging Cheat Sheet (security-focused logging guidance): https://cheatsheetseries.owasp.org/cheatsheets/Logging_Cheat_Sheet.html
Secrets management guidance:

OWASP Secrets Management Cheat Sheet: https://cheatsheetseries.owasp.org/cheatsheets/Secrets_Management_Cheat_Sheet.html
Kubernetes “Good practices for Kubernetes Secrets”: https://kubernetes.io/docs/concepts/security/secrets-good-practices/

OpenTelemetry Go instrumentation docs: https://opentelemetry.io/docs/languages/go/instrumentation/

Agent Observability That Doesn't Lie

Sat, 20 Dec 2025 12:00:00 -0500

Why this matters

Most “agent observability” is either:

too shallow (a chat transcript and a couple logs), or
too noisy (every token logged, every tool payload stored, no signal)

Neither works in production.

If you’re serious about operating agents, you need observability that answers three questions quickly:

What happened? (forensics)
Why did it happen? (debuggability)
How often does it happen? (reliability)

OpenTelemetry exists to standardize how you instrument, generate, and export telemetry across traces, metrics, and logs. [1] W3C Trace Context defines how trace context propagates across service boundaries. [2]

Agents add two new requirements:

tool calls are part of your “distributed trace”
“decisioning” is a first-class component (not just business logic)

This article is a practical blueprint.

TL;DR

Instrument agents like distributed systems:
traces for causality (what triggered what)
metrics for health (p95 latency, error rates)
logs for human context (but redacted)
Propagate a single trace across:
agent runtime -> MCP gateway -> MCP tool servers -> upstream APIs
Capture decision summaries, not chain-of-thought.
Treat cost as a production signal: emit per-run and per-tool cost metrics.
Use semantic conventions where possible to keep telemetry queryable. [3]
Don’t turn observability into a data breach: OWASP highlights sensitive info disclosure and prompt injection as key risks. [7]

What to observe in an agent system
A trace model for agents
Metrics that matter
Logs and redaction
Audit events vs debug logs
Dashboards and alerts
A production checklist
References

What to observe in an agent system

Agents have four observable subsystems:

Planner/Reasoner (creates the plan, chooses tools)
Tool execution (calls MCP tools and interprets results)
Memory/state (what was stored or retrieved)
Policy/budget (what was allowed or blocked)

If you only observe #2, you’ll miss why the agent chose the wrong tool. If you only observe #1, you’ll miss production failures.

You need the full chain.

A trace model for agents

The core idea

A single “agent run” is a distributed trace:

it spans model calls
tool calls
downstream system calls

Use W3C Trace Context (traceparent, tracestate) to propagate the trace across boundaries. [2]

Suggested spans (minimum viable)

Root span

agent.run
attributes: agent.name, tenant, user, session, goal_hash

Planner

agent.plan
attributes: planner.model, plan.step_count

Model calls

llm.call
attributes: model, prompt_tokens, completion_tokens, latency_ms

Tool selection

agent.tool_select
attributes: selector.version, candidate_count, selected_count

Tool call

tool.call
attributes: tool.name, tool.class (read/write/danger), tool.server, status

Policy

policy.check
attributes: policy.rule_id, decision (allow/deny), reason_code

Memory

memory.read / memory.write
attributes: store, keys, bytes

Why spans > logs

Spans give you causality:

which tool call caused a failure
which step blew the budget
which upstream dependency was slow

With OpenTelemetry, you can emit traces and metrics using the same SDK approach. [1][4]

Metrics that matter

Tool health metrics

tool_calls_total{tool,status}
tool_latency_ms_bucket{tool}
tool_timeouts_total{tool}
tool_retries_total{tool}

Agent run health metrics

agent_runs_total{status}
agent_run_latency_ms_bucket{agent}
agent_steps_total_bucket{agent}

Cost metrics (treat cost like reliability)

llm_tokens_total{model,type=prompt|completion}
llm_cost_usd_total{model}
run_cost_usd_bucket{agent}

Policy metrics

policy_denied_total{rule_id}
danger_tool_attempt_total{tool}

Semantic conventions help your metrics stay queryable and consistent across systems. OpenTelemetry documents semantic conventions for HTTP spans/metrics, for example. [3][5]

Logs and redaction

Logs should add human context, not become a data lake of secrets.

Rules I like:

Do not log prompts by default.
Do not log tool payloads by default.
Log summaries and hashes:
goal_hash, plan_hash, tool_args_hash
Log structured error reasons:
validation_error, upstream_rate_limited, auth_failed, policy_denied

For agent systems, OWASP highlights sensitive information disclosure and insecure output handling. Logging is one of the easiest ways to accidentally create both. [7]

“Debug mode” that isn’t dangerous

If you must support deeper logs:

only enable per tenant/user for a limited window
auto-expire
redact aggressively
never store raw secrets

Audit events vs debug logs

Treat them as different products:

Audit events (for governance)

immutable-ish records of side effects
minimal sensitive data
always on
long retention

Example audit fields:

who: tenant/user/client
what: tool + action class (create/update/delete)
when: timestamp
where: environment
result: success/failure
resource IDs (safe identifiers)
idempotency keys / plan IDs

Debug logs (for engineers)

short retention
more context
highly controlled access

Mixing these two is how you end up with “SharePoint logs full of PII” and no one wants to touch them.

Dashboards and alerts

Dashboards (start simple)

Tool reliability

top tools by error rate
top tools by p95 latency
timeouts per tool

Agent success

success rate by agent type
“stuck runs” (runs exceeding max duration)
average steps per run

Cost

cost per run
cost per tenant
top drivers (which tools/model calls)

Alerts (avoid noise)

Alert on what is actionable:

tool error rate spikes for critical tools
tool latency p95 spikes beyond SLO
budget exceeded spike (runaway behavior)
policy denied spike (possible prompt injection attempt)

If you use SLOs and error budgets, Google’s SRE material is a practical reference for turning SLOs into alerting strategies. [6]

A production checklist

Tracing

Every agent run has a trace ID.
Trace context propagates across MCP boundaries (W3C Trace Context). [2]
Tool calls are spans with stable tool identifiers.

Metrics

Tool success/error/latency metrics exist.
Agent run success/latency/steps metrics exist.
Cost metrics exist and are monitored.

Logging

Default logs are redacted summaries, not raw payloads.
Debug logging is time-bounded and access-controlled.

Audit

Audit events exist for all side-effecting tools.
Audit records include “who/what/when/result” without leaking secrets.

Security

Observability does not become a secret exfil path (OWASP risks considered). [7]

References

[1] OpenTelemetry - Documentation (overview): https://opentelemetry.io/docs/ [2] W3C - Trace Context: https://www.w3.org/TR/trace-context/ [3] OpenTelemetry - Semantic conventions for HTTP (spans/metrics/logs): https://opentelemetry.io/docs/specs/semconv/http/ [4] OpenTelemetry Go - Instrumentation docs: https://opentelemetry.io/docs/languages/go/instrumentation/ [5] OpenTelemetry - Semantic conventions for HTTP metrics: https://opentelemetry.io/docs/specs/semconv/http/http-metrics/ [6] Google SRE Workbook - Alerting on SLOs: https://sre.google/workbook/alerting-on-slos/ [7] OWASP - Top 10 for Large Language Model Applications: https://owasp.org/www-project-top-10-for-large-language-model-applications/

Observability | Roy Gabriel

MCP Servers in Production: Hardening, Backpressure, and Observability (Go)

Why this matters

TL;DR

Contents

A production mental model for MCP servers

Threat model: what actually goes wrong

1) Input ambiguity → destructive actions

2) Prompt injection → tool misuse

3) SSRF / network pivoting

4) Unbounded concurrency → resource collapse

5) “Helpful logs” → data leak

Hardening layer 1: identity and authorization

Practical rules

Go pattern: a minimal auth middleware skeleton (HTTP transport)

Hardening layer 2: tool contracts that resist ambiguity

Design tools like production APIs

Add a “preview → apply” flow for risky tools

Hardening layer 3: budgets and backpressure

Budget checklist

Go: server timeouts are not optional

Go: propagate cancellation everywhere with context

Go: per-tenant rate limiting with x/time/rate

Backpressure: choose a policy

Hardening layer 4: safe networking and SSRF containment

SSRF containment strategies that actually work

Go pattern: an outbound HTTP client with strict timeouts

Hardening layer 5: observability without leaking secrets

What to measure (minimum viable MCP telemetry)

Trace boundaries

Logging rules that save you later

Hardening layer 6: versioning and rollout discipline

Practical compatibility rules

Rollout like a platform team

A production checklist

Safety

Identity & access

Budgets & resilience

Networking

Observability

Operations

References

Agent Observability That Doesn't Lie

Why this matters

TL;DR

Contents

What to observe in an agent system

A trace model for agents

The core idea

Suggested spans (minimum viable)

Why spans > logs

Metrics that matter

Tool health metrics

Agent run health metrics

Cost metrics (treat cost like reliability)

Policy metrics

Logs and redaction

“Debug mode” that isn’t dangerous

Audit events vs debug logs

Audit events (for governance)

Debug logs (for engineers)

Dashboards and alerts

Dashboards (start simple)

Alerts (avoid noise)

A production checklist

Tracing

Metrics

Logging

Audit

Security

References

Go: propagate cancellation everywhere with `context`

Go: per-tenant rate limiting with `x/time/rate`