agentv 2.6.0 → 2.7.1-next.1

package/dist/chunk-C5GOHBQM.js

@@ -0,0 +1,84 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+
+// ../../packages/core/dist/chunk-HFSYZHGF.js
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+var OtlpJsonFileExporter = class {
+  // biome-ignore lint/suspicious/noExplicitAny: serialized span data
+  spans = [];
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  export(spans, resultCallback) {
+    for (const span of spans) {
+      this.spans.push({
+        traceId: span.spanContext().traceId,
+        spanId: span.spanContext().spanId,
+        parentSpanId: span.parentSpanId || void 0,
+        name: span.name,
+        kind: span.kind,
+        startTimeUnixNano: hrTimeToNanos(span.startTime),
+        endTimeUnixNano: hrTimeToNanos(span.endTime),
+        attributes: convertAttributes(span.attributes),
+        status: span.status,
+        events: span.events?.map(
+          (e) => ({
+            name: e.name,
+            timeUnixNano: hrTimeToNanos(e.time),
+            attributes: convertAttributes(e.attributes)
+          })
+        )
+      });
+    }
+    resultCallback({ code: 0 });
+  }
+  async shutdown() {
+    await this.flush();
+  }
+  async forceFlush() {
+    await this.flush();
+  }
+  async flush() {
+    if (this.spans.length === 0) return;
+    await mkdir(dirname(this.filePath), { recursive: true });
+    const otlpJson = {
+      resourceSpans: [
+        {
+          resource: { attributes: [] },
+          scopeSpans: [
+            {
+              scope: { name: "agentv", version: "1.0.0" },
+              spans: this.spans
+            }
+          ]
+        }
+      ]
+    };
+    const { writeFile } = await import("node:fs/promises");
+    await writeFile(this.filePath, JSON.stringify(otlpJson, null, 2));
+  }
+};
+function hrTimeToNanos(hrTime) {
+  return String(hrTime[0] * 1e9 + hrTime[1]);
+}
+function convertAttributes(attrs) {
+  return Object.entries(attrs || {}).map(([key, value]) => ({
+    key,
+    value: serializeAttributeValue(value)
+  }));
+}
+function serializeAttributeValue(value) {
+  if (typeof value === "string") return { stringValue: value };
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? { intValue: value } : { doubleValue: value };
+  }
+  if (typeof value === "boolean") return { boolValue: value };
+  if (Array.isArray(value)) return { arrayValue: { values: value.map(serializeAttributeValue) } };
+  return { stringValue: String(value) };
+}
+
+export {
+  OtlpJsonFileExporter
+};
+//# sourceMappingURL=chunk-C5GOHBQM.js.map

