sailfork / t3code-github / apps/ server/ src/ observability/ OtlpEndpointCheck.ts

import type {
  OtlpEndpointCheckInput,
  OtlpEndpointCheckResult,
  OtlpSignal,
} from "@t3tools/contracts";
import { layerOtlpSerialization } from "@t3tools/shared/observability";
import * as Clock from "effect/Clock";
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import { FetchHttpClient, HttpClient } from "effect/http";
import { OtlpSerialization } from "effect/observability";

import * as ServerConfig from "../config.ts";

const CHECK_TIMEOUT = "5 seconds";

export class OtlpEndpointCheck extends Context.Service<
  OtlpEndpointCheck,
  {
    readonly check: (input: OtlpEndpointCheckInput) => Effect.Effect<OtlpEndpointCheckResult>;
  }
>()("t3/observability/OtlpEndpointCheck") {}

const emptyExport = (
  serialization: OtlpSerialization.OtlpSerialization["Service"],
  signal: OtlpSignal,
) => {
  switch (signal) {
    case "traces":
      return serialization.traces({ resourceSpans: [] });
    case "metrics":
      return serialization.metrics({ resourceMetrics: [] });
    case "logs":
      return serialization.logs({ resourceLogs: [] });
  }
};

const make = Effect.gen(function* () {
  const config = yield* ServerConfig.ServerConfig;
  const httpClient = yield* HttpClient.HttpClient;

  const running = {
    traces: { url: config.otlpTracesUrl, export: config.otlpTracesExport },
    metrics: { url: config.otlpMetricsUrl, export: config.otlpMetricsExport },
    logs: { url: config.otlpLogsUrl, export: config.otlpLogsExport },
  } satisfies Record<OtlpSignal, unknown>;

  const check = Effect.fn("OtlpEndpointCheck.check")(function* ({
    signal,
    url,
  }: OtlpEndpointCheckInput) {
    const { url: runningUrl, export: signalExport } = running[signal];
    const headers = url === runningUrl ? signalExport.headers : undefined;
    const body = yield* Effect.gen(function* () {
      const serialization = yield* OtlpSerialization.OtlpSerialization;
      return emptyExport(serialization, signal);
    }).pipe(Effect.provide(layerOtlpSerialization(signalExport.protocol)));
    const startedAt = yield* Clock.currentTimeMillis;
    // Close after reading status so open bodies cannot hang; disable tracing to keep URLs and credentials out of spans.
    const response = yield* HttpClient.withScope(httpClient)
      .post(url, { body, headers })
      .pipe(
        Effect.map(({ status }) => ({ status })),
        Effect.scoped,
        Effect.provideService(FetchHttpClient.RequestInit, { redirect: "manual" }),
        Effect.withTracerEnabled(false),
        Effect.timeoutOption(CHECK_TIMEOUT),
        Effect.option,
      );
    if (Option.isNone(response)) {
      return { _tag: "Unreachable", timedOut: false } as const;
    }
    if (Option.isNone(response.value)) {
      return { _tag: "Unreachable", timedOut: true } as const;
    }
    const { status } = response.value.value;
    if (status < 200 || status >= 300) {
      return { _tag: "Rejected", status } as const;
    }
    const latencyMs = (yield* Clock.currentTimeMillis) - startedAt;
    return { _tag: "Accepted", latencyMs } as const;
  });

  return OtlpEndpointCheck.of({ check });
});

export const layer = Layer.effect(OtlpEndpointCheck, make);