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

import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, it } from "@effect/vitest";
import { DEFAULT_SIGNAL_EXPORT } 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 Tracer from "effect/Tracer";
import * as NetAddress from "effect/net/NetAddress";
import {
  FetchHttpClient,
  HttpClient,
  HttpClientError,
  HttpClientResponse,
  HttpServer,
  HttpServerRequest,
  HttpServerResponse,
} from "effect/http";
import { describe } from "vite-plus/test";

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

interface PostedRequest {
  readonly url: string;
  readonly headers: Readonly<Record<string, string>>;
  readonly body: string;
  readonly signal: AbortSignal;
}

const checkWith = (
  status: number | null,
  overrides: Partial<ServerConfig.ServerConfig["Service"]> = {},
  httpClientLayer?: Layer.Layer<HttpClient.HttpClient>,
) => {
  const requests: Array<PostedRequest> = [];
  const httpClient = HttpClient.make((request, _url, signal) => {
    requests.push({
      url: request.url,
      headers: request.headers,
      body: request.body._tag === "Uint8Array" ? new TextDecoder().decode(request.body.body) : "",
      signal,
    });
    return status === null
      ? Effect.fail(
          new HttpClientError.HttpClientError({
            reason: new HttpClientError.TransportError({ request }),
          }),
        )
      : Effect.succeed(HttpClientResponse.fromWeb(request, new Response(null, { status })));
  });
  const configLayer = Layer.effect(
    ServerConfig.ServerConfig,
    Effect.gen(function* () {
      const config = yield* ServerConfig.ServerConfig;
      return ServerConfig.make({ ...config, ...overrides });
    }),
  ).pipe(Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-otlp-check-" })));
  const layer = OtlpEndpointCheck.layer.pipe(
    Layer.provide(httpClientLayer ?? Layer.succeed(HttpClient.HttpClient, httpClient)),
    Layer.provide(configLayer),
    Layer.provide(NodeServices.layer),
  );
  return { requests, layer };
};

const check = (input: Parameters<OtlpEndpointCheck.OtlpEndpointCheck["Service"]["check"]>[0]) =>
  Effect.gen(function* () {
    const service = yield* OtlpEndpointCheck.OtlpEndpointCheck;
    return yield* service.check(input);
  });

describe("OtlpEndpointCheck", () => {
  it.effect("keeps T3 credentials paired with each running signal endpoint", () => {
    const signalExport = { ...DEFAULT_SIGNAL_EXPORT, headers: { "x-api-key": "secret" } };
    const { requests, layer } = checkWith(200, {
      otlpTracesUrl: "https://collector.example.com/v1/traces",
      otlpMetricsUrl: "https://collector.example.com/v1/metrics",
      otlpLogsUrl: "https://collector.example.com/v1/logs",
      otlpTracesExport: signalExport,
      otlpMetricsExport: signalExport,
      otlpLogsExport: signalExport,
      otelEnvironment: OtelEnvironment.none,
    });
    return Effect.gen(function* () {
      for (const signal of ["traces", "metrics", "logs"] as const) {
        const runningUrl = `https://collector.example.com/v1/${signal}`;
        yield* check({ signal, url: runningUrl });
        yield* check({ signal, url: "https://elsewhere.example.com/collect" });
        yield* check({ signal, url: `${runningUrl}/other` });
        yield* check({ signal, url: `${runningUrl}?tenant=other` });
      }

      assert.lengthOf(requests, 12);
      requests.forEach((request, index) => {
        if (index % 4 === 0) assert.strictEqual(request.headers["x-api-key"], "secret");
        else assert.isUndefined(request.headers["x-api-key"]);
      });
    }).pipe(Effect.provide(layer));
  });

  it.effect("does not send export credentials when the signal has no running endpoint", () => {
    const { requests, layer } = checkWith(200, {
      otlpLogsUrl: undefined,
      otlpLogsExport: { ...DEFAULT_SIGNAL_EXPORT, headers: { authorization: "Bearer t3" } },
      otelEnvironment: OtelEnvironment.none,
    });
    return Effect.gen(function* () {
      const result = yield* check({ signal: "logs", url: "https://new.example.com/v1/logs" });

      assert.strictEqual(result._tag, "Accepted");
      assert.lengthOf(requests, 1);
      assert.isUndefined(requests[0]?.headers.authorization);
    }).pipe(Effect.provide(layer));
  });

  it.effect("keeps endpoint URLs and credentials out of traces", () => {
    const url = "https://collector.example.com/v1/logs?api_key=query-secret";
    const { requests, layer } = checkWith(200, {
      otlpLogsUrl: url,
      otlpLogsExport: {
        ...DEFAULT_SIGNAL_EXPORT,
        headers: { "x-honeycomb-team": "header-secret" },
      },
      otelEnvironment: OtelEnvironment.none,
    });
    const recorded: Array<unknown> = [];
    const tracer = Tracer.make({
      span: (options) => {
        const span = new Tracer.NativeSpan(options);
        const end = span.end.bind(span);
        span.end = (endTime, exit) => {
          end(endTime, exit);
          recorded.push({ name: span.name, attributes: Object.fromEntries(span.attributes) });
        };
        return span;
      },
    });
    return Effect.gen(function* () {
      yield* check({ signal: "logs", url }).pipe(Effect.withTracer(tracer));

      assert.strictEqual(requests[0]?.headers["x-honeycomb-team"], "header-secret");
      assert.notInclude(JSON.stringify(recorded), "secret");
    }).pipe(Effect.provide(layer));
  });

  it.effect("does not forward credentials through a receiver redirect", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const requests: Array<{ url: string; apiKey: string | undefined }> = [];
        const server = yield* HttpServer.HttpServer;
        yield* server.serve(
          Effect.gen(function* () {
            const request = yield* HttpServerRequest.HttpServerRequest;
            yield* request.text;
            requests.push({ url: request.url, apiKey: request.headers["x-api-key"] });
            return request.url === "/v1/traces"
              ? HttpServerResponse.redirect("/other", { status: 307 })
              : HttpServerResponse.empty({ status: 200 });
          }),
        );
        if (!NetAddress.isInetAddress(server.address)) {
          return yield* Effect.die(new Error("Expected a TCP address"));
        }
        const url = `http://127.0.0.1:${server.address.port}/v1/traces`;
        const { layer } = checkWith(
          200,
          {
            otlpTracesUrl: url,
            otlpTracesExport: { ...DEFAULT_SIGNAL_EXPORT, headers: { "x-api-key": "secret" } },
          },
          FetchHttpClient.layer,
        );
        const result = yield* check({ signal: "traces", url }).pipe(Effect.provide(layer));

        assert.deepStrictEqual(result, { _tag: "Rejected", status: 307 });
        assert.deepStrictEqual(requests, [{ url: "/v1/traces", apiKey: "secret" }]);
      }),
    ).pipe(Effect.provide(NodeHttpServer.layerTest)),
  );

  it.effect("keeps OTEL endpoint credentials off other endpoints", () => {
    const otelUrl = "https://otel.example.com/v1/traces";
    const otelExport = { ...DEFAULT_SIGNAL_EXPORT, headers: { "x-api-key": "secret" } };
    const { requests, layer } = checkWith(200, {
      otlpTracesUrl: otelUrl,
      otlpTracesExport: otelExport,
      otelEnvironment: {
        ...OtelEnvironment.none,
        traces: OtelEnvironment.OtelSignal.Export({
          url: otelUrl,
          variable: "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
          protocol: otelExport.protocol,
          headers: otelExport.headers,
        }),
      },
    });
    return Effect.gen(function* () {
      yield* check({ signal: "traces", url: otelUrl });
      yield* check({ signal: "traces", url: "https://elsewhere.example.com/v1/traces" });

      assert.strictEqual(requests[0]?.headers["x-api-key"], "secret");
      assert.isUndefined(requests[1]?.headers["x-api-key"]);
    }).pipe(Effect.provide(layer));
  });
});