package/dist/chunk-C5GOHBQM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../packages/core/src/observability/otlp-json-file-exporter.ts"],"sourcesContent":["import { mkdir } from 'node:fs/promises';\nimport { dirname } from 'node:path';\n\n// biome-ignore lint/suspicious/noExplicitAny: OTel ReadableSpan loaded dynamically\ntype ReadableSpan = any;\n\n/**\n * SpanExporter that writes OTLP JSON (the standard OTel wire format) to a file.\n * The file can be imported by any OTel-compatible backend.\n */\nexport class OtlpJsonFileExporter {\n  // biome-ignore lint/suspicious/noExplicitAny: serialized span data\n  private spans: any[] = [];\n  private filePath: string;\n\n  constructor(filePath: string) {\n    this.filePath = filePath;\n  }\n\n  export(spans: ReadableSpan[], resultCallback: (result: { code: number }) => void): void {\n    for (const span of spans) {\n      this.spans.push({\n        traceId: span.spanContext().traceId,\n        spanId: span.spanContext().spanId,\n        parentSpanId: span.parentSpanId || undefined,\n        name: span.name,\n        kind: span.kind,\n        startTimeUnixNano: hrTimeToNanos(span.startTime),\n        endTimeUnixNano: hrTimeToNanos(span.endTime),\n        attributes: convertAttributes(span.attributes),\n        status: span.status,\n        events: span.events?.map(\n          (e: { name: string; time: [number, number]; attributes?: Record<string, unknown> }) => ({\n            name: e.name,\n            timeUnixNano: hrTimeToNanos(e.time),\n            attributes: convertAttributes(e.attributes),\n          }),\n        ),\n      });\n    }\n    resultCallback({ code: 0 }); // SUCCESS\n  }\n\n  async shutdown(): Promise<void> {\n    await this.flush();\n  }\n\n  async forceFlush(): Promise<void> {\n    await this.flush();\n  }\n\n  private async flush(): Promise<void> {\n    if (this.spans.length === 0) return;\n\n    await mkdir(dirname(this.filePath), { recursive: true });\n\n    const otlpJson = {\n      resourceSpans: [\n        {\n          resource: { attributes: [] },\n          scopeSpans: [\n            {\n              scope: { name: 'agentv', version: '1.0.0' },\n              spans: this.spans,\n            },\n          ],\n        },\n      ],\n    };\n\n    const { writeFile } = await import('node:fs/promises');\n    await writeFile(this.filePath, JSON.stringify(otlpJson, null, 2));\n  }\n}\n\nfunction hrTimeToNanos(hrTime: [number, number]): string {\n  return String(hrTime[0] * 1_000_000_000 + hrTime[1]);\n}\n\nfunction convertAttributes(\n  attrs: Record<string, unknown> | undefined,\n): Array<{ key: string; value: unknown }> {\n  return Object.entries(attrs || {}).map(([key, value]) => ({\n    key,\n    value: serializeAttributeValue(value),\n  }));\n}\n\nfunction serializeAttributeValue(value: unknown): unknown {\n  if (typeof value === 'string') return { stringValue: value };\n  if (typeof value === 'number') {\n    return Number.isInteger(value) ? { intValue: value } : { doubleValue: value };\n  }\n  if (typeof value === 'boolean') return { boolValue: value };\n  if (Array.isArray(value)) return { arrayValue: { values: value.map(serializeAttributeValue) } };\n  return { stringValue: String(value) };\n}\n"],"mappings":";;;AAAA,SAAS,aAAa;AACtB,SAAS,eAAe;AASjB,IAAM,uBAAN,MAA2B;;EAExB,QAAe,CAAC;EAChB;EAER,YAAY,UAAkB;AAC5B,SAAK,WAAW;EAClB;EAEA,OAAO,OAAuB,gBAA0D;AACtF,eAAW,QAAQ,OAAO;AACxB,WAAK,MAAM,KAAK;QACd,SAAS,KAAK,YAAY,EAAE;QAC5B,QAAQ,KAAK,YAAY,EAAE;QAC3B,cAAc,KAAK,gBAAgB;QACnC,MAAM,KAAK;QACX,MAAM,KAAK;QACX,mBAAmB,cAAc,KAAK,SAAS;QAC/C,iBAAiB,cAAc,KAAK,OAAO;QAC3C,YAAY,kBAAkB,KAAK,UAAU;QAC7C,QAAQ,KAAK;QACb,QAAQ,KAAK,QAAQ;UACnB,CAAC,OAAuF;YACtF,MAAM,EAAE;YACR,cAAc,cAAc,EAAE,IAAI;YAClC,YAAY,kBAAkB,EAAE,UAAU;UAC5C;QACF;MACF,CAAC;IACH;AACA,mBAAe,EAAE,MAAM,EAAE,CAAC;EAC5B;EAEA,MAAM,WAA0B;AAC9B,UAAM,KAAK,MAAM;EACnB;EAEA,MAAM,aAA4B;AAChC,UAAM,KAAK,MAAM;EACnB;EAEA,MAAc,QAAuB;AACnC,QAAI,KAAK,MAAM,WAAW,EAAG;AAE7B,UAAM,MAAM,QAAQ,KAAK,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;AAEvD,UAAM,WAAW;MACf,eAAe;QACb;UACE,UAAU,EAAE,YAAY,CAAC,EAAE;UAC3B,YAAY;YACV;cACE,OAAO,EAAE,MAAM,UAAU,SAAS,QAAQ;cAC1C,OAAO,KAAK;YACd;UACF;QACF;MACF;IACF;AAEA,UAAM,EAAE,UAAU,IAAI,MAAM,OAAO,kBAAkB;AACrD,UAAM,UAAU,KAAK,UAAU,KAAK,UAAU,UAAU,MAAM,CAAC,CAAC;EAClE;AACF;AAEA,SAAS,cAAc,QAAkC;AACvD,SAAO,OAAO,OAAO,CAAC,IAAI,MAAgB,OAAO,CAAC,CAAC;AACrD;AAEA,SAAS,kBACP,OACwC;AACxC,SAAO,OAAO,QAAQ,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,OAAO;IACxD;IACA,OAAO,wBAAwB,KAAK;EACtC,EAAE;AACJ;AAEA,SAAS,wBAAwB,OAAyB;AACxD,MAAI,OAAO,UAAU,SAAU,QAAO,EAAE,aAAa,MAAM;AAC3D,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,OAAO,UAAU,KAAK,IAAI,EAAE,UAAU,MAAM,IAAI,EAAE,aAAa,MAAM;EAC9E;AACA,MAAI,OAAO,UAAU,UAAW,QAAO,EAAE,WAAW,MAAM;AAC1D,MAAI,MAAM,QAAQ,KAAK,EAAG,QAAO,EAAE,YAAY,EAAE,QAAQ,MAAM,IAAI,uBAAuB,EAAE,EAAE;AAC9F,SAAO,EAAE,aAAa,OAAO,KAAK,EAAE;AACtC;","names":[]}

