@effect/opentelemetry 0.60.0 → 4.0.0-beta.0

package/src/OtlpResource.ts

@@ -1,232 +0,0 @@
-/**
- * @since 1.0.0
- */
-import * as Arr from "effect/Array"
-import * as Config from "effect/Config"
-import * as Effect from "effect/Effect"
-import * as Inspectable from "effect/Inspectable"
-
-const ATTR_SERVICE_NAME = "service.name"
-const ATTR_SERVICE_VERSION = "service.version"
-
-/**
- * @since 1.0.0
- * @category Models
- */
-export interface Resource {
-  /** Resource attributes */
-  attributes: Array<KeyValue>
-  /** Resource droppedAttributesCount */
-  droppedAttributesCount: number
-}
-
-/**
- * @since 1.0.0
- * @category Constructors
- */
-export const make = (options: {
-  readonly serviceName: string
-  readonly serviceVersion?: string | undefined
-  readonly attributes?: Record<string, unknown> | undefined
-}): Resource => {
-  const resourceAttributes = options.attributes
-    ? entriesToAttributes(Object.entries(options.attributes))
-    : []
-  resourceAttributes.push({
-    key: ATTR_SERVICE_NAME,
-    value: {
-      stringValue: options.serviceName
-    }
-  })
-  if (options.serviceVersion) {
-    resourceAttributes.push({
-      key: ATTR_SERVICE_VERSION,
-      value: {
-        stringValue: options.serviceVersion
-      }
-    })
-  }
-
-  return {
-    attributes: resourceAttributes,
-    droppedAttributesCount: 0
-  }
-}
-
-/**
- * @since 1.0.0
- * @category Constructors
- */
-export const fromConfig: (
-  options?: {
-    readonly serviceName?: string | undefined
-    readonly serviceVersion?: string | undefined
-    readonly attributes?: Record<string, unknown> | undefined
-  } | undefined
-) => Effect.Effect<Resource> = Effect.fnUntraced(function*(options?: {
-  readonly serviceName?: string | undefined
-  readonly serviceVersion?: string | undefined
-  readonly attributes?: Record<string, unknown> | undefined
-}) {
-  const attributes = yield* Config.string("OTEL_RESOURCE_ATTRIBUTES").pipe(
-    Config.map((s) => {
-      const attrs = s.split(",")
-      return Arr.reduce(attrs, {} as Record<string, string>, (acc, attr) => {
-        const parts = attr.split("=")
-        if (parts.length !== 2) {
-          return acc
-        }
-        acc[parts[0].trim()] = parts[1].trim()
-        return acc
-      })
-    }),
-    Config.withDefault({}),
-    Effect.map((envAttrs) => ({
-      ...envAttrs,
-      ...options?.attributes
-    }))
-  )
-  const serviceName = options?.serviceName ?? attributes[ATTR_SERVICE_NAME] as string ??
-    (yield* Config.string("OTEL_SERVICE_NAME"))
-  const serviceVersion = options?.serviceVersion ?? attributes[ATTR_SERVICE_VERSION] as string ??
-    (yield* Config.string("OTEL_SERVICE_VERSION").pipe(Config.withDefault(undefined)))
-  return make({
-    serviceName,
-    serviceVersion,
-    attributes
-  })
-}, Effect.orDie)
-
-/**
- * @since 1.0.0
- * @category Attributes
- */
-export const unsafeServiceName = (resource: Resource): string => {
-  const serviceNameAttribute = resource.attributes.find(
-    (attr) => attr.key === ATTR_SERVICE_NAME
-  )
-  if (!serviceNameAttribute || !serviceNameAttribute.value.stringValue) {
-    throw new Error("Resource does not contain a service name")
-  }
-  return serviceNameAttribute.value.stringValue
-}
-
-/**
- * @since 1.0.0
- * @category Attributes
- */
-export const entriesToAttributes = (entries: Iterable<[string, unknown]>): Array<KeyValue> => {
-  const attributes: Array<KeyValue> = []
-  for (const [key, value] of entries) {
-    attributes.push({
-      key,
-      value: unknownToAttributeValue(value)
-    })
-  }
-  return attributes
-}
-
-/**
- * @since 1.0.0
- * @category Attributes
- */
-export const unknownToAttributeValue = (value: unknown): AnyValue => {
-  if (Array.isArray(value)) {
-    return {
-      arrayValue: {
-        values: value.map(unknownToAttributeValue)
-      }
-    }
-  }
-  switch (typeof value) {
-    case "string":
-      return {
-        stringValue: value
-      }
-    case "bigint":
-      return {
-        intValue: Number(value)
-      }
-    case "number":
-      return Number.isInteger(value)
-        ? {
-          intValue: value
-        }
-        : {
-          doubleValue: value
-        }
-    case "boolean":
-      return {
-        boolValue: value
-      }
-    default:
-      return {
-        stringValue: Inspectable.toStringUnknown(value)
-      }
-  }
-}
-
-/**
- * @since 1.0.0
- * @category Models
- */
-export interface KeyValue {
-  /** KeyValue key */
-  key: string
-  /** KeyValue value */
-  value: AnyValue
-}
-
-/**
- * @since 1.0.0
- * @category Models
- */
-export interface AnyValue {
-  /** AnyValue stringValue */
-  stringValue?: string | null
-  /** AnyValue boolValue */
-  boolValue?: boolean | null
-  /** AnyValue intValue */
-  intValue?: number | null
-  /** AnyValue doubleValue */
-  doubleValue?: number | null
-  /** AnyValue arrayValue */
-  arrayValue?: ArrayValue
-  /** AnyValue kvlistValue */
-  kvlistValue?: KeyValueList
-  /** AnyValue bytesValue */
-  bytesValue?: Uint8Array
-}
-
-/**
- * @since 1.0.0
- * @category Models
- */
-export interface ArrayValue {
-  /** ArrayValue values */
-  values: Array<AnyValue>
-}
-
-/**
- * @since 1.0.0
- * @category Models
- */
-export interface KeyValueList {
-  /** KeyValueList values */
-  values: Array<KeyValue>
-}
-
-/**
- * @since 1.0.0
- * @category Models
- */
-export interface LongBits {
-  low: number
-  high: number
-}
-
-/**
- * @since 1.0.0
- * @category Models
- */
-export type Fixed64 = LongBits | string | number

