@effect/opentelemetry 0.46.3 → 0.46.5

package/src/OtlpResource.ts

@@ -0,0 +1,168 @@
+/**
+ * @since 1.0.0
+ */
+import * as Inspectable from "effect/Inspectable"
+
+/**
+ * @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: "service.name",
+    value: {
+      stringValue: options.serviceName
+    }
+  })
+  if (options.serviceVersion) {
+    resourceAttributes.push({
+      key: "service.version",
+      value: {
+        stringValue: options.serviceVersion
+      }
+    })
+  }
+
+  return {
+    attributes: resourceAttributes,
+    droppedAttributesCount: 0
+  }
+}
+
+/**
+ * @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,23 +1,22 @@
 /**
  * @since 1.0.0
  */
-import * as Headers from "@effect/platform/Headers"
-import * as HttpBody from "@effect/platform/HttpBody"
-import * as HttpClient from "@effect/platform/HttpClient"
-import * as HttpClientRequest from "@effect/platform/HttpClientRequest"
+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 FiberSet from "effect/FiberSet"
-import * as Inspectable from "effect/Inspectable"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
-import * as Schedule from "effect/Schedule"
-import * as Scope from "effect/Scope"
+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"
 
 /**
  * @since 1.0.0
@@ -34,112 +33,37 @@ export const make: (
     readonly headers?: Headers.Input | undefined
     readonly exportInterval?: Duration.DurationInput | undefined
     readonly maxBatchSize?: number | undefined
+    readonly context?: (<X>(f: () => X, span: Tracer.AnySpan) => X) | undefined
   }
 ) => Effect.Effect<
   Tracer.Tracer,
   never,
   HttpClient.HttpClient | Scope.Scope
 > = Effect.fnUntraced(function*(options) {
-  const exporterScope = yield* Effect.scope
-  const exportInterval = options.exportInterval ? Duration.decode(options.exportInterval) : Duration.seconds(5)
-  const maxBatchSize = options.maxBatchSize ?? 1000
-
-  const client = HttpClient.filterStatusOk(yield* HttpClient.HttpClient).pipe(
-    HttpClient.tapError((error) => {
-      if (error._tag !== "ResponseError" || error.response.status !== 429) {
-        return Effect.void
-      }
-      const retryAfter = error.response.headers["retry-after"]
-      const retryAfterSeconds = retryAfter ? parseInt(retryAfter, 10) : 5
-      return Effect.sleep(Duration.seconds(retryAfterSeconds))
-    }),
-    HttpClient.retryTransient({
-      schedule: Schedule.spaced(1000)
-    })
-  )
-
-  let headers = Headers.unsafeFromRecord({
-    "user-agent": "@effect-opentelemetry-OtlpExporter"
-  })
-  if (options.headers) {
-    headers = Headers.merge(Headers.fromInput(options.headers), headers)
-  }
-
-  const resourceAttributes = options.resource.attributes
-    ? entriesToAttributes(Object.entries(options.resource.attributes))
-    : []
-  resourceAttributes.push({
-    key: "service.name",
-    value: {
-      stringValue: options.resource.serviceName
-    }
-  })
-  if (options.resource.serviceVersion) {
-    resourceAttributes.push({
-      key: "service.version",
-      value: {
-        stringValue: options.resource.serviceVersion
-      }
-    })
-  }
-
-  const otelResource: OtlpResource = {
-    attributes: resourceAttributes,
-    droppedAttributesCount: 0
-  }
+  const otelResource = OtlpResource.make(options.resource)
   const scope: Scope = {
     name: options.resource.serviceName
   }
 
-  let spanBuffer: Array<OtlpSpan> = []
-
-  const runExport = Effect.suspend(() => {
-    if (spanBuffer.length === 0) {
-      return Effect.void
-    }
-    const spans = spanBuffer
-    spanBuffer = []
-    const data: TraceData = {
-      resourceSpans: [{
-        resource: otelResource,
-        scopeSpans: [{
-          scope,
-          spans
+  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 Effect.asVoid(client.execute(
-      HttpClientRequest.post(options.url, {
-        body: HttpBody.unsafeJson(data),
-        headers
-      })
-    ))
-  }).pipe(
-    Effect.catchAllCause((cause) => Effect.logWarning("Failed to export spans", cause)),
-    Effect.annotateLogs({
-      package: "@effect/opentelemetry",
-      module: "OtlpExporter"
-    })
-  )
-
-  yield* Scope.addFinalizer(exporterScope, runExport)
-
-  yield* Effect.sleep(exportInterval).pipe(
-    Effect.zipRight(runExport),
-    Effect.forever,
-    Effect.forkScoped,
-    Effect.interruptible
-  )
-
-  const runFork = yield* FiberSet.makeRuntime().pipe(
-    Effect.interruptible
-  )
-  const addSpan = (span: SpanImpl) => {
-    spanBuffer.push(makeOtlpSpan(span))
-    if (spanBuffer.length >= maxBatchSize) {
-      runFork(runExport)
+      }
+      return data
     }
-  }
+  })
 
   return Tracer.make({
     span(name, parent, context, links, startTime, kind) {
@@ -155,12 +79,19 @@ export const make: (
         links,
         sampled: true,
         kind,
-        export: addSpan
+        export(span) {
+          exporter.push(makeOtlpSpan(span))
+        }
       })
     },
-    context(f, _fiber) {
-      return f()
-    }
+    context: options.context ?
+      function(f, fiber) {
+        if (fiber.currentSpan === undefined) {
+          return f()
+        }
+        return options.context!(f, fiber.currentSpan)
+      } :
+      defaultContext
   })
 })
 
@@ -177,10 +108,16 @@ export const layer = (options: {
   }
   readonly headers?: Headers.Input | undefined
   readonly exportInterval?: Duration.DurationInput | undefined
+  readonly maxBatchSize?: number | undefined
+  readonly context?: (<X>(f: () => X, span: Tracer.AnySpan) => X) | 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>
@@ -262,10 +199,10 @@ const makeOtlpSpan = (self: SpanImpl): OtlpSpan => {
     const errors = Cause.prettyErrors(status.exit.cause)
     const firstError = errors[0]
     otelStatus = {
-      code: StatusCode.Error,
-      message: firstError && firstError.message
+      code: StatusCode.Error
     }
-    for (const error of errors) {
+    if (firstError) {
+      otelStatus.message = firstError.message
       events.push({
         name: "exception",
         timeUnixNano: String(status.endTime),
@@ -274,19 +211,19 @@ const makeOtlpSpan = (self: SpanImpl): OtlpSpan => {
           {
             "key": "exception.type",
             "value": {
-              "stringValue": error.name
+              "stringValue": firstError.name
             }
           },
           {
             "key": "exception.message",
             "value": {
-              "stringValue": error.message
+              "stringValue": firstError.message
             }
           },
           {
             "key": "exception.stacktrace",
             "value": {
-              "stringValue": error.stack ?? ""
+              "stringValue": Cause.pretty(status.exit.cause, { renderErrorCause: true })
             }
           }
         ]
@@ -317,83 +254,15 @@ const makeOtlpSpan = (self: SpanImpl): OtlpSpan => {
   }
 }
 
-const unknownToAttributeValue = (value: unknown): AttributeValue => {
-  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)
-      }
-  }
-}
-
-const entriesToAttributes = (entries: Iterable<[string, unknown]>): Array<Attribute> => {
-  const attributes: Array<Attribute> = []
-  for (const [key, value] of entries) {
-    attributes.push({
-      key,
-      value: unknownToAttributeValue(value)
-    })
-  }
-  return attributes
-}
-
 interface TraceData {
   readonly resourceSpans: Array<ResourceSpan>
 }
 
 interface ResourceSpan {
-  readonly resource: OtlpResource
+  readonly resource: Resource
   readonly scopeSpans: Array<ScopeSpan>
 }
 
-interface OtlpResource {
-  readonly attributes: Array<Attribute>
-  readonly droppedAttributesCount: number
-}
-
-interface Attribute {
-  readonly key: string
-  readonly value: AttributeValue
-}
-
-type AttributeValue = IntValue | DoubleValue | BoolValue | StringValue
-
-interface IntValue {
-  readonly intValue: number
-}
-
-interface DoubleValue {
-  readonly doubleValue: number
-}
-
-interface BoolValue {
-  readonly boolValue: boolean
-}
-
-interface StringValue {
-  readonly stringValue: string
-}
-
 interface ScopeSpan {
   readonly scope: Scope
   readonly spans: Array<OtlpSpan>
@@ -411,7 +280,7 @@ interface OtlpSpan {
   readonly kind: number
   readonly startTimeUnixNano: string
   readonly endTimeUnixNano: string
-  readonly attributes: Array<Attribute>
+  readonly attributes: Array<KeyValue>
   readonly droppedAttributesCount: number
   readonly events: Array<Event>
   readonly droppedEventsCount: number
@@ -421,14 +290,14 @@ interface OtlpSpan {
 }
 
 interface Event {
-  readonly attributes: Array<Attribute>
+  readonly attributes: Array<KeyValue>
   readonly name: string
   readonly timeUnixNano: string
   readonly droppedAttributesCount: number
 }
 
 interface Link {
-  readonly attributes: Array<Attribute>
+  readonly attributes: Array<KeyValue>
   readonly spanId: string
   readonly traceId: string
   readonly droppedAttributesCount: number
@@ -436,7 +305,7 @@ interface Link {
 
 interface Status {
   readonly code: StatusCode
-  readonly message?: string
+  message?: string
 }
 
 const enum StatusCode {

package/src/index.ts

@@ -13,6 +13,27 @@ export * as Metrics from "./Metrics.js"
  */
 export * as NodeSdk from "./NodeSdk.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as Otlp from "./Otlp.js"
