import * as HostProcess from "@t3tools/shared/HostProcess";
import * as HttpObservability from "@t3tools/shared/httpObservability";
import { makeLocalFileTracer, makeTraceSink } from "@t3tools/shared/observability";
import * as SharedObservability from "@t3tools/shared/observability";
import * as OtelEnvironment from "@t3tools/shared/otelEnvironment";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as References from "effect/References";
import * as Tracer from "effect/Tracer";
import * as OtlpExporter from "effect/observability/OtlpExporter";
import * as OtlpMetrics from "effect/observability/OtlpMetrics";
import * as OtlpTracer from "effect/observability/OtlpTracer";
import * as Statement from "effect/sql/Statement";
import * as ServerConfig from "../config.ts";
import * as ResourceAttribution from "../resourceTelemetry/ResourceAttribution.ts";
import * as ServerLogger from "../serverLogger.ts";
import * as BrowserTraceCollector from "./BrowserTraceCollector.ts";
import * as HeapAttribution from "./HeapAttribution.ts";
export const layer = Layer.unwrap(
Effect.gen(function* () {
const config = yield* ServerConfig.ServerConfig;
const traces = config.otlpTracesExport;
const metrics = config.otlpMetricsExport;
// Keep serialization in context for the browser trace forwarder's exporter.
const layerSerialization = SharedObservability.layerOtlpSerialization(traces.protocol);
const resource = ServerConfig.otlpResource(config, yield* HostProcess.Hostname);
const attribution = yield* ResourceAttribution.ResourceAttribution;
const layerTraceReferences = Layer.mergeAll(
Layer.succeed(Tracer.MinimumTraceLevel, config.traceMinLevel),
Layer.succeed(References.TracerTimingEnabled, config.traceTimingEnabled),
// Preserve SQL spans while awaiting connections so lock waits can be recorded on them.
Layer.succeed(Statement.SpanPropagationEnabled, true),
HttpObservability.layer,
);
const layerTracer = Layer.unwrap(
Effect.gen(function* () {
const sink = yield* makeTraceSink({
filePath: config.serverTracePath,
maxBytes: config.traceMaxBytes,
maxFiles: config.traceMaxFiles,
batchWindowMs: config.traceBatchWindowMs,
onFlush: (stats) =>
attribution.record({
component: "server-trace",
operation: "append",
logicalWriteBytes: stats.logicalWriteBytes,
count: stats.count,
durationMs: stats.durationMs,
}),
});
const delegate =
config.otlpTracesUrl === undefined
? undefined
: yield* OtlpTracer.make({
url: config.otlpTracesUrl,
exportInterval: `${traces.exportIntervalMs} millis`,
headers: traces.headers,
resource,
});
const tracer = yield* makeLocalFileTracer({
filePath: config.serverTracePath,
maxBytes: config.traceMaxBytes,
maxFiles: config.traceMaxFiles,
batchWindowMs: config.traceBatchWindowMs,
sink,
...(delegate ? { delegate } : {}),
});
const heapAttribution = yield* HeapAttribution.make(tracer);
yield* heapAttribution.run;
return Layer.mergeAll(
Layer.succeed(Tracer.Tracer, heapAttribution.tracer),
BrowserTraceCollector.layer(sink),
);
}),
).pipe(Layer.provide(OtlpExporter.layerFlusher), Layer.provideMerge(layerSerialization));
const metricsLayer =
config.otlpMetricsUrl === undefined
? Layer.empty
: OtlpMetrics.layer({
url: config.otlpMetricsUrl,
exportInterval: `${metrics.exportIntervalMs} millis`,
headers: metrics.headers,
resource,
}).pipe(Layer.provide(SharedObservability.layerOtlpSerialization(metrics.protocol)));
const layerOtelWarnings = Layer.effectDiscard(
Effect.forEach(config.otelEnvironment.warnings, (warning) => Effect.logWarning(warning)),
);
return layerOtelWarnings.pipe(
Layer.provideMerge(
Layer.mergeAll(ServerLogger.layer, layerTraceReferences, layerTracer, metricsLayer),
),
Layer.provide(
OtelEnvironment.layerResourceAttributes(config.otelEnvironment.resourceAttributes),
),
);
}),
);