@raindrop-ai/eve 0.0.23 → 0.0.24

package/README.md

@@ -303,3 +303,25 @@ Raindrop UI and Workshop with full nesting + AI SDK attributes.
 
 - [`examples/eve-basic`](../../examples/eve-basic) — single-agent example with one tool (`get_weather`) and an end-to-end dashboard verifier.
 - [`examples/eve-subagents`](../../examples/eve-subagents) — parent agent dispatching `weatherResearcher` + `attractionsFinder` sub-agents, verifying cross-sandbox nesting against the production dashboard.
+
+## Application Git identity
+
+Set `appGit` on `defineRaindropInstrumentation` (or `RaindropEveSpanExporter`) to override `commitSha`, `commitDirty`, and optional ordinary `branch`, or pass `false` to opt out. The revision is unknown by default because ambient deploy/CI and observer working-directory metadata are ignored. Local discovery requires an explicit `sourceDirectory` (or `RAINDROP_GIT_SOURCE_DIRECTORY`); explicit `RAINDROP_COMMIT_SHA` values are honored. Automatic branch discovery requires `detectBranch: true`. Eve's event feed and independent OTLP exporter share one application Git context.
+
+For advanced direct exporter wiring, install the start processor to freeze automatic metadata when each span begins. Keep `"auto"` to preserve Vercel's default processors; `traceExporter` retains its normal batch exporter:
+
+```ts
+import { registerOTel } from "@vercel/otel";
+import { RaindropEveSpanExporter, createEveAppGitSpanProcessor } from "@raindrop-ai/eve";
+
+const exporter = new RaindropEveSpanExporter({
+  writeKey: process.env.RAINDROP_WRITE_KEY,
+  appGit: { sourceDirectory: "/path/to/application" },
+});
+registerOTel({
+  traceExporter: exporter,
+  spanProcessors: ["auto", createEveAppGitSpanProcessor(exporter)],
+});
+```
+
+Without this processor, direct exporters attach only explicit client, environment, operation, or span values. Automatic discovery never fills in metadata for a span whose start was not observed. `defineRaindropInstrumentation` installs the processor automatically.

package/dist/index.d.mts

@@ -1,6 +1,141 @@
 import * as _vercel_otel from '@vercel/otel';
 import { RaindropAISDKClient } from '@raindrop-ai/ai-sdk';
 