package/dist/chunk-FV32QHPB.js

@@ -0,0 +1,565 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  SDK_INFO,
+  getStringFromEnv,
+  init_esm as init_esm3
+} from "./chunk-SR4I5KET.js";
+import {
+  ATTR_SERVICE_NAME,
+  ATTR_TELEMETRY_SDK_LANGUAGE,
+  ATTR_TELEMETRY_SDK_NAME,
+  ATTR_TELEMETRY_SDK_VERSION,
+  init_esm as init_esm2
+} from "./chunk-VQ2ZO7XJ.js";
+import {
+  diag,
+  init_esm
+} from "./chunk-LRULMAAA.js";
+import {
+  __esm
+} from "./chunk-5H446C7X.js";
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/default-service-name.js
+function defaultServiceName() {
+  if (serviceName === void 0) {
+    try {
+      const argv0 = globalThis.process.argv0;
+      serviceName = argv0 ? `unknown_service:${argv0}` : "unknown_service";
+    } catch {
+      serviceName = "unknown_service";
+    }
+  }
+  return serviceName;
+}
+var serviceName;
+var init_default_service_name = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/default-service-name.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/utils.js
+var isPromiseLike;
+var init_utils = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/utils.js"() {
+    "use strict";
+    isPromiseLike = (val) => {
+      return val !== null && typeof val === "object" && typeof val.then === "function";
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/ResourceImpl.js
+function resourceFromAttributes(attributes, options) {
+  return ResourceImpl.FromAttributeList(Object.entries(attributes), options);
+}
+function resourceFromDetectedResource(detectedResource, options) {
+  return new ResourceImpl(detectedResource, options);
+}
+function emptyResource() {
+  return resourceFromAttributes({});
+}
+function defaultResource() {
+  return resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: defaultServiceName(),
+    [ATTR_TELEMETRY_SDK_LANGUAGE]: SDK_INFO[ATTR_TELEMETRY_SDK_LANGUAGE],
+    [ATTR_TELEMETRY_SDK_NAME]: SDK_INFO[ATTR_TELEMETRY_SDK_NAME],
+    [ATTR_TELEMETRY_SDK_VERSION]: SDK_INFO[ATTR_TELEMETRY_SDK_VERSION]
+  });
+}
+function guardedRawAttributes(attributes) {
+  return attributes.map(([k, v]) => {
+    if (isPromiseLike(v)) {
+      return [
+        k,
+        v.catch((err) => {
+          diag.debug("promise rejection for resource attribute: %s - %s", k, err);
+          return void 0;
+        })
+      ];
+    }
+    return [k, v];
+  });
+}
+function validateSchemaUrl(schemaUrl) {
+  if (typeof schemaUrl === "string" || schemaUrl === void 0) {
+    return schemaUrl;
+  }
+  diag.warn("Schema URL must be string or undefined, got %s. Schema URL will be ignored.", schemaUrl);
+  return void 0;
+}
+function mergeSchemaUrl(old, updating) {
+  const oldSchemaUrl = old?.schemaUrl;
+  const updatingSchemaUrl = updating?.schemaUrl;
+  const isOldEmpty = oldSchemaUrl === void 0 || oldSchemaUrl === "";
+  const isUpdatingEmpty = updatingSchemaUrl === void 0 || updatingSchemaUrl === "";
+  if (isOldEmpty) {
+    return updatingSchemaUrl;
+  }
+  if (isUpdatingEmpty) {
+    return oldSchemaUrl;
+  }
+  if (oldSchemaUrl === updatingSchemaUrl) {
+    return oldSchemaUrl;
+  }
+  diag.warn('Schema URL merge conflict: old resource has "%s", updating resource has "%s". Resulting resource will have undefined Schema URL.', oldSchemaUrl, updatingSchemaUrl);
+  return void 0;
+}
+var ResourceImpl;
+var init_ResourceImpl = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/ResourceImpl.js"() {
+    "use strict";
+    init_esm();
+    init_esm3();
+    init_esm2();
+    init_default_service_name();
+    init_utils();
+    ResourceImpl = class _ResourceImpl {
+      _rawAttributes;
+      _asyncAttributesPending = false;
+      _schemaUrl;
+      _memoizedAttributes;
+      static FromAttributeList(attributes, options) {
+        const res = new _ResourceImpl({}, options);
+        res._rawAttributes = guardedRawAttributes(attributes);
+        res._asyncAttributesPending = attributes.filter(([_, val]) => isPromiseLike(val)).length > 0;
+        return res;
+      }
+      constructor(resource, options) {
+        const attributes = resource.attributes ?? {};
+        this._rawAttributes = Object.entries(attributes).map(([k, v]) => {
+          if (isPromiseLike(v)) {
+            this._asyncAttributesPending = true;
+          }
+          return [k, v];
+        });
+        this._rawAttributes = guardedRawAttributes(this._rawAttributes);
+        this._schemaUrl = validateSchemaUrl(options?.schemaUrl);
+      }
+      get asyncAttributesPending() {
+        return this._asyncAttributesPending;
+      }
+      async waitForAsyncAttributes() {
+        if (!this.asyncAttributesPending) {
+          return;
+        }
+        for (let i = 0; i < this._rawAttributes.length; i++) {
+          const [k, v] = this._rawAttributes[i];
+          this._rawAttributes[i] = [k, isPromiseLike(v) ? await v : v];
+        }
+        this._asyncAttributesPending = false;
+      }
+      get attributes() {
+        if (this.asyncAttributesPending) {
+          diag.error("Accessing resource attributes before async attributes settled");
+        }
+        if (this._memoizedAttributes) {
+          return this._memoizedAttributes;
+        }
+        const attrs = {};
+        for (const [k, v] of this._rawAttributes) {
+          if (isPromiseLike(v)) {
+            diag.debug(`Unsettled resource attribute ${k} skipped`);
+            continue;
+          }
+          if (v != null) {
+            attrs[k] ??= v;
+          }
+        }
+        if (!this._asyncAttributesPending) {
+          this._memoizedAttributes = attrs;
+        }
+        return attrs;
+      }
+      getRawAttributes() {
+        return this._rawAttributes;
+      }
+      get schemaUrl() {
+        return this._schemaUrl;
+      }
+      merge(resource) {
+        if (resource == null)
+          return this;
+        const mergedSchemaUrl = mergeSchemaUrl(this, resource);
+        const mergedOptions = mergedSchemaUrl ? { schemaUrl: mergedSchemaUrl } : void 0;
+        return _ResourceImpl.FromAttributeList([...resource.getRawAttributes(), ...this.getRawAttributes()], mergedOptions);
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detect-resources.js
+var detectResources;
+var init_detect_resources = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detect-resources.js"() {
+    "use strict";
+    init_esm();
+    init_ResourceImpl();
+    detectResources = (config = {}) => {
+      const resources = (config.detectors || []).map((d) => {
+        try {
+          const resource = resourceFromDetectedResource(d.detect(config));
+          diag.debug(`${d.constructor.name} found resource.`, resource);
+          return resource;
+        } catch (e) {
+          diag.debug(`${d.constructor.name} failed: ${e.message}`);
+          return emptyResource();
+        }
+      });
+      return resources.reduce((acc, resource) => acc.merge(resource), emptyResource());
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/EnvDetector.js
+var EnvDetector, envDetector;
+var init_EnvDetector = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/EnvDetector.js"() {
+    "use strict";
+    init_esm();
+    init_esm2();
+    init_esm3();
+    EnvDetector = class {
+      // Type, attribute keys, and attribute values should not exceed 256 characters.
+      _MAX_LENGTH = 255;
+      // OTEL_RESOURCE_ATTRIBUTES is a comma-separated list of attributes.
+      _COMMA_SEPARATOR = ",";
+      // OTEL_RESOURCE_ATTRIBUTES contains key value pair separated by '='.
+      _LABEL_KEY_VALUE_SPLITTER = "=";
+      _ERROR_MESSAGE_INVALID_CHARS = "should be a ASCII string with a length greater than 0 and not exceed " + this._MAX_LENGTH + " characters.";
+      _ERROR_MESSAGE_INVALID_VALUE = "should be a ASCII string with a length not exceed " + this._MAX_LENGTH + " characters.";
+      /**
+       * Returns a {@link Resource} populated with attributes from the
+       * OTEL_RESOURCE_ATTRIBUTES environment variable. Note this is an async
+       * function to conform to the Detector interface.
+       *
+       * @param config The resource detection config
+       */
+      detect(_config) {
+        const attributes = {};
+        const rawAttributes = getStringFromEnv("OTEL_RESOURCE_ATTRIBUTES");
+        const serviceName2 = getStringFromEnv("OTEL_SERVICE_NAME");
+        if (rawAttributes) {
+          try {
+            const parsedAttributes = this._parseResourceAttributes(rawAttributes);
+            Object.assign(attributes, parsedAttributes);
+          } catch (e) {
+            diag.debug(`EnvDetector failed: ${e.message}`);
+          }
+        }
+        if (serviceName2) {
+          attributes[ATTR_SERVICE_NAME] = serviceName2;
+        }
+        return { attributes };
+      }
+      /**
+       * Creates an attribute map from the OTEL_RESOURCE_ATTRIBUTES environment
+       * variable.
+       *
+       * OTEL_RESOURCE_ATTRIBUTES: A comma-separated list of attributes describing
+       * the source in more detail, e.g. “key1=val1,key2=val2”. Domain names and
+       * paths are accepted as attribute keys. Values may be quoted or unquoted in
+       * general. If a value contains whitespace, =, or " characters, it must
+       * always be quoted.
+       *
+       * @param rawEnvAttributes The resource attributes as a comma-separated list
+       * of key/value pairs.
+       * @returns The sanitized resource attributes.
+       */
+      _parseResourceAttributes(rawEnvAttributes) {
+        if (!rawEnvAttributes)
+          return {};
+        const attributes = {};
+        const rawAttributes = rawEnvAttributes.split(this._COMMA_SEPARATOR, -1);
+        for (const rawAttribute of rawAttributes) {
+          const keyValuePair = rawAttribute.split(this._LABEL_KEY_VALUE_SPLITTER, -1);
+          if (keyValuePair.length !== 2) {
+            continue;
+          }
+          let [key, value] = keyValuePair;
+          key = key.trim();
+          value = value.trim().split(/^"|"$/).join("");
+          if (!this._isValidAndNotEmpty(key)) {
+            throw new Error(`Attribute key ${this._ERROR_MESSAGE_INVALID_CHARS}`);
+          }
+          if (!this._isValid(value)) {
+            throw new Error(`Attribute value ${this._ERROR_MESSAGE_INVALID_VALUE}`);
+          }
+          attributes[key] = decodeURIComponent(value);
+        }
+        return attributes;
+      }
+      /**
+       * Determines whether the given String is a valid printable ASCII string with
+       * a length not exceed _MAX_LENGTH characters.
+       *
+       * @param str The String to be validated.
+       * @returns Whether the String is valid.
+       */
+      _isValid(name) {
+        return name.length <= this._MAX_LENGTH && this._isBaggageOctetString(name);
+      }
+      // https://www.w3.org/TR/baggage/#definition
+      _isBaggageOctetString(str) {
+        for (let i = 0; i < str.length; i++) {
+          const ch = str.charCodeAt(i);
+          if (ch < 33 || ch === 44 || ch === 59 || ch === 92 || ch > 126) {
+            return false;
+          }
+        }
+        return true;
+      }
+      /**
+       * Determines whether the given String is a valid printable ASCII string with
+       * a length greater than 0 and not exceed _MAX_LENGTH characters.
+       *
+       * @param str The String to be validated.
+       * @returns Whether the String is valid and not empty.
+       */
+      _isValidAndNotEmpty(str) {
+        return str.length > 0 && this._isValid(str);
+      }
+    };
+    envDetector = new EnvDetector();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/semconv.js
+var ATTR_HOST_ARCH, ATTR_HOST_ID, ATTR_HOST_NAME, ATTR_OS_TYPE, ATTR_OS_VERSION, ATTR_PROCESS_COMMAND, ATTR_PROCESS_COMMAND_ARGS, ATTR_PROCESS_EXECUTABLE_NAME, ATTR_PROCESS_EXECUTABLE_PATH, ATTR_PROCESS_OWNER, ATTR_PROCESS_PID, ATTR_PROCESS_RUNTIME_DESCRIPTION, ATTR_PROCESS_RUNTIME_NAME, ATTR_PROCESS_RUNTIME_VERSION, ATTR_SERVICE_INSTANCE_ID;
+var init_semconv = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/semconv.js"() {
+    "use strict";
+    ATTR_HOST_ARCH = "host.arch";
+    ATTR_HOST_ID = "host.id";
+    ATTR_HOST_NAME = "host.name";
+    ATTR_OS_TYPE = "os.type";
+    ATTR_OS_VERSION = "os.version";
+    ATTR_PROCESS_COMMAND = "process.command";
+    ATTR_PROCESS_COMMAND_ARGS = "process.command_args";
+    ATTR_PROCESS_EXECUTABLE_NAME = "process.executable.name";
+    ATTR_PROCESS_EXECUTABLE_PATH = "process.executable.path";
+    ATTR_PROCESS_OWNER = "process.owner";
+    ATTR_PROCESS_PID = "process.pid";
+    ATTR_PROCESS_RUNTIME_DESCRIPTION = "process.runtime.description";
+    ATTR_PROCESS_RUNTIME_NAME = "process.runtime.name";
+    ATTR_PROCESS_RUNTIME_VERSION = "process.runtime.version";
+    ATTR_SERVICE_INSTANCE_ID = "service.instance.id";
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId.js
+import * as process2 from "process";
+async function getMachineId() {
+  if (!getMachineIdImpl) {
+    switch (process2.platform) {
+      case "darwin":
+        getMachineIdImpl = (await import("./getMachineId-darwin-4DP6CCJV.js")).getMachineId;
+        break;
+      case "linux":
+        getMachineIdImpl = (await import("./getMachineId-linux-44LJ5UJB.js")).getMachineId;
+        break;
+      case "freebsd":
+        getMachineIdImpl = (await import("./getMachineId-bsd-HSK5LZMG.js")).getMachineId;
+        break;
+      case "win32":
+        getMachineIdImpl = (await import("./getMachineId-win-YZ36S7VA.js")).getMachineId;
+        break;
+      default:
+        getMachineIdImpl = (await import("./getMachineId-unsupported-NVK6IATM.js")).getMachineId;
+        break;
+    }
+  }
+  return getMachineIdImpl();
+}
+var getMachineIdImpl;
+var init_getMachineId = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/utils.js
+var normalizeArch, normalizeType;
+var init_utils2 = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/utils.js"() {
+    "use strict";
+    normalizeArch = (nodeArchString) => {
+      switch (nodeArchString) {
+        case "arm":
+          return "arm32";
+        case "ppc":
+          return "ppc32";
+        case "x64":
+          return "amd64";
+        default:
+          return nodeArchString;
+      }
+    };
+    normalizeType = (nodePlatform) => {
+      switch (nodePlatform) {
+        case "sunos":
+          return "solaris";
+        case "win32":
+          return "windows";
+        default:
+          return nodePlatform;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/HostDetector.js
+import { arch, hostname } from "os";
+var HostDetector, hostDetector;
+var init_HostDetector = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/HostDetector.js"() {
+    "use strict";
+    init_semconv();
+    init_getMachineId();
+    init_utils2();
+    HostDetector = class {
+      detect(_config) {
+        const attributes = {
+          [ATTR_HOST_NAME]: hostname(),
+          [ATTR_HOST_ARCH]: normalizeArch(arch()),
+          [ATTR_HOST_ID]: getMachineId()
+        };
+        return { attributes };
+      }
+    };
+    hostDetector = new HostDetector();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/OSDetector.js
+import { platform as platform2, release } from "os";
+var OSDetector, osDetector;
+var init_OSDetector = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/OSDetector.js"() {
+    "use strict";
+    init_semconv();
+    init_utils2();
+    OSDetector = class {
+      detect(_config) {
+        const attributes = {
+          [ATTR_OS_TYPE]: normalizeType(platform2()),
+          [ATTR_OS_VERSION]: release()
+        };
+        return { attributes };
+      }
+    };
+    osDetector = new OSDetector();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/ProcessDetector.js
+import * as os from "os";
+var ProcessDetector, processDetector;
+var init_ProcessDetector = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/ProcessDetector.js"() {
+    "use strict";
+    init_esm();
+    init_semconv();
+    ProcessDetector = class {
+      detect(_config) {
+        const attributes = {
+          [ATTR_PROCESS_PID]: process.pid,
+          [ATTR_PROCESS_EXECUTABLE_NAME]: process.title,
+          [ATTR_PROCESS_EXECUTABLE_PATH]: process.execPath,
+          [ATTR_PROCESS_COMMAND_ARGS]: [
+            process.argv[0],
+            ...process.execArgv,
+            ...process.argv.slice(1)
+          ],
+          [ATTR_PROCESS_RUNTIME_VERSION]: process.versions.node,
+          [ATTR_PROCESS_RUNTIME_NAME]: "nodejs",
+          [ATTR_PROCESS_RUNTIME_DESCRIPTION]: "Node.js"
+        };
+        if (process.argv.length > 1) {
+          attributes[ATTR_PROCESS_COMMAND] = process.argv[1];
+        }
+        try {
+          const userInfo2 = os.userInfo();
+          attributes[ATTR_PROCESS_OWNER] = userInfo2.username;
+        } catch (e) {
+          diag.debug(`error obtaining process owner: ${e}`);
+        }
+        return { attributes };
+      }
+    };
+    processDetector = new ProcessDetector();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/ServiceInstanceIdDetector.js
+import { randomUUID } from "crypto";
+var ServiceInstanceIdDetector, serviceInstanceIdDetector;
+var init_ServiceInstanceIdDetector = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/ServiceInstanceIdDetector.js"() {
+    "use strict";
+    init_semconv();
+    ServiceInstanceIdDetector = class {
+      detect(_config) {
+        return {
+          attributes: {
+            [ATTR_SERVICE_INSTANCE_ID]: randomUUID()
+          }
+        };
+      }
+    };
+    serviceInstanceIdDetector = new ServiceInstanceIdDetector();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/index.js
+var init_node = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/index.js"() {
+    "use strict";
+    init_HostDetector();
+    init_OSDetector();
+    init_ProcessDetector();
+    init_ServiceInstanceIdDetector();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/index.js
+var init_platform = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/platform/index.js"() {
+    "use strict";
+    init_node();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/index.js
+var init_detectors = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/detectors/index.js"() {
+    "use strict";
+    init_EnvDetector();
+    init_platform();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/index.js
+var init_esm4 = __esm({
+  "../../node_modules/.bun/@opentelemetry+resources@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/resources/build/esm/index.js"() {
+    init_detect_resources();
+    init_detectors();
+    init_ResourceImpl();
+    init_default_service_name();
+  }
+});
+
+export {
+  defaultServiceName,
+  resourceFromAttributes,
+  emptyResource,
+  defaultResource,
+  detectResources,
+  envDetector,
+  hostDetector,
+  osDetector,
+  processDetector,
+  serviceInstanceIdDetector,
+  init_esm4 as init_esm
+};
+//# sourceMappingURL=chunk-FV32QHPB.js.map