@dbos-inc/dbos-sdk 0.8.39-preview → 0.8.41-preview

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/ConsoleSpanExporter.js

@@ -0,0 +1,105 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { ExportResultCode, hrTimeToMicroseconds, } from '@opentelemetry/core';
+/**
+ * This is implementation of {@link SpanExporter} that prints spans to the
+ * console. This class can be used for diagnostic purposes.
+ */
+/* eslint-disable no-console */
+var ConsoleSpanExporter = /** @class */ (function () {
+    function ConsoleSpanExporter() {
+    }
+    /**
+     * Export spans.
+     * @param spans
+     * @param resultCallback
+     */
+    ConsoleSpanExporter.prototype.export = function (spans, resultCallback) {
+        return this._sendSpans(spans, resultCallback);
+    };
+    /**
+     * Shutdown the exporter.
+     */
+    ConsoleSpanExporter.prototype.shutdown = function () {
+        this._sendSpans([]);
+        return this.forceFlush();
+    };
+    /**
+     * Exports any pending spans in exporter
+     */
+    ConsoleSpanExporter.prototype.forceFlush = function () {
+        return Promise.resolve();
+    };
+    /**
+     * converts span info into more readable format
+     * @param span
+     */
+    ConsoleSpanExporter.prototype._exportInfo = function (span) {
+        var _a;
+        return {
+            traceId: span.spanContext().traceId,
+            parentId: span.parentSpanId,
+            traceState: (_a = span.spanContext().traceState) === null || _a === void 0 ? void 0 : _a.serialize(),
+            name: span.name,
+            id: span.spanContext().spanId,
+            kind: span.kind,
+            timestamp: hrTimeToMicroseconds(span.startTime),
+            duration: hrTimeToMicroseconds(span.duration),
+            attributes: span.attributes,
+            status: span.status,
+            events: span.events,
+            links: span.links,
+        };
+    };
+    /**
+     * Showing spans in console
+     * @param spans
+     * @param done
+     */
+    ConsoleSpanExporter.prototype._sendSpans = function (spans, done) {
+        var e_1, _a;
+        try {
+            for (var spans_1 = __values(spans), spans_1_1 = spans_1.next(); !spans_1_1.done; spans_1_1 = spans_1.next()) {
+                var span = spans_1_1.value;
+                console.dir(this._exportInfo(span), { depth: 3 });
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (spans_1_1 && !spans_1_1.done && (_a = spans_1.return)) _a.call(spans_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (done) {
+            return done({ code: ExportResultCode.SUCCESS });
+        }
+    };
+    return ConsoleSpanExporter;
+}());
+export { ConsoleSpanExporter };
+//# sourceMappingURL=ConsoleSpanExporter.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/ConsoleSpanExporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConsoleSpanExporter.js","sourceRoot":"","sources":["../../../src/export/ConsoleSpanExporter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;;;;;;;;;;;AAIH,OAAO,EAEL,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAE7B;;;GAGG;AAEH,+BAA+B;AAC/B;IAAA;IAiEA,CAAC;IAhEC;;;;OAIG;IACH,oCAAM,GAAN,UACE,KAAqB,EACrB,cAA8C;QAE9C,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACH,sCAAQ,GAAR;QACE,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QACpB,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,wCAAU,GAAV;QACE,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED;;;OAGG;IACK,yCAAW,GAAnB,UAAoB,IAAkB;;QACpC,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO;YACnC,QAAQ,EAAE,IAAI,CAAC,YAAY;YAC3B,UAAU,EAAE,MAAA,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,0CAAE,SAAS,EAAE;YACtD,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,EAAE,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,MAAM;YAC7B,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,SAAS,EAAE,oBAAoB,CAAC,IAAI,CAAC,SAAS,CAAC;YAC/C,QAAQ,EAAE,oBAAoB,CAAC,IAAI,CAAC,QAAQ,CAAC;YAC7C,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACK,wCAAU,GAAlB,UACE,KAAqB,EACrB,IAAqC;;;YAErC,KAAmB,IAAA,UAAA,SAAA,KAAK,CAAA,4BAAA,+CAAE;gBAArB,IAAM,IAAI,kBAAA;gBACb,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;aACnD;;;;;;;;;QACD,IAAI,IAAI,EAAE;YACR,OAAO,IAAI,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC;SACjD;IACH,CAAC;IACH,0BAAC;AAAD,CAAC,AAjED,IAiEC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { SpanExporter } from './SpanExporter';\nimport { ReadableSpan } from './ReadableSpan';\nimport {\n  ExportResult,\n  ExportResultCode,\n  hrTimeToMicroseconds,\n} from '@opentelemetry/core';\n\n/**\n * This is implementation of {@link SpanExporter} that prints spans to the\n * console. This class can be used for diagnostic purposes.\n */\n\n/* eslint-disable no-console */\nexport class ConsoleSpanExporter implements SpanExporter {\n  /**\n   * Export spans.\n   * @param spans\n   * @param resultCallback\n   */\n  export(\n    spans: ReadableSpan[],\n    resultCallback: (result: ExportResult) => void\n  ): void {\n    return this._sendSpans(spans, resultCallback);\n  }\n\n  /**\n   * Shutdown the exporter.\n   */\n  shutdown(): Promise<void> {\n    this._sendSpans([]);\n    return this.forceFlush();\n  }\n\n  /**\n   * Exports any pending spans in exporter\n   */\n  forceFlush(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  /**\n   * converts span info into more readable format\n   * @param span\n   */\n  private _exportInfo(span: ReadableSpan) {\n    return {\n      traceId: span.spanContext().traceId,\n      parentId: span.parentSpanId,\n      traceState: span.spanContext().traceState?.serialize(),\n      name: span.name,\n      id: span.spanContext().spanId,\n      kind: span.kind,\n      timestamp: hrTimeToMicroseconds(span.startTime),\n      duration: hrTimeToMicroseconds(span.duration),\n      attributes: span.attributes,\n      status: span.status,\n      events: span.events,\n      links: span.links,\n    };\n  }\n\n  /**\n   * Showing spans in console\n   * @param spans\n   * @param done\n   */\n  private _sendSpans(\n    spans: ReadableSpan[],\n    done?: (result: ExportResult) => void\n  ): void {\n    for (const span of spans) {\n      console.dir(this._exportInfo(span), { depth: 3 });\n    }\n    if (done) {\n      return done({ code: ExportResultCode.SUCCESS });\n    }\n  }\n}\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/InMemorySpanExporter.d.ts

@@ -0,0 +1,25 @@
+import { SpanExporter } from './SpanExporter';
+import { ReadableSpan } from './ReadableSpan';
+import { ExportResult } from '@opentelemetry/core';
+/**
+ * This class can be used for testing purposes. It stores the exported spans
+ * in a list in memory that can be retrieved using the `getFinishedSpans()`
+ * method.
+ */
+export declare class InMemorySpanExporter implements SpanExporter {
+    private _finishedSpans;
+    /**
+     * Indicates if the exporter has been "shutdown."
+     * When false, exported spans will not be stored in-memory.
+     */
+    protected _stopped: boolean;
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    /**
+     * Exports any pending spans in the exporter
+     */
+    forceFlush(): Promise<void>;
+    reset(): void;
+    getFinishedSpans(): ReadableSpan[];
+}
+//# sourceMappingURL=InMemorySpanExporter.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/InMemorySpanExporter.js

@@ -0,0 +1,86 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { ExportResultCode } from '@opentelemetry/core';
+/**
+ * This class can be used for testing purposes. It stores the exported spans
+ * in a list in memory that can be retrieved using the `getFinishedSpans()`
+ * method.
+ */
+var InMemorySpanExporter = /** @class */ (function () {
+    function InMemorySpanExporter() {
+        this._finishedSpans = [];
+        /**
+         * Indicates if the exporter has been "shutdown."
+         * When false, exported spans will not be stored in-memory.
+         */
+        this._stopped = false;
+    }
+    InMemorySpanExporter.prototype.export = function (spans, resultCallback) {
+        var _a;
+        if (this._stopped)
+            return resultCallback({
+                code: ExportResultCode.FAILED,
+                error: new Error('Exporter has been stopped'),
+            });
+        (_a = this._finishedSpans).push.apply(_a, __spreadArray([], __read(spans), false));
+        setTimeout(function () { return resultCallback({ code: ExportResultCode.SUCCESS }); }, 0);
+    };
+    InMemorySpanExporter.prototype.shutdown = function () {
+        this._stopped = true;
+        this._finishedSpans = [];
+        return this.forceFlush();
+    };
+    /**
+     * Exports any pending spans in the exporter
+     */
+    InMemorySpanExporter.prototype.forceFlush = function () {
+        return Promise.resolve();
+    };
+    InMemorySpanExporter.prototype.reset = function () {
+        this._finishedSpans = [];
+    };
+    InMemorySpanExporter.prototype.getFinishedSpans = function () {
+        return this._finishedSpans;
+    };
+    return InMemorySpanExporter;
+}());
+export { InMemorySpanExporter };
+//# sourceMappingURL=InMemorySpanExporter.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/InMemorySpanExporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemorySpanExporter.js","sourceRoot":"","sources":["../../../src/export/InMemorySpanExporter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;;;;;;;;;;;;;;;;;;;;;;;;;AAIH,OAAO,EAAgB,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAErE;;;;GAIG;AACH;IAAA;QACU,mBAAc,GAAmB,EAAE,CAAC;QAC5C;;;WAGG;QACO,aAAQ,GAAG,KAAK,CAAC;IAoC7B,CAAC;IAlCC,qCAAM,GAAN,UACE,KAAqB,EACrB,cAA8C;;QAE9C,IAAI,IAAI,CAAC,QAAQ;YACf,OAAO,cAAc,CAAC;gBACpB,IAAI,EAAE,gBAAgB,CAAC,MAAM;gBAC7B,KAAK,EAAE,IAAI,KAAK,CAAC,2BAA2B,CAAC;aAC9C,CAAC,CAAC;QACL,CAAA,KAAA,IAAI,CAAC,cAAc,CAAA,CAAC,IAAI,oCAAI,KAAK,WAAE;QAEnC,UAAU,CAAC,cAAM,OAAA,cAAc,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,OAAO,EAAE,CAAC,EAAlD,CAAkD,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC;IAED,uCAAQ,GAAR;QACE,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;QACzB,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,yCAAU,GAAV;QACE,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED,oCAAK,GAAL;QACE,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;IAC3B,CAAC;IAED,+CAAgB,GAAhB;QACE,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IACH,2BAAC;AAAD,CAAC,AA1CD,IA0CC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { SpanExporter } from './SpanExporter';\nimport { ReadableSpan } from './ReadableSpan';\nimport { ExportResult, ExportResultCode } from '@opentelemetry/core';\n\n/**\n * This class can be used for testing purposes. It stores the exported spans\n * in a list in memory that can be retrieved using the `getFinishedSpans()`\n * method.\n */\nexport class InMemorySpanExporter implements SpanExporter {\n  private _finishedSpans: ReadableSpan[] = [];\n  /**\n   * Indicates if the exporter has been \"shutdown.\"\n   * When false, exported spans will not be stored in-memory.\n   */\n  protected _stopped = false;\n\n  export(\n    spans: ReadableSpan[],\n    resultCallback: (result: ExportResult) => void\n  ): void {\n    if (this._stopped)\n      return resultCallback({\n        code: ExportResultCode.FAILED,\n        error: new Error('Exporter has been stopped'),\n      });\n    this._finishedSpans.push(...spans);\n\n    setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);\n  }\n\n  shutdown(): Promise<void> {\n    this._stopped = true;\n    this._finishedSpans = [];\n    return this.forceFlush();\n  }\n\n  /**\n   * Exports any pending spans in the exporter\n   */\n  forceFlush(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  reset(): void {\n    this._finishedSpans = [];\n  }\n\n  getFinishedSpans(): ReadableSpan[] {\n    return this._finishedSpans;\n  }\n}\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/NoopSpanProcessor.d.ts

@@ -0,0 +1,12 @@
+import { Context } from '@opentelemetry/api';
+import { ReadableSpan } from './ReadableSpan';
+import { Span } from '../Span';
+import { SpanProcessor } from '../SpanProcessor';
+/** No-op implementation of SpanProcessor */
+export declare class NoopSpanProcessor implements SpanProcessor {
+    onStart(_span: Span, _context: Context): void;
+    onEnd(_span: ReadableSpan): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+//# sourceMappingURL=NoopSpanProcessor.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/NoopSpanProcessor.js

@@ -0,0 +1,31 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** No-op implementation of SpanProcessor */
+var NoopSpanProcessor = /** @class */ (function () {
+    function NoopSpanProcessor() {
+    }
+    NoopSpanProcessor.prototype.onStart = function (_span, _context) { };
+    NoopSpanProcessor.prototype.onEnd = function (_span) { };
+    NoopSpanProcessor.prototype.shutdown = function () {
+        return Promise.resolve();
+    };
+    NoopSpanProcessor.prototype.forceFlush = function () {
+        return Promise.resolve();
+    };
+    return NoopSpanProcessor;
+}());
+export { NoopSpanProcessor };
+//# sourceMappingURL=NoopSpanProcessor.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/NoopSpanProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoopSpanProcessor.js","sourceRoot":"","sources":["../../../src/export/NoopSpanProcessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAOH,4CAA4C;AAC5C;IAAA;IASA,CAAC;IARC,mCAAO,GAAP,UAAQ,KAAW,EAAE,QAAiB,IAAS,CAAC;IAChD,iCAAK,GAAL,UAAM,KAAmB,IAAS,CAAC;IACnC,oCAAQ,GAAR;QACE,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IACD,sCAAU,GAAV;QACE,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IACH,wBAAC;AAAD,CAAC,AATD,IASC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Context } from '@opentelemetry/api';\nimport { ReadableSpan } from './ReadableSpan';\nimport { Span } from '../Span';\nimport { SpanProcessor } from '../SpanProcessor';\n\n/** No-op implementation of SpanProcessor */\nexport class NoopSpanProcessor implements SpanProcessor {\n  onStart(_span: Span, _context: Context): void {}\n  onEnd(_span: ReadableSpan): void {}\n  shutdown(): Promise<void> {\n    return Promise.resolve();\n  }\n  forceFlush(): Promise<void> {\n    return Promise.resolve();\n  }\n}\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/ReadableSpan.d.ts

@@ -0,0 +1,24 @@
+import { SpanKind, SpanStatus, SpanAttributes, HrTime, Link, SpanContext } from '@opentelemetry/api';
+import { IResource } from '@opentelemetry/resources';
+import { InstrumentationLibrary } from '@opentelemetry/core';
+import { TimedEvent } from '../TimedEvent';
+export interface ReadableSpan {
+    readonly name: string;
+    readonly kind: SpanKind;
+    readonly spanContext: () => SpanContext;
+    readonly parentSpanId?: string;
+    readonly startTime: HrTime;
+    readonly endTime: HrTime;
+    readonly status: SpanStatus;
+    readonly attributes: SpanAttributes;
+    readonly links: Link[];
+    readonly events: TimedEvent[];
+    readonly duration: HrTime;
+    readonly ended: boolean;
+    readonly resource: IResource;
+    readonly instrumentationLibrary: InstrumentationLibrary;
+    readonly droppedAttributesCount: number;
+    readonly droppedEventsCount: number;
+    readonly droppedLinksCount: number;
+}
+//# sourceMappingURL=ReadableSpan.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/ReadableSpan.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};
+//# sourceMappingURL=ReadableSpan.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/ReadableSpan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadableSpan.js","sourceRoot":"","sources":["../../../src/export/ReadableSpan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  SpanKind,\n  SpanStatus,\n  SpanAttributes,\n  HrTime,\n  Link,\n  SpanContext,\n} from '@opentelemetry/api';\nimport { IResource } from '@opentelemetry/resources';\nimport { InstrumentationLibrary } from '@opentelemetry/core';\nimport { TimedEvent } from '../TimedEvent';\n\nexport interface ReadableSpan {\n  readonly name: string;\n  readonly kind: SpanKind;\n  readonly spanContext: () => SpanContext;\n  readonly parentSpanId?: string;\n  readonly startTime: HrTime;\n  readonly endTime: HrTime;\n  readonly status: SpanStatus;\n  readonly attributes: SpanAttributes;\n  readonly links: Link[];\n  readonly events: TimedEvent[];\n  readonly duration: HrTime;\n  readonly ended: boolean;\n  readonly resource: IResource;\n  readonly instrumentationLibrary: InstrumentationLibrary;\n  readonly droppedAttributesCount: number;\n  readonly droppedEventsCount: number;\n  readonly droppedLinksCount: number;\n}\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/SimpleSpanProcessor.d.ts

@@ -0,0 +1,23 @@
+import { Context } from '@opentelemetry/api';
+import { Span } from '../Span';
+import { SpanProcessor } from '../SpanProcessor';
+import { ReadableSpan } from './ReadableSpan';
+import { SpanExporter } from './SpanExporter';
+/**
+ * An implementation of the {@link SpanProcessor} that converts the {@link Span}
+ * to {@link ReadableSpan} and passes it to the configured exporter.
+ *
+ * Only spans that are sampled are converted.
+ */
+export declare class SimpleSpanProcessor implements SpanProcessor {
+    private readonly _exporter;
+    private _shutdownOnce;
+    private _unresolvedExports;
+    constructor(_exporter: SpanExporter);
+    forceFlush(): Promise<void>;
+    onStart(_span: Span, _parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    shutdown(): Promise<void>;
+    private _shutdown;
+}
+//# sourceMappingURL=SimpleSpanProcessor.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/SimpleSpanProcessor.js

@@ -0,0 +1,135 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { TraceFlags } from '@opentelemetry/api';
+import { internal, ExportResultCode, globalErrorHandler, BindOnceFuture, } from '@opentelemetry/core';
+/**
+ * An implementation of the {@link SpanProcessor} that converts the {@link Span}
+ * to {@link ReadableSpan} and passes it to the configured exporter.
+ *
+ * Only spans that are sampled are converted.
+ */
+var SimpleSpanProcessor = /** @class */ (function () {
+    function SimpleSpanProcessor(_exporter) {
+        this._exporter = _exporter;
+        this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+        this._unresolvedExports = new Set();
+    }
+    SimpleSpanProcessor.prototype.forceFlush = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // await unresolved resources before resolving
+                    return [4 /*yield*/, Promise.all(Array.from(this._unresolvedExports))];
+                    case 1:
+                        // await unresolved resources before resolving
+                        _a.sent();
+                        if (!this._exporter.forceFlush) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this._exporter.forceFlush()];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SimpleSpanProcessor.prototype.onStart = function (_span, _parentContext) { };
+    SimpleSpanProcessor.prototype.onEnd = function (span) {
+        var _this = this;
+        var _a, _b;
+        if (this._shutdownOnce.isCalled) {
+            return;
+        }
+        if ((span.spanContext().traceFlags & TraceFlags.SAMPLED) === 0) {
+            return;
+        }
+        var doExport = function () {
+            return internal
+                ._export(_this._exporter, [span])
+                .then(function (result) {
+                var _a;
+                if (result.code !== ExportResultCode.SUCCESS) {
+                    globalErrorHandler((_a = result.error) !== null && _a !== void 0 ? _a : new Error("SimpleSpanProcessor: span export failed (status " + result + ")"));
+                }
+            })
+                .catch(function (error) {
+                globalErrorHandler(error);
+            });
+        };
+        // Avoid scheduling a promise to make the behavior more predictable and easier to test
+        if (span.resource.asyncAttributesPending) {
+            var exportPromise_1 = (_b = (_a = span.resource).waitForAsyncAttributes) === null || _b === void 0 ? void 0 : _b.call(_a).then(function () {
+                if (exportPromise_1 != null) {
+                    _this._unresolvedExports.delete(exportPromise_1);
+                }
+                return doExport();
+            }, function (err) { return globalErrorHandler(err); });
+            // store the unresolved exports
+            if (exportPromise_1 != null) {
+                this._unresolvedExports.add(exportPromise_1);
+            }
+        }
+        else {
+            void doExport();
+        }
+    };
+    SimpleSpanProcessor.prototype.shutdown = function () {
+        return this._shutdownOnce.call();
+    };
+    SimpleSpanProcessor.prototype._shutdown = function () {
+        return this._exporter.shutdown();
+    };
+    return SimpleSpanProcessor;
+}());
+export { SimpleSpanProcessor };
+//# sourceMappingURL=SimpleSpanProcessor.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/SimpleSpanProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimpleSpanProcessor.js","sourceRoot":"","sources":["../../../src/export/SimpleSpanProcessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,OAAO,EAAW,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,GAEf,MAAM,qBAAqB,CAAC;AAO7B;;;;;GAKG;AACH;IAIE,6BAA6B,SAAuB;QAAvB,cAAS,GAAT,SAAS,CAAc;QAClD,IAAI,CAAC,aAAa,GAAG,IAAI,cAAc,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QAC9D,IAAI,CAAC,kBAAkB,GAAG,IAAI,GAAG,EAAiB,CAAC;IACrD,CAAC;IAEK,wCAAU,GAAhB;;;;;oBACE,8CAA8C;oBAC9C,qBAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,EAAA;;wBADtD,8CAA8C;wBAC9C,SAAsD,CAAC;6BACnD,IAAI,CAAC,SAAS,CAAC,UAAU,EAAzB,wBAAyB;wBAC3B,qBAAM,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,EAAA;;wBAAjC,SAAiC,CAAC;;;;;;KAErC;IAED,qCAAO,GAAP,UAAQ,KAAW,EAAE,cAAuB,IAAS,CAAC;IAEtD,mCAAK,GAAL,UAAM,IAAkB;QAAxB,iBA+CC;;QA9CC,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE;YAC/B,OAAO;SACR;QAED,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,GAAG,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YAC9D,OAAO;SACR;QAED,IAAM,QAAQ,GAAG;YACf,OAAA,QAAQ;iBACL,OAAO,CAAC,KAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC;iBAC/B,IAAI,CAAC,UAAC,MAAoB;;gBACzB,IAAI,MAAM,CAAC,IAAI,KAAK,gBAAgB,CAAC,OAAO,EAAE;oBAC5C,kBAAkB,CAChB,MAAA,MAAM,CAAC,KAAK,mCACV,IAAI,KAAK,CACP,qDAAmD,MAAM,MAAG,CAC7D,CACJ,CAAC;iBACH;YACH,CAAC,CAAC;iBACD,KAAK,CAAC,UAAA,KAAK;gBACV,kBAAkB,CAAC,KAAK,CAAC,CAAC;YAC5B,CAAC,CAAC;QAdJ,CAcI,CAAC;QAEP,sFAAsF;QACtF,IAAI,IAAI,CAAC,QAAQ,CAAC,sBAAsB,EAAE;YACxC,IAAM,eAAa,GAAG,MAAA,MAAC,IAAI,CAAC,QAAqB,EAC9C,sBAAsB,mDACtB,IAAI,CACH;gBACE,IAAI,eAAa,IAAI,IAAI,EAAE;oBACzB,KAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,eAAa,CAAC,CAAC;iBAC/C;gBACD,OAAO,QAAQ,EAAE,CAAC;YACpB,CAAC,EACD,UAAA,GAAG,IAAI,OAAA,kBAAkB,CAAC,GAAG,CAAC,EAAvB,CAAuB,CAC/B,CAAC;YAEJ,+BAA+B;YAC/B,IAAI,eAAa,IAAI,IAAI,EAAE;gBACzB,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,eAAa,CAAC,CAAC;aAC5C;SACF;aAAM;YACL,KAAK,QAAQ,EAAE,CAAC;SACjB;IACH,CAAC;IAED,sCAAQ,GAAR;QACE,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;IACnC,CAAC;IAEO,uCAAS,GAAjB;QACE,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IACnC,CAAC;IACH,0BAAC;AAAD,CAAC,AA3ED,IA2EC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Context, TraceFlags } from '@opentelemetry/api';\nimport {\n  internal,\n  ExportResultCode,\n  globalErrorHandler,\n  BindOnceFuture,\n  ExportResult,\n} from '@opentelemetry/core';\nimport { Span } from '../Span';\nimport { SpanProcessor } from '../SpanProcessor';\nimport { ReadableSpan } from './ReadableSpan';\nimport { SpanExporter } from './SpanExporter';\nimport { Resource } from '@opentelemetry/resources';\n\n/**\n * An implementation of the {@link SpanProcessor} that converts the {@link Span}\n * to {@link ReadableSpan} and passes it to the configured exporter.\n *\n * Only spans that are sampled are converted.\n */\nexport class SimpleSpanProcessor implements SpanProcessor {\n  private _shutdownOnce: BindOnceFuture<void>;\n  private _unresolvedExports: Set<Promise<void>>;\n\n  constructor(private readonly _exporter: SpanExporter) {\n    this._shutdownOnce = new BindOnceFuture(this._shutdown, this);\n    this._unresolvedExports = new Set<Promise<void>>();\n  }\n\n  async forceFlush(): Promise<void> {\n    // await unresolved resources before resolving\n    await Promise.all(Array.from(this._unresolvedExports));\n    if (this._exporter.forceFlush) {\n      await this._exporter.forceFlush();\n    }\n  }\n\n  onStart(_span: Span, _parentContext: Context): void {}\n\n  onEnd(span: ReadableSpan): void {\n    if (this._shutdownOnce.isCalled) {\n      return;\n    }\n\n    if ((span.spanContext().traceFlags & TraceFlags.SAMPLED) === 0) {\n      return;\n    }\n\n    const doExport = () =>\n      internal\n        ._export(this._exporter, [span])\n        .then((result: ExportResult) => {\n          if (result.code !== ExportResultCode.SUCCESS) {\n            globalErrorHandler(\n              result.error ??\n                new Error(\n                  `SimpleSpanProcessor: span export failed (status ${result})`\n                )\n            );\n          }\n        })\n        .catch(error => {\n          globalErrorHandler(error);\n        });\n\n    // Avoid scheduling a promise to make the behavior more predictable and easier to test\n    if (span.resource.asyncAttributesPending) {\n      const exportPromise = (span.resource as Resource)\n        .waitForAsyncAttributes?.()\n        .then(\n          () => {\n            if (exportPromise != null) {\n              this._unresolvedExports.delete(exportPromise);\n            }\n            return doExport();\n          },\n          err => globalErrorHandler(err)\n        );\n\n      // store the unresolved exports\n      if (exportPromise != null) {\n        this._unresolvedExports.add(exportPromise);\n      }\n    } else {\n      void doExport();\n    }\n  }\n\n  shutdown(): Promise<void> {\n    return this._shutdownOnce.call();\n  }\n\n  private _shutdown(): Promise<void> {\n    return this._exporter.shutdown();\n  }\n}\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/SpanExporter.d.ts

@@ -0,0 +1,21 @@
+import { ExportResult } from '@opentelemetry/core';
+import { ReadableSpan } from './ReadableSpan';
+/**
+ * An interface that allows different tracing services to export recorded data
+ * for sampled spans in their own format.
+ *
+ * To export data this MUST be register to the Tracer SDK using a optional
+ * config.
+ */
+export interface SpanExporter {
+    /**
+     * Called to export sampled {@link ReadableSpan}s.
+     * @param spans the list of sampled Spans to be exported.
+     */
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    /** Stops the exporter. */
+    shutdown(): Promise<void>;
+    /** Immediately export all spans */
+    forceFlush?(): Promise<void>;
+}
+//# sourceMappingURL=SpanExporter.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/SpanExporter.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};
+//# sourceMappingURL=SpanExporter.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/SpanExporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpanExporter.js","sourceRoot":"","sources":["../../../src/export/SpanExporter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ExportResult } from '@opentelemetry/core';\nimport { ReadableSpan } from './ReadableSpan';\n\n/**\n * An interface that allows different tracing services to export recorded data\n * for sampled spans in their own format.\n *\n * To export data this MUST be register to the Tracer SDK using a optional\n * config.\n */\nexport interface SpanExporter {\n  /**\n   * Called to export sampled {@link ReadableSpan}s.\n   * @param spans the list of sampled Spans to be exported.\n   */\n  export(\n    spans: ReadableSpan[],\n    resultCallback: (result: ExportResult) => void\n  ): void;\n\n  /** Stops the exporter. */\n  shutdown(): Promise<void>;\n\n  /** Immediately export all spans */\n  forceFlush?(): Promise<void>;\n}\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/index.d.ts

@@ -0,0 +1,20 @@
+export * from './Tracer';
+export * from './BasicTracerProvider';
+export * from './platform';
+export * from './export/ConsoleSpanExporter';
+export * from './export/InMemorySpanExporter';
+export * from './export/ReadableSpan';
+export * from './export/SimpleSpanProcessor';
+export * from './export/SpanExporter';
+export * from './export/NoopSpanProcessor';
+export * from './sampler/AlwaysOffSampler';
+export * from './sampler/AlwaysOnSampler';
+export * from './sampler/ParentBasedSampler';
+export * from './sampler/TraceIdRatioBasedSampler';
+export * from './Sampler';
+export * from './Span';
+export * from './SpanProcessor';
+export * from './TimedEvent';
+export * from './types';
+export * from './IdGenerator';
+//# sourceMappingURL=index.d.ts.map

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/index.js

@@ -0,0 +1,35 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './Tracer';
+export * from './BasicTracerProvider';
+export * from './platform';
+export * from './export/ConsoleSpanExporter';
+export * from './export/InMemorySpanExporter';
+export * from './export/ReadableSpan';
+export * from './export/SimpleSpanProcessor';
+export * from './export/SpanExporter';
+export * from './export/NoopSpanProcessor';
+export * from './sampler/AlwaysOffSampler';
+export * from './sampler/AlwaysOnSampler';
+export * from './sampler/ParentBasedSampler';
+export * from './sampler/TraceIdRatioBasedSampler';
+export * from './Sampler';
+export * from './Span';
+export * from './SpanProcessor';
+export * from './TimedEvent';
+export * from './types';
+export * from './IdGenerator';
+//# sourceMappingURL=index.js.map

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,uBAAuB,CAAC;AACtC,cAAc,YAAY,CAAC;AAC3B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oCAAoC,CAAC;AACnD,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport * from './Tracer';\nexport * from './BasicTracerProvider';\nexport * from './platform';\nexport * from './export/ConsoleSpanExporter';\nexport * from './export/InMemorySpanExporter';\nexport * from './export/ReadableSpan';\nexport * from './export/SimpleSpanProcessor';\nexport * from './export/SpanExporter';\nexport * from './export/NoopSpanProcessor';\nexport * from './sampler/AlwaysOffSampler';\nexport * from './sampler/AlwaysOnSampler';\nexport * from './sampler/ParentBasedSampler';\nexport * from './sampler/TraceIdRatioBasedSampler';\nexport * from './Sampler';\nexport * from './Span';\nexport * from './SpanProcessor';\nexport * from './TimedEvent';\nexport * from './types';\nexport * from './IdGenerator';\n"]}

package/packages/dbos-cloud/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/browser/RandomIdGenerator.d.ts

@@ -0,0 +1,14 @@
+import { IdGenerator } from '../../IdGenerator';
+export declare class RandomIdGenerator implements IdGenerator {
+    /**
+     * Returns a random 16-byte trace ID formatted/encoded as a 32 lowercase hex
+     * characters corresponding to 128 bits.
+     */
+    generateTraceId: () => string;
+    /**
+     * Returns a random 8-byte span ID formatted/encoded as a 16 lowercase hex
+     * characters corresponding to 64 bits.
+     */
+    generateSpanId: () => string;
+}
+//# sourceMappingURL=RandomIdGenerator.d.ts.map