Two ways in. Neither of them rewrites your service.

# not on npm yet — install from the repository
git clone https://github.com/dwarka-prasad/optictrace
npm install ./optictrace/sdks/express

const express = require('express');
const optictrace = require('@optictrace/express');

const app = express();
app.use(optictrace({
  configPath: 'optic.yaml',
  agentUrl: 'http://localhost:9095',   // omit to log JSON to stdout
}));
app.use(express.json());                // AFTER optictrace

Mount it before your body parser. The middleware tees the raw request stream; a parser that has already consumed it leaves nothing to capture.

Log lines, filed under the request that wrote them:

const { LogShipper } = require('@optictrace/express');
const log = new LogShipper('http://localhost:9095', 'checkout');

log.info('charge captured', { amount: 129.0 });
// delivery is counted, not assumed: log.sent / log.failed / log.dropped

And a call this service makes downstream:

const headers = { ...optictrace.outboundHeaders() };
await fetch(url, { headers });   // carries THIS hop's span, so the next nests under it

Rules hot-reload on kill -HUP <pid>, mirroring the agent.

# not on PyPI yet — pip installs it straight from the subdirectory
pip install "git+https://github.com/dwarka-prasad/optictrace#subdirectory=sdks/fastapi"

from fastapi import FastAPI
from optictrace_fastapi import OpticTraceMiddleware

app = FastAPI()
app.add_middleware(
    OpticTraceMiddleware,
    config_path="optic.yaml",
    agent_url="http://localhost:9095",   # omit to log JSON to stdout
)

Logging and downstream propagation:

import logging
from optictrace_fastapi import OpticTraceLogHandler, outbound_headers

logging.getLogger().addHandler(
    OpticTraceLogHandler("http://localhost:9095", "checkout"))

# a downstream call carries this hop's span
httpx.post(url, headers=outbound_headers(), json=payload)

It is pure ASGI — no FastAPI import inside the middleware — so Starlette, Litestar or a hand-rolled ASGI app all work the same way.

A plain jakarta.servlet.Filter, so anything on Servlet 5+ can use it. Not on Maven Central yet — build it into your local repository first:

git clone https://github.com/dwarka-prasad/optictrace
(cd optictrace/sdks/java && mvn install -DskipTests)

<dependency>
  <groupId>io.github.dwarka-prasad</groupId>
  <artifactId>optictrace-servlet</artifactId>
  <version>0.10.1</version>
</dependency>

@Bean
FilterRegistrationBean<OpticTraceFilter> optictrace() throws IOException {
    var f = new OpticTraceFilter("optic.yaml", "http://localhost:9095", "checkout");
    var reg = new FilterRegistrationBean<>(f);
    reg.setOrder(Ordered.HIGHEST_PRECEDENCE);   // see the bytes the client sent
    reg.addUrlPatterns("/*");
    return reg;
}

Logging and downstream propagation:

Logger parent = Logger.getLogger("com.example.shop");
parent.setLevel(Level.FINE);        // see the note below
parent.addHandler(new OpticTraceLogHandler("http://localhost:9095", "checkout"));

// on an outbound call
HttpHeaders h = new HttpHeaders();
TraceContext.outboundHeaders().forEach(h::set);

java.util.logging filters on the logger level before a handler is consulted, and its default is INFO. Without raising it, debug lines are never shipped — and the setup looks like it is working, because everything at info and above arrives normally.

Spring Boot 2 / Tomcat 9 need the javax.servlet variant. It is generated rather than kept as a second copy — two copies of one engine drift, and the copy nobody runs is the one that drifts:

(cd sdks/java && ./scripts/gen-javax.sh)   # -> target/javax-src

The Go path is not a reimplementation: it is the agent’s own interceptor exposed as middleware, so it inherits every feature the proxy has by construction.

go get github.com/dwarka-prasad/optictrace

import (
    "github.com/dwarka-prasad/optictrace"
    optictracegin "github.com/dwarka-prasad/optictrace/sdks/gin"   // Gin only
)

agent, err := optictrace.New("optic.yaml")
if err != nil { log.Fatal(err) }
defer agent.Close()
agent.ServeAdmin("ui/out")   // dashboard + /metrics on the admin port

// net/http
http.ListenAndServe(":8080", agent.Middleware(mux))

// Gin
r.Use(optictracegin.Middleware(agent))

Logging and downstream propagation:

logger := slog.New(optictrace.NewLogHandler("http://localhost:9095", "checkout", nil))
logger.InfoContext(ctx, "charge captured", "amount", 129.0)

for k, v := range optictrace.OutboundHeaders(ctx) { req.Header.Set(k, v) }

Use slog’s ...Context variants. A plain logger.Info() passes context.Background(), which carries no span, so those lines arrive as orphans and the agent drops them by default.