package/src/OtlpTracer.ts

@@ -1,349 +0,0 @@
-/**
- * @since 1.0.0
- */
-import type * as Headers from "@effect/platform/Headers"
-import type * as HttpClient from "@effect/platform/HttpClient"
-import * as Cause from "effect/Cause"
-import type * as Context from "effect/Context"
-import * as Duration from "effect/Duration"
-import * as Effect from "effect/Effect"
-import type * as Exit from "effect/Exit"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import type * as Scope from "effect/Scope"
-import * as Tracer from "effect/Tracer"
-import type { ExtractTag } from "effect/Types"
-import * as Exporter from "./internal/otlpExporter.js"
-import type { KeyValue, Resource } from "./OtlpResource.js"
-import { entriesToAttributes } from "./OtlpResource.js"
-import * as OtlpResource from "./OtlpResource.js"
-
-const ATTR_EXCEPTION_TYPE = "exception.type"
-const ATTR_EXCEPTION_MESSAGE = "exception.message"
-const ATTR_EXCEPTION_STACKTRACE = "exception.stacktrace"
-
-/**
- * @since 1.0.0
- * @category Constructors
- */
-export const make: (
-  options: {
-    readonly url: string
-    readonly resource?: {
-      readonly serviceName?: string | undefined
-      readonly serviceVersion?: string | undefined
-      readonly attributes?: Record<string, unknown>
-    } | undefined
-    readonly headers?: Headers.Input | undefined
-    readonly exportInterval?: Duration.DurationInput | undefined
-    readonly maxBatchSize?: number | undefined
-    readonly context?: (<X>(f: () => X, span: Tracer.AnySpan) => X) | undefined
-    readonly shutdownTimeout?: Duration.DurationInput | undefined
-  }
-) => Effect.Effect<
-  Tracer.Tracer,
-  never,
-  HttpClient.HttpClient | Scope.Scope
-> = Effect.fnUntraced(function*(options) {
-  const otelResource = yield* OtlpResource.fromConfig(options.resource)
-  const scope: Scope = {
-    name: OtlpResource.unsafeServiceName(otelResource)
-  }
-
-  const exporter = yield* Exporter.make({
-    label: "OtlpTracer",
-    url: options.url,
-    headers: options.headers,
-    exportInterval: options.exportInterval ?? Duration.seconds(5),
-    maxBatchSize: options.maxBatchSize ?? 1000,
-    body(spans) {
-      const data: TraceData = {
-        resourceSpans: [{
-          resource: otelResource,
-          scopeSpans: [{
-            scope,
-            spans
-          }]
-        }]
-      }
-      return data
-    },
-    shutdownTimeout: options.shutdownTimeout ?? Duration.seconds(3)
-  })
-
-  const exportFn = (span: SpanImpl) => {
-    exporter.push(makeOtlpSpan(span))
-  }
-
-  return Tracer.make({
-    span(name, parent, context, links, startTime, kind) {
-      return makeSpan({
-        name,
-        parent,
-        context,
-        status: {
-          _tag: "Started",
-          startTime
-        },
-        attributes: new Map(),
-        links,
-        sampled: true,
-        kind,
-        export: exportFn
-      })
-    },
-    context: options.context ?
-      function(f, fiber) {
-        if (fiber.currentSpan === undefined) {
-          return f()
-        }
-        return options.context!(f, fiber.currentSpan)
-      } :
-      defaultContext
-  })
-})
-
-/**
- * @since 1.0.0
- * @category Layers
- */
-export const layer = (options: {
-  readonly url: string
-  readonly resource?: {
-    readonly serviceName?: string | undefined
-    readonly serviceVersion?: string | undefined
-    readonly attributes?: Record<string, unknown>
-  } | undefined
-  readonly headers?: Headers.Input | undefined
-  readonly exportInterval?: Duration.DurationInput | undefined
-  readonly maxBatchSize?: number | undefined
-  readonly context?: (<X>(f: () => X, span: Tracer.AnySpan) => X) | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
-}): Layer.Layer<never, never, HttpClient.HttpClient> => Layer.unwrapScoped(Effect.map(make(options), Layer.setTracer))
-
-// internal
-
-function defaultContext<X>(f: () => X, _: any): X {
-  return f()
-}
-
-interface SpanImpl extends Tracer.Span {
-  readonly export: (span: SpanImpl) => void
-  readonly attributes: Map<string, unknown>
-  readonly links: Array<Tracer.SpanLink>
-  readonly events: Array<[name: string, startTime: bigint, attributes: Record<string, unknown> | undefined]>
-  status: Tracer.SpanStatus
-}
-
-const SpanProto = {
-  _tag: "Span",
-  end(this: SpanImpl, endTime: bigint, exit: Exit.Exit<unknown, unknown>) {
-    this.status = {
-      _tag: "Ended",
-      startTime: this.status.startTime,
-      endTime,
-      exit
-    }
-    this.export(this)
-  },
-  attribute(this: SpanImpl, key: string, value: unknown) {
-    this.attributes.set(key, value)
-  },
-  event(this: SpanImpl, name: string, startTime: bigint, attributes?: Record<string, unknown>) {
-    this.events.push([name, startTime, attributes])
-  },
-  addLinks(this: SpanImpl, links: ReadonlyArray<Tracer.SpanLink>) {
-    // eslint-disable-next-line no-restricted-syntax
-    this.links.push(...links)
-  }
-}
-
-const makeSpan = (options: {
-  readonly name: string
-  readonly parent: Option.Option<Tracer.AnySpan>
-  readonly context: Context.Context<never>
-  readonly status: Tracer.SpanStatus
-  readonly attributes: ReadonlyMap<string, unknown>
-  readonly links: ReadonlyArray<Tracer.SpanLink>
-  readonly sampled: boolean
-  readonly kind: Tracer.SpanKind
-  readonly export: (span: SpanImpl) => void
-}): SpanImpl => {
-  const self = Object.assign(Object.create(SpanProto), options)
-  if (Option.isSome(self.parent)) {
-    self.traceId = self.parent.value.traceId
-  } else {
-    self.traceId = generateId(32)
-  }
-  self.spanId = generateId(16)
-  self.events = []
-  return self
-}
-
-const generateId = (len: number): string => {
-  const chars = "0123456789abcdef"
-  let result = ""
-  for (let i = 0; i < len; i++) {
-    result += chars[Math.floor(Math.random() * chars.length)]
-  }
-  return result
-}
-
-const makeOtlpSpan = (self: SpanImpl): OtlpSpan => {
-  const status = self.status as ExtractTag<Tracer.SpanStatus, "Ended">
-  const attributes = entriesToAttributes(self.attributes.entries())
-  const events = self.events.map(([name, startTime, attributes]) => ({
-    name,
-    timeUnixNano: String(startTime),
-    attributes: attributes
-      ? entriesToAttributes(Object.entries(attributes))
-      : [],
-    droppedAttributesCount: 0
-  }))
-  let otelStatus: Status
-
-  if (status.exit._tag === "Success") {
-    otelStatus = constOtelStatusSuccess
-  } else if (Cause.isInterruptedOnly(status.exit.cause)) {
-    otelStatus = {
-      code: StatusCode.Ok,
-      message: Cause.pretty(status.exit.cause)
-    }
-  } else {
-    const errors = Cause.prettyErrors(status.exit.cause)
-    const firstError = errors[0]
-    otelStatus = {
-      code: StatusCode.Error
-    }
-    attributes.push({
-      key: "span.label",
-      value: { stringValue: "⚠︎ Interrupted" }
-    }, {
-      key: "status.interrupted",
-      value: { boolValue: true }
-    })
-    if (firstError) {
-      otelStatus.message = firstError.message
-      events.push({
-        name: "exception",
-        timeUnixNano: String(status.endTime),
-        droppedAttributesCount: 0,
-        attributes: [
-          {
-            "key": ATTR_EXCEPTION_TYPE,
-            "value": {
-              "stringValue": firstError.name
-            }
-          },
-          {
-            "key": ATTR_EXCEPTION_MESSAGE,
-            "value": {
-              "stringValue": firstError.message
-            }
-          },
-          {
-            "key": ATTR_EXCEPTION_STACKTRACE,
-            "value": {
-              "stringValue": Cause.pretty(status.exit.cause, { renderErrorCause: true })
-            }
-          }
-        ]
-      })
-    }
-  }
-
-  return {
-    traceId: self.traceId,
-    spanId: self.spanId,
-    parentSpanId: Option.isSome(self.parent) ? self.parent.value.spanId : undefined,
-    name: self.name,
-    kind: SpanKind[self.kind],
-    startTimeUnixNano: String(status.startTime),
-    endTimeUnixNano: String(status.endTime),
-    attributes,
-    droppedAttributesCount: 0,
-    events,
-    droppedEventsCount: 0,
-    status: otelStatus,
-    links: self.links.map((link) => ({
-      traceId: link.span.traceId,
-      spanId: link.span.spanId,
-      attributes: entriesToAttributes(Object.entries(link.attributes)),
-      droppedAttributesCount: 0
-    })),
-    droppedLinksCount: 0
-  }
-}
-
-interface TraceData {
-  readonly resourceSpans: Array<ResourceSpan>
-}
-
-interface ResourceSpan {
-  readonly resource: Resource
-  readonly scopeSpans: Array<ScopeSpan>
-}
-
-interface ScopeSpan {
-  readonly scope: Scope
-  readonly spans: Array<OtlpSpan>
-}
-
-interface Scope {
-  readonly name: string
-}
-
-interface OtlpSpan {
-  readonly traceId: string
-  readonly spanId: string
-  readonly parentSpanId: string | undefined
-  readonly name: string
-  readonly kind: number
-  readonly startTimeUnixNano: string
-  readonly endTimeUnixNano: string
-  readonly attributes: Array<KeyValue>
-  readonly droppedAttributesCount: number
-  readonly events: Array<Event>
-  readonly droppedEventsCount: number
-  readonly status: Status
-  readonly links: Array<Link>
-  readonly droppedLinksCount: number
-}
-
-interface Event {
-  readonly attributes: Array<KeyValue>
-  readonly name: string
-  readonly timeUnixNano: string
-  readonly droppedAttributesCount: number
-}
-
-interface Link {
-  readonly attributes: Array<KeyValue>
-  readonly spanId: string
-  readonly traceId: string
-  readonly droppedAttributesCount: number
-}
-
-interface Status {
-  readonly code: StatusCode
-  message?: string
-}
-
-const enum StatusCode {
-  Unset = 0,
-  Ok = 1,
-  Error = 2
-}
-
-enum SpanKind {
-  unspecified = 0,
-  internal = 1,
-  server = 2,
-  client = 3,
-  producer = 4,
-  consumer = 5
-}
-
-const constOtelStatusSuccess: Status = {
-  code: StatusCode.Ok
-}