+/** Kept structural so public integration declarations do not depend on private schemas. */
+type AppGitOptions = {
+    commitSha?: string | null;
+    commitDirty?: boolean | null;
+    branch?: string | null;
+    detectBranch?: boolean;
+    sourceDirectory?: string;
+    autoDetect?: boolean;
+};
+type AppGitSnapshot = Readonly<Record<string, unknown>>;
+type AppGitEnvironment = Readonly<Record<string, string | undefined>>;
+type AppGitLocalResult = {
+    commitSha?: string;
+    commitDirty?: boolean;
+    branch?: string;
+};
+type AppGitOperationOwner = string;
+type AppGitLocalResolver = (sourceDirectory: string | undefined, detectBranch: boolean, completed: (result: AppGitLocalResult) => void) => () => void;
+/** One client owns its defaults; operation snapshots never wait for discovery. */
+declare class AppGitContextImpl {
+    private defaults;
+    private explicit;
+    private explicitKeys;
+    private cancel;
+    private disposed;
+    private operations;
+    private operationOverflow;
+    private detectBranch;
+    private replayBranch;
+    private disabled;
+    constructor(options: AppGitOptions | false | undefined, runtime?: {
+        allowLocalGit?: boolean;
+        resolveLocal?: AppGitLocalResolver;
+        env?: AppGitEnvironment;
+        captureLegacyReplayBranch?: boolean;
+        allowDiscovery?: boolean;
+    });
+    private accept;
+    snapshot(properties?: Readonly<Record<string, unknown>>): AppGitSnapshot;
+    /** Safe defaults when no operation/span start was observed; never infer identity. */
+    snapshotExplicit(properties?: Readonly<Record<string, unknown>>, eventId?: string): AppGitSnapshot;
+    /** Existing replay branch reporting stays separate from opt-in event properties. */
+    snapshotForReplay(): AppGitSnapshot;
+    /** Merge a frozen span snapshot without losing client-authored provenance. */
+    mergeSnapshot(base: AppGitSnapshot, properties?: Readonly<Record<string, unknown>>, explicitKeys?: ReadonlySet<string>): AppGitSnapshot;
+    /** Shippers belonging to one client share this bounded operation registry. */
+    forOperation(eventId: string | undefined, properties?: Readonly<Record<string, unknown>>, owner?: AppGitOperationOwner): AppGitSnapshot;
+    releaseOperation(eventId: string, owner: AppGitOperationOwner): void;
+    finishOperation(eventId: string): void;
+    dispose(): void;
+}
+/** Structural at package boundaries: public SDK bundles contain independent copies of core. */
+type AppGitContext = Pick<AppGitContextImpl, "snapshot" | "snapshotForReplay" | "forOperation" | "finishOperation" | "dispose"> & {
+    snapshotExplicit?: AppGitContextImpl["snapshotExplicit"];
+    mergeSnapshot?: AppGitContextImpl["mergeSnapshot"];
+    releaseOperation?: (eventId: string, owner: AppGitOperationOwner) => void;
+};
+declare const AppGitContext: typeof AppGitContextImpl;
+
+/**
+ * Run telemetry egress with OpenTelemetry tracing suppressed.
+ *
+ * Why this exists
+ * ---------------
+ * Raindrop integrations ship spans/events over HTTP with the global `fetch`
+ * (see {@link ../http.ts `postJson`}). When the host app also runs an OTel
+ * fetch/undici instrumentation — e.g. `@vercel/otel`'s `registerOTel`, which
+ * every Eve agent installs — that instrumentation wraps *our own* telemetry
+ * POSTs in a `fetch POST <endpoint>` span. Those spans are then handed to the
+ * very exporter that issued the request, so they get shipped right back to
+ * Raindrop and Workshop as standalone "runs" (and, because each export issues
+ * another fetch, they feed back on themselves). The result is a run list
+ * flooded with `fetch POST .../v1/traces`, `.../events/track_partial` and
+ * `.../live` entries that drown out the real agent turns — especially with
+ * sub-agents, where every sandbox runs its own instrumentation.
+ *
+ * The OTel-blessed fix is to mark the active context as "tracing suppressed"
+ * around the request; instrumentations check `isTracingSuppressed` and return
+ * a no-op span instead of recording one. We do this through a hook stashed on
+ * `globalThis` by the Node entrypoint ({@link ../index.node.ts}) so that:
+ *   - `@opentelemetry/api` / `@opentelemetry/core` stay *optional* — core never
+ *     hard-depends on them, and the hook is simply absent when they (and thus
+ *     any instrumentation to suppress) are not installed; and
+ *   - the browser bundle never pulls in `node:module`, mirroring how core
+ *     injects `AsyncLocalStorage` via `RAINDROP_ASYNC_LOCAL_STORAGE`.
+ *
+ * When no hook is present the callback runs unchanged, so suppression is a
+ * best-effort no-op rather than a hard requirement.
+ */
+/** Hook signature: run `fn` with OTel tracing suppressed, returning its value. */
+type SuppressTracingHook = <T>(fn: () => T) => T;
+declare global {
+    var RAINDROP_SUPPRESS_TRACING: SuppressTracingHook | undefined;
+}
+
+type ParentSpanContext = {
+    traceIdB64: string;
+    spanIdB64: string;
+    eventId: string;
+};
+interface ContextSpan {
+    readonly traceIdB64: string;
+    readonly spanIdB64: string;
+    readonly eventId: string;
+    log?(data: Record<string, unknown>): void;
+}
+interface AsyncLocalStorageLike<T> {
+    getStore(): T | undefined;
+    run<R>(store: T, callback: () => R): R;
+    enterWith?(store: T): void;
+}
+declare abstract class ContextManager {
+    abstract getParentSpanIds(): ParentSpanContext | undefined;
+    abstract runInContext<R>(span: ContextSpan, callback: () => R): R;
+    abstract getCurrentSpan(): ContextSpan | undefined;
+    abstract isReady(): boolean;
+}
+declare global {
+    var RAINDROP_CONTEXT_MANAGER: (new () => ContextManager) | undefined;
+    var RAINDROP_ASYNC_LOCAL_STORAGE: (new <T>() => AsyncLocalStorageLike<T>) | undefined;
+}
+
+/**
+ * RaindropEveSpanExporter — a tiny OTel SpanExporter that:
+ *
+ *   1. Ships OTLP/HTTP JSON traces to Raindrop (`<endpoint>/traces`) using a
+ *      Bearer write key, and
+ *   2. Mirrors the same export to a local Workshop daemon when one is
+ *      reachable (explicit URL, env vars, or auto-detect during development).
+ *
+ * It deliberately does NOT depend on the OpenTelemetry SDK at runtime beyond
+ * the structural `ReadableSpan` / `SpanExporter` shapes — those are typed via
+ * peer dependencies so consumers don't pay a second copy of `@opentelemetry/*`.
+ */
+
 type HrTime = [number, number];
 type AttributeValue = string | number | boolean | Array<string | number | boolean | null | undefined> | null | undefined;
 interface Attributes {
@@ -36,11 +171,19 @@ interface ReadableSpan {
     readonly parentSpanId?: string;
     readonly parentSpanContext?: SpanContext;
 }
+interface EveAppGitSpanProcessor {
+    onStart(span: ReadableSpan, parentContext?: unknown): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
 interface ExportResult {
     code: number;
     error?: Error;
 }
 interface RaindropEveExporterOptions {
+    /** Application Git identity. Local discovery requires an explicit sourceDirectory; false disables enrichment. */
+    appGit?: AppGitOptions | false;
     /**
      * Raindrop write key. Required to ship to Raindrop's hosted endpoint; when
      * omitted, the exporter still mirrors to Workshop (when one is reachable).
@@ -98,12 +241,18 @@ declare class RaindropEveSpanExporter {
     private readonly debug;
     private readonly prefix;
     private readonly maxTextFieldChars;
+    private readonly appGitContext;
+    private readonly startedAppGitSpans;
+    private readonly activeAppGitEvents;
+    private readonly appGitOwner;
     private inFlight;
     private shuttingDown;
     private auxShutdowns;
-    constructor(opts?: RaindropEveExporterOptions);
+    constructor(opts?: RaindropEveExporterOptions, appGitContext?: AppGitContext);
     /** True when we have at least one destination (Raindrop or Workshop). */
     hasDestinations(): boolean;
+    captureSpanStart(span: ReadableSpan): void;
+    private releaseStartedAppGitSpan;
     /**
      * Update the OTLP `service.name` attribute. Called by Eve's
      * `setup({ agentName })` so the resource attribute reflects the actual
@@ -122,6 +271,7 @@ declare class RaindropEveSpanExporter {
      */
     attachAuxShutdown(fn: () => Promise<void>): void;
 }
+declare function createEveAppGitSpanProcessor(exporter: RaindropEveSpanExporter): EveAppGitSpanProcessor;
 
 declare const RAINDROP_EVE_SDK_NAME: string;
 declare const RAINDROP_EVE_SDK_VERSION: string;
@@ -240,6 +390,8 @@ interface RaindropEveInstrumentationEventsConfig {
  * Options for {@link defineRaindropInstrumentation}.
  */
 interface RaindropEveInstrumentationOptions {
+    /** Application Git identity. Local discovery requires an explicit sourceDirectory; false disables enrichment. */
+    appGit?: AppGitOptions | false;
     /**
      * `registerOTel` from `@vercel/otel`. Pass the function directly so the
      * SDK doesn't have to dynamically import a peer dep at runtime.
@@ -452,4 +604,4 @@ interface RaindropInstrumentationDefinition {
  */
 declare function defineRaindropInstrumentation(opts?: RaindropEveInstrumentationOptions): RaindropInstrumentationDefinition;
 
-export { RAINDROP_EVE_SDK_NAME, RAINDROP_EVE_SDK_VERSION, type RaindropEveExporterOptions, type RaindropEveInstrumentationChannel, type RaindropEveInstrumentationEventsConfig, type RaindropEveInstrumentationMetadata, type RaindropEveInstrumentationMetadataConfig, type RaindropEveInstrumentationModelInput, type RaindropEveInstrumentationOptions, type RaindropEveInstrumentationSession, type RaindropEveInstrumentationStep, type RaindropEveInstrumentationTurn, RaindropEveSpanExporter, type RaindropEveStepStartedEventInput, type RaindropEveStepStartedEventResult, type RaindropEveStepStartedMetadataInput, type RaindropInstrumentationDefinition, type RegisterOTelFn, _resetCanonicalTurnIds, defineRaindropInstrumentation as default, defineRaindropInstrumentation };
+export { RAINDROP_EVE_SDK_NAME, RAINDROP_EVE_SDK_VERSION, type RaindropEveExporterOptions, type RaindropEveInstrumentationChannel, type RaindropEveInstrumentationEventsConfig, type RaindropEveInstrumentationMetadata, type RaindropEveInstrumentationMetadataConfig, type RaindropEveInstrumentationModelInput, type RaindropEveInstrumentationOptions, type RaindropEveInstrumentationSession, type RaindropEveInstrumentationStep, type RaindropEveInstrumentationTurn, RaindropEveSpanExporter, type RaindropEveStepStartedEventInput, type RaindropEveStepStartedEventResult, type RaindropEveStepStartedMetadataInput, type RaindropInstrumentationDefinition, type RegisterOTelFn, _resetCanonicalTurnIds, createEveAppGitSpanProcessor, defineRaindropInstrumentation as default, defineRaindropInstrumentation };

package/dist/index.d.ts

@@ -1,6 +1,141 @@
 import * as _vercel_otel from '@vercel/otel';
 import { RaindropAISDKClient } from '@raindrop-ai/ai-sdk';
 
+/** Kept structural so public integration declarations do not depend on private schemas. */
+type AppGitOptions = {
+    commitSha?: string | null;
+    commitDirty?: boolean | null;
+    branch?: string | null;
+    detectBranch?: boolean;
+    sourceDirectory?: string;
+    autoDetect?: boolean;
+};
+type AppGitSnapshot = Readonly<Record<string, unknown>>;
+type AppGitEnvironment = Readonly<Record<string, string | undefined>>;
+type AppGitLocalResult = {
+    commitSha?: string;
+    commitDirty?: boolean;
+    branch?: string;
+};
+type AppGitOperationOwner = string;
+type AppGitLocalResolver = (sourceDirectory: string | undefined, detectBranch: boolean, completed: (result: AppGitLocalResult) => void) => () => void;
+/** One client owns its defaults; operation snapshots never wait for discovery. */
+declare class AppGitContextImpl {
+    private defaults;
+    private explicit;
+    private explicitKeys;
+    private cancel;
+    private disposed;
+    private operations;
+    private operationOverflow;
+    private detectBranch;
+    private replayBranch;
+    private disabled;
+    constructor(options: AppGitOptions | false | undefined, runtime?: {
+        allowLocalGit?: boolean;
+        resolveLocal?: AppGitLocalResolver;
+        env?: AppGitEnvironment;
+        captureLegacyReplayBranch?: boolean;
+        allowDiscovery?: boolean;
+    });
+    private accept;
+    snapshot(properties?: Readonly<Record<string, unknown>>): AppGitSnapshot;
+    /** Safe defaults when no operation/span start was observed; never infer identity. */
+    snapshotExplicit(properties?: Readonly<Record<string, unknown>>, eventId?: string): AppGitSnapshot;
+    /** Existing replay branch reporting stays separate from opt-in event properties. */
+    snapshotForReplay(): AppGitSnapshot;
+    /** Merge a frozen span snapshot without losing client-authored provenance. */
+    mergeSnapshot(base: AppGitSnapshot, properties?: Readonly<Record<string, unknown>>, explicitKeys?: ReadonlySet<string>): AppGitSnapshot;
+    /** Shippers belonging to one client share this bounded operation registry. */
+    forOperation(eventId: string | undefined, properties?: Readonly<Record<string, unknown>>, owner?: AppGitOperationOwner): AppGitSnapshot;
+    releaseOperation(eventId: string, owner: AppGitOperationOwner): void;
+    finishOperation(eventId: string): void;
+    dispose(): void;
+}
+/** Structural at package boundaries: public SDK bundles contain independent copies of core. */
+type AppGitContext = Pick<AppGitContextImpl, "snapshot" | "snapshotForReplay" | "forOperation" | "finishOperation" | "dispose"> & {
+    snapshotExplicit?: AppGitContextImpl["snapshotExplicit"];
+    mergeSnapshot?: AppGitContextImpl["mergeSnapshot"];
+    releaseOperation?: (eventId: string, owner: AppGitOperationOwner) => void;
+};
+declare const AppGitContext: typeof AppGitContextImpl;
+
+/**
+ * Run telemetry egress with OpenTelemetry tracing suppressed.
+ *
+ * Why this exists
+ * ---------------
+ * Raindrop integrations ship spans/events over HTTP with the global `fetch`
+ * (see {@link ../http.ts `postJson`}). When the host app also runs an OTel
+ * fetch/undici instrumentation — e.g. `@vercel/otel`'s `registerOTel`, which
+ * every Eve agent installs — that instrumentation wraps *our own* telemetry
+ * POSTs in a `fetch POST <endpoint>` span. Those spans are then handed to the
+ * very exporter that issued the request, so they get shipped right back to
+ * Raindrop and Workshop as standalone "runs" (and, because each export issues
+ * another fetch, they feed back on themselves). The result is a run list
+ * flooded with `fetch POST .../v1/traces`, `.../events/track_partial` and
+ * `.../live` entries that drown out the real agent turns — especially with
+ * sub-agents, where every sandbox runs its own instrumentation.
+ *
+ * The OTel-blessed fix is to mark the active context as "tracing suppressed"
+ * around the request; instrumentations check `isTracingSuppressed` and return
+ * a no-op span instead of recording one. We do this through a hook stashed on
+ * `globalThis` by the Node entrypoint ({@link ../index.node.ts}) so that:
+ *   - `@opentelemetry/api` / `@opentelemetry/core` stay *optional* — core never
+ *     hard-depends on them, and the hook is simply absent when they (and thus
+ *     any instrumentation to suppress) are not installed; and
+ *   - the browser bundle never pulls in `node:module`, mirroring how core
+ *     injects `AsyncLocalStorage` via `RAINDROP_ASYNC_LOCAL_STORAGE`.
+ *
+ * When no hook is present the callback runs unchanged, so suppression is a
+ * best-effort no-op rather than a hard requirement.
+ */
+/** Hook signature: run `fn` with OTel tracing suppressed, returning its value. */
+type SuppressTracingHook = <T>(fn: () => T) => T;
+declare global {
+    var RAINDROP_SUPPRESS_TRACING: SuppressTracingHook | undefined;
+}
+
+type ParentSpanContext = {
+    traceIdB64: string;
+    spanIdB64: string;
+    eventId: string;
+};
+interface ContextSpan {
+    readonly traceIdB64: string;
+    readonly spanIdB64: string;
+    readonly eventId: string;
+    log?(data: Record<string, unknown>): void;
+}
+interface AsyncLocalStorageLike<T> {
+    getStore(): T | undefined;
+    run<R>(store: T, callback: () => R): R;
+    enterWith?(store: T): void;
+}
+declare abstract class ContextManager {
+    abstract getParentSpanIds(): ParentSpanContext | undefined;
+    abstract runInContext<R>(span: ContextSpan, callback: () => R): R;
+    abstract getCurrentSpan(): ContextSpan | undefined;
+    abstract isReady(): boolean;
+}
+declare global {
+    var RAINDROP_CONTEXT_MANAGER: (new () => ContextManager) | undefined;
+    var RAINDROP_ASYNC_LOCAL_STORAGE: (new <T>() => AsyncLocalStorageLike<T>) | undefined;
+}
+
+/**
+ * RaindropEveSpanExporter — a tiny OTel SpanExporter that:
+ *
+ *   1. Ships OTLP/HTTP JSON traces to Raindrop (`<endpoint>/traces`) using a
+ *      Bearer write key, and
+ *   2. Mirrors the same export to a local Workshop daemon when one is
+ *      reachable (explicit URL, env vars, or auto-detect during development).
+ *
+ * It deliberately does NOT depend on the OpenTelemetry SDK at runtime beyond
+ * the structural `ReadableSpan` / `SpanExporter` shapes — those are typed via
+ * peer dependencies so consumers don't pay a second copy of `@opentelemetry/*`.
+ */
+
 type HrTime = [number, number];
 type AttributeValue = string | number | boolean | Array<string | number | boolean | null | undefined> | null | undefined;
 interface Attributes {
@@ -36,11 +171,19 @@ interface ReadableSpan {
     readonly parentSpanId?: string;
     readonly parentSpanContext?: SpanContext;
 }
+interface EveAppGitSpanProcessor {
+    onStart(span: ReadableSpan, parentContext?: unknown): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
 interface ExportResult {
     code: number;
     error?: Error;
 }
 interface RaindropEveExporterOptions {
+    /** Application Git identity. Local discovery requires an explicit sourceDirectory; false disables enrichment. */
+    appGit?: AppGitOptions | false;
     /**
      * Raindrop write key. Required to ship to Raindrop's hosted endpoint; when
      * omitted, the exporter still mirrors to Workshop (when one is reachable).
@@ -98,12 +241,18 @@ declare class RaindropEveSpanExporter {
     private readonly debug;
     private readonly prefix;
     private readonly maxTextFieldChars;
+    private readonly appGitContext;
+    private readonly startedAppGitSpans;
+    private readonly activeAppGitEvents;
+    private readonly appGitOwner;
     private inFlight;
     private shuttingDown;
     private auxShutdowns;
-    constructor(opts?: RaindropEveExporterOptions);
+    constructor(opts?: RaindropEveExporterOptions, appGitContext?: AppGitContext);
     /** True when we have at least one destination (Raindrop or Workshop). */
     hasDestinations(): boolean;
+    captureSpanStart(span: ReadableSpan): void;
+    private releaseStartedAppGitSpan;
     /**
      * Update the OTLP `service.name` attribute. Called by Eve's
      * `setup({ agentName })` so the resource attribute reflects the actual
@@ -122,6 +271,7 @@ declare class RaindropEveSpanExporter {
      */
     attachAuxShutdown(fn: () => Promise<void>): void;
 }
+declare function createEveAppGitSpanProcessor(exporter: RaindropEveSpanExporter): EveAppGitSpanProcessor;
 
 declare const RAINDROP_EVE_SDK_NAME: string;
 declare const RAINDROP_EVE_SDK_VERSION: string;
@@ -240,6 +390,8 @@ interface RaindropEveInstrumentationEventsConfig {
  * Options for {@link defineRaindropInstrumentation}.
  */
 interface RaindropEveInstrumentationOptions {
+    /** Application Git identity. Local discovery requires an explicit sourceDirectory; false disables enrichment. */
+    appGit?: AppGitOptions | false;
     /**
      * `registerOTel` from `@vercel/otel`. Pass the function directly so the
      * SDK doesn't have to dynamically import a peer dep at runtime.
@@ -452,4 +604,4 @@ interface RaindropInstrumentationDefinition {
  */
 declare function defineRaindropInstrumentation(opts?: RaindropEveInstrumentationOptions): RaindropInstrumentationDefinition;
 
-export { RAINDROP_EVE_SDK_NAME, RAINDROP_EVE_SDK_VERSION, type RaindropEveExporterOptions, type RaindropEveInstrumentationChannel, type RaindropEveInstrumentationEventsConfig, type RaindropEveInstrumentationMetadata, type RaindropEveInstrumentationMetadataConfig, type RaindropEveInstrumentationModelInput, type RaindropEveInstrumentationOptions, type RaindropEveInstrumentationSession, type RaindropEveInstrumentationStep, type RaindropEveInstrumentationTurn, RaindropEveSpanExporter, type RaindropEveStepStartedEventInput, type RaindropEveStepStartedEventResult, type RaindropEveStepStartedMetadataInput, type RaindropInstrumentationDefinition, type RegisterOTelFn, _resetCanonicalTurnIds, defineRaindropInstrumentation as default, defineRaindropInstrumentation };
+export { RAINDROP_EVE_SDK_NAME, RAINDROP_EVE_SDK_VERSION, type RaindropEveExporterOptions, type RaindropEveInstrumentationChannel, type RaindropEveInstrumentationEventsConfig, type RaindropEveInstrumentationMetadata, type RaindropEveInstrumentationMetadataConfig, type RaindropEveInstrumentationModelInput, type RaindropEveInstrumentationOptions, type RaindropEveInstrumentationSession, type RaindropEveInstrumentationStep, type RaindropEveInstrumentationTurn, RaindropEveSpanExporter, type RaindropEveStepStartedEventInput, type RaindropEveStepStartedEventResult, type RaindropEveStepStartedMetadataInput, type RaindropInstrumentationDefinition, type RegisterOTelFn, _resetCanonicalTurnIds, createEveAppGitSpanProcessor, defineRaindropInstrumentation as default, defineRaindropInstrumentation };