The best way to control Claude Code, Codex and more from any computer or phone

main
ts 112 lines 4.54 KB
Raw
1 import * as HostProcess from "@t3tools/shared/HostProcess";
2 import * as HttpObservability from "@t3tools/shared/httpObservability";
3 import { makeLocalFileTracer, makeTraceSink } from "@t3tools/shared/observability";
4 import * as SharedObservability from "@t3tools/shared/observability";
5 import * as OtelEnvironment from "@t3tools/shared/otelEnvironment";
6 import * as Effect from "effect/Effect";
7 import * as Layer from "effect/Layer";
8 import * as References from "effect/References";
9 import * as Tracer from "effect/Tracer";
10 import * as OtlpExporter from "effect/observability/OtlpExporter";
11 import * as OtlpMetrics from "effect/observability/OtlpMetrics";
12 import * as OtlpTracer from "effect/observability/OtlpTracer";
13 import * as Statement from "effect/sql/Statement";
14
15 import * as ServerConfig from "../config.ts";
16 import * as ResourceAttribution from "../resourceTelemetry/ResourceAttribution.ts";
17 import * as ServerLogger from "../serverLogger.ts";
18 import * as BrowserTraceCollector from "./BrowserTraceCollector.ts";
19 import * as HeapAttribution from "./HeapAttribution.ts";
20 import * as OtlpExportFailures from "./OtlpExportFailures.ts";
21
22 export const layer = Layer.unwrap(
23 Effect.gen(function* () {
24 const config = yield* ServerConfig.ServerConfig;
25
26 const traces = config.otlpTracesExport;
27 const metrics = config.otlpMetricsExport;
28 // Keep serialization in context for the browser trace forwarder's exporter.
29 const layerSerialization = SharedObservability.layerOtlpSerialization(traces.protocol);
30 const resource = ServerConfig.otlpResource(config, yield* HostProcess.Hostname);
31 const attribution = yield* ResourceAttribution.ResourceAttribution;
32
33 const layerTraceReferences = Layer.mergeAll(
34 Layer.succeed(Tracer.MinimumTraceLevel, config.traceMinLevel),
35 Layer.succeed(References.TracerTimingEnabled, config.traceTimingEnabled),
36 // Preserve SQL spans while awaiting connections so lock waits can be recorded on them.
37 Layer.succeed(Statement.SpanPropagationEnabled, true),
38 HttpObservability.layer,
39 );
40
41 const layerTracer = Layer.unwrap(
42 Effect.gen(function* () {
43 const sink = yield* makeTraceSink({
44 filePath: config.serverTracePath,
45 maxBytes: config.traceMaxBytes,
46 maxFiles: config.traceMaxFiles,
47 batchWindowMs: config.traceBatchWindowMs,
48 onFlush: (stats) =>
49 attribution.record({
50 component: "server-trace",
51 operation: "append",
52 logicalWriteBytes: stats.logicalWriteBytes,
53 count: stats.count,
54 durationMs: stats.durationMs,
55 }),
56 });
57 const delegate =
58 config.otlpTracesUrl === undefined
59 ? undefined
60 : yield* OtlpTracer.make({
61 url: config.otlpTracesUrl,
62 exportInterval: `${traces.exportIntervalMs} millis`,
63 headers: traces.headers,
64 resource,
65 }).pipe(Effect.provide(OtlpExportFailures.layer("traces")));
66
67 const tracer = yield* makeLocalFileTracer({
68 filePath: config.serverTracePath,
69 maxBytes: config.traceMaxBytes,
70 maxFiles: config.traceMaxFiles,
71 batchWindowMs: config.traceBatchWindowMs,
72 sink,
73 ...(delegate ? { delegate } : {}),
74 });
75
76 const heapAttribution = yield* HeapAttribution.make(tracer);
77 yield* heapAttribution.run;
78
79 return Layer.mergeAll(
80 Layer.succeed(Tracer.Tracer, heapAttribution.tracer),
81 BrowserTraceCollector.layer(sink),
82 );
83 }),
84 ).pipe(Layer.provide(OtlpExporter.layerFlusher), Layer.provideMerge(layerSerialization));
85
86 const metricsLayer =
87 config.otlpMetricsUrl === undefined
88 ? Layer.empty
89 : OtlpMetrics.layer({
90 url: config.otlpMetricsUrl,
91 exportInterval: `${metrics.exportIntervalMs} millis`,
92 headers: metrics.headers,
93 resource,
94 }).pipe(
95 Layer.provide(OtlpExportFailures.layer("metrics")),
96 Layer.provide(SharedObservability.layerOtlpSerialization(metrics.protocol)),
97 );
98
99 const layerOtelWarnings = Layer.effectDiscard(
100 Effect.forEach(config.otelEnvironment.warnings, (warning) => Effect.logWarning(warning)),
101 );
102
103 return layerOtelWarnings.pipe(
104 Layer.provideMerge(
105 Layer.mergeAll(ServerLogger.layer, layerTraceReferences, layerTracer, metricsLayer),
106 ),
107 Layer.provide(
108 OtelEnvironment.layerResourceAttributes(config.otelEnvironment.resourceAttributes),
109 ),
110 );
111 }),
112 );