package/src/internal/otlpExporter.ts

@@ -1,124 +0,0 @@
-import * as Headers from "@effect/platform/Headers"
-import * as HttpClient from "@effect/platform/HttpClient"
-import * as HttpClientError from "@effect/platform/HttpClientError"
-import * as HttpClientRequest from "@effect/platform/HttpClientRequest"
-import * as Duration from "effect/Duration"
-import * as Effect from "effect/Effect"
-import * as FiberSet from "effect/FiberSet"
-import * as Num from "effect/Number"
-import * as Option from "effect/Option"
-import * as Schedule from "effect/Schedule"
-import * as Scope from "effect/Scope"
-
-const policy = Schedule.forever.pipe(
-  Schedule.passthrough,
-  Schedule.addDelay((error) => {
-    if (
-      HttpClientError.isHttpClientError(error)
-      && error._tag === "ResponseError"
-      && error.response.status === 429
-    ) {
-      const retryAfter = Option.fromNullable(error.response.headers["retry-after"]).pipe(
-        Option.flatMap(Num.parse),
-        Option.getOrElse(() => 5)
-      )
-      return Duration.seconds(retryAfter)
-    }
-    return Duration.seconds(1)
-  })
-)
-
-/** @internal */
-export const make: (
-  options: {
-    readonly url: string
-    readonly headers: Headers.Input | undefined
-    readonly label: string
-    readonly exportInterval: Duration.DurationInput
-    readonly maxBatchSize: number | "disabled"
-    readonly body: (data: Array<any>) => unknown
-    readonly shutdownTimeout: Duration.DurationInput
-  }
-) => Effect.Effect<
-  { readonly push: (data: unknown) => void },
-  never,
-  HttpClient.HttpClient | Scope.Scope
-> = Effect.fnUntraced(function*(options) {
-  const clock = yield* Effect.clock
-  const scope = yield* Effect.scope
-  const exportInterval = Duration.decode(options.exportInterval)
-  let disabledUntil: number | undefined = undefined
-
-  const client = HttpClient.filterStatusOk(yield* HttpClient.HttpClient).pipe(
-    HttpClient.retryTransient({ schedule: policy, times: 3 })
-  )
-
-  let headers = Headers.unsafeFromRecord({
-    "user-agent": `effect-opentelemetry-${options.label}/0.0.0`
-  })
-  if (options.headers) {
-    headers = Headers.merge(Headers.fromInput(options.headers), headers)
-  }
-
-  const request = HttpClientRequest.post(options.url, { headers })
-  let buffer: Array<any> = []
-  const runExport = Effect.suspend(() => {
-    if (disabledUntil !== undefined && clock.unsafeCurrentTimeMillis() < disabledUntil) {
-      return Effect.void
-    } else if (disabledUntil !== undefined) {
-      disabledUntil = undefined
-    }
-    const items = buffer
-    if (options.maxBatchSize !== "disabled") {
-      if (buffer.length === 0) {
-        return Effect.void
-      }
-      buffer = []
-    }
-    return client.execute(
-      HttpClientRequest.bodyUnsafeJson(request, options.body(items))
-    ).pipe(
-      Effect.asVoid,
-      Effect.withTracerEnabled(false)
-    )
-  }).pipe(
-    Effect.catchAllCause((cause) => {
-      if (disabledUntil !== undefined) return Effect.void
-      disabledUntil = clock.unsafeCurrentTimeMillis() + Duration.toMillis("1 minute")
-      return Effect.logDebug(`Disabling ${options.label} for 60 seconds`, cause)
-    })
-  )
-
-  yield* Scope.addFinalizer(
-    scope,
-    runExport.pipe(
-      Effect.ignore,
-      Effect.interruptible,
-      Effect.timeoutOption(options.shutdownTimeout)
-    )
-  )
-
-  yield* Effect.sleep(exportInterval).pipe(
-    Effect.zipRight(runExport),
-    Effect.forever,
-    Effect.annotateLogs({
-      package: "@effect/opentelemetry",
-      module: options.label
-    }),
-    Effect.forkIn(scope),
-    Effect.interruptible
-  )
-
-  const runFork = yield* FiberSet.makeRuntime().pipe(
-    Effect.interruptible
-  )
-  return {
-    push(data) {
-      if (disabledUntil !== undefined) return
-      buffer.push(data)
-      if (options.maxBatchSize !== "disabled" && buffer.length >= options.maxBatchSize) {
-        runFork(runExport)
-      }
-    }
-  }
-})