+
+/**
+ * @since 1.0.0
+ * @category Constructors
+ */
+export * as OtlpLogger from "./OtlpLogger.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as OtlpMetrics from "./OtlpMetrics.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as OtlpResource from "./OtlpResource.js"
+
 /**
  * @since 1.0.0
  */

package/src/internal/otlpExporter.ts

@@ -0,0 +1,114 @@
+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
+  }
+) => Effect.Effect<
+  { readonly push: (data: unknown) => void },
+  never,
+  HttpClient.HttpClient | Scope.Scope
+> = Effect.fnUntraced(function*(options) {
+  const scope = yield* Effect.scope
+  const exportInterval = Duration.decode(options.exportInterval)
+
+  const client = HttpClient.filterStatusOk(yield* HttpClient.HttpClient).pipe(
+    HttpClient.tapError((error) => {
+      if (error._tag !== "ResponseError" || error.response.status !== 429) {
+        return Effect.void
+      }
+      const retryAfter = error.response.headers["retry-after"]
+      const retryAfterSeconds = retryAfter ? parseInt(retryAfter, 10) : 5
+      return Effect.sleep(Duration.seconds(retryAfterSeconds))
+    }),
+    HttpClient.retryTransient({ schedule: policy })
+  )
+
+  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(() => {
+    const items = buffer
+    if (options.maxBatchSize !== "disabled") {
+      if (buffer.length === 0) {
+        return Effect.void
+      }
+      buffer = []
+    }
+    return Effect.asVoid(client.execute(
+      HttpClientRequest.bodyUnsafeJson(request, options.body(items))
+    ))
+  })
+
+  yield* Scope.addFinalizer(scope, Effect.ignore(runExport))
+
+  let disabled = false
+
+  yield* Effect.sleep(exportInterval).pipe(
+    Effect.zipRight(runExport),
+    Effect.forever,
+    Effect.catchAllCause((cause) => {
+      disabled = true
+      return Effect.logDebug("Failed to export", cause)
+    }),
+    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 (disabled) return
+      buffer.push(data)
+      if (options.maxBatchSize !== "disabled" && buffer.length >= options.maxBatchSize) {
+        runFork(runExport)
+      }
+    }
+  }
+})