sailfork / t3code-github / .repos/ effect/ packages/ opentelemetry/ test/ OtelLogger.test.ts

import * as NodeSdk from "@effect/opentelemetry/NodeSdk"
import * as OtelLogger from "@effect/opentelemetry/OtelLogger"
import * as OtelTracer from "@effect/opentelemetry/OtelTracer"
import * as Resource from "@effect/opentelemetry/Resource"
import { assert, describe, it } from "@effect/vitest"
import * as OtelApi from "@opentelemetry/api"
import { SeverityNumber } from "@opentelemetry/api-logs"
import { AsyncHooksContextManager } from "@opentelemetry/context-async-hooks"
import { InMemoryLogRecordExporter, type LogRecordProcessor, SimpleLogRecordProcessor } from "@opentelemetry/sdk-logs"
import { InMemorySpanExporter, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base"
import * as Cause from "effect/Cause"
import * as Clock from "effect/Clock"
import * as ConfigProvider from "effect/ConfigProvider"
import * as Context from "effect/Context"
import * as Effect from "effect/Effect"
import * as Layer from "effect/Layer"
import * as References from "effect/References"
import { TestClock } from "effect/testing"
import * as Tracer from "effect/Tracer"
import * as Version from "effect/Version"

describe("Logger", () => {
  const makeTestLayer = (exporter: InMemoryLogRecordExporter) =>
    NodeSdk.layer(Effect.sync(() => ({
      resource: { serviceName: "test", serviceVersion: "service-version" },
      logRecordProcessor: [new SimpleLogRecordProcessor({ exporter })]
    })))

  it.effect("adds SDK resource defaults when the resource comes only from the environment", () => {
    const exporter = new InMemoryLogRecordExporter()
    return Effect.gen(function*() {
      yield* Effect.log("test")
      const record = exporter.getFinishedLogRecords()[0]!
      assert.strictEqual(record.instrumentationScope.name, "effect")
      assert.strictEqual(record.instrumentationScope.version, Version.getCurrentVersion())
      assert.deepStrictEqual(record.resource.attributes, {
        "service.name": "env-service",
        "telemetry.sdk.name": "@effect/opentelemetry",
        "telemetry.sdk.language": "nodejs",
        "telemetry.sdk.version": Version.getCurrentVersion()
      })
    }).pipe(
      Effect.provide(NodeSdk.layer(() => ({ logRecordProcessor: [new SimpleLogRecordProcessor({ exporter })] }))),
      Effect.provideService(
        ConfigProvider.ConfigProvider,
        ConfigProvider.fromEnv({ env: { OTEL_SERVICE_NAME: "env-service" } })
      )
    )
  })

  it.effect("namespaces generated attributes and lets them override annotations", () => {
    const exporter = new InMemoryLogRecordExporter()
    return Effect.gen(function*() {
      const fiber = yield* Effect.fiber
      yield* Effect.gen(function*() {
        yield* TestClock.adjust("5 millis")
        yield* Effect.logError(
          "boom",
          Cause.fail(new TypeError("cause message", { cause: new Error("nested failure") }))
        )
      }).pipe(
        Effect.withLogSpan("op"),
        Effect.annotateLogs({
          "effect.fiberId": -1,
          "effect.log_span.op": -1,
          "exception.type": "annotated type",
          "exception.message": "annotated message",
          "exception.stacktrace": "annotated stack"
        })
      )

      const attributes = exporter.getFinishedLogRecords()[0]!.attributes
      assert.strictEqual(attributes["effect.fiberId"], fiber.id)
      assert.strictEqual(attributes["effect.log_span.op"], 5)
      assert.strictEqual(attributes["exception.type"], "TypeError")
      assert.strictEqual(attributes["exception.message"], "cause message")
      assert.include(attributes["exception.stacktrace"], "nested failure")
    }).pipe(Effect.provide(makeTestLayer(exporter)))
  })

  it.effect("shuts down the logger provider after forceFlush rejects", () =>
    Effect.gen(function*() {
      let shutdowns = 0
      const processor: LogRecordProcessor = {
        onEmit() {},
        forceFlush: () => Promise.reject(new Error("flush failed")),
        shutdown: () => {
          shutdowns++
          return Promise.resolve()
        }
      }
      yield* Effect.exit(
        Effect.scoped(Layer.build(OtelLogger.layerLoggerProvider(processor)).pipe(Effect.provide(Resource.layerEmpty)))
      )
      assert.strictEqual(shutdowns, 1)
    }))

  describe("provided", () => {
    const exporter = new InMemoryLogRecordExporter()

    const TracingLayer = NodeSdk.layer(Effect.sync(() => ({
      resource: {
        serviceName: "test"
      },
      logRecordProcessor: [new SimpleLogRecordProcessor({ exporter })]
    })))

    it.effect("emits log records", () =>
      Effect.gen(function*() {
        yield* Effect.log("test").pipe(
          Effect.repeat({ times: 9 })
        )
        assert.lengthOf(exporter.getFinishedLogRecords(), 10)
        const log = exporter.getFinishedLogRecords()[0]!
        assert.isUndefined(log.spanContext)
        assert.isUndefined(log.attributes.traceId)
        assert.isUndefined(log.attributes.spanId)
      }).pipe(Effect.provide(TracingLayer)))

    it.effect("maps Effect LogLevel to OTel SeverityNumber spec values", () => {
      const severityExporter = new InMemoryLogRecordExporter()
      const SeverityLayer = NodeSdk.layer(Effect.sync(() => ({
        resource: { serviceName: "test" },
        logRecordProcessor: [new SimpleLogRecordProcessor({ exporter: severityExporter })]
      })))

      return Effect.gen(function*() {
        yield* Effect.logTrace("trace")
        yield* Effect.logDebug("debug")
        yield* Effect.logInfo("info")
        yield* Effect.logWarning("warn")
        yield* Effect.logError("error")
        yield* Effect.logFatal("fatal")

        const records = severityExporter.getFinishedLogRecords()
        const byText = Object.fromEntries(records.map((r) => [r.severityText, r.severityNumber]))

        assert.strictEqual(byText.Trace, SeverityNumber.TRACE)
        assert.strictEqual(byText.Debug, SeverityNumber.DEBUG)
        assert.strictEqual(byText.Info, SeverityNumber.INFO)
        assert.strictEqual(byText.Warn, SeverityNumber.WARN)
        assert.strictEqual(byText.Error, SeverityNumber.ERROR)
        assert.strictEqual(byText.Fatal, SeverityNumber.FATAL)
      }).pipe(
        Effect.provide(SeverityLayer.pipe(Layer.provideMerge(Layer.succeed(References.MinimumLogLevel, "Trace"))))
      )
    })

    it.effect("keeps event time separate from observed time and uses wall-clock span time", () => {
      const logExporter = new InMemoryLogRecordExporter()
      const spanExporter = new InMemorySpanExporter()
      const wallTimeNanos = 1_735_689_600_123_456_789n
      const monotonicTimeNanos = 123_456_789n
      const expectedTime: readonly [number, number] = [
        Number(wallTimeNanos / BigInt(1_000_000_000)),
        Number(wallTimeNanos % BigInt(1_000_000_000))
      ]
      const skewedClock: Clock.Clock = {
        currentTimeMillisUnsafe: () => 1,
        currentTimeMillis: Effect.succeed(1),
        currentTimeNanosUnsafe: () => wallTimeNanos,
        currentTimeNanos: Effect.succeed(wallTimeNanos),
        monotonicTimeNanosUnsafe: () => monotonicTimeNanos,
        monotonicTimeNanos: Effect.succeed(monotonicTimeNanos),
        sleep: () => Effect.void
      }

      const TracingLayer = NodeSdk.layer(Effect.sync(() => ({
        resource: {
          serviceName: "test"
        },
        spanProcessor: [new SimpleSpanProcessor(spanExporter)],
        logRecordProcessor: [new SimpleLogRecordProcessor({ exporter: logExporter })]
      })))

      return Effect.gen(function*() {
        yield* Effect.log("test").pipe(
          Effect.withSpan("parent")
        )

        const logs = logExporter.getFinishedLogRecords()
        const spans = spanExporter.getFinishedSpans()
        assert.lengthOf(logs, 1)
        assert.lengthOf(spans, 1)
        const log = logs[0]!
        const span = spans[0]!

        assert.deepStrictEqual(log.hrTime, [0, 1_000_000])
        assert.deepStrictEqual(log.hrTimeObserved, expectedTime)
        assert.deepStrictEqual(log.hrTimeObserved, span.startTime)
        assert.strictEqual(log.attributes.spanId, span.spanContext().spanId)
        assert.strictEqual(log.attributes.traceId, span.spanContext().traceId)
      }).pipe(
        Effect.provide(TracingLayer),
        Effect.provideService(Clock.Clock, skewedClock)
      )
    })

    it.effect("does not let annotations overwrite active span correlation", () => {
      const logExporter = new InMemoryLogRecordExporter()
      const spanExporter = new InMemorySpanExporter()
      const TracingLayer = NodeSdk.layer(Effect.sync(() => ({
        resource: { serviceName: "test" },
        spanProcessor: [new SimpleSpanProcessor(spanExporter)],
        logRecordProcessor: [new SimpleLogRecordProcessor({ exporter: logExporter })]
      })))

      return Effect.gen(function*() {
        yield* Effect.log("test").pipe(
          Effect.annotateLogs({ traceId: "spoof-trace", spanId: "spoof-span" }),
          Effect.withSpan("parent")
        )

        const log = logExporter.getFinishedLogRecords()[0]!
        const span = spanExporter.getFinishedSpans()[0]!
        assert.strictEqual(log.attributes.traceId, span.spanContext().traceId)
        assert.strictEqual(log.attributes.spanId, span.spanContext().spanId)
        assert.deepStrictEqual(log.spanContext, span.spanContext())
      }).pipe(Effect.provide(TracingLayer))
    })

    it.effect("correlates a log with an external parent span", () => {
      const logExporter = new InMemoryLogRecordExporter()
      const traceId = "ab".repeat(16)
      const spanId = "cd".repeat(8)

      return Effect.gen(function*() {
        yield* Effect.log("test").pipe(
          Effect.withParentSpan(Tracer.externalSpan({
            traceId,
            spanId,
            sampled: false,
            annotations: OtelTracer.OtelTraceFlags.context(0x02 as OtelApi.TraceFlags).pipe(
              Context.add(OtelTracer.OtelTraceState, OtelApi.createTraceState("vendor=value"))
            )
          }))
        )
        const log = logExporter.getFinishedLogRecords()[0]!
        assert.strictEqual(log.spanContext?.traceId, traceId)
        assert.strictEqual(log.spanContext?.spanId, spanId)
        assert.strictEqual(log.spanContext?.traceFlags, 0x02)
        assert.strictEqual(log.spanContext?.traceState?.serialize(), "vendor=value")
        assert.isTrue(log.spanContext?.isRemote)
      }).pipe(Effect.provide(makeTestLayer(logExporter)))
    })

    it("uses ambient context only when there is no Effect parent span", async () => {
      const contextManager = new AsyncHooksContextManager()
      OtelApi.context.setGlobalContextManager(contextManager.enable())
      try {
        const logExporter = new InMemoryLogRecordExporter()
        const ambientSpan: OtelApi.SpanContext = {
          traceId: "ab".repeat(16),
          spanId: "cd".repeat(8),
          traceFlags: OtelApi.TraceFlags.SAMPLED
        }
        const effectSpan = Tracer.externalSpan({ traceId: "ef".repeat(16), spanId: "12".repeat(8) })
        const active = OtelApi.trace.setSpanContext(OtelApi.ROOT_CONTEXT, ambientSpan)
        await OtelApi.context.with(active, () =>
          Effect.runPromise(
            Effect.gen(function*() {
              yield* Effect.log("ambient")
              yield* Effect.log("effect").pipe(Effect.withParentSpan(effectSpan))
              const logs = logExporter.getFinishedLogRecords()
              assert.lengthOf(logs, 2)
              assert.deepStrictEqual(logs[0]!.spanContext, ambientSpan)
              assert.isUndefined(logs[0]!.attributes.traceId)
              assert.isUndefined(logs[0]!.attributes.spanId)
              assert.strictEqual(logs[1]!.spanContext?.traceId, effectSpan.traceId)
              assert.strictEqual(logs[1]!.spanContext?.spanId, effectSpan.spanId)
            }).pipe(Effect.provide(makeTestLayer(logExporter)))
          ))
      } finally {
        OtelApi.context.disable()
        contextManager.disable()
      }
    })
  })

  describe("not provided", () => {
    const exporter = new InMemoryLogRecordExporter()

    const TracingLayer = NodeSdk.layer(Effect.sync(() => ({
      resource: {
        serviceName: "test"
      }
    })))

    it.effect("withSpan", () =>
      Effect.gen(function*() {
        yield* Effect.log("test")
        assert.lengthOf(exporter.getFinishedLogRecords(), 0)
      }).pipe(Effect.provide(TracingLayer)))
  })
})