diff --git a/marketplace.json b/marketplace.json index b988fe5..8a66c60 100644 --- a/marketplace.json +++ b/marketplace.json @@ -740,6 +740,24 @@ "visualization" ], "icon": "https://cdn-zcode.z.ai/zcode/official-plugin/assets/obsidian/icon.png" + }, + { + "name": "zcode-plugin-langfuse", + "source": "./plugins/zcode-plugin-langfuse", + "description": "Fail-open Langfuse tracing for ZCode sessions, prompts, tool calls, and assistant responses.", + "description_i18n": { + "en": "Fail-open Langfuse tracing for ZCode sessions, prompts, tool calls, and assistant responses.", + "zh-CN": "为 ZCode 会话、提示词、工具调用和助手回复提供 fail-open 的 Langfuse 追踪。" + }, + "version": "0.3.0", + "category": "developer-tools", + "tags": [ + "langfuse", + "tracing", + "telemetry", + "hooks" + ], + "strict": true } ] } diff --git a/plugins/zcode-plugin-langfuse/.claude-plugin/plugin.json b/plugins/zcode-plugin-langfuse/.claude-plugin/plugin.json new file mode 100644 index 0000000..8f353fb --- /dev/null +++ b/plugins/zcode-plugin-langfuse/.claude-plugin/plugin.json @@ -0,0 +1,89 @@ +{ + "name": "zcode-plugin-langfuse", + "description": "Fail-open Langfuse tracing for ZCode sessions, prompts, tool calls, and assistant responses.", + "description_i18n": { + "en": "Fail-open Langfuse tracing for ZCode sessions, prompts, tool calls, and assistant responses.", + "zh-CN": "为 ZCode 会话、提示词、工具调用和助手回复提供 fail-open 的 Langfuse 追踪。" + }, + "version": "0.3.0", + "author": { + "name": "Community contributor" + }, + "license": "MIT", + "keywords": [ + "langfuse", + "observability", + "tracing", + "telemetry", + "hooks" + ], + "userConfig": { + "langfuse_public_key": { + "title": "Langfuse public key", + "description": "Langfuse project public key. You can also provide LANGFUSE_PUBLIC_KEY in the ZCode process environment.", + "type": "string", + "required": false + }, + "langfuse_secret_key": { + "title": "Langfuse secret key", + "description": "Langfuse project secret key. It is used only by the local hook process and is never written to hook output.", + "type": "string", + "required": false, + "sensitive": true + }, + "langfuse_base_url": { + "title": "Langfuse base URL", + "description": "HTTPS Langfuse host, for example https://cloud.langfuse.com or a self-hosted HTTPS URL. Plain HTTP is rejected.", + "type": "string", + "default": "https://cloud.langfuse.com" + }, + "langfuse_user_id": { + "title": "Langfuse user ID", + "description": "Optional stable user identifier attached to traces. Leave empty to omit it.", + "type": "string", + "required": false + }, + "langfuse_environment": { + "title": "Langfuse environment", + "description": "Environment label attached to traces.", + "type": "string", + "default": "development" + }, + "capture_prompts": { + "title": "Capture prompts", + "description": "Include user prompts and assistant responses in Langfuse. Disable for metadata-only tracing.", + "type": "boolean", + "default": true + }, + "capture_tool_inputs": { + "title": "Capture tool inputs", + "description": "Include tool names and inputs in Langfuse spans.", + "type": "boolean", + "default": true + }, + "capture_tool_outputs": { + "title": "Capture tool outputs", + "description": "Include tool results and errors in Langfuse spans.", + "type": "boolean", + "default": true + }, + "max_capture_chars": { + "title": "Maximum captured characters", + "description": "Maximum characters per captured prompt, tool payload, or response. Larger values are truncated.", + "type": "number", + "default": 20000 + }, + "max_media_chars": { + "title": "Maximum media characters", + "description": "Maximum characters per preserved image (base64 data URI) sent to Langfuse for upload and rendering. Images over this limit are replaced by an omission marker; 0 disables media preservation and upload entirely.", + "type": "number", + "default": 4000000 + }, + "debug": { + "title": "Debug diagnostics", + "description": "Write non-sensitive lifecycle diagnostics to stderr. Disabled by default.", + "type": "boolean", + "default": false + } + } +} diff --git a/plugins/zcode-plugin-langfuse/.zcode-plugin/plugin.json b/plugins/zcode-plugin-langfuse/.zcode-plugin/plugin.json new file mode 100644 index 0000000..8f353fb --- /dev/null +++ b/plugins/zcode-plugin-langfuse/.zcode-plugin/plugin.json @@ -0,0 +1,89 @@ +{ + "name": "zcode-plugin-langfuse", + "description": "Fail-open Langfuse tracing for ZCode sessions, prompts, tool calls, and assistant responses.", + "description_i18n": { + "en": "Fail-open Langfuse tracing for ZCode sessions, prompts, tool calls, and assistant responses.", + "zh-CN": "为 ZCode 会话、提示词、工具调用和助手回复提供 fail-open 的 Langfuse 追踪。" + }, + "version": "0.3.0", + "author": { + "name": "Community contributor" + }, + "license": "MIT", + "keywords": [ + "langfuse", + "observability", + "tracing", + "telemetry", + "hooks" + ], + "userConfig": { + "langfuse_public_key": { + "title": "Langfuse public key", + "description": "Langfuse project public key. You can also provide LANGFUSE_PUBLIC_KEY in the ZCode process environment.", + "type": "string", + "required": false + }, + "langfuse_secret_key": { + "title": "Langfuse secret key", + "description": "Langfuse project secret key. It is used only by the local hook process and is never written to hook output.", + "type": "string", + "required": false, + "sensitive": true + }, + "langfuse_base_url": { + "title": "Langfuse base URL", + "description": "HTTPS Langfuse host, for example https://cloud.langfuse.com or a self-hosted HTTPS URL. Plain HTTP is rejected.", + "type": "string", + "default": "https://cloud.langfuse.com" + }, + "langfuse_user_id": { + "title": "Langfuse user ID", + "description": "Optional stable user identifier attached to traces. Leave empty to omit it.", + "type": "string", + "required": false + }, + "langfuse_environment": { + "title": "Langfuse environment", + "description": "Environment label attached to traces.", + "type": "string", + "default": "development" + }, + "capture_prompts": { + "title": "Capture prompts", + "description": "Include user prompts and assistant responses in Langfuse. Disable for metadata-only tracing.", + "type": "boolean", + "default": true + }, + "capture_tool_inputs": { + "title": "Capture tool inputs", + "description": "Include tool names and inputs in Langfuse spans.", + "type": "boolean", + "default": true + }, + "capture_tool_outputs": { + "title": "Capture tool outputs", + "description": "Include tool results and errors in Langfuse spans.", + "type": "boolean", + "default": true + }, + "max_capture_chars": { + "title": "Maximum captured characters", + "description": "Maximum characters per captured prompt, tool payload, or response. Larger values are truncated.", + "type": "number", + "default": 20000 + }, + "max_media_chars": { + "title": "Maximum media characters", + "description": "Maximum characters per preserved image (base64 data URI) sent to Langfuse for upload and rendering. Images over this limit are replaced by an omission marker; 0 disables media preservation and upload entirely.", + "type": "number", + "default": 4000000 + }, + "debug": { + "title": "Debug diagnostics", + "description": "Write non-sensitive lifecycle diagnostics to stderr. Disabled by default.", + "type": "boolean", + "default": false + } + } +} diff --git a/plugins/zcode-plugin-langfuse/LICENSE b/plugins/zcode-plugin-langfuse/LICENSE new file mode 100644 index 0000000..b2f7956 --- /dev/null +++ b/plugins/zcode-plugin-langfuse/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 Community contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/plugins/zcode-plugin-langfuse/README.md b/plugins/zcode-plugin-langfuse/README.md new file mode 100644 index 0000000..7efba3d --- /dev/null +++ b/plugins/zcode-plugin-langfuse/README.md @@ -0,0 +1,262 @@ +# Langfuse Observability for ZCode + +[English](README.md) · [简体中文](README.zh-CN.md) + +A community ZCode plugin that sends one Langfuse trace per completed ZCode turn. +It is designed for review and possible inclusion in the ZCode official plugin +marketplace. + +> **Status:** early community contribution (`0.3.0`). The plugin is fail-open: +> a missing credential, malformed hook payload, local state error, or Langfuse +> request error must never block a ZCode session. Tracing uses Langfuse's +> OpenTelemetry (OTLP) ingestion endpoint, which is the only ingestion path on +> Langfuse v4 servers running in events-only mode. + +## What it records + +The plugin listens to ZCode's process-hook events: + +- `SessionStart` +- `UserPromptSubmit` +- `PreToolUse` +- `PostToolUse` +- `PostToolUseFailure` +- `Stop` + +At `Stop`, it emits a trace named `ZCode Turn` containing: + +- the ZCode session ID; +- the user prompt and final assistant message as chat-style input/output on the + turn root observation, when prompt capture is enabled; +- tool calls as Langfuse `tool` observations, including names and optional + input/output; +- an assistant response `generation`; +- release, environment, turn ID, tool-count, and plugin metadata. + +It does **not** read the transcript file or collect hidden chain-of-thought. It +only uses fields delivered in the ZCode hook payload. + +## Permissions and side effects + +Each of the six events starts a `node` process with the current user's +permissions. The process reads one JSON Hook event from stdin and writes one +empty JSON object to stdout; it does not spawn a shell or run user commands. + +The hook reads `ZCODE_CONFIG_PATH`, or +`~/.zcode/cli/config.json` when that variable is unset, to find persisted plugin +options. It writes only bounded, hashed JSON session state under +`ZCODE_PLUGIN_DATA`, or the ZCode plugin data directory fallback. At `Stop`, +it sends one OTLP/HTTPS request batch to the configured Langfuse OTLP endpoint +(`/api/public/otel/v1/traces`) using the local credentials. No transcript files +or hidden reasoning are read. + +## Architecture + +```text +ZCode hook stdin + │ one JSON object + ▼ + hooks/entry.mjs ──► TurnTracker ──► JsonStateStore + │ │ + │ └─ per-session, atomic, hashed filename + ▼ + LangfuseTraceSink ──► @langfuse/otel LangfuseSpanProcessor + │ + ▼ + Langfuse OTLP API (/api/public/otel/v1/traces) +``` + +The source is deliberately split into deep modules: + +- `src/domain/` — hook and trace data types plus payload extraction; +- `src/application/` — configuration and the turn state machine; +- `src/adapters/` — the filesystem state adapter and Langfuse OTLP adapter; +- `src/hooks/` — the small process entry point and fail-open policy. + +The distributable `dist/hooks/entry.mjs` bundles the Langfuse OpenTelemetry +toolchain (`@langfuse/otel`, `@langfuse/tracing`, and the OpenTelemetry SDK), so +an installed plugin does not need a separate `npm install` at runtime. + +## Configuration + +The plugin reads ZCode `userConfig` values using the standard ZCode environment +mapping. For example, the manifest key `langfuse_public_key` becomes: + +```text +ZCODE_USER_CONFIG_LANGFUSE_PUBLIC_KEY +``` + +The following ordinary environment variables are also accepted, which is useful +for local smoke tests and managed deployments: + +```text +LANGFUSE_PUBLIC_KEY +LANGFUSE_SECRET_KEY +LANGFUSE_BASE_URL +LANGFUSE_USER_ID +LANGFUSE_ENVIRONMENT +LANGFUSE_RELEASE +LANGFUSE_ENABLED +LANGFUSE_CAPTURE_PROMPTS +LANGFUSE_CAPTURE_TOOL_INPUTS +LANGFUSE_CAPTURE_TOOL_OUTPUTS +LANGFUSE_MAX_CAPTURE_CHARS +LANGFUSE_MAX_MEDIA_CHARS +LANGFUSE_DEBUG +``` + +`LANGFUSE_BASE_URL` defaults to `https://cloud.langfuse.com`. Set it to your +self-hosted HTTPS URL, for example `https://langfuse.example.com`. Plain HTTP +URLs are rejected and replaced with the default HTTPS endpoint. + +For a self-hosted project, configure the public and secret keys in the plugin +configuration. The hook reads its own persisted `plugins.options` entry using +`ZCODE_PLUGIN_ID`; this is needed because current ZCode runtimes do not inject +all `userConfig` values into process-hook environment variables. Standard +`LANGFUSE_*` environment variables override stored options. Never commit +credentials or put them in `hooks/hooks.json`. + +### Privacy controls + +All capture controls default to `true` for useful traces. Set any of these to +`false` to keep the corresponding content out of both the Langfuse request and +local per-session state: + +```text +LANGFUSE_CAPTURE_PROMPTS=false +LANGFUSE_CAPTURE_TOOL_INPUTS=false +LANGFUSE_CAPTURE_TOOL_OUTPUTS=false +``` + +Every captured field is bounded by `LANGFUSE_MAX_CAPTURE_CHARS` (default +`20000`). Metadata-only mode still reports timing/session/tool-count structure, +but not prompt, response, tool input, tool output, or error text. + +### Media capture + +Images delivered in hook payloads (as `image` content blocks or bare `img`/ +`image` base64 fields) are kept as whole data URIs and uploaded to Langfuse, so +they render as pictures in the trace view instead of truncated text. Media is +bounded by its own limit, `LANGFUSE_MAX_MEDIA_CHARS` (default `4000000` +characters, about 3 MB per turn); anything over the limit is replaced by an +`[media … omitted]` marker. Set it to `0` to disable media preservation and +upload entirely. Note that media upload sends image binaries to your Langfuse +server as a separate request; the capture flags above still decide whether the +containing prompt or tool payload is captured at all. + +## Development + +Requirements: Node.js 20 or newer. + +```bash +npm ci +npm run check +npm run package:plugin +``` + +`npm run build` builds the complete `dist/` output, structured as a ZCode +marketplace shell whose single entry uses the official plugin layout (same +shape as the `zcode-plugins-official` template): + +```text +dist/marketplace.json +dist/plugins/zcode-plugin-langfuse/ +├── .zcode-plugin/plugin.json +├── .claude-plugin/plugin.json (identical copy for Claude compatibility) +├── hooks/hooks.json (points at hooks/entry.mjs) +├── hooks/entry.mjs (sealed runtime bundle) +├── README.md +├── README_CN.md +├── LICENSE +└── THIRD_PARTY_NOTICES.md +``` + +`dist/plugins/zcode-plugin-langfuse/` is the installable plugin: its +`hooks/entry.mjs` runtime, manifest, hooks, dual-language README, license, and +third-party notices. The release workflow compresses the tree into the +versioned ZIP; the official catalog and local directory installs consume the +plugin directory as-is. Everything under `dist/` is generated and not +committed. + +The hook can be smoke-tested without credentials: + +```bash +printf '%s\n' '{"hook_event_name":"Stop","session_id":"smoke","last_assistant_message":"ok"}' \ + | ZCODE_PLUGIN_DATA="$(mktemp -d)" \ + LANGFUSE_DEBUG=true \ + node dist/plugins/zcode-plugin-langfuse/hooks/entry.mjs +``` + +Expected stdout is one empty hook result object: + +```json +{} +``` + +Diagnostics, when enabled, go to stderr. They never contain keys or full +prompts. + +## Third-party software + +The runtime uses `@langfuse/otel` 5.11.1, `@langfuse/tracing` 5.11.1, +`@langfuse/core` 5.11.1, and OpenTelemetry packages (`@opentelemetry/api` +1.9.1, `@opentelemetry/core` 2.11.0, `@opentelemetry/sdk-trace-node` 2.11.0, +`@opentelemetry/exporter-trace-otlp-http` 0.222.0 with its `otlp-*` +companions). The Langfuse packages are MIT-licensed; the OpenTelemetry packages +are Apache-2.0-licensed. See +[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) for versions, provenance, and +source links. Langfuse is an external service selected by the user and is not +bundled with credentials. + +## Local installation for testing + +ZCode treats a selected directory as a **plugin marketplace**, so this repository +includes `marketplace.json` at its root; its entry points at +`./dist/plugins/zcode-plugin-langfuse`. Build first, then use **Settings → +Plugins → Add marketplace → Select directory** and choose this repository. +Install `zcode-plugin-langfuse` from the resulting personal marketplace, enable +it, and configure its `userConfig` values. + +The plugin manifest is at `.zcode-plugin/plugin.json`; the hook declaration is +at `hooks/hooks.json`. + +## Install a release + +Download `zcode-plugin-langfuse-v.zip` from the release page, extract it, and add +the extracted plugin directory as a local marketplace via **Settings → +Plugins → Add marketplace**. Do not add a fresh checkout of this repository as +a marketplace: it has no `dist/` bundle (generated, not committed), so hooks +cannot start. For a development install from a checkout, run `npm install` +first — the `prepare` hook builds `dist/`. + +- Marketplace manifest: +- Plugin manifest: +- Latest release (asset: `zcode-plugin-langfuse-v.zip`): +- Release page: +- Official ZCode plugin documentation: +- Official ZCode plugin marketplace: + +The repository marketplace is named `zcode-plugin-langfuse`, and its +`marketplace.json` resolves the plugin from `source: "."`. Versioned release +assets are generated by the tagged GitHub Actions workflow. + +Before submitting a marketplace change, verify: + +1. `npm run check` passes; +2. `npm run package:plugin` creates and validates the release ZIP; +3. `hooks/hooks.json` contains no unsupported hook events; +4. no credentials are present in the repository, package, or logs; +5. disabling prompt/tool capture behaves as documented. + +## Project policies + +- [Agent instructions](AGENTS.md) +- [Contributing](CONTRIBUTING.md) +- [Code of Conduct](CODE_OF_CONDUCT.md) +- [Security policy](SECURITY.md) +- [Release checklist](docs/releasing.md) +- [Design notes](DESIGN.md) + +## License + +MIT. See [LICENSE](LICENSE). diff --git a/plugins/zcode-plugin-langfuse/README_CN.md b/plugins/zcode-plugin-langfuse/README_CN.md new file mode 100644 index 0000000..c85ccf3 --- /dev/null +++ b/plugins/zcode-plugin-langfuse/README_CN.md @@ -0,0 +1,184 @@ +# ZCode Langfuse Observability + +[English](README.md) · [简体中文](README.zh-CN.md) + +面向 ZCode 的社区 Langfuse 观测插件，按每个完成的 ZCode turn 生成一条 +Langfuse trace，目标是提交给 ZCode 官方插件市场。 + +> 当前版本：`0.3.0`。插件遵循 **fail-open**：缺少凭据、Hook 输入损坏、本地 +> 状态错误或 Langfuse 请求失败，都不能阻塞 ZCode 会话。追踪通过 Langfuse 的 +> OpenTelemetry（OTLP）接入端点上报——这也是 Langfuse v4 服务端在 +> events-only 模式下唯一的接入路径。 + +## 采集范围 + +监听 `SessionStart`、`UserPromptSubmit`、`PreToolUse`、`PostToolUse`、 +`PostToolUseFailure` 和 `Stop`。在 `Stop` 时发送： + +- session ID； +- 用户 prompt 与最后一条 assistant 回复，以 chat 形式挂在 turn 根 + observation 的 input/output 上（可关闭）； +- 工具调用 Langfuse `tool` observation（名称、输入、输出可分别关闭）； +- assistant 回复的 `generation`； +- release、environment、turn ID、工具数量和插件元数据。 + +插件**不读取 transcript 文件，也不采集隐藏完整思维链**，只使用 ZCode +Hook stdin 传入的字段。 + +## 权限与副作用 + +六个事件都会以当前用户权限启动一个 `node` process Hook。Hook 从 stdin +读取一个 JSON 事件，并向 stdout 写入一个空 JSON 对象；不会启动 shell，也不会 +执行用户命令。 + +Hook 会读取 `ZCODE_CONFIG_PATH` 指定的配置；未设置时读取 +`~/.zcode/cli/config.json` 中保存的插件选项。它只会在 +`ZCODE_PLUGIN_DATA` 或 ZCode 插件数据目录回退路径下写入有界、哈希化的 JSON +会话状态。`Stop` 时使用本地凭据向用户配置的 Langfuse OTLP 端点 +（`/api/public/otel/v1/traces`）发送一批 OTLP/HTTPS 请求。不会读取 +transcript 文件或隐藏推理内容。 + +## 配置 + +Manifest 中的 `userConfig` 会映射成以下环境变量，例如： + +```text +ZCODE_USER_CONFIG_LANGFUSE_PUBLIC_KEY +ZCODE_USER_CONFIG_LANGFUSE_SECRET_KEY +ZCODE_USER_CONFIG_LANGFUSE_BASE_URL +``` + +同时支持标准变量： + +```text +LANGFUSE_PUBLIC_KEY +LANGFUSE_SECRET_KEY +LANGFUSE_BASE_URL +LANGFUSE_USER_ID +LANGFUSE_ENVIRONMENT +LANGFUSE_RELEASE +LANGFUSE_ENABLED +LANGFUSE_CAPTURE_PROMPTS +LANGFUSE_CAPTURE_TOOL_INPUTS +LANGFUSE_CAPTURE_TOOL_OUTPUTS +LANGFUSE_MAX_CAPTURE_CHARS +LANGFUSE_DEBUG +``` + +`LANGFUSE_BASE_URL` 默认 `https://cloud.langfuse.com`；自建 Langfuse 请填写 +HTTPS 地址，例如 `https://langfuse.example.com`。明文 HTTP 地址会被拒绝并回退到 +默认 HTTPS 地址。 + +敏感 secret 不要写入仓库或 `hooks/hooks.json`。Hook 会根据运行时提供的 +`ZCODE_PLUGIN_ID` 从 ZCode 的 `plugins.options` 读取本插件配置；这是因为当前 +ZCode 不会把全部 `userConfig` 自动注入 process Hook 环境。标准 +`LANGFUSE_*` 环境变量优先级更高，可覆盖保存的配置。 + +关闭内容采集： + +```text +LANGFUSE_CAPTURE_PROMPTS=false +LANGFUSE_CAPTURE_TOOL_INPUTS=false +LANGFUSE_CAPTURE_TOOL_OUTPUTS=false +``` + +关闭后，内容不会写入 Langfuse，也不会写入本地会话状态；仍保留 session、 +工具数量等结构化元数据。单字段默认最多采集 20000 个字符，可用 +`LANGFUSE_MAX_CAPTURE_CHARS` 调整。 + +### 媒体采集 + +Hook payload 里的图片（`image` content block，或 `img`/`image` 字段下的裸 +base64）会以完整 data URI 保留并上传到 Langfuse，在 trace 视图中渲染为图片 +而不是被截断的文本。媒体有独立预算 `LANGFUSE_MAX_MEDIA_CHARS`（默认 +`4000000` 字符，约每轮 3 MB），超限的媒体会被替换成 `[media … omitted]` +标记；设为 `0` 可彻底关闭媒体保留与上传。注意媒体上传会把图片二进制单独 +请求发送到你的 Langfuse 服务器；上面的采集开关仍然决定所在 prompt 或工具 +payload 是否被采集。 + +## 第三方软件 + +运行时使用 `@langfuse/otel` 5.11.1、`@langfuse/tracing` 5.11.1、 +`@langfuse/core` 5.11.1，以及 OpenTelemetry 系列包（`@opentelemetry/api` +1.9.1、`@opentelemetry/core` 2.11.0、`@opentelemetry/sdk-trace-node` 2.11.0、 +`@opentelemetry/exporter-trace-otlp-http` 0.222.0 及其 `otlp-*` 伴生包）。 +Langfuse 系列包为 MIT 许可证，OpenTelemetry 系列包为 Apache-2.0 许可证。 +版本、来源和许可证见 +[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md)。Langfuse 是用户选择的外部服务， +仓库不会打包凭据。 + +## 在 ZCode 中本地测试 + +ZCode 选择本地目录时会按“插件市场”读取，因此仓库根目录包含 +`marketplace.json`，其条目指向 `./dist/plugins/zcode-plugin-langfuse`。先运行 +`npm run build`，再在 **设置 → 插件 → 添加插件市场 → +选择目录** 中选择本仓库，从“个人”市场安装并启用 +`zcode-plugin-langfuse`。正式市场使用版本化 ZIP 和 SHA-256。 + +## 在线 ZCode 插件市场 + +从 Release 页下载 `zcode-plugin-langfuse-v<版本>.zip` 并解压，在 **设置 → 插件 → 添加插件市场 → +选择目录** 中选择解压后的插件目录安装。不要把全新检出的源码仓库直接添加为市场： +其中没有 `dist/` bundle（生成目录不入库），Hook 无法启动。开发安装请先在检出目录 +运行 `npm install`（`prepare` 钩子会构建 `dist/`），再选择该目录。 + +- 市场清单： +- 插件清单： +- 最新 Release（资产：`zcode-plugin-langfuse-v<版本>.zip`）： +- Release 页面： +- ZCode 官方插件文档： +- ZCode 官方插件市场： + +本仓库市场名为 `zcode-plugin-langfuse`，`marketplace.json` 使用 +`source: "."` 从仓库根目录解析插件。版本化发行文件由 GitHub Actions 的 tag +workflow 生成。 + +## 开发与构建 + +需要 Node.js 20+： + +```bash +npm ci +npm run check +npm run package:plugin +``` + +`npm run build` 会把 Langfuse OpenTelemetry 工具链（`@langfuse/otel`、 +`@langfuse/tracing` 与 OpenTelemetry SDK）打包进本地 `dist/`。 +`npm run build` 会构建完整的 `dist/` 输出：外层是插件市场壳，内层插件目录与 +ZCode 官方模板（`zcode-plugins-official`）布局一致： + +```text +dist/marketplace.json +dist/plugins/zcode-plugin-langfuse/ +├── .zcode-plugin/plugin.json +├── .claude-plugin/plugin.json （同内容副本，兼容 Claude） +├── hooks/hooks.json （指向 hooks/entry.mjs） +├── hooks/entry.mjs （密封运行时 bundle） +├── README.md +├── README_CN.md +├── LICENSE +└── THIRD_PARTY_NOTICES.md +``` + +`dist/plugins/zcode-plugin-langfuse/` 即可安装的插件：包含 `hooks/entry.mjs` +运行时、manifest、hooks、双语 README、许可证与第三方声明。Release +工作流负责把该目录压缩为版本化 ZIP；官方目录与本地目录安装直接使用该插件目录。 +整个 `dist/` 均为生成目录，不入库。 + +目录分层： + +- `src/domain/`：Hook 与 trace 数据类型、输入解析； +- `src/application/`：配置与 turn 状态机； +- `src/adapters/`：本地状态和 Langfuse OTLP 适配器； +- `src/hooks/`：很薄的进程入口和 fail-open 策略。 + +更多设计约束见 [DESIGN.md](DESIGN.md)。 + +项目规范： + +- [Agent 指令](AGENTS.md) +- [贡献指南](CONTRIBUTING.md) +- [行为准则](CODE_OF_CONDUCT.md) +- [安全策略](SECURITY.md) +- [发布清单](docs/releasing.md) diff --git a/plugins/zcode-plugin-langfuse/THIRD_PARTY_NOTICES.md b/plugins/zcode-plugin-langfuse/THIRD_PARTY_NOTICES.md new file mode 100644 index 0000000..6a2bf66 --- /dev/null +++ b/plugins/zcode-plugin-langfuse/THIRD_PARTY_NOTICES.md @@ -0,0 +1,21 @@ +# Third-party notices + +The runtime uses the following npm packages. Versions are pinned by +`package-lock.json` and their licenses remain with the respective projects: + +| Package | Version | License | Source | +| --- | --- | --- | --- | +| `@langfuse/otel` | 5.11.1 | MIT | | +| `@langfuse/tracing` | 5.11.1 | MIT | | +| `@langfuse/core` | 5.11.1 | MIT | | +| `@opentelemetry/api` | 1.9.1 | Apache-2.0 | | +| `@opentelemetry/core` | 2.11.0 | Apache-2.0 | | +| `@opentelemetry/sdk-trace-base` | 2.11.0 | Apache-2.0 | | +| `@opentelemetry/sdk-trace-node` | 2.11.0 | Apache-2.0 | | +| `@opentelemetry/exporter-trace-otlp-http` | 0.222.0 | Apache-2.0 | | +| `@opentelemetry/otlp-transformer` | 0.222.0 | Apache-2.0 | | +| `@opentelemetry/otlp-exporter-base` | 0.222.0 | Apache-2.0 | | + +The plugin sends telemetry to a user-configured Langfuse service over HTTPS. +That service is external to this repository and is governed by the service +operator's terms and privacy policy. No credentials are bundled or published. diff --git a/plugins/zcode-plugin-langfuse/hooks/entry.mjs b/plugins/zcode-plugin-langfuse/hooks/entry.mjs new file mode 100644 index 0000000..0244322 --- /dev/null +++ b/plugins/zcode-plugin-langfuse/hooks/entry.mjs @@ -0,0 +1,35383 @@ +import { createRequire as __pluginCreateRequire } from 'node:module'; +const require = __pluginCreateRequire(import.meta.url); +// Generated by npm run build. Edit src/, not dist/. +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { + get: (a, b) => (typeof require !== "undefined" ? require : a)[b] +}) : x)(function(x) { + if (typeof require !== "undefined") return require.apply(this, arguments); + throw Error('Dynamic require of "' + x + '" is not supported'); +}); +var __esm = (fn, res, err) => function __init() { + if (err) throw err[0]; + try { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; + } catch (e) { + throw err = [e], e; + } +}; +var __commonJS = (cb, mod) => function __require2() { + try { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; + } catch (e) { + throw mod = 0, e; + } +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// node_modules/@opentelemetry/api/build/esm/version.js +var VERSION; +var init_version = __esm({ + "node_modules/@opentelemetry/api/build/esm/version.js"() { + VERSION = "1.9.1"; + } +}); + +// node_modules/@opentelemetry/api/build/esm/internal/semver.js +function _makeCompatibilityCheck(ownVersion) { + const acceptedVersions = /* @__PURE__ */ new Set([ownVersion]); + const rejectedVersions = /* @__PURE__ */ new Set(); + const myVersionMatch = ownVersion.match(re); + if (!myVersionMatch) { + return () => false; + } + const ownVersionParsed = { + major: +myVersionMatch[1], + minor: +myVersionMatch[2], + patch: +myVersionMatch[3], + prerelease: myVersionMatch[4] + }; + if (ownVersionParsed.prerelease != null) { + return function isExactmatch(globalVersion) { + return globalVersion === ownVersion; + }; + } + function _reject(v) { + rejectedVersions.add(v); + return false; + } + function _accept(v) { + acceptedVersions.add(v); + return true; + } + return function isCompatible2(globalVersion) { + if (acceptedVersions.has(globalVersion)) { + return true; + } + if (rejectedVersions.has(globalVersion)) { + return false; + } + const globalVersionMatch = globalVersion.match(re); + if (!globalVersionMatch) { + return _reject(globalVersion); + } + const globalVersionParsed = { + major: +globalVersionMatch[1], + minor: +globalVersionMatch[2], + patch: +globalVersionMatch[3], + prerelease: globalVersionMatch[4] + }; + if (globalVersionParsed.prerelease != null) { + return _reject(globalVersion); + } + if (ownVersionParsed.major !== globalVersionParsed.major) { + return _reject(globalVersion); + } + if (ownVersionParsed.major === 0) { + if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) { + return _accept(globalVersion); + } + return _reject(globalVersion); + } + if (ownVersionParsed.minor <= globalVersionParsed.minor) { + return _accept(globalVersion); + } + return _reject(globalVersion); + }; +} +var re, isCompatible; +var init_semver = __esm({ + "node_modules/@opentelemetry/api/build/esm/internal/semver.js"() { + init_version(); + re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/; + isCompatible = _makeCompatibilityCheck(VERSION); + } +}); + +// node_modules/@opentelemetry/api/build/esm/internal/global-utils.js +function registerGlobal(type, instance, diag3, allowOverride = false) { + var _a2; + const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a2 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a2 !== void 0 ? _a2 : { + version: VERSION + }; + if (!allowOverride && api[type]) { + const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`); + diag3.error(err.stack || err.message); + return false; + } + if (api.version !== VERSION) { + const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${VERSION}`); + diag3.error(err.stack || err.message); + return false; + } + api[type] = instance; + diag3.debug(`@opentelemetry/api: Registered a global for ${type} v${VERSION}.`); + return true; +} +function getGlobal(type) { + var _a2, _b; + const globalVersion = (_a2 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a2 === void 0 ? void 0 : _a2.version; + if (!globalVersion || !isCompatible(globalVersion)) { + return; + } + return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type]; +} +function unregisterGlobal(type, diag3) { + diag3.debug(`@opentelemetry/api: Unregistering a global for ${type} v${VERSION}.`); + const api = _global[GLOBAL_OPENTELEMETRY_API_KEY]; + if (api) { + delete api[type]; + } +} +var major, GLOBAL_OPENTELEMETRY_API_KEY, _global; +var init_global_utils = __esm({ + "node_modules/@opentelemetry/api/build/esm/internal/global-utils.js"() { + init_version(); + init_semver(); + major = VERSION.split(".")[0]; + GLOBAL_OPENTELEMETRY_API_KEY = /* @__PURE__ */ Symbol.for(`opentelemetry.js.api.${major}`); + _global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {}; + } +}); + +// node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js +function logProxy(funcName, namespace, args) { + const logger = getGlobal("diag"); + if (!logger) { + return; + } + return logger[funcName](namespace, ...args); +} +var DiagComponentLogger; +var init_ComponentLogger = __esm({ + "node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js"() { + init_global_utils(); + DiagComponentLogger = class { + constructor(props) { + this._namespace = props.namespace || "DiagComponentLogger"; + } + debug(...args) { + return logProxy("debug", this._namespace, args); + } + error(...args) { + return logProxy("error", this._namespace, args); + } + info(...args) { + return logProxy("info", this._namespace, args); + } + warn(...args) { + return logProxy("warn", this._namespace, args); + } + verbose(...args) { + return logProxy("verbose", this._namespace, args); + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/diag/types.js +var DiagLogLevel; +var init_types = __esm({ + "node_modules/@opentelemetry/api/build/esm/diag/types.js"() { + (function(DiagLogLevel2) { + DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE"; + DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR"; + DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN"; + DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO"; + DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG"; + DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE"; + DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL"; + })(DiagLogLevel || (DiagLogLevel = {})); + } +}); + +// node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js +function createLogLevelDiagLogger(maxLevel, logger) { + if (maxLevel < DiagLogLevel.NONE) { + maxLevel = DiagLogLevel.NONE; + } else if (maxLevel > DiagLogLevel.ALL) { + maxLevel = DiagLogLevel.ALL; + } + logger = logger || {}; + function _filterFunc(funcName, theLevel) { + const theFunc = logger[funcName]; + if (typeof theFunc === "function" && maxLevel >= theLevel) { + return theFunc.bind(logger); + } + return function() { + }; + } + return { + error: _filterFunc("error", DiagLogLevel.ERROR), + warn: _filterFunc("warn", DiagLogLevel.WARN), + info: _filterFunc("info", DiagLogLevel.INFO), + debug: _filterFunc("debug", DiagLogLevel.DEBUG), + verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE) + }; +} +var init_logLevelLogger = __esm({ + "node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js"() { + init_types(); + } +}); + +// node_modules/@opentelemetry/api/build/esm/api/diag.js +var API_NAME, DiagAPI; +var init_diag = __esm({ + "node_modules/@opentelemetry/api/build/esm/api/diag.js"() { + init_ComponentLogger(); + init_logLevelLogger(); + init_types(); + init_global_utils(); + API_NAME = "diag"; + DiagAPI = class _DiagAPI { + /** Get the singleton instance of the DiagAPI API */ + static instance() { + if (!this._instance) { + this._instance = new _DiagAPI(); + } + return this._instance; + } + /** + * Private internal constructor + * @private + */ + constructor() { + function _logProxy(funcName) { + return function(...args) { + const logger = getGlobal("diag"); + if (!logger) + return; + return logger[funcName](...args); + }; + } + const self2 = this; + const setLogger = (logger, optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }) => { + var _a2, _b, _c; + if (logger === self2) { + const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation"); + self2.error((_a2 = err.stack) !== null && _a2 !== void 0 ? _a2 : err.message); + return false; + } + if (typeof optionsOrLogLevel === "number") { + optionsOrLogLevel = { + logLevel: optionsOrLogLevel + }; + } + const oldLogger = getGlobal("diag"); + const newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger); + if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) { + const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : ""; + oldLogger.warn(`Current logger will be overwritten from ${stack}`); + newLogger.warn(`Current logger will overwrite one already registered from ${stack}`); + } + return registerGlobal("diag", newLogger, self2, true); + }; + self2.setLogger = setLogger; + self2.disable = () => { + unregisterGlobal(API_NAME, self2); + }; + self2.createComponentLogger = (options) => { + return new DiagComponentLogger(options); + }; + self2.verbose = _logProxy("verbose"); + self2.debug = _logProxy("debug"); + self2.info = _logProxy("info"); + self2.warn = _logProxy("warn"); + self2.error = _logProxy("error"); + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js +var BaggageImpl; +var init_baggage_impl = __esm({ + "node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js"() { + BaggageImpl = class _BaggageImpl { + constructor(entries) { + this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map(); + } + getEntry(key) { + const entry = this._entries.get(key); + if (!entry) { + return void 0; + } + return Object.assign({}, entry); + } + getAllEntries() { + return Array.from(this._entries.entries()); + } + setEntry(key, entry) { + const newBaggage = new _BaggageImpl(this._entries); + newBaggage._entries.set(key, entry); + return newBaggage; + } + removeEntry(key) { + const newBaggage = new _BaggageImpl(this._entries); + newBaggage._entries.delete(key); + return newBaggage; + } + removeEntries(...keys) { + const newBaggage = new _BaggageImpl(this._entries); + for (const key of keys) { + newBaggage._entries.delete(key); + } + return newBaggage; + } + clear() { + return new _BaggageImpl(); + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/baggage/internal/symbol.js +var baggageEntryMetadataSymbol; +var init_symbol = __esm({ + "node_modules/@opentelemetry/api/build/esm/baggage/internal/symbol.js"() { + baggageEntryMetadataSymbol = /* @__PURE__ */ Symbol("BaggageEntryMetadata"); + } +}); + +// node_modules/@opentelemetry/api/build/esm/baggage/utils.js +function createBaggage(entries = {}) { + return new BaggageImpl(new Map(Object.entries(entries))); +} +function baggageEntryMetadataFromString(str) { + if (typeof str !== "string") { + diag.error(`Cannot create baggage metadata from unknown type: ${typeof str}`); + str = ""; + } + return { + __TYPE__: baggageEntryMetadataSymbol, + toString() { + return str; + } + }; +} +var diag; +var init_utils = __esm({ + "node_modules/@opentelemetry/api/build/esm/baggage/utils.js"() { + init_diag(); + init_baggage_impl(); + init_symbol(); + diag = DiagAPI.instance(); + } +}); + +// node_modules/@opentelemetry/api/build/esm/context/context.js +function createContextKey(description) { + return Symbol.for(description); +} +var BaseContext, ROOT_CONTEXT; +var init_context = __esm({ + "node_modules/@opentelemetry/api/build/esm/context/context.js"() { + BaseContext = class _BaseContext { + /** + * Construct a new context which inherits values from an optional parent context. + * + * @param parentContext a context from which to inherit values + */ + constructor(parentContext) { + const self2 = this; + self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map(); + self2.getValue = (key) => self2._currentContext.get(key); + self2.setValue = (key, value) => { + const context2 = new _BaseContext(self2._currentContext); + context2._currentContext.set(key, value); + return context2; + }; + self2.deleteValue = (key) => { + const context2 = new _BaseContext(self2._currentContext); + context2._currentContext.delete(key); + return context2; + }; + } + }; + ROOT_CONTEXT = new BaseContext(); + } +}); + +// node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js +var consoleMap, _originalConsoleMethods, DiagConsoleLogger; +var init_consoleLogger = __esm({ + "node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js"() { + consoleMap = [ + { n: "error", c: "error" }, + { n: "warn", c: "warn" }, + { n: "info", c: "info" }, + { n: "debug", c: "debug" }, + { n: "verbose", c: "trace" } + ]; + _originalConsoleMethods = {}; + if (typeof console !== "undefined") { + const keys = [ + "error", + "warn", + "info", + "debug", + "trace", + "log" + ]; + for (const key of keys) { + if (typeof console[key] === "function") { + _originalConsoleMethods[key] = console[key]; + } + } + } + DiagConsoleLogger = class { + constructor() { + function _consoleFunc(funcName) { + return function(...args) { + let theFunc = _originalConsoleMethods[funcName]; + if (typeof theFunc !== "function") { + theFunc = _originalConsoleMethods["log"]; + } + if (typeof theFunc !== "function" && console) { + theFunc = console[funcName]; + if (typeof theFunc !== "function") { + theFunc = console.log; + } + } + if (typeof theFunc === "function") { + return theFunc.apply(console, args); + } + }; + } + for (let i = 0; i < consoleMap.length; i++) { + this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c); + } + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js +function createNoopMeter() { + return NOOP_METER; +} +var NoopMeter, NoopMetric, NoopCounterMetric, NoopUpDownCounterMetric, NoopGaugeMetric, NoopHistogramMetric, NoopObservableMetric, NoopObservableCounterMetric, NoopObservableGaugeMetric, NoopObservableUpDownCounterMetric, NOOP_METER, NOOP_COUNTER_METRIC, NOOP_GAUGE_METRIC, NOOP_HISTOGRAM_METRIC, NOOP_UP_DOWN_COUNTER_METRIC, NOOP_OBSERVABLE_COUNTER_METRIC, NOOP_OBSERVABLE_GAUGE_METRIC, NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC; +var init_NoopMeter = __esm({ + "node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js"() { + NoopMeter = class { + constructor() { + } + /** + * @see {@link Meter.createGauge} + */ + createGauge(_name, _options) { + return NOOP_GAUGE_METRIC; + } + /** + * @see {@link Meter.createHistogram} + */ + createHistogram(_name, _options) { + return NOOP_HISTOGRAM_METRIC; + } + /** + * @see {@link Meter.createCounter} + */ + createCounter(_name, _options) { + return NOOP_COUNTER_METRIC; + } + /** + * @see {@link Meter.createUpDownCounter} + */ + createUpDownCounter(_name, _options) { + return NOOP_UP_DOWN_COUNTER_METRIC; + } + /** + * @see {@link Meter.createObservableGauge} + */ + createObservableGauge(_name, _options) { + return NOOP_OBSERVABLE_GAUGE_METRIC; + } + /** + * @see {@link Meter.createObservableCounter} + */ + createObservableCounter(_name, _options) { + return NOOP_OBSERVABLE_COUNTER_METRIC; + } + /** + * @see {@link Meter.createObservableUpDownCounter} + */ + createObservableUpDownCounter(_name, _options) { + return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC; + } + /** + * @see {@link Meter.addBatchObservableCallback} + */ + addBatchObservableCallback(_callback, _observables) { + } + /** + * @see {@link Meter.removeBatchObservableCallback} + */ + removeBatchObservableCallback(_callback) { + } + }; + NoopMetric = class { + }; + NoopCounterMetric = class extends NoopMetric { + add(_value, _attributes) { + } + }; + NoopUpDownCounterMetric = class extends NoopMetric { + add(_value, _attributes) { + } + }; + NoopGaugeMetric = class extends NoopMetric { + record(_value, _attributes) { + } + }; + NoopHistogramMetric = class extends NoopMetric { + record(_value, _attributes) { + } + }; + NoopObservableMetric = class { + addCallback(_callback) { + } + removeCallback(_callback) { + } + }; + NoopObservableCounterMetric = class extends NoopObservableMetric { + }; + NoopObservableGaugeMetric = class extends NoopObservableMetric { + }; + NoopObservableUpDownCounterMetric = class extends NoopObservableMetric { + }; + NOOP_METER = new NoopMeter(); + NOOP_COUNTER_METRIC = new NoopCounterMetric(); + NOOP_GAUGE_METRIC = new NoopGaugeMetric(); + NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric(); + NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric(); + NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric(); + NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric(); + NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric(); + } +}); + +// node_modules/@opentelemetry/api/build/esm/metrics/Metric.js +var ValueType; +var init_Metric = __esm({ + "node_modules/@opentelemetry/api/build/esm/metrics/Metric.js"() { + (function(ValueType2) { + ValueType2[ValueType2["INT"] = 0] = "INT"; + ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE"; + })(ValueType || (ValueType = {})); + } +}); + +// node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js +var defaultTextMapGetter, defaultTextMapSetter; +var init_TextMapPropagator = __esm({ + "node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js"() { + defaultTextMapGetter = { + get(carrier, key) { + if (carrier == null) { + return void 0; + } + return carrier[key]; + }, + keys(carrier) { + if (carrier == null) { + return []; + } + return Object.keys(carrier); + } + }; + defaultTextMapSetter = { + set(carrier, key, value) { + if (carrier == null) { + return; + } + carrier[key] = value; + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js +var NoopContextManager; +var init_NoopContextManager = __esm({ + "node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js"() { + init_context(); + NoopContextManager = class { + active() { + return ROOT_CONTEXT; + } + with(_context, fn, thisArg, ...args) { + return fn.call(thisArg, ...args); + } + bind(_context, target) { + return target; + } + enable() { + return this; + } + disable() { + return this; + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/api/context.js +var API_NAME2, NOOP_CONTEXT_MANAGER, ContextAPI; +var init_context2 = __esm({ + "node_modules/@opentelemetry/api/build/esm/api/context.js"() { + init_NoopContextManager(); + init_global_utils(); + init_diag(); + API_NAME2 = "context"; + NOOP_CONTEXT_MANAGER = new NoopContextManager(); + ContextAPI = class _ContextAPI { + /** Empty private constructor prevents end users from constructing a new instance of the API */ + constructor() { + } + /** Get the singleton instance of the Context API */ + static getInstance() { + if (!this._instance) { + this._instance = new _ContextAPI(); + } + return this._instance; + } + /** + * Set the current context manager. + * + * @returns true if the context manager was successfully registered, else false + */ + setGlobalContextManager(contextManager) { + return registerGlobal(API_NAME2, contextManager, DiagAPI.instance()); + } + /** + * Get the currently active context + */ + active() { + return this._getContextManager().active(); + } + /** + * Execute a function with an active context + * + * @param context context to be active during function execution + * @param fn function to execute in a context + * @param thisArg optional receiver to be used for calling fn + * @param args optional arguments forwarded to fn + */ + with(context2, fn, thisArg, ...args) { + return this._getContextManager().with(context2, fn, thisArg, ...args); + } + /** + * Bind a context to a target function or event emitter + * + * @param context context to bind to the event emitter or function. Defaults to the currently active context + * @param target function or event emitter to bind + */ + bind(context2, target) { + return this._getContextManager().bind(context2, target); + } + _getContextManager() { + return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER; + } + /** Disable and remove the global context manager */ + disable() { + this._getContextManager().disable(); + unregisterGlobal(API_NAME2, DiagAPI.instance()); + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js +var TraceFlags; +var init_trace_flags = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js"() { + (function(TraceFlags2) { + TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE"; + TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED"; + })(TraceFlags || (TraceFlags = {})); + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js +var INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT; +var init_invalid_span_constants = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js"() { + init_trace_flags(); + INVALID_SPANID = "0000000000000000"; + INVALID_TRACEID = "00000000000000000000000000000000"; + INVALID_SPAN_CONTEXT = { + traceId: INVALID_TRACEID, + spanId: INVALID_SPANID, + traceFlags: TraceFlags.NONE + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js +var NonRecordingSpan; +var init_NonRecordingSpan = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js"() { + init_invalid_span_constants(); + NonRecordingSpan = class { + constructor(spanContext = INVALID_SPAN_CONTEXT) { + this._spanContext = spanContext; + } + // Returns a SpanContext. + spanContext() { + return this._spanContext; + } + // By default does nothing + setAttribute(_key, _value) { + return this; + } + // By default does nothing + setAttributes(_attributes) { + return this; + } + // By default does nothing + addEvent(_name, _attributes) { + return this; + } + addLink(_link) { + return this; + } + addLinks(_links) { + return this; + } + // By default does nothing + setStatus(_status) { + return this; + } + // By default does nothing + updateName(_name) { + return this; + } + // By default does nothing + end(_endTime) { + } + // isRecording always returns false for NonRecordingSpan. + isRecording() { + return false; + } + // By default does nothing + recordException(_exception, _time) { + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/context-utils.js +function getSpan(context2) { + return context2.getValue(SPAN_KEY) || void 0; +} +function getActiveSpan() { + return getSpan(ContextAPI.getInstance().active()); +} +function setSpan(context2, span) { + return context2.setValue(SPAN_KEY, span); +} +function deleteSpan(context2) { + return context2.deleteValue(SPAN_KEY); +} +function setSpanContext(context2, spanContext) { + return setSpan(context2, new NonRecordingSpan(spanContext)); +} +function getSpanContext(context2) { + var _a2; + return (_a2 = getSpan(context2)) === null || _a2 === void 0 ? void 0 : _a2.spanContext(); +} +var SPAN_KEY; +var init_context_utils = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/context-utils.js"() { + init_context(); + init_NonRecordingSpan(); + init_context2(); + SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN"); + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js +function isValidHex(id, length) { + if (typeof id !== "string" || id.length !== length) + return false; + let r = 0; + for (let i = 0; i < id.length; i += 4) { + r += (isHex[id.charCodeAt(i)] | 0) + (isHex[id.charCodeAt(i + 1)] | 0) + (isHex[id.charCodeAt(i + 2)] | 0) + (isHex[id.charCodeAt(i + 3)] | 0); + } + return r === length; +} +function isValidTraceId(traceId) { + return isValidHex(traceId, 32) && traceId !== INVALID_TRACEID; +} +function isValidSpanId(spanId) { + return isValidHex(spanId, 16) && spanId !== INVALID_SPANID; +} +function isSpanContextValid(spanContext) { + return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId); +} +function wrapSpanContext(spanContext) { + return new NonRecordingSpan(spanContext); +} +var isHex; +var init_spancontext_utils = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js"() { + init_invalid_span_constants(); + init_NonRecordingSpan(); + isHex = new Uint8Array([ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ]); + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js +function isSpanContext(spanContext) { + return spanContext !== null && typeof spanContext === "object" && "spanId" in spanContext && typeof spanContext["spanId"] === "string" && "traceId" in spanContext && typeof spanContext["traceId"] === "string" && "traceFlags" in spanContext && typeof spanContext["traceFlags"] === "number"; +} +var contextApi, NoopTracer; +var init_NoopTracer = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js"() { + init_context2(); + init_context_utils(); + init_NonRecordingSpan(); + init_spancontext_utils(); + contextApi = ContextAPI.getInstance(); + NoopTracer = class { + // startSpan starts a noop span. + startSpan(name, options, context2 = contextApi.active()) { + const root = Boolean(options === null || options === void 0 ? void 0 : options.root); + if (root) { + return new NonRecordingSpan(); + } + const parentFromContext = context2 && getSpanContext(context2); + if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) { + return new NonRecordingSpan(parentFromContext); + } else { + return new NonRecordingSpan(); + } + } + startActiveSpan(name, arg2, arg3, arg4) { + let opts; + let ctx; + let fn; + if (arguments.length < 2) { + return; + } else if (arguments.length === 2) { + fn = arg2; + } else if (arguments.length === 3) { + opts = arg2; + fn = arg3; + } else { + opts = arg2; + ctx = arg3; + fn = arg4; + } + const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active(); + const span = this.startSpan(name, opts, parentContext); + const contextWithSpanSet = setSpan(parentContext, span); + return contextApi.with(contextWithSpanSet, fn, void 0, span); + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js +var NOOP_TRACER, ProxyTracer; +var init_ProxyTracer = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js"() { + init_NoopTracer(); + NOOP_TRACER = new NoopTracer(); + ProxyTracer = class { + constructor(provider, name, version, options) { + this._provider = provider; + this.name = name; + this.version = version; + this.options = options; + } + startSpan(name, options, context2) { + return this._getTracer().startSpan(name, options, context2); + } + startActiveSpan(_name, _options, _context, _fn) { + const tracer = this._getTracer(); + return Reflect.apply(tracer.startActiveSpan, tracer, arguments); + } + /** + * Try to get a tracer from the proxy tracer provider. + * If the proxy tracer provider has no delegate, return a noop tracer. + */ + _getTracer() { + if (this._delegate) { + return this._delegate; + } + const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options); + if (!tracer) { + return NOOP_TRACER; + } + this._delegate = tracer; + return this._delegate; + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js +var NoopTracerProvider; +var init_NoopTracerProvider = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js"() { + init_NoopTracer(); + NoopTracerProvider = class { + getTracer(_name, _version, _options) { + return new NoopTracer(); + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js +var NOOP_TRACER_PROVIDER, ProxyTracerProvider; +var init_ProxyTracerProvider = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js"() { + init_ProxyTracer(); + init_NoopTracerProvider(); + NOOP_TRACER_PROVIDER = new NoopTracerProvider(); + ProxyTracerProvider = class { + /** + * Get a {@link ProxyTracer} + */ + getTracer(name, version, options) { + var _a2; + return (_a2 = this.getDelegateTracer(name, version, options)) !== null && _a2 !== void 0 ? _a2 : new ProxyTracer(this, name, version, options); + } + getDelegate() { + var _a2; + return (_a2 = this._delegate) !== null && _a2 !== void 0 ? _a2 : NOOP_TRACER_PROVIDER; + } + /** + * Set the delegate tracer provider + */ + setDelegate(delegate) { + this._delegate = delegate; + } + getDelegateTracer(name, version, options) { + var _a2; + return (_a2 = this._delegate) === null || _a2 === void 0 ? void 0 : _a2.getTracer(name, version, options); + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/SamplingResult.js +var SamplingDecision; +var init_SamplingResult = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/SamplingResult.js"() { + (function(SamplingDecision2) { + SamplingDecision2[SamplingDecision2["NOT_RECORD"] = 0] = "NOT_RECORD"; + SamplingDecision2[SamplingDecision2["RECORD"] = 1] = "RECORD"; + SamplingDecision2[SamplingDecision2["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED"; + })(SamplingDecision || (SamplingDecision = {})); + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/span_kind.js +var SpanKind; +var init_span_kind = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/span_kind.js"() { + (function(SpanKind2) { + SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL"; + SpanKind2[SpanKind2["SERVER"] = 1] = "SERVER"; + SpanKind2[SpanKind2["CLIENT"] = 2] = "CLIENT"; + SpanKind2[SpanKind2["PRODUCER"] = 3] = "PRODUCER"; + SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER"; + })(SpanKind || (SpanKind = {})); + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/status.js +var SpanStatusCode; +var init_status = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/status.js"() { + (function(SpanStatusCode2) { + SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET"; + SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK"; + SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR"; + })(SpanStatusCode || (SpanStatusCode = {})); + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-validators.js +function validateKey(key) { + return VALID_KEY_REGEX.test(key); +} +function validateValue(value) { + return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value); +} +var VALID_KEY_CHAR_RANGE, VALID_KEY, VALID_VENDOR_KEY, VALID_KEY_REGEX, VALID_VALUE_BASE_REGEX, INVALID_VALUE_COMMA_EQUAL_REGEX; +var init_tracestate_validators = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-validators.js"() { + VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]"; + VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`; + VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`; + VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`); + VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/; + INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/; + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-impl.js +var MAX_TRACE_STATE_ITEMS, MAX_TRACE_STATE_LEN, LIST_MEMBERS_SEPARATOR, LIST_MEMBER_KEY_VALUE_SPLITTER, TraceStateImpl; +var init_tracestate_impl = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-impl.js"() { + init_tracestate_validators(); + MAX_TRACE_STATE_ITEMS = 32; + MAX_TRACE_STATE_LEN = 512; + LIST_MEMBERS_SEPARATOR = ","; + LIST_MEMBER_KEY_VALUE_SPLITTER = "="; + TraceStateImpl = class _TraceStateImpl { + constructor(rawTraceState) { + this._internalState = /* @__PURE__ */ new Map(); + if (rawTraceState) + this._parse(rawTraceState); + } + set(key, value) { + const traceState = this._clone(); + if (traceState._internalState.has(key)) { + traceState._internalState.delete(key); + } + traceState._internalState.set(key, value); + return traceState; + } + unset(key) { + const traceState = this._clone(); + traceState._internalState.delete(key); + return traceState; + } + get(key) { + return this._internalState.get(key); + } + serialize() { + return Array.from(this._internalState.keys()).reduceRight((agg, key) => { + agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key)); + return agg; + }, []).join(LIST_MEMBERS_SEPARATOR); + } + _parse(rawTraceState) { + if (rawTraceState.length > MAX_TRACE_STATE_LEN) + return; + this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reduceRight((agg, part) => { + const listMember = part.trim(); + const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER); + if (i !== -1) { + const key = listMember.slice(0, i); + const value = listMember.slice(i + 1, part.length); + if (validateKey(key) && validateValue(value)) { + agg.set(key, value); + } else { + } + } + return agg; + }, /* @__PURE__ */ new Map()); + if (this._internalState.size > MAX_TRACE_STATE_ITEMS) { + this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, MAX_TRACE_STATE_ITEMS)); + } + } + // @ts-expect-error TS6133 Accessed in tests only. + _keys() { + return Array.from(this._internalState.keys()).reverse(); + } + _clone() { + const traceState = new _TraceStateImpl(); + traceState._internalState = new Map(this._internalState); + return traceState; + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace/internal/utils.js +function createTraceState(rawTraceState) { + return new TraceStateImpl(rawTraceState); +} +var init_utils2 = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace/internal/utils.js"() { + init_tracestate_impl(); + } +}); + +// node_modules/@opentelemetry/api/build/esm/context-api.js +var context; +var init_context_api = __esm({ + "node_modules/@opentelemetry/api/build/esm/context-api.js"() { + init_context2(); + context = ContextAPI.getInstance(); + } +}); + +// node_modules/@opentelemetry/api/build/esm/diag-api.js +var diag2; +var init_diag_api = __esm({ + "node_modules/@opentelemetry/api/build/esm/diag-api.js"() { + init_diag(); + diag2 = DiagAPI.instance(); + } +}); + +// node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js +var NoopMeterProvider, NOOP_METER_PROVIDER; +var init_NoopMeterProvider = __esm({ + "node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js"() { + init_NoopMeter(); + NoopMeterProvider = class { + getMeter(_name, _version, _options) { + return NOOP_METER; + } + }; + NOOP_METER_PROVIDER = new NoopMeterProvider(); + } +}); + +// node_modules/@opentelemetry/api/build/esm/api/metrics.js +var API_NAME3, MetricsAPI; +var init_metrics = __esm({ + "node_modules/@opentelemetry/api/build/esm/api/metrics.js"() { + init_NoopMeterProvider(); + init_global_utils(); + init_diag(); + API_NAME3 = "metrics"; + MetricsAPI = class _MetricsAPI { + /** Empty private constructor prevents end users from constructing a new instance of the API */ + constructor() { + } + /** Get the singleton instance of the Metrics API */ + static getInstance() { + if (!this._instance) { + this._instance = new _MetricsAPI(); + } + return this._instance; + } + /** + * Set the current global meter provider. + * Returns true if the meter provider was successfully registered, else false. + */ + setGlobalMeterProvider(provider) { + return registerGlobal(API_NAME3, provider, DiagAPI.instance()); + } + /** + * Returns the global meter provider. + */ + getMeterProvider() { + return getGlobal(API_NAME3) || NOOP_METER_PROVIDER; + } + /** + * Returns a meter from the global meter provider. + */ + getMeter(name, version, options) { + return this.getMeterProvider().getMeter(name, version, options); + } + /** Remove the global meter provider */ + disable() { + unregisterGlobal(API_NAME3, DiagAPI.instance()); + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/metrics-api.js +var metrics; +var init_metrics_api = __esm({ + "node_modules/@opentelemetry/api/build/esm/metrics-api.js"() { + init_metrics(); + metrics = MetricsAPI.getInstance(); + } +}); + +// node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js +var NoopTextMapPropagator; +var init_NoopTextMapPropagator = __esm({ + "node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js"() { + NoopTextMapPropagator = class { + /** Noop inject function does nothing */ + inject(_context, _carrier) { + } + /** Noop extract function does nothing and returns the input context */ + extract(context2, _carrier) { + return context2; + } + fields() { + return []; + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/baggage/context-helpers.js +function getBaggage(context2) { + return context2.getValue(BAGGAGE_KEY) || void 0; +} +function getActiveBaggage() { + return getBaggage(ContextAPI.getInstance().active()); +} +function setBaggage(context2, baggage) { + return context2.setValue(BAGGAGE_KEY, baggage); +} +function deleteBaggage(context2) { + return context2.deleteValue(BAGGAGE_KEY); +} +var BAGGAGE_KEY; +var init_context_helpers = __esm({ + "node_modules/@opentelemetry/api/build/esm/baggage/context-helpers.js"() { + init_context2(); + init_context(); + BAGGAGE_KEY = createContextKey("OpenTelemetry Baggage Key"); + } +}); + +// node_modules/@opentelemetry/api/build/esm/api/propagation.js +var API_NAME4, NOOP_TEXT_MAP_PROPAGATOR, PropagationAPI; +var init_propagation = __esm({ + "node_modules/@opentelemetry/api/build/esm/api/propagation.js"() { + init_global_utils(); + init_NoopTextMapPropagator(); + init_TextMapPropagator(); + init_context_helpers(); + init_utils(); + init_diag(); + API_NAME4 = "propagation"; + NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator(); + PropagationAPI = class _PropagationAPI { + /** Empty private constructor prevents end users from constructing a new instance of the API */ + constructor() { + this.createBaggage = createBaggage; + this.getBaggage = getBaggage; + this.getActiveBaggage = getActiveBaggage; + this.setBaggage = setBaggage; + this.deleteBaggage = deleteBaggage; + } + /** Get the singleton instance of the Propagator API */ + static getInstance() { + if (!this._instance) { + this._instance = new _PropagationAPI(); + } + return this._instance; + } + /** + * Set the current propagator. + * + * @returns true if the propagator was successfully registered, else false + */ + setGlobalPropagator(propagator) { + return registerGlobal(API_NAME4, propagator, DiagAPI.instance()); + } + /** + * Inject context into a carrier to be propagated inter-process + * + * @param context Context carrying tracing data to inject + * @param carrier carrier to inject context into + * @param setter Function used to set values on the carrier + */ + inject(context2, carrier, setter = defaultTextMapSetter) { + return this._getGlobalPropagator().inject(context2, carrier, setter); + } + /** + * Extract context from a carrier + * + * @param context Context which the newly created context will inherit from + * @param carrier Carrier to extract context from + * @param getter Function used to extract keys from a carrier + */ + extract(context2, carrier, getter = defaultTextMapGetter) { + return this._getGlobalPropagator().extract(context2, carrier, getter); + } + /** + * Return a list of all fields which may be used by the propagator. + */ + fields() { + return this._getGlobalPropagator().fields(); + } + /** Remove the global propagator */ + disable() { + unregisterGlobal(API_NAME4, DiagAPI.instance()); + } + _getGlobalPropagator() { + return getGlobal(API_NAME4) || NOOP_TEXT_MAP_PROPAGATOR; + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/propagation-api.js +var propagation; +var init_propagation_api = __esm({ + "node_modules/@opentelemetry/api/build/esm/propagation-api.js"() { + init_propagation(); + propagation = PropagationAPI.getInstance(); + } +}); + +// node_modules/@opentelemetry/api/build/esm/api/trace.js +var API_NAME5, TraceAPI; +var init_trace = __esm({ + "node_modules/@opentelemetry/api/build/esm/api/trace.js"() { + init_global_utils(); + init_ProxyTracerProvider(); + init_spancontext_utils(); + init_context_utils(); + init_diag(); + API_NAME5 = "trace"; + TraceAPI = class _TraceAPI { + /** Empty private constructor prevents end users from constructing a new instance of the API */ + constructor() { + this._proxyTracerProvider = new ProxyTracerProvider(); + this.wrapSpanContext = wrapSpanContext; + this.isSpanContextValid = isSpanContextValid; + this.deleteSpan = deleteSpan; + this.getSpan = getSpan; + this.getActiveSpan = getActiveSpan; + this.getSpanContext = getSpanContext; + this.setSpan = setSpan; + this.setSpanContext = setSpanContext; + } + /** Get the singleton instance of the Trace API */ + static getInstance() { + if (!this._instance) { + this._instance = new _TraceAPI(); + } + return this._instance; + } + /** + * Set the current global tracer. + * + * @returns true if the tracer provider was successfully registered, else false + */ + setGlobalTracerProvider(provider) { + const success = registerGlobal(API_NAME5, this._proxyTracerProvider, DiagAPI.instance()); + if (success) { + this._proxyTracerProvider.setDelegate(provider); + } + return success; + } + /** + * Returns the global tracer provider. + */ + getTracerProvider() { + return getGlobal(API_NAME5) || this._proxyTracerProvider; + } + /** + * Returns a tracer from the global tracer provider. + */ + getTracer(name, version) { + return this.getTracerProvider().getTracer(name, version); + } + /** Remove the global tracer provider */ + disable() { + unregisterGlobal(API_NAME5, DiagAPI.instance()); + this._proxyTracerProvider = new ProxyTracerProvider(); + } + }; + } +}); + +// node_modules/@opentelemetry/api/build/esm/trace-api.js +var trace; +var init_trace_api = __esm({ + "node_modules/@opentelemetry/api/build/esm/trace-api.js"() { + init_trace(); + trace = TraceAPI.getInstance(); + } +}); + +// node_modules/@opentelemetry/api/build/esm/index.js +var esm_exports = {}; +__export(esm_exports, { + DiagConsoleLogger: () => DiagConsoleLogger, + DiagLogLevel: () => DiagLogLevel, + INVALID_SPANID: () => INVALID_SPANID, + INVALID_SPAN_CONTEXT: () => INVALID_SPAN_CONTEXT, + INVALID_TRACEID: () => INVALID_TRACEID, + ProxyTracer: () => ProxyTracer, + ProxyTracerProvider: () => ProxyTracerProvider, + ROOT_CONTEXT: () => ROOT_CONTEXT, + SamplingDecision: () => SamplingDecision, + SpanKind: () => SpanKind, + SpanStatusCode: () => SpanStatusCode, + TraceFlags: () => TraceFlags, + ValueType: () => ValueType, + baggageEntryMetadataFromString: () => baggageEntryMetadataFromString, + context: () => context, + createContextKey: () => createContextKey, + createNoopMeter: () => createNoopMeter, + createTraceState: () => createTraceState, + default: () => esm_default, + defaultTextMapGetter: () => defaultTextMapGetter, + defaultTextMapSetter: () => defaultTextMapSetter, + diag: () => diag2, + isSpanContextValid: () => isSpanContextValid, + isValidSpanId: () => isValidSpanId, + isValidTraceId: () => isValidTraceId, + metrics: () => metrics, + propagation: () => propagation, + trace: () => trace +}); +var esm_default; +var init_esm = __esm({ + "node_modules/@opentelemetry/api/build/esm/index.js"() { + init_utils(); + init_context(); + init_consoleLogger(); + init_types(); + init_NoopMeter(); + init_Metric(); + init_TextMapPropagator(); + init_ProxyTracer(); + init_ProxyTracerProvider(); + init_SamplingResult(); + init_span_kind(); + init_status(); + init_trace_flags(); + init_utils2(); + init_spancontext_utils(); + init_invalid_span_constants(); + init_context_api(); + init_diag_api(); + init_metrics_api(); + init_propagation_api(); + init_trace_api(); + esm_default = { + context, + diag: diag2, + metrics, + propagation, + trace + }; + } +}); + +// node_modules/@opentelemetry/core/build/src/trace/suppress-tracing.js +var require_suppress_tracing = __commonJS({ + "node_modules/@opentelemetry/core/build/src/trace/suppress-tracing.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isTracingSuppressed = exports.unsuppressTracing = exports.suppressTracing = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var SUPPRESS_TRACING_KEY = (0, api_1.createContextKey)("OpenTelemetry SDK Context Key SUPPRESS_TRACING"); + function suppressTracing(context2) { + return context2.setValue(SUPPRESS_TRACING_KEY, true); + } + exports.suppressTracing = suppressTracing; + function unsuppressTracing(context2) { + return context2.deleteValue(SUPPRESS_TRACING_KEY); + } + exports.unsuppressTracing = unsuppressTracing; + function isTracingSuppressed(context2) { + return context2.getValue(SUPPRESS_TRACING_KEY) === true; + } + exports.isTracingSuppressed = isTracingSuppressed; + } +}); + +// node_modules/@opentelemetry/core/build/src/baggage/constants.js +var require_constants = __commonJS({ + "node_modules/@opentelemetry/core/build/src/baggage/constants.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.BAGGAGE_MAX_TOTAL_LENGTH = exports.BAGGAGE_MAX_PER_NAME_VALUE_PAIRS = exports.BAGGAGE_MAX_NAME_VALUE_PAIRS = exports.BAGGAGE_HEADER = exports.BAGGAGE_ITEMS_SEPARATOR = exports.BAGGAGE_PROPERTIES_SEPARATOR = exports.BAGGAGE_KEY_PAIR_SEPARATOR = void 0; + exports.BAGGAGE_KEY_PAIR_SEPARATOR = "="; + exports.BAGGAGE_PROPERTIES_SEPARATOR = ";"; + exports.BAGGAGE_ITEMS_SEPARATOR = ","; + exports.BAGGAGE_HEADER = "baggage"; + exports.BAGGAGE_MAX_NAME_VALUE_PAIRS = 180; + exports.BAGGAGE_MAX_PER_NAME_VALUE_PAIRS = 4096; + exports.BAGGAGE_MAX_TOTAL_LENGTH = 8192; + } +}); + +// node_modules/@opentelemetry/core/build/src/baggage/utils.js +var require_utils = __commonJS({ + "node_modules/@opentelemetry/core/build/src/baggage/utils.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.parseKeyPairsIntoRecord = exports.parseBaggageHeaderString = exports.parsePairKeyValue = exports.getKeyPairs = exports.serializeKeyPairs = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var constants_1 = require_constants(); + function serializeKeyPairs(keyPairs) { + return keyPairs.reduce((hValue, current) => { + const value = `${hValue}${hValue !== "" ? constants_1.BAGGAGE_ITEMS_SEPARATOR : ""}${current}`; + return value.length > constants_1.BAGGAGE_MAX_TOTAL_LENGTH ? hValue : value; + }, ""); + } + exports.serializeKeyPairs = serializeKeyPairs; + function getKeyPairs(baggage) { + return baggage.getAllEntries().map(([key, value]) => { + let entry = `${encodeURIComponent(key)}=${encodeURIComponent(value.value)}`; + if (value.metadata !== void 0) { + entry += constants_1.BAGGAGE_PROPERTIES_SEPARATOR + value.metadata.toString(); + } + return entry; + }); + } + exports.getKeyPairs = getKeyPairs; + function parsePairKeyValue(entry) { + if (!entry) + return; + const metadataSeparatorIndex = entry.indexOf(constants_1.BAGGAGE_PROPERTIES_SEPARATOR); + const keyPairPart = metadataSeparatorIndex === -1 ? entry : entry.substring(0, metadataSeparatorIndex); + const separatorIndex = keyPairPart.indexOf(constants_1.BAGGAGE_KEY_PAIR_SEPARATOR); + if (separatorIndex <= 0) + return; + const rawKey = keyPairPart.substring(0, separatorIndex).trim(); + const rawValue = keyPairPart.substring(separatorIndex + 1).trim(); + if (!rawKey || !rawValue) + return; + let key; + let value; + try { + key = decodeURIComponent(rawKey); + value = decodeURIComponent(rawValue); + } catch { + return; + } + let metadata; + if (metadataSeparatorIndex !== -1 && metadataSeparatorIndex < entry.length - 1) { + const metadataString = entry.substring(metadataSeparatorIndex + 1); + metadata = (0, api_1.baggageEntryMetadataFromString)(metadataString); + } + return { key, value, metadata }; + } + exports.parsePairKeyValue = parsePairKeyValue; + function parseBaggageHeaderString(value, baggage, count, totalSize) { + let start = 0; + while (start < value.length && count < constants_1.BAGGAGE_MAX_NAME_VALUE_PAIRS) { + const end = value.indexOf(constants_1.BAGGAGE_ITEMS_SEPARATOR, start); + const entryEnd = end === -1 ? value.length : end; + const entryLength = entryEnd - start; + if (entryLength <= constants_1.BAGGAGE_MAX_PER_NAME_VALUE_PAIRS) { + const keyPair = parsePairKeyValue(value.substring(start, entryEnd)); + if (keyPair) { + const entrySize = (count === 0 ? 0 : 1) + entryLength; + if (totalSize + entrySize > constants_1.BAGGAGE_MAX_TOTAL_LENGTH) + break; + baggage[keyPair.key] = keyPair.metadata ? { value: keyPair.value, metadata: keyPair.metadata } : { value: keyPair.value }; + count++; + totalSize += entrySize; + } + } + if (end === -1) + break; + start = end + 1; + } + return [count, totalSize]; + } + exports.parseBaggageHeaderString = parseBaggageHeaderString; + function parseKeyPairsIntoRecord2(value) { + const result = {}; + if (typeof value === "string" && value.length > 0) { + value.split(constants_1.BAGGAGE_ITEMS_SEPARATOR).forEach((entry) => { + const keyPair = parsePairKeyValue(entry); + if (keyPair !== void 0 && keyPair.value.length > 0) { + result[keyPair.key] = keyPair.value; + } + }); + } + return result; + } + exports.parseKeyPairsIntoRecord = parseKeyPairsIntoRecord2; + } +}); + +// node_modules/@opentelemetry/core/build/src/baggage/propagation/W3CBaggagePropagator.js +var require_W3CBaggagePropagator = __commonJS({ + "node_modules/@opentelemetry/core/build/src/baggage/propagation/W3CBaggagePropagator.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.W3CBaggagePropagator = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var suppress_tracing_1 = require_suppress_tracing(); + var constants_1 = require_constants(); + var utils_1 = require_utils(); + var W3CBaggagePropagator = class { + inject(context2, carrier, setter) { + const baggage = api_1.propagation.getBaggage(context2); + if (!baggage || (0, suppress_tracing_1.isTracingSuppressed)(context2)) + return; + const keyPairs = (0, utils_1.getKeyPairs)(baggage).filter((pair) => { + return pair.length <= constants_1.BAGGAGE_MAX_PER_NAME_VALUE_PAIRS; + }).slice(0, constants_1.BAGGAGE_MAX_NAME_VALUE_PAIRS); + const headerValue = (0, utils_1.serializeKeyPairs)(keyPairs); + if (headerValue.length > 0) { + setter.set(carrier, constants_1.BAGGAGE_HEADER, headerValue); + } + } + extract(context2, carrier, getter) { + const headerValue = getter.get(carrier, constants_1.BAGGAGE_HEADER); + if (!headerValue) { + return context2; + } + const baggage = {}; + let count = 0; + let totalSize = 0; + if (Array.isArray(headerValue)) { + for (let i = 0; i < headerValue.length; i++) { + [count, totalSize] = (0, utils_1.parseBaggageHeaderString)(headerValue[i], baggage, count, totalSize); + } + } else { + [count] = (0, utils_1.parseBaggageHeaderString)(headerValue, baggage, count, totalSize); + } + if (count === 0) { + return context2; + } + return api_1.propagation.setBaggage(context2, api_1.propagation.createBaggage(baggage)); + } + fields() { + return [constants_1.BAGGAGE_HEADER]; + } + }; + exports.W3CBaggagePropagator = W3CBaggagePropagator; + } +}); + +// node_modules/@opentelemetry/core/build/src/common/anchored-clock.js +var require_anchored_clock = __commonJS({ + "node_modules/@opentelemetry/core/build/src/common/anchored-clock.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.AnchoredClock = void 0; + var AnchoredClock = class { + _monotonicClock; + _epochMillis; + _performanceMillis; + /** + * Create a new AnchoredClock anchored to the current time returned by systemClock. + * + * @param systemClock should be a clock that returns the number of milliseconds since January 1 1970 such as Date + * @param monotonicClock should be a clock that counts milliseconds monotonically such as window.performance or perf_hooks.performance + */ + constructor(systemClock, monotonicClock) { + this._monotonicClock = monotonicClock; + this._epochMillis = systemClock.now(); + this._performanceMillis = monotonicClock.now(); + } + /** + * Returns the current time by adding the number of milliseconds since the + * AnchoredClock was created to the creation epoch time + */ + now() { + const delta = this._monotonicClock.now() - this._performanceMillis; + return this._epochMillis + delta; + } + }; + exports.AnchoredClock = AnchoredClock; + } +}); + +// node_modules/@opentelemetry/core/build/src/common/attributes.js +var require_attributes = __commonJS({ + "node_modules/@opentelemetry/core/build/src/common/attributes.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isAttributeValue = exports.isAttributeKey = exports.sanitizeAttributes = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + function sanitizeAttributes(attributes) { + const out = {}; + if (typeof attributes !== "object" || attributes == null) { + return out; + } + for (const key in attributes) { + if (!Object.prototype.hasOwnProperty.call(attributes, key)) { + continue; + } + if (!isAttributeKey(key)) { + api_1.diag.warn(`Invalid attribute key: ${key}`); + continue; + } + const val = attributes[key]; + if (!isAttributeValue(val)) { + api_1.diag.warn(`Invalid attribute value set for key: ${key}`); + continue; + } + if (Array.isArray(val)) { + out[key] = val.slice(); + } else { + out[key] = val; + } + } + return out; + } + exports.sanitizeAttributes = sanitizeAttributes; + function isAttributeKey(key) { + return typeof key === "string" && key !== ""; + } + exports.isAttributeKey = isAttributeKey; + function isAttributeValue(val) { + if (val == null) { + return true; + } + if (Array.isArray(val)) { + return isHomogeneousAttributeValueArray(val); + } + return isValidPrimitiveAttributeValueType(typeof val); + } + exports.isAttributeValue = isAttributeValue; + function isHomogeneousAttributeValueArray(arr) { + let type; + for (const element of arr) { + if (element == null) + continue; + const elementType = typeof element; + if (elementType === type) { + continue; + } + if (!type) { + if (isValidPrimitiveAttributeValueType(elementType)) { + type = elementType; + continue; + } + return false; + } + return false; + } + return true; + } + function isValidPrimitiveAttributeValueType(valType) { + switch (valType) { + case "number": + case "boolean": + case "string": + return true; + } + return false; + } + } +}); + +// node_modules/@opentelemetry/core/build/src/common/logging-error-handler.js +var require_logging_error_handler = __commonJS({ + "node_modules/@opentelemetry/core/build/src/common/logging-error-handler.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.loggingErrorHandler = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + function loggingErrorHandler() { + return (ex) => { + api_1.diag.error(stringifyException(ex)); + }; + } + exports.loggingErrorHandler = loggingErrorHandler; + function stringifyException(ex) { + if (typeof ex === "string") { + return ex; + } else { + return JSON.stringify(flattenException(ex)); + } + } + function flattenException(ex) { + const result = {}; + let current = ex; + while (current !== null) { + Object.getOwnPropertyNames(current).forEach((propertyName) => { + if (result[propertyName]) + return; + const value = current[propertyName]; + if (value) { + result[propertyName] = String(value); + } + }); + current = Object.getPrototypeOf(current); + } + return result; + } + } +}); + +// node_modules/@opentelemetry/core/build/src/common/global-error-handler.js +var require_global_error_handler = __commonJS({ + "node_modules/@opentelemetry/core/build/src/common/global-error-handler.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.globalErrorHandler = exports.setGlobalErrorHandler = void 0; + var logging_error_handler_1 = require_logging_error_handler(); + var delegateHandler = (0, logging_error_handler_1.loggingErrorHandler)(); + function setGlobalErrorHandler(handler) { + delegateHandler = handler; + } + exports.setGlobalErrorHandler = setGlobalErrorHandler; + function globalErrorHandler(ex) { + try { + delegateHandler(ex); + } catch { + } + } + exports.globalErrorHandler = globalErrorHandler; + } +}); + +// node_modules/@opentelemetry/core/build/src/platform/node/environment.js +var require_environment = __commonJS({ + "node_modules/@opentelemetry/core/build/src/platform/node/environment.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getStringListFromEnv = exports.getBooleanFromEnv = exports.getStringFromEnv = exports.getNumberFromEnv = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var util_1 = __require("util"); + function getNumberFromEnv2(key) { + const raw = process.env[key]; + if (raw == null || raw.trim() === "") { + return void 0; + } + const value = Number(raw); + if (isNaN(value)) { + api_1.diag.warn(`Unknown value ${(0, util_1.inspect)(raw)} for ${key}, expected a number, using defaults`); + return void 0; + } + return value; + } + exports.getNumberFromEnv = getNumberFromEnv2; + function getStringFromEnv3(key) { + const raw = process.env[key]; + if (raw == null || raw.trim() === "") { + return void 0; + } + return raw; + } + exports.getStringFromEnv = getStringFromEnv3; + function getBooleanFromEnv(key) { + const raw = process.env[key]?.trim().toLowerCase(); + if (raw == null || raw === "") { + return false; + } + if (raw === "true") { + return true; + } else if (raw === "false") { + return false; + } else { + api_1.diag.warn(`Unknown value ${(0, util_1.inspect)(raw)} for ${key}, expected 'true' or 'false', falling back to 'false' (default)`); + return false; + } + } + exports.getBooleanFromEnv = getBooleanFromEnv; + function getStringListFromEnv(key) { + return getStringFromEnv3(key)?.split(",").map((v) => v.trim()).filter((s) => s !== ""); + } + exports.getStringListFromEnv = getStringListFromEnv; + } +}); + +// node_modules/@opentelemetry/core/build/src/common/globalThis.js +var require_globalThis = __commonJS({ + "node_modules/@opentelemetry/core/build/src/common/globalThis.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports._globalThis = void 0; + exports._globalThis = globalThis; + } +}); + +// node_modules/@opentelemetry/core/build/src/version.js +var require_version = __commonJS({ + "node_modules/@opentelemetry/core/build/src/version.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.VERSION = void 0; + exports.VERSION = "2.11.0"; + } +}); + +// node_modules/@opentelemetry/semantic-conventions/build/esm/internal/utils.js +// @__NO_SIDE_EFFECTS__ +function createConstMap(values) { + let res = {}; + const len = values.length; + for (let lp = 0; lp < len; lp++) { + const val = values[lp]; + if (val) { + res[String(val).toUpperCase().replace(/[-.]/g, "_")] = val; + } + } + return res; +} +var init_utils3 = __esm({ + "node_modules/@opentelemetry/semantic-conventions/build/esm/internal/utils.js"() { + } +}); + +// node_modules/@opentelemetry/semantic-conventions/build/esm/trace/SemanticAttributes.js +var TMP_AWS_LAMBDA_INVOKED_ARN, TMP_DB_SYSTEM, TMP_DB_CONNECTION_STRING, TMP_DB_USER, TMP_DB_JDBC_DRIVER_CLASSNAME, TMP_DB_NAME, TMP_DB_STATEMENT, TMP_DB_OPERATION, TMP_DB_MSSQL_INSTANCE_NAME, TMP_DB_CASSANDRA_KEYSPACE, TMP_DB_CASSANDRA_PAGE_SIZE, TMP_DB_CASSANDRA_CONSISTENCY_LEVEL, TMP_DB_CASSANDRA_TABLE, TMP_DB_CASSANDRA_IDEMPOTENCE, TMP_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT, TMP_DB_CASSANDRA_COORDINATOR_ID, TMP_DB_CASSANDRA_COORDINATOR_DC, TMP_DB_HBASE_NAMESPACE, TMP_DB_REDIS_DATABASE_INDEX, TMP_DB_MONGODB_COLLECTION, TMP_DB_SQL_TABLE, TMP_EXCEPTION_TYPE, TMP_EXCEPTION_MESSAGE, TMP_EXCEPTION_STACKTRACE, TMP_EXCEPTION_ESCAPED, TMP_FAAS_TRIGGER, TMP_FAAS_EXECUTION, TMP_FAAS_DOCUMENT_COLLECTION, TMP_FAAS_DOCUMENT_OPERATION, TMP_FAAS_DOCUMENT_TIME, TMP_FAAS_DOCUMENT_NAME, TMP_FAAS_TIME, TMP_FAAS_CRON, TMP_FAAS_COLDSTART, TMP_FAAS_INVOKED_NAME, TMP_FAAS_INVOKED_PROVIDER, TMP_FAAS_INVOKED_REGION, TMP_NET_TRANSPORT, TMP_NET_PEER_IP, TMP_NET_PEER_PORT, TMP_NET_PEER_NAME, TMP_NET_HOST_IP, TMP_NET_HOST_PORT, TMP_NET_HOST_NAME, TMP_NET_HOST_CONNECTION_TYPE, TMP_NET_HOST_CONNECTION_SUBTYPE, TMP_NET_HOST_CARRIER_NAME, TMP_NET_HOST_CARRIER_MCC, TMP_NET_HOST_CARRIER_MNC, TMP_NET_HOST_CARRIER_ICC, TMP_PEER_SERVICE, TMP_ENDUSER_ID, TMP_ENDUSER_ROLE, TMP_ENDUSER_SCOPE, TMP_THREAD_ID, TMP_THREAD_NAME, TMP_CODE_FUNCTION, TMP_CODE_NAMESPACE, TMP_CODE_FILEPATH, TMP_CODE_LINENO, TMP_HTTP_METHOD, TMP_HTTP_URL, TMP_HTTP_TARGET, TMP_HTTP_HOST, TMP_HTTP_SCHEME, TMP_HTTP_STATUS_CODE, TMP_HTTP_FLAVOR, TMP_HTTP_USER_AGENT, TMP_HTTP_REQUEST_CONTENT_LENGTH, TMP_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED, TMP_HTTP_RESPONSE_CONTENT_LENGTH, TMP_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED, TMP_HTTP_SERVER_NAME, TMP_HTTP_ROUTE, TMP_HTTP_CLIENT_IP, TMP_AWS_DYNAMODB_TABLE_NAMES, TMP_AWS_DYNAMODB_CONSUMED_CAPACITY, TMP_AWS_DYNAMODB_ITEM_COLLECTION_METRICS, TMP_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY, TMP_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY, TMP_AWS_DYNAMODB_CONSISTENT_READ, TMP_AWS_DYNAMODB_PROJECTION, TMP_AWS_DYNAMODB_LIMIT, TMP_AWS_DYNAMODB_ATTRIBUTES_TO_GET, TMP_AWS_DYNAMODB_INDEX_NAME, TMP_AWS_DYNAMODB_SELECT, TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES, TMP_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES, TMP_AWS_DYNAMODB_EXCLUSIVE_START_TABLE, TMP_AWS_DYNAMODB_TABLE_COUNT, TMP_AWS_DYNAMODB_SCAN_FORWARD, TMP_AWS_DYNAMODB_SEGMENT, TMP_AWS_DYNAMODB_TOTAL_SEGMENTS, TMP_AWS_DYNAMODB_COUNT, TMP_AWS_DYNAMODB_SCANNED_COUNT, TMP_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS, TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES, TMP_MESSAGING_SYSTEM, TMP_MESSAGING_DESTINATION, TMP_MESSAGING_DESTINATION_KIND, TMP_MESSAGING_TEMP_DESTINATION, TMP_MESSAGING_PROTOCOL, TMP_MESSAGING_PROTOCOL_VERSION, TMP_MESSAGING_URL, TMP_MESSAGING_MESSAGE_ID, TMP_MESSAGING_CONVERSATION_ID, TMP_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES, TMP_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES, TMP_MESSAGING_OPERATION, TMP_MESSAGING_CONSUMER_ID, TMP_MESSAGING_RABBITMQ_ROUTING_KEY, TMP_MESSAGING_KAFKA_MESSAGE_KEY, TMP_MESSAGING_KAFKA_CONSUMER_GROUP, TMP_MESSAGING_KAFKA_CLIENT_ID, TMP_MESSAGING_KAFKA_PARTITION, TMP_MESSAGING_KAFKA_TOMBSTONE, TMP_RPC_SYSTEM, TMP_RPC_SERVICE, TMP_RPC_METHOD, TMP_RPC_GRPC_STATUS_CODE, TMP_RPC_JSONRPC_VERSION, TMP_RPC_JSONRPC_REQUEST_ID, TMP_RPC_JSONRPC_ERROR_CODE, TMP_RPC_JSONRPC_ERROR_MESSAGE, TMP_MESSAGE_TYPE, TMP_MESSAGE_ID, TMP_MESSAGE_COMPRESSED_SIZE, TMP_MESSAGE_UNCOMPRESSED_SIZE, SEMATTRS_AWS_LAMBDA_INVOKED_ARN, SEMATTRS_DB_SYSTEM, SEMATTRS_DB_CONNECTION_STRING, SEMATTRS_DB_USER, SEMATTRS_DB_JDBC_DRIVER_CLASSNAME, SEMATTRS_DB_NAME, SEMATTRS_DB_STATEMENT, SEMATTRS_DB_OPERATION, SEMATTRS_DB_MSSQL_INSTANCE_NAME, SEMATTRS_DB_CASSANDRA_KEYSPACE, SEMATTRS_DB_CASSANDRA_PAGE_SIZE, SEMATTRS_DB_CASSANDRA_CONSISTENCY_LEVEL, SEMATTRS_DB_CASSANDRA_TABLE, SEMATTRS_DB_CASSANDRA_IDEMPOTENCE, SEMATTRS_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT, SEMATTRS_DB_CASSANDRA_COORDINATOR_ID, SEMATTRS_DB_CASSANDRA_COORDINATOR_DC, SEMATTRS_DB_HBASE_NAMESPACE, SEMATTRS_DB_REDIS_DATABASE_INDEX, SEMATTRS_DB_MONGODB_COLLECTION, SEMATTRS_DB_SQL_TABLE, SEMATTRS_EXCEPTION_TYPE, SEMATTRS_EXCEPTION_MESSAGE, SEMATTRS_EXCEPTION_STACKTRACE, SEMATTRS_EXCEPTION_ESCAPED, SEMATTRS_FAAS_TRIGGER, SEMATTRS_FAAS_EXECUTION, SEMATTRS_FAAS_DOCUMENT_COLLECTION, SEMATTRS_FAAS_DOCUMENT_OPERATION, SEMATTRS_FAAS_DOCUMENT_TIME, SEMATTRS_FAAS_DOCUMENT_NAME, SEMATTRS_FAAS_TIME, SEMATTRS_FAAS_CRON, SEMATTRS_FAAS_COLDSTART, SEMATTRS_FAAS_INVOKED_NAME, SEMATTRS_FAAS_INVOKED_PROVIDER, SEMATTRS_FAAS_INVOKED_REGION, SEMATTRS_NET_TRANSPORT, SEMATTRS_NET_PEER_IP, SEMATTRS_NET_PEER_PORT, SEMATTRS_NET_PEER_NAME, SEMATTRS_NET_HOST_IP, SEMATTRS_NET_HOST_PORT, SEMATTRS_NET_HOST_NAME, SEMATTRS_NET_HOST_CONNECTION_TYPE, SEMATTRS_NET_HOST_CONNECTION_SUBTYPE, SEMATTRS_NET_HOST_CARRIER_NAME, SEMATTRS_NET_HOST_CARRIER_MCC, SEMATTRS_NET_HOST_CARRIER_MNC, SEMATTRS_NET_HOST_CARRIER_ICC, SEMATTRS_PEER_SERVICE, SEMATTRS_ENDUSER_ID, SEMATTRS_ENDUSER_ROLE, SEMATTRS_ENDUSER_SCOPE, SEMATTRS_THREAD_ID, SEMATTRS_THREAD_NAME, SEMATTRS_CODE_FUNCTION, SEMATTRS_CODE_NAMESPACE, SEMATTRS_CODE_FILEPATH, SEMATTRS_CODE_LINENO, SEMATTRS_HTTP_METHOD, SEMATTRS_HTTP_URL, SEMATTRS_HTTP_TARGET, SEMATTRS_HTTP_HOST, SEMATTRS_HTTP_SCHEME, SEMATTRS_HTTP_STATUS_CODE, SEMATTRS_HTTP_FLAVOR, SEMATTRS_HTTP_USER_AGENT, SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH, SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED, SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH, SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED, SEMATTRS_HTTP_SERVER_NAME, SEMATTRS_HTTP_ROUTE, SEMATTRS_HTTP_CLIENT_IP, SEMATTRS_AWS_DYNAMODB_TABLE_NAMES, SEMATTRS_AWS_DYNAMODB_CONSUMED_CAPACITY, SEMATTRS_AWS_DYNAMODB_ITEM_COLLECTION_METRICS, SEMATTRS_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY, SEMATTRS_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY, SEMATTRS_AWS_DYNAMODB_CONSISTENT_READ, SEMATTRS_AWS_DYNAMODB_PROJECTION, SEMATTRS_AWS_DYNAMODB_LIMIT, SEMATTRS_AWS_DYNAMODB_ATTRIBUTES_TO_GET, SEMATTRS_AWS_DYNAMODB_INDEX_NAME, SEMATTRS_AWS_DYNAMODB_SELECT, SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES, SEMATTRS_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES, SEMATTRS_AWS_DYNAMODB_EXCLUSIVE_START_TABLE, SEMATTRS_AWS_DYNAMODB_TABLE_COUNT, SEMATTRS_AWS_DYNAMODB_SCAN_FORWARD, SEMATTRS_AWS_DYNAMODB_SEGMENT, SEMATTRS_AWS_DYNAMODB_TOTAL_SEGMENTS, SEMATTRS_AWS_DYNAMODB_COUNT, SEMATTRS_AWS_DYNAMODB_SCANNED_COUNT, SEMATTRS_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS, SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES, SEMATTRS_MESSAGING_SYSTEM, SEMATTRS_MESSAGING_DESTINATION, SEMATTRS_MESSAGING_DESTINATION_KIND, SEMATTRS_MESSAGING_TEMP_DESTINATION, SEMATTRS_MESSAGING_PROTOCOL, SEMATTRS_MESSAGING_PROTOCOL_VERSION, SEMATTRS_MESSAGING_URL, SEMATTRS_MESSAGING_MESSAGE_ID, SEMATTRS_MESSAGING_CONVERSATION_ID, SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES, SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES, SEMATTRS_MESSAGING_OPERATION, SEMATTRS_MESSAGING_CONSUMER_ID, SEMATTRS_MESSAGING_RABBITMQ_ROUTING_KEY, SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY, SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP, SEMATTRS_MESSAGING_KAFKA_CLIENT_ID, SEMATTRS_MESSAGING_KAFKA_PARTITION, SEMATTRS_MESSAGING_KAFKA_TOMBSTONE, SEMATTRS_RPC_SYSTEM, SEMATTRS_RPC_SERVICE, SEMATTRS_RPC_METHOD, SEMATTRS_RPC_GRPC_STATUS_CODE, SEMATTRS_RPC_JSONRPC_VERSION, SEMATTRS_RPC_JSONRPC_REQUEST_ID, SEMATTRS_RPC_JSONRPC_ERROR_CODE, SEMATTRS_RPC_JSONRPC_ERROR_MESSAGE, SEMATTRS_MESSAGE_TYPE, SEMATTRS_MESSAGE_ID, SEMATTRS_MESSAGE_COMPRESSED_SIZE, SEMATTRS_MESSAGE_UNCOMPRESSED_SIZE, SemanticAttributes, TMP_DBSYSTEMVALUES_OTHER_SQL, TMP_DBSYSTEMVALUES_MSSQL, TMP_DBSYSTEMVALUES_MYSQL, TMP_DBSYSTEMVALUES_ORACLE, TMP_DBSYSTEMVALUES_DB2, TMP_DBSYSTEMVALUES_POSTGRESQL, TMP_DBSYSTEMVALUES_REDSHIFT, TMP_DBSYSTEMVALUES_HIVE, TMP_DBSYSTEMVALUES_CLOUDSCAPE, TMP_DBSYSTEMVALUES_HSQLDB, TMP_DBSYSTEMVALUES_PROGRESS, TMP_DBSYSTEMVALUES_MAXDB, TMP_DBSYSTEMVALUES_HANADB, TMP_DBSYSTEMVALUES_INGRES, TMP_DBSYSTEMVALUES_FIRSTSQL, TMP_DBSYSTEMVALUES_EDB, TMP_DBSYSTEMVALUES_CACHE, TMP_DBSYSTEMVALUES_ADABAS, TMP_DBSYSTEMVALUES_FIREBIRD, TMP_DBSYSTEMVALUES_DERBY, TMP_DBSYSTEMVALUES_FILEMAKER, TMP_DBSYSTEMVALUES_INFORMIX, TMP_DBSYSTEMVALUES_INSTANTDB, TMP_DBSYSTEMVALUES_INTERBASE, TMP_DBSYSTEMVALUES_MARIADB, TMP_DBSYSTEMVALUES_NETEZZA, TMP_DBSYSTEMVALUES_PERVASIVE, TMP_DBSYSTEMVALUES_POINTBASE, TMP_DBSYSTEMVALUES_SQLITE, TMP_DBSYSTEMVALUES_SYBASE, TMP_DBSYSTEMVALUES_TERADATA, TMP_DBSYSTEMVALUES_VERTICA, TMP_DBSYSTEMVALUES_H2, TMP_DBSYSTEMVALUES_COLDFUSION, TMP_DBSYSTEMVALUES_CASSANDRA, TMP_DBSYSTEMVALUES_HBASE, TMP_DBSYSTEMVALUES_MONGODB, TMP_DBSYSTEMVALUES_REDIS, TMP_DBSYSTEMVALUES_COUCHBASE, TMP_DBSYSTEMVALUES_COUCHDB, TMP_DBSYSTEMVALUES_COSMOSDB, TMP_DBSYSTEMVALUES_DYNAMODB, TMP_DBSYSTEMVALUES_NEO4J, TMP_DBSYSTEMVALUES_GEODE, TMP_DBSYSTEMVALUES_ELASTICSEARCH, TMP_DBSYSTEMVALUES_MEMCACHED, TMP_DBSYSTEMVALUES_COCKROACHDB, DBSYSTEMVALUES_OTHER_SQL, DBSYSTEMVALUES_MSSQL, DBSYSTEMVALUES_MYSQL, DBSYSTEMVALUES_ORACLE, DBSYSTEMVALUES_DB2, DBSYSTEMVALUES_POSTGRESQL, DBSYSTEMVALUES_REDSHIFT, DBSYSTEMVALUES_HIVE, DBSYSTEMVALUES_CLOUDSCAPE, DBSYSTEMVALUES_HSQLDB, DBSYSTEMVALUES_PROGRESS, DBSYSTEMVALUES_MAXDB, DBSYSTEMVALUES_HANADB, DBSYSTEMVALUES_INGRES, DBSYSTEMVALUES_FIRSTSQL, DBSYSTEMVALUES_EDB, DBSYSTEMVALUES_CACHE, DBSYSTEMVALUES_ADABAS, DBSYSTEMVALUES_FIREBIRD, DBSYSTEMVALUES_DERBY, DBSYSTEMVALUES_FILEMAKER, DBSYSTEMVALUES_INFORMIX, DBSYSTEMVALUES_INSTANTDB, DBSYSTEMVALUES_INTERBASE, DBSYSTEMVALUES_MARIADB, DBSYSTEMVALUES_NETEZZA, DBSYSTEMVALUES_PERVASIVE, DBSYSTEMVALUES_POINTBASE, DBSYSTEMVALUES_SQLITE, DBSYSTEMVALUES_SYBASE, DBSYSTEMVALUES_TERADATA, DBSYSTEMVALUES_VERTICA, DBSYSTEMVALUES_H2, DBSYSTEMVALUES_COLDFUSION, DBSYSTEMVALUES_CASSANDRA, DBSYSTEMVALUES_HBASE, DBSYSTEMVALUES_MONGODB, DBSYSTEMVALUES_REDIS, DBSYSTEMVALUES_COUCHBASE, DBSYSTEMVALUES_COUCHDB, DBSYSTEMVALUES_COSMOSDB, DBSYSTEMVALUES_DYNAMODB, DBSYSTEMVALUES_NEO4J, DBSYSTEMVALUES_GEODE, DBSYSTEMVALUES_ELASTICSEARCH, DBSYSTEMVALUES_MEMCACHED, DBSYSTEMVALUES_COCKROACHDB, DbSystemValues, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ALL, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ONE, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_TWO, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_THREE, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ANY, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL, TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL, DBCASSANDRACONSISTENCYLEVELVALUES_ALL, DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM, DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM, DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM, DBCASSANDRACONSISTENCYLEVELVALUES_ONE, DBCASSANDRACONSISTENCYLEVELVALUES_TWO, DBCASSANDRACONSISTENCYLEVELVALUES_THREE, DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE, DBCASSANDRACONSISTENCYLEVELVALUES_ANY, DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL, DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL, DbCassandraConsistencyLevelValues, TMP_FAASTRIGGERVALUES_DATASOURCE, TMP_FAASTRIGGERVALUES_HTTP, TMP_FAASTRIGGERVALUES_PUBSUB, TMP_FAASTRIGGERVALUES_TIMER, TMP_FAASTRIGGERVALUES_OTHER, FAASTRIGGERVALUES_DATASOURCE, FAASTRIGGERVALUES_HTTP, FAASTRIGGERVALUES_PUBSUB, FAASTRIGGERVALUES_TIMER, FAASTRIGGERVALUES_OTHER, FaasTriggerValues, TMP_FAASDOCUMENTOPERATIONVALUES_INSERT, TMP_FAASDOCUMENTOPERATIONVALUES_EDIT, TMP_FAASDOCUMENTOPERATIONVALUES_DELETE, FAASDOCUMENTOPERATIONVALUES_INSERT, FAASDOCUMENTOPERATIONVALUES_EDIT, FAASDOCUMENTOPERATIONVALUES_DELETE, FaasDocumentOperationValues, TMP_FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD, TMP_FAASINVOKEDPROVIDERVALUES_AWS, TMP_FAASINVOKEDPROVIDERVALUES_AZURE, TMP_FAASINVOKEDPROVIDERVALUES_GCP, FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD, FAASINVOKEDPROVIDERVALUES_AWS, FAASINVOKEDPROVIDERVALUES_AZURE, FAASINVOKEDPROVIDERVALUES_GCP, FaasInvokedProviderValues, TMP_NETTRANSPORTVALUES_IP_TCP, TMP_NETTRANSPORTVALUES_IP_UDP, TMP_NETTRANSPORTVALUES_IP, TMP_NETTRANSPORTVALUES_UNIX, TMP_NETTRANSPORTVALUES_PIPE, TMP_NETTRANSPORTVALUES_INPROC, TMP_NETTRANSPORTVALUES_OTHER, NETTRANSPORTVALUES_IP_TCP, NETTRANSPORTVALUES_IP_UDP, NETTRANSPORTVALUES_IP, NETTRANSPORTVALUES_UNIX, NETTRANSPORTVALUES_PIPE, NETTRANSPORTVALUES_INPROC, NETTRANSPORTVALUES_OTHER, NetTransportValues, TMP_NETHOSTCONNECTIONTYPEVALUES_WIFI, TMP_NETHOSTCONNECTIONTYPEVALUES_WIRED, TMP_NETHOSTCONNECTIONTYPEVALUES_CELL, TMP_NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE, TMP_NETHOSTCONNECTIONTYPEVALUES_UNKNOWN, NETHOSTCONNECTIONTYPEVALUES_WIFI, NETHOSTCONNECTIONTYPEVALUES_WIRED, NETHOSTCONNECTIONTYPEVALUES_CELL, NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE, NETHOSTCONNECTIONTYPEVALUES_UNKNOWN, NetHostConnectionTypeValues, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GPRS, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EDGE, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_UMTS, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPA, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IDEN, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GSM, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NR, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA, TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA, NETHOSTCONNECTIONSUBTYPEVALUES_GPRS, NETHOSTCONNECTIONSUBTYPEVALUES_EDGE, NETHOSTCONNECTIONSUBTYPEVALUES_UMTS, NETHOSTCONNECTIONSUBTYPEVALUES_CDMA, NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0, NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A, NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT, NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA, NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA, NETHOSTCONNECTIONSUBTYPEVALUES_HSPA, NETHOSTCONNECTIONSUBTYPEVALUES_IDEN, NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B, NETHOSTCONNECTIONSUBTYPEVALUES_LTE, NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD, NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP, NETHOSTCONNECTIONSUBTYPEVALUES_GSM, NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA, NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN, NETHOSTCONNECTIONSUBTYPEVALUES_NR, NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA, NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA, NetHostConnectionSubtypeValues, TMP_HTTPFLAVORVALUES_HTTP_1_0, TMP_HTTPFLAVORVALUES_HTTP_1_1, TMP_HTTPFLAVORVALUES_HTTP_2_0, TMP_HTTPFLAVORVALUES_SPDY, TMP_HTTPFLAVORVALUES_QUIC, HTTPFLAVORVALUES_HTTP_1_0, HTTPFLAVORVALUES_HTTP_1_1, HTTPFLAVORVALUES_HTTP_2_0, HTTPFLAVORVALUES_SPDY, HTTPFLAVORVALUES_QUIC, HttpFlavorValues, TMP_MESSAGINGDESTINATIONKINDVALUES_QUEUE, TMP_MESSAGINGDESTINATIONKINDVALUES_TOPIC, MESSAGINGDESTINATIONKINDVALUES_QUEUE, MESSAGINGDESTINATIONKINDVALUES_TOPIC, MessagingDestinationKindValues, TMP_MESSAGINGOPERATIONVALUES_RECEIVE, TMP_MESSAGINGOPERATIONVALUES_PROCESS, MESSAGINGOPERATIONVALUES_RECEIVE, MESSAGINGOPERATIONVALUES_PROCESS, MessagingOperationValues, TMP_RPCGRPCSTATUSCODEVALUES_OK, TMP_RPCGRPCSTATUSCODEVALUES_CANCELLED, TMP_RPCGRPCSTATUSCODEVALUES_UNKNOWN, TMP_RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT, TMP_RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED, TMP_RPCGRPCSTATUSCODEVALUES_NOT_FOUND, TMP_RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS, TMP_RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED, TMP_RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED, TMP_RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION, TMP_RPCGRPCSTATUSCODEVALUES_ABORTED, TMP_RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE, TMP_RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED, TMP_RPCGRPCSTATUSCODEVALUES_INTERNAL, TMP_RPCGRPCSTATUSCODEVALUES_UNAVAILABLE, TMP_RPCGRPCSTATUSCODEVALUES_DATA_LOSS, TMP_RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED, RPCGRPCSTATUSCODEVALUES_OK, RPCGRPCSTATUSCODEVALUES_CANCELLED, RPCGRPCSTATUSCODEVALUES_UNKNOWN, RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT, RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED, RPCGRPCSTATUSCODEVALUES_NOT_FOUND, RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS, RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED, RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED, RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION, RPCGRPCSTATUSCODEVALUES_ABORTED, RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE, RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED, RPCGRPCSTATUSCODEVALUES_INTERNAL, RPCGRPCSTATUSCODEVALUES_UNAVAILABLE, RPCGRPCSTATUSCODEVALUES_DATA_LOSS, RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED, RpcGrpcStatusCodeValues, TMP_MESSAGETYPEVALUES_SENT, TMP_MESSAGETYPEVALUES_RECEIVED, MESSAGETYPEVALUES_SENT, MESSAGETYPEVALUES_RECEIVED, MessageTypeValues; +var init_SemanticAttributes = __esm({ + "node_modules/@opentelemetry/semantic-conventions/build/esm/trace/SemanticAttributes.js"() { + init_utils3(); + TMP_AWS_LAMBDA_INVOKED_ARN = "aws.lambda.invoked_arn"; + TMP_DB_SYSTEM = "db.system"; + TMP_DB_CONNECTION_STRING = "db.connection_string"; + TMP_DB_USER = "db.user"; + TMP_DB_JDBC_DRIVER_CLASSNAME = "db.jdbc.driver_classname"; + TMP_DB_NAME = "db.name"; + TMP_DB_STATEMENT = "db.statement"; + TMP_DB_OPERATION = "db.operation"; + TMP_DB_MSSQL_INSTANCE_NAME = "db.mssql.instance_name"; + TMP_DB_CASSANDRA_KEYSPACE = "db.cassandra.keyspace"; + TMP_DB_CASSANDRA_PAGE_SIZE = "db.cassandra.page_size"; + TMP_DB_CASSANDRA_CONSISTENCY_LEVEL = "db.cassandra.consistency_level"; + TMP_DB_CASSANDRA_TABLE = "db.cassandra.table"; + TMP_DB_CASSANDRA_IDEMPOTENCE = "db.cassandra.idempotence"; + TMP_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT = "db.cassandra.speculative_execution_count"; + TMP_DB_CASSANDRA_COORDINATOR_ID = "db.cassandra.coordinator.id"; + TMP_DB_CASSANDRA_COORDINATOR_DC = "db.cassandra.coordinator.dc"; + TMP_DB_HBASE_NAMESPACE = "db.hbase.namespace"; + TMP_DB_REDIS_DATABASE_INDEX = "db.redis.database_index"; + TMP_DB_MONGODB_COLLECTION = "db.mongodb.collection"; + TMP_DB_SQL_TABLE = "db.sql.table"; + TMP_EXCEPTION_TYPE = "exception.type"; + TMP_EXCEPTION_MESSAGE = "exception.message"; + TMP_EXCEPTION_STACKTRACE = "exception.stacktrace"; + TMP_EXCEPTION_ESCAPED = "exception.escaped"; + TMP_FAAS_TRIGGER = "faas.trigger"; + TMP_FAAS_EXECUTION = "faas.execution"; + TMP_FAAS_DOCUMENT_COLLECTION = "faas.document.collection"; + TMP_FAAS_DOCUMENT_OPERATION = "faas.document.operation"; + TMP_FAAS_DOCUMENT_TIME = "faas.document.time"; + TMP_FAAS_DOCUMENT_NAME = "faas.document.name"; + TMP_FAAS_TIME = "faas.time"; + TMP_FAAS_CRON = "faas.cron"; + TMP_FAAS_COLDSTART = "faas.coldstart"; + TMP_FAAS_INVOKED_NAME = "faas.invoked_name"; + TMP_FAAS_INVOKED_PROVIDER = "faas.invoked_provider"; + TMP_FAAS_INVOKED_REGION = "faas.invoked_region"; + TMP_NET_TRANSPORT = "net.transport"; + TMP_NET_PEER_IP = "net.peer.ip"; + TMP_NET_PEER_PORT = "net.peer.port"; + TMP_NET_PEER_NAME = "net.peer.name"; + TMP_NET_HOST_IP = "net.host.ip"; + TMP_NET_HOST_PORT = "net.host.port"; + TMP_NET_HOST_NAME = "net.host.name"; + TMP_NET_HOST_CONNECTION_TYPE = "net.host.connection.type"; + TMP_NET_HOST_CONNECTION_SUBTYPE = "net.host.connection.subtype"; + TMP_NET_HOST_CARRIER_NAME = "net.host.carrier.name"; + TMP_NET_HOST_CARRIER_MCC = "net.host.carrier.mcc"; + TMP_NET_HOST_CARRIER_MNC = "net.host.carrier.mnc"; + TMP_NET_HOST_CARRIER_ICC = "net.host.carrier.icc"; + TMP_PEER_SERVICE = "peer.service"; + TMP_ENDUSER_ID = "enduser.id"; + TMP_ENDUSER_ROLE = "enduser.role"; + TMP_ENDUSER_SCOPE = "enduser.scope"; + TMP_THREAD_ID = "thread.id"; + TMP_THREAD_NAME = "thread.name"; + TMP_CODE_FUNCTION = "code.function"; + TMP_CODE_NAMESPACE = "code.namespace"; + TMP_CODE_FILEPATH = "code.filepath"; + TMP_CODE_LINENO = "code.lineno"; + TMP_HTTP_METHOD = "http.method"; + TMP_HTTP_URL = "http.url"; + TMP_HTTP_TARGET = "http.target"; + TMP_HTTP_HOST = "http.host"; + TMP_HTTP_SCHEME = "http.scheme"; + TMP_HTTP_STATUS_CODE = "http.status_code"; + TMP_HTTP_FLAVOR = "http.flavor"; + TMP_HTTP_USER_AGENT = "http.user_agent"; + TMP_HTTP_REQUEST_CONTENT_LENGTH = "http.request_content_length"; + TMP_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED = "http.request_content_length_uncompressed"; + TMP_HTTP_RESPONSE_CONTENT_LENGTH = "http.response_content_length"; + TMP_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED = "http.response_content_length_uncompressed"; + TMP_HTTP_SERVER_NAME = "http.server_name"; + TMP_HTTP_ROUTE = "http.route"; + TMP_HTTP_CLIENT_IP = "http.client_ip"; + TMP_AWS_DYNAMODB_TABLE_NAMES = "aws.dynamodb.table_names"; + TMP_AWS_DYNAMODB_CONSUMED_CAPACITY = "aws.dynamodb.consumed_capacity"; + TMP_AWS_DYNAMODB_ITEM_COLLECTION_METRICS = "aws.dynamodb.item_collection_metrics"; + TMP_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY = "aws.dynamodb.provisioned_read_capacity"; + TMP_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY = "aws.dynamodb.provisioned_write_capacity"; + TMP_AWS_DYNAMODB_CONSISTENT_READ = "aws.dynamodb.consistent_read"; + TMP_AWS_DYNAMODB_PROJECTION = "aws.dynamodb.projection"; + TMP_AWS_DYNAMODB_LIMIT = "aws.dynamodb.limit"; + TMP_AWS_DYNAMODB_ATTRIBUTES_TO_GET = "aws.dynamodb.attributes_to_get"; + TMP_AWS_DYNAMODB_INDEX_NAME = "aws.dynamodb.index_name"; + TMP_AWS_DYNAMODB_SELECT = "aws.dynamodb.select"; + TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES = "aws.dynamodb.global_secondary_indexes"; + TMP_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES = "aws.dynamodb.local_secondary_indexes"; + TMP_AWS_DYNAMODB_EXCLUSIVE_START_TABLE = "aws.dynamodb.exclusive_start_table"; + TMP_AWS_DYNAMODB_TABLE_COUNT = "aws.dynamodb.table_count"; + TMP_AWS_DYNAMODB_SCAN_FORWARD = "aws.dynamodb.scan_forward"; + TMP_AWS_DYNAMODB_SEGMENT = "aws.dynamodb.segment"; + TMP_AWS_DYNAMODB_TOTAL_SEGMENTS = "aws.dynamodb.total_segments"; + TMP_AWS_DYNAMODB_COUNT = "aws.dynamodb.count"; + TMP_AWS_DYNAMODB_SCANNED_COUNT = "aws.dynamodb.scanned_count"; + TMP_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS = "aws.dynamodb.attribute_definitions"; + TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES = "aws.dynamodb.global_secondary_index_updates"; + TMP_MESSAGING_SYSTEM = "messaging.system"; + TMP_MESSAGING_DESTINATION = "messaging.destination"; + TMP_MESSAGING_DESTINATION_KIND = "messaging.destination_kind"; + TMP_MESSAGING_TEMP_DESTINATION = "messaging.temp_destination"; + TMP_MESSAGING_PROTOCOL = "messaging.protocol"; + TMP_MESSAGING_PROTOCOL_VERSION = "messaging.protocol_version"; + TMP_MESSAGING_URL = "messaging.url"; + TMP_MESSAGING_MESSAGE_ID = "messaging.message_id"; + TMP_MESSAGING_CONVERSATION_ID = "messaging.conversation_id"; + TMP_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES = "messaging.message_payload_size_bytes"; + TMP_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES = "messaging.message_payload_compressed_size_bytes"; + TMP_MESSAGING_OPERATION = "messaging.operation"; + TMP_MESSAGING_CONSUMER_ID = "messaging.consumer_id"; + TMP_MESSAGING_RABBITMQ_ROUTING_KEY = "messaging.rabbitmq.routing_key"; + TMP_MESSAGING_KAFKA_MESSAGE_KEY = "messaging.kafka.message_key"; + TMP_MESSAGING_KAFKA_CONSUMER_GROUP = "messaging.kafka.consumer_group"; + TMP_MESSAGING_KAFKA_CLIENT_ID = "messaging.kafka.client_id"; + TMP_MESSAGING_KAFKA_PARTITION = "messaging.kafka.partition"; + TMP_MESSAGING_KAFKA_TOMBSTONE = "messaging.kafka.tombstone"; + TMP_RPC_SYSTEM = "rpc.system"; + TMP_RPC_SERVICE = "rpc.service"; + TMP_RPC_METHOD = "rpc.method"; + TMP_RPC_GRPC_STATUS_CODE = "rpc.grpc.status_code"; + TMP_RPC_JSONRPC_VERSION = "rpc.jsonrpc.version"; + TMP_RPC_JSONRPC_REQUEST_ID = "rpc.jsonrpc.request_id"; + TMP_RPC_JSONRPC_ERROR_CODE = "rpc.jsonrpc.error_code"; + TMP_RPC_JSONRPC_ERROR_MESSAGE = "rpc.jsonrpc.error_message"; + TMP_MESSAGE_TYPE = "message.type"; + TMP_MESSAGE_ID = "message.id"; + TMP_MESSAGE_COMPRESSED_SIZE = "message.compressed_size"; + TMP_MESSAGE_UNCOMPRESSED_SIZE = "message.uncompressed_size"; + SEMATTRS_AWS_LAMBDA_INVOKED_ARN = TMP_AWS_LAMBDA_INVOKED_ARN; + SEMATTRS_DB_SYSTEM = TMP_DB_SYSTEM; + SEMATTRS_DB_CONNECTION_STRING = TMP_DB_CONNECTION_STRING; + SEMATTRS_DB_USER = TMP_DB_USER; + SEMATTRS_DB_JDBC_DRIVER_CLASSNAME = TMP_DB_JDBC_DRIVER_CLASSNAME; + SEMATTRS_DB_NAME = TMP_DB_NAME; + SEMATTRS_DB_STATEMENT = TMP_DB_STATEMENT; + SEMATTRS_DB_OPERATION = TMP_DB_OPERATION; + SEMATTRS_DB_MSSQL_INSTANCE_NAME = TMP_DB_MSSQL_INSTANCE_NAME; + SEMATTRS_DB_CASSANDRA_KEYSPACE = TMP_DB_CASSANDRA_KEYSPACE; + SEMATTRS_DB_CASSANDRA_PAGE_SIZE = TMP_DB_CASSANDRA_PAGE_SIZE; + SEMATTRS_DB_CASSANDRA_CONSISTENCY_LEVEL = TMP_DB_CASSANDRA_CONSISTENCY_LEVEL; + SEMATTRS_DB_CASSANDRA_TABLE = TMP_DB_CASSANDRA_TABLE; + SEMATTRS_DB_CASSANDRA_IDEMPOTENCE = TMP_DB_CASSANDRA_IDEMPOTENCE; + SEMATTRS_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT = TMP_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT; + SEMATTRS_DB_CASSANDRA_COORDINATOR_ID = TMP_DB_CASSANDRA_COORDINATOR_ID; + SEMATTRS_DB_CASSANDRA_COORDINATOR_DC = TMP_DB_CASSANDRA_COORDINATOR_DC; + SEMATTRS_DB_HBASE_NAMESPACE = TMP_DB_HBASE_NAMESPACE; + SEMATTRS_DB_REDIS_DATABASE_INDEX = TMP_DB_REDIS_DATABASE_INDEX; + SEMATTRS_DB_MONGODB_COLLECTION = TMP_DB_MONGODB_COLLECTION; + SEMATTRS_DB_SQL_TABLE = TMP_DB_SQL_TABLE; + SEMATTRS_EXCEPTION_TYPE = TMP_EXCEPTION_TYPE; + SEMATTRS_EXCEPTION_MESSAGE = TMP_EXCEPTION_MESSAGE; + SEMATTRS_EXCEPTION_STACKTRACE = TMP_EXCEPTION_STACKTRACE; + SEMATTRS_EXCEPTION_ESCAPED = TMP_EXCEPTION_ESCAPED; + SEMATTRS_FAAS_TRIGGER = TMP_FAAS_TRIGGER; + SEMATTRS_FAAS_EXECUTION = TMP_FAAS_EXECUTION; + SEMATTRS_FAAS_DOCUMENT_COLLECTION = TMP_FAAS_DOCUMENT_COLLECTION; + SEMATTRS_FAAS_DOCUMENT_OPERATION = TMP_FAAS_DOCUMENT_OPERATION; + SEMATTRS_FAAS_DOCUMENT_TIME = TMP_FAAS_DOCUMENT_TIME; + SEMATTRS_FAAS_DOCUMENT_NAME = TMP_FAAS_DOCUMENT_NAME; + SEMATTRS_FAAS_TIME = TMP_FAAS_TIME; + SEMATTRS_FAAS_CRON = TMP_FAAS_CRON; + SEMATTRS_FAAS_COLDSTART = TMP_FAAS_COLDSTART; + SEMATTRS_FAAS_INVOKED_NAME = TMP_FAAS_INVOKED_NAME; + SEMATTRS_FAAS_INVOKED_PROVIDER = TMP_FAAS_INVOKED_PROVIDER; + SEMATTRS_FAAS_INVOKED_REGION = TMP_FAAS_INVOKED_REGION; + SEMATTRS_NET_TRANSPORT = TMP_NET_TRANSPORT; + SEMATTRS_NET_PEER_IP = TMP_NET_PEER_IP; + SEMATTRS_NET_PEER_PORT = TMP_NET_PEER_PORT; + SEMATTRS_NET_PEER_NAME = TMP_NET_PEER_NAME; + SEMATTRS_NET_HOST_IP = TMP_NET_HOST_IP; + SEMATTRS_NET_HOST_PORT = TMP_NET_HOST_PORT; + SEMATTRS_NET_HOST_NAME = TMP_NET_HOST_NAME; + SEMATTRS_NET_HOST_CONNECTION_TYPE = TMP_NET_HOST_CONNECTION_TYPE; + SEMATTRS_NET_HOST_CONNECTION_SUBTYPE = TMP_NET_HOST_CONNECTION_SUBTYPE; + SEMATTRS_NET_HOST_CARRIER_NAME = TMP_NET_HOST_CARRIER_NAME; + SEMATTRS_NET_HOST_CARRIER_MCC = TMP_NET_HOST_CARRIER_MCC; + SEMATTRS_NET_HOST_CARRIER_MNC = TMP_NET_HOST_CARRIER_MNC; + SEMATTRS_NET_HOST_CARRIER_ICC = TMP_NET_HOST_CARRIER_ICC; + SEMATTRS_PEER_SERVICE = TMP_PEER_SERVICE; + SEMATTRS_ENDUSER_ID = TMP_ENDUSER_ID; + SEMATTRS_ENDUSER_ROLE = TMP_ENDUSER_ROLE; + SEMATTRS_ENDUSER_SCOPE = TMP_ENDUSER_SCOPE; + SEMATTRS_THREAD_ID = TMP_THREAD_ID; + SEMATTRS_THREAD_NAME = TMP_THREAD_NAME; + SEMATTRS_CODE_FUNCTION = TMP_CODE_FUNCTION; + SEMATTRS_CODE_NAMESPACE = TMP_CODE_NAMESPACE; + SEMATTRS_CODE_FILEPATH = TMP_CODE_FILEPATH; + SEMATTRS_CODE_LINENO = TMP_CODE_LINENO; + SEMATTRS_HTTP_METHOD = TMP_HTTP_METHOD; + SEMATTRS_HTTP_URL = TMP_HTTP_URL; + SEMATTRS_HTTP_TARGET = TMP_HTTP_TARGET; + SEMATTRS_HTTP_HOST = TMP_HTTP_HOST; + SEMATTRS_HTTP_SCHEME = TMP_HTTP_SCHEME; + SEMATTRS_HTTP_STATUS_CODE = TMP_HTTP_STATUS_CODE; + SEMATTRS_HTTP_FLAVOR = TMP_HTTP_FLAVOR; + SEMATTRS_HTTP_USER_AGENT = TMP_HTTP_USER_AGENT; + SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH = TMP_HTTP_REQUEST_CONTENT_LENGTH; + SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED = TMP_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED; + SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH = TMP_HTTP_RESPONSE_CONTENT_LENGTH; + SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED = TMP_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED; + SEMATTRS_HTTP_SERVER_NAME = TMP_HTTP_SERVER_NAME; + SEMATTRS_HTTP_ROUTE = TMP_HTTP_ROUTE; + SEMATTRS_HTTP_CLIENT_IP = TMP_HTTP_CLIENT_IP; + SEMATTRS_AWS_DYNAMODB_TABLE_NAMES = TMP_AWS_DYNAMODB_TABLE_NAMES; + SEMATTRS_AWS_DYNAMODB_CONSUMED_CAPACITY = TMP_AWS_DYNAMODB_CONSUMED_CAPACITY; + SEMATTRS_AWS_DYNAMODB_ITEM_COLLECTION_METRICS = TMP_AWS_DYNAMODB_ITEM_COLLECTION_METRICS; + SEMATTRS_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY = TMP_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY; + SEMATTRS_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY = TMP_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY; + SEMATTRS_AWS_DYNAMODB_CONSISTENT_READ = TMP_AWS_DYNAMODB_CONSISTENT_READ; + SEMATTRS_AWS_DYNAMODB_PROJECTION = TMP_AWS_DYNAMODB_PROJECTION; + SEMATTRS_AWS_DYNAMODB_LIMIT = TMP_AWS_DYNAMODB_LIMIT; + SEMATTRS_AWS_DYNAMODB_ATTRIBUTES_TO_GET = TMP_AWS_DYNAMODB_ATTRIBUTES_TO_GET; + SEMATTRS_AWS_DYNAMODB_INDEX_NAME = TMP_AWS_DYNAMODB_INDEX_NAME; + SEMATTRS_AWS_DYNAMODB_SELECT = TMP_AWS_DYNAMODB_SELECT; + SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES = TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES; + SEMATTRS_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES = TMP_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES; + SEMATTRS_AWS_DYNAMODB_EXCLUSIVE_START_TABLE = TMP_AWS_DYNAMODB_EXCLUSIVE_START_TABLE; + SEMATTRS_AWS_DYNAMODB_TABLE_COUNT = TMP_AWS_DYNAMODB_TABLE_COUNT; + SEMATTRS_AWS_DYNAMODB_SCAN_FORWARD = TMP_AWS_DYNAMODB_SCAN_FORWARD; + SEMATTRS_AWS_DYNAMODB_SEGMENT = TMP_AWS_DYNAMODB_SEGMENT; + SEMATTRS_AWS_DYNAMODB_TOTAL_SEGMENTS = TMP_AWS_DYNAMODB_TOTAL_SEGMENTS; + SEMATTRS_AWS_DYNAMODB_COUNT = TMP_AWS_DYNAMODB_COUNT; + SEMATTRS_AWS_DYNAMODB_SCANNED_COUNT = TMP_AWS_DYNAMODB_SCANNED_COUNT; + SEMATTRS_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS = TMP_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS; + SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES = TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES; + SEMATTRS_MESSAGING_SYSTEM = TMP_MESSAGING_SYSTEM; + SEMATTRS_MESSAGING_DESTINATION = TMP_MESSAGING_DESTINATION; + SEMATTRS_MESSAGING_DESTINATION_KIND = TMP_MESSAGING_DESTINATION_KIND; + SEMATTRS_MESSAGING_TEMP_DESTINATION = TMP_MESSAGING_TEMP_DESTINATION; + SEMATTRS_MESSAGING_PROTOCOL = TMP_MESSAGING_PROTOCOL; + SEMATTRS_MESSAGING_PROTOCOL_VERSION = TMP_MESSAGING_PROTOCOL_VERSION; + SEMATTRS_MESSAGING_URL = TMP_MESSAGING_URL; + SEMATTRS_MESSAGING_MESSAGE_ID = TMP_MESSAGING_MESSAGE_ID; + SEMATTRS_MESSAGING_CONVERSATION_ID = TMP_MESSAGING_CONVERSATION_ID; + SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES = TMP_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES; + SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES = TMP_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES; + SEMATTRS_MESSAGING_OPERATION = TMP_MESSAGING_OPERATION; + SEMATTRS_MESSAGING_CONSUMER_ID = TMP_MESSAGING_CONSUMER_ID; + SEMATTRS_MESSAGING_RABBITMQ_ROUTING_KEY = TMP_MESSAGING_RABBITMQ_ROUTING_KEY; + SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY = TMP_MESSAGING_KAFKA_MESSAGE_KEY; + SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP = TMP_MESSAGING_KAFKA_CONSUMER_GROUP; + SEMATTRS_MESSAGING_KAFKA_CLIENT_ID = TMP_MESSAGING_KAFKA_CLIENT_ID; + SEMATTRS_MESSAGING_KAFKA_PARTITION = TMP_MESSAGING_KAFKA_PARTITION; + SEMATTRS_MESSAGING_KAFKA_TOMBSTONE = TMP_MESSAGING_KAFKA_TOMBSTONE; + SEMATTRS_RPC_SYSTEM = TMP_RPC_SYSTEM; + SEMATTRS_RPC_SERVICE = TMP_RPC_SERVICE; + SEMATTRS_RPC_METHOD = TMP_RPC_METHOD; + SEMATTRS_RPC_GRPC_STATUS_CODE = TMP_RPC_GRPC_STATUS_CODE; + SEMATTRS_RPC_JSONRPC_VERSION = TMP_RPC_JSONRPC_VERSION; + SEMATTRS_RPC_JSONRPC_REQUEST_ID = TMP_RPC_JSONRPC_REQUEST_ID; + SEMATTRS_RPC_JSONRPC_ERROR_CODE = TMP_RPC_JSONRPC_ERROR_CODE; + SEMATTRS_RPC_JSONRPC_ERROR_MESSAGE = TMP_RPC_JSONRPC_ERROR_MESSAGE; + SEMATTRS_MESSAGE_TYPE = TMP_MESSAGE_TYPE; + SEMATTRS_MESSAGE_ID = TMP_MESSAGE_ID; + SEMATTRS_MESSAGE_COMPRESSED_SIZE = TMP_MESSAGE_COMPRESSED_SIZE; + SEMATTRS_MESSAGE_UNCOMPRESSED_SIZE = TMP_MESSAGE_UNCOMPRESSED_SIZE; + SemanticAttributes = /* @__PURE__ */ createConstMap([ + TMP_AWS_LAMBDA_INVOKED_ARN, + TMP_DB_SYSTEM, + TMP_DB_CONNECTION_STRING, + TMP_DB_USER, + TMP_DB_JDBC_DRIVER_CLASSNAME, + TMP_DB_NAME, + TMP_DB_STATEMENT, + TMP_DB_OPERATION, + TMP_DB_MSSQL_INSTANCE_NAME, + TMP_DB_CASSANDRA_KEYSPACE, + TMP_DB_CASSANDRA_PAGE_SIZE, + TMP_DB_CASSANDRA_CONSISTENCY_LEVEL, + TMP_DB_CASSANDRA_TABLE, + TMP_DB_CASSANDRA_IDEMPOTENCE, + TMP_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT, + TMP_DB_CASSANDRA_COORDINATOR_ID, + TMP_DB_CASSANDRA_COORDINATOR_DC, + TMP_DB_HBASE_NAMESPACE, + TMP_DB_REDIS_DATABASE_INDEX, + TMP_DB_MONGODB_COLLECTION, + TMP_DB_SQL_TABLE, + TMP_EXCEPTION_TYPE, + TMP_EXCEPTION_MESSAGE, + TMP_EXCEPTION_STACKTRACE, + TMP_EXCEPTION_ESCAPED, + TMP_FAAS_TRIGGER, + TMP_FAAS_EXECUTION, + TMP_FAAS_DOCUMENT_COLLECTION, + TMP_FAAS_DOCUMENT_OPERATION, + TMP_FAAS_DOCUMENT_TIME, + TMP_FAAS_DOCUMENT_NAME, + TMP_FAAS_TIME, + TMP_FAAS_CRON, + TMP_FAAS_COLDSTART, + TMP_FAAS_INVOKED_NAME, + TMP_FAAS_INVOKED_PROVIDER, + TMP_FAAS_INVOKED_REGION, + TMP_NET_TRANSPORT, + TMP_NET_PEER_IP, + TMP_NET_PEER_PORT, + TMP_NET_PEER_NAME, + TMP_NET_HOST_IP, + TMP_NET_HOST_PORT, + TMP_NET_HOST_NAME, + TMP_NET_HOST_CONNECTION_TYPE, + TMP_NET_HOST_CONNECTION_SUBTYPE, + TMP_NET_HOST_CARRIER_NAME, + TMP_NET_HOST_CARRIER_MCC, + TMP_NET_HOST_CARRIER_MNC, + TMP_NET_HOST_CARRIER_ICC, + TMP_PEER_SERVICE, + TMP_ENDUSER_ID, + TMP_ENDUSER_ROLE, + TMP_ENDUSER_SCOPE, + TMP_THREAD_ID, + TMP_THREAD_NAME, + TMP_CODE_FUNCTION, + TMP_CODE_NAMESPACE, + TMP_CODE_FILEPATH, + TMP_CODE_LINENO, + TMP_HTTP_METHOD, + TMP_HTTP_URL, + TMP_HTTP_TARGET, + TMP_HTTP_HOST, + TMP_HTTP_SCHEME, + TMP_HTTP_STATUS_CODE, + TMP_HTTP_FLAVOR, + TMP_HTTP_USER_AGENT, + TMP_HTTP_REQUEST_CONTENT_LENGTH, + TMP_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED, + TMP_HTTP_RESPONSE_CONTENT_LENGTH, + TMP_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED, + TMP_HTTP_SERVER_NAME, + TMP_HTTP_ROUTE, + TMP_HTTP_CLIENT_IP, + TMP_AWS_DYNAMODB_TABLE_NAMES, + TMP_AWS_DYNAMODB_CONSUMED_CAPACITY, + TMP_AWS_DYNAMODB_ITEM_COLLECTION_METRICS, + TMP_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY, + TMP_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY, + TMP_AWS_DYNAMODB_CONSISTENT_READ, + TMP_AWS_DYNAMODB_PROJECTION, + TMP_AWS_DYNAMODB_LIMIT, + TMP_AWS_DYNAMODB_ATTRIBUTES_TO_GET, + TMP_AWS_DYNAMODB_INDEX_NAME, + TMP_AWS_DYNAMODB_SELECT, + TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES, + TMP_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES, + TMP_AWS_DYNAMODB_EXCLUSIVE_START_TABLE, + TMP_AWS_DYNAMODB_TABLE_COUNT, + TMP_AWS_DYNAMODB_SCAN_FORWARD, + TMP_AWS_DYNAMODB_SEGMENT, + TMP_AWS_DYNAMODB_TOTAL_SEGMENTS, + TMP_AWS_DYNAMODB_COUNT, + TMP_AWS_DYNAMODB_SCANNED_COUNT, + TMP_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS, + TMP_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES, + TMP_MESSAGING_SYSTEM, + TMP_MESSAGING_DESTINATION, + TMP_MESSAGING_DESTINATION_KIND, + TMP_MESSAGING_TEMP_DESTINATION, + TMP_MESSAGING_PROTOCOL, + TMP_MESSAGING_PROTOCOL_VERSION, + TMP_MESSAGING_URL, + TMP_MESSAGING_MESSAGE_ID, + TMP_MESSAGING_CONVERSATION_ID, + TMP_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES, + TMP_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES, + TMP_MESSAGING_OPERATION, + TMP_MESSAGING_CONSUMER_ID, + TMP_MESSAGING_RABBITMQ_ROUTING_KEY, + TMP_MESSAGING_KAFKA_MESSAGE_KEY, + TMP_MESSAGING_KAFKA_CONSUMER_GROUP, + TMP_MESSAGING_KAFKA_CLIENT_ID, + TMP_MESSAGING_KAFKA_PARTITION, + TMP_MESSAGING_KAFKA_TOMBSTONE, + TMP_RPC_SYSTEM, + TMP_RPC_SERVICE, + TMP_RPC_METHOD, + TMP_RPC_GRPC_STATUS_CODE, + TMP_RPC_JSONRPC_VERSION, + TMP_RPC_JSONRPC_REQUEST_ID, + TMP_RPC_JSONRPC_ERROR_CODE, + TMP_RPC_JSONRPC_ERROR_MESSAGE, + TMP_MESSAGE_TYPE, + TMP_MESSAGE_ID, + TMP_MESSAGE_COMPRESSED_SIZE, + TMP_MESSAGE_UNCOMPRESSED_SIZE + ]); + TMP_DBSYSTEMVALUES_OTHER_SQL = "other_sql"; + TMP_DBSYSTEMVALUES_MSSQL = "mssql"; + TMP_DBSYSTEMVALUES_MYSQL = "mysql"; + TMP_DBSYSTEMVALUES_ORACLE = "oracle"; + TMP_DBSYSTEMVALUES_DB2 = "db2"; + TMP_DBSYSTEMVALUES_POSTGRESQL = "postgresql"; + TMP_DBSYSTEMVALUES_REDSHIFT = "redshift"; + TMP_DBSYSTEMVALUES_HIVE = "hive"; + TMP_DBSYSTEMVALUES_CLOUDSCAPE = "cloudscape"; + TMP_DBSYSTEMVALUES_HSQLDB = "hsqldb"; + TMP_DBSYSTEMVALUES_PROGRESS = "progress"; + TMP_DBSYSTEMVALUES_MAXDB = "maxdb"; + TMP_DBSYSTEMVALUES_HANADB = "hanadb"; + TMP_DBSYSTEMVALUES_INGRES = "ingres"; + TMP_DBSYSTEMVALUES_FIRSTSQL = "firstsql"; + TMP_DBSYSTEMVALUES_EDB = "edb"; + TMP_DBSYSTEMVALUES_CACHE = "cache"; + TMP_DBSYSTEMVALUES_ADABAS = "adabas"; + TMP_DBSYSTEMVALUES_FIREBIRD = "firebird"; + TMP_DBSYSTEMVALUES_DERBY = "derby"; + TMP_DBSYSTEMVALUES_FILEMAKER = "filemaker"; + TMP_DBSYSTEMVALUES_INFORMIX = "informix"; + TMP_DBSYSTEMVALUES_INSTANTDB = "instantdb"; + TMP_DBSYSTEMVALUES_INTERBASE = "interbase"; + TMP_DBSYSTEMVALUES_MARIADB = "mariadb"; + TMP_DBSYSTEMVALUES_NETEZZA = "netezza"; + TMP_DBSYSTEMVALUES_PERVASIVE = "pervasive"; + TMP_DBSYSTEMVALUES_POINTBASE = "pointbase"; + TMP_DBSYSTEMVALUES_SQLITE = "sqlite"; + TMP_DBSYSTEMVALUES_SYBASE = "sybase"; + TMP_DBSYSTEMVALUES_TERADATA = "teradata"; + TMP_DBSYSTEMVALUES_VERTICA = "vertica"; + TMP_DBSYSTEMVALUES_H2 = "h2"; + TMP_DBSYSTEMVALUES_COLDFUSION = "coldfusion"; + TMP_DBSYSTEMVALUES_CASSANDRA = "cassandra"; + TMP_DBSYSTEMVALUES_HBASE = "hbase"; + TMP_DBSYSTEMVALUES_MONGODB = "mongodb"; + TMP_DBSYSTEMVALUES_REDIS = "redis"; + TMP_DBSYSTEMVALUES_COUCHBASE = "couchbase"; + TMP_DBSYSTEMVALUES_COUCHDB = "couchdb"; + TMP_DBSYSTEMVALUES_COSMOSDB = "cosmosdb"; + TMP_DBSYSTEMVALUES_DYNAMODB = "dynamodb"; + TMP_DBSYSTEMVALUES_NEO4J = "neo4j"; + TMP_DBSYSTEMVALUES_GEODE = "geode"; + TMP_DBSYSTEMVALUES_ELASTICSEARCH = "elasticsearch"; + TMP_DBSYSTEMVALUES_MEMCACHED = "memcached"; + TMP_DBSYSTEMVALUES_COCKROACHDB = "cockroachdb"; + DBSYSTEMVALUES_OTHER_SQL = TMP_DBSYSTEMVALUES_OTHER_SQL; + DBSYSTEMVALUES_MSSQL = TMP_DBSYSTEMVALUES_MSSQL; + DBSYSTEMVALUES_MYSQL = TMP_DBSYSTEMVALUES_MYSQL; + DBSYSTEMVALUES_ORACLE = TMP_DBSYSTEMVALUES_ORACLE; + DBSYSTEMVALUES_DB2 = TMP_DBSYSTEMVALUES_DB2; + DBSYSTEMVALUES_POSTGRESQL = TMP_DBSYSTEMVALUES_POSTGRESQL; + DBSYSTEMVALUES_REDSHIFT = TMP_DBSYSTEMVALUES_REDSHIFT; + DBSYSTEMVALUES_HIVE = TMP_DBSYSTEMVALUES_HIVE; + DBSYSTEMVALUES_CLOUDSCAPE = TMP_DBSYSTEMVALUES_CLOUDSCAPE; + DBSYSTEMVALUES_HSQLDB = TMP_DBSYSTEMVALUES_HSQLDB; + DBSYSTEMVALUES_PROGRESS = TMP_DBSYSTEMVALUES_PROGRESS; + DBSYSTEMVALUES_MAXDB = TMP_DBSYSTEMVALUES_MAXDB; + DBSYSTEMVALUES_HANADB = TMP_DBSYSTEMVALUES_HANADB; + DBSYSTEMVALUES_INGRES = TMP_DBSYSTEMVALUES_INGRES; + DBSYSTEMVALUES_FIRSTSQL = TMP_DBSYSTEMVALUES_FIRSTSQL; + DBSYSTEMVALUES_EDB = TMP_DBSYSTEMVALUES_EDB; + DBSYSTEMVALUES_CACHE = TMP_DBSYSTEMVALUES_CACHE; + DBSYSTEMVALUES_ADABAS = TMP_DBSYSTEMVALUES_ADABAS; + DBSYSTEMVALUES_FIREBIRD = TMP_DBSYSTEMVALUES_FIREBIRD; + DBSYSTEMVALUES_DERBY = TMP_DBSYSTEMVALUES_DERBY; + DBSYSTEMVALUES_FILEMAKER = TMP_DBSYSTEMVALUES_FILEMAKER; + DBSYSTEMVALUES_INFORMIX = TMP_DBSYSTEMVALUES_INFORMIX; + DBSYSTEMVALUES_INSTANTDB = TMP_DBSYSTEMVALUES_INSTANTDB; + DBSYSTEMVALUES_INTERBASE = TMP_DBSYSTEMVALUES_INTERBASE; + DBSYSTEMVALUES_MARIADB = TMP_DBSYSTEMVALUES_MARIADB; + DBSYSTEMVALUES_NETEZZA = TMP_DBSYSTEMVALUES_NETEZZA; + DBSYSTEMVALUES_PERVASIVE = TMP_DBSYSTEMVALUES_PERVASIVE; + DBSYSTEMVALUES_POINTBASE = TMP_DBSYSTEMVALUES_POINTBASE; + DBSYSTEMVALUES_SQLITE = TMP_DBSYSTEMVALUES_SQLITE; + DBSYSTEMVALUES_SYBASE = TMP_DBSYSTEMVALUES_SYBASE; + DBSYSTEMVALUES_TERADATA = TMP_DBSYSTEMVALUES_TERADATA; + DBSYSTEMVALUES_VERTICA = TMP_DBSYSTEMVALUES_VERTICA; + DBSYSTEMVALUES_H2 = TMP_DBSYSTEMVALUES_H2; + DBSYSTEMVALUES_COLDFUSION = TMP_DBSYSTEMVALUES_COLDFUSION; + DBSYSTEMVALUES_CASSANDRA = TMP_DBSYSTEMVALUES_CASSANDRA; + DBSYSTEMVALUES_HBASE = TMP_DBSYSTEMVALUES_HBASE; + DBSYSTEMVALUES_MONGODB = TMP_DBSYSTEMVALUES_MONGODB; + DBSYSTEMVALUES_REDIS = TMP_DBSYSTEMVALUES_REDIS; + DBSYSTEMVALUES_COUCHBASE = TMP_DBSYSTEMVALUES_COUCHBASE; + DBSYSTEMVALUES_COUCHDB = TMP_DBSYSTEMVALUES_COUCHDB; + DBSYSTEMVALUES_COSMOSDB = TMP_DBSYSTEMVALUES_COSMOSDB; + DBSYSTEMVALUES_DYNAMODB = TMP_DBSYSTEMVALUES_DYNAMODB; + DBSYSTEMVALUES_NEO4J = TMP_DBSYSTEMVALUES_NEO4J; + DBSYSTEMVALUES_GEODE = TMP_DBSYSTEMVALUES_GEODE; + DBSYSTEMVALUES_ELASTICSEARCH = TMP_DBSYSTEMVALUES_ELASTICSEARCH; + DBSYSTEMVALUES_MEMCACHED = TMP_DBSYSTEMVALUES_MEMCACHED; + DBSYSTEMVALUES_COCKROACHDB = TMP_DBSYSTEMVALUES_COCKROACHDB; + DbSystemValues = /* @__PURE__ */ createConstMap([ + TMP_DBSYSTEMVALUES_OTHER_SQL, + TMP_DBSYSTEMVALUES_MSSQL, + TMP_DBSYSTEMVALUES_MYSQL, + TMP_DBSYSTEMVALUES_ORACLE, + TMP_DBSYSTEMVALUES_DB2, + TMP_DBSYSTEMVALUES_POSTGRESQL, + TMP_DBSYSTEMVALUES_REDSHIFT, + TMP_DBSYSTEMVALUES_HIVE, + TMP_DBSYSTEMVALUES_CLOUDSCAPE, + TMP_DBSYSTEMVALUES_HSQLDB, + TMP_DBSYSTEMVALUES_PROGRESS, + TMP_DBSYSTEMVALUES_MAXDB, + TMP_DBSYSTEMVALUES_HANADB, + TMP_DBSYSTEMVALUES_INGRES, + TMP_DBSYSTEMVALUES_FIRSTSQL, + TMP_DBSYSTEMVALUES_EDB, + TMP_DBSYSTEMVALUES_CACHE, + TMP_DBSYSTEMVALUES_ADABAS, + TMP_DBSYSTEMVALUES_FIREBIRD, + TMP_DBSYSTEMVALUES_DERBY, + TMP_DBSYSTEMVALUES_FILEMAKER, + TMP_DBSYSTEMVALUES_INFORMIX, + TMP_DBSYSTEMVALUES_INSTANTDB, + TMP_DBSYSTEMVALUES_INTERBASE, + TMP_DBSYSTEMVALUES_MARIADB, + TMP_DBSYSTEMVALUES_NETEZZA, + TMP_DBSYSTEMVALUES_PERVASIVE, + TMP_DBSYSTEMVALUES_POINTBASE, + TMP_DBSYSTEMVALUES_SQLITE, + TMP_DBSYSTEMVALUES_SYBASE, + TMP_DBSYSTEMVALUES_TERADATA, + TMP_DBSYSTEMVALUES_VERTICA, + TMP_DBSYSTEMVALUES_H2, + TMP_DBSYSTEMVALUES_COLDFUSION, + TMP_DBSYSTEMVALUES_CASSANDRA, + TMP_DBSYSTEMVALUES_HBASE, + TMP_DBSYSTEMVALUES_MONGODB, + TMP_DBSYSTEMVALUES_REDIS, + TMP_DBSYSTEMVALUES_COUCHBASE, + TMP_DBSYSTEMVALUES_COUCHDB, + TMP_DBSYSTEMVALUES_COSMOSDB, + TMP_DBSYSTEMVALUES_DYNAMODB, + TMP_DBSYSTEMVALUES_NEO4J, + TMP_DBSYSTEMVALUES_GEODE, + TMP_DBSYSTEMVALUES_ELASTICSEARCH, + TMP_DBSYSTEMVALUES_MEMCACHED, + TMP_DBSYSTEMVALUES_COCKROACHDB + ]); + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ALL = "all"; + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM = "each_quorum"; + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM = "quorum"; + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM = "local_quorum"; + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ONE = "one"; + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_TWO = "two"; + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_THREE = "three"; + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE = "local_one"; + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ANY = "any"; + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL = "serial"; + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL = "local_serial"; + DBCASSANDRACONSISTENCYLEVELVALUES_ALL = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ALL; + DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM; + DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM; + DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM; + DBCASSANDRACONSISTENCYLEVELVALUES_ONE = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ONE; + DBCASSANDRACONSISTENCYLEVELVALUES_TWO = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_TWO; + DBCASSANDRACONSISTENCYLEVELVALUES_THREE = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_THREE; + DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE; + DBCASSANDRACONSISTENCYLEVELVALUES_ANY = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ANY; + DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL; + DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL = TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL; + DbCassandraConsistencyLevelValues = /* @__PURE__ */ createConstMap([ + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ALL, + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM, + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM, + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM, + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ONE, + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_TWO, + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_THREE, + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE, + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_ANY, + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL, + TMP_DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL + ]); + TMP_FAASTRIGGERVALUES_DATASOURCE = "datasource"; + TMP_FAASTRIGGERVALUES_HTTP = "http"; + TMP_FAASTRIGGERVALUES_PUBSUB = "pubsub"; + TMP_FAASTRIGGERVALUES_TIMER = "timer"; + TMP_FAASTRIGGERVALUES_OTHER = "other"; + FAASTRIGGERVALUES_DATASOURCE = TMP_FAASTRIGGERVALUES_DATASOURCE; + FAASTRIGGERVALUES_HTTP = TMP_FAASTRIGGERVALUES_HTTP; + FAASTRIGGERVALUES_PUBSUB = TMP_FAASTRIGGERVALUES_PUBSUB; + FAASTRIGGERVALUES_TIMER = TMP_FAASTRIGGERVALUES_TIMER; + FAASTRIGGERVALUES_OTHER = TMP_FAASTRIGGERVALUES_OTHER; + FaasTriggerValues = /* @__PURE__ */ createConstMap([ + TMP_FAASTRIGGERVALUES_DATASOURCE, + TMP_FAASTRIGGERVALUES_HTTP, + TMP_FAASTRIGGERVALUES_PUBSUB, + TMP_FAASTRIGGERVALUES_TIMER, + TMP_FAASTRIGGERVALUES_OTHER + ]); + TMP_FAASDOCUMENTOPERATIONVALUES_INSERT = "insert"; + TMP_FAASDOCUMENTOPERATIONVALUES_EDIT = "edit"; + TMP_FAASDOCUMENTOPERATIONVALUES_DELETE = "delete"; + FAASDOCUMENTOPERATIONVALUES_INSERT = TMP_FAASDOCUMENTOPERATIONVALUES_INSERT; + FAASDOCUMENTOPERATIONVALUES_EDIT = TMP_FAASDOCUMENTOPERATIONVALUES_EDIT; + FAASDOCUMENTOPERATIONVALUES_DELETE = TMP_FAASDOCUMENTOPERATIONVALUES_DELETE; + FaasDocumentOperationValues = /* @__PURE__ */ createConstMap([ + TMP_FAASDOCUMENTOPERATIONVALUES_INSERT, + TMP_FAASDOCUMENTOPERATIONVALUES_EDIT, + TMP_FAASDOCUMENTOPERATIONVALUES_DELETE + ]); + TMP_FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD = "alibaba_cloud"; + TMP_FAASINVOKEDPROVIDERVALUES_AWS = "aws"; + TMP_FAASINVOKEDPROVIDERVALUES_AZURE = "azure"; + TMP_FAASINVOKEDPROVIDERVALUES_GCP = "gcp"; + FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD = TMP_FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD; + FAASINVOKEDPROVIDERVALUES_AWS = TMP_FAASINVOKEDPROVIDERVALUES_AWS; + FAASINVOKEDPROVIDERVALUES_AZURE = TMP_FAASINVOKEDPROVIDERVALUES_AZURE; + FAASINVOKEDPROVIDERVALUES_GCP = TMP_FAASINVOKEDPROVIDERVALUES_GCP; + FaasInvokedProviderValues = /* @__PURE__ */ createConstMap([ + TMP_FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD, + TMP_FAASINVOKEDPROVIDERVALUES_AWS, + TMP_FAASINVOKEDPROVIDERVALUES_AZURE, + TMP_FAASINVOKEDPROVIDERVALUES_GCP + ]); + TMP_NETTRANSPORTVALUES_IP_TCP = "ip_tcp"; + TMP_NETTRANSPORTVALUES_IP_UDP = "ip_udp"; + TMP_NETTRANSPORTVALUES_IP = "ip"; + TMP_NETTRANSPORTVALUES_UNIX = "unix"; + TMP_NETTRANSPORTVALUES_PIPE = "pipe"; + TMP_NETTRANSPORTVALUES_INPROC = "inproc"; + TMP_NETTRANSPORTVALUES_OTHER = "other"; + NETTRANSPORTVALUES_IP_TCP = TMP_NETTRANSPORTVALUES_IP_TCP; + NETTRANSPORTVALUES_IP_UDP = TMP_NETTRANSPORTVALUES_IP_UDP; + NETTRANSPORTVALUES_IP = TMP_NETTRANSPORTVALUES_IP; + NETTRANSPORTVALUES_UNIX = TMP_NETTRANSPORTVALUES_UNIX; + NETTRANSPORTVALUES_PIPE = TMP_NETTRANSPORTVALUES_PIPE; + NETTRANSPORTVALUES_INPROC = TMP_NETTRANSPORTVALUES_INPROC; + NETTRANSPORTVALUES_OTHER = TMP_NETTRANSPORTVALUES_OTHER; + NetTransportValues = /* @__PURE__ */ createConstMap([ + TMP_NETTRANSPORTVALUES_IP_TCP, + TMP_NETTRANSPORTVALUES_IP_UDP, + TMP_NETTRANSPORTVALUES_IP, + TMP_NETTRANSPORTVALUES_UNIX, + TMP_NETTRANSPORTVALUES_PIPE, + TMP_NETTRANSPORTVALUES_INPROC, + TMP_NETTRANSPORTVALUES_OTHER + ]); + TMP_NETHOSTCONNECTIONTYPEVALUES_WIFI = "wifi"; + TMP_NETHOSTCONNECTIONTYPEVALUES_WIRED = "wired"; + TMP_NETHOSTCONNECTIONTYPEVALUES_CELL = "cell"; + TMP_NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE = "unavailable"; + TMP_NETHOSTCONNECTIONTYPEVALUES_UNKNOWN = "unknown"; + NETHOSTCONNECTIONTYPEVALUES_WIFI = TMP_NETHOSTCONNECTIONTYPEVALUES_WIFI; + NETHOSTCONNECTIONTYPEVALUES_WIRED = TMP_NETHOSTCONNECTIONTYPEVALUES_WIRED; + NETHOSTCONNECTIONTYPEVALUES_CELL = TMP_NETHOSTCONNECTIONTYPEVALUES_CELL; + NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE = TMP_NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE; + NETHOSTCONNECTIONTYPEVALUES_UNKNOWN = TMP_NETHOSTCONNECTIONTYPEVALUES_UNKNOWN; + NetHostConnectionTypeValues = /* @__PURE__ */ createConstMap([ + TMP_NETHOSTCONNECTIONTYPEVALUES_WIFI, + TMP_NETHOSTCONNECTIONTYPEVALUES_WIRED, + TMP_NETHOSTCONNECTIONTYPEVALUES_CELL, + TMP_NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE, + TMP_NETHOSTCONNECTIONTYPEVALUES_UNKNOWN + ]); + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GPRS = "gprs"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EDGE = "edge"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_UMTS = "umts"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA = "cdma"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0 = "evdo_0"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A = "evdo_a"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT = "cdma2000_1xrtt"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA = "hsdpa"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA = "hsupa"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPA = "hspa"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IDEN = "iden"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B = "evdo_b"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE = "lte"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD = "ehrpd"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP = "hspap"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GSM = "gsm"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA = "td_scdma"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN = "iwlan"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NR = "nr"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA = "nrnsa"; + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA = "lte_ca"; + NETHOSTCONNECTIONSUBTYPEVALUES_GPRS = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GPRS; + NETHOSTCONNECTIONSUBTYPEVALUES_EDGE = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EDGE; + NETHOSTCONNECTIONSUBTYPEVALUES_UMTS = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_UMTS; + NETHOSTCONNECTIONSUBTYPEVALUES_CDMA = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA; + NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0 = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0; + NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A; + NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT; + NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA; + NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA; + NETHOSTCONNECTIONSUBTYPEVALUES_HSPA = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPA; + NETHOSTCONNECTIONSUBTYPEVALUES_IDEN = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IDEN; + NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B; + NETHOSTCONNECTIONSUBTYPEVALUES_LTE = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE; + NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD; + NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP; + NETHOSTCONNECTIONSUBTYPEVALUES_GSM = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GSM; + NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA; + NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN; + NETHOSTCONNECTIONSUBTYPEVALUES_NR = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NR; + NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA; + NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA = TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA; + NetHostConnectionSubtypeValues = /* @__PURE__ */ createConstMap([ + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GPRS, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EDGE, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_UMTS, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPA, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IDEN, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_GSM, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NR, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA, + TMP_NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA + ]); + TMP_HTTPFLAVORVALUES_HTTP_1_0 = "1.0"; + TMP_HTTPFLAVORVALUES_HTTP_1_1 = "1.1"; + TMP_HTTPFLAVORVALUES_HTTP_2_0 = "2.0"; + TMP_HTTPFLAVORVALUES_SPDY = "SPDY"; + TMP_HTTPFLAVORVALUES_QUIC = "QUIC"; + HTTPFLAVORVALUES_HTTP_1_0 = TMP_HTTPFLAVORVALUES_HTTP_1_0; + HTTPFLAVORVALUES_HTTP_1_1 = TMP_HTTPFLAVORVALUES_HTTP_1_1; + HTTPFLAVORVALUES_HTTP_2_0 = TMP_HTTPFLAVORVALUES_HTTP_2_0; + HTTPFLAVORVALUES_SPDY = TMP_HTTPFLAVORVALUES_SPDY; + HTTPFLAVORVALUES_QUIC = TMP_HTTPFLAVORVALUES_QUIC; + HttpFlavorValues = { + HTTP_1_0: TMP_HTTPFLAVORVALUES_HTTP_1_0, + HTTP_1_1: TMP_HTTPFLAVORVALUES_HTTP_1_1, + HTTP_2_0: TMP_HTTPFLAVORVALUES_HTTP_2_0, + SPDY: TMP_HTTPFLAVORVALUES_SPDY, + QUIC: TMP_HTTPFLAVORVALUES_QUIC + }; + TMP_MESSAGINGDESTINATIONKINDVALUES_QUEUE = "queue"; + TMP_MESSAGINGDESTINATIONKINDVALUES_TOPIC = "topic"; + MESSAGINGDESTINATIONKINDVALUES_QUEUE = TMP_MESSAGINGDESTINATIONKINDVALUES_QUEUE; + MESSAGINGDESTINATIONKINDVALUES_TOPIC = TMP_MESSAGINGDESTINATIONKINDVALUES_TOPIC; + MessagingDestinationKindValues = /* @__PURE__ */ createConstMap([ + TMP_MESSAGINGDESTINATIONKINDVALUES_QUEUE, + TMP_MESSAGINGDESTINATIONKINDVALUES_TOPIC + ]); + TMP_MESSAGINGOPERATIONVALUES_RECEIVE = "receive"; + TMP_MESSAGINGOPERATIONVALUES_PROCESS = "process"; + MESSAGINGOPERATIONVALUES_RECEIVE = TMP_MESSAGINGOPERATIONVALUES_RECEIVE; + MESSAGINGOPERATIONVALUES_PROCESS = TMP_MESSAGINGOPERATIONVALUES_PROCESS; + MessagingOperationValues = /* @__PURE__ */ createConstMap([ + TMP_MESSAGINGOPERATIONVALUES_RECEIVE, + TMP_MESSAGINGOPERATIONVALUES_PROCESS + ]); + TMP_RPCGRPCSTATUSCODEVALUES_OK = 0; + TMP_RPCGRPCSTATUSCODEVALUES_CANCELLED = 1; + TMP_RPCGRPCSTATUSCODEVALUES_UNKNOWN = 2; + TMP_RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT = 3; + TMP_RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED = 4; + TMP_RPCGRPCSTATUSCODEVALUES_NOT_FOUND = 5; + TMP_RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS = 6; + TMP_RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED = 7; + TMP_RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED = 8; + TMP_RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION = 9; + TMP_RPCGRPCSTATUSCODEVALUES_ABORTED = 10; + TMP_RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE = 11; + TMP_RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED = 12; + TMP_RPCGRPCSTATUSCODEVALUES_INTERNAL = 13; + TMP_RPCGRPCSTATUSCODEVALUES_UNAVAILABLE = 14; + TMP_RPCGRPCSTATUSCODEVALUES_DATA_LOSS = 15; + TMP_RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED = 16; + RPCGRPCSTATUSCODEVALUES_OK = TMP_RPCGRPCSTATUSCODEVALUES_OK; + RPCGRPCSTATUSCODEVALUES_CANCELLED = TMP_RPCGRPCSTATUSCODEVALUES_CANCELLED; + RPCGRPCSTATUSCODEVALUES_UNKNOWN = TMP_RPCGRPCSTATUSCODEVALUES_UNKNOWN; + RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT = TMP_RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT; + RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED = TMP_RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED; + RPCGRPCSTATUSCODEVALUES_NOT_FOUND = TMP_RPCGRPCSTATUSCODEVALUES_NOT_FOUND; + RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS = TMP_RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS; + RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED = TMP_RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED; + RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED = TMP_RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED; + RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION = TMP_RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION; + RPCGRPCSTATUSCODEVALUES_ABORTED = TMP_RPCGRPCSTATUSCODEVALUES_ABORTED; + RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE = TMP_RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE; + RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED = TMP_RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED; + RPCGRPCSTATUSCODEVALUES_INTERNAL = TMP_RPCGRPCSTATUSCODEVALUES_INTERNAL; + RPCGRPCSTATUSCODEVALUES_UNAVAILABLE = TMP_RPCGRPCSTATUSCODEVALUES_UNAVAILABLE; + RPCGRPCSTATUSCODEVALUES_DATA_LOSS = TMP_RPCGRPCSTATUSCODEVALUES_DATA_LOSS; + RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED = TMP_RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED; + RpcGrpcStatusCodeValues = { + OK: TMP_RPCGRPCSTATUSCODEVALUES_OK, + CANCELLED: TMP_RPCGRPCSTATUSCODEVALUES_CANCELLED, + UNKNOWN: TMP_RPCGRPCSTATUSCODEVALUES_UNKNOWN, + INVALID_ARGUMENT: TMP_RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT, + DEADLINE_EXCEEDED: TMP_RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED, + NOT_FOUND: TMP_RPCGRPCSTATUSCODEVALUES_NOT_FOUND, + ALREADY_EXISTS: TMP_RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS, + PERMISSION_DENIED: TMP_RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED, + RESOURCE_EXHAUSTED: TMP_RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED, + FAILED_PRECONDITION: TMP_RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION, + ABORTED: TMP_RPCGRPCSTATUSCODEVALUES_ABORTED, + OUT_OF_RANGE: TMP_RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE, + UNIMPLEMENTED: TMP_RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED, + INTERNAL: TMP_RPCGRPCSTATUSCODEVALUES_INTERNAL, + UNAVAILABLE: TMP_RPCGRPCSTATUSCODEVALUES_UNAVAILABLE, + DATA_LOSS: TMP_RPCGRPCSTATUSCODEVALUES_DATA_LOSS, + UNAUTHENTICATED: TMP_RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED + }; + TMP_MESSAGETYPEVALUES_SENT = "SENT"; + TMP_MESSAGETYPEVALUES_RECEIVED = "RECEIVED"; + MESSAGETYPEVALUES_SENT = TMP_MESSAGETYPEVALUES_SENT; + MESSAGETYPEVALUES_RECEIVED = TMP_MESSAGETYPEVALUES_RECEIVED; + MessageTypeValues = /* @__PURE__ */ createConstMap([ + TMP_MESSAGETYPEVALUES_SENT, + TMP_MESSAGETYPEVALUES_RECEIVED + ]); + } +}); + +// node_modules/@opentelemetry/semantic-conventions/build/esm/trace/index.js +var init_trace2 = __esm({ + "node_modules/@opentelemetry/semantic-conventions/build/esm/trace/index.js"() { + init_SemanticAttributes(); + } +}); + +// node_modules/@opentelemetry/semantic-conventions/build/esm/resource/SemanticResourceAttributes.js +var TMP_CLOUD_PROVIDER, TMP_CLOUD_ACCOUNT_ID, TMP_CLOUD_REGION, TMP_CLOUD_AVAILABILITY_ZONE, TMP_CLOUD_PLATFORM, TMP_AWS_ECS_CONTAINER_ARN, TMP_AWS_ECS_CLUSTER_ARN, TMP_AWS_ECS_LAUNCHTYPE, TMP_AWS_ECS_TASK_ARN, TMP_AWS_ECS_TASK_FAMILY, TMP_AWS_ECS_TASK_REVISION, TMP_AWS_EKS_CLUSTER_ARN, TMP_AWS_LOG_GROUP_NAMES, TMP_AWS_LOG_GROUP_ARNS, TMP_AWS_LOG_STREAM_NAMES, TMP_AWS_LOG_STREAM_ARNS, TMP_CONTAINER_NAME, TMP_CONTAINER_ID, TMP_CONTAINER_RUNTIME, TMP_CONTAINER_IMAGE_NAME, TMP_CONTAINER_IMAGE_TAG, TMP_DEPLOYMENT_ENVIRONMENT, TMP_DEVICE_ID, TMP_DEVICE_MODEL_IDENTIFIER, TMP_DEVICE_MODEL_NAME, TMP_FAAS_NAME, TMP_FAAS_ID, TMP_FAAS_VERSION, TMP_FAAS_INSTANCE, TMP_FAAS_MAX_MEMORY, TMP_HOST_ID, TMP_HOST_NAME, TMP_HOST_TYPE, TMP_HOST_ARCH, TMP_HOST_IMAGE_NAME, TMP_HOST_IMAGE_ID, TMP_HOST_IMAGE_VERSION, TMP_K8S_CLUSTER_NAME, TMP_K8S_NODE_NAME, TMP_K8S_NODE_UID, TMP_K8S_NAMESPACE_NAME, TMP_K8S_POD_UID, TMP_K8S_POD_NAME, TMP_K8S_CONTAINER_NAME, TMP_K8S_REPLICASET_UID, TMP_K8S_REPLICASET_NAME, TMP_K8S_DEPLOYMENT_UID, TMP_K8S_DEPLOYMENT_NAME, TMP_K8S_STATEFULSET_UID, TMP_K8S_STATEFULSET_NAME, TMP_K8S_DAEMONSET_UID, TMP_K8S_DAEMONSET_NAME, TMP_K8S_JOB_UID, TMP_K8S_JOB_NAME, TMP_K8S_CRONJOB_UID, TMP_K8S_CRONJOB_NAME, TMP_OS_TYPE, TMP_OS_DESCRIPTION, TMP_OS_NAME, TMP_OS_VERSION, TMP_PROCESS_PID, TMP_PROCESS_EXECUTABLE_NAME, TMP_PROCESS_EXECUTABLE_PATH, TMP_PROCESS_COMMAND, TMP_PROCESS_COMMAND_LINE, TMP_PROCESS_COMMAND_ARGS, TMP_PROCESS_OWNER, TMP_PROCESS_RUNTIME_NAME, TMP_PROCESS_RUNTIME_VERSION, TMP_PROCESS_RUNTIME_DESCRIPTION, TMP_SERVICE_NAME, TMP_SERVICE_NAMESPACE, TMP_SERVICE_INSTANCE_ID, TMP_SERVICE_VERSION, TMP_TELEMETRY_SDK_NAME, TMP_TELEMETRY_SDK_LANGUAGE, TMP_TELEMETRY_SDK_VERSION, TMP_TELEMETRY_AUTO_VERSION, TMP_WEBENGINE_NAME, TMP_WEBENGINE_VERSION, TMP_WEBENGINE_DESCRIPTION, SEMRESATTRS_CLOUD_PROVIDER, SEMRESATTRS_CLOUD_ACCOUNT_ID, SEMRESATTRS_CLOUD_REGION, SEMRESATTRS_CLOUD_AVAILABILITY_ZONE, SEMRESATTRS_CLOUD_PLATFORM, SEMRESATTRS_AWS_ECS_CONTAINER_ARN, SEMRESATTRS_AWS_ECS_CLUSTER_ARN, SEMRESATTRS_AWS_ECS_LAUNCHTYPE, SEMRESATTRS_AWS_ECS_TASK_ARN, SEMRESATTRS_AWS_ECS_TASK_FAMILY, SEMRESATTRS_AWS_ECS_TASK_REVISION, SEMRESATTRS_AWS_EKS_CLUSTER_ARN, SEMRESATTRS_AWS_LOG_GROUP_NAMES, SEMRESATTRS_AWS_LOG_GROUP_ARNS, SEMRESATTRS_AWS_LOG_STREAM_NAMES, SEMRESATTRS_AWS_LOG_STREAM_ARNS, SEMRESATTRS_CONTAINER_NAME, SEMRESATTRS_CONTAINER_ID, SEMRESATTRS_CONTAINER_RUNTIME, SEMRESATTRS_CONTAINER_IMAGE_NAME, SEMRESATTRS_CONTAINER_IMAGE_TAG, SEMRESATTRS_DEPLOYMENT_ENVIRONMENT, SEMRESATTRS_DEVICE_ID, SEMRESATTRS_DEVICE_MODEL_IDENTIFIER, SEMRESATTRS_DEVICE_MODEL_NAME, SEMRESATTRS_FAAS_NAME, SEMRESATTRS_FAAS_ID, SEMRESATTRS_FAAS_VERSION, SEMRESATTRS_FAAS_INSTANCE, SEMRESATTRS_FAAS_MAX_MEMORY, SEMRESATTRS_HOST_ID, SEMRESATTRS_HOST_NAME, SEMRESATTRS_HOST_TYPE, SEMRESATTRS_HOST_ARCH, SEMRESATTRS_HOST_IMAGE_NAME, SEMRESATTRS_HOST_IMAGE_ID, SEMRESATTRS_HOST_IMAGE_VERSION, SEMRESATTRS_K8S_CLUSTER_NAME, SEMRESATTRS_K8S_NODE_NAME, SEMRESATTRS_K8S_NODE_UID, SEMRESATTRS_K8S_NAMESPACE_NAME, SEMRESATTRS_K8S_POD_UID, SEMRESATTRS_K8S_POD_NAME, SEMRESATTRS_K8S_CONTAINER_NAME, SEMRESATTRS_K8S_REPLICASET_UID, SEMRESATTRS_K8S_REPLICASET_NAME, SEMRESATTRS_K8S_DEPLOYMENT_UID, SEMRESATTRS_K8S_DEPLOYMENT_NAME, SEMRESATTRS_K8S_STATEFULSET_UID, SEMRESATTRS_K8S_STATEFULSET_NAME, SEMRESATTRS_K8S_DAEMONSET_UID, SEMRESATTRS_K8S_DAEMONSET_NAME, SEMRESATTRS_K8S_JOB_UID, SEMRESATTRS_K8S_JOB_NAME, SEMRESATTRS_K8S_CRONJOB_UID, SEMRESATTRS_K8S_CRONJOB_NAME, SEMRESATTRS_OS_TYPE, SEMRESATTRS_OS_DESCRIPTION, SEMRESATTRS_OS_NAME, SEMRESATTRS_OS_VERSION, SEMRESATTRS_PROCESS_PID, SEMRESATTRS_PROCESS_EXECUTABLE_NAME, SEMRESATTRS_PROCESS_EXECUTABLE_PATH, SEMRESATTRS_PROCESS_COMMAND, SEMRESATTRS_PROCESS_COMMAND_LINE, SEMRESATTRS_PROCESS_COMMAND_ARGS, SEMRESATTRS_PROCESS_OWNER, SEMRESATTRS_PROCESS_RUNTIME_NAME, SEMRESATTRS_PROCESS_RUNTIME_VERSION, SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION, SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_NAMESPACE, SEMRESATTRS_SERVICE_INSTANCE_ID, SEMRESATTRS_SERVICE_VERSION, SEMRESATTRS_TELEMETRY_SDK_NAME, SEMRESATTRS_TELEMETRY_SDK_LANGUAGE, SEMRESATTRS_TELEMETRY_SDK_VERSION, SEMRESATTRS_TELEMETRY_AUTO_VERSION, SEMRESATTRS_WEBENGINE_NAME, SEMRESATTRS_WEBENGINE_VERSION, SEMRESATTRS_WEBENGINE_DESCRIPTION, SemanticResourceAttributes, TMP_CLOUDPROVIDERVALUES_ALIBABA_CLOUD, TMP_CLOUDPROVIDERVALUES_AWS, TMP_CLOUDPROVIDERVALUES_AZURE, TMP_CLOUDPROVIDERVALUES_GCP, CLOUDPROVIDERVALUES_ALIBABA_CLOUD, CLOUDPROVIDERVALUES_AWS, CLOUDPROVIDERVALUES_AZURE, CLOUDPROVIDERVALUES_GCP, CloudProviderValues, TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS, TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC, TMP_CLOUDPLATFORMVALUES_AWS_EC2, TMP_CLOUDPLATFORMVALUES_AWS_ECS, TMP_CLOUDPLATFORMVALUES_AWS_EKS, TMP_CLOUDPLATFORMVALUES_AWS_LAMBDA, TMP_CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK, TMP_CLOUDPLATFORMVALUES_AZURE_VM, TMP_CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES, TMP_CLOUDPLATFORMVALUES_AZURE_AKS, TMP_CLOUDPLATFORMVALUES_AZURE_FUNCTIONS, TMP_CLOUDPLATFORMVALUES_AZURE_APP_SERVICE, TMP_CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE, TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_RUN, TMP_CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE, TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS, TMP_CLOUDPLATFORMVALUES_GCP_APP_ENGINE, CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS, CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC, CLOUDPLATFORMVALUES_AWS_EC2, CLOUDPLATFORMVALUES_AWS_ECS, CLOUDPLATFORMVALUES_AWS_EKS, CLOUDPLATFORMVALUES_AWS_LAMBDA, CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK, CLOUDPLATFORMVALUES_AZURE_VM, CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES, CLOUDPLATFORMVALUES_AZURE_AKS, CLOUDPLATFORMVALUES_AZURE_FUNCTIONS, CLOUDPLATFORMVALUES_AZURE_APP_SERVICE, CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE, CLOUDPLATFORMVALUES_GCP_CLOUD_RUN, CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE, CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS, CLOUDPLATFORMVALUES_GCP_APP_ENGINE, CloudPlatformValues, TMP_AWSECSLAUNCHTYPEVALUES_EC2, TMP_AWSECSLAUNCHTYPEVALUES_FARGATE, AWSECSLAUNCHTYPEVALUES_EC2, AWSECSLAUNCHTYPEVALUES_FARGATE, AwsEcsLaunchtypeValues, TMP_HOSTARCHVALUES_AMD64, TMP_HOSTARCHVALUES_ARM32, TMP_HOSTARCHVALUES_ARM64, TMP_HOSTARCHVALUES_IA64, TMP_HOSTARCHVALUES_PPC32, TMP_HOSTARCHVALUES_PPC64, TMP_HOSTARCHVALUES_X86, HOSTARCHVALUES_AMD64, HOSTARCHVALUES_ARM32, HOSTARCHVALUES_ARM64, HOSTARCHVALUES_IA64, HOSTARCHVALUES_PPC32, HOSTARCHVALUES_PPC64, HOSTARCHVALUES_X86, HostArchValues, TMP_OSTYPEVALUES_WINDOWS, TMP_OSTYPEVALUES_LINUX, TMP_OSTYPEVALUES_DARWIN, TMP_OSTYPEVALUES_FREEBSD, TMP_OSTYPEVALUES_NETBSD, TMP_OSTYPEVALUES_OPENBSD, TMP_OSTYPEVALUES_DRAGONFLYBSD, TMP_OSTYPEVALUES_HPUX, TMP_OSTYPEVALUES_AIX, TMP_OSTYPEVALUES_SOLARIS, TMP_OSTYPEVALUES_Z_OS, OSTYPEVALUES_WINDOWS, OSTYPEVALUES_LINUX, OSTYPEVALUES_DARWIN, OSTYPEVALUES_FREEBSD, OSTYPEVALUES_NETBSD, OSTYPEVALUES_OPENBSD, OSTYPEVALUES_DRAGONFLYBSD, OSTYPEVALUES_HPUX, OSTYPEVALUES_AIX, OSTYPEVALUES_SOLARIS, OSTYPEVALUES_Z_OS, OsTypeValues, TMP_TELEMETRYSDKLANGUAGEVALUES_CPP, TMP_TELEMETRYSDKLANGUAGEVALUES_DOTNET, TMP_TELEMETRYSDKLANGUAGEVALUES_ERLANG, TMP_TELEMETRYSDKLANGUAGEVALUES_GO, TMP_TELEMETRYSDKLANGUAGEVALUES_JAVA, TMP_TELEMETRYSDKLANGUAGEVALUES_NODEJS, TMP_TELEMETRYSDKLANGUAGEVALUES_PHP, TMP_TELEMETRYSDKLANGUAGEVALUES_PYTHON, TMP_TELEMETRYSDKLANGUAGEVALUES_RUBY, TMP_TELEMETRYSDKLANGUAGEVALUES_WEBJS, TELEMETRYSDKLANGUAGEVALUES_CPP, TELEMETRYSDKLANGUAGEVALUES_DOTNET, TELEMETRYSDKLANGUAGEVALUES_ERLANG, TELEMETRYSDKLANGUAGEVALUES_GO, TELEMETRYSDKLANGUAGEVALUES_JAVA, TELEMETRYSDKLANGUAGEVALUES_NODEJS, TELEMETRYSDKLANGUAGEVALUES_PHP, TELEMETRYSDKLANGUAGEVALUES_PYTHON, TELEMETRYSDKLANGUAGEVALUES_RUBY, TELEMETRYSDKLANGUAGEVALUES_WEBJS, TelemetrySdkLanguageValues; +var init_SemanticResourceAttributes = __esm({ + "node_modules/@opentelemetry/semantic-conventions/build/esm/resource/SemanticResourceAttributes.js"() { + init_utils3(); + TMP_CLOUD_PROVIDER = "cloud.provider"; + TMP_CLOUD_ACCOUNT_ID = "cloud.account.id"; + TMP_CLOUD_REGION = "cloud.region"; + TMP_CLOUD_AVAILABILITY_ZONE = "cloud.availability_zone"; + TMP_CLOUD_PLATFORM = "cloud.platform"; + TMP_AWS_ECS_CONTAINER_ARN = "aws.ecs.container.arn"; + TMP_AWS_ECS_CLUSTER_ARN = "aws.ecs.cluster.arn"; + TMP_AWS_ECS_LAUNCHTYPE = "aws.ecs.launchtype"; + TMP_AWS_ECS_TASK_ARN = "aws.ecs.task.arn"; + TMP_AWS_ECS_TASK_FAMILY = "aws.ecs.task.family"; + TMP_AWS_ECS_TASK_REVISION = "aws.ecs.task.revision"; + TMP_AWS_EKS_CLUSTER_ARN = "aws.eks.cluster.arn"; + TMP_AWS_LOG_GROUP_NAMES = "aws.log.group.names"; + TMP_AWS_LOG_GROUP_ARNS = "aws.log.group.arns"; + TMP_AWS_LOG_STREAM_NAMES = "aws.log.stream.names"; + TMP_AWS_LOG_STREAM_ARNS = "aws.log.stream.arns"; + TMP_CONTAINER_NAME = "container.name"; + TMP_CONTAINER_ID = "container.id"; + TMP_CONTAINER_RUNTIME = "container.runtime"; + TMP_CONTAINER_IMAGE_NAME = "container.image.name"; + TMP_CONTAINER_IMAGE_TAG = "container.image.tag"; + TMP_DEPLOYMENT_ENVIRONMENT = "deployment.environment"; + TMP_DEVICE_ID = "device.id"; + TMP_DEVICE_MODEL_IDENTIFIER = "device.model.identifier"; + TMP_DEVICE_MODEL_NAME = "device.model.name"; + TMP_FAAS_NAME = "faas.name"; + TMP_FAAS_ID = "faas.id"; + TMP_FAAS_VERSION = "faas.version"; + TMP_FAAS_INSTANCE = "faas.instance"; + TMP_FAAS_MAX_MEMORY = "faas.max_memory"; + TMP_HOST_ID = "host.id"; + TMP_HOST_NAME = "host.name"; + TMP_HOST_TYPE = "host.type"; + TMP_HOST_ARCH = "host.arch"; + TMP_HOST_IMAGE_NAME = "host.image.name"; + TMP_HOST_IMAGE_ID = "host.image.id"; + TMP_HOST_IMAGE_VERSION = "host.image.version"; + TMP_K8S_CLUSTER_NAME = "k8s.cluster.name"; + TMP_K8S_NODE_NAME = "k8s.node.name"; + TMP_K8S_NODE_UID = "k8s.node.uid"; + TMP_K8S_NAMESPACE_NAME = "k8s.namespace.name"; + TMP_K8S_POD_UID = "k8s.pod.uid"; + TMP_K8S_POD_NAME = "k8s.pod.name"; + TMP_K8S_CONTAINER_NAME = "k8s.container.name"; + TMP_K8S_REPLICASET_UID = "k8s.replicaset.uid"; + TMP_K8S_REPLICASET_NAME = "k8s.replicaset.name"; + TMP_K8S_DEPLOYMENT_UID = "k8s.deployment.uid"; + TMP_K8S_DEPLOYMENT_NAME = "k8s.deployment.name"; + TMP_K8S_STATEFULSET_UID = "k8s.statefulset.uid"; + TMP_K8S_STATEFULSET_NAME = "k8s.statefulset.name"; + TMP_K8S_DAEMONSET_UID = "k8s.daemonset.uid"; + TMP_K8S_DAEMONSET_NAME = "k8s.daemonset.name"; + TMP_K8S_JOB_UID = "k8s.job.uid"; + TMP_K8S_JOB_NAME = "k8s.job.name"; + TMP_K8S_CRONJOB_UID = "k8s.cronjob.uid"; + TMP_K8S_CRONJOB_NAME = "k8s.cronjob.name"; + TMP_OS_TYPE = "os.type"; + TMP_OS_DESCRIPTION = "os.description"; + TMP_OS_NAME = "os.name"; + TMP_OS_VERSION = "os.version"; + TMP_PROCESS_PID = "process.pid"; + TMP_PROCESS_EXECUTABLE_NAME = "process.executable.name"; + TMP_PROCESS_EXECUTABLE_PATH = "process.executable.path"; + TMP_PROCESS_COMMAND = "process.command"; + TMP_PROCESS_COMMAND_LINE = "process.command_line"; + TMP_PROCESS_COMMAND_ARGS = "process.command_args"; + TMP_PROCESS_OWNER = "process.owner"; + TMP_PROCESS_RUNTIME_NAME = "process.runtime.name"; + TMP_PROCESS_RUNTIME_VERSION = "process.runtime.version"; + TMP_PROCESS_RUNTIME_DESCRIPTION = "process.runtime.description"; + TMP_SERVICE_NAME = "service.name"; + TMP_SERVICE_NAMESPACE = "service.namespace"; + TMP_SERVICE_INSTANCE_ID = "service.instance.id"; + TMP_SERVICE_VERSION = "service.version"; + TMP_TELEMETRY_SDK_NAME = "telemetry.sdk.name"; + TMP_TELEMETRY_SDK_LANGUAGE = "telemetry.sdk.language"; + TMP_TELEMETRY_SDK_VERSION = "telemetry.sdk.version"; + TMP_TELEMETRY_AUTO_VERSION = "telemetry.auto.version"; + TMP_WEBENGINE_NAME = "webengine.name"; + TMP_WEBENGINE_VERSION = "webengine.version"; + TMP_WEBENGINE_DESCRIPTION = "webengine.description"; + SEMRESATTRS_CLOUD_PROVIDER = TMP_CLOUD_PROVIDER; + SEMRESATTRS_CLOUD_ACCOUNT_ID = TMP_CLOUD_ACCOUNT_ID; + SEMRESATTRS_CLOUD_REGION = TMP_CLOUD_REGION; + SEMRESATTRS_CLOUD_AVAILABILITY_ZONE = TMP_CLOUD_AVAILABILITY_ZONE; + SEMRESATTRS_CLOUD_PLATFORM = TMP_CLOUD_PLATFORM; + SEMRESATTRS_AWS_ECS_CONTAINER_ARN = TMP_AWS_ECS_CONTAINER_ARN; + SEMRESATTRS_AWS_ECS_CLUSTER_ARN = TMP_AWS_ECS_CLUSTER_ARN; + SEMRESATTRS_AWS_ECS_LAUNCHTYPE = TMP_AWS_ECS_LAUNCHTYPE; + SEMRESATTRS_AWS_ECS_TASK_ARN = TMP_AWS_ECS_TASK_ARN; + SEMRESATTRS_AWS_ECS_TASK_FAMILY = TMP_AWS_ECS_TASK_FAMILY; + SEMRESATTRS_AWS_ECS_TASK_REVISION = TMP_AWS_ECS_TASK_REVISION; + SEMRESATTRS_AWS_EKS_CLUSTER_ARN = TMP_AWS_EKS_CLUSTER_ARN; + SEMRESATTRS_AWS_LOG_GROUP_NAMES = TMP_AWS_LOG_GROUP_NAMES; + SEMRESATTRS_AWS_LOG_GROUP_ARNS = TMP_AWS_LOG_GROUP_ARNS; + SEMRESATTRS_AWS_LOG_STREAM_NAMES = TMP_AWS_LOG_STREAM_NAMES; + SEMRESATTRS_AWS_LOG_STREAM_ARNS = TMP_AWS_LOG_STREAM_ARNS; + SEMRESATTRS_CONTAINER_NAME = TMP_CONTAINER_NAME; + SEMRESATTRS_CONTAINER_ID = TMP_CONTAINER_ID; + SEMRESATTRS_CONTAINER_RUNTIME = TMP_CONTAINER_RUNTIME; + SEMRESATTRS_CONTAINER_IMAGE_NAME = TMP_CONTAINER_IMAGE_NAME; + SEMRESATTRS_CONTAINER_IMAGE_TAG = TMP_CONTAINER_IMAGE_TAG; + SEMRESATTRS_DEPLOYMENT_ENVIRONMENT = TMP_DEPLOYMENT_ENVIRONMENT; + SEMRESATTRS_DEVICE_ID = TMP_DEVICE_ID; + SEMRESATTRS_DEVICE_MODEL_IDENTIFIER = TMP_DEVICE_MODEL_IDENTIFIER; + SEMRESATTRS_DEVICE_MODEL_NAME = TMP_DEVICE_MODEL_NAME; + SEMRESATTRS_FAAS_NAME = TMP_FAAS_NAME; + SEMRESATTRS_FAAS_ID = TMP_FAAS_ID; + SEMRESATTRS_FAAS_VERSION = TMP_FAAS_VERSION; + SEMRESATTRS_FAAS_INSTANCE = TMP_FAAS_INSTANCE; + SEMRESATTRS_FAAS_MAX_MEMORY = TMP_FAAS_MAX_MEMORY; + SEMRESATTRS_HOST_ID = TMP_HOST_ID; + SEMRESATTRS_HOST_NAME = TMP_HOST_NAME; + SEMRESATTRS_HOST_TYPE = TMP_HOST_TYPE; + SEMRESATTRS_HOST_ARCH = TMP_HOST_ARCH; + SEMRESATTRS_HOST_IMAGE_NAME = TMP_HOST_IMAGE_NAME; + SEMRESATTRS_HOST_IMAGE_ID = TMP_HOST_IMAGE_ID; + SEMRESATTRS_HOST_IMAGE_VERSION = TMP_HOST_IMAGE_VERSION; + SEMRESATTRS_K8S_CLUSTER_NAME = TMP_K8S_CLUSTER_NAME; + SEMRESATTRS_K8S_NODE_NAME = TMP_K8S_NODE_NAME; + SEMRESATTRS_K8S_NODE_UID = TMP_K8S_NODE_UID; + SEMRESATTRS_K8S_NAMESPACE_NAME = TMP_K8S_NAMESPACE_NAME; + SEMRESATTRS_K8S_POD_UID = TMP_K8S_POD_UID; + SEMRESATTRS_K8S_POD_NAME = TMP_K8S_POD_NAME; + SEMRESATTRS_K8S_CONTAINER_NAME = TMP_K8S_CONTAINER_NAME; + SEMRESATTRS_K8S_REPLICASET_UID = TMP_K8S_REPLICASET_UID; + SEMRESATTRS_K8S_REPLICASET_NAME = TMP_K8S_REPLICASET_NAME; + SEMRESATTRS_K8S_DEPLOYMENT_UID = TMP_K8S_DEPLOYMENT_UID; + SEMRESATTRS_K8S_DEPLOYMENT_NAME = TMP_K8S_DEPLOYMENT_NAME; + SEMRESATTRS_K8S_STATEFULSET_UID = TMP_K8S_STATEFULSET_UID; + SEMRESATTRS_K8S_STATEFULSET_NAME = TMP_K8S_STATEFULSET_NAME; + SEMRESATTRS_K8S_DAEMONSET_UID = TMP_K8S_DAEMONSET_UID; + SEMRESATTRS_K8S_DAEMONSET_NAME = TMP_K8S_DAEMONSET_NAME; + SEMRESATTRS_K8S_JOB_UID = TMP_K8S_JOB_UID; + SEMRESATTRS_K8S_JOB_NAME = TMP_K8S_JOB_NAME; + SEMRESATTRS_K8S_CRONJOB_UID = TMP_K8S_CRONJOB_UID; + SEMRESATTRS_K8S_CRONJOB_NAME = TMP_K8S_CRONJOB_NAME; + SEMRESATTRS_OS_TYPE = TMP_OS_TYPE; + SEMRESATTRS_OS_DESCRIPTION = TMP_OS_DESCRIPTION; + SEMRESATTRS_OS_NAME = TMP_OS_NAME; + SEMRESATTRS_OS_VERSION = TMP_OS_VERSION; + SEMRESATTRS_PROCESS_PID = TMP_PROCESS_PID; + SEMRESATTRS_PROCESS_EXECUTABLE_NAME = TMP_PROCESS_EXECUTABLE_NAME; + SEMRESATTRS_PROCESS_EXECUTABLE_PATH = TMP_PROCESS_EXECUTABLE_PATH; + SEMRESATTRS_PROCESS_COMMAND = TMP_PROCESS_COMMAND; + SEMRESATTRS_PROCESS_COMMAND_LINE = TMP_PROCESS_COMMAND_LINE; + SEMRESATTRS_PROCESS_COMMAND_ARGS = TMP_PROCESS_COMMAND_ARGS; + SEMRESATTRS_PROCESS_OWNER = TMP_PROCESS_OWNER; + SEMRESATTRS_PROCESS_RUNTIME_NAME = TMP_PROCESS_RUNTIME_NAME; + SEMRESATTRS_PROCESS_RUNTIME_VERSION = TMP_PROCESS_RUNTIME_VERSION; + SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION = TMP_PROCESS_RUNTIME_DESCRIPTION; + SEMRESATTRS_SERVICE_NAME = TMP_SERVICE_NAME; + SEMRESATTRS_SERVICE_NAMESPACE = TMP_SERVICE_NAMESPACE; + SEMRESATTRS_SERVICE_INSTANCE_ID = TMP_SERVICE_INSTANCE_ID; + SEMRESATTRS_SERVICE_VERSION = TMP_SERVICE_VERSION; + SEMRESATTRS_TELEMETRY_SDK_NAME = TMP_TELEMETRY_SDK_NAME; + SEMRESATTRS_TELEMETRY_SDK_LANGUAGE = TMP_TELEMETRY_SDK_LANGUAGE; + SEMRESATTRS_TELEMETRY_SDK_VERSION = TMP_TELEMETRY_SDK_VERSION; + SEMRESATTRS_TELEMETRY_AUTO_VERSION = TMP_TELEMETRY_AUTO_VERSION; + SEMRESATTRS_WEBENGINE_NAME = TMP_WEBENGINE_NAME; + SEMRESATTRS_WEBENGINE_VERSION = TMP_WEBENGINE_VERSION; + SEMRESATTRS_WEBENGINE_DESCRIPTION = TMP_WEBENGINE_DESCRIPTION; + SemanticResourceAttributes = /* @__PURE__ */ createConstMap([ + TMP_CLOUD_PROVIDER, + TMP_CLOUD_ACCOUNT_ID, + TMP_CLOUD_REGION, + TMP_CLOUD_AVAILABILITY_ZONE, + TMP_CLOUD_PLATFORM, + TMP_AWS_ECS_CONTAINER_ARN, + TMP_AWS_ECS_CLUSTER_ARN, + TMP_AWS_ECS_LAUNCHTYPE, + TMP_AWS_ECS_TASK_ARN, + TMP_AWS_ECS_TASK_FAMILY, + TMP_AWS_ECS_TASK_REVISION, + TMP_AWS_EKS_CLUSTER_ARN, + TMP_AWS_LOG_GROUP_NAMES, + TMP_AWS_LOG_GROUP_ARNS, + TMP_AWS_LOG_STREAM_NAMES, + TMP_AWS_LOG_STREAM_ARNS, + TMP_CONTAINER_NAME, + TMP_CONTAINER_ID, + TMP_CONTAINER_RUNTIME, + TMP_CONTAINER_IMAGE_NAME, + TMP_CONTAINER_IMAGE_TAG, + TMP_DEPLOYMENT_ENVIRONMENT, + TMP_DEVICE_ID, + TMP_DEVICE_MODEL_IDENTIFIER, + TMP_DEVICE_MODEL_NAME, + TMP_FAAS_NAME, + TMP_FAAS_ID, + TMP_FAAS_VERSION, + TMP_FAAS_INSTANCE, + TMP_FAAS_MAX_MEMORY, + TMP_HOST_ID, + TMP_HOST_NAME, + TMP_HOST_TYPE, + TMP_HOST_ARCH, + TMP_HOST_IMAGE_NAME, + TMP_HOST_IMAGE_ID, + TMP_HOST_IMAGE_VERSION, + TMP_K8S_CLUSTER_NAME, + TMP_K8S_NODE_NAME, + TMP_K8S_NODE_UID, + TMP_K8S_NAMESPACE_NAME, + TMP_K8S_POD_UID, + TMP_K8S_POD_NAME, + TMP_K8S_CONTAINER_NAME, + TMP_K8S_REPLICASET_UID, + TMP_K8S_REPLICASET_NAME, + TMP_K8S_DEPLOYMENT_UID, + TMP_K8S_DEPLOYMENT_NAME, + TMP_K8S_STATEFULSET_UID, + TMP_K8S_STATEFULSET_NAME, + TMP_K8S_DAEMONSET_UID, + TMP_K8S_DAEMONSET_NAME, + TMP_K8S_JOB_UID, + TMP_K8S_JOB_NAME, + TMP_K8S_CRONJOB_UID, + TMP_K8S_CRONJOB_NAME, + TMP_OS_TYPE, + TMP_OS_DESCRIPTION, + TMP_OS_NAME, + TMP_OS_VERSION, + TMP_PROCESS_PID, + TMP_PROCESS_EXECUTABLE_NAME, + TMP_PROCESS_EXECUTABLE_PATH, + TMP_PROCESS_COMMAND, + TMP_PROCESS_COMMAND_LINE, + TMP_PROCESS_COMMAND_ARGS, + TMP_PROCESS_OWNER, + TMP_PROCESS_RUNTIME_NAME, + TMP_PROCESS_RUNTIME_VERSION, + TMP_PROCESS_RUNTIME_DESCRIPTION, + TMP_SERVICE_NAME, + TMP_SERVICE_NAMESPACE, + TMP_SERVICE_INSTANCE_ID, + TMP_SERVICE_VERSION, + TMP_TELEMETRY_SDK_NAME, + TMP_TELEMETRY_SDK_LANGUAGE, + TMP_TELEMETRY_SDK_VERSION, + TMP_TELEMETRY_AUTO_VERSION, + TMP_WEBENGINE_NAME, + TMP_WEBENGINE_VERSION, + TMP_WEBENGINE_DESCRIPTION + ]); + TMP_CLOUDPROVIDERVALUES_ALIBABA_CLOUD = "alibaba_cloud"; + TMP_CLOUDPROVIDERVALUES_AWS = "aws"; + TMP_CLOUDPROVIDERVALUES_AZURE = "azure"; + TMP_CLOUDPROVIDERVALUES_GCP = "gcp"; + CLOUDPROVIDERVALUES_ALIBABA_CLOUD = TMP_CLOUDPROVIDERVALUES_ALIBABA_CLOUD; + CLOUDPROVIDERVALUES_AWS = TMP_CLOUDPROVIDERVALUES_AWS; + CLOUDPROVIDERVALUES_AZURE = TMP_CLOUDPROVIDERVALUES_AZURE; + CLOUDPROVIDERVALUES_GCP = TMP_CLOUDPROVIDERVALUES_GCP; + CloudProviderValues = /* @__PURE__ */ createConstMap([ + TMP_CLOUDPROVIDERVALUES_ALIBABA_CLOUD, + TMP_CLOUDPROVIDERVALUES_AWS, + TMP_CLOUDPROVIDERVALUES_AZURE, + TMP_CLOUDPROVIDERVALUES_GCP + ]); + TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS = "alibaba_cloud_ecs"; + TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC = "alibaba_cloud_fc"; + TMP_CLOUDPLATFORMVALUES_AWS_EC2 = "aws_ec2"; + TMP_CLOUDPLATFORMVALUES_AWS_ECS = "aws_ecs"; + TMP_CLOUDPLATFORMVALUES_AWS_EKS = "aws_eks"; + TMP_CLOUDPLATFORMVALUES_AWS_LAMBDA = "aws_lambda"; + TMP_CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK = "aws_elastic_beanstalk"; + TMP_CLOUDPLATFORMVALUES_AZURE_VM = "azure_vm"; + TMP_CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES = "azure_container_instances"; + TMP_CLOUDPLATFORMVALUES_AZURE_AKS = "azure_aks"; + TMP_CLOUDPLATFORMVALUES_AZURE_FUNCTIONS = "azure_functions"; + TMP_CLOUDPLATFORMVALUES_AZURE_APP_SERVICE = "azure_app_service"; + TMP_CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE = "gcp_compute_engine"; + TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_RUN = "gcp_cloud_run"; + TMP_CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE = "gcp_kubernetes_engine"; + TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS = "gcp_cloud_functions"; + TMP_CLOUDPLATFORMVALUES_GCP_APP_ENGINE = "gcp_app_engine"; + CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS = TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS; + CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC = TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC; + CLOUDPLATFORMVALUES_AWS_EC2 = TMP_CLOUDPLATFORMVALUES_AWS_EC2; + CLOUDPLATFORMVALUES_AWS_ECS = TMP_CLOUDPLATFORMVALUES_AWS_ECS; + CLOUDPLATFORMVALUES_AWS_EKS = TMP_CLOUDPLATFORMVALUES_AWS_EKS; + CLOUDPLATFORMVALUES_AWS_LAMBDA = TMP_CLOUDPLATFORMVALUES_AWS_LAMBDA; + CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK = TMP_CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK; + CLOUDPLATFORMVALUES_AZURE_VM = TMP_CLOUDPLATFORMVALUES_AZURE_VM; + CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES = TMP_CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES; + CLOUDPLATFORMVALUES_AZURE_AKS = TMP_CLOUDPLATFORMVALUES_AZURE_AKS; + CLOUDPLATFORMVALUES_AZURE_FUNCTIONS = TMP_CLOUDPLATFORMVALUES_AZURE_FUNCTIONS; + CLOUDPLATFORMVALUES_AZURE_APP_SERVICE = TMP_CLOUDPLATFORMVALUES_AZURE_APP_SERVICE; + CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE = TMP_CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE; + CLOUDPLATFORMVALUES_GCP_CLOUD_RUN = TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_RUN; + CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE = TMP_CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE; + CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS = TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS; + CLOUDPLATFORMVALUES_GCP_APP_ENGINE = TMP_CLOUDPLATFORMVALUES_GCP_APP_ENGINE; + CloudPlatformValues = /* @__PURE__ */ createConstMap([ + TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS, + TMP_CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC, + TMP_CLOUDPLATFORMVALUES_AWS_EC2, + TMP_CLOUDPLATFORMVALUES_AWS_ECS, + TMP_CLOUDPLATFORMVALUES_AWS_EKS, + TMP_CLOUDPLATFORMVALUES_AWS_LAMBDA, + TMP_CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK, + TMP_CLOUDPLATFORMVALUES_AZURE_VM, + TMP_CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES, + TMP_CLOUDPLATFORMVALUES_AZURE_AKS, + TMP_CLOUDPLATFORMVALUES_AZURE_FUNCTIONS, + TMP_CLOUDPLATFORMVALUES_AZURE_APP_SERVICE, + TMP_CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE, + TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_RUN, + TMP_CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE, + TMP_CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS, + TMP_CLOUDPLATFORMVALUES_GCP_APP_ENGINE + ]); + TMP_AWSECSLAUNCHTYPEVALUES_EC2 = "ec2"; + TMP_AWSECSLAUNCHTYPEVALUES_FARGATE = "fargate"; + AWSECSLAUNCHTYPEVALUES_EC2 = TMP_AWSECSLAUNCHTYPEVALUES_EC2; + AWSECSLAUNCHTYPEVALUES_FARGATE = TMP_AWSECSLAUNCHTYPEVALUES_FARGATE; + AwsEcsLaunchtypeValues = /* @__PURE__ */ createConstMap([ + TMP_AWSECSLAUNCHTYPEVALUES_EC2, + TMP_AWSECSLAUNCHTYPEVALUES_FARGATE + ]); + TMP_HOSTARCHVALUES_AMD64 = "amd64"; + TMP_HOSTARCHVALUES_ARM32 = "arm32"; + TMP_HOSTARCHVALUES_ARM64 = "arm64"; + TMP_HOSTARCHVALUES_IA64 = "ia64"; + TMP_HOSTARCHVALUES_PPC32 = "ppc32"; + TMP_HOSTARCHVALUES_PPC64 = "ppc64"; + TMP_HOSTARCHVALUES_X86 = "x86"; + HOSTARCHVALUES_AMD64 = TMP_HOSTARCHVALUES_AMD64; + HOSTARCHVALUES_ARM32 = TMP_HOSTARCHVALUES_ARM32; + HOSTARCHVALUES_ARM64 = TMP_HOSTARCHVALUES_ARM64; + HOSTARCHVALUES_IA64 = TMP_HOSTARCHVALUES_IA64; + HOSTARCHVALUES_PPC32 = TMP_HOSTARCHVALUES_PPC32; + HOSTARCHVALUES_PPC64 = TMP_HOSTARCHVALUES_PPC64; + HOSTARCHVALUES_X86 = TMP_HOSTARCHVALUES_X86; + HostArchValues = /* @__PURE__ */ createConstMap([ + TMP_HOSTARCHVALUES_AMD64, + TMP_HOSTARCHVALUES_ARM32, + TMP_HOSTARCHVALUES_ARM64, + TMP_HOSTARCHVALUES_IA64, + TMP_HOSTARCHVALUES_PPC32, + TMP_HOSTARCHVALUES_PPC64, + TMP_HOSTARCHVALUES_X86 + ]); + TMP_OSTYPEVALUES_WINDOWS = "windows"; + TMP_OSTYPEVALUES_LINUX = "linux"; + TMP_OSTYPEVALUES_DARWIN = "darwin"; + TMP_OSTYPEVALUES_FREEBSD = "freebsd"; + TMP_OSTYPEVALUES_NETBSD = "netbsd"; + TMP_OSTYPEVALUES_OPENBSD = "openbsd"; + TMP_OSTYPEVALUES_DRAGONFLYBSD = "dragonflybsd"; + TMP_OSTYPEVALUES_HPUX = "hpux"; + TMP_OSTYPEVALUES_AIX = "aix"; + TMP_OSTYPEVALUES_SOLARIS = "solaris"; + TMP_OSTYPEVALUES_Z_OS = "z_os"; + OSTYPEVALUES_WINDOWS = TMP_OSTYPEVALUES_WINDOWS; + OSTYPEVALUES_LINUX = TMP_OSTYPEVALUES_LINUX; + OSTYPEVALUES_DARWIN = TMP_OSTYPEVALUES_DARWIN; + OSTYPEVALUES_FREEBSD = TMP_OSTYPEVALUES_FREEBSD; + OSTYPEVALUES_NETBSD = TMP_OSTYPEVALUES_NETBSD; + OSTYPEVALUES_OPENBSD = TMP_OSTYPEVALUES_OPENBSD; + OSTYPEVALUES_DRAGONFLYBSD = TMP_OSTYPEVALUES_DRAGONFLYBSD; + OSTYPEVALUES_HPUX = TMP_OSTYPEVALUES_HPUX; + OSTYPEVALUES_AIX = TMP_OSTYPEVALUES_AIX; + OSTYPEVALUES_SOLARIS = TMP_OSTYPEVALUES_SOLARIS; + OSTYPEVALUES_Z_OS = TMP_OSTYPEVALUES_Z_OS; + OsTypeValues = /* @__PURE__ */ createConstMap([ + TMP_OSTYPEVALUES_WINDOWS, + TMP_OSTYPEVALUES_LINUX, + TMP_OSTYPEVALUES_DARWIN, + TMP_OSTYPEVALUES_FREEBSD, + TMP_OSTYPEVALUES_NETBSD, + TMP_OSTYPEVALUES_OPENBSD, + TMP_OSTYPEVALUES_DRAGONFLYBSD, + TMP_OSTYPEVALUES_HPUX, + TMP_OSTYPEVALUES_AIX, + TMP_OSTYPEVALUES_SOLARIS, + TMP_OSTYPEVALUES_Z_OS + ]); + TMP_TELEMETRYSDKLANGUAGEVALUES_CPP = "cpp"; + TMP_TELEMETRYSDKLANGUAGEVALUES_DOTNET = "dotnet"; + TMP_TELEMETRYSDKLANGUAGEVALUES_ERLANG = "erlang"; + TMP_TELEMETRYSDKLANGUAGEVALUES_GO = "go"; + TMP_TELEMETRYSDKLANGUAGEVALUES_JAVA = "java"; + TMP_TELEMETRYSDKLANGUAGEVALUES_NODEJS = "nodejs"; + TMP_TELEMETRYSDKLANGUAGEVALUES_PHP = "php"; + TMP_TELEMETRYSDKLANGUAGEVALUES_PYTHON = "python"; + TMP_TELEMETRYSDKLANGUAGEVALUES_RUBY = "ruby"; + TMP_TELEMETRYSDKLANGUAGEVALUES_WEBJS = "webjs"; + TELEMETRYSDKLANGUAGEVALUES_CPP = TMP_TELEMETRYSDKLANGUAGEVALUES_CPP; + TELEMETRYSDKLANGUAGEVALUES_DOTNET = TMP_TELEMETRYSDKLANGUAGEVALUES_DOTNET; + TELEMETRYSDKLANGUAGEVALUES_ERLANG = TMP_TELEMETRYSDKLANGUAGEVALUES_ERLANG; + TELEMETRYSDKLANGUAGEVALUES_GO = TMP_TELEMETRYSDKLANGUAGEVALUES_GO; + TELEMETRYSDKLANGUAGEVALUES_JAVA = TMP_TELEMETRYSDKLANGUAGEVALUES_JAVA; + TELEMETRYSDKLANGUAGEVALUES_NODEJS = TMP_TELEMETRYSDKLANGUAGEVALUES_NODEJS; + TELEMETRYSDKLANGUAGEVALUES_PHP = TMP_TELEMETRYSDKLANGUAGEVALUES_PHP; + TELEMETRYSDKLANGUAGEVALUES_PYTHON = TMP_TELEMETRYSDKLANGUAGEVALUES_PYTHON; + TELEMETRYSDKLANGUAGEVALUES_RUBY = TMP_TELEMETRYSDKLANGUAGEVALUES_RUBY; + TELEMETRYSDKLANGUAGEVALUES_WEBJS = TMP_TELEMETRYSDKLANGUAGEVALUES_WEBJS; + TelemetrySdkLanguageValues = /* @__PURE__ */ createConstMap([ + TMP_TELEMETRYSDKLANGUAGEVALUES_CPP, + TMP_TELEMETRYSDKLANGUAGEVALUES_DOTNET, + TMP_TELEMETRYSDKLANGUAGEVALUES_ERLANG, + TMP_TELEMETRYSDKLANGUAGEVALUES_GO, + TMP_TELEMETRYSDKLANGUAGEVALUES_JAVA, + TMP_TELEMETRYSDKLANGUAGEVALUES_NODEJS, + TMP_TELEMETRYSDKLANGUAGEVALUES_PHP, + TMP_TELEMETRYSDKLANGUAGEVALUES_PYTHON, + TMP_TELEMETRYSDKLANGUAGEVALUES_RUBY, + TMP_TELEMETRYSDKLANGUAGEVALUES_WEBJS + ]); + } +}); + +// node_modules/@opentelemetry/semantic-conventions/build/esm/resource/index.js +var init_resource = __esm({ + "node_modules/@opentelemetry/semantic-conventions/build/esm/resource/index.js"() { + init_SemanticResourceAttributes(); + } +}); + +// node_modules/@opentelemetry/semantic-conventions/build/esm/stable_attributes.js +var ATTR_ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT, ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_ABORTED, ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_HANDLED, ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_SKIPPED, ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_UNHANDLED, ATTR_ASPNETCORE_DIAGNOSTICS_HANDLER_TYPE, ATTR_ASPNETCORE_RATE_LIMITING_POLICY, ATTR_ASPNETCORE_RATE_LIMITING_RESULT, ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ACQUIRED, ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ENDPOINT_LIMITER, ASPNETCORE_RATE_LIMITING_RESULT_VALUE_GLOBAL_LIMITER, ASPNETCORE_RATE_LIMITING_RESULT_VALUE_REQUEST_CANCELED, ATTR_ASPNETCORE_REQUEST_IS_UNHANDLED, ATTR_ASPNETCORE_ROUTING_IS_FALLBACK, ATTR_ASPNETCORE_ROUTING_MATCH_STATUS, ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_FAILURE, ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_SUCCESS, ATTR_ASPNETCORE_USER_IS_AUTHENTICATED, ATTR_CLIENT_ADDRESS, ATTR_CLIENT_PORT, ATTR_CODE_COLUMN_NUMBER, ATTR_CODE_FILE_PATH, ATTR_CODE_FUNCTION_NAME, ATTR_CODE_LINE_NUMBER, ATTR_CODE_STACKTRACE, ATTR_CONTAINER_ID, ATTR_CONTAINER_IMAGE_NAME, ATTR_CONTAINER_IMAGE_REPO_DIGESTS, ATTR_CONTAINER_IMAGE_TAGS, ATTR_DB_COLLECTION_NAME, ATTR_DB_NAMESPACE, ATTR_DB_OPERATION_BATCH_SIZE, ATTR_DB_OPERATION_NAME, ATTR_DB_QUERY_SUMMARY, ATTR_DB_QUERY_TEXT, ATTR_DB_RESPONSE_STATUS_CODE, ATTR_DB_STORED_PROCEDURE_NAME, ATTR_DB_SYSTEM_NAME, DB_SYSTEM_NAME_VALUE_MARIADB, DB_SYSTEM_NAME_VALUE_MICROSOFT_SQL_SERVER, DB_SYSTEM_NAME_VALUE_MYSQL, DB_SYSTEM_NAME_VALUE_POSTGRESQL, ATTR_DEPLOYMENT_ENVIRONMENT_NAME, DEPLOYMENT_ENVIRONMENT_NAME_VALUE_DEVELOPMENT, DEPLOYMENT_ENVIRONMENT_NAME_VALUE_PRODUCTION, DEPLOYMENT_ENVIRONMENT_NAME_VALUE_STAGING, DEPLOYMENT_ENVIRONMENT_NAME_VALUE_TEST, ATTR_DOTNET_GC_HEAP_GENERATION, DOTNET_GC_HEAP_GENERATION_VALUE_GEN0, DOTNET_GC_HEAP_GENERATION_VALUE_GEN1, DOTNET_GC_HEAP_GENERATION_VALUE_GEN2, DOTNET_GC_HEAP_GENERATION_VALUE_LOH, DOTNET_GC_HEAP_GENERATION_VALUE_POH, ATTR_ERROR_TYPE, ERROR_TYPE_VALUE_OTHER, ATTR_EXCEPTION_ESCAPED, ATTR_EXCEPTION_MESSAGE, ATTR_EXCEPTION_STACKTRACE, ATTR_EXCEPTION_TYPE, ATTR_HTTP_REQUEST_HEADER, ATTR_HTTP_REQUEST_METHOD, HTTP_REQUEST_METHOD_VALUE_OTHER, HTTP_REQUEST_METHOD_VALUE_CONNECT, HTTP_REQUEST_METHOD_VALUE_DELETE, HTTP_REQUEST_METHOD_VALUE_GET, HTTP_REQUEST_METHOD_VALUE_HEAD, HTTP_REQUEST_METHOD_VALUE_OPTIONS, HTTP_REQUEST_METHOD_VALUE_PATCH, HTTP_REQUEST_METHOD_VALUE_POST, HTTP_REQUEST_METHOD_VALUE_PUT, HTTP_REQUEST_METHOD_VALUE_TRACE, ATTR_HTTP_REQUEST_METHOD_ORIGINAL, ATTR_HTTP_REQUEST_RESEND_COUNT, ATTR_HTTP_RESPONSE_HEADER, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_HTTP_ROUTE, ATTR_JVM_GC_ACTION, ATTR_JVM_GC_NAME, ATTR_JVM_MEMORY_POOL_NAME, ATTR_JVM_MEMORY_TYPE, JVM_MEMORY_TYPE_VALUE_HEAP, JVM_MEMORY_TYPE_VALUE_NON_HEAP, ATTR_JVM_THREAD_DAEMON, ATTR_JVM_THREAD_STATE, JVM_THREAD_STATE_VALUE_BLOCKED, JVM_THREAD_STATE_VALUE_NEW, JVM_THREAD_STATE_VALUE_RUNNABLE, JVM_THREAD_STATE_VALUE_TERMINATED, JVM_THREAD_STATE_VALUE_TIMED_WAITING, JVM_THREAD_STATE_VALUE_WAITING, ATTR_K8S_CLUSTER_NAME, ATTR_K8S_CLUSTER_UID, ATTR_K8S_CONTAINER_NAME, ATTR_K8S_CONTAINER_RESTART_COUNT, ATTR_K8S_CRONJOB_ANNOTATION, ATTR_K8S_CRONJOB_LABEL, ATTR_K8S_CRONJOB_NAME, ATTR_K8S_CRONJOB_UID, ATTR_K8S_DAEMONSET_ANNOTATION, ATTR_K8S_DAEMONSET_LABEL, ATTR_K8S_DAEMONSET_NAME, ATTR_K8S_DAEMONSET_UID, ATTR_K8S_DEPLOYMENT_ANNOTATION, ATTR_K8S_DEPLOYMENT_LABEL, ATTR_K8S_DEPLOYMENT_NAME, ATTR_K8S_DEPLOYMENT_UID, ATTR_K8S_JOB_ANNOTATION, ATTR_K8S_JOB_LABEL, ATTR_K8S_JOB_NAME, ATTR_K8S_JOB_UID, ATTR_K8S_NAMESPACE_ANNOTATION, ATTR_K8S_NAMESPACE_LABEL, ATTR_K8S_NAMESPACE_NAME, ATTR_K8S_NODE_ANNOTATION, ATTR_K8S_NODE_LABEL, ATTR_K8S_NODE_NAME, ATTR_K8S_NODE_UID, ATTR_K8S_POD_ANNOTATION, ATTR_K8S_POD_HOSTNAME, ATTR_K8S_POD_IP, ATTR_K8S_POD_LABEL, ATTR_K8S_POD_NAME, ATTR_K8S_POD_START_TIME, ATTR_K8S_POD_UID, ATTR_K8S_REPLICASET_ANNOTATION, ATTR_K8S_REPLICASET_LABEL, ATTR_K8S_REPLICASET_NAME, ATTR_K8S_REPLICASET_UID, ATTR_K8S_STATEFULSET_ANNOTATION, ATTR_K8S_STATEFULSET_LABEL, ATTR_K8S_STATEFULSET_NAME, ATTR_K8S_STATEFULSET_UID, ATTR_NETWORK_LOCAL_ADDRESS, ATTR_NETWORK_LOCAL_PORT, ATTR_NETWORK_PEER_ADDRESS, ATTR_NETWORK_PEER_PORT, ATTR_NETWORK_PROTOCOL_NAME, ATTR_NETWORK_PROTOCOL_VERSION, ATTR_NETWORK_TRANSPORT, NETWORK_TRANSPORT_VALUE_PIPE, NETWORK_TRANSPORT_VALUE_QUIC, NETWORK_TRANSPORT_VALUE_TCP, NETWORK_TRANSPORT_VALUE_UDP, NETWORK_TRANSPORT_VALUE_UNIX, ATTR_NETWORK_TYPE, NETWORK_TYPE_VALUE_IPV4, NETWORK_TYPE_VALUE_IPV6, ATTR_OTEL_EVENT_NAME, ATTR_OTEL_SCOPE_NAME, ATTR_OTEL_SCOPE_VERSION, ATTR_OTEL_STATUS_CODE, OTEL_STATUS_CODE_VALUE_ERROR, OTEL_STATUS_CODE_VALUE_OK, ATTR_OTEL_STATUS_DESCRIPTION, ATTR_SERVER_ADDRESS, ATTR_SERVER_PORT, ATTR_SERVICE_INSTANCE_ID, ATTR_SERVICE_NAME, ATTR_SERVICE_NAMESPACE, ATTR_SERVICE_VERSION, ATTR_SIGNALR_CONNECTION_STATUS, SIGNALR_CONNECTION_STATUS_VALUE_APP_SHUTDOWN, SIGNALR_CONNECTION_STATUS_VALUE_NORMAL_CLOSURE, SIGNALR_CONNECTION_STATUS_VALUE_TIMEOUT, ATTR_SIGNALR_TRANSPORT, SIGNALR_TRANSPORT_VALUE_LONG_POLLING, SIGNALR_TRANSPORT_VALUE_SERVER_SENT_EVENTS, SIGNALR_TRANSPORT_VALUE_WEB_SOCKETS, ATTR_TELEMETRY_DISTRO_NAME, ATTR_TELEMETRY_DISTRO_VERSION, ATTR_TELEMETRY_SDK_LANGUAGE, TELEMETRY_SDK_LANGUAGE_VALUE_CPP, TELEMETRY_SDK_LANGUAGE_VALUE_DOTNET, TELEMETRY_SDK_LANGUAGE_VALUE_ERLANG, TELEMETRY_SDK_LANGUAGE_VALUE_GO, TELEMETRY_SDK_LANGUAGE_VALUE_JAVA, TELEMETRY_SDK_LANGUAGE_VALUE_KOTLIN, TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS, TELEMETRY_SDK_LANGUAGE_VALUE_PHP, TELEMETRY_SDK_LANGUAGE_VALUE_PYTHON, TELEMETRY_SDK_LANGUAGE_VALUE_RUBY, TELEMETRY_SDK_LANGUAGE_VALUE_RUST, TELEMETRY_SDK_LANGUAGE_VALUE_SWIFT, TELEMETRY_SDK_LANGUAGE_VALUE_WEBJS, ATTR_TELEMETRY_SDK_NAME, ATTR_TELEMETRY_SDK_VERSION, ATTR_URL_FRAGMENT, ATTR_URL_FULL, ATTR_URL_PATH, ATTR_URL_QUERY, ATTR_URL_SCHEME, ATTR_USER_AGENT_ORIGINAL; +var init_stable_attributes = __esm({ + "node_modules/@opentelemetry/semantic-conventions/build/esm/stable_attributes.js"() { + ATTR_ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT = "aspnetcore.diagnostics.exception.result"; + ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_ABORTED = "aborted"; + ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_HANDLED = "handled"; + ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_SKIPPED = "skipped"; + ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_UNHANDLED = "unhandled"; + ATTR_ASPNETCORE_DIAGNOSTICS_HANDLER_TYPE = "aspnetcore.diagnostics.handler.type"; + ATTR_ASPNETCORE_RATE_LIMITING_POLICY = "aspnetcore.rate_limiting.policy"; + ATTR_ASPNETCORE_RATE_LIMITING_RESULT = "aspnetcore.rate_limiting.result"; + ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ACQUIRED = "acquired"; + ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ENDPOINT_LIMITER = "endpoint_limiter"; + ASPNETCORE_RATE_LIMITING_RESULT_VALUE_GLOBAL_LIMITER = "global_limiter"; + ASPNETCORE_RATE_LIMITING_RESULT_VALUE_REQUEST_CANCELED = "request_canceled"; + ATTR_ASPNETCORE_REQUEST_IS_UNHANDLED = "aspnetcore.request.is_unhandled"; + ATTR_ASPNETCORE_ROUTING_IS_FALLBACK = "aspnetcore.routing.is_fallback"; + ATTR_ASPNETCORE_ROUTING_MATCH_STATUS = "aspnetcore.routing.match_status"; + ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_FAILURE = "failure"; + ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_SUCCESS = "success"; + ATTR_ASPNETCORE_USER_IS_AUTHENTICATED = "aspnetcore.user.is_authenticated"; + ATTR_CLIENT_ADDRESS = "client.address"; + ATTR_CLIENT_PORT = "client.port"; + ATTR_CODE_COLUMN_NUMBER = "code.column.number"; + ATTR_CODE_FILE_PATH = "code.file.path"; + ATTR_CODE_FUNCTION_NAME = "code.function.name"; + ATTR_CODE_LINE_NUMBER = "code.line.number"; + ATTR_CODE_STACKTRACE = "code.stacktrace"; + ATTR_CONTAINER_ID = "container.id"; + ATTR_CONTAINER_IMAGE_NAME = "container.image.name"; + ATTR_CONTAINER_IMAGE_REPO_DIGESTS = "container.image.repo_digests"; + ATTR_CONTAINER_IMAGE_TAGS = "container.image.tags"; + ATTR_DB_COLLECTION_NAME = "db.collection.name"; + ATTR_DB_NAMESPACE = "db.namespace"; + ATTR_DB_OPERATION_BATCH_SIZE = "db.operation.batch.size"; + ATTR_DB_OPERATION_NAME = "db.operation.name"; + ATTR_DB_QUERY_SUMMARY = "db.query.summary"; + ATTR_DB_QUERY_TEXT = "db.query.text"; + ATTR_DB_RESPONSE_STATUS_CODE = "db.response.status_code"; + ATTR_DB_STORED_PROCEDURE_NAME = "db.stored_procedure.name"; + ATTR_DB_SYSTEM_NAME = "db.system.name"; + DB_SYSTEM_NAME_VALUE_MARIADB = "mariadb"; + DB_SYSTEM_NAME_VALUE_MICROSOFT_SQL_SERVER = "microsoft.sql_server"; + DB_SYSTEM_NAME_VALUE_MYSQL = "mysql"; + DB_SYSTEM_NAME_VALUE_POSTGRESQL = "postgresql"; + ATTR_DEPLOYMENT_ENVIRONMENT_NAME = "deployment.environment.name"; + DEPLOYMENT_ENVIRONMENT_NAME_VALUE_DEVELOPMENT = "development"; + DEPLOYMENT_ENVIRONMENT_NAME_VALUE_PRODUCTION = "production"; + DEPLOYMENT_ENVIRONMENT_NAME_VALUE_STAGING = "staging"; + DEPLOYMENT_ENVIRONMENT_NAME_VALUE_TEST = "test"; + ATTR_DOTNET_GC_HEAP_GENERATION = "dotnet.gc.heap.generation"; + DOTNET_GC_HEAP_GENERATION_VALUE_GEN0 = "gen0"; + DOTNET_GC_HEAP_GENERATION_VALUE_GEN1 = "gen1"; + DOTNET_GC_HEAP_GENERATION_VALUE_GEN2 = "gen2"; + DOTNET_GC_HEAP_GENERATION_VALUE_LOH = "loh"; + DOTNET_GC_HEAP_GENERATION_VALUE_POH = "poh"; + ATTR_ERROR_TYPE = "error.type"; + ERROR_TYPE_VALUE_OTHER = "_OTHER"; + ATTR_EXCEPTION_ESCAPED = "exception.escaped"; + ATTR_EXCEPTION_MESSAGE = "exception.message"; + ATTR_EXCEPTION_STACKTRACE = "exception.stacktrace"; + ATTR_EXCEPTION_TYPE = "exception.type"; + ATTR_HTTP_REQUEST_HEADER = (key) => `http.request.header.${key}`; + ATTR_HTTP_REQUEST_METHOD = "http.request.method"; + HTTP_REQUEST_METHOD_VALUE_OTHER = "_OTHER"; + HTTP_REQUEST_METHOD_VALUE_CONNECT = "CONNECT"; + HTTP_REQUEST_METHOD_VALUE_DELETE = "DELETE"; + HTTP_REQUEST_METHOD_VALUE_GET = "GET"; + HTTP_REQUEST_METHOD_VALUE_HEAD = "HEAD"; + HTTP_REQUEST_METHOD_VALUE_OPTIONS = "OPTIONS"; + HTTP_REQUEST_METHOD_VALUE_PATCH = "PATCH"; + HTTP_REQUEST_METHOD_VALUE_POST = "POST"; + HTTP_REQUEST_METHOD_VALUE_PUT = "PUT"; + HTTP_REQUEST_METHOD_VALUE_TRACE = "TRACE"; + ATTR_HTTP_REQUEST_METHOD_ORIGINAL = "http.request.method_original"; + ATTR_HTTP_REQUEST_RESEND_COUNT = "http.request.resend_count"; + ATTR_HTTP_RESPONSE_HEADER = (key) => `http.response.header.${key}`; + ATTR_HTTP_RESPONSE_STATUS_CODE = "http.response.status_code"; + ATTR_HTTP_ROUTE = "http.route"; + ATTR_JVM_GC_ACTION = "jvm.gc.action"; + ATTR_JVM_GC_NAME = "jvm.gc.name"; + ATTR_JVM_MEMORY_POOL_NAME = "jvm.memory.pool.name"; + ATTR_JVM_MEMORY_TYPE = "jvm.memory.type"; + JVM_MEMORY_TYPE_VALUE_HEAP = "heap"; + JVM_MEMORY_TYPE_VALUE_NON_HEAP = "non_heap"; + ATTR_JVM_THREAD_DAEMON = "jvm.thread.daemon"; + ATTR_JVM_THREAD_STATE = "jvm.thread.state"; + JVM_THREAD_STATE_VALUE_BLOCKED = "blocked"; + JVM_THREAD_STATE_VALUE_NEW = "new"; + JVM_THREAD_STATE_VALUE_RUNNABLE = "runnable"; + JVM_THREAD_STATE_VALUE_TERMINATED = "terminated"; + JVM_THREAD_STATE_VALUE_TIMED_WAITING = "timed_waiting"; + JVM_THREAD_STATE_VALUE_WAITING = "waiting"; + ATTR_K8S_CLUSTER_NAME = "k8s.cluster.name"; + ATTR_K8S_CLUSTER_UID = "k8s.cluster.uid"; + ATTR_K8S_CONTAINER_NAME = "k8s.container.name"; + ATTR_K8S_CONTAINER_RESTART_COUNT = "k8s.container.restart_count"; + ATTR_K8S_CRONJOB_ANNOTATION = (key) => `k8s.cronjob.annotation.${key}`; + ATTR_K8S_CRONJOB_LABEL = (key) => `k8s.cronjob.label.${key}`; + ATTR_K8S_CRONJOB_NAME = "k8s.cronjob.name"; + ATTR_K8S_CRONJOB_UID = "k8s.cronjob.uid"; + ATTR_K8S_DAEMONSET_ANNOTATION = (key) => `k8s.daemonset.annotation.${key}`; + ATTR_K8S_DAEMONSET_LABEL = (key) => `k8s.daemonset.label.${key}`; + ATTR_K8S_DAEMONSET_NAME = "k8s.daemonset.name"; + ATTR_K8S_DAEMONSET_UID = "k8s.daemonset.uid"; + ATTR_K8S_DEPLOYMENT_ANNOTATION = (key) => `k8s.deployment.annotation.${key}`; + ATTR_K8S_DEPLOYMENT_LABEL = (key) => `k8s.deployment.label.${key}`; + ATTR_K8S_DEPLOYMENT_NAME = "k8s.deployment.name"; + ATTR_K8S_DEPLOYMENT_UID = "k8s.deployment.uid"; + ATTR_K8S_JOB_ANNOTATION = (key) => `k8s.job.annotation.${key}`; + ATTR_K8S_JOB_LABEL = (key) => `k8s.job.label.${key}`; + ATTR_K8S_JOB_NAME = "k8s.job.name"; + ATTR_K8S_JOB_UID = "k8s.job.uid"; + ATTR_K8S_NAMESPACE_ANNOTATION = (key) => `k8s.namespace.annotation.${key}`; + ATTR_K8S_NAMESPACE_LABEL = (key) => `k8s.namespace.label.${key}`; + ATTR_K8S_NAMESPACE_NAME = "k8s.namespace.name"; + ATTR_K8S_NODE_ANNOTATION = (key) => `k8s.node.annotation.${key}`; + ATTR_K8S_NODE_LABEL = (key) => `k8s.node.label.${key}`; + ATTR_K8S_NODE_NAME = "k8s.node.name"; + ATTR_K8S_NODE_UID = "k8s.node.uid"; + ATTR_K8S_POD_ANNOTATION = (key) => `k8s.pod.annotation.${key}`; + ATTR_K8S_POD_HOSTNAME = "k8s.pod.hostname"; + ATTR_K8S_POD_IP = "k8s.pod.ip"; + ATTR_K8S_POD_LABEL = (key) => `k8s.pod.label.${key}`; + ATTR_K8S_POD_NAME = "k8s.pod.name"; + ATTR_K8S_POD_START_TIME = "k8s.pod.start_time"; + ATTR_K8S_POD_UID = "k8s.pod.uid"; + ATTR_K8S_REPLICASET_ANNOTATION = (key) => `k8s.replicaset.annotation.${key}`; + ATTR_K8S_REPLICASET_LABEL = (key) => `k8s.replicaset.label.${key}`; + ATTR_K8S_REPLICASET_NAME = "k8s.replicaset.name"; + ATTR_K8S_REPLICASET_UID = "k8s.replicaset.uid"; + ATTR_K8S_STATEFULSET_ANNOTATION = (key) => `k8s.statefulset.annotation.${key}`; + ATTR_K8S_STATEFULSET_LABEL = (key) => `k8s.statefulset.label.${key}`; + ATTR_K8S_STATEFULSET_NAME = "k8s.statefulset.name"; + ATTR_K8S_STATEFULSET_UID = "k8s.statefulset.uid"; + ATTR_NETWORK_LOCAL_ADDRESS = "network.local.address"; + ATTR_NETWORK_LOCAL_PORT = "network.local.port"; + ATTR_NETWORK_PEER_ADDRESS = "network.peer.address"; + ATTR_NETWORK_PEER_PORT = "network.peer.port"; + ATTR_NETWORK_PROTOCOL_NAME = "network.protocol.name"; + ATTR_NETWORK_PROTOCOL_VERSION = "network.protocol.version"; + ATTR_NETWORK_TRANSPORT = "network.transport"; + NETWORK_TRANSPORT_VALUE_PIPE = "pipe"; + NETWORK_TRANSPORT_VALUE_QUIC = "quic"; + NETWORK_TRANSPORT_VALUE_TCP = "tcp"; + NETWORK_TRANSPORT_VALUE_UDP = "udp"; + NETWORK_TRANSPORT_VALUE_UNIX = "unix"; + ATTR_NETWORK_TYPE = "network.type"; + NETWORK_TYPE_VALUE_IPV4 = "ipv4"; + NETWORK_TYPE_VALUE_IPV6 = "ipv6"; + ATTR_OTEL_EVENT_NAME = "otel.event.name"; + ATTR_OTEL_SCOPE_NAME = "otel.scope.name"; + ATTR_OTEL_SCOPE_VERSION = "otel.scope.version"; + ATTR_OTEL_STATUS_CODE = "otel.status_code"; + OTEL_STATUS_CODE_VALUE_ERROR = "ERROR"; + OTEL_STATUS_CODE_VALUE_OK = "OK"; + ATTR_OTEL_STATUS_DESCRIPTION = "otel.status_description"; + ATTR_SERVER_ADDRESS = "server.address"; + ATTR_SERVER_PORT = "server.port"; + ATTR_SERVICE_INSTANCE_ID = "service.instance.id"; + ATTR_SERVICE_NAME = "service.name"; + ATTR_SERVICE_NAMESPACE = "service.namespace"; + ATTR_SERVICE_VERSION = "service.version"; + ATTR_SIGNALR_CONNECTION_STATUS = "signalr.connection.status"; + SIGNALR_CONNECTION_STATUS_VALUE_APP_SHUTDOWN = "app_shutdown"; + SIGNALR_CONNECTION_STATUS_VALUE_NORMAL_CLOSURE = "normal_closure"; + SIGNALR_CONNECTION_STATUS_VALUE_TIMEOUT = "timeout"; + ATTR_SIGNALR_TRANSPORT = "signalr.transport"; + SIGNALR_TRANSPORT_VALUE_LONG_POLLING = "long_polling"; + SIGNALR_TRANSPORT_VALUE_SERVER_SENT_EVENTS = "server_sent_events"; + SIGNALR_TRANSPORT_VALUE_WEB_SOCKETS = "web_sockets"; + ATTR_TELEMETRY_DISTRO_NAME = "telemetry.distro.name"; + ATTR_TELEMETRY_DISTRO_VERSION = "telemetry.distro.version"; + ATTR_TELEMETRY_SDK_LANGUAGE = "telemetry.sdk.language"; + TELEMETRY_SDK_LANGUAGE_VALUE_CPP = "cpp"; + TELEMETRY_SDK_LANGUAGE_VALUE_DOTNET = "dotnet"; + TELEMETRY_SDK_LANGUAGE_VALUE_ERLANG = "erlang"; + TELEMETRY_SDK_LANGUAGE_VALUE_GO = "go"; + TELEMETRY_SDK_LANGUAGE_VALUE_JAVA = "java"; + TELEMETRY_SDK_LANGUAGE_VALUE_KOTLIN = "kotlin"; + TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS = "nodejs"; + TELEMETRY_SDK_LANGUAGE_VALUE_PHP = "php"; + TELEMETRY_SDK_LANGUAGE_VALUE_PYTHON = "python"; + TELEMETRY_SDK_LANGUAGE_VALUE_RUBY = "ruby"; + TELEMETRY_SDK_LANGUAGE_VALUE_RUST = "rust"; + TELEMETRY_SDK_LANGUAGE_VALUE_SWIFT = "swift"; + TELEMETRY_SDK_LANGUAGE_VALUE_WEBJS = "webjs"; + ATTR_TELEMETRY_SDK_NAME = "telemetry.sdk.name"; + ATTR_TELEMETRY_SDK_VERSION = "telemetry.sdk.version"; + ATTR_URL_FRAGMENT = "url.fragment"; + ATTR_URL_FULL = "url.full"; + ATTR_URL_PATH = "url.path"; + ATTR_URL_QUERY = "url.query"; + ATTR_URL_SCHEME = "url.scheme"; + ATTR_USER_AGENT_ORIGINAL = "user_agent.original"; + } +}); + +// node_modules/@opentelemetry/semantic-conventions/build/esm/stable_metrics.js +var METRIC_ASPNETCORE_DIAGNOSTICS_EXCEPTIONS, METRIC_ASPNETCORE_RATE_LIMITING_ACTIVE_REQUEST_LEASES, METRIC_ASPNETCORE_RATE_LIMITING_QUEUED_REQUESTS, METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_TIME_IN_QUEUE, METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_LEASE_DURATION, METRIC_ASPNETCORE_RATE_LIMITING_REQUESTS, METRIC_ASPNETCORE_ROUTING_MATCH_ATTEMPTS, METRIC_DB_CLIENT_OPERATION_DURATION, METRIC_DOTNET_ASSEMBLY_COUNT, METRIC_DOTNET_EXCEPTIONS, METRIC_DOTNET_GC_COLLECTIONS, METRIC_DOTNET_GC_HEAP_TOTAL_ALLOCATED, METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_FRAGMENTATION_SIZE, METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_SIZE, METRIC_DOTNET_GC_LAST_COLLECTION_MEMORY_COMMITTED_SIZE, METRIC_DOTNET_GC_PAUSE_TIME, METRIC_DOTNET_JIT_COMPILATION_TIME, METRIC_DOTNET_JIT_COMPILED_IL_SIZE, METRIC_DOTNET_JIT_COMPILED_METHODS, METRIC_DOTNET_MONITOR_LOCK_CONTENTIONS, METRIC_DOTNET_PROCESS_CPU_COUNT, METRIC_DOTNET_PROCESS_CPU_TIME, METRIC_DOTNET_PROCESS_MEMORY_WORKING_SET, METRIC_DOTNET_THREAD_POOL_QUEUE_LENGTH, METRIC_DOTNET_THREAD_POOL_THREAD_COUNT, METRIC_DOTNET_THREAD_POOL_WORK_ITEM_COUNT, METRIC_DOTNET_TIMER_COUNT, METRIC_HTTP_CLIENT_REQUEST_DURATION, METRIC_HTTP_SERVER_REQUEST_DURATION, METRIC_JVM_CLASS_COUNT, METRIC_JVM_CLASS_LOADED, METRIC_JVM_CLASS_UNLOADED, METRIC_JVM_CPU_COUNT, METRIC_JVM_CPU_RECENT_UTILIZATION, METRIC_JVM_CPU_TIME, METRIC_JVM_GC_DURATION, METRIC_JVM_MEMORY_COMMITTED, METRIC_JVM_MEMORY_LIMIT, METRIC_JVM_MEMORY_USED, METRIC_JVM_MEMORY_USED_AFTER_LAST_GC, METRIC_JVM_THREAD_COUNT, METRIC_KESTREL_ACTIVE_CONNECTIONS, METRIC_KESTREL_ACTIVE_TLS_HANDSHAKES, METRIC_KESTREL_CONNECTION_DURATION, METRIC_KESTREL_QUEUED_CONNECTIONS, METRIC_KESTREL_QUEUED_REQUESTS, METRIC_KESTREL_REJECTED_CONNECTIONS, METRIC_KESTREL_TLS_HANDSHAKE_DURATION, METRIC_KESTREL_UPGRADED_CONNECTIONS, METRIC_SIGNALR_SERVER_ACTIVE_CONNECTIONS, METRIC_SIGNALR_SERVER_CONNECTION_DURATION; +var init_stable_metrics = __esm({ + "node_modules/@opentelemetry/semantic-conventions/build/esm/stable_metrics.js"() { + METRIC_ASPNETCORE_DIAGNOSTICS_EXCEPTIONS = "aspnetcore.diagnostics.exceptions"; + METRIC_ASPNETCORE_RATE_LIMITING_ACTIVE_REQUEST_LEASES = "aspnetcore.rate_limiting.active_request_leases"; + METRIC_ASPNETCORE_RATE_LIMITING_QUEUED_REQUESTS = "aspnetcore.rate_limiting.queued_requests"; + METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_TIME_IN_QUEUE = "aspnetcore.rate_limiting.request.time_in_queue"; + METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_LEASE_DURATION = "aspnetcore.rate_limiting.request_lease.duration"; + METRIC_ASPNETCORE_RATE_LIMITING_REQUESTS = "aspnetcore.rate_limiting.requests"; + METRIC_ASPNETCORE_ROUTING_MATCH_ATTEMPTS = "aspnetcore.routing.match_attempts"; + METRIC_DB_CLIENT_OPERATION_DURATION = "db.client.operation.duration"; + METRIC_DOTNET_ASSEMBLY_COUNT = "dotnet.assembly.count"; + METRIC_DOTNET_EXCEPTIONS = "dotnet.exceptions"; + METRIC_DOTNET_GC_COLLECTIONS = "dotnet.gc.collections"; + METRIC_DOTNET_GC_HEAP_TOTAL_ALLOCATED = "dotnet.gc.heap.total_allocated"; + METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_FRAGMENTATION_SIZE = "dotnet.gc.last_collection.heap.fragmentation.size"; + METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_SIZE = "dotnet.gc.last_collection.heap.size"; + METRIC_DOTNET_GC_LAST_COLLECTION_MEMORY_COMMITTED_SIZE = "dotnet.gc.last_collection.memory.committed_size"; + METRIC_DOTNET_GC_PAUSE_TIME = "dotnet.gc.pause.time"; + METRIC_DOTNET_JIT_COMPILATION_TIME = "dotnet.jit.compilation.time"; + METRIC_DOTNET_JIT_COMPILED_IL_SIZE = "dotnet.jit.compiled_il.size"; + METRIC_DOTNET_JIT_COMPILED_METHODS = "dotnet.jit.compiled_methods"; + METRIC_DOTNET_MONITOR_LOCK_CONTENTIONS = "dotnet.monitor.lock_contentions"; + METRIC_DOTNET_PROCESS_CPU_COUNT = "dotnet.process.cpu.count"; + METRIC_DOTNET_PROCESS_CPU_TIME = "dotnet.process.cpu.time"; + METRIC_DOTNET_PROCESS_MEMORY_WORKING_SET = "dotnet.process.memory.working_set"; + METRIC_DOTNET_THREAD_POOL_QUEUE_LENGTH = "dotnet.thread_pool.queue.length"; + METRIC_DOTNET_THREAD_POOL_THREAD_COUNT = "dotnet.thread_pool.thread.count"; + METRIC_DOTNET_THREAD_POOL_WORK_ITEM_COUNT = "dotnet.thread_pool.work_item.count"; + METRIC_DOTNET_TIMER_COUNT = "dotnet.timer.count"; + METRIC_HTTP_CLIENT_REQUEST_DURATION = "http.client.request.duration"; + METRIC_HTTP_SERVER_REQUEST_DURATION = "http.server.request.duration"; + METRIC_JVM_CLASS_COUNT = "jvm.class.count"; + METRIC_JVM_CLASS_LOADED = "jvm.class.loaded"; + METRIC_JVM_CLASS_UNLOADED = "jvm.class.unloaded"; + METRIC_JVM_CPU_COUNT = "jvm.cpu.count"; + METRIC_JVM_CPU_RECENT_UTILIZATION = "jvm.cpu.recent_utilization"; + METRIC_JVM_CPU_TIME = "jvm.cpu.time"; + METRIC_JVM_GC_DURATION = "jvm.gc.duration"; + METRIC_JVM_MEMORY_COMMITTED = "jvm.memory.committed"; + METRIC_JVM_MEMORY_LIMIT = "jvm.memory.limit"; + METRIC_JVM_MEMORY_USED = "jvm.memory.used"; + METRIC_JVM_MEMORY_USED_AFTER_LAST_GC = "jvm.memory.used_after_last_gc"; + METRIC_JVM_THREAD_COUNT = "jvm.thread.count"; + METRIC_KESTREL_ACTIVE_CONNECTIONS = "kestrel.active_connections"; + METRIC_KESTREL_ACTIVE_TLS_HANDSHAKES = "kestrel.active_tls_handshakes"; + METRIC_KESTREL_CONNECTION_DURATION = "kestrel.connection.duration"; + METRIC_KESTREL_QUEUED_CONNECTIONS = "kestrel.queued_connections"; + METRIC_KESTREL_QUEUED_REQUESTS = "kestrel.queued_requests"; + METRIC_KESTREL_REJECTED_CONNECTIONS = "kestrel.rejected_connections"; + METRIC_KESTREL_TLS_HANDSHAKE_DURATION = "kestrel.tls_handshake.duration"; + METRIC_KESTREL_UPGRADED_CONNECTIONS = "kestrel.upgraded_connections"; + METRIC_SIGNALR_SERVER_ACTIVE_CONNECTIONS = "signalr.server.active_connections"; + METRIC_SIGNALR_SERVER_CONNECTION_DURATION = "signalr.server.connection.duration"; + } +}); + +// node_modules/@opentelemetry/semantic-conventions/build/esm/stable_events.js +var EVENT_EXCEPTION; +var init_stable_events = __esm({ + "node_modules/@opentelemetry/semantic-conventions/build/esm/stable_events.js"() { + EVENT_EXCEPTION = "exception"; + } +}); + +// node_modules/@opentelemetry/semantic-conventions/build/esm/index.js +var esm_exports2 = {}; +__export(esm_exports2, { + ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_ABORTED: () => ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_ABORTED, + ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_HANDLED: () => ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_HANDLED, + ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_SKIPPED: () => ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_SKIPPED, + ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_UNHANDLED: () => ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT_VALUE_UNHANDLED, + ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ACQUIRED: () => ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ACQUIRED, + ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ENDPOINT_LIMITER: () => ASPNETCORE_RATE_LIMITING_RESULT_VALUE_ENDPOINT_LIMITER, + ASPNETCORE_RATE_LIMITING_RESULT_VALUE_GLOBAL_LIMITER: () => ASPNETCORE_RATE_LIMITING_RESULT_VALUE_GLOBAL_LIMITER, + ASPNETCORE_RATE_LIMITING_RESULT_VALUE_REQUEST_CANCELED: () => ASPNETCORE_RATE_LIMITING_RESULT_VALUE_REQUEST_CANCELED, + ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_FAILURE: () => ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_FAILURE, + ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_SUCCESS: () => ASPNETCORE_ROUTING_MATCH_STATUS_VALUE_SUCCESS, + ATTR_ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT: () => ATTR_ASPNETCORE_DIAGNOSTICS_EXCEPTION_RESULT, + ATTR_ASPNETCORE_DIAGNOSTICS_HANDLER_TYPE: () => ATTR_ASPNETCORE_DIAGNOSTICS_HANDLER_TYPE, + ATTR_ASPNETCORE_RATE_LIMITING_POLICY: () => ATTR_ASPNETCORE_RATE_LIMITING_POLICY, + ATTR_ASPNETCORE_RATE_LIMITING_RESULT: () => ATTR_ASPNETCORE_RATE_LIMITING_RESULT, + ATTR_ASPNETCORE_REQUEST_IS_UNHANDLED: () => ATTR_ASPNETCORE_REQUEST_IS_UNHANDLED, + ATTR_ASPNETCORE_ROUTING_IS_FALLBACK: () => ATTR_ASPNETCORE_ROUTING_IS_FALLBACK, + ATTR_ASPNETCORE_ROUTING_MATCH_STATUS: () => ATTR_ASPNETCORE_ROUTING_MATCH_STATUS, + ATTR_ASPNETCORE_USER_IS_AUTHENTICATED: () => ATTR_ASPNETCORE_USER_IS_AUTHENTICATED, + ATTR_CLIENT_ADDRESS: () => ATTR_CLIENT_ADDRESS, + ATTR_CLIENT_PORT: () => ATTR_CLIENT_PORT, + ATTR_CODE_COLUMN_NUMBER: () => ATTR_CODE_COLUMN_NUMBER, + ATTR_CODE_FILE_PATH: () => ATTR_CODE_FILE_PATH, + ATTR_CODE_FUNCTION_NAME: () => ATTR_CODE_FUNCTION_NAME, + ATTR_CODE_LINE_NUMBER: () => ATTR_CODE_LINE_NUMBER, + ATTR_CODE_STACKTRACE: () => ATTR_CODE_STACKTRACE, + ATTR_CONTAINER_ID: () => ATTR_CONTAINER_ID, + ATTR_CONTAINER_IMAGE_NAME: () => ATTR_CONTAINER_IMAGE_NAME, + ATTR_CONTAINER_IMAGE_REPO_DIGESTS: () => ATTR_CONTAINER_IMAGE_REPO_DIGESTS, + ATTR_CONTAINER_IMAGE_TAGS: () => ATTR_CONTAINER_IMAGE_TAGS, + ATTR_DB_COLLECTION_NAME: () => ATTR_DB_COLLECTION_NAME, + ATTR_DB_NAMESPACE: () => ATTR_DB_NAMESPACE, + ATTR_DB_OPERATION_BATCH_SIZE: () => ATTR_DB_OPERATION_BATCH_SIZE, + ATTR_DB_OPERATION_NAME: () => ATTR_DB_OPERATION_NAME, + ATTR_DB_QUERY_SUMMARY: () => ATTR_DB_QUERY_SUMMARY, + ATTR_DB_QUERY_TEXT: () => ATTR_DB_QUERY_TEXT, + ATTR_DB_RESPONSE_STATUS_CODE: () => ATTR_DB_RESPONSE_STATUS_CODE, + ATTR_DB_STORED_PROCEDURE_NAME: () => ATTR_DB_STORED_PROCEDURE_NAME, + ATTR_DB_SYSTEM_NAME: () => ATTR_DB_SYSTEM_NAME, + ATTR_DEPLOYMENT_ENVIRONMENT_NAME: () => ATTR_DEPLOYMENT_ENVIRONMENT_NAME, + ATTR_DOTNET_GC_HEAP_GENERATION: () => ATTR_DOTNET_GC_HEAP_GENERATION, + ATTR_ERROR_TYPE: () => ATTR_ERROR_TYPE, + ATTR_EXCEPTION_ESCAPED: () => ATTR_EXCEPTION_ESCAPED, + ATTR_EXCEPTION_MESSAGE: () => ATTR_EXCEPTION_MESSAGE, + ATTR_EXCEPTION_STACKTRACE: () => ATTR_EXCEPTION_STACKTRACE, + ATTR_EXCEPTION_TYPE: () => ATTR_EXCEPTION_TYPE, + ATTR_HTTP_REQUEST_HEADER: () => ATTR_HTTP_REQUEST_HEADER, + ATTR_HTTP_REQUEST_METHOD: () => ATTR_HTTP_REQUEST_METHOD, + ATTR_HTTP_REQUEST_METHOD_ORIGINAL: () => ATTR_HTTP_REQUEST_METHOD_ORIGINAL, + ATTR_HTTP_REQUEST_RESEND_COUNT: () => ATTR_HTTP_REQUEST_RESEND_COUNT, + ATTR_HTTP_RESPONSE_HEADER: () => ATTR_HTTP_RESPONSE_HEADER, + ATTR_HTTP_RESPONSE_STATUS_CODE: () => ATTR_HTTP_RESPONSE_STATUS_CODE, + ATTR_HTTP_ROUTE: () => ATTR_HTTP_ROUTE, + ATTR_JVM_GC_ACTION: () => ATTR_JVM_GC_ACTION, + ATTR_JVM_GC_NAME: () => ATTR_JVM_GC_NAME, + ATTR_JVM_MEMORY_POOL_NAME: () => ATTR_JVM_MEMORY_POOL_NAME, + ATTR_JVM_MEMORY_TYPE: () => ATTR_JVM_MEMORY_TYPE, + ATTR_JVM_THREAD_DAEMON: () => ATTR_JVM_THREAD_DAEMON, + ATTR_JVM_THREAD_STATE: () => ATTR_JVM_THREAD_STATE, + ATTR_K8S_CLUSTER_NAME: () => ATTR_K8S_CLUSTER_NAME, + ATTR_K8S_CLUSTER_UID: () => ATTR_K8S_CLUSTER_UID, + ATTR_K8S_CONTAINER_NAME: () => ATTR_K8S_CONTAINER_NAME, + ATTR_K8S_CONTAINER_RESTART_COUNT: () => ATTR_K8S_CONTAINER_RESTART_COUNT, + ATTR_K8S_CRONJOB_ANNOTATION: () => ATTR_K8S_CRONJOB_ANNOTATION, + ATTR_K8S_CRONJOB_LABEL: () => ATTR_K8S_CRONJOB_LABEL, + ATTR_K8S_CRONJOB_NAME: () => ATTR_K8S_CRONJOB_NAME, + ATTR_K8S_CRONJOB_UID: () => ATTR_K8S_CRONJOB_UID, + ATTR_K8S_DAEMONSET_ANNOTATION: () => ATTR_K8S_DAEMONSET_ANNOTATION, + ATTR_K8S_DAEMONSET_LABEL: () => ATTR_K8S_DAEMONSET_LABEL, + ATTR_K8S_DAEMONSET_NAME: () => ATTR_K8S_DAEMONSET_NAME, + ATTR_K8S_DAEMONSET_UID: () => ATTR_K8S_DAEMONSET_UID, + ATTR_K8S_DEPLOYMENT_ANNOTATION: () => ATTR_K8S_DEPLOYMENT_ANNOTATION, + ATTR_K8S_DEPLOYMENT_LABEL: () => ATTR_K8S_DEPLOYMENT_LABEL, + ATTR_K8S_DEPLOYMENT_NAME: () => ATTR_K8S_DEPLOYMENT_NAME, + ATTR_K8S_DEPLOYMENT_UID: () => ATTR_K8S_DEPLOYMENT_UID, + ATTR_K8S_JOB_ANNOTATION: () => ATTR_K8S_JOB_ANNOTATION, + ATTR_K8S_JOB_LABEL: () => ATTR_K8S_JOB_LABEL, + ATTR_K8S_JOB_NAME: () => ATTR_K8S_JOB_NAME, + ATTR_K8S_JOB_UID: () => ATTR_K8S_JOB_UID, + ATTR_K8S_NAMESPACE_ANNOTATION: () => ATTR_K8S_NAMESPACE_ANNOTATION, + ATTR_K8S_NAMESPACE_LABEL: () => ATTR_K8S_NAMESPACE_LABEL, + ATTR_K8S_NAMESPACE_NAME: () => ATTR_K8S_NAMESPACE_NAME, + ATTR_K8S_NODE_ANNOTATION: () => ATTR_K8S_NODE_ANNOTATION, + ATTR_K8S_NODE_LABEL: () => ATTR_K8S_NODE_LABEL, + ATTR_K8S_NODE_NAME: () => ATTR_K8S_NODE_NAME, + ATTR_K8S_NODE_UID: () => ATTR_K8S_NODE_UID, + ATTR_K8S_POD_ANNOTATION: () => ATTR_K8S_POD_ANNOTATION, + ATTR_K8S_POD_HOSTNAME: () => ATTR_K8S_POD_HOSTNAME, + ATTR_K8S_POD_IP: () => ATTR_K8S_POD_IP, + ATTR_K8S_POD_LABEL: () => ATTR_K8S_POD_LABEL, + ATTR_K8S_POD_NAME: () => ATTR_K8S_POD_NAME, + ATTR_K8S_POD_START_TIME: () => ATTR_K8S_POD_START_TIME, + ATTR_K8S_POD_UID: () => ATTR_K8S_POD_UID, + ATTR_K8S_REPLICASET_ANNOTATION: () => ATTR_K8S_REPLICASET_ANNOTATION, + ATTR_K8S_REPLICASET_LABEL: () => ATTR_K8S_REPLICASET_LABEL, + ATTR_K8S_REPLICASET_NAME: () => ATTR_K8S_REPLICASET_NAME, + ATTR_K8S_REPLICASET_UID: () => ATTR_K8S_REPLICASET_UID, + ATTR_K8S_STATEFULSET_ANNOTATION: () => ATTR_K8S_STATEFULSET_ANNOTATION, + ATTR_K8S_STATEFULSET_LABEL: () => ATTR_K8S_STATEFULSET_LABEL, + ATTR_K8S_STATEFULSET_NAME: () => ATTR_K8S_STATEFULSET_NAME, + ATTR_K8S_STATEFULSET_UID: () => ATTR_K8S_STATEFULSET_UID, + ATTR_NETWORK_LOCAL_ADDRESS: () => ATTR_NETWORK_LOCAL_ADDRESS, + ATTR_NETWORK_LOCAL_PORT: () => ATTR_NETWORK_LOCAL_PORT, + ATTR_NETWORK_PEER_ADDRESS: () => ATTR_NETWORK_PEER_ADDRESS, + ATTR_NETWORK_PEER_PORT: () => ATTR_NETWORK_PEER_PORT, + ATTR_NETWORK_PROTOCOL_NAME: () => ATTR_NETWORK_PROTOCOL_NAME, + ATTR_NETWORK_PROTOCOL_VERSION: () => ATTR_NETWORK_PROTOCOL_VERSION, + ATTR_NETWORK_TRANSPORT: () => ATTR_NETWORK_TRANSPORT, + ATTR_NETWORK_TYPE: () => ATTR_NETWORK_TYPE, + ATTR_OTEL_EVENT_NAME: () => ATTR_OTEL_EVENT_NAME, + ATTR_OTEL_SCOPE_NAME: () => ATTR_OTEL_SCOPE_NAME, + ATTR_OTEL_SCOPE_VERSION: () => ATTR_OTEL_SCOPE_VERSION, + ATTR_OTEL_STATUS_CODE: () => ATTR_OTEL_STATUS_CODE, + ATTR_OTEL_STATUS_DESCRIPTION: () => ATTR_OTEL_STATUS_DESCRIPTION, + ATTR_SERVER_ADDRESS: () => ATTR_SERVER_ADDRESS, + ATTR_SERVER_PORT: () => ATTR_SERVER_PORT, + ATTR_SERVICE_INSTANCE_ID: () => ATTR_SERVICE_INSTANCE_ID, + ATTR_SERVICE_NAME: () => ATTR_SERVICE_NAME, + ATTR_SERVICE_NAMESPACE: () => ATTR_SERVICE_NAMESPACE, + ATTR_SERVICE_VERSION: () => ATTR_SERVICE_VERSION, + ATTR_SIGNALR_CONNECTION_STATUS: () => ATTR_SIGNALR_CONNECTION_STATUS, + ATTR_SIGNALR_TRANSPORT: () => ATTR_SIGNALR_TRANSPORT, + ATTR_TELEMETRY_DISTRO_NAME: () => ATTR_TELEMETRY_DISTRO_NAME, + ATTR_TELEMETRY_DISTRO_VERSION: () => ATTR_TELEMETRY_DISTRO_VERSION, + ATTR_TELEMETRY_SDK_LANGUAGE: () => ATTR_TELEMETRY_SDK_LANGUAGE, + ATTR_TELEMETRY_SDK_NAME: () => ATTR_TELEMETRY_SDK_NAME, + ATTR_TELEMETRY_SDK_VERSION: () => ATTR_TELEMETRY_SDK_VERSION, + ATTR_URL_FRAGMENT: () => ATTR_URL_FRAGMENT, + ATTR_URL_FULL: () => ATTR_URL_FULL, + ATTR_URL_PATH: () => ATTR_URL_PATH, + ATTR_URL_QUERY: () => ATTR_URL_QUERY, + ATTR_URL_SCHEME: () => ATTR_URL_SCHEME, + ATTR_USER_AGENT_ORIGINAL: () => ATTR_USER_AGENT_ORIGINAL, + AWSECSLAUNCHTYPEVALUES_EC2: () => AWSECSLAUNCHTYPEVALUES_EC2, + AWSECSLAUNCHTYPEVALUES_FARGATE: () => AWSECSLAUNCHTYPEVALUES_FARGATE, + AwsEcsLaunchtypeValues: () => AwsEcsLaunchtypeValues, + CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS: () => CLOUDPLATFORMVALUES_ALIBABA_CLOUD_ECS, + CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC: () => CLOUDPLATFORMVALUES_ALIBABA_CLOUD_FC, + CLOUDPLATFORMVALUES_AWS_EC2: () => CLOUDPLATFORMVALUES_AWS_EC2, + CLOUDPLATFORMVALUES_AWS_ECS: () => CLOUDPLATFORMVALUES_AWS_ECS, + CLOUDPLATFORMVALUES_AWS_EKS: () => CLOUDPLATFORMVALUES_AWS_EKS, + CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK: () => CLOUDPLATFORMVALUES_AWS_ELASTIC_BEANSTALK, + CLOUDPLATFORMVALUES_AWS_LAMBDA: () => CLOUDPLATFORMVALUES_AWS_LAMBDA, + CLOUDPLATFORMVALUES_AZURE_AKS: () => CLOUDPLATFORMVALUES_AZURE_AKS, + CLOUDPLATFORMVALUES_AZURE_APP_SERVICE: () => CLOUDPLATFORMVALUES_AZURE_APP_SERVICE, + CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES: () => CLOUDPLATFORMVALUES_AZURE_CONTAINER_INSTANCES, + CLOUDPLATFORMVALUES_AZURE_FUNCTIONS: () => CLOUDPLATFORMVALUES_AZURE_FUNCTIONS, + CLOUDPLATFORMVALUES_AZURE_VM: () => CLOUDPLATFORMVALUES_AZURE_VM, + CLOUDPLATFORMVALUES_GCP_APP_ENGINE: () => CLOUDPLATFORMVALUES_GCP_APP_ENGINE, + CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS: () => CLOUDPLATFORMVALUES_GCP_CLOUD_FUNCTIONS, + CLOUDPLATFORMVALUES_GCP_CLOUD_RUN: () => CLOUDPLATFORMVALUES_GCP_CLOUD_RUN, + CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE: () => CLOUDPLATFORMVALUES_GCP_COMPUTE_ENGINE, + CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE: () => CLOUDPLATFORMVALUES_GCP_KUBERNETES_ENGINE, + CLOUDPROVIDERVALUES_ALIBABA_CLOUD: () => CLOUDPROVIDERVALUES_ALIBABA_CLOUD, + CLOUDPROVIDERVALUES_AWS: () => CLOUDPROVIDERVALUES_AWS, + CLOUDPROVIDERVALUES_AZURE: () => CLOUDPROVIDERVALUES_AZURE, + CLOUDPROVIDERVALUES_GCP: () => CLOUDPROVIDERVALUES_GCP, + CloudPlatformValues: () => CloudPlatformValues, + CloudProviderValues: () => CloudProviderValues, + DBCASSANDRACONSISTENCYLEVELVALUES_ALL: () => DBCASSANDRACONSISTENCYLEVELVALUES_ALL, + DBCASSANDRACONSISTENCYLEVELVALUES_ANY: () => DBCASSANDRACONSISTENCYLEVELVALUES_ANY, + DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM: () => DBCASSANDRACONSISTENCYLEVELVALUES_EACH_QUORUM, + DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE: () => DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_ONE, + DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM: () => DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_QUORUM, + DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL: () => DBCASSANDRACONSISTENCYLEVELVALUES_LOCAL_SERIAL, + DBCASSANDRACONSISTENCYLEVELVALUES_ONE: () => DBCASSANDRACONSISTENCYLEVELVALUES_ONE, + DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM: () => DBCASSANDRACONSISTENCYLEVELVALUES_QUORUM, + DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL: () => DBCASSANDRACONSISTENCYLEVELVALUES_SERIAL, + DBCASSANDRACONSISTENCYLEVELVALUES_THREE: () => DBCASSANDRACONSISTENCYLEVELVALUES_THREE, + DBCASSANDRACONSISTENCYLEVELVALUES_TWO: () => DBCASSANDRACONSISTENCYLEVELVALUES_TWO, + DBSYSTEMVALUES_ADABAS: () => DBSYSTEMVALUES_ADABAS, + DBSYSTEMVALUES_CACHE: () => DBSYSTEMVALUES_CACHE, + DBSYSTEMVALUES_CASSANDRA: () => DBSYSTEMVALUES_CASSANDRA, + DBSYSTEMVALUES_CLOUDSCAPE: () => DBSYSTEMVALUES_CLOUDSCAPE, + DBSYSTEMVALUES_COCKROACHDB: () => DBSYSTEMVALUES_COCKROACHDB, + DBSYSTEMVALUES_COLDFUSION: () => DBSYSTEMVALUES_COLDFUSION, + DBSYSTEMVALUES_COSMOSDB: () => DBSYSTEMVALUES_COSMOSDB, + DBSYSTEMVALUES_COUCHBASE: () => DBSYSTEMVALUES_COUCHBASE, + DBSYSTEMVALUES_COUCHDB: () => DBSYSTEMVALUES_COUCHDB, + DBSYSTEMVALUES_DB2: () => DBSYSTEMVALUES_DB2, + DBSYSTEMVALUES_DERBY: () => DBSYSTEMVALUES_DERBY, + DBSYSTEMVALUES_DYNAMODB: () => DBSYSTEMVALUES_DYNAMODB, + DBSYSTEMVALUES_EDB: () => DBSYSTEMVALUES_EDB, + DBSYSTEMVALUES_ELASTICSEARCH: () => DBSYSTEMVALUES_ELASTICSEARCH, + DBSYSTEMVALUES_FILEMAKER: () => DBSYSTEMVALUES_FILEMAKER, + DBSYSTEMVALUES_FIREBIRD: () => DBSYSTEMVALUES_FIREBIRD, + DBSYSTEMVALUES_FIRSTSQL: () => DBSYSTEMVALUES_FIRSTSQL, + DBSYSTEMVALUES_GEODE: () => DBSYSTEMVALUES_GEODE, + DBSYSTEMVALUES_H2: () => DBSYSTEMVALUES_H2, + DBSYSTEMVALUES_HANADB: () => DBSYSTEMVALUES_HANADB, + DBSYSTEMVALUES_HBASE: () => DBSYSTEMVALUES_HBASE, + DBSYSTEMVALUES_HIVE: () => DBSYSTEMVALUES_HIVE, + DBSYSTEMVALUES_HSQLDB: () => DBSYSTEMVALUES_HSQLDB, + DBSYSTEMVALUES_INFORMIX: () => DBSYSTEMVALUES_INFORMIX, + DBSYSTEMVALUES_INGRES: () => DBSYSTEMVALUES_INGRES, + DBSYSTEMVALUES_INSTANTDB: () => DBSYSTEMVALUES_INSTANTDB, + DBSYSTEMVALUES_INTERBASE: () => DBSYSTEMVALUES_INTERBASE, + DBSYSTEMVALUES_MARIADB: () => DBSYSTEMVALUES_MARIADB, + DBSYSTEMVALUES_MAXDB: () => DBSYSTEMVALUES_MAXDB, + DBSYSTEMVALUES_MEMCACHED: () => DBSYSTEMVALUES_MEMCACHED, + DBSYSTEMVALUES_MONGODB: () => DBSYSTEMVALUES_MONGODB, + DBSYSTEMVALUES_MSSQL: () => DBSYSTEMVALUES_MSSQL, + DBSYSTEMVALUES_MYSQL: () => DBSYSTEMVALUES_MYSQL, + DBSYSTEMVALUES_NEO4J: () => DBSYSTEMVALUES_NEO4J, + DBSYSTEMVALUES_NETEZZA: () => DBSYSTEMVALUES_NETEZZA, + DBSYSTEMVALUES_ORACLE: () => DBSYSTEMVALUES_ORACLE, + DBSYSTEMVALUES_OTHER_SQL: () => DBSYSTEMVALUES_OTHER_SQL, + DBSYSTEMVALUES_PERVASIVE: () => DBSYSTEMVALUES_PERVASIVE, + DBSYSTEMVALUES_POINTBASE: () => DBSYSTEMVALUES_POINTBASE, + DBSYSTEMVALUES_POSTGRESQL: () => DBSYSTEMVALUES_POSTGRESQL, + DBSYSTEMVALUES_PROGRESS: () => DBSYSTEMVALUES_PROGRESS, + DBSYSTEMVALUES_REDIS: () => DBSYSTEMVALUES_REDIS, + DBSYSTEMVALUES_REDSHIFT: () => DBSYSTEMVALUES_REDSHIFT, + DBSYSTEMVALUES_SQLITE: () => DBSYSTEMVALUES_SQLITE, + DBSYSTEMVALUES_SYBASE: () => DBSYSTEMVALUES_SYBASE, + DBSYSTEMVALUES_TERADATA: () => DBSYSTEMVALUES_TERADATA, + DBSYSTEMVALUES_VERTICA: () => DBSYSTEMVALUES_VERTICA, + DB_SYSTEM_NAME_VALUE_MARIADB: () => DB_SYSTEM_NAME_VALUE_MARIADB, + DB_SYSTEM_NAME_VALUE_MICROSOFT_SQL_SERVER: () => DB_SYSTEM_NAME_VALUE_MICROSOFT_SQL_SERVER, + DB_SYSTEM_NAME_VALUE_MYSQL: () => DB_SYSTEM_NAME_VALUE_MYSQL, + DB_SYSTEM_NAME_VALUE_POSTGRESQL: () => DB_SYSTEM_NAME_VALUE_POSTGRESQL, + DEPLOYMENT_ENVIRONMENT_NAME_VALUE_DEVELOPMENT: () => DEPLOYMENT_ENVIRONMENT_NAME_VALUE_DEVELOPMENT, + DEPLOYMENT_ENVIRONMENT_NAME_VALUE_PRODUCTION: () => DEPLOYMENT_ENVIRONMENT_NAME_VALUE_PRODUCTION, + DEPLOYMENT_ENVIRONMENT_NAME_VALUE_STAGING: () => DEPLOYMENT_ENVIRONMENT_NAME_VALUE_STAGING, + DEPLOYMENT_ENVIRONMENT_NAME_VALUE_TEST: () => DEPLOYMENT_ENVIRONMENT_NAME_VALUE_TEST, + DOTNET_GC_HEAP_GENERATION_VALUE_GEN0: () => DOTNET_GC_HEAP_GENERATION_VALUE_GEN0, + DOTNET_GC_HEAP_GENERATION_VALUE_GEN1: () => DOTNET_GC_HEAP_GENERATION_VALUE_GEN1, + DOTNET_GC_HEAP_GENERATION_VALUE_GEN2: () => DOTNET_GC_HEAP_GENERATION_VALUE_GEN2, + DOTNET_GC_HEAP_GENERATION_VALUE_LOH: () => DOTNET_GC_HEAP_GENERATION_VALUE_LOH, + DOTNET_GC_HEAP_GENERATION_VALUE_POH: () => DOTNET_GC_HEAP_GENERATION_VALUE_POH, + DbCassandraConsistencyLevelValues: () => DbCassandraConsistencyLevelValues, + DbSystemValues: () => DbSystemValues, + ERROR_TYPE_VALUE_OTHER: () => ERROR_TYPE_VALUE_OTHER, + EVENT_EXCEPTION: () => EVENT_EXCEPTION, + FAASDOCUMENTOPERATIONVALUES_DELETE: () => FAASDOCUMENTOPERATIONVALUES_DELETE, + FAASDOCUMENTOPERATIONVALUES_EDIT: () => FAASDOCUMENTOPERATIONVALUES_EDIT, + FAASDOCUMENTOPERATIONVALUES_INSERT: () => FAASDOCUMENTOPERATIONVALUES_INSERT, + FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD: () => FAASINVOKEDPROVIDERVALUES_ALIBABA_CLOUD, + FAASINVOKEDPROVIDERVALUES_AWS: () => FAASINVOKEDPROVIDERVALUES_AWS, + FAASINVOKEDPROVIDERVALUES_AZURE: () => FAASINVOKEDPROVIDERVALUES_AZURE, + FAASINVOKEDPROVIDERVALUES_GCP: () => FAASINVOKEDPROVIDERVALUES_GCP, + FAASTRIGGERVALUES_DATASOURCE: () => FAASTRIGGERVALUES_DATASOURCE, + FAASTRIGGERVALUES_HTTP: () => FAASTRIGGERVALUES_HTTP, + FAASTRIGGERVALUES_OTHER: () => FAASTRIGGERVALUES_OTHER, + FAASTRIGGERVALUES_PUBSUB: () => FAASTRIGGERVALUES_PUBSUB, + FAASTRIGGERVALUES_TIMER: () => FAASTRIGGERVALUES_TIMER, + FaasDocumentOperationValues: () => FaasDocumentOperationValues, + FaasInvokedProviderValues: () => FaasInvokedProviderValues, + FaasTriggerValues: () => FaasTriggerValues, + HOSTARCHVALUES_AMD64: () => HOSTARCHVALUES_AMD64, + HOSTARCHVALUES_ARM32: () => HOSTARCHVALUES_ARM32, + HOSTARCHVALUES_ARM64: () => HOSTARCHVALUES_ARM64, + HOSTARCHVALUES_IA64: () => HOSTARCHVALUES_IA64, + HOSTARCHVALUES_PPC32: () => HOSTARCHVALUES_PPC32, + HOSTARCHVALUES_PPC64: () => HOSTARCHVALUES_PPC64, + HOSTARCHVALUES_X86: () => HOSTARCHVALUES_X86, + HTTPFLAVORVALUES_HTTP_1_0: () => HTTPFLAVORVALUES_HTTP_1_0, + HTTPFLAVORVALUES_HTTP_1_1: () => HTTPFLAVORVALUES_HTTP_1_1, + HTTPFLAVORVALUES_HTTP_2_0: () => HTTPFLAVORVALUES_HTTP_2_0, + HTTPFLAVORVALUES_QUIC: () => HTTPFLAVORVALUES_QUIC, + HTTPFLAVORVALUES_SPDY: () => HTTPFLAVORVALUES_SPDY, + HTTP_REQUEST_METHOD_VALUE_CONNECT: () => HTTP_REQUEST_METHOD_VALUE_CONNECT, + HTTP_REQUEST_METHOD_VALUE_DELETE: () => HTTP_REQUEST_METHOD_VALUE_DELETE, + HTTP_REQUEST_METHOD_VALUE_GET: () => HTTP_REQUEST_METHOD_VALUE_GET, + HTTP_REQUEST_METHOD_VALUE_HEAD: () => HTTP_REQUEST_METHOD_VALUE_HEAD, + HTTP_REQUEST_METHOD_VALUE_OPTIONS: () => HTTP_REQUEST_METHOD_VALUE_OPTIONS, + HTTP_REQUEST_METHOD_VALUE_OTHER: () => HTTP_REQUEST_METHOD_VALUE_OTHER, + HTTP_REQUEST_METHOD_VALUE_PATCH: () => HTTP_REQUEST_METHOD_VALUE_PATCH, + HTTP_REQUEST_METHOD_VALUE_POST: () => HTTP_REQUEST_METHOD_VALUE_POST, + HTTP_REQUEST_METHOD_VALUE_PUT: () => HTTP_REQUEST_METHOD_VALUE_PUT, + HTTP_REQUEST_METHOD_VALUE_TRACE: () => HTTP_REQUEST_METHOD_VALUE_TRACE, + HostArchValues: () => HostArchValues, + HttpFlavorValues: () => HttpFlavorValues, + JVM_MEMORY_TYPE_VALUE_HEAP: () => JVM_MEMORY_TYPE_VALUE_HEAP, + JVM_MEMORY_TYPE_VALUE_NON_HEAP: () => JVM_MEMORY_TYPE_VALUE_NON_HEAP, + JVM_THREAD_STATE_VALUE_BLOCKED: () => JVM_THREAD_STATE_VALUE_BLOCKED, + JVM_THREAD_STATE_VALUE_NEW: () => JVM_THREAD_STATE_VALUE_NEW, + JVM_THREAD_STATE_VALUE_RUNNABLE: () => JVM_THREAD_STATE_VALUE_RUNNABLE, + JVM_THREAD_STATE_VALUE_TERMINATED: () => JVM_THREAD_STATE_VALUE_TERMINATED, + JVM_THREAD_STATE_VALUE_TIMED_WAITING: () => JVM_THREAD_STATE_VALUE_TIMED_WAITING, + JVM_THREAD_STATE_VALUE_WAITING: () => JVM_THREAD_STATE_VALUE_WAITING, + MESSAGETYPEVALUES_RECEIVED: () => MESSAGETYPEVALUES_RECEIVED, + MESSAGETYPEVALUES_SENT: () => MESSAGETYPEVALUES_SENT, + MESSAGINGDESTINATIONKINDVALUES_QUEUE: () => MESSAGINGDESTINATIONKINDVALUES_QUEUE, + MESSAGINGDESTINATIONKINDVALUES_TOPIC: () => MESSAGINGDESTINATIONKINDVALUES_TOPIC, + MESSAGINGOPERATIONVALUES_PROCESS: () => MESSAGINGOPERATIONVALUES_PROCESS, + MESSAGINGOPERATIONVALUES_RECEIVE: () => MESSAGINGOPERATIONVALUES_RECEIVE, + METRIC_ASPNETCORE_DIAGNOSTICS_EXCEPTIONS: () => METRIC_ASPNETCORE_DIAGNOSTICS_EXCEPTIONS, + METRIC_ASPNETCORE_RATE_LIMITING_ACTIVE_REQUEST_LEASES: () => METRIC_ASPNETCORE_RATE_LIMITING_ACTIVE_REQUEST_LEASES, + METRIC_ASPNETCORE_RATE_LIMITING_QUEUED_REQUESTS: () => METRIC_ASPNETCORE_RATE_LIMITING_QUEUED_REQUESTS, + METRIC_ASPNETCORE_RATE_LIMITING_REQUESTS: () => METRIC_ASPNETCORE_RATE_LIMITING_REQUESTS, + METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_LEASE_DURATION: () => METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_LEASE_DURATION, + METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_TIME_IN_QUEUE: () => METRIC_ASPNETCORE_RATE_LIMITING_REQUEST_TIME_IN_QUEUE, + METRIC_ASPNETCORE_ROUTING_MATCH_ATTEMPTS: () => METRIC_ASPNETCORE_ROUTING_MATCH_ATTEMPTS, + METRIC_DB_CLIENT_OPERATION_DURATION: () => METRIC_DB_CLIENT_OPERATION_DURATION, + METRIC_DOTNET_ASSEMBLY_COUNT: () => METRIC_DOTNET_ASSEMBLY_COUNT, + METRIC_DOTNET_EXCEPTIONS: () => METRIC_DOTNET_EXCEPTIONS, + METRIC_DOTNET_GC_COLLECTIONS: () => METRIC_DOTNET_GC_COLLECTIONS, + METRIC_DOTNET_GC_HEAP_TOTAL_ALLOCATED: () => METRIC_DOTNET_GC_HEAP_TOTAL_ALLOCATED, + METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_FRAGMENTATION_SIZE: () => METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_FRAGMENTATION_SIZE, + METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_SIZE: () => METRIC_DOTNET_GC_LAST_COLLECTION_HEAP_SIZE, + METRIC_DOTNET_GC_LAST_COLLECTION_MEMORY_COMMITTED_SIZE: () => METRIC_DOTNET_GC_LAST_COLLECTION_MEMORY_COMMITTED_SIZE, + METRIC_DOTNET_GC_PAUSE_TIME: () => METRIC_DOTNET_GC_PAUSE_TIME, + METRIC_DOTNET_JIT_COMPILATION_TIME: () => METRIC_DOTNET_JIT_COMPILATION_TIME, + METRIC_DOTNET_JIT_COMPILED_IL_SIZE: () => METRIC_DOTNET_JIT_COMPILED_IL_SIZE, + METRIC_DOTNET_JIT_COMPILED_METHODS: () => METRIC_DOTNET_JIT_COMPILED_METHODS, + METRIC_DOTNET_MONITOR_LOCK_CONTENTIONS: () => METRIC_DOTNET_MONITOR_LOCK_CONTENTIONS, + METRIC_DOTNET_PROCESS_CPU_COUNT: () => METRIC_DOTNET_PROCESS_CPU_COUNT, + METRIC_DOTNET_PROCESS_CPU_TIME: () => METRIC_DOTNET_PROCESS_CPU_TIME, + METRIC_DOTNET_PROCESS_MEMORY_WORKING_SET: () => METRIC_DOTNET_PROCESS_MEMORY_WORKING_SET, + METRIC_DOTNET_THREAD_POOL_QUEUE_LENGTH: () => METRIC_DOTNET_THREAD_POOL_QUEUE_LENGTH, + METRIC_DOTNET_THREAD_POOL_THREAD_COUNT: () => METRIC_DOTNET_THREAD_POOL_THREAD_COUNT, + METRIC_DOTNET_THREAD_POOL_WORK_ITEM_COUNT: () => METRIC_DOTNET_THREAD_POOL_WORK_ITEM_COUNT, + METRIC_DOTNET_TIMER_COUNT: () => METRIC_DOTNET_TIMER_COUNT, + METRIC_HTTP_CLIENT_REQUEST_DURATION: () => METRIC_HTTP_CLIENT_REQUEST_DURATION, + METRIC_HTTP_SERVER_REQUEST_DURATION: () => METRIC_HTTP_SERVER_REQUEST_DURATION, + METRIC_JVM_CLASS_COUNT: () => METRIC_JVM_CLASS_COUNT, + METRIC_JVM_CLASS_LOADED: () => METRIC_JVM_CLASS_LOADED, + METRIC_JVM_CLASS_UNLOADED: () => METRIC_JVM_CLASS_UNLOADED, + METRIC_JVM_CPU_COUNT: () => METRIC_JVM_CPU_COUNT, + METRIC_JVM_CPU_RECENT_UTILIZATION: () => METRIC_JVM_CPU_RECENT_UTILIZATION, + METRIC_JVM_CPU_TIME: () => METRIC_JVM_CPU_TIME, + METRIC_JVM_GC_DURATION: () => METRIC_JVM_GC_DURATION, + METRIC_JVM_MEMORY_COMMITTED: () => METRIC_JVM_MEMORY_COMMITTED, + METRIC_JVM_MEMORY_LIMIT: () => METRIC_JVM_MEMORY_LIMIT, + METRIC_JVM_MEMORY_USED: () => METRIC_JVM_MEMORY_USED, + METRIC_JVM_MEMORY_USED_AFTER_LAST_GC: () => METRIC_JVM_MEMORY_USED_AFTER_LAST_GC, + METRIC_JVM_THREAD_COUNT: () => METRIC_JVM_THREAD_COUNT, + METRIC_KESTREL_ACTIVE_CONNECTIONS: () => METRIC_KESTREL_ACTIVE_CONNECTIONS, + METRIC_KESTREL_ACTIVE_TLS_HANDSHAKES: () => METRIC_KESTREL_ACTIVE_TLS_HANDSHAKES, + METRIC_KESTREL_CONNECTION_DURATION: () => METRIC_KESTREL_CONNECTION_DURATION, + METRIC_KESTREL_QUEUED_CONNECTIONS: () => METRIC_KESTREL_QUEUED_CONNECTIONS, + METRIC_KESTREL_QUEUED_REQUESTS: () => METRIC_KESTREL_QUEUED_REQUESTS, + METRIC_KESTREL_REJECTED_CONNECTIONS: () => METRIC_KESTREL_REJECTED_CONNECTIONS, + METRIC_KESTREL_TLS_HANDSHAKE_DURATION: () => METRIC_KESTREL_TLS_HANDSHAKE_DURATION, + METRIC_KESTREL_UPGRADED_CONNECTIONS: () => METRIC_KESTREL_UPGRADED_CONNECTIONS, + METRIC_SIGNALR_SERVER_ACTIVE_CONNECTIONS: () => METRIC_SIGNALR_SERVER_ACTIVE_CONNECTIONS, + METRIC_SIGNALR_SERVER_CONNECTION_DURATION: () => METRIC_SIGNALR_SERVER_CONNECTION_DURATION, + MessageTypeValues: () => MessageTypeValues, + MessagingDestinationKindValues: () => MessagingDestinationKindValues, + MessagingOperationValues: () => MessagingOperationValues, + NETHOSTCONNECTIONSUBTYPEVALUES_CDMA: () => NETHOSTCONNECTIONSUBTYPEVALUES_CDMA, + NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT: () => NETHOSTCONNECTIONSUBTYPEVALUES_CDMA2000_1XRTT, + NETHOSTCONNECTIONSUBTYPEVALUES_EDGE: () => NETHOSTCONNECTIONSUBTYPEVALUES_EDGE, + NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD: () => NETHOSTCONNECTIONSUBTYPEVALUES_EHRPD, + NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0: () => NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_0, + NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A: () => NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_A, + NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B: () => NETHOSTCONNECTIONSUBTYPEVALUES_EVDO_B, + NETHOSTCONNECTIONSUBTYPEVALUES_GPRS: () => NETHOSTCONNECTIONSUBTYPEVALUES_GPRS, + NETHOSTCONNECTIONSUBTYPEVALUES_GSM: () => NETHOSTCONNECTIONSUBTYPEVALUES_GSM, + NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA: () => NETHOSTCONNECTIONSUBTYPEVALUES_HSDPA, + NETHOSTCONNECTIONSUBTYPEVALUES_HSPA: () => NETHOSTCONNECTIONSUBTYPEVALUES_HSPA, + NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP: () => NETHOSTCONNECTIONSUBTYPEVALUES_HSPAP, + NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA: () => NETHOSTCONNECTIONSUBTYPEVALUES_HSUPA, + NETHOSTCONNECTIONSUBTYPEVALUES_IDEN: () => NETHOSTCONNECTIONSUBTYPEVALUES_IDEN, + NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN: () => NETHOSTCONNECTIONSUBTYPEVALUES_IWLAN, + NETHOSTCONNECTIONSUBTYPEVALUES_LTE: () => NETHOSTCONNECTIONSUBTYPEVALUES_LTE, + NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA: () => NETHOSTCONNECTIONSUBTYPEVALUES_LTE_CA, + NETHOSTCONNECTIONSUBTYPEVALUES_NR: () => NETHOSTCONNECTIONSUBTYPEVALUES_NR, + NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA: () => NETHOSTCONNECTIONSUBTYPEVALUES_NRNSA, + NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA: () => NETHOSTCONNECTIONSUBTYPEVALUES_TD_SCDMA, + NETHOSTCONNECTIONSUBTYPEVALUES_UMTS: () => NETHOSTCONNECTIONSUBTYPEVALUES_UMTS, + NETHOSTCONNECTIONTYPEVALUES_CELL: () => NETHOSTCONNECTIONTYPEVALUES_CELL, + NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE: () => NETHOSTCONNECTIONTYPEVALUES_UNAVAILABLE, + NETHOSTCONNECTIONTYPEVALUES_UNKNOWN: () => NETHOSTCONNECTIONTYPEVALUES_UNKNOWN, + NETHOSTCONNECTIONTYPEVALUES_WIFI: () => NETHOSTCONNECTIONTYPEVALUES_WIFI, + NETHOSTCONNECTIONTYPEVALUES_WIRED: () => NETHOSTCONNECTIONTYPEVALUES_WIRED, + NETTRANSPORTVALUES_INPROC: () => NETTRANSPORTVALUES_INPROC, + NETTRANSPORTVALUES_IP: () => NETTRANSPORTVALUES_IP, + NETTRANSPORTVALUES_IP_TCP: () => NETTRANSPORTVALUES_IP_TCP, + NETTRANSPORTVALUES_IP_UDP: () => NETTRANSPORTVALUES_IP_UDP, + NETTRANSPORTVALUES_OTHER: () => NETTRANSPORTVALUES_OTHER, + NETTRANSPORTVALUES_PIPE: () => NETTRANSPORTVALUES_PIPE, + NETTRANSPORTVALUES_UNIX: () => NETTRANSPORTVALUES_UNIX, + NETWORK_TRANSPORT_VALUE_PIPE: () => NETWORK_TRANSPORT_VALUE_PIPE, + NETWORK_TRANSPORT_VALUE_QUIC: () => NETWORK_TRANSPORT_VALUE_QUIC, + NETWORK_TRANSPORT_VALUE_TCP: () => NETWORK_TRANSPORT_VALUE_TCP, + NETWORK_TRANSPORT_VALUE_UDP: () => NETWORK_TRANSPORT_VALUE_UDP, + NETWORK_TRANSPORT_VALUE_UNIX: () => NETWORK_TRANSPORT_VALUE_UNIX, + NETWORK_TYPE_VALUE_IPV4: () => NETWORK_TYPE_VALUE_IPV4, + NETWORK_TYPE_VALUE_IPV6: () => NETWORK_TYPE_VALUE_IPV6, + NetHostConnectionSubtypeValues: () => NetHostConnectionSubtypeValues, + NetHostConnectionTypeValues: () => NetHostConnectionTypeValues, + NetTransportValues: () => NetTransportValues, + OSTYPEVALUES_AIX: () => OSTYPEVALUES_AIX, + OSTYPEVALUES_DARWIN: () => OSTYPEVALUES_DARWIN, + OSTYPEVALUES_DRAGONFLYBSD: () => OSTYPEVALUES_DRAGONFLYBSD, + OSTYPEVALUES_FREEBSD: () => OSTYPEVALUES_FREEBSD, + OSTYPEVALUES_HPUX: () => OSTYPEVALUES_HPUX, + OSTYPEVALUES_LINUX: () => OSTYPEVALUES_LINUX, + OSTYPEVALUES_NETBSD: () => OSTYPEVALUES_NETBSD, + OSTYPEVALUES_OPENBSD: () => OSTYPEVALUES_OPENBSD, + OSTYPEVALUES_SOLARIS: () => OSTYPEVALUES_SOLARIS, + OSTYPEVALUES_WINDOWS: () => OSTYPEVALUES_WINDOWS, + OSTYPEVALUES_Z_OS: () => OSTYPEVALUES_Z_OS, + OTEL_STATUS_CODE_VALUE_ERROR: () => OTEL_STATUS_CODE_VALUE_ERROR, + OTEL_STATUS_CODE_VALUE_OK: () => OTEL_STATUS_CODE_VALUE_OK, + OsTypeValues: () => OsTypeValues, + RPCGRPCSTATUSCODEVALUES_ABORTED: () => RPCGRPCSTATUSCODEVALUES_ABORTED, + RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS: () => RPCGRPCSTATUSCODEVALUES_ALREADY_EXISTS, + RPCGRPCSTATUSCODEVALUES_CANCELLED: () => RPCGRPCSTATUSCODEVALUES_CANCELLED, + RPCGRPCSTATUSCODEVALUES_DATA_LOSS: () => RPCGRPCSTATUSCODEVALUES_DATA_LOSS, + RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED: () => RPCGRPCSTATUSCODEVALUES_DEADLINE_EXCEEDED, + RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION: () => RPCGRPCSTATUSCODEVALUES_FAILED_PRECONDITION, + RPCGRPCSTATUSCODEVALUES_INTERNAL: () => RPCGRPCSTATUSCODEVALUES_INTERNAL, + RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT: () => RPCGRPCSTATUSCODEVALUES_INVALID_ARGUMENT, + RPCGRPCSTATUSCODEVALUES_NOT_FOUND: () => RPCGRPCSTATUSCODEVALUES_NOT_FOUND, + RPCGRPCSTATUSCODEVALUES_OK: () => RPCGRPCSTATUSCODEVALUES_OK, + RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE: () => RPCGRPCSTATUSCODEVALUES_OUT_OF_RANGE, + RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED: () => RPCGRPCSTATUSCODEVALUES_PERMISSION_DENIED, + RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED: () => RPCGRPCSTATUSCODEVALUES_RESOURCE_EXHAUSTED, + RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED: () => RPCGRPCSTATUSCODEVALUES_UNAUTHENTICATED, + RPCGRPCSTATUSCODEVALUES_UNAVAILABLE: () => RPCGRPCSTATUSCODEVALUES_UNAVAILABLE, + RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED: () => RPCGRPCSTATUSCODEVALUES_UNIMPLEMENTED, + RPCGRPCSTATUSCODEVALUES_UNKNOWN: () => RPCGRPCSTATUSCODEVALUES_UNKNOWN, + RpcGrpcStatusCodeValues: () => RpcGrpcStatusCodeValues, + SEMATTRS_AWS_DYNAMODB_ATTRIBUTES_TO_GET: () => SEMATTRS_AWS_DYNAMODB_ATTRIBUTES_TO_GET, + SEMATTRS_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS: () => SEMATTRS_AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS, + SEMATTRS_AWS_DYNAMODB_CONSISTENT_READ: () => SEMATTRS_AWS_DYNAMODB_CONSISTENT_READ, + SEMATTRS_AWS_DYNAMODB_CONSUMED_CAPACITY: () => SEMATTRS_AWS_DYNAMODB_CONSUMED_CAPACITY, + SEMATTRS_AWS_DYNAMODB_COUNT: () => SEMATTRS_AWS_DYNAMODB_COUNT, + SEMATTRS_AWS_DYNAMODB_EXCLUSIVE_START_TABLE: () => SEMATTRS_AWS_DYNAMODB_EXCLUSIVE_START_TABLE, + SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES: () => SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES, + SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES: () => SEMATTRS_AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES, + SEMATTRS_AWS_DYNAMODB_INDEX_NAME: () => SEMATTRS_AWS_DYNAMODB_INDEX_NAME, + SEMATTRS_AWS_DYNAMODB_ITEM_COLLECTION_METRICS: () => SEMATTRS_AWS_DYNAMODB_ITEM_COLLECTION_METRICS, + SEMATTRS_AWS_DYNAMODB_LIMIT: () => SEMATTRS_AWS_DYNAMODB_LIMIT, + SEMATTRS_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES: () => SEMATTRS_AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES, + SEMATTRS_AWS_DYNAMODB_PROJECTION: () => SEMATTRS_AWS_DYNAMODB_PROJECTION, + SEMATTRS_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY: () => SEMATTRS_AWS_DYNAMODB_PROVISIONED_READ_CAPACITY, + SEMATTRS_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY: () => SEMATTRS_AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY, + SEMATTRS_AWS_DYNAMODB_SCANNED_COUNT: () => SEMATTRS_AWS_DYNAMODB_SCANNED_COUNT, + SEMATTRS_AWS_DYNAMODB_SCAN_FORWARD: () => SEMATTRS_AWS_DYNAMODB_SCAN_FORWARD, + SEMATTRS_AWS_DYNAMODB_SEGMENT: () => SEMATTRS_AWS_DYNAMODB_SEGMENT, + SEMATTRS_AWS_DYNAMODB_SELECT: () => SEMATTRS_AWS_DYNAMODB_SELECT, + SEMATTRS_AWS_DYNAMODB_TABLE_COUNT: () => SEMATTRS_AWS_DYNAMODB_TABLE_COUNT, + SEMATTRS_AWS_DYNAMODB_TABLE_NAMES: () => SEMATTRS_AWS_DYNAMODB_TABLE_NAMES, + SEMATTRS_AWS_DYNAMODB_TOTAL_SEGMENTS: () => SEMATTRS_AWS_DYNAMODB_TOTAL_SEGMENTS, + SEMATTRS_AWS_LAMBDA_INVOKED_ARN: () => SEMATTRS_AWS_LAMBDA_INVOKED_ARN, + SEMATTRS_CODE_FILEPATH: () => SEMATTRS_CODE_FILEPATH, + SEMATTRS_CODE_FUNCTION: () => SEMATTRS_CODE_FUNCTION, + SEMATTRS_CODE_LINENO: () => SEMATTRS_CODE_LINENO, + SEMATTRS_CODE_NAMESPACE: () => SEMATTRS_CODE_NAMESPACE, + SEMATTRS_DB_CASSANDRA_CONSISTENCY_LEVEL: () => SEMATTRS_DB_CASSANDRA_CONSISTENCY_LEVEL, + SEMATTRS_DB_CASSANDRA_COORDINATOR_DC: () => SEMATTRS_DB_CASSANDRA_COORDINATOR_DC, + SEMATTRS_DB_CASSANDRA_COORDINATOR_ID: () => SEMATTRS_DB_CASSANDRA_COORDINATOR_ID, + SEMATTRS_DB_CASSANDRA_IDEMPOTENCE: () => SEMATTRS_DB_CASSANDRA_IDEMPOTENCE, + SEMATTRS_DB_CASSANDRA_KEYSPACE: () => SEMATTRS_DB_CASSANDRA_KEYSPACE, + SEMATTRS_DB_CASSANDRA_PAGE_SIZE: () => SEMATTRS_DB_CASSANDRA_PAGE_SIZE, + SEMATTRS_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT: () => SEMATTRS_DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT, + SEMATTRS_DB_CASSANDRA_TABLE: () => SEMATTRS_DB_CASSANDRA_TABLE, + SEMATTRS_DB_CONNECTION_STRING: () => SEMATTRS_DB_CONNECTION_STRING, + SEMATTRS_DB_HBASE_NAMESPACE: () => SEMATTRS_DB_HBASE_NAMESPACE, + SEMATTRS_DB_JDBC_DRIVER_CLASSNAME: () => SEMATTRS_DB_JDBC_DRIVER_CLASSNAME, + SEMATTRS_DB_MONGODB_COLLECTION: () => SEMATTRS_DB_MONGODB_COLLECTION, + SEMATTRS_DB_MSSQL_INSTANCE_NAME: () => SEMATTRS_DB_MSSQL_INSTANCE_NAME, + SEMATTRS_DB_NAME: () => SEMATTRS_DB_NAME, + SEMATTRS_DB_OPERATION: () => SEMATTRS_DB_OPERATION, + SEMATTRS_DB_REDIS_DATABASE_INDEX: () => SEMATTRS_DB_REDIS_DATABASE_INDEX, + SEMATTRS_DB_SQL_TABLE: () => SEMATTRS_DB_SQL_TABLE, + SEMATTRS_DB_STATEMENT: () => SEMATTRS_DB_STATEMENT, + SEMATTRS_DB_SYSTEM: () => SEMATTRS_DB_SYSTEM, + SEMATTRS_DB_USER: () => SEMATTRS_DB_USER, + SEMATTRS_ENDUSER_ID: () => SEMATTRS_ENDUSER_ID, + SEMATTRS_ENDUSER_ROLE: () => SEMATTRS_ENDUSER_ROLE, + SEMATTRS_ENDUSER_SCOPE: () => SEMATTRS_ENDUSER_SCOPE, + SEMATTRS_EXCEPTION_ESCAPED: () => SEMATTRS_EXCEPTION_ESCAPED, + SEMATTRS_EXCEPTION_MESSAGE: () => SEMATTRS_EXCEPTION_MESSAGE, + SEMATTRS_EXCEPTION_STACKTRACE: () => SEMATTRS_EXCEPTION_STACKTRACE, + SEMATTRS_EXCEPTION_TYPE: () => SEMATTRS_EXCEPTION_TYPE, + SEMATTRS_FAAS_COLDSTART: () => SEMATTRS_FAAS_COLDSTART, + SEMATTRS_FAAS_CRON: () => SEMATTRS_FAAS_CRON, + SEMATTRS_FAAS_DOCUMENT_COLLECTION: () => SEMATTRS_FAAS_DOCUMENT_COLLECTION, + SEMATTRS_FAAS_DOCUMENT_NAME: () => SEMATTRS_FAAS_DOCUMENT_NAME, + SEMATTRS_FAAS_DOCUMENT_OPERATION: () => SEMATTRS_FAAS_DOCUMENT_OPERATION, + SEMATTRS_FAAS_DOCUMENT_TIME: () => SEMATTRS_FAAS_DOCUMENT_TIME, + SEMATTRS_FAAS_EXECUTION: () => SEMATTRS_FAAS_EXECUTION, + SEMATTRS_FAAS_INVOKED_NAME: () => SEMATTRS_FAAS_INVOKED_NAME, + SEMATTRS_FAAS_INVOKED_PROVIDER: () => SEMATTRS_FAAS_INVOKED_PROVIDER, + SEMATTRS_FAAS_INVOKED_REGION: () => SEMATTRS_FAAS_INVOKED_REGION, + SEMATTRS_FAAS_TIME: () => SEMATTRS_FAAS_TIME, + SEMATTRS_FAAS_TRIGGER: () => SEMATTRS_FAAS_TRIGGER, + SEMATTRS_HTTP_CLIENT_IP: () => SEMATTRS_HTTP_CLIENT_IP, + SEMATTRS_HTTP_FLAVOR: () => SEMATTRS_HTTP_FLAVOR, + SEMATTRS_HTTP_HOST: () => SEMATTRS_HTTP_HOST, + SEMATTRS_HTTP_METHOD: () => SEMATTRS_HTTP_METHOD, + SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH: () => SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH, + SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED: () => SEMATTRS_HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED, + SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH: () => SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH, + SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED: () => SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED, + SEMATTRS_HTTP_ROUTE: () => SEMATTRS_HTTP_ROUTE, + SEMATTRS_HTTP_SCHEME: () => SEMATTRS_HTTP_SCHEME, + SEMATTRS_HTTP_SERVER_NAME: () => SEMATTRS_HTTP_SERVER_NAME, + SEMATTRS_HTTP_STATUS_CODE: () => SEMATTRS_HTTP_STATUS_CODE, + SEMATTRS_HTTP_TARGET: () => SEMATTRS_HTTP_TARGET, + SEMATTRS_HTTP_URL: () => SEMATTRS_HTTP_URL, + SEMATTRS_HTTP_USER_AGENT: () => SEMATTRS_HTTP_USER_AGENT, + SEMATTRS_MESSAGE_COMPRESSED_SIZE: () => SEMATTRS_MESSAGE_COMPRESSED_SIZE, + SEMATTRS_MESSAGE_ID: () => SEMATTRS_MESSAGE_ID, + SEMATTRS_MESSAGE_TYPE: () => SEMATTRS_MESSAGE_TYPE, + SEMATTRS_MESSAGE_UNCOMPRESSED_SIZE: () => SEMATTRS_MESSAGE_UNCOMPRESSED_SIZE, + SEMATTRS_MESSAGING_CONSUMER_ID: () => SEMATTRS_MESSAGING_CONSUMER_ID, + SEMATTRS_MESSAGING_CONVERSATION_ID: () => SEMATTRS_MESSAGING_CONVERSATION_ID, + SEMATTRS_MESSAGING_DESTINATION: () => SEMATTRS_MESSAGING_DESTINATION, + SEMATTRS_MESSAGING_DESTINATION_KIND: () => SEMATTRS_MESSAGING_DESTINATION_KIND, + SEMATTRS_MESSAGING_KAFKA_CLIENT_ID: () => SEMATTRS_MESSAGING_KAFKA_CLIENT_ID, + SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP: () => SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP, + SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY: () => SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY, + SEMATTRS_MESSAGING_KAFKA_PARTITION: () => SEMATTRS_MESSAGING_KAFKA_PARTITION, + SEMATTRS_MESSAGING_KAFKA_TOMBSTONE: () => SEMATTRS_MESSAGING_KAFKA_TOMBSTONE, + SEMATTRS_MESSAGING_MESSAGE_ID: () => SEMATTRS_MESSAGING_MESSAGE_ID, + SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES: () => SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES, + SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES: () => SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES, + SEMATTRS_MESSAGING_OPERATION: () => SEMATTRS_MESSAGING_OPERATION, + SEMATTRS_MESSAGING_PROTOCOL: () => SEMATTRS_MESSAGING_PROTOCOL, + SEMATTRS_MESSAGING_PROTOCOL_VERSION: () => SEMATTRS_MESSAGING_PROTOCOL_VERSION, + SEMATTRS_MESSAGING_RABBITMQ_ROUTING_KEY: () => SEMATTRS_MESSAGING_RABBITMQ_ROUTING_KEY, + SEMATTRS_MESSAGING_SYSTEM: () => SEMATTRS_MESSAGING_SYSTEM, + SEMATTRS_MESSAGING_TEMP_DESTINATION: () => SEMATTRS_MESSAGING_TEMP_DESTINATION, + SEMATTRS_MESSAGING_URL: () => SEMATTRS_MESSAGING_URL, + SEMATTRS_NET_HOST_CARRIER_ICC: () => SEMATTRS_NET_HOST_CARRIER_ICC, + SEMATTRS_NET_HOST_CARRIER_MCC: () => SEMATTRS_NET_HOST_CARRIER_MCC, + SEMATTRS_NET_HOST_CARRIER_MNC: () => SEMATTRS_NET_HOST_CARRIER_MNC, + SEMATTRS_NET_HOST_CARRIER_NAME: () => SEMATTRS_NET_HOST_CARRIER_NAME, + SEMATTRS_NET_HOST_CONNECTION_SUBTYPE: () => SEMATTRS_NET_HOST_CONNECTION_SUBTYPE, + SEMATTRS_NET_HOST_CONNECTION_TYPE: () => SEMATTRS_NET_HOST_CONNECTION_TYPE, + SEMATTRS_NET_HOST_IP: () => SEMATTRS_NET_HOST_IP, + SEMATTRS_NET_HOST_NAME: () => SEMATTRS_NET_HOST_NAME, + SEMATTRS_NET_HOST_PORT: () => SEMATTRS_NET_HOST_PORT, + SEMATTRS_NET_PEER_IP: () => SEMATTRS_NET_PEER_IP, + SEMATTRS_NET_PEER_NAME: () => SEMATTRS_NET_PEER_NAME, + SEMATTRS_NET_PEER_PORT: () => SEMATTRS_NET_PEER_PORT, + SEMATTRS_NET_TRANSPORT: () => SEMATTRS_NET_TRANSPORT, + SEMATTRS_PEER_SERVICE: () => SEMATTRS_PEER_SERVICE, + SEMATTRS_RPC_GRPC_STATUS_CODE: () => SEMATTRS_RPC_GRPC_STATUS_CODE, + SEMATTRS_RPC_JSONRPC_ERROR_CODE: () => SEMATTRS_RPC_JSONRPC_ERROR_CODE, + SEMATTRS_RPC_JSONRPC_ERROR_MESSAGE: () => SEMATTRS_RPC_JSONRPC_ERROR_MESSAGE, + SEMATTRS_RPC_JSONRPC_REQUEST_ID: () => SEMATTRS_RPC_JSONRPC_REQUEST_ID, + SEMATTRS_RPC_JSONRPC_VERSION: () => SEMATTRS_RPC_JSONRPC_VERSION, + SEMATTRS_RPC_METHOD: () => SEMATTRS_RPC_METHOD, + SEMATTRS_RPC_SERVICE: () => SEMATTRS_RPC_SERVICE, + SEMATTRS_RPC_SYSTEM: () => SEMATTRS_RPC_SYSTEM, + SEMATTRS_THREAD_ID: () => SEMATTRS_THREAD_ID, + SEMATTRS_THREAD_NAME: () => SEMATTRS_THREAD_NAME, + SEMRESATTRS_AWS_ECS_CLUSTER_ARN: () => SEMRESATTRS_AWS_ECS_CLUSTER_ARN, + SEMRESATTRS_AWS_ECS_CONTAINER_ARN: () => SEMRESATTRS_AWS_ECS_CONTAINER_ARN, + SEMRESATTRS_AWS_ECS_LAUNCHTYPE: () => SEMRESATTRS_AWS_ECS_LAUNCHTYPE, + SEMRESATTRS_AWS_ECS_TASK_ARN: () => SEMRESATTRS_AWS_ECS_TASK_ARN, + SEMRESATTRS_AWS_ECS_TASK_FAMILY: () => SEMRESATTRS_AWS_ECS_TASK_FAMILY, + SEMRESATTRS_AWS_ECS_TASK_REVISION: () => SEMRESATTRS_AWS_ECS_TASK_REVISION, + SEMRESATTRS_AWS_EKS_CLUSTER_ARN: () => SEMRESATTRS_AWS_EKS_CLUSTER_ARN, + SEMRESATTRS_AWS_LOG_GROUP_ARNS: () => SEMRESATTRS_AWS_LOG_GROUP_ARNS, + SEMRESATTRS_AWS_LOG_GROUP_NAMES: () => SEMRESATTRS_AWS_LOG_GROUP_NAMES, + SEMRESATTRS_AWS_LOG_STREAM_ARNS: () => SEMRESATTRS_AWS_LOG_STREAM_ARNS, + SEMRESATTRS_AWS_LOG_STREAM_NAMES: () => SEMRESATTRS_AWS_LOG_STREAM_NAMES, + SEMRESATTRS_CLOUD_ACCOUNT_ID: () => SEMRESATTRS_CLOUD_ACCOUNT_ID, + SEMRESATTRS_CLOUD_AVAILABILITY_ZONE: () => SEMRESATTRS_CLOUD_AVAILABILITY_ZONE, + SEMRESATTRS_CLOUD_PLATFORM: () => SEMRESATTRS_CLOUD_PLATFORM, + SEMRESATTRS_CLOUD_PROVIDER: () => SEMRESATTRS_CLOUD_PROVIDER, + SEMRESATTRS_CLOUD_REGION: () => SEMRESATTRS_CLOUD_REGION, + SEMRESATTRS_CONTAINER_ID: () => SEMRESATTRS_CONTAINER_ID, + SEMRESATTRS_CONTAINER_IMAGE_NAME: () => SEMRESATTRS_CONTAINER_IMAGE_NAME, + SEMRESATTRS_CONTAINER_IMAGE_TAG: () => SEMRESATTRS_CONTAINER_IMAGE_TAG, + SEMRESATTRS_CONTAINER_NAME: () => SEMRESATTRS_CONTAINER_NAME, + SEMRESATTRS_CONTAINER_RUNTIME: () => SEMRESATTRS_CONTAINER_RUNTIME, + SEMRESATTRS_DEPLOYMENT_ENVIRONMENT: () => SEMRESATTRS_DEPLOYMENT_ENVIRONMENT, + SEMRESATTRS_DEVICE_ID: () => SEMRESATTRS_DEVICE_ID, + SEMRESATTRS_DEVICE_MODEL_IDENTIFIER: () => SEMRESATTRS_DEVICE_MODEL_IDENTIFIER, + SEMRESATTRS_DEVICE_MODEL_NAME: () => SEMRESATTRS_DEVICE_MODEL_NAME, + SEMRESATTRS_FAAS_ID: () => SEMRESATTRS_FAAS_ID, + SEMRESATTRS_FAAS_INSTANCE: () => SEMRESATTRS_FAAS_INSTANCE, + SEMRESATTRS_FAAS_MAX_MEMORY: () => SEMRESATTRS_FAAS_MAX_MEMORY, + SEMRESATTRS_FAAS_NAME: () => SEMRESATTRS_FAAS_NAME, + SEMRESATTRS_FAAS_VERSION: () => SEMRESATTRS_FAAS_VERSION, + SEMRESATTRS_HOST_ARCH: () => SEMRESATTRS_HOST_ARCH, + SEMRESATTRS_HOST_ID: () => SEMRESATTRS_HOST_ID, + SEMRESATTRS_HOST_IMAGE_ID: () => SEMRESATTRS_HOST_IMAGE_ID, + SEMRESATTRS_HOST_IMAGE_NAME: () => SEMRESATTRS_HOST_IMAGE_NAME, + SEMRESATTRS_HOST_IMAGE_VERSION: () => SEMRESATTRS_HOST_IMAGE_VERSION, + SEMRESATTRS_HOST_NAME: () => SEMRESATTRS_HOST_NAME, + SEMRESATTRS_HOST_TYPE: () => SEMRESATTRS_HOST_TYPE, + SEMRESATTRS_K8S_CLUSTER_NAME: () => SEMRESATTRS_K8S_CLUSTER_NAME, + SEMRESATTRS_K8S_CONTAINER_NAME: () => SEMRESATTRS_K8S_CONTAINER_NAME, + SEMRESATTRS_K8S_CRONJOB_NAME: () => SEMRESATTRS_K8S_CRONJOB_NAME, + SEMRESATTRS_K8S_CRONJOB_UID: () => SEMRESATTRS_K8S_CRONJOB_UID, + SEMRESATTRS_K8S_DAEMONSET_NAME: () => SEMRESATTRS_K8S_DAEMONSET_NAME, + SEMRESATTRS_K8S_DAEMONSET_UID: () => SEMRESATTRS_K8S_DAEMONSET_UID, + SEMRESATTRS_K8S_DEPLOYMENT_NAME: () => SEMRESATTRS_K8S_DEPLOYMENT_NAME, + SEMRESATTRS_K8S_DEPLOYMENT_UID: () => SEMRESATTRS_K8S_DEPLOYMENT_UID, + SEMRESATTRS_K8S_JOB_NAME: () => SEMRESATTRS_K8S_JOB_NAME, + SEMRESATTRS_K8S_JOB_UID: () => SEMRESATTRS_K8S_JOB_UID, + SEMRESATTRS_K8S_NAMESPACE_NAME: () => SEMRESATTRS_K8S_NAMESPACE_NAME, + SEMRESATTRS_K8S_NODE_NAME: () => SEMRESATTRS_K8S_NODE_NAME, + SEMRESATTRS_K8S_NODE_UID: () => SEMRESATTRS_K8S_NODE_UID, + SEMRESATTRS_K8S_POD_NAME: () => SEMRESATTRS_K8S_POD_NAME, + SEMRESATTRS_K8S_POD_UID: () => SEMRESATTRS_K8S_POD_UID, + SEMRESATTRS_K8S_REPLICASET_NAME: () => SEMRESATTRS_K8S_REPLICASET_NAME, + SEMRESATTRS_K8S_REPLICASET_UID: () => SEMRESATTRS_K8S_REPLICASET_UID, + SEMRESATTRS_K8S_STATEFULSET_NAME: () => SEMRESATTRS_K8S_STATEFULSET_NAME, + SEMRESATTRS_K8S_STATEFULSET_UID: () => SEMRESATTRS_K8S_STATEFULSET_UID, + SEMRESATTRS_OS_DESCRIPTION: () => SEMRESATTRS_OS_DESCRIPTION, + SEMRESATTRS_OS_NAME: () => SEMRESATTRS_OS_NAME, + SEMRESATTRS_OS_TYPE: () => SEMRESATTRS_OS_TYPE, + SEMRESATTRS_OS_VERSION: () => SEMRESATTRS_OS_VERSION, + SEMRESATTRS_PROCESS_COMMAND: () => SEMRESATTRS_PROCESS_COMMAND, + SEMRESATTRS_PROCESS_COMMAND_ARGS: () => SEMRESATTRS_PROCESS_COMMAND_ARGS, + SEMRESATTRS_PROCESS_COMMAND_LINE: () => SEMRESATTRS_PROCESS_COMMAND_LINE, + SEMRESATTRS_PROCESS_EXECUTABLE_NAME: () => SEMRESATTRS_PROCESS_EXECUTABLE_NAME, + SEMRESATTRS_PROCESS_EXECUTABLE_PATH: () => SEMRESATTRS_PROCESS_EXECUTABLE_PATH, + SEMRESATTRS_PROCESS_OWNER: () => SEMRESATTRS_PROCESS_OWNER, + SEMRESATTRS_PROCESS_PID: () => SEMRESATTRS_PROCESS_PID, + SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION: () => SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION, + SEMRESATTRS_PROCESS_RUNTIME_NAME: () => SEMRESATTRS_PROCESS_RUNTIME_NAME, + SEMRESATTRS_PROCESS_RUNTIME_VERSION: () => SEMRESATTRS_PROCESS_RUNTIME_VERSION, + SEMRESATTRS_SERVICE_INSTANCE_ID: () => SEMRESATTRS_SERVICE_INSTANCE_ID, + SEMRESATTRS_SERVICE_NAME: () => SEMRESATTRS_SERVICE_NAME, + SEMRESATTRS_SERVICE_NAMESPACE: () => SEMRESATTRS_SERVICE_NAMESPACE, + SEMRESATTRS_SERVICE_VERSION: () => SEMRESATTRS_SERVICE_VERSION, + SEMRESATTRS_TELEMETRY_AUTO_VERSION: () => SEMRESATTRS_TELEMETRY_AUTO_VERSION, + SEMRESATTRS_TELEMETRY_SDK_LANGUAGE: () => SEMRESATTRS_TELEMETRY_SDK_LANGUAGE, + SEMRESATTRS_TELEMETRY_SDK_NAME: () => SEMRESATTRS_TELEMETRY_SDK_NAME, + SEMRESATTRS_TELEMETRY_SDK_VERSION: () => SEMRESATTRS_TELEMETRY_SDK_VERSION, + SEMRESATTRS_WEBENGINE_DESCRIPTION: () => SEMRESATTRS_WEBENGINE_DESCRIPTION, + SEMRESATTRS_WEBENGINE_NAME: () => SEMRESATTRS_WEBENGINE_NAME, + SEMRESATTRS_WEBENGINE_VERSION: () => SEMRESATTRS_WEBENGINE_VERSION, + SIGNALR_CONNECTION_STATUS_VALUE_APP_SHUTDOWN: () => SIGNALR_CONNECTION_STATUS_VALUE_APP_SHUTDOWN, + SIGNALR_CONNECTION_STATUS_VALUE_NORMAL_CLOSURE: () => SIGNALR_CONNECTION_STATUS_VALUE_NORMAL_CLOSURE, + SIGNALR_CONNECTION_STATUS_VALUE_TIMEOUT: () => SIGNALR_CONNECTION_STATUS_VALUE_TIMEOUT, + SIGNALR_TRANSPORT_VALUE_LONG_POLLING: () => SIGNALR_TRANSPORT_VALUE_LONG_POLLING, + SIGNALR_TRANSPORT_VALUE_SERVER_SENT_EVENTS: () => SIGNALR_TRANSPORT_VALUE_SERVER_SENT_EVENTS, + SIGNALR_TRANSPORT_VALUE_WEB_SOCKETS: () => SIGNALR_TRANSPORT_VALUE_WEB_SOCKETS, + SemanticAttributes: () => SemanticAttributes, + SemanticResourceAttributes: () => SemanticResourceAttributes, + TELEMETRYSDKLANGUAGEVALUES_CPP: () => TELEMETRYSDKLANGUAGEVALUES_CPP, + TELEMETRYSDKLANGUAGEVALUES_DOTNET: () => TELEMETRYSDKLANGUAGEVALUES_DOTNET, + TELEMETRYSDKLANGUAGEVALUES_ERLANG: () => TELEMETRYSDKLANGUAGEVALUES_ERLANG, + TELEMETRYSDKLANGUAGEVALUES_GO: () => TELEMETRYSDKLANGUAGEVALUES_GO, + TELEMETRYSDKLANGUAGEVALUES_JAVA: () => TELEMETRYSDKLANGUAGEVALUES_JAVA, + TELEMETRYSDKLANGUAGEVALUES_NODEJS: () => TELEMETRYSDKLANGUAGEVALUES_NODEJS, + TELEMETRYSDKLANGUAGEVALUES_PHP: () => TELEMETRYSDKLANGUAGEVALUES_PHP, + TELEMETRYSDKLANGUAGEVALUES_PYTHON: () => TELEMETRYSDKLANGUAGEVALUES_PYTHON, + TELEMETRYSDKLANGUAGEVALUES_RUBY: () => TELEMETRYSDKLANGUAGEVALUES_RUBY, + TELEMETRYSDKLANGUAGEVALUES_WEBJS: () => TELEMETRYSDKLANGUAGEVALUES_WEBJS, + TELEMETRY_SDK_LANGUAGE_VALUE_CPP: () => TELEMETRY_SDK_LANGUAGE_VALUE_CPP, + TELEMETRY_SDK_LANGUAGE_VALUE_DOTNET: () => TELEMETRY_SDK_LANGUAGE_VALUE_DOTNET, + TELEMETRY_SDK_LANGUAGE_VALUE_ERLANG: () => TELEMETRY_SDK_LANGUAGE_VALUE_ERLANG, + TELEMETRY_SDK_LANGUAGE_VALUE_GO: () => TELEMETRY_SDK_LANGUAGE_VALUE_GO, + TELEMETRY_SDK_LANGUAGE_VALUE_JAVA: () => TELEMETRY_SDK_LANGUAGE_VALUE_JAVA, + TELEMETRY_SDK_LANGUAGE_VALUE_KOTLIN: () => TELEMETRY_SDK_LANGUAGE_VALUE_KOTLIN, + TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS: () => TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS, + TELEMETRY_SDK_LANGUAGE_VALUE_PHP: () => TELEMETRY_SDK_LANGUAGE_VALUE_PHP, + TELEMETRY_SDK_LANGUAGE_VALUE_PYTHON: () => TELEMETRY_SDK_LANGUAGE_VALUE_PYTHON, + TELEMETRY_SDK_LANGUAGE_VALUE_RUBY: () => TELEMETRY_SDK_LANGUAGE_VALUE_RUBY, + TELEMETRY_SDK_LANGUAGE_VALUE_RUST: () => TELEMETRY_SDK_LANGUAGE_VALUE_RUST, + TELEMETRY_SDK_LANGUAGE_VALUE_SWIFT: () => TELEMETRY_SDK_LANGUAGE_VALUE_SWIFT, + TELEMETRY_SDK_LANGUAGE_VALUE_WEBJS: () => TELEMETRY_SDK_LANGUAGE_VALUE_WEBJS, + TelemetrySdkLanguageValues: () => TelemetrySdkLanguageValues +}); +var init_esm2 = __esm({ + "node_modules/@opentelemetry/semantic-conventions/build/esm/index.js"() { + init_trace2(); + init_resource(); + init_stable_attributes(); + init_stable_metrics(); + init_stable_events(); + } +}); + +// node_modules/@opentelemetry/core/build/src/semconv.js +var require_semconv = __commonJS({ + "node_modules/@opentelemetry/core/build/src/semconv.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ATTR_PROCESS_RUNTIME_NAME = void 0; + exports.ATTR_PROCESS_RUNTIME_NAME = "process.runtime.name"; + } +}); + +// node_modules/@opentelemetry/core/build/src/platform/node/sdk-info.js +var require_sdk_info = __commonJS({ + "node_modules/@opentelemetry/core/build/src/platform/node/sdk-info.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SDK_INFO = void 0; + var version_1 = require_version(); + var semantic_conventions_1 = (init_esm2(), __toCommonJS(esm_exports2)); + var semconv_1 = require_semconv(); + exports.SDK_INFO = { + [semantic_conventions_1.ATTR_TELEMETRY_SDK_NAME]: "opentelemetry", + [semconv_1.ATTR_PROCESS_RUNTIME_NAME]: "node", + [semantic_conventions_1.ATTR_TELEMETRY_SDK_LANGUAGE]: semantic_conventions_1.TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS, + [semantic_conventions_1.ATTR_TELEMETRY_SDK_VERSION]: version_1.VERSION + }; + } +}); + +// node_modules/@opentelemetry/core/build/src/platform/node/index.js +var require_node = __commonJS({ + "node_modules/@opentelemetry/core/build/src/platform/node/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.otperformance = exports.SDK_INFO = exports._globalThis = exports.getStringListFromEnv = exports.getNumberFromEnv = exports.getBooleanFromEnv = exports.getStringFromEnv = void 0; + var environment_1 = require_environment(); + Object.defineProperty(exports, "getStringFromEnv", { enumerable: true, get: function() { + return environment_1.getStringFromEnv; + } }); + Object.defineProperty(exports, "getBooleanFromEnv", { enumerable: true, get: function() { + return environment_1.getBooleanFromEnv; + } }); + Object.defineProperty(exports, "getNumberFromEnv", { enumerable: true, get: function() { + return environment_1.getNumberFromEnv; + } }); + Object.defineProperty(exports, "getStringListFromEnv", { enumerable: true, get: function() { + return environment_1.getStringListFromEnv; + } }); + var globalThis_1 = require_globalThis(); + Object.defineProperty(exports, "_globalThis", { enumerable: true, get: function() { + return globalThis_1._globalThis; + } }); + var sdk_info_1 = require_sdk_info(); + Object.defineProperty(exports, "SDK_INFO", { enumerable: true, get: function() { + return sdk_info_1.SDK_INFO; + } }); + exports.otperformance = performance; + } +}); + +// node_modules/@opentelemetry/core/build/src/platform/index.js +var require_platform = __commonJS({ + "node_modules/@opentelemetry/core/build/src/platform/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getStringListFromEnv = exports.getNumberFromEnv = exports.getStringFromEnv = exports.getBooleanFromEnv = exports.otperformance = exports._globalThis = exports.SDK_INFO = void 0; + var node_1 = require_node(); + Object.defineProperty(exports, "SDK_INFO", { enumerable: true, get: function() { + return node_1.SDK_INFO; + } }); + Object.defineProperty(exports, "_globalThis", { enumerable: true, get: function() { + return node_1._globalThis; + } }); + Object.defineProperty(exports, "otperformance", { enumerable: true, get: function() { + return node_1.otperformance; + } }); + Object.defineProperty(exports, "getBooleanFromEnv", { enumerable: true, get: function() { + return node_1.getBooleanFromEnv; + } }); + Object.defineProperty(exports, "getStringFromEnv", { enumerable: true, get: function() { + return node_1.getStringFromEnv; + } }); + Object.defineProperty(exports, "getNumberFromEnv", { enumerable: true, get: function() { + return node_1.getNumberFromEnv; + } }); + Object.defineProperty(exports, "getStringListFromEnv", { enumerable: true, get: function() { + return node_1.getStringListFromEnv; + } }); + } +}); + +// node_modules/@opentelemetry/core/build/src/common/time.js +var require_time = __commonJS({ + "node_modules/@opentelemetry/core/build/src/common/time.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.addHrTimes = exports.isTimeInput = exports.isTimeInputHrTime = exports.hrTimeToSeconds = exports.hrTimeToMilliseconds = exports.hrTimeToMicroseconds = exports.hrTimeToNanoseconds = exports.hrTimeToTimeStamp = exports.hrTimeDuration = exports.timeInputToHrTime = exports.hrTime = exports.getTimeOrigin = exports.millisToHrTime = void 0; + var platform_1 = require_platform(); + var NANOSECOND_DIGITS = 9; + var NANOSECOND_DIGITS_IN_MILLIS = 6; + var MILLISECONDS_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS_IN_MILLIS); + var SECOND_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS); + function millisToHrTime(epochMillis) { + const epochSeconds = epochMillis / 1e3; + const seconds = Math.trunc(epochSeconds); + const nanos = Math.round(epochMillis % 1e3 * MILLISECONDS_TO_NANOSECONDS); + return [seconds, nanos]; + } + exports.millisToHrTime = millisToHrTime; + function getTimeOrigin() { + return platform_1.otperformance.timeOrigin; + } + exports.getTimeOrigin = getTimeOrigin; + function hrTime2(performanceNow) { + const timeOrigin = millisToHrTime(platform_1.otperformance.timeOrigin); + const now = millisToHrTime(typeof performanceNow === "number" ? performanceNow : platform_1.otperformance.now()); + return addHrTimes(timeOrigin, now); + } + exports.hrTime = hrTime2; + function timeInputToHrTime(time) { + if (isTimeInputHrTime(time)) { + return time; + } else if (typeof time === "number") { + if (time < platform_1.otperformance.timeOrigin / 2) { + return hrTime2(time); + } else { + return millisToHrTime(time); + } + } else if (time instanceof Date) { + return millisToHrTime(time.getTime()); + } else { + throw TypeError("Invalid input type"); + } + } + exports.timeInputToHrTime = timeInputToHrTime; + function hrTimeDuration2(startTime, endTime) { + let seconds = endTime[0] - startTime[0]; + let nanos = endTime[1] - startTime[1]; + if (nanos < 0) { + seconds -= 1; + nanos += SECOND_TO_NANOSECONDS; + } + return [seconds, nanos]; + } + exports.hrTimeDuration = hrTimeDuration2; + function hrTimeToTimeStamp(time) { + const precision = NANOSECOND_DIGITS; + const tmp = `${"0".repeat(precision)}${time[1]}Z`; + const nanoString = tmp.substring(tmp.length - precision - 1); + const date = new Date(time[0] * 1e3).toISOString(); + return date.replace("000Z", nanoString); + } + exports.hrTimeToTimeStamp = hrTimeToTimeStamp; + function hrTimeToNanoseconds(time) { + return time[0] * SECOND_TO_NANOSECONDS + time[1]; + } + exports.hrTimeToNanoseconds = hrTimeToNanoseconds; + function hrTimeToMicroseconds(time) { + return time[0] * 1e6 + time[1] / 1e3; + } + exports.hrTimeToMicroseconds = hrTimeToMicroseconds; + function hrTimeToMilliseconds3(time) { + return time[0] * 1e3 + time[1] / 1e6; + } + exports.hrTimeToMilliseconds = hrTimeToMilliseconds3; + function hrTimeToSeconds(time) { + return time[0] + time[1] / SECOND_TO_NANOSECONDS; + } + exports.hrTimeToSeconds = hrTimeToSeconds; + function isTimeInputHrTime(value) { + return Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number"; + } + exports.isTimeInputHrTime = isTimeInputHrTime; + function isTimeInput(value) { + return isTimeInputHrTime(value) || typeof value === "number" || value instanceof Date; + } + exports.isTimeInput = isTimeInput; + function addHrTimes(time1, time2) { + const out = [time1[0] + time2[0], time1[1] + time2[1]]; + if (out[1] >= SECOND_TO_NANOSECONDS) { + out[1] -= SECOND_TO_NANOSECONDS; + out[0] += 1; + } + return out; + } + exports.addHrTimes = addHrTimes; + } +}); + +// node_modules/@opentelemetry/core/build/src/common/timer-util.js +var require_timer_util = __commonJS({ + "node_modules/@opentelemetry/core/build/src/common/timer-util.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.unrefTimer = void 0; + function unrefTimer(timer) { + if (typeof timer !== "number") { + timer.unref(); + } + } + exports.unrefTimer = unrefTimer; + } +}); + +// node_modules/@opentelemetry/core/build/src/ExportResult.js +var require_ExportResult = __commonJS({ + "node_modules/@opentelemetry/core/build/src/ExportResult.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ExportResultCode = void 0; + var ExportResultCode2; + (function(ExportResultCode3) { + ExportResultCode3[ExportResultCode3["SUCCESS"] = 0] = "SUCCESS"; + ExportResultCode3[ExportResultCode3["FAILED"] = 1] = "FAILED"; + })(ExportResultCode2 || (exports.ExportResultCode = ExportResultCode2 = {})); + } +}); + +// node_modules/@opentelemetry/core/build/src/propagation/composite.js +var require_composite = __commonJS({ + "node_modules/@opentelemetry/core/build/src/propagation/composite.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.CompositePropagator = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var CompositePropagator = class { + _propagators; + _fields; + /** + * Construct a composite propagator from a list of propagators. + * + * @param [config] Configuration object for composite propagator + */ + constructor(config = {}) { + this._propagators = config.propagators ?? []; + const fields = /* @__PURE__ */ new Set(); + for (const propagator of this._propagators) { + const propagatorFields = typeof propagator.fields === "function" ? propagator.fields() : []; + for (const field of propagatorFields) { + fields.add(field); + } + } + this._fields = Array.from(fields); + } + /** + * Run each of the configured propagators with the given context and carrier. + * Propagators are run in the order they are configured, so if multiple + * propagators write the same carrier key, the propagator later in the list + * will "win". + * + * @param context Context to inject + * @param carrier Carrier into which context will be injected + */ + inject(context2, carrier, setter) { + for (const propagator of this._propagators) { + try { + propagator.inject(context2, carrier, setter); + } catch (err) { + api_1.diag.warn(`Failed to inject with ${propagator.constructor.name}. Err: ${err.message}`); + } + } + } + /** + * Run each of the configured propagators with the given context and carrier. + * Propagators are run in the order they are configured, so if multiple + * propagators write the same context key, the propagator later in the list + * will "win". + * + * @param context Context to add values to + * @param carrier Carrier from which to extract context + */ + extract(context2, carrier, getter) { + return this._propagators.reduce((ctx, propagator) => { + try { + return propagator.extract(ctx, carrier, getter); + } catch (err) { + api_1.diag.warn(`Failed to extract with ${propagator.constructor.name}. Err: ${err.message}`); + } + return ctx; + }, context2); + } + fields() { + return this._fields.slice(); + } + }; + exports.CompositePropagator = CompositePropagator; + } +}); + +// node_modules/@opentelemetry/core/build/src/internal/validators.js +var require_validators = __commonJS({ + "node_modules/@opentelemetry/core/build/src/internal/validators.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.validateValue = exports.validateKey = void 0; + var VALID_KEY_CHAR_RANGE2 = "[_0-9a-z-*/]"; + var VALID_KEY2 = `[a-z]${VALID_KEY_CHAR_RANGE2}{0,255}`; + var VALID_VENDOR_KEY2 = `[a-z0-9]${VALID_KEY_CHAR_RANGE2}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE2}{0,13}`; + var VALID_KEY_REGEX2 = new RegExp(`^(?:${VALID_KEY2}|${VALID_VENDOR_KEY2})$`); + var VALID_VALUE_BASE_REGEX2 = /^[ -~]{0,255}[!-~]$/; + var INVALID_VALUE_COMMA_EQUAL_REGEX2 = /,|=/; + function validateKey2(key) { + return VALID_KEY_REGEX2.test(key); + } + exports.validateKey = validateKey2; + function validateValue2(value) { + return VALID_VALUE_BASE_REGEX2.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX2.test(value); + } + exports.validateValue = validateValue2; + } +}); + +// node_modules/@opentelemetry/core/build/src/trace/TraceState.js +var require_TraceState = __commonJS({ + "node_modules/@opentelemetry/core/build/src/trace/TraceState.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.TraceState = void 0; + var validators_1 = require_validators(); + var MAX_TRACE_STATE_ITEMS2 = 32; + var MAX_TRACE_STATE_LEN2 = 512; + var LIST_MEMBERS_SEPARATOR2 = ","; + var LIST_MEMBER_KEY_VALUE_SPLITTER2 = "="; + var TraceState = class _TraceState { + _length; + _rawTraceState; + _internalState; + constructor(rawTraceState) { + this._rawTraceState = typeof rawTraceState === "string" ? rawTraceState : ""; + this._length = this._rawTraceState.length; + } + set(key, value) { + if (!(0, validators_1.validateKey)(key) || !(0, validators_1.validateValue)(value)) { + return this; + } + const currState = this._getState(); + const currValue = currState.get(key); + let newLength = this._length; + if (typeof currValue === "string") { + newLength += value.length - currValue.length; + } else { + newLength += key.length + value.length + (currState.size > 0 ? 2 : 1); + } + if (newLength > MAX_TRACE_STATE_LEN2) { + return this; + } + const newState = new Map(currState); + newState.delete(key); + newState.set(key, value); + return this._fromState(newState, newLength); + } + unset(key) { + const currState = this._getState(); + const currValue = currState.get(key); + if (typeof currValue !== "string") { + return this; + } + let newLength = this._length - (key.length + currValue.length + 1); + if (currState.size > 1) { + newLength = newLength - 1; + } + const newState = new Map(currState); + newState.delete(key); + return this._fromState(newState, newLength); + } + get(key) { + const currState = this._getState(); + return currState.get(key); + } + serialize() { + let serialized = ""; + let index = 0; + for (const entry of this._getState()) { + if (index > 0) { + serialized = LIST_MEMBERS_SEPARATOR2 + serialized; + } + serialized = `${entry[0]}${LIST_MEMBER_KEY_VALUE_SPLITTER2}${entry[1]}` + serialized; + index++; + } + return serialized; + } + _getState() { + if (this._internalState) { + return this._internalState; + } + const vendorMembers = this._rawTraceState.split(LIST_MEMBERS_SEPARATOR2); + const vendorEntries = /* @__PURE__ */ new Map(); + let currentLength = 0; + for (const member of vendorMembers) { + const m = member.trim(); + const idx = m.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER2); + if (idx === -1) { + continue; + } + const key = m.slice(0, idx); + const value = m.slice(idx + 1); + if (!(0, validators_1.validateKey)(key) || !(0, validators_1.validateValue)(value)) { + continue; + } + const futureLength = currentLength + m.length + (vendorEntries.size > 0 ? 1 : 0); + if (futureLength > MAX_TRACE_STATE_LEN2) { + continue; + } + vendorEntries.set(key, value); + currentLength = futureLength; + if (vendorEntries.size >= MAX_TRACE_STATE_ITEMS2) { + break; + } + } + this._length = currentLength; + this._internalState = new Map(Array.from(vendorEntries.entries()).reverse()); + return this._internalState; + } + _fromState(state, length) { + const traceState = Object.create(_TraceState.prototype); + traceState._internalState = state; + traceState._length = length; + return traceState; + } + }; + exports.TraceState = TraceState; + } +}); + +// node_modules/@opentelemetry/core/build/src/trace/W3CTraceContextPropagator.js +var require_W3CTraceContextPropagator = __commonJS({ + "node_modules/@opentelemetry/core/build/src/trace/W3CTraceContextPropagator.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.W3CTraceContextPropagator = exports.parseTraceParent = exports.TRACE_STATE_HEADER = exports.TRACE_PARENT_HEADER = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var suppress_tracing_1 = require_suppress_tracing(); + var TraceState_1 = require_TraceState(); + exports.TRACE_PARENT_HEADER = "traceparent"; + exports.TRACE_STATE_HEADER = "tracestate"; + var VERSION3 = "00"; + var VERSION_PART = "(?!ff)[\\da-f]{2}"; + var TRACE_ID_PART = "(?![0]{32})[\\da-f]{32}"; + var PARENT_ID_PART = "(?![0]{16})[\\da-f]{16}"; + var FLAGS_PART = "[\\da-f]{2}"; + var TRACE_PARENT_REGEX = new RegExp(`^\\s?(${VERSION_PART})-(${TRACE_ID_PART})-(${PARENT_ID_PART})-(${FLAGS_PART})(-.*)?\\s?$`); + function parseTraceParent(traceParent) { + const match = TRACE_PARENT_REGEX.exec(traceParent); + if (!match) + return null; + if (match[1] === "00" && match[5]) + return null; + return { + traceId: match[2], + spanId: match[3], + traceFlags: parseInt(match[4], 16) + }; + } + exports.parseTraceParent = parseTraceParent; + var W3CTraceContextPropagator = class { + inject(context2, carrier, setter) { + const spanContext = api_1.trace.getSpanContext(context2); + if (!spanContext || (0, suppress_tracing_1.isTracingSuppressed)(context2) || !(0, api_1.isSpanContextValid)(spanContext)) + return; + const traceParent = `${VERSION3}-${spanContext.traceId}-${spanContext.spanId}-0${Number(spanContext.traceFlags || api_1.TraceFlags.NONE).toString(16)}`; + setter.set(carrier, exports.TRACE_PARENT_HEADER, traceParent); + if (spanContext.traceState) { + setter.set(carrier, exports.TRACE_STATE_HEADER, spanContext.traceState.serialize()); + } + } + extract(context2, carrier, getter) { + const traceParentHeader = getter.get(carrier, exports.TRACE_PARENT_HEADER); + if (!traceParentHeader) + return context2; + const traceParent = Array.isArray(traceParentHeader) ? traceParentHeader[0] : traceParentHeader; + if (typeof traceParent !== "string") + return context2; + const spanContext = parseTraceParent(traceParent); + if (!spanContext) + return context2; + spanContext.isRemote = true; + const traceStateHeader = getter.get(carrier, exports.TRACE_STATE_HEADER); + if (traceStateHeader) { + const state = Array.isArray(traceStateHeader) ? traceStateHeader.join(",") : traceStateHeader; + spanContext.traceState = new TraceState_1.TraceState(typeof state === "string" ? state : void 0); + } + return api_1.trace.setSpanContext(context2, spanContext); + } + fields() { + return [exports.TRACE_PARENT_HEADER, exports.TRACE_STATE_HEADER]; + } + }; + exports.W3CTraceContextPropagator = W3CTraceContextPropagator; + } +}); + +// node_modules/@opentelemetry/core/build/src/trace/rpc-metadata.js +var require_rpc_metadata = __commonJS({ + "node_modules/@opentelemetry/core/build/src/trace/rpc-metadata.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getRPCMetadata = exports.deleteRPCMetadata = exports.setRPCMetadata = exports.RPCType = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var RPC_METADATA_KEY = (0, api_1.createContextKey)("OpenTelemetry SDK Context Key RPC_METADATA"); + var RPCType; + (function(RPCType2) { + RPCType2["HTTP"] = "http"; + })(RPCType || (exports.RPCType = RPCType = {})); + function setRPCMetadata(context2, meta) { + return context2.setValue(RPC_METADATA_KEY, meta); + } + exports.setRPCMetadata = setRPCMetadata; + function deleteRPCMetadata(context2) { + return context2.deleteValue(RPC_METADATA_KEY); + } + exports.deleteRPCMetadata = deleteRPCMetadata; + function getRPCMetadata(context2) { + return context2.getValue(RPC_METADATA_KEY); + } + exports.getRPCMetadata = getRPCMetadata; + } +}); + +// node_modules/@opentelemetry/core/build/src/utils/lodash.merge.js +var require_lodash_merge = __commonJS({ + "node_modules/@opentelemetry/core/build/src/utils/lodash.merge.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isPlainObject = void 0; + var objectTag = "[object Object]"; + var nullTag = "[object Null]"; + var undefinedTag = "[object Undefined]"; + var funcProto = Function.prototype; + var funcToString = funcProto.toString; + var objectCtorString = funcToString.call(Object); + var getPrototypeOf = Object.getPrototypeOf; + var objectProto = Object.prototype; + var hasOwnProperty = objectProto.hasOwnProperty; + var symToStringTag = Symbol ? Symbol.toStringTag : void 0; + var nativeObjectToString = objectProto.toString; + function isPlainObject(value) { + if (!isObjectLike(value) || baseGetTag(value) !== objectTag) { + return false; + } + const proto = getPrototypeOf(value); + if (proto === null) { + return true; + } + const Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor; + return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) === objectCtorString; + } + exports.isPlainObject = isPlainObject; + function isObjectLike(value) { + return value != null && typeof value == "object"; + } + function baseGetTag(value) { + if (value == null) { + return value === void 0 ? undefinedTag : nullTag; + } + return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value); + } + function getRawTag(value) { + const isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag]; + let unmasked = false; + try { + value[symToStringTag] = void 0; + unmasked = true; + } catch { + } + const result = nativeObjectToString.call(value); + if (unmasked) { + if (isOwn) { + value[symToStringTag] = tag; + } else { + delete value[symToStringTag]; + } + } + return result; + } + function objectToString(value) { + return nativeObjectToString.call(value); + } + } +}); + +// node_modules/@opentelemetry/core/build/src/utils/merge.js +var require_merge = __commonJS({ + "node_modules/@opentelemetry/core/build/src/utils/merge.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.merge = void 0; + var lodash_merge_1 = require_lodash_merge(); + var MAX_LEVEL = 20; + function merge(...args) { + let result = args.shift(); + const objects = /* @__PURE__ */ new WeakMap(); + while (args.length > 0) { + result = mergeTwoObjects(result, args.shift(), 0, objects); + } + return result; + } + exports.merge = merge; + function takeValue(value) { + if (isArray(value)) { + return value.slice(); + } + return value; + } + function mergeTwoObjects(one, two, level = 0, objects) { + let result; + if (level > MAX_LEVEL) { + return void 0; + } + level++; + if (isPrimitive(one) || isPrimitive(two) || isFunction(two)) { + result = takeValue(two); + } else if (isArray(one)) { + result = one.slice(); + if (isArray(two)) { + for (let i = 0, j = two.length; i < j; i++) { + result.push(takeValue(two[i])); + } + } else if (isObject(two)) { + const keys = Object.keys(two); + for (let i = 0, j = keys.length; i < j; i++) { + const key = keys[i]; + if (key === "__proto__" || key === "constructor" || key === "prototype") { + continue; + } + result[key] = takeValue(two[key]); + } + } + } else if (isObject(one)) { + if (isObject(two)) { + if (!shouldMerge(one, two)) { + return two; + } + result = Object.assign({}, one); + const keys = Object.keys(two); + for (let i = 0, j = keys.length; i < j; i++) { + const key = keys[i]; + if (key === "__proto__" || key === "constructor" || key === "prototype") { + continue; + } + const twoValue = two[key]; + if (isPrimitive(twoValue)) { + if (typeof twoValue === "undefined") { + delete result[key]; + } else { + result[key] = twoValue; + } + } else { + const obj1 = result[key]; + const obj2 = twoValue; + if (wasObjectReferenced(one, key, objects) || wasObjectReferenced(two, key, objects)) { + delete result[key]; + } else { + if (isObject(obj1) && isObject(obj2)) { + const arr1 = objects.get(obj1) || []; + const arr2 = objects.get(obj2) || []; + arr1.push({ obj: one, key }); + arr2.push({ obj: two, key }); + objects.set(obj1, arr1); + objects.set(obj2, arr2); + } + result[key] = mergeTwoObjects(result[key], twoValue, level, objects); + } + } + } + } else { + result = two; + } + } + return result; + } + function wasObjectReferenced(obj, key, objects) { + const arr = objects.get(obj[key]) || []; + for (let i = 0, j = arr.length; i < j; i++) { + const info = arr[i]; + if (info.key === key && info.obj === obj) { + return true; + } + } + return false; + } + function isArray(value) { + return Array.isArray(value); + } + function isFunction(value) { + return typeof value === "function"; + } + function isObject(value) { + return !isPrimitive(value) && !isArray(value) && !isFunction(value) && typeof value === "object"; + } + function isPrimitive(value) { + return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "undefined" || value instanceof Date || value instanceof RegExp || value === null; + } + function shouldMerge(one, two) { + if (!(0, lodash_merge_1.isPlainObject)(one) || !(0, lodash_merge_1.isPlainObject)(two)) { + return false; + } + return true; + } + } +}); + +// node_modules/@opentelemetry/core/build/src/utils/timeout.js +var require_timeout = __commonJS({ + "node_modules/@opentelemetry/core/build/src/utils/timeout.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.callWithTimeout = exports.TimeoutError = void 0; + var TimeoutError = class _TimeoutError extends Error { + constructor(message) { + super(message); + Object.setPrototypeOf(this, _TimeoutError.prototype); + } + }; + exports.TimeoutError = TimeoutError; + function callWithTimeout(promise, timeout) { + let timeoutHandle; + const timeoutPromise = new Promise(function timeoutFunction(_resolve, reject) { + timeoutHandle = setTimeout(function timeoutHandler() { + reject(new TimeoutError("Operation timed out.")); + }, timeout); + }); + return Promise.race([promise, timeoutPromise]).then((result) => { + clearTimeout(timeoutHandle); + return result; + }, (reason) => { + clearTimeout(timeoutHandle); + throw reason; + }); + } + exports.callWithTimeout = callWithTimeout; + } +}); + +// node_modules/@opentelemetry/core/build/src/utils/url.js +var require_url = __commonJS({ + "node_modules/@opentelemetry/core/build/src/utils/url.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isUrlIgnored = exports.urlMatches = void 0; + function urlMatches(url, urlToMatch) { + if (typeof urlToMatch === "string") { + return url === urlToMatch; + } else { + return !!url.match(urlToMatch); + } + } + exports.urlMatches = urlMatches; + function isUrlIgnored(url, ignoredUrls) { + if (!ignoredUrls) { + return false; + } + for (const ignoreUrl of ignoredUrls) { + if (urlMatches(url, ignoreUrl)) { + return true; + } + } + return false; + } + exports.isUrlIgnored = isUrlIgnored; + } +}); + +// node_modules/@opentelemetry/core/build/src/utils/promise.js +var require_promise = __commonJS({ + "node_modules/@opentelemetry/core/build/src/utils/promise.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Deferred = void 0; + var Deferred = class { + _promise; + _resolve; + _reject; + constructor() { + this._promise = new Promise((resolve2, reject) => { + this._resolve = resolve2; + this._reject = reject; + }); + } + get promise() { + return this._promise; + } + resolve(val) { + this._resolve(val); + } + reject(err) { + this._reject(err); + } + }; + exports.Deferred = Deferred; + } +}); + +// node_modules/@opentelemetry/core/build/src/utils/callback.js +var require_callback = __commonJS({ + "node_modules/@opentelemetry/core/build/src/utils/callback.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.BindOnceFuture = void 0; + var promise_1 = require_promise(); + var BindOnceFuture = class { + _isCalled = false; + _deferred = new promise_1.Deferred(); + _callback; + _that; + constructor(callback, that) { + this._callback = callback; + this._that = that; + } + get isCalled() { + return this._isCalled; + } + get promise() { + return this._deferred.promise; + } + call(...args) { + if (!this._isCalled) { + this._isCalled = true; + try { + Promise.resolve(this._callback.call(this._that, ...args)).then((val) => this._deferred.resolve(val), (err) => this._deferred.reject(err)); + } catch (err) { + this._deferred.reject(err); + } + } + return this._deferred.promise; + } + }; + exports.BindOnceFuture = BindOnceFuture; + } +}); + +// node_modules/@opentelemetry/core/build/src/utils/configuration.js +var require_configuration = __commonJS({ + "node_modules/@opentelemetry/core/build/src/utils/configuration.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.diagLogLevelFromString = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var logLevelMap = { + ALL: api_1.DiagLogLevel.ALL, + VERBOSE: api_1.DiagLogLevel.VERBOSE, + DEBUG: api_1.DiagLogLevel.DEBUG, + INFO: api_1.DiagLogLevel.INFO, + WARN: api_1.DiagLogLevel.WARN, + ERROR: api_1.DiagLogLevel.ERROR, + NONE: api_1.DiagLogLevel.NONE + }; + function diagLogLevelFromString(value) { + if (value == null) { + return void 0; + } + const resolvedLogLevel = logLevelMap[value.toUpperCase()]; + if (resolvedLogLevel == null) { + api_1.diag.warn(`Unknown log level "${value}", expected one of ${Object.keys(logLevelMap)}, using default`); + return api_1.DiagLogLevel.INFO; + } + return resolvedLogLevel; + } + exports.diagLogLevelFromString = diagLogLevelFromString; + } +}); + +// node_modules/@opentelemetry/core/build/src/internal/exporter.js +var require_exporter = __commonJS({ + "node_modules/@opentelemetry/core/build/src/internal/exporter.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports._export = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var suppress_tracing_1 = require_suppress_tracing(); + function _export(exporter, arg) { + return new Promise((resolve2) => { + api_1.context.with((0, suppress_tracing_1.suppressTracing)(api_1.context.active()), () => { + exporter.export(arg, resolve2); + }); + }); + } + exports._export = _export; + } +}); + +// node_modules/@opentelemetry/core/build/src/index.js +var require_src = __commonJS({ + "node_modules/@opentelemetry/core/build/src/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.diagLogLevelFromString = exports.BindOnceFuture = exports.urlMatches = exports.isUrlIgnored = exports.callWithTimeout = exports.TimeoutError = exports.merge = exports.TraceState = exports.unsuppressTracing = exports.suppressTracing = exports.isTracingSuppressed = exports.setRPCMetadata = exports.getRPCMetadata = exports.deleteRPCMetadata = exports.RPCType = exports.parseTraceParent = exports.W3CTraceContextPropagator = exports.TRACE_STATE_HEADER = exports.TRACE_PARENT_HEADER = exports.CompositePropagator = exports.otperformance = exports.getStringListFromEnv = exports.getNumberFromEnv = exports.getBooleanFromEnv = exports.getStringFromEnv = exports._globalThis = exports.SDK_INFO = exports.parseKeyPairsIntoRecord = exports.ExportResultCode = exports.unrefTimer = exports.timeInputToHrTime = exports.millisToHrTime = exports.isTimeInputHrTime = exports.isTimeInput = exports.hrTimeToTimeStamp = exports.hrTimeToSeconds = exports.hrTimeToNanoseconds = exports.hrTimeToMilliseconds = exports.hrTimeToMicroseconds = exports.hrTimeDuration = exports.hrTime = exports.getTimeOrigin = exports.addHrTimes = exports.loggingErrorHandler = exports.setGlobalErrorHandler = exports.globalErrorHandler = exports.sanitizeAttributes = exports.isAttributeValue = exports.AnchoredClock = exports.W3CBaggagePropagator = void 0; + exports.internal = void 0; + var W3CBaggagePropagator_1 = require_W3CBaggagePropagator(); + Object.defineProperty(exports, "W3CBaggagePropagator", { enumerable: true, get: function() { + return W3CBaggagePropagator_1.W3CBaggagePropagator; + } }); + var anchored_clock_1 = require_anchored_clock(); + Object.defineProperty(exports, "AnchoredClock", { enumerable: true, get: function() { + return anchored_clock_1.AnchoredClock; + } }); + var attributes_1 = require_attributes(); + Object.defineProperty(exports, "isAttributeValue", { enumerable: true, get: function() { + return attributes_1.isAttributeValue; + } }); + Object.defineProperty(exports, "sanitizeAttributes", { enumerable: true, get: function() { + return attributes_1.sanitizeAttributes; + } }); + var global_error_handler_1 = require_global_error_handler(); + Object.defineProperty(exports, "globalErrorHandler", { enumerable: true, get: function() { + return global_error_handler_1.globalErrorHandler; + } }); + Object.defineProperty(exports, "setGlobalErrorHandler", { enumerable: true, get: function() { + return global_error_handler_1.setGlobalErrorHandler; + } }); + var logging_error_handler_1 = require_logging_error_handler(); + Object.defineProperty(exports, "loggingErrorHandler", { enumerable: true, get: function() { + return logging_error_handler_1.loggingErrorHandler; + } }); + var time_1 = require_time(); + Object.defineProperty(exports, "addHrTimes", { enumerable: true, get: function() { + return time_1.addHrTimes; + } }); + Object.defineProperty(exports, "getTimeOrigin", { enumerable: true, get: function() { + return time_1.getTimeOrigin; + } }); + Object.defineProperty(exports, "hrTime", { enumerable: true, get: function() { + return time_1.hrTime; + } }); + Object.defineProperty(exports, "hrTimeDuration", { enumerable: true, get: function() { + return time_1.hrTimeDuration; + } }); + Object.defineProperty(exports, "hrTimeToMicroseconds", { enumerable: true, get: function() { + return time_1.hrTimeToMicroseconds; + } }); + Object.defineProperty(exports, "hrTimeToMilliseconds", { enumerable: true, get: function() { + return time_1.hrTimeToMilliseconds; + } }); + Object.defineProperty(exports, "hrTimeToNanoseconds", { enumerable: true, get: function() { + return time_1.hrTimeToNanoseconds; + } }); + Object.defineProperty(exports, "hrTimeToSeconds", { enumerable: true, get: function() { + return time_1.hrTimeToSeconds; + } }); + Object.defineProperty(exports, "hrTimeToTimeStamp", { enumerable: true, get: function() { + return time_1.hrTimeToTimeStamp; + } }); + Object.defineProperty(exports, "isTimeInput", { enumerable: true, get: function() { + return time_1.isTimeInput; + } }); + Object.defineProperty(exports, "isTimeInputHrTime", { enumerable: true, get: function() { + return time_1.isTimeInputHrTime; + } }); + Object.defineProperty(exports, "millisToHrTime", { enumerable: true, get: function() { + return time_1.millisToHrTime; + } }); + Object.defineProperty(exports, "timeInputToHrTime", { enumerable: true, get: function() { + return time_1.timeInputToHrTime; + } }); + var timer_util_1 = require_timer_util(); + Object.defineProperty(exports, "unrefTimer", { enumerable: true, get: function() { + return timer_util_1.unrefTimer; + } }); + var ExportResult_1 = require_ExportResult(); + Object.defineProperty(exports, "ExportResultCode", { enumerable: true, get: function() { + return ExportResult_1.ExportResultCode; + } }); + var utils_1 = require_utils(); + Object.defineProperty(exports, "parseKeyPairsIntoRecord", { enumerable: true, get: function() { + return utils_1.parseKeyPairsIntoRecord; + } }); + var platform_1 = require_platform(); + Object.defineProperty(exports, "SDK_INFO", { enumerable: true, get: function() { + return platform_1.SDK_INFO; + } }); + Object.defineProperty(exports, "_globalThis", { enumerable: true, get: function() { + return platform_1._globalThis; + } }); + Object.defineProperty(exports, "getStringFromEnv", { enumerable: true, get: function() { + return platform_1.getStringFromEnv; + } }); + Object.defineProperty(exports, "getBooleanFromEnv", { enumerable: true, get: function() { + return platform_1.getBooleanFromEnv; + } }); + Object.defineProperty(exports, "getNumberFromEnv", { enumerable: true, get: function() { + return platform_1.getNumberFromEnv; + } }); + Object.defineProperty(exports, "getStringListFromEnv", { enumerable: true, get: function() { + return platform_1.getStringListFromEnv; + } }); + Object.defineProperty(exports, "otperformance", { enumerable: true, get: function() { + return platform_1.otperformance; + } }); + var composite_1 = require_composite(); + Object.defineProperty(exports, "CompositePropagator", { enumerable: true, get: function() { + return composite_1.CompositePropagator; + } }); + var W3CTraceContextPropagator_1 = require_W3CTraceContextPropagator(); + Object.defineProperty(exports, "TRACE_PARENT_HEADER", { enumerable: true, get: function() { + return W3CTraceContextPropagator_1.TRACE_PARENT_HEADER; + } }); + Object.defineProperty(exports, "TRACE_STATE_HEADER", { enumerable: true, get: function() { + return W3CTraceContextPropagator_1.TRACE_STATE_HEADER; + } }); + Object.defineProperty(exports, "W3CTraceContextPropagator", { enumerable: true, get: function() { + return W3CTraceContextPropagator_1.W3CTraceContextPropagator; + } }); + Object.defineProperty(exports, "parseTraceParent", { enumerable: true, get: function() { + return W3CTraceContextPropagator_1.parseTraceParent; + } }); + var rpc_metadata_1 = require_rpc_metadata(); + Object.defineProperty(exports, "RPCType", { enumerable: true, get: function() { + return rpc_metadata_1.RPCType; + } }); + Object.defineProperty(exports, "deleteRPCMetadata", { enumerable: true, get: function() { + return rpc_metadata_1.deleteRPCMetadata; + } }); + Object.defineProperty(exports, "getRPCMetadata", { enumerable: true, get: function() { + return rpc_metadata_1.getRPCMetadata; + } }); + Object.defineProperty(exports, "setRPCMetadata", { enumerable: true, get: function() { + return rpc_metadata_1.setRPCMetadata; + } }); + var suppress_tracing_1 = require_suppress_tracing(); + Object.defineProperty(exports, "isTracingSuppressed", { enumerable: true, get: function() { + return suppress_tracing_1.isTracingSuppressed; + } }); + Object.defineProperty(exports, "suppressTracing", { enumerable: true, get: function() { + return suppress_tracing_1.suppressTracing; + } }); + Object.defineProperty(exports, "unsuppressTracing", { enumerable: true, get: function() { + return suppress_tracing_1.unsuppressTracing; + } }); + var TraceState_1 = require_TraceState(); + Object.defineProperty(exports, "TraceState", { enumerable: true, get: function() { + return TraceState_1.TraceState; + } }); + var merge_1 = require_merge(); + Object.defineProperty(exports, "merge", { enumerable: true, get: function() { + return merge_1.merge; + } }); + var timeout_1 = require_timeout(); + Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function() { + return timeout_1.TimeoutError; + } }); + Object.defineProperty(exports, "callWithTimeout", { enumerable: true, get: function() { + return timeout_1.callWithTimeout; + } }); + var url_1 = require_url(); + Object.defineProperty(exports, "isUrlIgnored", { enumerable: true, get: function() { + return url_1.isUrlIgnored; + } }); + Object.defineProperty(exports, "urlMatches", { enumerable: true, get: function() { + return url_1.urlMatches; + } }); + var callback_1 = require_callback(); + Object.defineProperty(exports, "BindOnceFuture", { enumerable: true, get: function() { + return callback_1.BindOnceFuture; + } }); + var configuration_1 = require_configuration(); + Object.defineProperty(exports, "diagLogLevelFromString", { enumerable: true, get: function() { + return configuration_1.diagLogLevelFromString; + } }); + var exporter_1 = require_exporter(); + exports.internal = { + _export: exporter_1._export + }; + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/OTLPExporterBase.js +var OTLPExporterBase; +var init_OTLPExporterBase = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/OTLPExporterBase.js"() { + OTLPExporterBase = class { + _delegate; + constructor(delegate) { + this._delegate = delegate; + } + /** + * Export items. + * @param items + * @param resultCallback + */ + export(items, resultCallback) { + this._delegate.export(items, resultCallback); + } + forceFlush() { + return this._delegate.forceFlush(); + } + shutdown() { + return this._delegate.shutdown(); + } + setMetrics(metrics2) { + this._delegate.setMetrics(metrics2); + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/types.js +var OTLPExporterError; +var init_types2 = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/types.js"() { + OTLPExporterError = class extends Error { + code; + name = "OTLPExporterError"; + data; + constructor(message, code, data) { + super(message); + this.data = data; + this.code = code; + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-configuration.js +function validateTimeoutMillis(timeoutMillis) { + if (Number.isFinite(timeoutMillis) && timeoutMillis > 0) { + return timeoutMillis; + } + throw new Error(`Configuration: timeoutMillis is invalid, expected number greater than 0 (actual: '${timeoutMillis}')`); +} +function wrapStaticHeadersInFunction(headers) { + if (headers == null) { + return void 0; + } + return async () => headers; +} +function mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) { + return { + timeoutMillis: validateTimeoutMillis(userProvidedConfiguration.timeoutMillis ?? fallbackConfiguration.timeoutMillis ?? defaultConfiguration.timeoutMillis), + concurrencyLimit: userProvidedConfiguration.concurrencyLimit ?? fallbackConfiguration.concurrencyLimit ?? defaultConfiguration.concurrencyLimit, + compression: userProvidedConfiguration.compression ?? fallbackConfiguration.compression ?? defaultConfiguration.compression + }; +} +function getSharedConfigurationDefaults() { + return { + timeoutMillis: 1e4, + concurrencyLimit: 30, + compression: "none" + }; +} +var init_shared_configuration = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-configuration.js"() { + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/legacy-node-configuration.js +var CompressionAlgorithm; +var init_legacy_node_configuration = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/legacy-node-configuration.js"() { + (function(CompressionAlgorithm2) { + CompressionAlgorithm2["NONE"] = "none"; + CompressionAlgorithm2["GZIP"] = "gzip"; + })(CompressionAlgorithm || (CompressionAlgorithm = {})); + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/bounded-queue-export-promise-handler.js +function createBoundedQueueExportPromiseHandler(options) { + return new BoundedQueueExportPromiseHandler(options.concurrencyLimit); +} +var BoundedQueueExportPromiseHandler; +var init_bounded_queue_export_promise_handler = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/bounded-queue-export-promise-handler.js"() { + BoundedQueueExportPromiseHandler = class { + _concurrencyLimit; + _sendingPromises = []; + /** + * @param concurrencyLimit maximum promises allowed in a queue at the same time. + */ + constructor(concurrencyLimit) { + this._concurrencyLimit = concurrencyLimit; + } + pushPromise(promise) { + if (this.hasReachedLimit()) { + throw new Error("Concurrency Limit reached"); + } + this._sendingPromises.push(promise); + const popPromise = () => { + const index = this._sendingPromises.indexOf(promise); + void this._sendingPromises.splice(index, 1); + }; + promise.then(popPromise, popPromise); + } + hasReachedLimit() { + return this._sendingPromises.length >= this._concurrencyLimit; + } + async awaitAll() { + await Promise.all(this._sendingPromises); + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/logging-response-handler.js +function isPartialSuccessResponse(response) { + return Object.prototype.hasOwnProperty.call(response, "partialSuccess"); +} +function createLoggingPartialSuccessResponseHandler() { + return { + handleResponse(response) { + if (response == null || !isPartialSuccessResponse(response) || response.partialSuccess == null || Object.keys(response.partialSuccess).length === 0) { + return; + } + diag2.warn("Received Partial Success response:", JSON.stringify(response.partialSuccess)); + } + }; +} +var init_logging_response_handler = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/logging-response-handler.js"() { + init_esm(); + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-export-delegate.js +function createOtlpExportDelegate(components, settings) { + return new OTLPExportDelegate(components.transport, components.serializer, createLoggingPartialSuccessResponseHandler(), components.promiseHandler, components.metrics, settings.timeout); +} +var import_core, OTLPExportDelegate; +var init_otlp_export_delegate = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-export-delegate.js"() { + import_core = __toESM(require_src()); + init_types2(); + init_logging_response_handler(); + init_esm(); + OTLPExportDelegate = class { + _metrics; + _diagLogger; + _transport; + _serializer; + _responseHandler; + _promiseQueue; + _timeout; + constructor(transport, serializer, responseHandler, promiseQueue, metrics2, timeout) { + this._transport = transport; + this._serializer = serializer; + this._responseHandler = responseHandler; + this._promiseQueue = promiseQueue; + this._timeout = timeout; + this._diagLogger = diag2.createComponentLogger({ + namespace: "OTLPExportDelegate" + }); + this._metrics = metrics2; + } + export(internalRepresentation, resultCallback) { + this._diagLogger.debug("items to be sent", internalRepresentation); + if (this._promiseQueue.hasReachedLimit()) { + resultCallback({ + code: import_core.ExportResultCode.FAILED, + error: new Error("Concurrent export limit reached") + }); + return; + } + const serializedRequest = this._serializer.serializeRequest(internalRepresentation); + if (serializedRequest == null) { + resultCallback({ + code: import_core.ExportResultCode.FAILED, + error: new Error("Nothing to send") + }); + return; + } + const finishExport = this._metrics.startExport(internalRepresentation); + this._promiseQueue.pushPromise(this._transport.send(serializedRequest, this._timeout).then((response) => { + if (response.status === "success") { + finishExport(void 0); + if (response.data != null) { + try { + this._responseHandler.handleResponse(this._serializer.deserializeResponse(response.data)); + } catch (e) { + this._diagLogger.warn("Export succeeded but could not deserialize response - is the response specification compliant?", e, response.data); + } + } + resultCallback({ + code: import_core.ExportResultCode.SUCCESS + }); + return; + } else if (response.status === "failure" && response.error) { + finishExport(response.error); + resultCallback({ + code: import_core.ExportResultCode.FAILED, + error: response.error + }); + return; + } else if (response.status === "retryable") { + finishExport("export_max_retries"); + resultCallback({ + code: import_core.ExportResultCode.FAILED, + error: response.error ?? new OTLPExporterError("Export failed with retryable status") + }); + } else { + finishExport("export_failed"); + resultCallback({ + code: import_core.ExportResultCode.FAILED, + error: new OTLPExporterError("Export failed with unknown error") + }); + } + }, (reason) => { + finishExport(reason); + resultCallback({ + code: import_core.ExportResultCode.FAILED, + error: reason + }); + })); + } + forceFlush() { + return this._promiseQueue.awaitAll(); + } + setMetrics(metrics2) { + this._metrics = metrics2; + } + async shutdown() { + this._diagLogger.debug("shutdown started"); + await this.forceFlush(); + this._transport.shutdown(); + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-network-export-delegate.js +function createOtlpNetworkExportDelegate(options, serializer, metrics2, transport) { + return createOtlpExportDelegate({ + transport, + serializer, + promiseHandler: createBoundedQueueExportPromiseHandler(options), + metrics: metrics2 + }, { timeout: options.timeoutMillis }); +} +var init_otlp_network_export_delegate = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-network-export-delegate.js"() { + init_bounded_queue_export_promise_handler(); + init_otlp_export_delegate(); + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/semconv.js +var ATTR_HTTP_RESPONSE_STATUS_CODE2, ATTR_OTEL_COMPONENT_NAME, ATTR_OTEL_COMPONENT_TYPE, ATTR_SERVER_ADDRESS2, ATTR_SERVER_PORT2, ATTR_ERROR_TYPE2; +var init_semconv = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/semconv.js"() { + ATTR_HTTP_RESPONSE_STATUS_CODE2 = "http.response.status_code"; + ATTR_OTEL_COMPONENT_NAME = "otel.component.name"; + ATTR_OTEL_COMPONENT_TYPE = "otel.component.type"; + ATTR_SERVER_ADDRESS2 = "server.address"; + ATTR_SERVER_PORT2 = "server.port"; + ATTR_ERROR_TYPE2 = "error.type"; + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/version.js +var VERSION2; +var init_version2 = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/version.js"() { + VERSION2 = "0.222.0"; + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/ExporterMetrics.js +var import_core2, componentCounter, ExporterMetrics; +var init_ExporterMetrics = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/ExporterMetrics.js"() { + init_esm(); + import_core2 = __toESM(require_src()); + init_semconv(); + init_version2(); + componentCounter = /* @__PURE__ */ new Map(); + ExporterMetrics = class { + inflight; + exported; + duration; + standardAttrs; + responseAttributesFromError; + helper; + constructor(options) { + const { componentType, metricsHelper, meterProvider, url, responseAttributesFromError } = options; + this.responseAttributesFromError = responseAttributesFromError; + const meter = meterProvider ? meterProvider.getMeter("@opentelemetry/otlp-exporter", VERSION2) : createNoopMeter(); + const counter = componentCounter.get(componentType) ?? 0; + componentCounter.set(componentType, counter + 1); + this.standardAttrs = { + [ATTR_OTEL_COMPONENT_TYPE]: componentType, + [ATTR_OTEL_COMPONENT_NAME]: `${componentType}/${counter}` + }; + if (url) { + let urlToParse = url; + if (!url.includes("://")) { + urlToParse = `http://${url}`; + } + try { + const parsedUrl = new URL(urlToParse); + this.standardAttrs[ATTR_SERVER_ADDRESS2] = parsedUrl.hostname; + let port = void 0; + if (parsedUrl.port) { + port = Number(parsedUrl.port); + } else if (parsedUrl.protocol === "http:") { + port = 80; + } else if (parsedUrl.protocol === "https:") { + port = 443; + } + if (typeof port === "number") { + this.standardAttrs[ATTR_SERVER_PORT2] = port; + } + } catch { + } + } + this.helper = metricsHelper; + this.inflight = meter.createUpDownCounter(`otel.sdk.exporter.${this.helper.name}.inflight`, { + unit: `{${this.helper.name}}`, + description: `The number of ${this.helper.name}s which were passed to the exporter, but that have not been exported yet (neither successful, nor failed).` + }); + this.exported = meter.createCounter(`otel.sdk.exporter.${this.helper.name}.exported`, { + unit: `{${this.helper.name}}`, + description: `The number of ${this.helper.name}s for which the export has finished, either successful or failed.` + }); + this.duration = meter.createHistogram("otel.sdk.exporter.operation.duration", { + unit: "s", + description: "The duration of exporting a batch of telemetry records.", + advice: { + explicitBucketBoundaries: [] + } + }); + } + startExport(request) { + const numItems = this.helper.countItems(request); + const startTime = (0, import_core2.hrTime)(); + this.inflight.add(numItems, this.standardAttrs); + return (error) => { + const endTime = (0, import_core2.hrTime)(); + this.inflight.add(-numItems, this.standardAttrs); + const exportedAttrs = error ? { + ...this.standardAttrs, + [ATTR_ERROR_TYPE2]: error instanceof Error ? error.name : "export_failed" + } : this.standardAttrs; + this.exported.add(numItems, exportedAttrs); + const durationAttrs = { + ...exportedAttrs, + ...this.responseAttributesFromError(error) + }; + const duration = (0, import_core2.hrTimeToMilliseconds)((0, import_core2.hrTimeDuration)(startTime, endTime)) / 1e3; + this.duration.record(duration, durationAttrs); + }; + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/index.js +var esm_exports3 = {}; +__export(esm_exports3, { + CompressionAlgorithm: () => CompressionAlgorithm, + ExporterMetrics: () => ExporterMetrics, + OTLPExporterBase: () => OTLPExporterBase, + OTLPExporterError: () => OTLPExporterError, + createOtlpNetworkExportDelegate: () => createOtlpNetworkExportDelegate, + getSharedConfigurationDefaults: () => getSharedConfigurationDefaults, + mergeOtlpSharedConfigurationWithDefaults: () => mergeOtlpSharedConfigurationWithDefaults +}); +var init_esm3 = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/index.js"() { + init_OTLPExporterBase(); + init_types2(); + init_shared_configuration(); + init_legacy_node_configuration(); + init_otlp_network_export_delegate(); + init_ExporterMetrics(); + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/metrics/index.js +var require_metrics = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/metrics/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MetricsExporterMetricsHelper = void 0; + exports.MetricsExporterMetricsHelper = { + name: "metric_data_point", + countItems: (request) => { + let count = 0; + for (const scopeMetrics of request.scopeMetrics) { + for (const metric of scopeMetrics.metrics) { + count += metric.dataPoints.length; + } + } + return count; + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/trace/index.js +var require_trace = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/trace/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.TraceExporterMetricsHelper = void 0; + exports.TraceExporterMetricsHelper = { + name: "span", + countItems: (request) => request.length + }; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/logs/index.js +var require_logs = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/logs/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.LogsExporterMetricsHelper = void 0; + exports.LogsExporterMetricsHelper = { + name: "log", + countItems: (request) => request.length + }; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/utils.js +var require_utils2 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/utils.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.estimateVarintSize = void 0; + function estimateVarintSize(v) { + if (v < 0) + return 10; + if (v < 128) + return 1; + if (v < 16384) + return 2; + if (v < 2097152) + return 3; + if (v < 268435456) + return 4; + if (v < 34359738368) + return 5; + if (v < 4398046511104) + return 6; + if (v < 562949953421312) + return 7; + if (v < 72057594037927940) + return 8; + return 9; + } + exports.estimateVarintSize = estimateVarintSize; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-writer.js +var require_protobuf_writer = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-writer.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ProtobufWriter = exports.GROWING_BUFFER_DEBUG_MESSAGE = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var utils_1 = require_utils2(); + exports.GROWING_BUFFER_DEBUG_MESSAGE = "ProtobufWriter: estimated size was too small, growing buffer."; + var RESERVED_LENGTH_BYTES = 1; + var ProtobufWriter = class { + _buffer; + // Avoid using TextEncoder type. While the global is there on all supported runtimes, types may differ. + _textEncoder; + _dataView; + pos = 0; + constructor(estimatedSize = 65536) { + this._buffer = new Uint8Array(estimatedSize); + this._textEncoder = new TextEncoder(); + this._dataView = new DataView(this._buffer.buffer, this._buffer.byteOffset); + } + /** + * Ensure buffer has capacity for at least size more bytes + */ + _ensureCapacity(size) { + const needed = this.pos + size; + if (needed <= this._buffer.length) { + return; + } + api_1.diag.debug(exports.GROWING_BUFFER_DEBUG_MESSAGE); + let newSize = this._buffer.length * 2; + while (newSize < needed) { + newSize *= 2; + } + const newBuffer = new Uint8Array(newSize); + newBuffer.set(this._buffer); + this._buffer = newBuffer; + this._dataView = new DataView(this._buffer.buffer, this._buffer.byteOffset); + } + /** + * Get the written bytes as a Uint8Array + */ + finish() { + return this._buffer.subarray(0, this.pos); + } + /** + * Insert placeholder for length. Update later with {@link finishLengthDelimited} + * Returns the position where to write the length. + */ + startLengthDelimited() { + const lengthPos = this.pos; + this._ensureCapacity(RESERVED_LENGTH_BYTES); + this.pos += RESERVED_LENGTH_BYTES; + return lengthPos; + } + /** + * Write length varint at placeholder position and shift content forward if needed. + * Most messages are small (< 128 bytes), so we reserve 1 byte and only shift + * when the length needs more bytes. + */ + finishLengthDelimited(pos, length) { + const v = length >>> 0; + const varintSize = (0, utils_1.estimateVarintSize)(v); + if (varintSize > RESERVED_LENGTH_BYTES) { + const additionalBytes = varintSize - RESERVED_LENGTH_BYTES; + this._ensureCapacity(additionalBytes); + this._buffer.copyWithin(pos + varintSize, pos + RESERVED_LENGTH_BYTES, this.pos); + this.pos += additionalBytes; + } + let writePos = pos; + if (v < 128) { + this._buffer[writePos] = v; + } else if (v < 16384) { + this._buffer[writePos++] = v & 127 | 128; + this._buffer[writePos] = v >>> 7; + } else if (v < 2097152) { + this._buffer[writePos++] = v & 127 | 128; + this._buffer[writePos++] = v >>> 7 & 127 | 128; + this._buffer[writePos] = v >>> 14; + } else if (v < 268435456) { + this._buffer[writePos++] = v & 127 | 128; + this._buffer[writePos++] = v >>> 7 & 127 | 128; + this._buffer[writePos++] = v >>> 14 & 127 | 128; + this._buffer[writePos] = v >>> 21; + } else { + this._buffer[writePos++] = v & 127 | 128; + this._buffer[writePos++] = v >>> 7 & 127 | 128; + this._buffer[writePos++] = v >>> 14 & 127 | 128; + this._buffer[writePos++] = v >>> 21 & 127 | 128; + this._buffer[writePos] = v >>> 28; + } + } + /** + * Write a sint32 value using zigzag encoding + */ + writeSint32(value) { + this.writeVarint((value << 1 ^ value >> 31) >>> 0); + } + /** + * Write a signed 64-bit fixed integer (sfixed64) from a JS number. + * Handles negative values via two's complement. + */ + writeSfixed64(value) { + let low; + let high; + if (value >= 0) { + low = value >>> 0; + high = value / 4294967296 >>> 0; + } else { + const abs = Math.abs(value); + low = abs >>> 0; + high = abs / 4294967296 >>> 0; + low = ~low >>> 0; + high = ~high >>> 0; + low = low + 1 >>> 0; + if (low === 0) { + high = high + 1 >>> 0; + } + } + this.writeFixed64(low, high); + } + /** + * Write a varint (variable-length integer) + */ + writeVarint(value) { + this._ensureCapacity((0, utils_1.estimateVarintSize)(value)); + if (value >= 0 && value <= 4294967295) { + let v = value >>> 0; + while (v > 127) { + this._buffer[this.pos++] = v & 127 | 128; + v >>>= 7; + } + this._buffer[this.pos++] = v; + } else { + let low; + let high; + if (value >= 0) { + low = value >>> 0; + high = value / 4294967296 >>> 0; + } else { + const abs = Math.abs(value); + low = abs >>> 0; + high = abs / 4294967296 >>> 0; + low = ~low >>> 0; + high = ~high >>> 0; + low = low + 1 >>> 0; + if (low === 0) { + high = high + 1 >>> 0; + } + } + while (high > 0 || low > 127) { + this._buffer[this.pos++] = low & 127 | 128; + low = (low >>> 7 | high << 25) >>> 0; + high >>>= 7; + } + this._buffer[this.pos++] = low & 127; + } + } + /** + * Write a 32-bit fixed integer (little-endian) + */ + writeFixed32(value) { + this._ensureCapacity(4); + const v = value >>> 0; + this._buffer[this.pos++] = v & 255; + this._buffer[this.pos++] = v >>> 8 & 255; + this._buffer[this.pos++] = v >>> 16 & 255; + this._buffer[this.pos++] = v >>> 24 & 255; + } + /** + * Write a 64-bit fixed integer (little-endian) + * @param low - Low 32 bits + * @param high - High 32 bits + */ + writeFixed64(low, high) { + this._ensureCapacity(8); + const l = low >>> 0; + const h = high >>> 0; + this._buffer[this.pos++] = l & 255; + this._buffer[this.pos++] = l >>> 8 & 255; + this._buffer[this.pos++] = l >>> 16 & 255; + this._buffer[this.pos++] = l >>> 24 & 255; + this._buffer[this.pos++] = h & 255; + this._buffer[this.pos++] = h >>> 8 & 255; + this._buffer[this.pos++] = h >>> 16 & 255; + this._buffer[this.pos++] = h >>> 24 & 255; + } + /** + * Write length-delimited data (varint length + bytes) + */ + writeBytes(bytes) { + this.writeVarint(bytes.length); + this._ensureCapacity(bytes.length); + this._buffer.set(bytes, this.pos); + this.pos += bytes.length; + } + /** + * Write a field key (field number + wire type) + */ + writeTag(fieldNumber, wireType) { + this.writeVarint(fieldNumber << 3 | wireType); + } + /** + * Write a double (64-bit IEEE 754) + */ + writeDouble(value) { + this._ensureCapacity(8); + this._dataView.setFloat64(this.pos, value, true); + this.pos += 8; + } + /** + * Write a string as UTF-8 bytes (length-delimited) + */ + writeString(str) { + let isAscii = true; + const len = str.length; + for (let i = 0; i < len; i++) { + if (str.charCodeAt(i) > 127) { + isAscii = false; + break; + } + } + if (isAscii) { + this.writeVarint(len); + this._ensureCapacity(len); + for (let i = 0; i < len; i++) { + this._buffer[this.pos++] = str.charCodeAt(i); + } + } else { + const bytes = this._textEncoder.encode(str); + this.writeBytes(bytes); + } + } + }; + exports.ProtobufWriter = ProtobufWriter; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/common/hex-to-binary.js +var require_hex_to_binary = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/common/hex-to-binary.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.hexToBinary = void 0; + function intValue(charCode) { + if (charCode >= 48 && charCode <= 57) { + return charCode - 48; + } + if (charCode >= 97 && charCode <= 102) { + return charCode - 87; + } + return charCode - 55; + } + function hexToBinary(hexStr) { + const buf = new Uint8Array(hexStr.length / 2); + let offset = 0; + for (let i = 0; i < hexStr.length; i += 2) { + const hi = intValue(hexStr.charCodeAt(i)); + const lo = intValue(hexStr.charCodeAt(i + 1)); + buf[offset++] = hi << 4 | lo; + } + return buf; + } + exports.hexToBinary = hexToBinary; + } +}); + +// node_modules/@opentelemetry/api-logs/build/src/types/LogRecord.js +var require_LogRecord = __commonJS({ + "node_modules/@opentelemetry/api-logs/build/src/types/LogRecord.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SeverityNumber = void 0; + var SeverityNumber; + (function(SeverityNumber2) { + SeverityNumber2[SeverityNumber2["UNSPECIFIED"] = 0] = "UNSPECIFIED"; + SeverityNumber2[SeverityNumber2["TRACE"] = 1] = "TRACE"; + SeverityNumber2[SeverityNumber2["TRACE2"] = 2] = "TRACE2"; + SeverityNumber2[SeverityNumber2["TRACE3"] = 3] = "TRACE3"; + SeverityNumber2[SeverityNumber2["TRACE4"] = 4] = "TRACE4"; + SeverityNumber2[SeverityNumber2["DEBUG"] = 5] = "DEBUG"; + SeverityNumber2[SeverityNumber2["DEBUG2"] = 6] = "DEBUG2"; + SeverityNumber2[SeverityNumber2["DEBUG3"] = 7] = "DEBUG3"; + SeverityNumber2[SeverityNumber2["DEBUG4"] = 8] = "DEBUG4"; + SeverityNumber2[SeverityNumber2["INFO"] = 9] = "INFO"; + SeverityNumber2[SeverityNumber2["INFO2"] = 10] = "INFO2"; + SeverityNumber2[SeverityNumber2["INFO3"] = 11] = "INFO3"; + SeverityNumber2[SeverityNumber2["INFO4"] = 12] = "INFO4"; + SeverityNumber2[SeverityNumber2["WARN"] = 13] = "WARN"; + SeverityNumber2[SeverityNumber2["WARN2"] = 14] = "WARN2"; + SeverityNumber2[SeverityNumber2["WARN3"] = 15] = "WARN3"; + SeverityNumber2[SeverityNumber2["WARN4"] = 16] = "WARN4"; + SeverityNumber2[SeverityNumber2["ERROR"] = 17] = "ERROR"; + SeverityNumber2[SeverityNumber2["ERROR2"] = 18] = "ERROR2"; + SeverityNumber2[SeverityNumber2["ERROR3"] = 19] = "ERROR3"; + SeverityNumber2[SeverityNumber2["ERROR4"] = 20] = "ERROR4"; + SeverityNumber2[SeverityNumber2["FATAL"] = 21] = "FATAL"; + SeverityNumber2[SeverityNumber2["FATAL2"] = 22] = "FATAL2"; + SeverityNumber2[SeverityNumber2["FATAL3"] = 23] = "FATAL3"; + SeverityNumber2[SeverityNumber2["FATAL4"] = 24] = "FATAL4"; + })(SeverityNumber || (exports.SeverityNumber = SeverityNumber = {})); + } +}); + +// node_modules/@opentelemetry/api-logs/build/src/NoopLogger.js +var require_NoopLogger = __commonJS({ + "node_modules/@opentelemetry/api-logs/build/src/NoopLogger.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.createNoopLogger = exports.NOOP_LOGGER = exports.NoopLogger = void 0; + var NoopLogger = class { + emit(_logRecord) { + } + enabled() { + return false; + } + }; + exports.NoopLogger = NoopLogger; + exports.NOOP_LOGGER = new NoopLogger(); + function createNoopLogger() { + return exports.NOOP_LOGGER; + } + exports.createNoopLogger = createNoopLogger; + } +}); + +// node_modules/@opentelemetry/api-logs/build/src/internal/global-utils.js +var require_global_utils = __commonJS({ + "node_modules/@opentelemetry/api-logs/build/src/internal/global-utils.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.API_BACKWARDS_COMPATIBILITY_VERSION = exports.makeGetter = exports._global = exports.GLOBAL_LOGS_API_KEY = void 0; + exports.GLOBAL_LOGS_API_KEY = /* @__PURE__ */ Symbol.for("io.opentelemetry.js.api.logs"); + exports._global = globalThis; + function makeGetter(requiredVersion, instance, fallback) { + return (version) => version === requiredVersion ? instance : fallback; + } + exports.makeGetter = makeGetter; + exports.API_BACKWARDS_COMPATIBILITY_VERSION = 1; + } +}); + +// node_modules/@opentelemetry/api-logs/build/src/NoopLoggerProvider.js +var require_NoopLoggerProvider = __commonJS({ + "node_modules/@opentelemetry/api-logs/build/src/NoopLoggerProvider.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.NOOP_LOGGER_PROVIDER = exports.NoopLoggerProvider = void 0; + var NoopLogger_1 = require_NoopLogger(); + var NoopLoggerProvider = class { + getLogger(_name, _version, _options) { + return new NoopLogger_1.NoopLogger(); + } + }; + exports.NoopLoggerProvider = NoopLoggerProvider; + exports.NOOP_LOGGER_PROVIDER = new NoopLoggerProvider(); + } +}); + +// node_modules/@opentelemetry/api-logs/build/src/ProxyLogger.js +var require_ProxyLogger = __commonJS({ + "node_modules/@opentelemetry/api-logs/build/src/ProxyLogger.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ProxyLogger = void 0; + var NoopLogger_1 = require_NoopLogger(); + var ProxyLogger = class { + constructor(provider, name, version, options) { + this._provider = provider; + this.name = name; + this.version = version; + this.options = options; + } + /** + * Emit a log record. This method should only be used by log appenders. + * + * @param logRecord + */ + emit(logRecord) { + this._getLogger().emit(logRecord); + } + enabled(options) { + return this._getLogger().enabled(options); + } + /** + * Try to get a logger from the proxy logger provider. + * If the proxy logger provider has no delegate, return a noop logger. + */ + _getLogger() { + if (this._delegate) { + return this._delegate; + } + const logger = this._provider._getDelegateLogger(this.name, this.version, this.options); + if (!logger) { + return NoopLogger_1.NOOP_LOGGER; + } + this._delegate = logger; + return this._delegate; + } + }; + exports.ProxyLogger = ProxyLogger; + } +}); + +// node_modules/@opentelemetry/api-logs/build/src/ProxyLoggerProvider.js +var require_ProxyLoggerProvider = __commonJS({ + "node_modules/@opentelemetry/api-logs/build/src/ProxyLoggerProvider.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ProxyLoggerProvider = void 0; + var NoopLoggerProvider_1 = require_NoopLoggerProvider(); + var ProxyLogger_1 = require_ProxyLogger(); + var ProxyLoggerProvider = class { + getLogger(name, version, options) { + var _a2; + return (_a2 = this._getDelegateLogger(name, version, options)) !== null && _a2 !== void 0 ? _a2 : new ProxyLogger_1.ProxyLogger(this, name, version, options); + } + /** + * Get the delegate logger provider. + * Used by tests only. + * @internal + */ + _getDelegate() { + var _a2; + return (_a2 = this._delegate) !== null && _a2 !== void 0 ? _a2 : NoopLoggerProvider_1.NOOP_LOGGER_PROVIDER; + } + /** + * Set the delegate logger provider + * @internal + */ + _setDelegate(delegate) { + this._delegate = delegate; + } + /** + * @internal + */ + _getDelegateLogger(name, version, options) { + var _a2; + return (_a2 = this._delegate) === null || _a2 === void 0 ? void 0 : _a2.getLogger(name, version, options); + } + }; + exports.ProxyLoggerProvider = ProxyLoggerProvider; + } +}); + +// node_modules/@opentelemetry/api-logs/build/src/api/logs.js +var require_logs2 = __commonJS({ + "node_modules/@opentelemetry/api-logs/build/src/api/logs.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.LogsAPI = void 0; + var global_utils_1 = require_global_utils(); + var NoopLoggerProvider_1 = require_NoopLoggerProvider(); + var ProxyLoggerProvider_1 = require_ProxyLoggerProvider(); + var LogsAPI = class _LogsAPI { + constructor() { + this._proxyLoggerProvider = new ProxyLoggerProvider_1.ProxyLoggerProvider(); + } + static getInstance() { + if (!this._instance) { + this._instance = new _LogsAPI(); + } + return this._instance; + } + setGlobalLoggerProvider(provider) { + if (global_utils_1._global[global_utils_1.GLOBAL_LOGS_API_KEY]) { + return this.getLoggerProvider(); + } + global_utils_1._global[global_utils_1.GLOBAL_LOGS_API_KEY] = (0, global_utils_1.makeGetter)(global_utils_1.API_BACKWARDS_COMPATIBILITY_VERSION, provider, NoopLoggerProvider_1.NOOP_LOGGER_PROVIDER); + this._proxyLoggerProvider._setDelegate(provider); + return provider; + } + /** + * Returns the global logger provider. + * + * @returns LoggerProvider + */ + getLoggerProvider() { + var _a2, _b; + return (_b = (_a2 = global_utils_1._global[global_utils_1.GLOBAL_LOGS_API_KEY]) === null || _a2 === void 0 ? void 0 : _a2.call(global_utils_1._global, global_utils_1.API_BACKWARDS_COMPATIBILITY_VERSION)) !== null && _b !== void 0 ? _b : this._proxyLoggerProvider; + } + /** + * Returns a Logger, creating one if one with the given name, version, + * schemaUrl, and attributes is not already created. + * + * Getting a Logger may be expensive, especially when `attributes` are + * provided. Reuse Logger instances where possible instead of calling + * `getLogger()` on hot paths. + * + * @param name The name of the logger or instrumentation library. + * @param version The version of the logger or instrumentation library. + * @param options The options of the logger or instrumentation library. + * @returns {@link Logger} + */ + getLogger(name, version, options) { + return this.getLoggerProvider().getLogger(name, version, options); + } + /** Remove the global logger provider */ + disable() { + delete global_utils_1._global[global_utils_1.GLOBAL_LOGS_API_KEY]; + this._proxyLoggerProvider = new ProxyLoggerProvider_1.ProxyLoggerProvider(); + } + }; + exports.LogsAPI = LogsAPI; + } +}); + +// node_modules/@opentelemetry/api-logs/build/src/index.js +var require_src2 = __commonJS({ + "node_modules/@opentelemetry/api-logs/build/src/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.logs = exports.createNoopLogger = exports.SeverityNumber = void 0; + var LogRecord_1 = require_LogRecord(); + Object.defineProperty(exports, "SeverityNumber", { enumerable: true, get: function() { + return LogRecord_1.SeverityNumber; + } }); + var NoopLogger_1 = require_NoopLogger(); + Object.defineProperty(exports, "createNoopLogger", { enumerable: true, get: function() { + return NoopLogger_1.createNoopLogger; + } }); + var logs_1 = require_logs2(); + exports.logs = logs_1.LogsAPI.getInstance(); + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/common-serializer.js +var require_common_serializer = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/common-serializer.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.writeResource = exports.writeInstrumentationScope = exports.writeAnyValue = exports.writeKeyValue = exports.writeAttributes = exports.writeHrTimeAsFixed64 = void 0; + function writeHrTimeAsFixed64(serializer, hrTime2) { + const seconds = hrTime2[0]; + const nanos = hrTime2[1]; + const nanosPerSecond = 1e9; + const secondsLower16Bits = seconds & 65535; + const secondsUpperBits = seconds / 65536 >>> 0; + const nanosFromLower16Bits = secondsLower16Bits * nanosPerSecond; + const nanosFromUpperBits = secondsUpperBits * nanosPerSecond; + const lower16ContributionLow32 = nanosFromLower16Bits >>> 0; + const lower16ContributionHigh32 = Math.floor(nanosFromLower16Bits / 4294967296); + const upperBitsContributionLow32 = (nanosFromUpperBits & 65535) * 65536 >>> 0; + const upperBitsContributionHigh32 = nanosFromUpperBits / 65536 >>> 0; + const low32WithCarry = lower16ContributionLow32 + upperBitsContributionLow32 + nanos; + const totalLow = low32WithCarry >>> 0; + const carry = Math.floor(low32WithCarry / 4294967296); + const totalHigh = lower16ContributionHigh32 + upperBitsContributionHigh32 + carry >>> 0; + serializer.writeFixed64(totalLow, totalHigh); + } + exports.writeHrTimeAsFixed64 = writeHrTimeAsFixed64; + function writeAttributes(writer, attributes, fieldNumber) { + for (const key in attributes) { + if (!Object.prototype.hasOwnProperty.call(attributes, key)) { + continue; + } + const value = attributes[key]; + writer.writeTag(fieldNumber, 2); + const kvStart = writer.startLengthDelimited(); + const startPos = writer.pos; + writeKeyValue(writer, key, value); + writer.finishLengthDelimited(kvStart, writer.pos - startPos); + } + } + exports.writeAttributes = writeAttributes; + function writeKeyValue(writer, key, value) { + writer.writeTag(1, 2); + writer.writeString(key); + writer.writeTag(2, 2); + const valueStart = writer.startLengthDelimited(); + const startPos = writer.pos; + writeAnyValue(writer, value); + writer.finishLengthDelimited(valueStart, writer.pos - startPos); + } + exports.writeKeyValue = writeKeyValue; + var MIN_64_BIT_INT = -(2 ** 63); + var MAX_64_BIT_INT = 2 ** 63; + function writeAnyValue(writer, value) { + const t = typeof value; + if (t === "string") { + writer.writeTag(1, 2); + writer.writeString(value); + } else if (t === "boolean") { + writer.writeTag(2, 0); + writer.writeVarint(value ? 1 : 0); + } else if (t === "number") { + const numValue = value; + if (Number.isInteger(numValue) && numValue >= MIN_64_BIT_INT && numValue < MAX_64_BIT_INT) { + writer.writeTag(3, 0); + writer.writeVarint(numValue); + } else { + writer.writeTag(4, 1); + writer.writeDouble(numValue); + } + } else if (value instanceof Uint8Array) { + writer.writeTag(7, 2); + writer.writeBytes(value); + } else if (Array.isArray(value)) { + writer.writeTag(5, 2); + const arrayStart = writer.startLengthDelimited(); + const arrayStartPos = writer.pos; + for (const item of value) { + writer.writeTag(1, 2); + const itemStart = writer.startLengthDelimited(); + const itemStartPos = writer.pos; + writeAnyValue(writer, item); + writer.finishLengthDelimited(itemStart, writer.pos - itemStartPos); + } + writer.finishLengthDelimited(arrayStart, writer.pos - arrayStartPos); + } else if (t === "object" && value != null) { + writer.writeTag(6, 2); + const kvlistStart = writer.startLengthDelimited(); + const kvlistStartPos = writer.pos; + const obj = value; + for (const k in obj) { + if (!Object.prototype.hasOwnProperty.call(obj, k)) { + continue; + } + const v = obj[k]; + writer.writeTag(1, 2); + const kvStart = writer.startLengthDelimited(); + const kvStartPos = writer.pos; + writer.writeTag(1, 2); + writer.writeString(k); + writer.writeTag(2, 2); + const valueStart = writer.startLengthDelimited(); + const valueStartPos = writer.pos; + writeAnyValue(writer, v); + writer.finishLengthDelimited(valueStart, writer.pos - valueStartPos); + writer.finishLengthDelimited(kvStart, writer.pos - kvStartPos); + } + writer.finishLengthDelimited(kvlistStart, writer.pos - kvlistStartPos); + } + } + exports.writeAnyValue = writeAnyValue; + function writeInstrumentationScope(writer, scope, fieldNumber) { + writer.writeTag(fieldNumber, 2); + const start = writer.startLengthDelimited(); + const startPos = writer.pos; + writer.writeTag(1, 2); + writer.writeString(scope.name); + if (scope.version) { + writer.writeTag(2, 2); + writer.writeString(scope.version); + } + if (scope.attributes) { + writeAttributes(writer, scope.attributes, 3); + } + if (scope.droppedAttributesCount) { + writer.writeTag(4, 0); + writer.writeVarint(scope.droppedAttributesCount); + } + writer.finishLengthDelimited(start, writer.pos - startPos); + } + exports.writeInstrumentationScope = writeInstrumentationScope; + function writeResource(writer, resource, fieldNumber) { + writer.writeTag(fieldNumber, 2); + const resourceStart = writer.startLengthDelimited(); + const resourceStartPos = writer.pos; + if (resource.attributes) { + writeAttributes(writer, resource.attributes, 1); + } + writer.writeTag(2, 0); + writer.writeVarint(0); + writer.finishLengthDelimited(resourceStart, writer.pos - resourceStartPos); + } + exports.writeResource = writeResource; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-size-estimator.js +var require_protobuf_size_estimator = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-size-estimator.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ProtobufSizeEstimator = void 0; + var utils_1 = require_utils2(); + function utf8ByteLength(str) { + const len = str.length; + let byteLen = 0; + for (let i = 0; i < len; i++) { + const code = str.charCodeAt(i); + if (code < 128) { + byteLen += 1; + } else if (code < 2048) { + byteLen += 2; + } else if (code < 55296 || code >= 57344) { + byteLen += 3; + } else { + i++; + byteLen += 4; + } + } + return byteLen; + } + var ProtobufSizeEstimator = class { + pos = 0; + startLengthDelimited() { + return this.pos; + } + finishLengthDelimited(_, length) { + this.pos += (0, utils_1.estimateVarintSize)(length); + } + writeVarint(value) { + this.pos += (0, utils_1.estimateVarintSize)(value); + } + writeSint32(value) { + this.pos += (0, utils_1.estimateVarintSize)((value << 1 ^ value >> 31) >>> 0); + } + writeSfixed64(_value) { + this.pos += 8; + } + writeFixed32(_value) { + this.pos += 4; + } + writeFixed64(_low, _high) { + this.pos += 8; + } + writeBytes(bytes) { + this.pos += (0, utils_1.estimateVarintSize)(bytes.length); + this.pos += bytes.length; + } + writeTag(fieldNumber, wireType) { + this.writeVarint(fieldNumber << 3 | wireType); + } + writeDouble(_value) { + this.pos += 8; + } + writeString(str) { + const byteLen = utf8ByteLength(str); + this.pos += (0, utils_1.estimateVarintSize)(byteLen); + this.pos += byteLen; + } + }; + exports.ProtobufSizeEstimator = ProtobufSizeEstimator; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/logs/protobuf/logs-serializer.js +var require_logs_serializer = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/logs/protobuf/logs-serializer.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.serializeLogsExportRequest = void 0; + var protobuf_writer_1 = require_protobuf_writer(); + var hex_to_binary_1 = require_hex_to_binary(); + var api_logs_1 = require_src2(); + var common_serializer_1 = require_common_serializer(); + var protobuf_size_estimator_1 = require_protobuf_size_estimator(); + function serializeLogRecord(writer, logRecord) { + const logStart = writer.startLengthDelimited(); + const logStartPos = writer.pos; + writer.writeTag(1, 1); + (0, common_serializer_1.writeHrTimeAsFixed64)(writer, logRecord.hrTime); + if (logRecord.severityNumber !== void 0 && logRecord.severityNumber !== api_logs_1.SeverityNumber.UNSPECIFIED) { + writer.writeTag(2, 0); + writer.writeVarint(logRecord.severityNumber); + } + if (logRecord.severityText) { + writer.writeTag(3, 2); + writer.writeString(logRecord.severityText); + } + if (logRecord.body !== void 0) { + writer.writeTag(5, 2); + const bodyStart = writer.startLengthDelimited(); + const bodyStartPos = writer.pos; + (0, common_serializer_1.writeAnyValue)(writer, logRecord.body); + writer.finishLengthDelimited(bodyStart, writer.pos - bodyStartPos); + } + if (logRecord.attributes) { + (0, common_serializer_1.writeAttributes)(writer, logRecord.attributes, 6); + } + writer.writeTag(7, 0); + writer.writeVarint(logRecord.droppedAttributesCount); + if (logRecord.spanContext?.traceFlags) { + writer.writeTag(8, 5); + writer.writeFixed32(logRecord.spanContext.traceFlags); + } + if (logRecord.spanContext?.traceId) { + writer.writeTag(9, 2); + writer.writeBytes((0, hex_to_binary_1.hexToBinary)(logRecord.spanContext.traceId)); + } + if (logRecord.spanContext?.spanId) { + writer.writeTag(10, 2); + writer.writeBytes((0, hex_to_binary_1.hexToBinary)(logRecord.spanContext.spanId)); + } + writer.writeTag(11, 1); + (0, common_serializer_1.writeHrTimeAsFixed64)(writer, logRecord.hrTimeObserved); + if (logRecord.eventName) { + writer.writeTag(12, 2); + writer.writeString(logRecord.eventName); + } + writer.finishLengthDelimited(logStart, writer.pos - logStartPos); + } + function serializeScopeLogs(writer, scope, logRecords) { + const scopeLogsStart = writer.startLengthDelimited(); + const scopeLogsStartPos = writer.pos; + (0, common_serializer_1.writeInstrumentationScope)(writer, scope, 1); + for (const logRecord of logRecords) { + writer.writeTag(2, 2); + serializeLogRecord(writer, logRecord); + } + if (scope.schemaUrl) { + writer.writeTag(3, 2); + writer.writeString(scope.schemaUrl); + } + writer.finishLengthDelimited(scopeLogsStart, writer.pos - scopeLogsStartPos); + } + function serializeResourceLogs(writer, resource, scopeMap) { + const resourceLogsStart = writer.startLengthDelimited(); + const resourceLogsStartPos = writer.pos; + (0, common_serializer_1.writeResource)(writer, resource, 1); + for (const scopeLogs of scopeMap.values()) { + writer.writeTag(2, 2); + const scope = scopeLogs[0].instrumentationScope; + serializeScopeLogs(writer, scope, scopeLogs); + } + if (resource.schemaUrl) { + writer.writeTag(3, 2); + writer.writeString(resource.schemaUrl); + } + writer.finishLengthDelimited(resourceLogsStart, writer.pos - resourceLogsStartPos); + } + function createResourceMap(logRecords) { + const resourceMap = /* @__PURE__ */ new Map(); + for (const record of logRecords) { + const resource = record.resource; + const scope = record.instrumentationScope; + let ismMap = resourceMap.get(resource); + if (!ismMap) { + ismMap = /* @__PURE__ */ new Map(); + resourceMap.set(resource, ismMap); + } + let records = ismMap.get(scope); + if (!records) { + records = []; + ismMap.set(scope, records); + } + records.push(record); + } + return resourceMap; + } + function serializeLogsExportRequest(logRecords) { + const resourceMap = createResourceMap(logRecords); + const estimator = new protobuf_size_estimator_1.ProtobufSizeEstimator(); + for (const [resource, scopeMap] of resourceMap) { + estimator.writeTag(1, 2); + serializeResourceLogs(estimator, resource, scopeMap); + } + const writer = new protobuf_writer_1.ProtobufWriter(estimator.pos); + for (const [resource, scopeMap] of resourceMap) { + writer.writeTag(1, 2); + serializeResourceLogs(writer, resource, scopeMap); + } + return writer.finish(); + } + exports.serializeLogsExportRequest = serializeLogsExportRequest; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-reader.js +var require_protobuf_reader = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/common/protobuf/protobuf-reader.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ProtobufReader = void 0; + var ProtobufReader = class { + pos = 0; + _buf; + _textDecoder; + constructor(buf) { + this._buf = buf; + this._textDecoder = new TextDecoder(); + } + isAtEnd() { + return this.pos >= this._buf.length; + } + /** Read a varint and decode it as a tag, returning field number and wire type. */ + readTag() { + const raw = this.readVarint(); + return { fieldNumber: raw >>> 3, wireType: raw & 7 }; + } + /** + * Read a base-128 varint. + * Returns a JS `number`; precision above 2^53 is silently lost. + * Throws if the buffer is truncated mid-varint. + */ + readVarint() { + let result = 0; + let shift = 0; + let terminated = false; + while (this.pos < this._buf.length) { + const b = this._buf[this.pos++]; + result += (b & 127) * Math.pow(2, shift); + shift += 7; + if ((b & 128) === 0) { + terminated = true; + break; + } + } + if (!terminated) { + throw new Error("Truncated buffer: unexpected end of data while reading varint"); + } + return result; + } + /** Read a length-delimited byte sequence (bytes field or embedded message). */ + readBytes() { + const len = this.readVarint(); + if (this.pos + len > this._buf.length) { + throw new Error(`Truncated buffer: expected ${len} bytes at position ${this.pos}, but only ${this._buf.length - this.pos} available`); + } + const slice = this._buf.subarray(this.pos, this.pos + len); + this.pos += len; + return slice; + } + /** Read a length-delimited UTF-8 string. */ + readString() { + return this._textDecoder.decode(this.readBytes()); + } + /** + * Skip an unknown field. + * Handles wire types 0 (varint), 1 (64-bit), 2 (length-delimited), + * and 5 (32-bit). + * + * Wire types 3 and 4 (start-group / end-group) are deprecated in proto3 + * and are not used by any OpenTelemetry proto definition. Encountering + * them is treated as an error. + */ + skip(wireType) { + switch (wireType) { + case 0: + this.readVarint(); + break; + case 1: + this.pos += 8; + break; + case 2: + this.readBytes(); + break; + case 5: + this.pos += 4; + break; + default: + throw new Error(`Unknown wire type ${wireType}, cannot safely skip`); + } + } + }; + exports.ProtobufReader = ProtobufReader; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/logs/protobuf/response-deserializer.js +var require_response_deserializer = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/logs/protobuf/response-deserializer.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.deserializeExportLogsServiceResponse = void 0; + var protobuf_reader_1 = require_protobuf_reader(); + function deserializePartialSuccess(data) { + const reader = new protobuf_reader_1.ProtobufReader(data); + const result = {}; + while (!reader.isAtEnd()) { + const { fieldNumber, wireType } = reader.readTag(); + switch (fieldNumber) { + case 1: + if (wireType === 0) { + result.rejectedLogRecords = reader.readVarint(); + } else { + reader.skip(wireType); + } + break; + case 2: + if (wireType === 2) { + result.errorMessage = reader.readString(); + } else { + reader.skip(wireType); + } + break; + default: + reader.skip(wireType); + break; + } + } + return result; + } + function deserializeExportLogsServiceResponse(data) { + const reader = new protobuf_reader_1.ProtobufReader(data); + const result = {}; + while (!reader.isAtEnd()) { + const { fieldNumber, wireType } = reader.readTag(); + switch (fieldNumber) { + case 1: + if (wireType === 2) { + result.partialSuccess = deserializePartialSuccess(reader.readBytes()); + } else { + reader.skip(wireType); + } + break; + default: + reader.skip(wireType); + break; + } + } + return result; + } + exports.deserializeExportLogsServiceResponse = deserializeExportLogsServiceResponse; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/logs/protobuf/logs.js +var require_logs3 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/logs/protobuf/logs.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ProtobufLogsSerializer = void 0; + var logs_serializer_1 = require_logs_serializer(); + var response_deserializer_1 = require_response_deserializer(); + exports.ProtobufLogsSerializer = { + serializeRequest: (arg) => { + return (0, logs_serializer_1.serializeLogsExportRequest)(arg); + }, + deserializeResponse: (arg) => { + return (0, response_deserializer_1.deserializeExportLogsServiceResponse)(arg); + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/logs/protobuf/index.js +var require_protobuf = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/logs/protobuf/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ProtobufLogsSerializer = void 0; + var logs_1 = require_logs3(); + Object.defineProperty(exports, "ProtobufLogsSerializer", { enumerable: true, get: function() { + return logs_1.ProtobufLogsSerializer; + } }); + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/export/AggregationTemporality.js +var require_AggregationTemporality = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/export/AggregationTemporality.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.AggregationTemporality = void 0; + var AggregationTemporality; + (function(AggregationTemporality2) { + AggregationTemporality2[AggregationTemporality2["DELTA"] = 0] = "DELTA"; + AggregationTemporality2[AggregationTemporality2["CUMULATIVE"] = 1] = "CUMULATIVE"; + })(AggregationTemporality || (exports.AggregationTemporality = AggregationTemporality = {})); + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/export/MetricData.js +var require_MetricData = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/export/MetricData.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.DataPointType = exports.InstrumentType = void 0; + var InstrumentType; + (function(InstrumentType2) { + InstrumentType2["COUNTER"] = "COUNTER"; + InstrumentType2["GAUGE"] = "GAUGE"; + InstrumentType2["HISTOGRAM"] = "HISTOGRAM"; + InstrumentType2["UP_DOWN_COUNTER"] = "UP_DOWN_COUNTER"; + InstrumentType2["OBSERVABLE_COUNTER"] = "OBSERVABLE_COUNTER"; + InstrumentType2["OBSERVABLE_GAUGE"] = "OBSERVABLE_GAUGE"; + InstrumentType2["OBSERVABLE_UP_DOWN_COUNTER"] = "OBSERVABLE_UP_DOWN_COUNTER"; + })(InstrumentType || (exports.InstrumentType = InstrumentType = {})); + var DataPointType; + (function(DataPointType2) { + DataPointType2[DataPointType2["HISTOGRAM"] = 0] = "HISTOGRAM"; + DataPointType2[DataPointType2["EXPONENTIAL_HISTOGRAM"] = 1] = "EXPONENTIAL_HISTOGRAM"; + DataPointType2[DataPointType2["GAUGE"] = 2] = "GAUGE"; + DataPointType2[DataPointType2["SUM"] = 3] = "SUM"; + })(DataPointType || (exports.DataPointType = DataPointType = {})); + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/utils.js +var require_utils3 = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/utils.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.equalsCaseInsensitive = exports.binarySearchUB = exports.setEquals = exports.callWithTimeout = exports.TimeoutError = exports.instrumentationScopeId = exports.hashAttributes = void 0; + function hashAttributes(attributes) { + let keys = Object.keys(attributes); + if (keys.length === 0) + return ""; + keys = keys.sort(); + return JSON.stringify(keys.map((key) => [key, attributes[key]])); + } + exports.hashAttributes = hashAttributes; + function instrumentationScopeId(instrumentationScope) { + return `${instrumentationScope.name}:${instrumentationScope.version ?? ""}:${instrumentationScope.schemaUrl ?? ""}`; + } + exports.instrumentationScopeId = instrumentationScopeId; + var TimeoutError = class _TimeoutError extends Error { + constructor(message) { + super(message); + Object.setPrototypeOf(this, _TimeoutError.prototype); + } + }; + exports.TimeoutError = TimeoutError; + function callWithTimeout(promise, timeout) { + let timeoutHandle; + const timeoutPromise = new Promise(function timeoutFunction(_resolve, reject) { + timeoutHandle = setTimeout(function timeoutHandler() { + reject(new TimeoutError("Operation timed out.")); + }, timeout); + }); + return Promise.race([promise, timeoutPromise]).then((result) => { + clearTimeout(timeoutHandle); + return result; + }, (reason) => { + clearTimeout(timeoutHandle); + throw reason; + }); + } + exports.callWithTimeout = callWithTimeout; + function setEquals(lhs, rhs) { + if (lhs.size !== rhs.size) { + return false; + } + for (const item of lhs) { + if (!rhs.has(item)) { + return false; + } + } + return true; + } + exports.setEquals = setEquals; + function binarySearchUB(arr, value) { + let lo = 0; + let hi = arr.length - 1; + let ret = arr.length; + while (hi >= lo) { + const mid = lo + Math.trunc((hi - lo) / 2); + if (arr[mid] < value) { + lo = mid + 1; + } else { + ret = mid; + hi = mid - 1; + } + } + return ret; + } + exports.binarySearchUB = binarySearchUB; + function equalsCaseInsensitive(lhs, rhs) { + return lhs.toLowerCase() === rhs.toLowerCase(); + } + exports.equalsCaseInsensitive = equalsCaseInsensitive; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/types.js +var require_types = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/types.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.AggregatorKind = void 0; + var AggregatorKind; + (function(AggregatorKind2) { + AggregatorKind2[AggregatorKind2["DROP"] = 0] = "DROP"; + AggregatorKind2[AggregatorKind2["SUM"] = 1] = "SUM"; + AggregatorKind2[AggregatorKind2["LAST_VALUE"] = 2] = "LAST_VALUE"; + AggregatorKind2[AggregatorKind2["HISTOGRAM"] = 3] = "HISTOGRAM"; + AggregatorKind2[AggregatorKind2["EXPONENTIAL_HISTOGRAM"] = 4] = "EXPONENTIAL_HISTOGRAM"; + })(AggregatorKind || (exports.AggregatorKind = AggregatorKind = {})); + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Drop.js +var require_Drop = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Drop.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.DropAggregator = void 0; + var types_1 = require_types(); + var DropAggregator = class { + kind = types_1.AggregatorKind.DROP; + createAccumulation() { + return void 0; + } + merge(_previous, _delta) { + return void 0; + } + diff(_previous, _current) { + return void 0; + } + toMetricData(_descriptor, _aggregationTemporality, _accumulationByAttributes, _endTime) { + return void 0; + } + }; + exports.DropAggregator = DropAggregator; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Histogram.js +var require_Histogram = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Histogram.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.HistogramAggregator = exports.HistogramAccumulation = void 0; + var types_1 = require_types(); + var MetricData_1 = require_MetricData(); + var utils_1 = require_utils3(); + function createNewEmptyCheckpoint(boundaries) { + const counts = boundaries.map(() => 0); + counts.push(0); + return { + buckets: { + boundaries, + counts + }, + sum: 0, + count: 0, + hasMinMax: false, + min: Infinity, + max: -Infinity + }; + } + var HistogramAccumulation = class { + startTime; + _boundaries; + _recordMinMax; + _current; + constructor(startTime, boundaries, recordMinMax = true, current = createNewEmptyCheckpoint(boundaries)) { + this.startTime = startTime; + this._boundaries = boundaries; + this._recordMinMax = recordMinMax; + this._current = current; + } + record(value) { + if (Number.isNaN(value)) { + return; + } + this._current.count += 1; + this._current.sum += value; + if (this._recordMinMax) { + this._current.min = Math.min(value, this._current.min); + this._current.max = Math.max(value, this._current.max); + this._current.hasMinMax = true; + } + const idx = (0, utils_1.binarySearchUB)(this._boundaries, value); + this._current.buckets.counts[idx] += 1; + } + setStartTime(startTime) { + this.startTime = startTime; + } + toPointValue() { + return this._current; + } + }; + exports.HistogramAccumulation = HistogramAccumulation; + var HistogramAggregator = class { + kind = types_1.AggregatorKind.HISTOGRAM; + _boundaries; + _recordMinMax; + /** + * @param _boundaries sorted upper bounds of recorded values. + * @param _recordMinMax If set to true, min and max will be recorded. Otherwise, min and max will not be recorded. + */ + constructor(boundaries, recordMinMax) { + this._boundaries = boundaries; + this._recordMinMax = recordMinMax; + } + createAccumulation(startTime) { + return new HistogramAccumulation(startTime, this._boundaries, this._recordMinMax); + } + /** + * Return the result of the merge of two histogram accumulations. As long as one Aggregator + * instance produces all Accumulations with constant boundaries we don't need to worry about + * merging accumulations with different boundaries. + */ + merge(previous, delta) { + const previousValue = previous.toPointValue(); + const deltaValue = delta.toPointValue(); + const previousCounts = previousValue.buckets.counts; + const deltaCounts = deltaValue.buckets.counts; + const mergedCounts = new Array(previousCounts.length); + for (let idx = 0; idx < previousCounts.length; idx++) { + mergedCounts[idx] = previousCounts[idx] + deltaCounts[idx]; + } + let min = Infinity; + let max = -Infinity; + if (this._recordMinMax) { + if (previousValue.hasMinMax && deltaValue.hasMinMax) { + min = Math.min(previousValue.min, deltaValue.min); + max = Math.max(previousValue.max, deltaValue.max); + } else if (previousValue.hasMinMax) { + min = previousValue.min; + max = previousValue.max; + } else if (deltaValue.hasMinMax) { + min = deltaValue.min; + max = deltaValue.max; + } + } + return new HistogramAccumulation(previous.startTime, previousValue.buckets.boundaries, this._recordMinMax, { + buckets: { + boundaries: previousValue.buckets.boundaries, + counts: mergedCounts + }, + count: previousValue.count + deltaValue.count, + sum: previousValue.sum + deltaValue.sum, + hasMinMax: this._recordMinMax && (previousValue.hasMinMax || deltaValue.hasMinMax), + min, + max + }); + } + /** + * Returns a new DELTA aggregation by comparing two cumulative measurements. + */ + diff(previous, current) { + const previousValue = previous.toPointValue(); + const currentValue = current.toPointValue(); + const previousCounts = previousValue.buckets.counts; + const currentCounts = currentValue.buckets.counts; + const diffedCounts = new Array(previousCounts.length); + for (let idx = 0; idx < previousCounts.length; idx++) { + diffedCounts[idx] = currentCounts[idx] - previousCounts[idx]; + } + return new HistogramAccumulation(current.startTime, previousValue.buckets.boundaries, this._recordMinMax, { + buckets: { + boundaries: previousValue.buckets.boundaries, + counts: diffedCounts + }, + count: currentValue.count - previousValue.count, + sum: currentValue.sum - previousValue.sum, + hasMinMax: false, + min: Infinity, + max: -Infinity + }); + } + toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) { + return { + descriptor, + aggregationTemporality, + dataPointType: MetricData_1.DataPointType.HISTOGRAM, + dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => { + const pointValue = accumulation.toPointValue(); + const allowsNegativeValues = descriptor.type === MetricData_1.InstrumentType.GAUGE || descriptor.type === MetricData_1.InstrumentType.UP_DOWN_COUNTER || descriptor.type === MetricData_1.InstrumentType.OBSERVABLE_GAUGE || descriptor.type === MetricData_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER; + return { + attributes, + startTime: accumulation.startTime, + endTime, + value: { + min: pointValue.hasMinMax ? pointValue.min : void 0, + max: pointValue.hasMinMax ? pointValue.max : void 0, + sum: !allowsNegativeValues ? pointValue.sum : void 0, + buckets: pointValue.buckets, + count: pointValue.count + } + }; + }) + }; + } + }; + exports.HistogramAggregator = HistogramAggregator; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/Buckets.js +var require_Buckets = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/Buckets.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Buckets = void 0; + var Buckets = class _Buckets { + backing; + indexBase; + indexStart; + indexEnd; + /** + * The term index refers to the number of the exponential histogram bucket + * used to determine its boundaries. The lower boundary of a bucket is + * determined by base ** index and the upper boundary of a bucket is + * determined by base ** (index + 1). index values are signed to account + * for values less than or equal to 1. + * + * indexBase is the index of the 0th position in the + * backing array, i.e., backing[0] is the count + * in the bucket with index `indexBase`. + * + * indexStart is the smallest index value represented + * in the backing array. + * + * indexEnd is the largest index value represented in + * the backing array. + */ + constructor(backing = new BucketsBacking(), indexBase = 0, indexStart = 0, indexEnd = 0) { + this.backing = backing; + this.indexBase = indexBase; + this.indexStart = indexStart; + this.indexEnd = indexEnd; + } + /** + * Offset is the bucket index of the smallest entry in the counts array + * @returns {number} + */ + get offset() { + return this.indexStart; + } + /** + * Buckets is a view into the backing array. + * @returns {number} + */ + get length() { + if (this.backing.length === 0) { + return 0; + } + if (this.indexEnd === this.indexStart && this.at(0) === 0) { + return 0; + } + return this.indexEnd - this.indexStart + 1; + } + /** + * An array of counts, where count[i] carries the count + * of the bucket at index (offset+i). count[i] is the count of + * values greater than base^(offset+i) and less than or equal to + * base^(offset+i+1). + * @returns {number} The logical counts based on the backing array + */ + counts() { + return Array.from({ length: this.length }, (_, i) => this.at(i)); + } + /** + * At returns the count of the bucket at a position in the logical + * array of counts. + * @param position + * @returns {number} + */ + at(position) { + const bias = this.indexBase - this.indexStart; + if (position < bias) { + position += this.backing.length; + } + position -= bias; + return this.backing.countAt(position); + } + /** + * incrementBucket increments the backing array index by `increment` + * @param bucketIndex + * @param increment + */ + incrementBucket(bucketIndex, increment) { + this.backing.increment(bucketIndex, increment); + } + /** + * decrementBucket decrements the backing array index by `decrement` + * if decrement is greater than the current value, it's set to 0. + * @param bucketIndex + * @param decrement + */ + decrementBucket(bucketIndex, decrement) { + this.backing.decrement(bucketIndex, decrement); + } + /** + * trim removes leading and / or trailing zero buckets (which can occur + * after diffing two histos) and rotates the backing array so that the + * smallest non-zero index is in the 0th position of the backing array + */ + trim() { + for (let i = 0; i < this.length; i++) { + if (this.at(i) !== 0) { + this.indexStart += i; + break; + } else if (i === this.length - 1) { + this.indexStart = this.indexEnd = this.indexBase = 0; + return; + } + } + for (let i = this.length - 1; i >= 0; i--) { + if (this.at(i) !== 0) { + this.indexEnd -= this.length - i - 1; + break; + } + } + this._rotate(); + } + /** + * downscale first rotates, then collapses 2**`by`-to-1 buckets. + * @param by + */ + downscale(by) { + this._rotate(); + const size = 1 + this.indexEnd - this.indexStart; + const each = 1 << by; + let inpos = 0; + let outpos = 0; + for (let pos = this.indexStart; pos <= this.indexEnd; ) { + let mod = pos % each; + if (mod < 0) { + mod += each; + } + for (let i = mod; i < each && inpos < size; i++) { + this._relocateBucket(outpos, inpos); + inpos++; + pos++; + } + outpos++; + } + this.indexStart >>= by; + this.indexEnd >>= by; + this.indexBase = this.indexStart; + } + /** + * Clone returns a deep copy of Buckets + * @returns {Buckets} + */ + clone() { + return new _Buckets(this.backing.clone(), this.indexBase, this.indexStart, this.indexEnd); + } + /** + * _rotate shifts the backing array contents so that indexStart == + * indexBase to simplify the downscale logic. + */ + _rotate() { + const bias = this.indexBase - this.indexStart; + if (bias === 0) { + return; + } else if (bias > 0) { + this.backing.reverse(0, this.backing.length); + this.backing.reverse(0, bias); + this.backing.reverse(bias, this.backing.length); + } else { + this.backing.reverse(0, this.backing.length); + this.backing.reverse(0, this.backing.length + bias); + } + this.indexBase = this.indexStart; + } + /** + * _relocateBucket adds the count in counts[src] to counts[dest] and + * resets count[src] to zero. + */ + _relocateBucket(dest, src) { + if (dest === src) { + return; + } + this.incrementBucket(dest, this.backing.emptyBucket(src)); + } + }; + exports.Buckets = Buckets; + var BucketsBacking = class _BucketsBacking { + _counts; + constructor(counts = [0]) { + this._counts = counts; + } + /** + * length returns the physical size of the backing array, which + * is >= buckets.length() + */ + get length() { + return this._counts.length; + } + /** + * countAt returns the count in a specific bucket + */ + countAt(pos) { + return this._counts[pos]; + } + /** + * growTo grows a backing array and copies old entries + * into their correct new positions. + */ + growTo(newSize, oldPositiveLimit, newPositiveLimit) { + const tmp = new Array(newSize).fill(0); + tmp.splice(newPositiveLimit, this._counts.length - oldPositiveLimit, ...this._counts.slice(oldPositiveLimit)); + tmp.splice(0, oldPositiveLimit, ...this._counts.slice(0, oldPositiveLimit)); + this._counts = tmp; + } + /** + * reverse the items in the backing array in the range [from, limit). + */ + reverse(from, limit) { + const num = Math.floor((from + limit) / 2) - from; + for (let i = 0; i < num; i++) { + const tmp = this._counts[from + i]; + this._counts[from + i] = this._counts[limit - i - 1]; + this._counts[limit - i - 1] = tmp; + } + } + /** + * emptyBucket empties the count from a bucket, for + * moving into another. + */ + emptyBucket(src) { + const tmp = this._counts[src]; + this._counts[src] = 0; + return tmp; + } + /** + * increments a bucket by `increment` + */ + increment(bucketIndex, increment) { + this._counts[bucketIndex] += increment; + } + /** + * decrements a bucket by `decrement` + */ + decrement(bucketIndex, decrement) { + if (this._counts[bucketIndex] >= decrement) { + this._counts[bucketIndex] -= decrement; + } else { + this._counts[bucketIndex] = 0; + } + } + /** + * clone returns a deep copy of BucketsBacking + */ + clone() { + return new _BucketsBacking([...this._counts]); + } + }; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/ieee754.js +var require_ieee754 = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/ieee754.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isPowerOfTwo = exports.getNormalBase2 = exports.MIN_VALUE = exports.MAX_NORMAL_EXPONENT = exports.MIN_NORMAL_EXPONENT = void 0; + var EXPONENT_MASK = 2146435072; + var SIGNIFICAND_MASK = 1048575; + var EXPONENT_BIAS = 1023; + exports.MIN_NORMAL_EXPONENT = -EXPONENT_BIAS + 1; + exports.MAX_NORMAL_EXPONENT = EXPONENT_BIAS; + exports.MIN_VALUE = Math.pow(2, -1022); + var dv = new DataView(new ArrayBuffer(8)); + function floatBits(value) { + dv.setFloat64(0, value); + return { hi: dv.getUint32(0), lo: dv.getUint32(4) }; + } + function getNormalBase2(value) { + const { hi } = floatBits(value); + return ((hi & EXPONENT_MASK) >> 20) - EXPONENT_BIAS; + } + exports.getNormalBase2 = getNormalBase2; + function isPowerOfTwo(value) { + const { hi, lo } = floatBits(value); + return (hi & SIGNIFICAND_MASK) === 0 && lo === 0; + } + exports.isPowerOfTwo = isPowerOfTwo; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/util.js +var require_util = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/util.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.nextGreaterSquare = exports.ldexp = void 0; + function ldexp(frac, exp) { + if (frac === 0 || frac === Number.POSITIVE_INFINITY || frac === Number.NEGATIVE_INFINITY || Number.isNaN(frac)) { + return frac; + } + return frac * Math.pow(2, exp); + } + exports.ldexp = ldexp; + function nextGreaterSquare(v) { + v--; + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + v++; + return v; + } + exports.nextGreaterSquare = nextGreaterSquare; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/types.js +var require_types2 = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/types.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MappingError = void 0; + var MappingError = class extends Error { + }; + exports.MappingError = MappingError; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/ExponentMapping.js +var require_ExponentMapping = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/ExponentMapping.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ExponentMapping = void 0; + var ieee754 = require_ieee754(); + var util = require_util(); + var types_1 = require_types2(); + var ExponentMapping = class { + _shift; + constructor(scale) { + this._shift = -scale; + } + /** + * Maps positive floating point values to indexes corresponding to scale + * @param value + * @returns {number} index for provided value at the current scale + */ + mapToIndex(value) { + if (value < ieee754.MIN_VALUE) { + return this._minNormalLowerBoundaryIndex(); + } + const exp = ieee754.getNormalBase2(value); + const correction = ieee754.isPowerOfTwo(value) ? -1 : 0; + return exp + correction >> this._shift; + } + /** + * Returns the lower bucket boundary for the given index for scale + * + * @param index + * @returns {number} + */ + lowerBoundary(index) { + const minIndex = this._minNormalLowerBoundaryIndex(); + if (index < minIndex) { + throw new types_1.MappingError(`underflow: ${index} is < minimum lower boundary: ${minIndex}`); + } + const maxIndex = this._maxNormalLowerBoundaryIndex(); + if (index > maxIndex) { + throw new types_1.MappingError(`overflow: ${index} is > maximum lower boundary: ${maxIndex}`); + } + return util.ldexp(1, index << this._shift); + } + /** + * The scale used by this mapping + * @returns {number} + */ + get scale() { + if (this._shift === 0) { + return 0; + } + return -this._shift; + } + _minNormalLowerBoundaryIndex() { + let index = ieee754.MIN_NORMAL_EXPONENT >> this._shift; + if (this._shift < 2) { + index--; + } + return index; + } + _maxNormalLowerBoundaryIndex() { + return ieee754.MAX_NORMAL_EXPONENT >> this._shift; + } + }; + exports.ExponentMapping = ExponentMapping; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/LogarithmMapping.js +var require_LogarithmMapping = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/LogarithmMapping.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.LogarithmMapping = void 0; + var ieee754 = require_ieee754(); + var util = require_util(); + var types_1 = require_types2(); + var LogarithmMapping = class { + _scale; + _scaleFactor; + _inverseFactor; + constructor(scale) { + this._scale = scale; + this._scaleFactor = util.ldexp(Math.LOG2E, scale); + this._inverseFactor = util.ldexp(Math.LN2, -scale); + } + /** + * Maps positive floating point values to indexes corresponding to scale + * @param value + * @returns {number} index for provided value at the current scale + */ + mapToIndex(value) { + if (value <= ieee754.MIN_VALUE) { + return this._minNormalLowerBoundaryIndex() - 1; + } + if (ieee754.isPowerOfTwo(value)) { + const exp = ieee754.getNormalBase2(value); + return (exp << this._scale) - 1; + } + const index = Math.floor(Math.log(value) * this._scaleFactor); + const maxIndex = this._maxNormalLowerBoundaryIndex(); + if (index >= maxIndex) { + return maxIndex; + } + return index; + } + /** + * Returns the lower bucket boundary for the given index for scale + * + * @param index + * @returns {number} + */ + lowerBoundary(index) { + const maxIndex = this._maxNormalLowerBoundaryIndex(); + if (index >= maxIndex) { + if (index === maxIndex) { + return 2 * Math.exp((index - (1 << this._scale)) / this._scaleFactor); + } + throw new types_1.MappingError(`overflow: ${index} is > maximum lower boundary: ${maxIndex}`); + } + const minIndex = this._minNormalLowerBoundaryIndex(); + if (index <= minIndex) { + if (index === minIndex) { + return ieee754.MIN_VALUE; + } else if (index === minIndex - 1) { + return Math.exp((index + (1 << this._scale)) / this._scaleFactor) / 2; + } + throw new types_1.MappingError(`overflow: ${index} is < minimum lower boundary: ${minIndex}`); + } + return Math.exp(index * this._inverseFactor); + } + /** + * The scale used by this mapping + * @returns {number} + */ + get scale() { + return this._scale; + } + _minNormalLowerBoundaryIndex() { + return ieee754.MIN_NORMAL_EXPONENT << this._scale; + } + _maxNormalLowerBoundaryIndex() { + return (ieee754.MAX_NORMAL_EXPONENT + 1 << this._scale) - 1; + } + }; + exports.LogarithmMapping = LogarithmMapping; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/getMapping.js +var require_getMapping = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/getMapping.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getMapping = void 0; + var ExponentMapping_1 = require_ExponentMapping(); + var LogarithmMapping_1 = require_LogarithmMapping(); + var types_1 = require_types2(); + var MIN_SCALE = -10; + var MAX_SCALE = 20; + var PREBUILT_MAPPINGS = Array.from({ length: 31 }, (_, i) => { + if (i > 10) { + return new LogarithmMapping_1.LogarithmMapping(i - 10); + } + return new ExponentMapping_1.ExponentMapping(i - 10); + }); + function getMapping(scale) { + if (scale > MAX_SCALE || scale < MIN_SCALE) { + throw new types_1.MappingError(`expected scale >= ${MIN_SCALE} && <= ${MAX_SCALE}, got: ${scale}`); + } + return PREBUILT_MAPPINGS[scale + 10]; + } + exports.getMapping = getMapping; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/ExponentialHistogram.js +var require_ExponentialHistogram = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/ExponentialHistogram.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ExponentialHistogramAggregator = exports.ExponentialHistogramAccumulation = void 0; + var types_1 = require_types(); + var MetricData_1 = require_MetricData(); + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var Buckets_1 = require_Buckets(); + var getMapping_1 = require_getMapping(); + var util_1 = require_util(); + var HighLow = class _HighLow { + static combine(h1, h2) { + return new _HighLow(Math.min(h1.low, h2.low), Math.max(h1.high, h2.high)); + } + low; + high; + constructor(low, high) { + this.low = low; + this.high = high; + } + }; + var MAX_SCALE = 20; + var DEFAULT_MAX_SIZE = 160; + var MIN_MAX_SIZE = 2; + var ExponentialHistogramAccumulation = class _ExponentialHistogramAccumulation { + startTime; + _maxSize; + _recordMinMax; + _sum; + _count; + _zeroCount; + _min; + _max; + _positive; + _negative; + _mapping; + constructor(startTime, maxSize = DEFAULT_MAX_SIZE, recordMinMax = true, sum = 0, count = 0, zeroCount = 0, min = Number.POSITIVE_INFINITY, max = Number.NEGATIVE_INFINITY, positive = new Buckets_1.Buckets(), negative = new Buckets_1.Buckets(), mapping = (0, getMapping_1.getMapping)(MAX_SCALE)) { + this.startTime = startTime; + this._maxSize = maxSize; + this._recordMinMax = recordMinMax; + this._sum = sum; + this._count = count; + this._zeroCount = zeroCount; + this._min = min; + this._max = max; + this._positive = positive; + this._negative = negative; + this._mapping = mapping; + if (this._maxSize < MIN_MAX_SIZE) { + api_1.diag.warn(`Exponential Histogram Max Size set to ${this._maxSize}, changing to the minimum size of: ${MIN_MAX_SIZE}`); + this._maxSize = MIN_MAX_SIZE; + } + } + /** + * record updates a histogram with a single count + * @param {Number} value + */ + record(value) { + this.updateByIncrement(value, 1); + } + /** + * Sets the start time for this accumulation + * @param {HrTime} startTime + */ + setStartTime(startTime) { + this.startTime = startTime; + } + /** + * Returns the datapoint representation of this accumulation + * @param {HrTime} startTime + */ + toPointValue() { + return { + hasMinMax: this._recordMinMax, + min: this.min, + max: this.max, + sum: this.sum, + positive: { + offset: this.positive.offset, + bucketCounts: this.positive.counts() + }, + negative: { + offset: this.negative.offset, + bucketCounts: this.negative.counts() + }, + count: this.count, + scale: this.scale, + zeroCount: this.zeroCount + }; + } + /** + * @returns {Number} The sum of values recorded by this accumulation + */ + get sum() { + return this._sum; + } + /** + * @returns {Number} The minimum value recorded by this accumulation + */ + get min() { + return this._min; + } + /** + * @returns {Number} The maximum value recorded by this accumulation + */ + get max() { + return this._max; + } + /** + * @returns {Number} The count of values recorded by this accumulation + */ + get count() { + return this._count; + } + /** + * @returns {Number} The number of 0 values recorded by this accumulation + */ + get zeroCount() { + return this._zeroCount; + } + /** + * @returns {Number} The scale used by this accumulation + */ + get scale() { + if (this._count === this._zeroCount) { + return 0; + } + return this._mapping.scale; + } + /** + * positive holds the positive values + * @returns {Buckets} + */ + get positive() { + return this._positive; + } + /** + * negative holds the negative values by their absolute value + * @returns {Buckets} + */ + get negative() { + return this._negative; + } + /** + * updateByIncr supports updating a histogram with a non-negative + * increment. + * @param value + * @param increment + */ + updateByIncrement(value, increment) { + if (!Number.isFinite(value)) { + return; + } + if (value > this._max) { + this._max = value; + } + if (value < this._min) { + this._min = value; + } + this._count += increment; + if (value === 0) { + this._zeroCount += increment; + return; + } + this._sum += value * increment; + if (value > 0) { + this._updateBuckets(this._positive, value, increment); + } else { + this._updateBuckets(this._negative, -value, increment); + } + } + /** + * merge combines data from previous value into self + * @param {ExponentialHistogramAccumulation} previous + */ + merge(previous) { + if (this._count === 0) { + this._min = previous.min; + this._max = previous.max; + } else if (previous.count !== 0) { + if (previous.min < this.min) { + this._min = previous.min; + } + if (previous.max > this.max) { + this._max = previous.max; + } + } + this.startTime = previous.startTime; + this._sum += previous.sum; + this._count += previous.count; + this._zeroCount += previous.zeroCount; + const minScale = this._minScale(previous); + this._downscale(this.scale - minScale); + this._mergeBuckets(this.positive, previous, previous.positive, minScale); + this._mergeBuckets(this.negative, previous, previous.negative, minScale); + } + /** + * diff subtracts other from self + * @param {ExponentialHistogramAccumulation} other + */ + diff(other) { + this._min = Infinity; + this._max = -Infinity; + this._sum -= other.sum; + this._count -= other.count; + this._zeroCount -= other.zeroCount; + const minScale = this._minScale(other); + this._downscale(this.scale - minScale); + this._diffBuckets(this.positive, other, other.positive, minScale); + this._diffBuckets(this.negative, other, other.negative, minScale); + } + /** + * clone returns a deep copy of self + * @returns {ExponentialHistogramAccumulation} + */ + clone() { + return new _ExponentialHistogramAccumulation(this.startTime, this._maxSize, this._recordMinMax, this._sum, this._count, this._zeroCount, this._min, this._max, this.positive.clone(), this.negative.clone(), this._mapping); + } + /** + * _updateBuckets maps the incoming value to a bucket index for the current + * scale. If the bucket index is outside of the range of the backing array, + * it will rescale the backing array and update the mapping for the new scale. + */ + _updateBuckets(buckets, value, increment) { + let index = this._mapping.mapToIndex(value); + let rescalingNeeded = false; + let high = 0; + let low = 0; + if (buckets.length === 0) { + buckets.indexStart = index; + buckets.indexEnd = buckets.indexStart; + buckets.indexBase = buckets.indexStart; + } else if (index < buckets.indexStart && buckets.indexEnd - index >= this._maxSize) { + rescalingNeeded = true; + low = index; + high = buckets.indexEnd; + } else if (index > buckets.indexEnd && index - buckets.indexStart >= this._maxSize) { + rescalingNeeded = true; + low = buckets.indexStart; + high = index; + } + if (rescalingNeeded) { + const change = this._changeScale(high, low); + this._downscale(change); + index = this._mapping.mapToIndex(value); + } + this._incrementIndexBy(buckets, index, increment); + } + /** + * _incrementIndexBy increments the count of the bucket specified by `index`. + * If the index is outside of the range [buckets.indexStart, buckets.indexEnd] + * the boundaries of the backing array will be adjusted and more buckets will + * be added if needed. + */ + _incrementIndexBy(buckets, index, increment) { + if (increment === 0) { + return; + } + if (buckets.length === 0) { + buckets.indexStart = buckets.indexEnd = buckets.indexBase = index; + } + if (index < buckets.indexStart) { + const span = buckets.indexEnd - index; + if (span >= buckets.backing.length) { + this._grow(buckets, span + 1); + } + buckets.indexStart = index; + } else if (index > buckets.indexEnd) { + const span = index - buckets.indexStart; + if (span >= buckets.backing.length) { + this._grow(buckets, span + 1); + } + buckets.indexEnd = index; + } + let bucketIndex = index - buckets.indexBase; + if (bucketIndex < 0) { + bucketIndex += buckets.backing.length; + } + buckets.incrementBucket(bucketIndex, increment); + } + /** + * grow resizes the backing array by doubling in size up to maxSize. + * This extends the array with a bunch of zeros and copies the + * existing counts to the same position. + */ + _grow(buckets, needed) { + const size = buckets.backing.length; + const bias = buckets.indexBase - buckets.indexStart; + const oldPositiveLimit = size - bias; + let newSize = (0, util_1.nextGreaterSquare)(needed); + if (newSize > this._maxSize) { + newSize = this._maxSize; + } + const newPositiveLimit = newSize - bias; + buckets.backing.growTo(newSize, oldPositiveLimit, newPositiveLimit); + } + /** + * _changeScale computes how much downscaling is needed by shifting the + * high and low values until they are separated by no more than size. + */ + _changeScale(high, low) { + let change = 0; + while (high - low >= this._maxSize) { + high >>= 1; + low >>= 1; + change++; + } + return change; + } + /** + * _downscale subtracts `change` from the current mapping scale. + */ + _downscale(change) { + if (change === 0) { + return; + } + if (change < 0) { + throw new Error(`impossible change of scale: ${this.scale}`); + } + const newScale = this._mapping.scale - change; + this._positive.downscale(change); + this._negative.downscale(change); + this._mapping = (0, getMapping_1.getMapping)(newScale); + } + /** + * _minScale is used by diff and merge to compute an ideal combined scale + */ + _minScale(other) { + const minScale = Math.min(this.scale, other.scale); + const highLowPos = HighLow.combine(this._highLowAtScale(this.positive, this.scale, minScale), this._highLowAtScale(other.positive, other.scale, minScale)); + const highLowNeg = HighLow.combine(this._highLowAtScale(this.negative, this.scale, minScale), this._highLowAtScale(other.negative, other.scale, minScale)); + return Math.min(minScale - this._changeScale(highLowPos.high, highLowPos.low), minScale - this._changeScale(highLowNeg.high, highLowNeg.low)); + } + /** + * _highLowAtScale is used by diff and merge to compute an ideal combined scale. + */ + _highLowAtScale(buckets, currentScale, newScale) { + if (buckets.length === 0) { + return new HighLow(0, -1); + } + const shift = currentScale - newScale; + return new HighLow(buckets.indexStart >> shift, buckets.indexEnd >> shift); + } + /** + * _mergeBuckets translates index values from another histogram and + * adds the values into the corresponding buckets of this histogram. + */ + _mergeBuckets(ours, other, theirs, scale) { + const theirOffset = theirs.offset; + const theirChange = other.scale - scale; + for (let i = 0; i < theirs.length; i++) { + this._incrementIndexBy(ours, theirOffset + i >> theirChange, theirs.at(i)); + } + } + /** + * _diffBuckets translates index values from another histogram and + * subtracts the values in the corresponding buckets of this histogram. + */ + _diffBuckets(ours, other, theirs, scale) { + const theirOffset = theirs.offset; + const theirChange = other.scale - scale; + for (let i = 0; i < theirs.length; i++) { + const ourIndex = theirOffset + i >> theirChange; + let bucketIndex = ourIndex - ours.indexBase; + if (bucketIndex < 0) { + bucketIndex += ours.backing.length; + } + ours.decrementBucket(bucketIndex, theirs.at(i)); + } + ours.trim(); + } + }; + exports.ExponentialHistogramAccumulation = ExponentialHistogramAccumulation; + var ExponentialHistogramAggregator = class { + kind = types_1.AggregatorKind.EXPONENTIAL_HISTOGRAM; + _maxSize; + _recordMinMax; + /** + * @param _maxSize Maximum number of buckets for each of the positive + * and negative ranges, exclusive of the zero-bucket. + * @param _recordMinMax If set to true, min and max will be recorded. + * Otherwise, min and max will not be recorded. + */ + constructor(maxSize, recordMinMax) { + this._maxSize = maxSize; + this._recordMinMax = recordMinMax; + } + createAccumulation(startTime) { + return new ExponentialHistogramAccumulation(startTime, this._maxSize, this._recordMinMax); + } + /** + * Return the result of the merge of two exponential histogram accumulations. + */ + merge(previous, delta) { + const result = delta.clone(); + result.merge(previous); + return result; + } + /** + * Returns a new DELTA aggregation by comparing two cumulative measurements. + */ + diff(previous, current) { + const result = current.clone(); + result.diff(previous); + return result; + } + toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) { + return { + descriptor, + aggregationTemporality, + dataPointType: MetricData_1.DataPointType.EXPONENTIAL_HISTOGRAM, + dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => { + const pointValue = accumulation.toPointValue(); + const allowsNegativeValues = descriptor.type === MetricData_1.InstrumentType.GAUGE || descriptor.type === MetricData_1.InstrumentType.UP_DOWN_COUNTER || descriptor.type === MetricData_1.InstrumentType.OBSERVABLE_GAUGE || descriptor.type === MetricData_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER; + return { + attributes, + startTime: accumulation.startTime, + endTime, + value: { + min: pointValue.hasMinMax ? pointValue.min : void 0, + max: pointValue.hasMinMax ? pointValue.max : void 0, + sum: !allowsNegativeValues ? pointValue.sum : void 0, + positive: { + offset: pointValue.positive.offset, + bucketCounts: pointValue.positive.bucketCounts + }, + negative: { + offset: pointValue.negative.offset, + bucketCounts: pointValue.negative.bucketCounts + }, + count: pointValue.count, + scale: pointValue.scale, + zeroCount: pointValue.zeroCount + } + }; + }) + }; + } + }; + exports.ExponentialHistogramAggregator = ExponentialHistogramAggregator; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/LastValue.js +var require_LastValue = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/LastValue.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.LastValueAggregator = exports.LastValueAccumulation = void 0; + var types_1 = require_types(); + var core_1 = require_src(); + var MetricData_1 = require_MetricData(); + var LastValueAccumulation = class { + startTime; + _current; + sampleTime; + constructor(startTime, current = 0, sampleTime = [0, 0]) { + this.startTime = startTime; + this._current = current; + this.sampleTime = sampleTime; + } + record(value) { + this._current = value; + this.sampleTime = (0, core_1.millisToHrTime)(Date.now()); + } + setStartTime(startTime) { + this.startTime = startTime; + } + toPointValue() { + return this._current; + } + }; + exports.LastValueAccumulation = LastValueAccumulation; + var LastValueAggregator = class { + kind = types_1.AggregatorKind.LAST_VALUE; + createAccumulation(startTime) { + return new LastValueAccumulation(startTime); + } + /** + * Returns the result of the merge of the given accumulations. + * + * Return the newly captured (delta) accumulation for LastValueAggregator. + */ + merge(previous, delta) { + const latestAccumulation = (0, core_1.hrTimeToMicroseconds)(delta.sampleTime) >= (0, core_1.hrTimeToMicroseconds)(previous.sampleTime) ? delta : previous; + return new LastValueAccumulation(previous.startTime, latestAccumulation.toPointValue(), latestAccumulation.sampleTime); + } + /** + * Returns a new DELTA aggregation by comparing two cumulative measurements. + * + * A delta aggregation is not meaningful to LastValueAggregator, just return + * the newly captured (delta) accumulation for LastValueAggregator. + */ + diff(previous, current) { + const latestAccumulation = (0, core_1.hrTimeToMicroseconds)(current.sampleTime) >= (0, core_1.hrTimeToMicroseconds)(previous.sampleTime) ? current : previous; + return new LastValueAccumulation(current.startTime, latestAccumulation.toPointValue(), latestAccumulation.sampleTime); + } + toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) { + return { + descriptor, + aggregationTemporality, + dataPointType: MetricData_1.DataPointType.GAUGE, + dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => { + return { + attributes, + startTime: accumulation.startTime, + endTime, + value: accumulation.toPointValue() + }; + }) + }; + } + }; + exports.LastValueAggregator = LastValueAggregator; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Sum.js +var require_Sum = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Sum.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SumAggregator = exports.SumAccumulation = void 0; + var types_1 = require_types(); + var MetricData_1 = require_MetricData(); + var SumAccumulation = class { + startTime; + monotonic; + _current; + reset; + constructor(startTime, monotonic, current = 0, reset = false) { + this.startTime = startTime; + this.monotonic = monotonic; + this._current = current; + this.reset = reset; + } + record(value) { + if (this.monotonic && value < 0) { + return; + } + this._current += value; + } + setStartTime(startTime) { + this.startTime = startTime; + } + toPointValue() { + return this._current; + } + }; + exports.SumAccumulation = SumAccumulation; + var SumAggregator = class { + kind = types_1.AggregatorKind.SUM; + monotonic; + constructor(monotonic) { + this.monotonic = monotonic; + } + createAccumulation(startTime) { + return new SumAccumulation(startTime, this.monotonic); + } + /** + * Returns the result of the merge of the given accumulations. + */ + merge(previous, delta) { + const prevPv = previous.toPointValue(); + const deltaPv = delta.toPointValue(); + if (delta.reset) { + return new SumAccumulation(delta.startTime, this.monotonic, deltaPv, delta.reset); + } + return new SumAccumulation(previous.startTime, this.monotonic, prevPv + deltaPv); + } + /** + * Returns a new DELTA aggregation by comparing two cumulative measurements. + */ + diff(previous, current) { + const prevPv = previous.toPointValue(); + const currPv = current.toPointValue(); + if (this.monotonic && prevPv > currPv) { + return new SumAccumulation(current.startTime, this.monotonic, currPv, true); + } + return new SumAccumulation(current.startTime, this.monotonic, currPv - prevPv); + } + toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) { + return { + descriptor, + aggregationTemporality, + dataPointType: MetricData_1.DataPointType.SUM, + dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => { + return { + attributes, + startTime: accumulation.startTime, + endTime, + value: accumulation.toPointValue() + }; + }), + isMonotonic: this.monotonic + }; + } + }; + exports.SumAggregator = SumAggregator; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/index.js +var require_aggregator = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SumAggregator = exports.SumAccumulation = exports.LastValueAggregator = exports.LastValueAccumulation = exports.ExponentialHistogramAggregator = exports.ExponentialHistogramAccumulation = exports.HistogramAggregator = exports.HistogramAccumulation = exports.DropAggregator = void 0; + var Drop_1 = require_Drop(); + Object.defineProperty(exports, "DropAggregator", { enumerable: true, get: function() { + return Drop_1.DropAggregator; + } }); + var Histogram_1 = require_Histogram(); + Object.defineProperty(exports, "HistogramAccumulation", { enumerable: true, get: function() { + return Histogram_1.HistogramAccumulation; + } }); + Object.defineProperty(exports, "HistogramAggregator", { enumerable: true, get: function() { + return Histogram_1.HistogramAggregator; + } }); + var ExponentialHistogram_1 = require_ExponentialHistogram(); + Object.defineProperty(exports, "ExponentialHistogramAccumulation", { enumerable: true, get: function() { + return ExponentialHistogram_1.ExponentialHistogramAccumulation; + } }); + Object.defineProperty(exports, "ExponentialHistogramAggregator", { enumerable: true, get: function() { + return ExponentialHistogram_1.ExponentialHistogramAggregator; + } }); + var LastValue_1 = require_LastValue(); + Object.defineProperty(exports, "LastValueAccumulation", { enumerable: true, get: function() { + return LastValue_1.LastValueAccumulation; + } }); + Object.defineProperty(exports, "LastValueAggregator", { enumerable: true, get: function() { + return LastValue_1.LastValueAggregator; + } }); + var Sum_1 = require_Sum(); + Object.defineProperty(exports, "SumAccumulation", { enumerable: true, get: function() { + return Sum_1.SumAccumulation; + } }); + Object.defineProperty(exports, "SumAggregator", { enumerable: true, get: function() { + return Sum_1.SumAggregator; + } }); + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/view/Aggregation.js +var require_Aggregation = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/view/Aggregation.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.DEFAULT_AGGREGATION = exports.EXPONENTIAL_HISTOGRAM_AGGREGATION = exports.HISTOGRAM_AGGREGATION = exports.LAST_VALUE_AGGREGATION = exports.SUM_AGGREGATION = exports.DROP_AGGREGATION = exports.DefaultAggregation = exports.ExponentialHistogramAggregation = exports.ExplicitBucketHistogramAggregation = exports.HistogramAggregation = exports.LastValueAggregation = exports.SumAggregation = exports.DropAggregation = void 0; + var api = (init_esm(), __toCommonJS(esm_exports)); + var aggregator_1 = require_aggregator(); + var MetricData_1 = require_MetricData(); + var DropAggregation = class _DropAggregation { + static DEFAULT_INSTANCE = new aggregator_1.DropAggregator(); + createAggregator(_instrument) { + return _DropAggregation.DEFAULT_INSTANCE; + } + }; + exports.DropAggregation = DropAggregation; + var SumAggregation = class _SumAggregation { + static MONOTONIC_INSTANCE = new aggregator_1.SumAggregator(true); + static NON_MONOTONIC_INSTANCE = new aggregator_1.SumAggregator(false); + createAggregator(instrument) { + switch (instrument.type) { + case MetricData_1.InstrumentType.COUNTER: + case MetricData_1.InstrumentType.OBSERVABLE_COUNTER: + case MetricData_1.InstrumentType.HISTOGRAM: { + return _SumAggregation.MONOTONIC_INSTANCE; + } + default: { + return _SumAggregation.NON_MONOTONIC_INSTANCE; + } + } + } + }; + exports.SumAggregation = SumAggregation; + var LastValueAggregation = class _LastValueAggregation { + static DEFAULT_INSTANCE = new aggregator_1.LastValueAggregator(); + createAggregator(_instrument) { + return _LastValueAggregation.DEFAULT_INSTANCE; + } + }; + exports.LastValueAggregation = LastValueAggregation; + var HistogramAggregation = class _HistogramAggregation { + static DEFAULT_INSTANCE = new aggregator_1.HistogramAggregator([0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1e3, 2500, 5e3, 7500, 1e4], true); + createAggregator(_instrument) { + return _HistogramAggregation.DEFAULT_INSTANCE; + } + }; + exports.HistogramAggregation = HistogramAggregation; + var ExplicitBucketHistogramAggregation = class { + _boundaries; + _recordMinMax; + /** + * @param boundaries the bucket boundaries of the histogram aggregation + * @param _recordMinMax If set to true, min and max will be recorded. Otherwise, min and max will not be recorded. + */ + constructor(boundaries, recordMinMax = true) { + if (boundaries == null) { + throw new Error("ExplicitBucketHistogramAggregation should be created with explicit boundaries, if a single bucket histogram is required, please pass an empty array"); + } + boundaries = boundaries.concat(); + boundaries = boundaries.sort((a, b) => a - b); + const minusInfinityIndex = boundaries.lastIndexOf(-Infinity); + let infinityIndex = boundaries.indexOf(Infinity); + if (infinityIndex === -1) { + infinityIndex = void 0; + } + this._boundaries = boundaries.slice(minusInfinityIndex + 1, infinityIndex); + this._recordMinMax = recordMinMax; + } + createAggregator(_instrument) { + return new aggregator_1.HistogramAggregator(this._boundaries, this._recordMinMax); + } + }; + exports.ExplicitBucketHistogramAggregation = ExplicitBucketHistogramAggregation; + var ExponentialHistogramAggregation = class { + _maxSize; + _recordMinMax; + constructor(maxSize = 160, recordMinMax = true) { + this._maxSize = maxSize; + this._recordMinMax = recordMinMax; + } + createAggregator(_instrument) { + return new aggregator_1.ExponentialHistogramAggregator(this._maxSize, this._recordMinMax); + } + }; + exports.ExponentialHistogramAggregation = ExponentialHistogramAggregation; + var DefaultAggregation = class { + _resolve(instrument) { + switch (instrument.type) { + case MetricData_1.InstrumentType.COUNTER: + case MetricData_1.InstrumentType.UP_DOWN_COUNTER: + case MetricData_1.InstrumentType.OBSERVABLE_COUNTER: + case MetricData_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER: { + return exports.SUM_AGGREGATION; + } + case MetricData_1.InstrumentType.GAUGE: + case MetricData_1.InstrumentType.OBSERVABLE_GAUGE: { + return exports.LAST_VALUE_AGGREGATION; + } + case MetricData_1.InstrumentType.HISTOGRAM: { + if (instrument.advice.explicitBucketBoundaries) { + return new ExplicitBucketHistogramAggregation(instrument.advice.explicitBucketBoundaries); + } + return exports.HISTOGRAM_AGGREGATION; + } + } + api.diag.warn(`Unable to recognize instrument type: ${instrument.type}`); + return exports.DROP_AGGREGATION; + } + createAggregator(instrument) { + return this._resolve(instrument).createAggregator(instrument); + } + }; + exports.DefaultAggregation = DefaultAggregation; + exports.DROP_AGGREGATION = new DropAggregation(); + exports.SUM_AGGREGATION = new SumAggregation(); + exports.LAST_VALUE_AGGREGATION = new LastValueAggregation(); + exports.HISTOGRAM_AGGREGATION = new HistogramAggregation(); + exports.EXPONENTIAL_HISTOGRAM_AGGREGATION = new ExponentialHistogramAggregation(); + exports.DEFAULT_AGGREGATION = new DefaultAggregation(); + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/view/AggregationOption.js +var require_AggregationOption = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/view/AggregationOption.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.toAggregation = exports.AggregationType = void 0; + var Aggregation_1 = require_Aggregation(); + var AggregationType; + (function(AggregationType2) { + AggregationType2[AggregationType2["DEFAULT"] = 0] = "DEFAULT"; + AggregationType2[AggregationType2["DROP"] = 1] = "DROP"; + AggregationType2[AggregationType2["SUM"] = 2] = "SUM"; + AggregationType2[AggregationType2["LAST_VALUE"] = 3] = "LAST_VALUE"; + AggregationType2[AggregationType2["EXPLICIT_BUCKET_HISTOGRAM"] = 4] = "EXPLICIT_BUCKET_HISTOGRAM"; + AggregationType2[AggregationType2["EXPONENTIAL_HISTOGRAM"] = 5] = "EXPONENTIAL_HISTOGRAM"; + })(AggregationType || (exports.AggregationType = AggregationType = {})); + function toAggregation(option2) { + switch (option2.type) { + case AggregationType.DEFAULT: + return Aggregation_1.DEFAULT_AGGREGATION; + case AggregationType.DROP: + return Aggregation_1.DROP_AGGREGATION; + case AggregationType.SUM: + return Aggregation_1.SUM_AGGREGATION; + case AggregationType.LAST_VALUE: + return Aggregation_1.LAST_VALUE_AGGREGATION; + case AggregationType.EXPONENTIAL_HISTOGRAM: { + const expOption = option2; + return new Aggregation_1.ExponentialHistogramAggregation(expOption.options?.maxSize, expOption.options?.recordMinMax); + } + case AggregationType.EXPLICIT_BUCKET_HISTOGRAM: { + const expOption = option2; + if (expOption.options == null) { + return Aggregation_1.HISTOGRAM_AGGREGATION; + } else { + return new Aggregation_1.ExplicitBucketHistogramAggregation(expOption.options?.boundaries, expOption.options?.recordMinMax); + } + } + default: + throw new Error("Unsupported Aggregation"); + } + } + exports.toAggregation = toAggregation; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/export/AggregationSelector.js +var require_AggregationSelector = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/export/AggregationSelector.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR = exports.DEFAULT_AGGREGATION_SELECTOR = void 0; + var AggregationTemporality_1 = require_AggregationTemporality(); + var AggregationOption_1 = require_AggregationOption(); + var DEFAULT_AGGREGATION_SELECTOR = (_instrumentType) => { + return { + type: AggregationOption_1.AggregationType.DEFAULT + }; + }; + exports.DEFAULT_AGGREGATION_SELECTOR = DEFAULT_AGGREGATION_SELECTOR; + var DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR = (_instrumentType) => AggregationTemporality_1.AggregationTemporality.CUMULATIVE; + exports.DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR = DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/semconv.js +var require_semconv2 = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/semconv.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ATTR_ERROR_TYPE = exports.METRIC_OTEL_SDK_METRIC_READER_COLLECTION_DURATION = exports.OTEL_COMPONENT_TYPE_VALUE_PERIODIC_METRIC_READER = exports.ATTR_OTEL_COMPONENT_TYPE = exports.ATTR_OTEL_COMPONENT_NAME = void 0; + exports.ATTR_OTEL_COMPONENT_NAME = "otel.component.name"; + exports.ATTR_OTEL_COMPONENT_TYPE = "otel.component.type"; + exports.OTEL_COMPONENT_TYPE_VALUE_PERIODIC_METRIC_READER = "periodic_metric_reader"; + exports.METRIC_OTEL_SDK_METRIC_READER_COLLECTION_DURATION = "otel.sdk.metric_reader.collection.duration"; + exports.ATTR_ERROR_TYPE = "error.type"; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/export/MetricReaderMetrics.js +var require_MetricReaderMetrics = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/export/MetricReaderMetrics.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MetricReaderMetrics = void 0; + var semconv_1 = require_semconv2(); + var componentCounter2 = /* @__PURE__ */ new Map(); + var MetricReaderMetrics = class { + collectionDuration; + standardAttrs; + constructor(componentType, meter) { + const counter = componentCounter2.get(componentType) ?? 0; + componentCounter2.set(componentType, counter + 1); + this.standardAttrs = { + [semconv_1.ATTR_OTEL_COMPONENT_TYPE]: componentType, + [semconv_1.ATTR_OTEL_COMPONENT_NAME]: `${componentType}/${counter}` + }; + this.collectionDuration = meter.createHistogram(semconv_1.METRIC_OTEL_SDK_METRIC_READER_COLLECTION_DURATION, { + unit: "s", + description: "The duration of the collect operation of the metric reader.", + advice: { + explicitBucketBoundaries: [] + } + }); + } + recordCollection(durationSecs, error) { + const attrs = error ? { ...this.standardAttrs, [semconv_1.ATTR_ERROR_TYPE]: error } : this.standardAttrs; + this.collectionDuration.record(durationSecs, attrs); + } + }; + exports.MetricReaderMetrics = MetricReaderMetrics; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/version.js +var require_version2 = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/version.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.VERSION = void 0; + exports.VERSION = "2.11.0"; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/export/MetricReader.js +var require_MetricReader = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/export/MetricReader.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MetricReader = void 0; + var api = (init_esm(), __toCommonJS(esm_exports)); + var utils_1 = require_utils3(); + var AggregationSelector_1 = require_AggregationSelector(); + var MetricReaderMetrics_1 = require_MetricReaderMetrics(); + var version_1 = require_version2(); + var core_1 = require_src(); + var MetricReader = class { + // Tracks the shutdown state. + // TODO: use BindOncePromise here once a new version of @opentelemetry/core is available. + _shutdown = false; + // Additional MetricProducers which will be combined with the SDK's output + _metricProducers; + // MetricProducer used by this instance which produces metrics from the SDK + _sdkMetricProducer; + // Metrics about the MetricReader itself + _selfObsMetrics; + _aggregationTemporalitySelector; + _aggregationSelector; + _cardinalitySelector; + _otelComponentType; + constructor(options) { + this._aggregationSelector = options?.aggregationSelector ?? AggregationSelector_1.DEFAULT_AGGREGATION_SELECTOR; + this._aggregationTemporalitySelector = options?.aggregationTemporalitySelector ?? AggregationSelector_1.DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR; + this._metricProducers = options?.metricProducers ?? []; + this._cardinalitySelector = options?.cardinalitySelector; + this._otelComponentType = options?.otelComponentType ?? this.constructor.name; + this._selfObsMetrics = new MetricReaderMetrics_1.MetricReaderMetrics(this._otelComponentType, api.createNoopMeter()); + } + setMetricProducer(metricProducer) { + if (this._sdkMetricProducer) { + throw new Error("MetricReader can not be bound to a MeterProvider again."); + } + this._sdkMetricProducer = metricProducer; + this.onInitialized(); + } + _setSelfObsMeterProvider(meterProvider) { + const meter = meterProvider.getMeter("@opentelemetry/sdk-metrics", version_1.VERSION); + this._selfObsMetrics = new MetricReaderMetrics_1.MetricReaderMetrics(this._otelComponentType, meter); + } + selectAggregation(instrumentType) { + return this._aggregationSelector(instrumentType); + } + selectAggregationTemporality(instrumentType) { + return this._aggregationTemporalitySelector(instrumentType); + } + selectCardinalityLimit(instrumentType) { + return this._cardinalitySelector ? this._cardinalitySelector(instrumentType) : 2e3; + } + /** + * Handle once the SDK has initialized this {@link MetricReader} + * Overriding this method is optional. + */ + onInitialized() { + } + async collect(options) { + if (this._sdkMetricProducer === void 0) { + throw new Error("MetricReader is not bound to a MetricProducer"); + } + if (this._shutdown) { + throw new Error("MetricReader is shutdown"); + } + const startTime = (0, core_1.hrTime)(); + const [sdkCollectionResults, ...additionalCollectionResults] = await Promise.all([ + this._sdkMetricProducer.collect({ + timeoutMillis: options?.timeoutMillis + }), + ...this._metricProducers.map((producer) => producer.collect({ + timeoutMillis: options?.timeoutMillis + })) + ]); + const endTime = (0, core_1.hrTime)(); + const errors = sdkCollectionResults.errors.concat(additionalCollectionResults.flatMap((result) => result.errors)); + const collectDuration = (0, core_1.hrTimeToSeconds)((0, core_1.hrTimeDuration)(startTime, endTime)); + this._selfObsMetrics.recordCollection(collectDuration, errors.length > 0 ? errors[0].name ?? "collect_error" : void 0); + const resource = sdkCollectionResults.resourceMetrics.resource; + const scopeMetrics = sdkCollectionResults.resourceMetrics.scopeMetrics.concat(additionalCollectionResults.flatMap((result) => result.resourceMetrics.scopeMetrics)); + return { + resourceMetrics: { + resource, + scopeMetrics + }, + errors + }; + } + async shutdown(options) { + if (this._shutdown) { + api.diag.error("Cannot call shutdown twice."); + return; + } + if (options?.timeoutMillis == null) { + await this.onShutdown(); + } else { + await (0, utils_1.callWithTimeout)(this.onShutdown(), options.timeoutMillis); + } + this._shutdown = true; + } + async forceFlush(options) { + if (this._shutdown) { + api.diag.warn("Cannot forceFlush on already shutdown MetricReader."); + return; + } + if (options?.timeoutMillis == null) { + await this.onForceFlush(); + return; + } + await (0, utils_1.callWithTimeout)(this.onForceFlush(), options.timeoutMillis); + } + }; + exports.MetricReader = MetricReader; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/export/MetricDataSplitter.js +var require_MetricDataSplitter = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/export/MetricDataSplitter.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.splitMetricData = void 0; + function splitMetricData(resourceMetrics, maxExportBatchSize) { + if (!Number.isInteger(maxExportBatchSize) || maxExportBatchSize <= 0) { + throw new Error("maxExportBatchSize must be a positive integer"); + } + const batches = []; + let currentBatchPoints = 0; + let currentScopeMetrics = []; + function flush() { + if (currentScopeMetrics.length > 0) { + batches.push({ + resource: resourceMetrics.resource, + scopeMetrics: currentScopeMetrics + }); + currentScopeMetrics = []; + currentBatchPoints = 0; + } + } + for (const scopeMetric of resourceMetrics.scopeMetrics) { + let scopeMetricCopy = null; + for (const metric of scopeMetric.metrics) { + const dataPoints = metric.dataPoints; + if (dataPoints.length === 0) { + if (!scopeMetricCopy) { + scopeMetricCopy = { scope: scopeMetric.scope, metrics: [] }; + currentScopeMetrics.push(scopeMetricCopy); + } + scopeMetricCopy.metrics.push(metric); + continue; + } + let offset = 0; + while (offset < dataPoints.length) { + const spaceLeft = maxExportBatchSize - currentBatchPoints; + const take = Math.min(spaceLeft, dataPoints.length - offset); + if (!scopeMetricCopy) { + scopeMetricCopy = { scope: scopeMetric.scope, metrics: [] }; + currentScopeMetrics.push(scopeMetricCopy); + } + const metricCopy = { + ...metric, + dataPoints: dataPoints.slice(offset, offset + take) + }; + scopeMetricCopy.metrics.push(metricCopy); + offset += take; + currentBatchPoints += take; + if (currentBatchPoints === maxExportBatchSize) { + flush(); + scopeMetricCopy = null; + } + } + } + } + flush(); + return batches; + } + exports.splitMetricData = splitMetricData; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/export/PeriodicExportingMetricReader.js +var require_PeriodicExportingMetricReader = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/export/PeriodicExportingMetricReader.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.PeriodicExportingMetricReader = void 0; + var api = (init_esm(), __toCommonJS(esm_exports)); + var core_1 = require_src(); + var MetricReader_1 = require_MetricReader(); + var utils_1 = require_utils3(); + var MetricData_1 = require_MetricData(); + var MetricDataSplitter_1 = require_MetricDataSplitter(); + var semconv_1 = require_semconv2(); + var PeriodicExportingMetricReader = class extends MetricReader_1.MetricReader { + _interval; + _exporter; + _exportInterval; + _exportTimeout; + _maxExportBatchSize; + _ongoingExportPromise = null; + constructor(options) { + const { exporter, exportIntervalMillis = 6e4, metricProducers, cardinalityLimits, maxExportBatchSize } = options; + let { exportTimeoutMillis = 3e4 } = options; + super({ + aggregationSelector: exporter.selectAggregation?.bind(exporter), + aggregationTemporalitySelector: exporter.selectAggregationTemporality?.bind(exporter), + otelComponentType: semconv_1.OTEL_COMPONENT_TYPE_VALUE_PERIODIC_METRIC_READER, + metricProducers, + cardinalitySelector: (instrumentType) => { + const limits = { + default: 2e3, + ...cardinalityLimits + }; + switch (instrumentType) { + case MetricData_1.InstrumentType.COUNTER: + return limits.counter ?? limits.default; + case MetricData_1.InstrumentType.GAUGE: + return limits.gauge ?? limits.default; + case MetricData_1.InstrumentType.HISTOGRAM: + return limits.histogram ?? limits.default; + case MetricData_1.InstrumentType.OBSERVABLE_COUNTER: + return limits.observableCounter ?? limits.default; + case MetricData_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER: + return limits.observableUpDownCounter ?? limits.default; + case MetricData_1.InstrumentType.OBSERVABLE_GAUGE: + return limits.observableGauge ?? limits.default; + case MetricData_1.InstrumentType.UP_DOWN_COUNTER: + return limits.upDownCounter ?? limits.default; + default: + return limits.default; + } + } + }); + if (exportIntervalMillis <= 0) { + throw Error("exportIntervalMillis must be greater than 0"); + } + if (exportTimeoutMillis <= 0) { + throw Error("exportTimeoutMillis must be greater than 0"); + } + if (maxExportBatchSize !== void 0 && (!Number.isInteger(maxExportBatchSize) || maxExportBatchSize <= 0)) { + throw Error("maxExportBatchSize must be a positive integer"); + } + if (exportIntervalMillis < exportTimeoutMillis) { + if ("exportIntervalMillis" in options && "exportTimeoutMillis" in options) { + throw Error("exportIntervalMillis must be greater than or equal to exportTimeoutMillis"); + } else { + api.diag.info(`Timeout of ${exportTimeoutMillis} exceeds the interval of ${exportIntervalMillis}. Clamping timeout to interval duration.`); + exportTimeoutMillis = exportIntervalMillis; + } + } + this._exportInterval = exportIntervalMillis; + this._exportTimeout = exportTimeoutMillis; + this._exporter = exporter; + this._maxExportBatchSize = maxExportBatchSize; + } + async _runOnce() { + try { + await this._doRun(); + } catch (err) { + (0, core_1.globalErrorHandler)(err); + } + } + async _doRun() { + if (this._ongoingExportPromise) { + api.diag.debug("PeriodicExportingMetricReader: export already in progress, skipping"); + return; + } + const currentRun = async () => { + const { resourceMetrics, errors } = await this.collect({ + timeoutMillis: this._exportTimeout + }); + if (errors.length > 0) { + api.diag.error("PeriodicExportingMetricReader: metrics collection errors", ...errors); + } + if (resourceMetrics.resource.asyncAttributesPending) { + try { + await resourceMetrics.resource.waitForAsyncAttributes?.(); + } catch (e) { + api.diag.debug("Error while resolving async portion of resource: ", e); + (0, core_1.globalErrorHandler)(e); + } + } + if (resourceMetrics.scopeMetrics.length === 0) { + return; + } + const batches = this._maxExportBatchSize ? (0, MetricDataSplitter_1.splitMetricData)(resourceMetrics, this._maxExportBatchSize) : [resourceMetrics]; + let anyErr = null; + for (const batch of batches) { + try { + const result = await (0, utils_1.callWithTimeout)(core_1.internal._export(this._exporter, batch), this._exportTimeout); + if (result.code !== core_1.ExportResultCode.SUCCESS) { + const err = new Error(`PeriodicExportingMetricReader: metrics export failed (error ${result.error})`); + anyErr = err; + } + } catch (e) { + if (e instanceof utils_1.TimeoutError) { + api.diag.error(`PeriodicExportingMetricReader: metrics export timed out after ${this._exportTimeout}ms`); + break; + } else { + api.diag.error("PeriodicExportingMetricReader: metrics export threw error", e); + anyErr = e instanceof Error ? e : new Error(String(e)); + } + } + } + if (anyErr) { + throw anyErr; + } + }; + this._ongoingExportPromise = currentRun(); + try { + await this._ongoingExportPromise; + } finally { + this._ongoingExportPromise = null; + } + } + onInitialized() { + this._interval = setInterval(() => { + void this._runOnce(); + }, this._exportInterval); + if (typeof this._interval !== "number") { + this._interval.unref(); + } + } + async onForceFlush() { + await this._awaitOngoingExport(); + if (this._ongoingExportPromise) { + await this._awaitOngoingExport(); + } else { + await this._runOnce(); + } + await this._exporter.forceFlush(); + } + /** + * Helper function to wait for an ongoing export to complete. + * Errors are swallowed and handled by the original _runOnce(). + */ + async _awaitOngoingExport() { + if (this._ongoingExportPromise) { + api.diag.debug("PeriodicExportingMetricReader: export already in progress, awaiting ongoing export"); + try { + await this._ongoingExportPromise; + } catch { + } + } + } + async onShutdown() { + if (this._interval) { + clearInterval(this._interval); + } + await this.onForceFlush(); + await this._exporter.shutdown(); + } + }; + exports.PeriodicExportingMetricReader = PeriodicExportingMetricReader; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/export/InMemoryMetricExporter.js +var require_InMemoryMetricExporter = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/export/InMemoryMetricExporter.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.InMemoryMetricExporter = void 0; + var core_1 = require_src(); + var InMemoryMetricExporter = class { + _shutdown = false; + _aggregationTemporality; + _metrics = []; + constructor(aggregationTemporality) { + this._aggregationTemporality = aggregationTemporality; + } + /** + * @inheritedDoc + */ + export(metrics2, resultCallback) { + if (this._shutdown) { + setTimeout(() => resultCallback({ code: core_1.ExportResultCode.FAILED }), 0); + return; + } + this._metrics.push(metrics2); + setTimeout(() => resultCallback({ code: core_1.ExportResultCode.SUCCESS }), 0); + } + /** + * Returns all the collected resource metrics + * @returns ResourceMetrics[] + */ + getMetrics() { + return this._metrics; + } + forceFlush() { + return Promise.resolve(); + } + reset() { + this._metrics = []; + } + selectAggregationTemporality(_instrumentType) { + return this._aggregationTemporality; + } + shutdown() { + this._shutdown = true; + return Promise.resolve(); + } + }; + exports.InMemoryMetricExporter = InMemoryMetricExporter; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/export/ConsoleMetricExporter.js +var require_ConsoleMetricExporter = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/export/ConsoleMetricExporter.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ConsoleMetricExporter = void 0; + var core_1 = require_src(); + var AggregationSelector_1 = require_AggregationSelector(); + var ConsoleMetricExporter = class _ConsoleMetricExporter { + _shutdown = false; + _temporalitySelector; + constructor(options) { + this._temporalitySelector = options?.temporalitySelector ?? AggregationSelector_1.DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR; + } + export(metrics2, resultCallback) { + if (this._shutdown) { + resultCallback({ code: core_1.ExportResultCode.FAILED }); + return; + } + return _ConsoleMetricExporter._sendMetrics(metrics2, resultCallback); + } + forceFlush() { + return Promise.resolve(); + } + selectAggregationTemporality(_instrumentType) { + return this._temporalitySelector(_instrumentType); + } + shutdown() { + this._shutdown = true; + return Promise.resolve(); + } + static _sendMetrics(metrics2, done) { + for (const scopeMetrics of metrics2.scopeMetrics) { + for (const metric of scopeMetrics.metrics) { + console.dir({ + descriptor: metric.descriptor, + dataPointType: metric.dataPointType, + dataPoints: metric.dataPoints + }, { depth: null }); + } + } + done({ code: core_1.ExportResultCode.SUCCESS }); + } + }; + exports.ConsoleMetricExporter = ConsoleMetricExporter; + } +}); + +// node_modules/@opentelemetry/resources/build/src/default-service-name.js +var require_default_service_name = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/default-service-name.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports._clearDefaultServiceNameCache = exports.defaultServiceName = void 0; + var serviceName; + 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; + } + exports.defaultServiceName = defaultServiceName; + function _clearDefaultServiceNameCache() { + serviceName = void 0; + } + exports._clearDefaultServiceNameCache = _clearDefaultServiceNameCache; + } +}); + +// node_modules/@opentelemetry/resources/build/src/utils.js +var require_utils4 = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/utils.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isPromiseLike = void 0; + var isPromiseLike = (val) => { + return val !== null && typeof val === "object" && typeof val.then === "function"; + }; + exports.isPromiseLike = isPromiseLike; + } +}); + +// node_modules/@opentelemetry/resources/build/src/ResourceImpl.js +var require_ResourceImpl = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/ResourceImpl.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.defaultResource = exports.emptyResource = exports.resourceFromDetectedResource = exports.resourceFromAttributes = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var core_1 = require_src(); + var semantic_conventions_1 = (init_esm2(), __toCommonJS(esm_exports2)); + var default_service_name_1 = require_default_service_name(); + var utils_1 = require_utils4(); + var 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]) => (0, utils_1.isPromiseLike)(val)).length > 0; + return res; + } + constructor(resource, options) { + const attributes = resource.attributes ?? {}; + this._rawAttributes = Object.entries(attributes).map(([k, v]) => { + if ((0, utils_1.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, (0, utils_1.isPromiseLike)(v) ? await v : v]; + } + this._asyncAttributesPending = false; + } + get attributes() { + if (this.asyncAttributesPending) { + api_1.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 ((0, utils_1.isPromiseLike)(v)) { + api_1.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); + } + }; + function resourceFromAttributes(attributes, options) { + return ResourceImpl.FromAttributeList(Object.entries(attributes), options); + } + exports.resourceFromAttributes = resourceFromAttributes; + function resourceFromDetectedResource(detectedResource, options) { + return new ResourceImpl(detectedResource, options); + } + exports.resourceFromDetectedResource = resourceFromDetectedResource; + function emptyResource() { + return resourceFromAttributes({}); + } + exports.emptyResource = emptyResource; + function defaultResource() { + return resourceFromAttributes({ + [semantic_conventions_1.ATTR_SERVICE_NAME]: (0, default_service_name_1.defaultServiceName)(), + [semantic_conventions_1.ATTR_TELEMETRY_SDK_LANGUAGE]: core_1.SDK_INFO[semantic_conventions_1.ATTR_TELEMETRY_SDK_LANGUAGE], + [semantic_conventions_1.ATTR_TELEMETRY_SDK_NAME]: core_1.SDK_INFO[semantic_conventions_1.ATTR_TELEMETRY_SDK_NAME], + [semantic_conventions_1.ATTR_TELEMETRY_SDK_VERSION]: core_1.SDK_INFO[semantic_conventions_1.ATTR_TELEMETRY_SDK_VERSION] + }); + } + exports.defaultResource = defaultResource; + function guardedRawAttributes(attributes) { + return attributes.map(([k, v]) => { + if ((0, utils_1.isPromiseLike)(v)) { + return [ + k, + v.catch((err) => { + api_1.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; + } + api_1.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; + } + api_1.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; + } + } +}); + +// node_modules/@opentelemetry/resources/build/src/detect-resources.js +var require_detect_resources = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detect-resources.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.detectResources = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var ResourceImpl_1 = require_ResourceImpl(); + var detectResources = (config = {}) => { + const resources = (config.detectors || []).map((d) => { + try { + const resource = (0, ResourceImpl_1.resourceFromDetectedResource)(d.detect(config)); + api_1.diag.debug(`${d.constructor.name} found resource.`, resource); + return resource; + } catch (e) { + api_1.diag.debug(`${d.constructor.name} failed: ${e.message}`); + return (0, ResourceImpl_1.emptyResource)(); + } + }); + return resources.reduce((acc, resource) => acc.merge(resource), (0, ResourceImpl_1.emptyResource)()); + }; + exports.detectResources = detectResources; + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/EnvDetector.js +var require_EnvDetector = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/EnvDetector.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.envDetector = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var semantic_conventions_1 = (init_esm2(), __toCommonJS(esm_exports2)); + var core_1 = require_src(); + var 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 = "="; + /** + * 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 = (0, core_1.getStringFromEnv)("OTEL_RESOURCE_ATTRIBUTES"); + const serviceName = (0, core_1.getStringFromEnv)("OTEL_SERVICE_NAME"); + if (rawAttributes) { + try { + const parsedAttributes = this._parseResourceAttributes(rawAttributes); + Object.assign(attributes, parsedAttributes); + } catch (e) { + api_1.diag.debug(`EnvDetector failed: ${e instanceof Error ? e.message : e}`); + } + } + if (serviceName) { + attributes[semantic_conventions_1.ATTR_SERVICE_NAME] = serviceName; + } + return { attributes }; + } + /** + * Creates an attribute map from the OTEL_RESOURCE_ATTRIBUTES environment + * variable. + * + * OTEL_RESOURCE_ATTRIBUTES: A comma-separated list of attributes in the + * format "key1=value1,key2=value2". The ',' and '=' characters in keys + * and values MUST be percent-encoded. Other characters MAY be percent-encoded. + * + * Per the spec, on any error (e.g., decoding failure), the entire environment + * variable value is discarded. + * + * @param rawEnvAttributes The resource attributes as a comma-separated list + * of key/value pairs. + * @returns The parsed resource attributes. + * @throws Error if parsing fails (caller handles by discarding all attributes) + */ + _parseResourceAttributes(rawEnvAttributes) { + if (!rawEnvAttributes) + return {}; + const attributes = {}; + const rawAttributes = rawEnvAttributes.split(this._COMMA_SEPARATOR).filter((attr) => attr.trim() !== ""); + for (const rawAttribute of rawAttributes) { + const keyValuePair = rawAttribute.split(this._LABEL_KEY_VALUE_SPLITTER); + if (keyValuePair.length !== 2) { + throw new Error(`Invalid format for OTEL_RESOURCE_ATTRIBUTES: "${rawAttribute}". Expected format: key=value. The ',' and '=' characters must be percent-encoded in keys and values.`); + } + const [rawKey, rawValue] = keyValuePair; + const key = rawKey.trim(); + const value = rawValue.trim(); + if (key.length === 0) { + throw new Error(`Invalid OTEL_RESOURCE_ATTRIBUTES: empty attribute key in "${rawAttribute}".`); + } + let decodedKey; + let decodedValue; + try { + decodedKey = decodeURIComponent(key); + decodedValue = decodeURIComponent(value); + } catch (e) { + throw new Error(`Failed to percent-decode OTEL_RESOURCE_ATTRIBUTES entry "${rawAttribute}": ${e instanceof Error ? e.message : e}`, { cause: e }); + } + if (decodedKey.length > this._MAX_LENGTH) { + throw new Error(`Attribute key exceeds the maximum length of ${this._MAX_LENGTH} characters: "${decodedKey}".`); + } + if (decodedValue.length > this._MAX_LENGTH) { + throw new Error(`Attribute value exceeds the maximum length of ${this._MAX_LENGTH} characters for key "${decodedKey}".`); + } + attributes[decodedKey] = decodedValue; + } + return attributes; + } + }; + exports.envDetector = new EnvDetector(); + } +}); + +// node_modules/@opentelemetry/resources/build/src/semconv.js +var require_semconv3 = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/semconv.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ATTR_WEBENGINE_VERSION = exports.ATTR_WEBENGINE_NAME = exports.ATTR_WEBENGINE_DESCRIPTION = exports.ATTR_SERVICE_NAMESPACE = exports.ATTR_SERVICE_INSTANCE_ID = exports.ATTR_PROCESS_RUNTIME_VERSION = exports.ATTR_PROCESS_RUNTIME_NAME = exports.ATTR_PROCESS_RUNTIME_DESCRIPTION = exports.ATTR_PROCESS_PID = exports.ATTR_PROCESS_OWNER = exports.ATTR_PROCESS_EXECUTABLE_PATH = exports.ATTR_PROCESS_EXECUTABLE_NAME = exports.ATTR_PROCESS_COMMAND_ARGS = exports.ATTR_PROCESS_COMMAND = exports.ATTR_OS_VERSION = exports.ATTR_OS_TYPE = exports.ATTR_K8S_POD_NAME = exports.ATTR_K8S_NAMESPACE_NAME = exports.ATTR_K8S_DEPLOYMENT_NAME = exports.ATTR_K8S_CLUSTER_NAME = exports.ATTR_HOST_TYPE = exports.ATTR_HOST_NAME = exports.ATTR_HOST_IMAGE_VERSION = exports.ATTR_HOST_IMAGE_NAME = exports.ATTR_HOST_IMAGE_ID = exports.ATTR_HOST_ID = exports.ATTR_HOST_ARCH = exports.ATTR_CONTAINER_NAME = exports.ATTR_CONTAINER_IMAGE_TAGS = exports.ATTR_CONTAINER_IMAGE_NAME = exports.ATTR_CONTAINER_ID = exports.ATTR_CLOUD_REGION = exports.ATTR_CLOUD_PROVIDER = exports.ATTR_CLOUD_AVAILABILITY_ZONE = exports.ATTR_CLOUD_ACCOUNT_ID = void 0; + exports.ATTR_CLOUD_ACCOUNT_ID = "cloud.account.id"; + exports.ATTR_CLOUD_AVAILABILITY_ZONE = "cloud.availability_zone"; + exports.ATTR_CLOUD_PROVIDER = "cloud.provider"; + exports.ATTR_CLOUD_REGION = "cloud.region"; + exports.ATTR_CONTAINER_ID = "container.id"; + exports.ATTR_CONTAINER_IMAGE_NAME = "container.image.name"; + exports.ATTR_CONTAINER_IMAGE_TAGS = "container.image.tags"; + exports.ATTR_CONTAINER_NAME = "container.name"; + exports.ATTR_HOST_ARCH = "host.arch"; + exports.ATTR_HOST_ID = "host.id"; + exports.ATTR_HOST_IMAGE_ID = "host.image.id"; + exports.ATTR_HOST_IMAGE_NAME = "host.image.name"; + exports.ATTR_HOST_IMAGE_VERSION = "host.image.version"; + exports.ATTR_HOST_NAME = "host.name"; + exports.ATTR_HOST_TYPE = "host.type"; + exports.ATTR_K8S_CLUSTER_NAME = "k8s.cluster.name"; + exports.ATTR_K8S_DEPLOYMENT_NAME = "k8s.deployment.name"; + exports.ATTR_K8S_NAMESPACE_NAME = "k8s.namespace.name"; + exports.ATTR_K8S_POD_NAME = "k8s.pod.name"; + exports.ATTR_OS_TYPE = "os.type"; + exports.ATTR_OS_VERSION = "os.version"; + exports.ATTR_PROCESS_COMMAND = "process.command"; + exports.ATTR_PROCESS_COMMAND_ARGS = "process.command_args"; + exports.ATTR_PROCESS_EXECUTABLE_NAME = "process.executable.name"; + exports.ATTR_PROCESS_EXECUTABLE_PATH = "process.executable.path"; + exports.ATTR_PROCESS_OWNER = "process.owner"; + exports.ATTR_PROCESS_PID = "process.pid"; + exports.ATTR_PROCESS_RUNTIME_DESCRIPTION = "process.runtime.description"; + exports.ATTR_PROCESS_RUNTIME_NAME = "process.runtime.name"; + exports.ATTR_PROCESS_RUNTIME_VERSION = "process.runtime.version"; + exports.ATTR_SERVICE_INSTANCE_ID = "service.instance.id"; + exports.ATTR_SERVICE_NAMESPACE = "service.namespace"; + exports.ATTR_WEBENGINE_DESCRIPTION = "webengine.description"; + exports.ATTR_WEBENGINE_NAME = "webengine.name"; + exports.ATTR_WEBENGINE_VERSION = "webengine.version"; + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/execAsync.js +var require_execAsync = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/execAsync.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.execAsync = void 0; + var child_process = __require("child_process"); + var util = __require("util"); + exports.execAsync = util.promisify(child_process.exec); + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-darwin.js +var require_getMachineId_darwin = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-darwin.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getMachineId = void 0; + var execAsync_1 = require_execAsync(); + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + async function getMachineId() { + try { + const result = await (0, execAsync_1.execAsync)('ioreg -rd1 -c "IOPlatformExpertDevice"'); + const idLine = result.stdout.split("\n").find((line) => line.includes("IOPlatformUUID")); + if (!idLine) { + return void 0; + } + const parts = idLine.split('" = "'); + if (parts.length === 2) { + return parts[1].slice(0, -1); + } + } catch (e) { + api_1.diag.debug(`error reading machine id: ${e}`); + } + return void 0; + } + exports.getMachineId = getMachineId; + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-linux.js +var require_getMachineId_linux = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-linux.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getMachineId = void 0; + var fs_1 = __require("fs"); + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + async function getMachineId() { + const paths = ["/etc/machine-id", "/var/lib/dbus/machine-id"]; + for (const path2 of paths) { + try { + const result = await fs_1.promises.readFile(path2, { encoding: "utf8" }); + return result.trim(); + } catch (e) { + api_1.diag.debug(`error reading machine id: ${e}`); + } + } + return void 0; + } + exports.getMachineId = getMachineId; + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-bsd.js +var require_getMachineId_bsd = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-bsd.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getMachineId = void 0; + var fs_1 = __require("fs"); + var execAsync_1 = require_execAsync(); + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + async function getMachineId() { + try { + const result = await fs_1.promises.readFile("/etc/hostid", { encoding: "utf8" }); + return result.trim(); + } catch (e) { + api_1.diag.debug(`error reading machine id: ${e}`); + } + try { + const result = await (0, execAsync_1.execAsync)("kenv -q smbios.system.uuid"); + return result.stdout.trim(); + } catch (e) { + api_1.diag.debug(`error reading machine id: ${e}`); + } + return void 0; + } + exports.getMachineId = getMachineId; + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-win.js +var require_getMachineId_win = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-win.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getMachineId = void 0; + var process2 = __require("process"); + var execAsync_1 = require_execAsync(); + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + async function getMachineId() { + const args = "QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid"; + let command = "%windir%\\System32\\REG.exe"; + if (process2.arch === "ia32" && "PROCESSOR_ARCHITEW6432" in process2.env) { + command = "%windir%\\sysnative\\cmd.exe /c " + command; + } + try { + const result = await (0, execAsync_1.execAsync)(`${command} ${args}`); + const parts = result.stdout.split("REG_SZ"); + if (parts.length === 2) { + return parts[1].trim(); + } + } catch (e) { + api_1.diag.debug(`error reading machine id: ${e}`); + } + return void 0; + } + exports.getMachineId = getMachineId; + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-unsupported.js +var require_getMachineId_unsupported = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-unsupported.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getMachineId = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + async function getMachineId() { + api_1.diag.debug("could not read machine-id: unsupported platform"); + return void 0; + } + exports.getMachineId = getMachineId; + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId.js +var require_getMachineId = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getMachineId = void 0; + var process2 = __require("process"); + var getMachineIdImpl; + async function getMachineId() { + if (!getMachineIdImpl) { + switch (process2.platform) { + case "darwin": + getMachineIdImpl = (await Promise.resolve().then(() => __toESM(require_getMachineId_darwin()))).getMachineId; + break; + case "linux": + getMachineIdImpl = (await Promise.resolve().then(() => __toESM(require_getMachineId_linux()))).getMachineId; + break; + case "freebsd": + getMachineIdImpl = (await Promise.resolve().then(() => __toESM(require_getMachineId_bsd()))).getMachineId; + break; + case "win32": + getMachineIdImpl = (await Promise.resolve().then(() => __toESM(require_getMachineId_win()))).getMachineId; + break; + default: + getMachineIdImpl = (await Promise.resolve().then(() => __toESM(require_getMachineId_unsupported()))).getMachineId; + break; + } + } + return getMachineIdImpl(); + } + exports.getMachineId = getMachineId; + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/platform/node/utils.js +var require_utils5 = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/platform/node/utils.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.normalizeType = exports.normalizeArch = void 0; + var normalizeArch = (nodeArchString) => { + switch (nodeArchString) { + case "arm": + return "arm32"; + case "ppc": + return "ppc32"; + case "x64": + return "amd64"; + default: + return nodeArchString; + } + }; + exports.normalizeArch = normalizeArch; + var normalizeType = (nodePlatform) => { + switch (nodePlatform) { + case "sunos": + return "solaris"; + case "win32": + return "windows"; + default: + return nodePlatform; + } + }; + exports.normalizeType = normalizeType; + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/platform/node/HostDetector.js +var require_HostDetector = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/platform/node/HostDetector.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.hostDetector = void 0; + var semconv_1 = require_semconv3(); + var os_1 = __require("os"); + var getMachineId_1 = require_getMachineId(); + var utils_1 = require_utils5(); + var HostDetector = class { + detect(_config) { + const attributes = { + [semconv_1.ATTR_HOST_NAME]: (0, os_1.hostname)(), + [semconv_1.ATTR_HOST_ARCH]: (0, utils_1.normalizeArch)((0, os_1.arch)()), + [semconv_1.ATTR_HOST_ID]: (0, getMachineId_1.getMachineId)() + }; + return { attributes }; + } + }; + exports.hostDetector = new HostDetector(); + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/platform/node/OSDetector.js +var require_OSDetector = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/platform/node/OSDetector.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.osDetector = void 0; + var semconv_1 = require_semconv3(); + var os_1 = __require("os"); + var utils_1 = require_utils5(); + var OSDetector = class { + detect(_config) { + const attributes = { + [semconv_1.ATTR_OS_TYPE]: (0, utils_1.normalizeType)((0, os_1.platform)()), + [semconv_1.ATTR_OS_VERSION]: (0, os_1.release)() + }; + return { attributes }; + } + }; + exports.osDetector = new OSDetector(); + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/platform/node/ProcessDetector.js +var require_ProcessDetector = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/platform/node/ProcessDetector.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.processDetector = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var semconv_1 = require_semconv3(); + var os = __require("os"); + var ProcessDetector = class { + detect(_config) { + const attributes = { + [semconv_1.ATTR_PROCESS_PID]: process.pid, + [semconv_1.ATTR_PROCESS_EXECUTABLE_NAME]: process.title, + [semconv_1.ATTR_PROCESS_EXECUTABLE_PATH]: process.execPath, + [semconv_1.ATTR_PROCESS_COMMAND_ARGS]: [ + process.argv[0], + ...process.execArgv, + ...process.argv.slice(1) + ], + [semconv_1.ATTR_PROCESS_RUNTIME_VERSION]: process.versions.node, + [semconv_1.ATTR_PROCESS_RUNTIME_NAME]: "nodejs", + [semconv_1.ATTR_PROCESS_RUNTIME_DESCRIPTION]: "Node.js" + }; + if (process.argv.length > 1) { + attributes[semconv_1.ATTR_PROCESS_COMMAND] = process.argv[1]; + } + try { + const userInfo = os.userInfo(); + attributes[semconv_1.ATTR_PROCESS_OWNER] = userInfo.username; + } catch (e) { + api_1.diag.debug(`error obtaining process owner: ${e}`); + } + return { attributes }; + } + }; + exports.processDetector = new ProcessDetector(); + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/platform/node/ServiceInstanceIdDetector.js +var require_ServiceInstanceIdDetector = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/platform/node/ServiceInstanceIdDetector.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.serviceInstanceIdDetector = void 0; + var semconv_1 = require_semconv3(); + var crypto_1 = __require("crypto"); + var ServiceInstanceIdDetector = class { + // Multiple calls to ServiceInstanceIdDetector return the same ID. + _serviceInstanceId; + detect(_config) { + if (!this._serviceInstanceId) { + this._serviceInstanceId = (0, crypto_1.randomUUID)(); + } + return { + attributes: { + [semconv_1.ATTR_SERVICE_INSTANCE_ID]: this._serviceInstanceId + } + }; + } + }; + exports.serviceInstanceIdDetector = new ServiceInstanceIdDetector(); + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/platform/node/index.js +var require_node2 = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/platform/node/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.serviceInstanceIdDetector = exports.processDetector = exports.osDetector = exports.hostDetector = void 0; + var HostDetector_1 = require_HostDetector(); + Object.defineProperty(exports, "hostDetector", { enumerable: true, get: function() { + return HostDetector_1.hostDetector; + } }); + var OSDetector_1 = require_OSDetector(); + Object.defineProperty(exports, "osDetector", { enumerable: true, get: function() { + return OSDetector_1.osDetector; + } }); + var ProcessDetector_1 = require_ProcessDetector(); + Object.defineProperty(exports, "processDetector", { enumerable: true, get: function() { + return ProcessDetector_1.processDetector; + } }); + var ServiceInstanceIdDetector_1 = require_ServiceInstanceIdDetector(); + Object.defineProperty(exports, "serviceInstanceIdDetector", { enumerable: true, get: function() { + return ServiceInstanceIdDetector_1.serviceInstanceIdDetector; + } }); + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/platform/index.js +var require_platform2 = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/platform/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.serviceInstanceIdDetector = exports.processDetector = exports.osDetector = exports.hostDetector = void 0; + var node_1 = require_node2(); + Object.defineProperty(exports, "hostDetector", { enumerable: true, get: function() { + return node_1.hostDetector; + } }); + Object.defineProperty(exports, "osDetector", { enumerable: true, get: function() { + return node_1.osDetector; + } }); + Object.defineProperty(exports, "processDetector", { enumerable: true, get: function() { + return node_1.processDetector; + } }); + Object.defineProperty(exports, "serviceInstanceIdDetector", { enumerable: true, get: function() { + return node_1.serviceInstanceIdDetector; + } }); + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/NoopDetector.js +var require_NoopDetector = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/NoopDetector.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.noopDetector = exports.NoopDetector = void 0; + var NoopDetector = class { + detect() { + return { + attributes: {} + }; + } + }; + exports.NoopDetector = NoopDetector; + exports.noopDetector = new NoopDetector(); + } +}); + +// node_modules/@opentelemetry/resources/build/src/detectors/index.js +var require_detectors = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/detectors/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.noopDetector = exports.serviceInstanceIdDetector = exports.processDetector = exports.osDetector = exports.hostDetector = exports.envDetector = void 0; + var EnvDetector_1 = require_EnvDetector(); + Object.defineProperty(exports, "envDetector", { enumerable: true, get: function() { + return EnvDetector_1.envDetector; + } }); + var platform_1 = require_platform2(); + Object.defineProperty(exports, "hostDetector", { enumerable: true, get: function() { + return platform_1.hostDetector; + } }); + Object.defineProperty(exports, "osDetector", { enumerable: true, get: function() { + return platform_1.osDetector; + } }); + Object.defineProperty(exports, "processDetector", { enumerable: true, get: function() { + return platform_1.processDetector; + } }); + Object.defineProperty(exports, "serviceInstanceIdDetector", { enumerable: true, get: function() { + return platform_1.serviceInstanceIdDetector; + } }); + var NoopDetector_1 = require_NoopDetector(); + Object.defineProperty(exports, "noopDetector", { enumerable: true, get: function() { + return NoopDetector_1.noopDetector; + } }); + } +}); + +// node_modules/@opentelemetry/resources/build/src/index.js +var require_src3 = __commonJS({ + "node_modules/@opentelemetry/resources/build/src/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.defaultServiceName = exports.emptyResource = exports.defaultResource = exports.resourceFromAttributes = exports.serviceInstanceIdDetector = exports.processDetector = exports.osDetector = exports.hostDetector = exports.envDetector = exports.detectResources = void 0; + var detect_resources_1 = require_detect_resources(); + Object.defineProperty(exports, "detectResources", { enumerable: true, get: function() { + return detect_resources_1.detectResources; + } }); + var detectors_1 = require_detectors(); + Object.defineProperty(exports, "envDetector", { enumerable: true, get: function() { + return detectors_1.envDetector; + } }); + Object.defineProperty(exports, "hostDetector", { enumerable: true, get: function() { + return detectors_1.hostDetector; + } }); + Object.defineProperty(exports, "osDetector", { enumerable: true, get: function() { + return detectors_1.osDetector; + } }); + Object.defineProperty(exports, "processDetector", { enumerable: true, get: function() { + return detectors_1.processDetector; + } }); + Object.defineProperty(exports, "serviceInstanceIdDetector", { enumerable: true, get: function() { + return detectors_1.serviceInstanceIdDetector; + } }); + var ResourceImpl_1 = require_ResourceImpl(); + Object.defineProperty(exports, "resourceFromAttributes", { enumerable: true, get: function() { + return ResourceImpl_1.resourceFromAttributes; + } }); + Object.defineProperty(exports, "defaultResource", { enumerable: true, get: function() { + return ResourceImpl_1.defaultResource; + } }); + Object.defineProperty(exports, "emptyResource", { enumerable: true, get: function() { + return ResourceImpl_1.emptyResource; + } }); + var default_service_name_1 = require_default_service_name(); + Object.defineProperty(exports, "defaultServiceName", { enumerable: true, get: function() { + return default_service_name_1.defaultServiceName; + } }); + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/view/ViewRegistry.js +var require_ViewRegistry = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/view/ViewRegistry.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ViewRegistry = void 0; + var ViewRegistry = class { + _registeredViews = []; + addView(view) { + this._registeredViews.push(view); + } + findViews(instrument, meter) { + const views = this._registeredViews.filter((registeredView) => { + return this._matchInstrument(registeredView.instrumentSelector, instrument) && this._matchMeter(registeredView.meterSelector, meter); + }); + return views; + } + _matchInstrument(selector, instrument) { + return (selector.getType() === void 0 || instrument.type === selector.getType()) && selector.getNameFilter().match(instrument.name) && selector.getUnitFilter().match(instrument.unit); + } + _matchMeter(selector, meter) { + return selector.getNameFilter().match(meter.name) && (meter.version === void 0 || selector.getVersionFilter().match(meter.version)) && (meter.schemaUrl === void 0 || selector.getSchemaUrlFilter().match(meter.schemaUrl)); + } + }; + exports.ViewRegistry = ViewRegistry; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/InstrumentDescriptor.js +var require_InstrumentDescriptor = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/InstrumentDescriptor.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isValidName = exports.isDescriptorCompatibleWith = exports.createInstrumentDescriptorWithView = exports.createInstrumentDescriptor = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var utils_1 = require_utils3(); + function createInstrumentDescriptor(name, type, options) { + if (!isValidName(name)) { + api_1.diag.warn(`Invalid metric name: "${name}". The metric name should be a ASCII string with a length no greater than 255 characters.`); + } + return { + name, + type, + description: options?.description ?? "", + unit: options?.unit ?? "", + valueType: options?.valueType ?? api_1.ValueType.DOUBLE, + advice: options?.advice ?? {} + }; + } + exports.createInstrumentDescriptor = createInstrumentDescriptor; + function createInstrumentDescriptorWithView(view, instrument) { + return { + name: view.name ?? instrument.name, + description: view.description ?? instrument.description, + type: instrument.type, + unit: instrument.unit, + valueType: instrument.valueType, + advice: instrument.advice + }; + } + exports.createInstrumentDescriptorWithView = createInstrumentDescriptorWithView; + function isDescriptorCompatibleWith(descriptor, otherDescriptor) { + return (0, utils_1.equalsCaseInsensitive)(descriptor.name, otherDescriptor.name) && descriptor.unit === otherDescriptor.unit && descriptor.type === otherDescriptor.type && descriptor.valueType === otherDescriptor.valueType; + } + exports.isDescriptorCompatibleWith = isDescriptorCompatibleWith; + var NAME_REGEXP = /^[a-z][a-z0-9_.\-/]{0,254}$/i; + function isValidName(name) { + return NAME_REGEXP.test(name); + } + exports.isValidName = isValidName; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/Instruments.js +var require_Instruments = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/Instruments.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.isObservableInstrument = exports.ObservableUpDownCounterInstrument = exports.ObservableGaugeInstrument = exports.ObservableCounterInstrument = exports.ObservableInstrument = exports.HistogramInstrument = exports.GaugeInstrument = exports.CounterInstrument = exports.UpDownCounterInstrument = exports.SyncInstrument = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var SyncInstrument = class { + _writableMetricStorage; + _descriptor; + constructor(writableMetricStorage, descriptor) { + this._writableMetricStorage = writableMetricStorage; + this._descriptor = descriptor; + } + _record(value, attributes = {}, context2) { + if (typeof value !== "number") { + api_1.diag.warn(`non-number value provided to metric ${this._descriptor.name}: ${value}`); + return; + } + if (this._descriptor.valueType === api_1.ValueType.INT && !Number.isInteger(value)) { + api_1.diag.warn(`INT value type cannot accept a floating-point value for ${this._descriptor.name}, ignoring the fractional digits.`); + value = Math.trunc(value); + if (!Number.isInteger(value)) { + return; + } + } + this._writableMetricStorage.record(value, attributes, context2, Date.now()); + } + }; + exports.SyncInstrument = SyncInstrument; + var UpDownCounterInstrument = class extends SyncInstrument { + /** + * Increment value of counter by the input. Inputs may be negative. + */ + add(value, attributes, ctx) { + this._record(value, attributes, ctx); + } + }; + exports.UpDownCounterInstrument = UpDownCounterInstrument; + var CounterInstrument = class extends SyncInstrument { + /** + * Increment value of counter by the input. Inputs may not be negative. + */ + add(value, attributes, ctx) { + if (value < 0) { + api_1.diag.warn(`negative value provided to counter ${this._descriptor.name}: ${value}`); + return; + } + this._record(value, attributes, ctx); + } + }; + exports.CounterInstrument = CounterInstrument; + var GaugeInstrument = class extends SyncInstrument { + /** + * Records a measurement. + */ + record(value, attributes, ctx) { + this._record(value, attributes, ctx); + } + }; + exports.GaugeInstrument = GaugeInstrument; + var HistogramInstrument = class extends SyncInstrument { + /** + * Records a measurement. Value of the measurement must not be negative. + */ + record(value, attributes, ctx) { + if (value < 0) { + api_1.diag.warn(`negative value provided to histogram ${this._descriptor.name}: ${value}`); + return; + } + this._record(value, attributes, ctx); + } + }; + exports.HistogramInstrument = HistogramInstrument; + var ObservableInstrument = class { + /** @internal */ + _metricStorages; + /** @internal */ + _descriptor; + _observableRegistry; + constructor(descriptor, metricStorages, observableRegistry) { + this._descriptor = descriptor; + this._metricStorages = metricStorages; + this._observableRegistry = observableRegistry; + } + /** + * @see {Observable.addCallback} + */ + addCallback(callback) { + this._observableRegistry.addCallback(callback, this); + } + /** + * @see {Observable.removeCallback} + */ + removeCallback(callback) { + this._observableRegistry.removeCallback(callback, this); + } + }; + exports.ObservableInstrument = ObservableInstrument; + var ObservableCounterInstrument = class extends ObservableInstrument { + }; + exports.ObservableCounterInstrument = ObservableCounterInstrument; + var ObservableGaugeInstrument = class extends ObservableInstrument { + }; + exports.ObservableGaugeInstrument = ObservableGaugeInstrument; + var ObservableUpDownCounterInstrument = class extends ObservableInstrument { + }; + exports.ObservableUpDownCounterInstrument = ObservableUpDownCounterInstrument; + function isObservableInstrument(it) { + return it instanceof ObservableInstrument; + } + exports.isObservableInstrument = isObservableInstrument; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/Meter.js +var require_Meter = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/Meter.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Meter = void 0; + var InstrumentDescriptor_1 = require_InstrumentDescriptor(); + var Instruments_1 = require_Instruments(); + var MetricData_1 = require_MetricData(); + var Meter = class { + _meterSharedState; + constructor(meterSharedState) { + this._meterSharedState = meterSharedState; + } + /** + * Create a {@link Gauge} instrument. + */ + createGauge(name, options) { + const descriptor = (0, InstrumentDescriptor_1.createInstrumentDescriptor)(name, MetricData_1.InstrumentType.GAUGE, options); + const storage = this._meterSharedState.registerMetricStorage(descriptor); + return new Instruments_1.GaugeInstrument(storage, descriptor); + } + /** + * Create a {@link Histogram} instrument. + */ + createHistogram(name, options) { + const descriptor = (0, InstrumentDescriptor_1.createInstrumentDescriptor)(name, MetricData_1.InstrumentType.HISTOGRAM, options); + const storage = this._meterSharedState.registerMetricStorage(descriptor); + return new Instruments_1.HistogramInstrument(storage, descriptor); + } + /** + * Create a {@link Counter} instrument. + */ + createCounter(name, options) { + const descriptor = (0, InstrumentDescriptor_1.createInstrumentDescriptor)(name, MetricData_1.InstrumentType.COUNTER, options); + const storage = this._meterSharedState.registerMetricStorage(descriptor); + return new Instruments_1.CounterInstrument(storage, descriptor); + } + /** + * Create a {@link UpDownCounter} instrument. + */ + createUpDownCounter(name, options) { + const descriptor = (0, InstrumentDescriptor_1.createInstrumentDescriptor)(name, MetricData_1.InstrumentType.UP_DOWN_COUNTER, options); + const storage = this._meterSharedState.registerMetricStorage(descriptor); + return new Instruments_1.UpDownCounterInstrument(storage, descriptor); + } + /** + * Create a {@link ObservableGauge} instrument. + */ + createObservableGauge(name, options) { + const descriptor = (0, InstrumentDescriptor_1.createInstrumentDescriptor)(name, MetricData_1.InstrumentType.OBSERVABLE_GAUGE, options); + const storages = this._meterSharedState.registerAsyncMetricStorage(descriptor); + return new Instruments_1.ObservableGaugeInstrument(descriptor, storages, this._meterSharedState.observableRegistry); + } + /** + * Create a {@link ObservableCounter} instrument. + */ + createObservableCounter(name, options) { + const descriptor = (0, InstrumentDescriptor_1.createInstrumentDescriptor)(name, MetricData_1.InstrumentType.OBSERVABLE_COUNTER, options); + const storages = this._meterSharedState.registerAsyncMetricStorage(descriptor); + return new Instruments_1.ObservableCounterInstrument(descriptor, storages, this._meterSharedState.observableRegistry); + } + /** + * Create a {@link ObservableUpDownCounter} instrument. + */ + createObservableUpDownCounter(name, options) { + const descriptor = (0, InstrumentDescriptor_1.createInstrumentDescriptor)(name, MetricData_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER, options); + const storages = this._meterSharedState.registerAsyncMetricStorage(descriptor); + return new Instruments_1.ObservableUpDownCounterInstrument(descriptor, storages, this._meterSharedState.observableRegistry); + } + /** + * @see {@link Meter.addBatchObservableCallback} + */ + addBatchObservableCallback(callback, observables) { + this._meterSharedState.observableRegistry.addBatchCallback(callback, observables); + } + /** + * @see {@link Meter.removeBatchObservableCallback} + */ + removeBatchObservableCallback(callback, observables) { + this._meterSharedState.observableRegistry.removeBatchCallback(callback, observables); + } + }; + exports.Meter = Meter; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/state/MetricStorage.js +var require_MetricStorage = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/state/MetricStorage.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MetricStorage = void 0; + var InstrumentDescriptor_1 = require_InstrumentDescriptor(); + var MetricStorage = class { + _instrumentDescriptor; + constructor(instrumentDescriptor) { + this._instrumentDescriptor = instrumentDescriptor; + } + getInstrumentDescriptor() { + return this._instrumentDescriptor; + } + updateDescription(description) { + this._instrumentDescriptor = (0, InstrumentDescriptor_1.createInstrumentDescriptor)(this._instrumentDescriptor.name, this._instrumentDescriptor.type, { + description, + valueType: this._instrumentDescriptor.valueType, + unit: this._instrumentDescriptor.unit, + advice: this._instrumentDescriptor.advice + }); + } + }; + exports.MetricStorage = MetricStorage; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/state/HashMap.js +var require_HashMap = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/state/HashMap.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.AttributeHashMap = exports.HashMap = void 0; + var utils_1 = require_utils3(); + var HashMap = class { + _valueMap = /* @__PURE__ */ new Map(); + _keyMap = /* @__PURE__ */ new Map(); + _hash; + constructor(hash) { + this._hash = hash; + } + get(key, hashCode) { + hashCode ??= this._hash(key); + return this._valueMap.get(hashCode); + } + getOrDefault(key, defaultFactory) { + const hash = this._hash(key); + if (this._valueMap.has(hash)) { + return this._valueMap.get(hash); + } + const val = defaultFactory(); + if (!this._keyMap.has(hash)) { + this._keyMap.set(hash, key); + } + this._valueMap.set(hash, val); + return val; + } + set(key, value, hashCode) { + hashCode ??= this._hash(key); + if (!this._keyMap.has(hashCode)) { + this._keyMap.set(hashCode, key); + } + this._valueMap.set(hashCode, value); + } + has(key, hashCode) { + hashCode ??= this._hash(key); + return this._valueMap.has(hashCode); + } + *keys() { + const keyIterator = this._keyMap.entries(); + let next = keyIterator.next(); + while (next.done !== true) { + yield [next.value[1], next.value[0]]; + next = keyIterator.next(); + } + } + *entries() { + const valueIterator = this._valueMap.entries(); + let next = valueIterator.next(); + while (next.done !== true) { + yield [this._keyMap.get(next.value[0]), next.value[1], next.value[0]]; + next = valueIterator.next(); + } + } + get size() { + return this._valueMap.size; + } + }; + exports.HashMap = HashMap; + var AttributeHashMap = class extends HashMap { + constructor() { + super(utils_1.hashAttributes); + } + }; + exports.AttributeHashMap = AttributeHashMap; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/state/DeltaMetricProcessor.js +var require_DeltaMetricProcessor = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/state/DeltaMetricProcessor.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.DeltaMetricProcessor = void 0; + var core_1 = require_src(); + var utils_1 = require_utils3(); + var HashMap_1 = require_HashMap(); + var DeltaMetricProcessor = class { + _activeCollectionStorage = new HashMap_1.AttributeHashMap(); + // TODO: find a reasonable mean to clean the memo; + // https://github.com/open-telemetry/opentelemetry-specification/pull/2208 + _cumulativeMemoStorage = new HashMap_1.AttributeHashMap(); + _cardinalityLimit; + _overflowAttributes = { "otel.metric.overflow": true }; + _overflowHashCode; + _aggregator; + constructor(aggregator, aggregationCardinalityLimit) { + this._aggregator = aggregator; + this._cardinalityLimit = (aggregationCardinalityLimit ?? 2e3) - 1; + this._overflowHashCode = (0, utils_1.hashAttributes)(this._overflowAttributes); + } + record(value, attributes, collectionTime) { + let accumulation = this._activeCollectionStorage.get(attributes); + if (!accumulation) { + const hrTime2 = (0, core_1.millisToHrTime)(collectionTime); + if (this._activeCollectionStorage.size >= this._cardinalityLimit) { + const overflowAccumulation = this._activeCollectionStorage.getOrDefault(this._overflowAttributes, () => this._aggregator.createAccumulation(hrTime2)); + overflowAccumulation?.record(value); + return; + } + accumulation = this._aggregator.createAccumulation(hrTime2); + this._activeCollectionStorage.set(attributes, accumulation); + } + accumulation?.record(value); + } + batchCumulate(measurements, collectionTime) { + for (const [originalAttributes, value, originalHashCode] of measurements.entries()) { + let attributes = originalAttributes; + let hashCode = originalHashCode; + const accumulation = this._aggregator.createAccumulation(collectionTime); + accumulation?.record(value); + let delta = accumulation; + if (this._cumulativeMemoStorage.has(attributes, hashCode)) { + const previous = this._cumulativeMemoStorage.get(attributes, hashCode); + delta = this._aggregator.diff(previous, accumulation); + } else { + if (this._cumulativeMemoStorage.size >= this._cardinalityLimit) { + attributes = this._overflowAttributes; + hashCode = this._overflowHashCode; + if (this._cumulativeMemoStorage.has(attributes, hashCode)) { + const previous = this._cumulativeMemoStorage.get(attributes, hashCode); + delta = this._aggregator.diff(previous, accumulation); + } + } + } + if (this._activeCollectionStorage.has(attributes, hashCode)) { + const active = this._activeCollectionStorage.get(attributes, hashCode); + delta = this._aggregator.merge(active, delta); + } + this._cumulativeMemoStorage.set(attributes, accumulation, hashCode); + this._activeCollectionStorage.set(attributes, delta, hashCode); + } + } + /** + * Returns a collection of delta metrics. Start time is the when first + * time event collected. + */ + collect() { + const unreportedDelta = this._activeCollectionStorage; + this._activeCollectionStorage = new HashMap_1.AttributeHashMap(); + return unreportedDelta; + } + }; + exports.DeltaMetricProcessor = DeltaMetricProcessor; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/state/TemporalMetricProcessor.js +var require_TemporalMetricProcessor = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/state/TemporalMetricProcessor.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.TemporalMetricProcessor = void 0; + var AggregationTemporality_1 = require_AggregationTemporality(); + var HashMap_1 = require_HashMap(); + var TemporalMetricProcessor = class _TemporalMetricProcessor { + _aggregator; + _unreportedAccumulations = /* @__PURE__ */ new Map(); + _reportHistory = /* @__PURE__ */ new Map(); + constructor(aggregator, collectorHandles) { + this._aggregator = aggregator; + collectorHandles.forEach((handle) => { + this._unreportedAccumulations.set(handle, []); + }); + } + /** + * Builds the {@link MetricData} streams to report against a specific MetricCollector. + * @param collector The information of the MetricCollector. + * @param collectors The registered collectors. + * @param instrumentDescriptor The instrumentation descriptor that these metrics generated with. + * @param currentAccumulations The current accumulation of metric data from instruments. + * @param collectionTime The current collection timestamp. + * @returns The {@link MetricData} points or `null`. + */ + buildMetrics(collector, instrumentDescriptor, currentAccumulations, collectionTime) { + this._stashAccumulations(currentAccumulations); + const unreportedAccumulations = this._getMergedUnreportedAccumulations(collector); + let result = unreportedAccumulations; + let aggregationTemporality; + if (this._reportHistory.has(collector)) { + const last = this._reportHistory.get(collector); + const lastCollectionTime = last.collectionTime; + aggregationTemporality = last.aggregationTemporality; + if (aggregationTemporality === AggregationTemporality_1.AggregationTemporality.CUMULATIVE) { + result = _TemporalMetricProcessor.merge(last.accumulations, unreportedAccumulations, this._aggregator); + } else { + result = _TemporalMetricProcessor.calibrateStartTime(last.accumulations, unreportedAccumulations, lastCollectionTime); + } + } else { + aggregationTemporality = collector.selectAggregationTemporality(instrumentDescriptor.type); + } + this._reportHistory.set(collector, { + accumulations: result, + collectionTime, + aggregationTemporality + }); + const accumulationRecords = AttributesMapToAccumulationRecords(result); + if (accumulationRecords.length === 0) { + return void 0; + } + return this._aggregator.toMetricData( + instrumentDescriptor, + aggregationTemporality, + accumulationRecords, + /* endTime */ + collectionTime + ); + } + _stashAccumulations(currentAccumulation) { + const registeredCollectors = this._unreportedAccumulations.keys(); + for (const collector of registeredCollectors) { + let stash = this._unreportedAccumulations.get(collector); + if (stash === void 0) { + stash = []; + this._unreportedAccumulations.set(collector, stash); + } + stash.push(currentAccumulation); + } + } + _getMergedUnreportedAccumulations(collector) { + let result = new HashMap_1.AttributeHashMap(); + const unreportedList = this._unreportedAccumulations.get(collector); + this._unreportedAccumulations.set(collector, []); + if (unreportedList === void 0) { + return result; + } + for (const it of unreportedList) { + result = _TemporalMetricProcessor.merge(result, it, this._aggregator); + } + return result; + } + static merge(last, current, aggregator) { + const result = last; + const iterator = current.entries(); + let next = iterator.next(); + while (next.done !== true) { + const [key, record, hash] = next.value; + if (last.has(key, hash)) { + const lastAccumulation = last.get(key, hash); + const accumulation = aggregator.merge(lastAccumulation, record); + result.set(key, accumulation, hash); + } else { + result.set(key, record, hash); + } + next = iterator.next(); + } + return result; + } + /** + * Calibrate the reported metric streams' startTime to lastCollectionTime. Leaves + * the new stream to be the initial observation time unchanged. + */ + static calibrateStartTime(last, current, lastCollectionTime) { + for (const [key, hash] of last.keys()) { + const currentAccumulation = current.get(key, hash); + currentAccumulation?.setStartTime(lastCollectionTime); + } + return current; + } + }; + exports.TemporalMetricProcessor = TemporalMetricProcessor; + function AttributesMapToAccumulationRecords(map) { + return Array.from(map.entries()); + } + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/state/AsyncMetricStorage.js +var require_AsyncMetricStorage = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/state/AsyncMetricStorage.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.AsyncMetricStorage = void 0; + var MetricStorage_1 = require_MetricStorage(); + var DeltaMetricProcessor_1 = require_DeltaMetricProcessor(); + var TemporalMetricProcessor_1 = require_TemporalMetricProcessor(); + var HashMap_1 = require_HashMap(); + var AsyncMetricStorage = class extends MetricStorage_1.MetricStorage { + _aggregationCardinalityLimit; + _deltaMetricStorage; + _temporalMetricStorage; + _attributesProcessor; + constructor(_instrumentDescriptor, aggregator, attributesProcessor, collectorHandles, aggregationCardinalityLimit) { + super(_instrumentDescriptor); + this._aggregationCardinalityLimit = aggregationCardinalityLimit; + this._deltaMetricStorage = new DeltaMetricProcessor_1.DeltaMetricProcessor(aggregator, this._aggregationCardinalityLimit); + this._temporalMetricStorage = new TemporalMetricProcessor_1.TemporalMetricProcessor(aggregator, collectorHandles); + this._attributesProcessor = attributesProcessor; + } + record(measurements, observationTime) { + if (this._attributesProcessor === void 0) { + this._deltaMetricStorage.batchCumulate(measurements, observationTime); + return; + } + const processed = new HashMap_1.AttributeHashMap(); + for (const [attributes, value] of measurements.entries()) { + processed.set(this._attributesProcessor.process(attributes), value); + } + this._deltaMetricStorage.batchCumulate(processed, observationTime); + } + /** + * Collects the metrics from this storage. The ObservableCallback is invoked + * during the collection. + * + * Note: This is a stateful operation and may reset any interval-related + * state for the MetricCollector. + */ + collect(collector, collectionTime) { + const accumulations = this._deltaMetricStorage.collect(); + return this._temporalMetricStorage.buildMetrics(collector, this._instrumentDescriptor, accumulations, collectionTime); + } + }; + exports.AsyncMetricStorage = AsyncMetricStorage; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/view/RegistrationConflicts.js +var require_RegistrationConflicts = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/view/RegistrationConflicts.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getConflictResolutionRecipe = exports.getDescriptionResolutionRecipe = exports.getTypeConflictResolutionRecipe = exports.getUnitConflictResolutionRecipe = exports.getValueTypeConflictResolutionRecipe = exports.getIncompatibilityDetails = void 0; + function getIncompatibilityDetails(existing, otherDescriptor) { + let incompatibility = ""; + if (existing.unit !== otherDescriptor.unit) { + incompatibility += ` - Unit '${existing.unit}' does not match '${otherDescriptor.unit}' +`; + } + if (existing.type !== otherDescriptor.type) { + incompatibility += ` - Type '${existing.type}' does not match '${otherDescriptor.type}' +`; + } + if (existing.valueType !== otherDescriptor.valueType) { + incompatibility += ` - Value Type '${existing.valueType}' does not match '${otherDescriptor.valueType}' +`; + } + if (existing.description !== otherDescriptor.description) { + incompatibility += ` - Description '${existing.description}' does not match '${otherDescriptor.description}' +`; + } + return incompatibility; + } + exports.getIncompatibilityDetails = getIncompatibilityDetails; + function getValueTypeConflictResolutionRecipe(existing, otherDescriptor) { + return ` - use valueType '${existing.valueType}' on instrument creation or use an instrument name other than '${otherDescriptor.name}'`; + } + exports.getValueTypeConflictResolutionRecipe = getValueTypeConflictResolutionRecipe; + function getUnitConflictResolutionRecipe(existing, otherDescriptor) { + return ` - use unit '${existing.unit}' on instrument creation or use an instrument name other than '${otherDescriptor.name}'`; + } + exports.getUnitConflictResolutionRecipe = getUnitConflictResolutionRecipe; + function getTypeConflictResolutionRecipe(existing, otherDescriptor) { + const selector = { + name: otherDescriptor.name, + type: otherDescriptor.type, + unit: otherDescriptor.unit + }; + const selectorString = JSON.stringify(selector); + return ` - create a new view with a name other than '${existing.name}' and InstrumentSelector '${selectorString}'`; + } + exports.getTypeConflictResolutionRecipe = getTypeConflictResolutionRecipe; + function getDescriptionResolutionRecipe(existing, otherDescriptor) { + const selector = { + name: otherDescriptor.name, + type: otherDescriptor.type, + unit: otherDescriptor.unit + }; + const selectorString = JSON.stringify(selector); + return ` - create a new view with a name other than '${existing.name}' and InstrumentSelector '${selectorString}' + - OR - create a new view with the name ${existing.name} and description '${existing.description}' and InstrumentSelector ${selectorString} + - OR - create a new view with the name ${otherDescriptor.name} and description '${existing.description}' and InstrumentSelector ${selectorString}`; + } + exports.getDescriptionResolutionRecipe = getDescriptionResolutionRecipe; + function getConflictResolutionRecipe(existing, otherDescriptor) { + if (existing.valueType !== otherDescriptor.valueType) { + return getValueTypeConflictResolutionRecipe(existing, otherDescriptor); + } + if (existing.unit !== otherDescriptor.unit) { + return getUnitConflictResolutionRecipe(existing, otherDescriptor); + } + if (existing.type !== otherDescriptor.type) { + return getTypeConflictResolutionRecipe(existing, otherDescriptor); + } + if (existing.description !== otherDescriptor.description) { + return getDescriptionResolutionRecipe(existing, otherDescriptor); + } + return ""; + } + exports.getConflictResolutionRecipe = getConflictResolutionRecipe; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/state/MetricStorageRegistry.js +var require_MetricStorageRegistry = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/state/MetricStorageRegistry.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MetricStorageRegistry = void 0; + var InstrumentDescriptor_1 = require_InstrumentDescriptor(); + var api = (init_esm(), __toCommonJS(esm_exports)); + var RegistrationConflicts_1 = require_RegistrationConflicts(); + var MetricStorageRegistry = class _MetricStorageRegistry { + _sharedRegistry = /* @__PURE__ */ new Map(); + _perCollectorRegistry = /* @__PURE__ */ new Map(); + static create() { + return new _MetricStorageRegistry(); + } + getStorages(collector) { + let storages = []; + for (const metricStorages of this._sharedRegistry.values()) { + storages = storages.concat(metricStorages); + } + const perCollectorStorages = this._perCollectorRegistry.get(collector); + if (perCollectorStorages != null) { + for (const metricStorages of perCollectorStorages.values()) { + storages = storages.concat(metricStorages); + } + } + return storages; + } + register(storage) { + this._registerStorage(storage, this._sharedRegistry); + } + registerForCollector(collector, storage) { + let storageMap = this._perCollectorRegistry.get(collector); + if (storageMap == null) { + storageMap = /* @__PURE__ */ new Map(); + this._perCollectorRegistry.set(collector, storageMap); + } + this._registerStorage(storage, storageMap); + } + findOrUpdateCompatibleStorage(expectedDescriptor) { + const storages = this._sharedRegistry.get(expectedDescriptor.name); + if (storages === void 0) { + return null; + } + return this._findOrUpdateCompatibleStorage(expectedDescriptor, storages); + } + findOrUpdateCompatibleCollectorStorage(collector, expectedDescriptor) { + const storageMap = this._perCollectorRegistry.get(collector); + if (storageMap === void 0) { + return null; + } + const storages = storageMap.get(expectedDescriptor.name); + if (storages === void 0) { + return null; + } + return this._findOrUpdateCompatibleStorage(expectedDescriptor, storages); + } + _registerStorage(storage, storageMap) { + const descriptor = storage.getInstrumentDescriptor(); + const storages = storageMap.get(descriptor.name); + if (storages === void 0) { + storageMap.set(descriptor.name, [storage]); + return; + } + storages.push(storage); + } + _findOrUpdateCompatibleStorage(expectedDescriptor, existingStorages) { + let compatibleStorage = null; + for (const existingStorage of existingStorages) { + const existingDescriptor = existingStorage.getInstrumentDescriptor(); + if ((0, InstrumentDescriptor_1.isDescriptorCompatibleWith)(existingDescriptor, expectedDescriptor)) { + if (existingDescriptor.description !== expectedDescriptor.description) { + if (expectedDescriptor.description.length > existingDescriptor.description.length) { + existingStorage.updateDescription(expectedDescriptor.description); + } + api.diag.warn("A view or instrument with the name ", expectedDescriptor.name, " has already been registered, but has a different description and is incompatible with another registered view.\n", "Details:\n", (0, RegistrationConflicts_1.getIncompatibilityDetails)(existingDescriptor, expectedDescriptor), "The longer description will be used.\nTo resolve the conflict:", (0, RegistrationConflicts_1.getConflictResolutionRecipe)(existingDescriptor, expectedDescriptor)); + } + compatibleStorage = existingStorage; + } else { + api.diag.warn("A view or instrument with the name ", expectedDescriptor.name, " has already been registered and is incompatible with another registered view.\n", "Details:\n", (0, RegistrationConflicts_1.getIncompatibilityDetails)(existingDescriptor, expectedDescriptor), "To resolve the conflict:\n", (0, RegistrationConflicts_1.getConflictResolutionRecipe)(existingDescriptor, expectedDescriptor)); + } + } + return compatibleStorage; + } + }; + exports.MetricStorageRegistry = MetricStorageRegistry; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/state/MultiWritableMetricStorage.js +var require_MultiWritableMetricStorage = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/state/MultiWritableMetricStorage.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MultiMetricStorage = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var MultiMetricStorage = class { + _backingStorages; + hasAttributeProcessor; + constructor(backingStorages) { + this._backingStorages = backingStorages; + this.hasAttributeProcessor = backingStorages.some((s) => s.hasAttributeProcessor); + } + record(value, attributes, context2, recordTime) { + if (this.hasAttributeProcessor && context2 === void 0) { + context2 = api_1.context.active(); + } + const storages = this._backingStorages; + for (let i = 0; i < storages.length; i++) { + storages[i].record(value, attributes, context2, recordTime); + } + } + }; + exports.MultiMetricStorage = MultiMetricStorage; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/ObservableResult.js +var require_ObservableResult = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/ObservableResult.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.BatchObservableResultImpl = exports.ObservableResultImpl = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var HashMap_1 = require_HashMap(); + var Instruments_1 = require_Instruments(); + var ObservableResultImpl = class { + /** + * @internal + */ + _buffer = new HashMap_1.AttributeHashMap(); + _instrumentName; + _valueType; + constructor(instrumentName, valueType) { + this._instrumentName = instrumentName; + this._valueType = valueType; + } + /** + * Observe a measurement of the value associated with the given attributes. + */ + observe(value, attributes = {}) { + if (typeof value !== "number") { + api_1.diag.warn(`non-number value provided to metric ${this._instrumentName}: ${value}`); + return; + } + if (this._valueType === api_1.ValueType.INT && !Number.isInteger(value)) { + api_1.diag.warn(`INT value type cannot accept a floating-point value for ${this._instrumentName}, ignoring the fractional digits.`); + value = Math.trunc(value); + if (!Number.isInteger(value)) { + return; + } + } + this._buffer.set(attributes, value); + } + }; + exports.ObservableResultImpl = ObservableResultImpl; + var BatchObservableResultImpl = class { + /** + * @internal + */ + _buffer = /* @__PURE__ */ new Map(); + /** + * Observe a measurement of the value associated with the given attributes. + */ + observe(metric, value, attributes = {}) { + if (!(0, Instruments_1.isObservableInstrument)(metric)) { + return; + } + let map = this._buffer.get(metric); + if (map == null) { + map = new HashMap_1.AttributeHashMap(); + this._buffer.set(metric, map); + } + if (typeof value !== "number") { + api_1.diag.warn(`non-number value provided to metric ${metric._descriptor.name}: ${value}`); + return; + } + if (metric._descriptor.valueType === api_1.ValueType.INT && !Number.isInteger(value)) { + api_1.diag.warn(`INT value type cannot accept a floating-point value for ${metric._descriptor.name}, ignoring the fractional digits.`); + value = Math.trunc(value); + if (!Number.isInteger(value)) { + return; + } + } + map.set(attributes, value); + } + }; + exports.BatchObservableResultImpl = BatchObservableResultImpl; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/state/ObservableRegistry.js +var require_ObservableRegistry = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/state/ObservableRegistry.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ObservableRegistry = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var Instruments_1 = require_Instruments(); + var ObservableResult_1 = require_ObservableResult(); + var utils_1 = require_utils3(); + var ObservableRegistry = class { + _callbacks = []; + _batchCallbacks = []; + addCallback(callback, instrument) { + const idx = this._findCallback(callback, instrument); + if (idx >= 0) { + return; + } + this._callbacks.push({ callback, instrument }); + } + removeCallback(callback, instrument) { + const idx = this._findCallback(callback, instrument); + if (idx < 0) { + return; + } + this._callbacks.splice(idx, 1); + } + addBatchCallback(callback, instruments) { + const observableInstruments = new Set(instruments.filter(Instruments_1.isObservableInstrument)); + if (observableInstruments.size === 0) { + api_1.diag.error("BatchObservableCallback is not associated with valid instruments", instruments); + return; + } + const idx = this._findBatchCallback(callback, observableInstruments); + if (idx >= 0) { + return; + } + this._batchCallbacks.push({ callback, instruments: observableInstruments }); + } + removeBatchCallback(callback, instruments) { + const observableInstruments = new Set(instruments.filter(Instruments_1.isObservableInstrument)); + const idx = this._findBatchCallback(callback, observableInstruments); + if (idx < 0) { + return; + } + this._batchCallbacks.splice(idx, 1); + } + /** + * @returns a promise of rejected reasons for invoking callbacks. + */ + async observe(collectionTime, timeoutMillis) { + const callbackFutures = this._observeCallbacks(collectionTime, timeoutMillis); + const batchCallbackFutures = this._observeBatchCallbacks(collectionTime, timeoutMillis); + const results = await Promise.allSettled([ + ...callbackFutures, + ...batchCallbackFutures + ]); + const rejections = results.filter((result) => result.status === "rejected").map((result) => result.reason); + return rejections; + } + _observeCallbacks(observationTime, timeoutMillis) { + return this._callbacks.map(async ({ callback, instrument }) => { + const observableResult = new ObservableResult_1.ObservableResultImpl(instrument._descriptor.name, instrument._descriptor.valueType); + let callPromise = Promise.resolve(callback(observableResult)); + if (timeoutMillis != null) { + callPromise = (0, utils_1.callWithTimeout)(callPromise, timeoutMillis); + } + await callPromise; + instrument._metricStorages.forEach((metricStorage) => { + metricStorage.record(observableResult._buffer, observationTime); + }); + }); + } + _observeBatchCallbacks(observationTime, timeoutMillis) { + return this._batchCallbacks.map(async ({ callback, instruments }) => { + const observableResult = new ObservableResult_1.BatchObservableResultImpl(); + let callPromise = Promise.resolve(callback(observableResult)); + if (timeoutMillis != null) { + callPromise = (0, utils_1.callWithTimeout)(callPromise, timeoutMillis); + } + await callPromise; + instruments.forEach((instrument) => { + const buffer = observableResult._buffer.get(instrument); + if (buffer == null) { + return; + } + instrument._metricStorages.forEach((metricStorage) => { + metricStorage.record(buffer, observationTime); + }); + }); + }); + } + _findCallback(callback, instrument) { + return this._callbacks.findIndex((record) => { + return record.callback === callback && record.instrument === instrument; + }); + } + _findBatchCallback(callback, instruments) { + return this._batchCallbacks.findIndex((record) => { + return record.callback === callback && (0, utils_1.setEquals)(record.instruments, instruments); + }); + } + }; + exports.ObservableRegistry = ObservableRegistry; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/state/SyncMetricStorage.js +var require_SyncMetricStorage = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/state/SyncMetricStorage.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SyncMetricStorage = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var MetricStorage_1 = require_MetricStorage(); + var DeltaMetricProcessor_1 = require_DeltaMetricProcessor(); + var TemporalMetricProcessor_1 = require_TemporalMetricProcessor(); + var SyncMetricStorage = class extends MetricStorage_1.MetricStorage { + _aggregationCardinalityLimit; + _deltaMetricStorage; + _temporalMetricStorage; + _attributesProcessor; + constructor(instrumentDescriptor, aggregator, attributesProcessor, collectorHandles, aggregationCardinalityLimit) { + super(instrumentDescriptor); + this._aggregationCardinalityLimit = aggregationCardinalityLimit; + this._deltaMetricStorage = new DeltaMetricProcessor_1.DeltaMetricProcessor(aggregator, this._aggregationCardinalityLimit); + this._temporalMetricStorage = new TemporalMetricProcessor_1.TemporalMetricProcessor(aggregator, collectorHandles); + this._attributesProcessor = attributesProcessor; + this.hasAttributeProcessor = attributesProcessor !== void 0; + } + hasAttributeProcessor; + record(value, attributes, context2, recordTime) { + if (this._attributesProcessor !== void 0) { + attributes = this._attributesProcessor.process(attributes, context2 ?? api_1.context.active()); + } + this._deltaMetricStorage.record(value, attributes, recordTime); + } + /** + * Collects the metrics from this storage. + * + * Note: This is a stateful operation and may reset any interval-related + * state for the MetricCollector. + */ + collect(collector, collectionTime) { + const accumulations = this._deltaMetricStorage.collect(); + return this._temporalMetricStorage.buildMetrics(collector, this._instrumentDescriptor, accumulations, collectionTime); + } + }; + exports.SyncMetricStorage = SyncMetricStorage; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/state/MeterSharedState.js +var require_MeterSharedState = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/state/MeterSharedState.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MeterSharedState = void 0; + var InstrumentDescriptor_1 = require_InstrumentDescriptor(); + var Meter_1 = require_Meter(); + var AsyncMetricStorage_1 = require_AsyncMetricStorage(); + var MetricStorageRegistry_1 = require_MetricStorageRegistry(); + var MultiWritableMetricStorage_1 = require_MultiWritableMetricStorage(); + var ObservableRegistry_1 = require_ObservableRegistry(); + var SyncMetricStorage_1 = require_SyncMetricStorage(); + var MeterSharedState = class { + metricStorageRegistry = new MetricStorageRegistry_1.MetricStorageRegistry(); + observableRegistry = new ObservableRegistry_1.ObservableRegistry(); + meter; + _meterProviderSharedState; + _instrumentationScope; + constructor(meterProviderSharedState, instrumentationScope) { + this.meter = new Meter_1.Meter(this); + this._meterProviderSharedState = meterProviderSharedState; + this._instrumentationScope = instrumentationScope; + } + registerMetricStorage(descriptor) { + const storages = this._registerMetricStorage(descriptor, SyncMetricStorage_1.SyncMetricStorage); + if (storages.length === 1) { + return storages[0]; + } + return new MultiWritableMetricStorage_1.MultiMetricStorage(storages); + } + registerAsyncMetricStorage(descriptor) { + const storages = this._registerMetricStorage(descriptor, AsyncMetricStorage_1.AsyncMetricStorage); + return storages; + } + /** + * @param collector opaque handle of {@link MetricCollector} which initiated the collection. + * @param collectionTime the HrTime at which the collection was initiated. + * @param options options for collection. + * @returns the list of metric data collected. + */ + async collect(collector, collectionTime, options) { + const errors = await this.observableRegistry.observe(collectionTime, options?.timeoutMillis); + const storages = this.metricStorageRegistry.getStorages(collector); + if (storages.length === 0) { + return null; + } + const metricDataList = []; + storages.forEach((metricStorage) => { + const metricData = metricStorage.collect(collector, collectionTime); + if (metricData != null) { + metricDataList.push(metricData); + } + }); + if (metricDataList.length === 0) { + return { errors }; + } + return { + scopeMetrics: { + scope: this._instrumentationScope, + metrics: metricDataList + }, + errors + }; + } + _registerMetricStorage(descriptor, MetricStorageType) { + const views = this._meterProviderSharedState.viewRegistry.findViews(descriptor, this._instrumentationScope); + let storages = views.map((view) => { + const viewDescriptor = (0, InstrumentDescriptor_1.createInstrumentDescriptorWithView)(view, descriptor); + const compatibleStorage = this.metricStorageRegistry.findOrUpdateCompatibleStorage(viewDescriptor); + if (compatibleStorage != null) { + return compatibleStorage; + } + const aggregator = view.aggregation.createAggregator(viewDescriptor); + const viewStorage = new MetricStorageType(viewDescriptor, aggregator, view.attributesProcessor, this._meterProviderSharedState.metricCollectors, view.aggregationCardinalityLimit); + this.metricStorageRegistry.register(viewStorage); + return viewStorage; + }); + if (storages.length === 0) { + const perCollectorAggregations = this._meterProviderSharedState.selectAggregations(descriptor.type); + const collectorStorages = perCollectorAggregations.map(([collector, aggregation]) => { + const compatibleStorage = this.metricStorageRegistry.findOrUpdateCompatibleCollectorStorage(collector, descriptor); + if (compatibleStorage != null) { + return compatibleStorage; + } + const aggregator = aggregation.createAggregator(descriptor); + const cardinalityLimit = collector.selectCardinalityLimit(descriptor.type); + const storage = new MetricStorageType(descriptor, aggregator, void 0, [collector], cardinalityLimit); + this.metricStorageRegistry.registerForCollector(collector, storage); + return storage; + }); + storages = storages.concat(collectorStorages); + } + return storages; + } + }; + exports.MeterSharedState = MeterSharedState; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/state/MeterProviderSharedState.js +var require_MeterProviderSharedState = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/state/MeterProviderSharedState.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MeterProviderSharedState = void 0; + var utils_1 = require_utils3(); + var ViewRegistry_1 = require_ViewRegistry(); + var MeterSharedState_1 = require_MeterSharedState(); + var AggregationOption_1 = require_AggregationOption(); + var MeterProviderSharedState = class { + viewRegistry = new ViewRegistry_1.ViewRegistry(); + metricCollectors = []; + meterSharedStates = /* @__PURE__ */ new Map(); + resource; + constructor(resource) { + this.resource = resource; + } + getMeterSharedState(instrumentationScope) { + const id = (0, utils_1.instrumentationScopeId)(instrumentationScope); + let meterSharedState = this.meterSharedStates.get(id); + if (meterSharedState == null) { + meterSharedState = new MeterSharedState_1.MeterSharedState(this, instrumentationScope); + this.meterSharedStates.set(id, meterSharedState); + } + return meterSharedState; + } + selectAggregations(instrumentType) { + const result = []; + for (const collector of this.metricCollectors) { + result.push([ + collector, + (0, AggregationOption_1.toAggregation)(collector.selectAggregation(instrumentType)) + ]); + } + return result; + } + }; + exports.MeterProviderSharedState = MeterProviderSharedState; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/state/MetricCollector.js +var require_MetricCollector = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/state/MetricCollector.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MetricCollector = void 0; + var core_1 = require_src(); + var MetricCollector = class { + _sharedState; + _metricReader; + constructor(sharedState, metricReader) { + this._sharedState = sharedState; + this._metricReader = metricReader; + } + async collect(options) { + const collectionTime = (0, core_1.millisToHrTime)(Date.now()); + const scopeMetrics = []; + const errors = []; + const meterCollectionPromises = Array.from(this._sharedState.meterSharedStates.values()).map(async (meterSharedState) => { + const current = await meterSharedState.collect(this, collectionTime, options); + if (current?.scopeMetrics != null) { + scopeMetrics.push(current.scopeMetrics); + } + if (current?.errors != null) { + errors.push(...current.errors); + } + }); + await Promise.all(meterCollectionPromises); + return { + resourceMetrics: { + resource: this._sharedState.resource, + scopeMetrics + }, + errors + }; + } + /** + * Delegates for MetricReader.forceFlush. + */ + async forceFlush(options) { + await this._metricReader.forceFlush(options); + } + /** + * Delegates for MetricReader.shutdown. + */ + async shutdown(options) { + await this._metricReader.shutdown(options); + } + selectAggregationTemporality(instrumentType) { + return this._metricReader.selectAggregationTemporality(instrumentType); + } + selectAggregation(instrumentType) { + return this._metricReader.selectAggregation(instrumentType); + } + /** + * Select the cardinality limit for the given {@link InstrumentType} for this + * collector. + */ + selectCardinalityLimit(instrumentType) { + return this._metricReader.selectCardinalityLimit?.(instrumentType) ?? 2e3; + } + }; + exports.MetricCollector = MetricCollector; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/view/Predicate.js +var require_Predicate = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/view/Predicate.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ExactPredicate = exports.PatternPredicate = void 0; + var ESCAPE = /[\^$\\.+?()[\]{}|]/g; + var PatternPredicate = class _PatternPredicate { + _matchAll; + _regexp; + constructor(pattern) { + if (pattern === "*") { + this._matchAll = true; + this._regexp = /.*/; + } else { + this._matchAll = false; + this._regexp = new RegExp(_PatternPredicate.escapePattern(pattern)); + } + } + match(str) { + if (this._matchAll) { + return true; + } + return this._regexp.test(str); + } + static escapePattern(pattern) { + return `^${pattern.replace(ESCAPE, "\\$&").replace("*", ".*")}$`; + } + static hasWildcard(pattern) { + return pattern.includes("*"); + } + }; + exports.PatternPredicate = PatternPredicate; + var ExactPredicate = class { + _matchAll; + _pattern; + constructor(pattern) { + this._matchAll = pattern === void 0; + this._pattern = pattern; + } + match(str) { + if (this._matchAll) { + return true; + } + if (str === this._pattern) { + return true; + } + return false; + } + }; + exports.ExactPredicate = ExactPredicate; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/view/AttributesProcessor.js +var require_AttributesProcessor = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/view/AttributesProcessor.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.createDenyListAttributesProcessor = exports.createAllowListAttributesProcessor = exports.createMultiAttributesProcessor = exports.createNoopAttributesProcessor = void 0; + var NoopAttributesProcessor = class { + process(incoming, _context) { + return incoming; + } + }; + var MultiAttributesProcessor = class { + _processors; + constructor(processors) { + this._processors = processors; + } + process(incoming, context2) { + let filteredAttributes = incoming; + for (const processor of this._processors) { + filteredAttributes = processor.process(filteredAttributes, context2); + } + return filteredAttributes; + } + }; + var AllowListProcessor = class { + _allowedAttributeNames; + constructor(allowedAttributeNames) { + this._allowedAttributeNames = new Set(allowedAttributeNames); + } + process(incoming, _context) { + const filteredAttributes = {}; + for (const attributeName in incoming) { + if (Object.prototype.hasOwnProperty.call(incoming, attributeName) && this._allowedAttributeNames.has(attributeName)) { + filteredAttributes[attributeName] = incoming[attributeName]; + } + } + return filteredAttributes; + } + }; + var DenyListProcessor = class { + _deniedAttributeNames; + constructor(deniedAttributeNames) { + this._deniedAttributeNames = new Set(deniedAttributeNames); + } + process(incoming, _context) { + const filteredAttributes = {}; + for (const attributeName in incoming) { + if (Object.prototype.hasOwnProperty.call(incoming, attributeName) && !this._deniedAttributeNames.has(attributeName)) { + filteredAttributes[attributeName] = incoming[attributeName]; + } + } + return filteredAttributes; + } + }; + function createNoopAttributesProcessor() { + return NOOP; + } + exports.createNoopAttributesProcessor = createNoopAttributesProcessor; + function createMultiAttributesProcessor(processors) { + return new MultiAttributesProcessor(processors); + } + exports.createMultiAttributesProcessor = createMultiAttributesProcessor; + function createAllowListAttributesProcessor(attributeAllowList) { + return new AllowListProcessor(attributeAllowList); + } + exports.createAllowListAttributesProcessor = createAllowListAttributesProcessor; + function createDenyListAttributesProcessor(attributeDenyList) { + return new DenyListProcessor(attributeDenyList); + } + exports.createDenyListAttributesProcessor = createDenyListAttributesProcessor; + var NOOP = new NoopAttributesProcessor(); + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/view/InstrumentSelector.js +var require_InstrumentSelector = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/view/InstrumentSelector.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.InstrumentSelector = void 0; + var Predicate_1 = require_Predicate(); + var InstrumentSelector = class { + _nameFilter; + _type; + _unitFilter; + constructor(criteria) { + this._nameFilter = new Predicate_1.PatternPredicate(criteria?.name ?? "*"); + this._type = criteria?.type; + this._unitFilter = new Predicate_1.ExactPredicate(criteria?.unit); + } + getType() { + return this._type; + } + getNameFilter() { + return this._nameFilter; + } + getUnitFilter() { + return this._unitFilter; + } + }; + exports.InstrumentSelector = InstrumentSelector; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/view/MeterSelector.js +var require_MeterSelector = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/view/MeterSelector.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MeterSelector = void 0; + var Predicate_1 = require_Predicate(); + var MeterSelector = class { + _nameFilter; + _versionFilter; + _schemaUrlFilter; + constructor(criteria) { + this._nameFilter = new Predicate_1.ExactPredicate(criteria?.name); + this._versionFilter = new Predicate_1.ExactPredicate(criteria?.version); + this._schemaUrlFilter = new Predicate_1.ExactPredicate(criteria?.schemaUrl); + } + getNameFilter() { + return this._nameFilter; + } + /** + * TODO: semver filter? no spec yet. + */ + getVersionFilter() { + return this._versionFilter; + } + getSchemaUrlFilter() { + return this._schemaUrlFilter; + } + }; + exports.MeterSelector = MeterSelector; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/view/View.js +var require_View = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/view/View.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.View = void 0; + var Predicate_1 = require_Predicate(); + var AttributesProcessor_1 = require_AttributesProcessor(); + var InstrumentSelector_1 = require_InstrumentSelector(); + var MeterSelector_1 = require_MeterSelector(); + var AggregationOption_1 = require_AggregationOption(); + function isSelectorNotProvided(options) { + return options.instrumentName == null && options.instrumentType == null && options.instrumentUnit == null && options.meterName == null && options.meterVersion == null && options.meterSchemaUrl == null; + } + function validateViewOptions(viewOptions) { + if (isSelectorNotProvided(viewOptions)) { + throw new Error("Cannot create view with no selector arguments supplied"); + } + if (viewOptions.name != null && (viewOptions?.instrumentName == null || Predicate_1.PatternPredicate.hasWildcard(viewOptions.instrumentName))) { + throw new Error("Views with a specified name must be declared with an instrument selector that selects at most one instrument per meter."); + } + } + var View = class { + name; + description; + aggregation; + attributesProcessor; + instrumentSelector; + meterSelector; + aggregationCardinalityLimit; + /** + * Create a new {@link View} instance. + * + * Parameters can be categorized as two types: + * Instrument selection criteria: Used to describe the instrument(s) this view will be applied to. + * Will be treated as additive (the Instrument has to meet all the provided criteria to be selected). + * + * Metric stream altering: Alter the metric stream of instruments selected by instrument selection criteria. + * + * @param viewOptions {@link ViewOptions} for altering the metric stream and instrument selection. + * @param viewOptions.name + * Alters the metric stream: + * This will be used as the name of the metrics stream. + * If not provided, the original Instrument name will be used. + * @param viewOptions.description + * Alters the metric stream: + * This will be used as the description of the metrics stream. + * If not provided, the original Instrument description will be used by default. + * @param viewOptions.attributesProcessors + * Alters the metric stream: + * If provided, the attributes will be modified as defined by the added processors. + * If not provided, all attribute keys will be used by default. + * @param viewOptions.aggregationCardinalityLimit + * Alters the metric stream: + * Sets a limit on the number of unique attribute combinations (cardinality) that can be aggregated. + * If not provided, the default limit of 2000 will be used. + * @param viewOptions.aggregation + * Alters the metric stream: + * Alters the {@link Aggregation} of the metric stream. + * @param viewOptions.instrumentName + * Instrument selection criteria: + * Original name of the Instrument(s) with wildcard support. + * @param viewOptions.instrumentType + * Instrument selection criteria: + * The original type of the Instrument(s). + * @param viewOptions.instrumentUnit + * Instrument selection criteria: + * The unit of the Instrument(s). + * @param viewOptions.meterName + * Instrument selection criteria: + * The name of the Meter. No wildcard support, name must match the meter exactly. + * @param viewOptions.meterVersion + * Instrument selection criteria: + * The version of the Meter. No wildcard support, version must match exactly. + * @param viewOptions.meterSchemaUrl + * Instrument selection criteria: + * The schema URL of the Meter. No wildcard support, schema URL must match exactly. + * + * @example + * // Create a view that changes the Instrument 'my.instrument' to use to an + * // ExplicitBucketHistogramAggregation with the boundaries [20, 30, 40] + * new View({ + * aggregation: new ExplicitBucketHistogramAggregation([20, 30, 40]), + * instrumentName: 'my.instrument' + * }) + */ + constructor(viewOptions) { + validateViewOptions(viewOptions); + if (viewOptions.attributesProcessors != null) { + this.attributesProcessor = (0, AttributesProcessor_1.createMultiAttributesProcessor)(viewOptions.attributesProcessors); + } else { + this.attributesProcessor = (0, AttributesProcessor_1.createNoopAttributesProcessor)(); + } + this.name = viewOptions.name; + this.description = viewOptions.description; + this.aggregation = (0, AggregationOption_1.toAggregation)(viewOptions.aggregation ?? { type: AggregationOption_1.AggregationType.DEFAULT }); + this.instrumentSelector = new InstrumentSelector_1.InstrumentSelector({ + name: viewOptions.instrumentName, + type: viewOptions.instrumentType, + unit: viewOptions.instrumentUnit + }); + this.meterSelector = new MeterSelector_1.MeterSelector({ + name: viewOptions.meterName, + version: viewOptions.meterVersion, + schemaUrl: viewOptions.meterSchemaUrl + }); + this.aggregationCardinalityLimit = viewOptions.aggregationCardinalityLimit; + } + }; + exports.View = View; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/MeterProvider.js +var require_MeterProvider = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/MeterProvider.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MeterProvider = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var resources_1 = require_src3(); + var MetricReader_1 = require_MetricReader(); + var MeterProviderSharedState_1 = require_MeterProviderSharedState(); + var MetricCollector_1 = require_MetricCollector(); + var View_1 = require_View(); + var MeterProvider = class { + _sharedState; + _shutdown = false; + constructor(options) { + this._sharedState = new MeterProviderSharedState_1.MeterProviderSharedState(options?.resource ?? (0, resources_1.defaultResource)()); + if (options?.views != null && options.views.length > 0) { + for (const viewOption of options.views) { + this._sharedState.viewRegistry.addView(new View_1.View(viewOption)); + } + } + if (options?.readers != null && options.readers.length > 0) { + for (const metricReader of options.readers) { + const collector = new MetricCollector_1.MetricCollector(this._sharedState, metricReader); + metricReader.setMetricProducer(collector); + this._sharedState.metricCollectors.push(collector); + if (options.sdkMetricsEnabled && metricReader instanceof MetricReader_1.MetricReader) { + metricReader._setSelfObsMeterProvider(this); + } + } + } + } + /** + * Get a meter with the configuration of the MeterProvider. + */ + getMeter(name, version = "", options = {}) { + if (this._shutdown) { + api_1.diag.warn("A shutdown MeterProvider cannot provide a Meter"); + return (0, api_1.createNoopMeter)(); + } + return this._sharedState.getMeterSharedState({ + name, + version, + schemaUrl: options.schemaUrl + }).meter; + } + /** + * Shut down the MeterProvider and all registered + * MetricReaders. + * + * Returns a promise which is resolved when all flushes are complete. + */ + async shutdown(options) { + if (this._shutdown) { + api_1.diag.warn("shutdown may only be called once per MeterProvider"); + return; + } + this._shutdown = true; + await Promise.all(this._sharedState.metricCollectors.map((collector) => { + return collector.shutdown(options); + })); + } + /** + * Notifies all registered MetricReaders to flush any buffered data. + * + * Returns a promise which is resolved when all flushes are complete. + */ + async forceFlush(options) { + if (this._shutdown) { + api_1.diag.warn("invalid attempt to force flush after MeterProvider shutdown"); + return; + } + await Promise.all(this._sharedState.metricCollectors.map((collector) => { + return collector.forceFlush(options); + })); + } + }; + exports.MeterProvider = MeterProvider; + } +}); + +// node_modules/@opentelemetry/sdk-metrics/build/src/index.js +var require_src4 = __commonJS({ + "node_modules/@opentelemetry/sdk-metrics/build/src/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.TimeoutError = exports.createDenyListAttributesProcessor = exports.createAllowListAttributesProcessor = exports.AggregationType = exports.MeterProvider = exports.ConsoleMetricExporter = exports.InMemoryMetricExporter = exports.PeriodicExportingMetricReader = exports.MetricReader = exports.InstrumentType = exports.DataPointType = exports.AggregationTemporality = void 0; + var AggregationTemporality_1 = require_AggregationTemporality(); + Object.defineProperty(exports, "AggregationTemporality", { enumerable: true, get: function() { + return AggregationTemporality_1.AggregationTemporality; + } }); + var MetricData_1 = require_MetricData(); + Object.defineProperty(exports, "DataPointType", { enumerable: true, get: function() { + return MetricData_1.DataPointType; + } }); + Object.defineProperty(exports, "InstrumentType", { enumerable: true, get: function() { + return MetricData_1.InstrumentType; + } }); + var MetricReader_1 = require_MetricReader(); + Object.defineProperty(exports, "MetricReader", { enumerable: true, get: function() { + return MetricReader_1.MetricReader; + } }); + var PeriodicExportingMetricReader_1 = require_PeriodicExportingMetricReader(); + Object.defineProperty(exports, "PeriodicExportingMetricReader", { enumerable: true, get: function() { + return PeriodicExportingMetricReader_1.PeriodicExportingMetricReader; + } }); + var InMemoryMetricExporter_1 = require_InMemoryMetricExporter(); + Object.defineProperty(exports, "InMemoryMetricExporter", { enumerable: true, get: function() { + return InMemoryMetricExporter_1.InMemoryMetricExporter; + } }); + var ConsoleMetricExporter_1 = require_ConsoleMetricExporter(); + Object.defineProperty(exports, "ConsoleMetricExporter", { enumerable: true, get: function() { + return ConsoleMetricExporter_1.ConsoleMetricExporter; + } }); + var MeterProvider_1 = require_MeterProvider(); + Object.defineProperty(exports, "MeterProvider", { enumerable: true, get: function() { + return MeterProvider_1.MeterProvider; + } }); + var AggregationOption_1 = require_AggregationOption(); + Object.defineProperty(exports, "AggregationType", { enumerable: true, get: function() { + return AggregationOption_1.AggregationType; + } }); + var AttributesProcessor_1 = require_AttributesProcessor(); + Object.defineProperty(exports, "createAllowListAttributesProcessor", { enumerable: true, get: function() { + return AttributesProcessor_1.createAllowListAttributesProcessor; + } }); + Object.defineProperty(exports, "createDenyListAttributesProcessor", { enumerable: true, get: function() { + return AttributesProcessor_1.createDenyListAttributesProcessor; + } }); + var utils_1 = require_utils3(); + Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function() { + return utils_1.TimeoutError; + } }); + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/metrics/protobuf/metrics-serializer.js +var require_metrics_serializer = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/metrics/protobuf/metrics-serializer.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.serializeMetricsExportRequest = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var sdk_metrics_1 = require_src4(); + var common_serializer_1 = require_common_serializer(); + var protobuf_size_estimator_1 = require_protobuf_size_estimator(); + var protobuf_writer_1 = require_protobuf_writer(); + function serializeNumberDataPoint(writer, dataPoint, valueType) { + const start = writer.startLengthDelimited(); + const startPos = writer.pos; + writer.writeTag(2, 1); + (0, common_serializer_1.writeHrTimeAsFixed64)(writer, dataPoint.startTime); + writer.writeTag(3, 1); + (0, common_serializer_1.writeHrTimeAsFixed64)(writer, dataPoint.endTime); + if (valueType === api_1.ValueType.INT) { + writer.writeTag(6, 1); + writer.writeSfixed64(dataPoint.value); + } else { + writer.writeTag(4, 1); + writer.writeDouble(dataPoint.value); + } + if (dataPoint.attributes) { + (0, common_serializer_1.writeAttributes)(writer, dataPoint.attributes, 7); + } + writer.finishLengthDelimited(start, writer.pos - startPos); + } + function serializeHistogramDataPoint(writer, dataPoint) { + const start = writer.startLengthDelimited(); + const startPos = writer.pos; + const histogram = dataPoint.value; + writer.writeTag(2, 1); + (0, common_serializer_1.writeHrTimeAsFixed64)(writer, dataPoint.startTime); + writer.writeTag(3, 1); + (0, common_serializer_1.writeHrTimeAsFixed64)(writer, dataPoint.endTime); + writer.writeTag(4, 1); + writer.writeFixed64(histogram.count >>> 0, histogram.count / 4294967296 >>> 0); + if (histogram.sum !== void 0) { + writer.writeTag(5, 1); + writer.writeDouble(histogram.sum); + } + if (histogram.buckets.counts.length > 0) { + writer.writeTag(6, 2); + const countsStart = writer.startLengthDelimited(); + const countsStartPos = writer.pos; + for (const count of histogram.buckets.counts) { + writer.writeFixed64(count >>> 0, count / 4294967296 >>> 0); + } + writer.finishLengthDelimited(countsStart, writer.pos - countsStartPos); + } + if (histogram.buckets.boundaries.length > 0) { + writer.writeTag(7, 2); + const boundsStart = writer.startLengthDelimited(); + const boundsStartPos = writer.pos; + for (const bound of histogram.buckets.boundaries) { + writer.writeDouble(bound); + } + writer.finishLengthDelimited(boundsStart, writer.pos - boundsStartPos); + } + if (dataPoint.attributes) { + (0, common_serializer_1.writeAttributes)(writer, dataPoint.attributes, 9); + } + if (histogram.min !== void 0) { + writer.writeTag(11, 1); + writer.writeDouble(histogram.min); + } + if (histogram.max !== void 0) { + writer.writeTag(12, 1); + writer.writeDouble(histogram.max); + } + writer.finishLengthDelimited(start, writer.pos - startPos); + } + function serializeExponentialBuckets(writer, offset, bucketCounts) { + const start = writer.startLengthDelimited(); + const startPos = writer.pos; + if (offset !== 0) { + writer.writeTag(1, 0); + writer.writeSint32(offset); + } + if (bucketCounts.length > 0) { + writer.writeTag(2, 2); + const bcStart = writer.startLengthDelimited(); + const bcStartPos = writer.pos; + for (const count of bucketCounts) { + writer.writeVarint(count); + } + writer.finishLengthDelimited(bcStart, writer.pos - bcStartPos); + } + writer.finishLengthDelimited(start, writer.pos - startPos); + } + function serializeExponentialHistogramDataPoint(writer, dataPoint) { + const start = writer.startLengthDelimited(); + const startPos = writer.pos; + const histogram = dataPoint.value; + if (dataPoint.attributes) { + (0, common_serializer_1.writeAttributes)(writer, dataPoint.attributes, 1); + } + writer.writeTag(2, 1); + (0, common_serializer_1.writeHrTimeAsFixed64)(writer, dataPoint.startTime); + writer.writeTag(3, 1); + (0, common_serializer_1.writeHrTimeAsFixed64)(writer, dataPoint.endTime); + writer.writeTag(4, 1); + writer.writeFixed64(histogram.count >>> 0, histogram.count / 4294967296 >>> 0); + if (histogram.sum !== void 0) { + writer.writeTag(5, 1); + writer.writeDouble(histogram.sum); + } + if (histogram.scale !== 0) { + writer.writeTag(6, 0); + writer.writeSint32(histogram.scale); + } + writer.writeTag(7, 1); + writer.writeFixed64(histogram.zeroCount >>> 0, histogram.zeroCount / 4294967296 >>> 0); + writer.writeTag(8, 2); + serializeExponentialBuckets(writer, histogram.positive.offset, histogram.positive.bucketCounts); + writer.writeTag(9, 2); + serializeExponentialBuckets(writer, histogram.negative.offset, histogram.negative.bucketCounts); + if (histogram.min !== void 0) { + writer.writeTag(12, 1); + writer.writeDouble(histogram.min); + } + if (histogram.max !== void 0) { + writer.writeTag(13, 1); + writer.writeDouble(histogram.max); + } + writer.finishLengthDelimited(start, writer.pos - startPos); + } + function serializeMetric(writer, metricData) { + const metricStart = writer.startLengthDelimited(); + const metricStartPos = writer.pos; + writer.writeTag(1, 2); + writer.writeString(metricData.descriptor.name); + if (metricData.descriptor.description) { + writer.writeTag(2, 2); + writer.writeString(metricData.descriptor.description); + } + if (metricData.descriptor.unit) { + writer.writeTag(3, 2); + writer.writeString(metricData.descriptor.unit); + } + switch (metricData.dataPointType) { + case sdk_metrics_1.DataPointType.GAUGE: + writer.writeTag(5, 2); + serializeGauge(writer, metricData); + break; + case sdk_metrics_1.DataPointType.SUM: + writer.writeTag(7, 2); + serializeSum(writer, metricData); + break; + case sdk_metrics_1.DataPointType.HISTOGRAM: + writer.writeTag(9, 2); + serializeHistogramMetric(writer, metricData); + break; + case sdk_metrics_1.DataPointType.EXPONENTIAL_HISTOGRAM: + writer.writeTag(10, 2); + serializeExponentialHistogramMetric(writer, metricData); + break; + default: { + const _exhaustive = metricData; + void _exhaustive; + } + } + writer.finishLengthDelimited(metricStart, writer.pos - metricStartPos); + } + function serializeGauge(writer, metricData) { + const start = writer.startLengthDelimited(); + const startPos = writer.pos; + for (const dataPoint of metricData.dataPoints) { + writer.writeTag(1, 2); + serializeNumberDataPoint(writer, dataPoint, metricData.descriptor.valueType); + } + writer.finishLengthDelimited(start, writer.pos - startPos); + } + function serializeSum(writer, metricData) { + const start = writer.startLengthDelimited(); + const startPos = writer.pos; + for (const dataPoint of metricData.dataPoints) { + writer.writeTag(1, 2); + serializeNumberDataPoint(writer, dataPoint, metricData.descriptor.valueType); + } + const temporality = toProtoAggregationTemporality(metricData.aggregationTemporality); + if (temporality !== 0) { + writer.writeTag(2, 0); + writer.writeVarint(temporality); + } + if (metricData.isMonotonic) { + writer.writeTag(3, 0); + writer.writeVarint(1); + } + writer.finishLengthDelimited(start, writer.pos - startPos); + } + function serializeHistogramMetric(writer, metricData) { + const start = writer.startLengthDelimited(); + const startPos = writer.pos; + for (const dataPoint of metricData.dataPoints) { + writer.writeTag(1, 2); + serializeHistogramDataPoint(writer, dataPoint); + } + const temporality = toProtoAggregationTemporality(metricData.aggregationTemporality); + if (temporality !== 0) { + writer.writeTag(2, 0); + writer.writeVarint(temporality); + } + writer.finishLengthDelimited(start, writer.pos - startPos); + } + function serializeExponentialHistogramMetric(writer, metricData) { + const start = writer.startLengthDelimited(); + const startPos = writer.pos; + for (const dataPoint of metricData.dataPoints) { + writer.writeTag(1, 2); + serializeExponentialHistogramDataPoint(writer, dataPoint); + } + const temporality = toProtoAggregationTemporality(metricData.aggregationTemporality); + if (temporality !== 0) { + writer.writeTag(2, 0); + writer.writeVarint(temporality); + } + writer.finishLengthDelimited(start, writer.pos - startPos); + } + function serializeScopeMetrics(writer, scopeMetrics) { + const scopeStart = writer.startLengthDelimited(); + const scopeStartPos = writer.pos; + (0, common_serializer_1.writeInstrumentationScope)(writer, scopeMetrics.scope, 1); + for (const metric of scopeMetrics.metrics) { + writer.writeTag(2, 2); + serializeMetric(writer, metric); + } + if (scopeMetrics.scope.schemaUrl) { + writer.writeTag(3, 2); + writer.writeString(scopeMetrics.scope.schemaUrl); + } + writer.finishLengthDelimited(scopeStart, writer.pos - scopeStartPos); + } + function serializeResourceMetrics(writer, resourceMetrics) { + const start = writer.startLengthDelimited(); + const startPos = writer.pos; + (0, common_serializer_1.writeResource)(writer, resourceMetrics.resource, 1); + for (const scopeMetrics of resourceMetrics.scopeMetrics) { + writer.writeTag(2, 2); + serializeScopeMetrics(writer, scopeMetrics); + } + if (resourceMetrics.resource.schemaUrl) { + writer.writeTag(3, 2); + writer.writeString(resourceMetrics.resource.schemaUrl); + } + writer.finishLengthDelimited(start, writer.pos - startPos); + } + function toProtoAggregationTemporality(temporality) { + switch (temporality) { + case sdk_metrics_1.AggregationTemporality.DELTA: + return 1; + case sdk_metrics_1.AggregationTemporality.CUMULATIVE: + return 2; + default: + return 0; + } + } + function serializeMetricsExportRequest(resourceMetrics) { + const estimator = new protobuf_size_estimator_1.ProtobufSizeEstimator(); + estimator.writeTag(1, 2); + serializeResourceMetrics(estimator, resourceMetrics); + const writer = new protobuf_writer_1.ProtobufWriter(estimator.pos); + writer.writeTag(1, 2); + serializeResourceMetrics(writer, resourceMetrics); + return writer.finish(); + } + exports.serializeMetricsExportRequest = serializeMetricsExportRequest; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/metrics/protobuf/response-deserializer.js +var require_response_deserializer2 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/metrics/protobuf/response-deserializer.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.deserializeExportMetricsServiceResponse = void 0; + var protobuf_reader_1 = require_protobuf_reader(); + function deserializePartialSuccess(data) { + const reader = new protobuf_reader_1.ProtobufReader(data); + const result = {}; + while (!reader.isAtEnd()) { + const { fieldNumber, wireType } = reader.readTag(); + switch (fieldNumber) { + case 1: + if (wireType === 0) { + result.rejectedDataPoints = reader.readVarint(); + } else { + reader.skip(wireType); + } + break; + case 2: + if (wireType === 2) { + result.errorMessage = reader.readString(); + } else { + reader.skip(wireType); + } + break; + default: + reader.skip(wireType); + break; + } + } + return result; + } + function deserializeExportMetricsServiceResponse(data) { + const reader = new protobuf_reader_1.ProtobufReader(data); + const result = {}; + while (!reader.isAtEnd()) { + const { fieldNumber, wireType } = reader.readTag(); + switch (fieldNumber) { + case 1: + if (wireType === 2) { + result.partialSuccess = deserializePartialSuccess(reader.readBytes()); + } else { + reader.skip(wireType); + } + break; + default: + reader.skip(wireType); + break; + } + } + return result; + } + exports.deserializeExportMetricsServiceResponse = deserializeExportMetricsServiceResponse; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/metrics/protobuf/metrics.js +var require_metrics2 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/metrics/protobuf/metrics.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ProtobufMetricsSerializer = void 0; + var metrics_serializer_1 = require_metrics_serializer(); + var response_deserializer_1 = require_response_deserializer2(); + exports.ProtobufMetricsSerializer = { + serializeRequest: (arg) => { + return (0, metrics_serializer_1.serializeMetricsExportRequest)(arg); + }, + deserializeResponse: (arg) => { + return (0, response_deserializer_1.deserializeExportMetricsServiceResponse)(arg); + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/metrics/protobuf/index.js +var require_protobuf2 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/metrics/protobuf/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ProtobufMetricsSerializer = void 0; + var metrics_1 = require_metrics2(); + Object.defineProperty(exports, "ProtobufMetricsSerializer", { enumerable: true, get: function() { + return metrics_1.ProtobufMetricsSerializer; + } }); + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/trace/protobuf/trace-serializer.js +var require_trace_serializer = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/trace/protobuf/trace-serializer.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.serializeTraceExportRequest = void 0; + var protobuf_writer_1 = require_protobuf_writer(); + var hex_to_binary_1 = require_hex_to_binary(); + var common_serializer_1 = require_common_serializer(); + var protobuf_size_estimator_1 = require_protobuf_size_estimator(); + var SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK = 256; + var SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK = 512; + function buildSpanFlags(traceFlags, isRemote) { + let flags = traceFlags & 255 | SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK; + if (isRemote) { + flags |= SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK; + } + return flags; + } + function serializeStatus(writer, status) { + const statusStart = writer.startLengthDelimited(); + const statusStartPos = writer.pos; + if (status.message) { + writer.writeTag(2, 2); + writer.writeString(status.message); + } + writer.writeTag(3, 0); + writer.writeVarint(status.code); + writer.finishLengthDelimited(statusStart, writer.pos - statusStartPos); + } + function serializeEvent(writer, event) { + const eventStart = writer.startLengthDelimited(); + const eventStartPos = writer.pos; + writer.writeTag(1, 1); + (0, common_serializer_1.writeHrTimeAsFixed64)(writer, event.time); + writer.writeTag(2, 2); + writer.writeString(event.name); + if (event.attributes) { + (0, common_serializer_1.writeAttributes)(writer, event.attributes, 3); + } + writer.writeTag(4, 0); + writer.writeVarint(event.droppedAttributesCount || 0); + writer.finishLengthDelimited(eventStart, writer.pos - eventStartPos); + } + function serializeLink(writer, link) { + const linkStart = writer.startLengthDelimited(); + const linkStartPos = writer.pos; + const context2 = link.context; + writer.writeTag(1, 2); + writer.writeBytes((0, hex_to_binary_1.hexToBinary)(context2.traceId)); + writer.writeTag(2, 2); + writer.writeBytes((0, hex_to_binary_1.hexToBinary)(context2.spanId)); + const linkTraceState = context2.traceState?.serialize(); + if (linkTraceState) { + writer.writeTag(3, 2); + writer.writeString(linkTraceState); + } + if (link.attributes) { + (0, common_serializer_1.writeAttributes)(writer, link.attributes, 4); + } + writer.writeTag(5, 0); + writer.writeVarint(link.droppedAttributesCount || 0); + const linkFlags = buildSpanFlags(context2.traceFlags, context2.isRemote); + if (linkFlags) { + writer.writeTag(6, 5); + writer.writeFixed32(linkFlags); + } + writer.finishLengthDelimited(linkStart, writer.pos - linkStartPos); + } + function serializeSpan(writer, span) { + const spanStart = writer.startLengthDelimited(); + const spanStartPos = writer.pos; + const ctx = span.spanContext(); + writer.writeTag(1, 2); + writer.writeBytes((0, hex_to_binary_1.hexToBinary)(ctx.traceId)); + writer.writeTag(2, 2); + writer.writeBytes((0, hex_to_binary_1.hexToBinary)(ctx.spanId)); + const traceState = ctx.traceState?.serialize(); + if (traceState) { + writer.writeTag(3, 2); + writer.writeString(traceState); + } + if (span.parentSpanContext?.spanId) { + writer.writeTag(4, 2); + writer.writeBytes((0, hex_to_binary_1.hexToBinary)(span.parentSpanContext.spanId)); + } + writer.writeTag(5, 2); + writer.writeString(span.name); + const kind = span.kind == null ? 0 : span.kind + 1; + if (kind !== 0) { + writer.writeTag(6, 0); + writer.writeVarint(kind); + } + writer.writeTag(7, 1); + (0, common_serializer_1.writeHrTimeAsFixed64)(writer, span.startTime); + writer.writeTag(8, 1); + (0, common_serializer_1.writeHrTimeAsFixed64)(writer, span.endTime); + if (span.attributes) { + (0, common_serializer_1.writeAttributes)(writer, span.attributes, 9); + } + writer.writeTag(10, 0); + writer.writeVarint(span.droppedAttributesCount); + for (const event of span.events) { + writer.writeTag(11, 2); + serializeEvent(writer, event); + } + writer.writeTag(12, 0); + writer.writeVarint(span.droppedEventsCount); + for (const link of span.links) { + writer.writeTag(13, 2); + serializeLink(writer, link); + } + writer.writeTag(14, 0); + writer.writeVarint(span.droppedLinksCount); + writer.writeTag(15, 2); + serializeStatus(writer, span.status); + const flags = buildSpanFlags(ctx.traceFlags, span.parentSpanContext?.isRemote); + if (flags) { + writer.writeTag(16, 5); + writer.writeFixed32(flags); + } + writer.finishLengthDelimited(spanStart, writer.pos - spanStartPos); + } + function serializeScopeSpans(writer, scope, spans) { + const scopeSpansStart = writer.startLengthDelimited(); + const scopeSpansStartPos = writer.pos; + (0, common_serializer_1.writeInstrumentationScope)(writer, scope, 1); + for (const span of spans) { + writer.writeTag(2, 2); + serializeSpan(writer, span); + } + if (scope.schemaUrl) { + writer.writeTag(3, 2); + writer.writeString(scope.schemaUrl); + } + writer.finishLengthDelimited(scopeSpansStart, writer.pos - scopeSpansStartPos); + } + function serializeResourceSpans(writer, resource, scopeMap) { + const resourceSpansStart = writer.startLengthDelimited(); + const resourceSpansStartPos = writer.pos; + (0, common_serializer_1.writeResource)(writer, resource, 1); + for (const scopeSpans of scopeMap.values()) { + writer.writeTag(2, 2); + const scope = scopeSpans[0].instrumentationScope; + serializeScopeSpans(writer, scope, scopeSpans); + } + if (resource.schemaUrl) { + writer.writeTag(3, 2); + writer.writeString(resource.schemaUrl); + } + writer.finishLengthDelimited(resourceSpansStart, writer.pos - resourceSpansStartPos); + } + function createResourceMap(spans) { + const resourceMap = /* @__PURE__ */ new Map(); + for (const span of spans) { + const resource = span.resource; + const scope = span.instrumentationScope; + let scopeMap = resourceMap.get(resource); + if (!scopeMap) { + scopeMap = /* @__PURE__ */ new Map(); + resourceMap.set(resource, scopeMap); + } + let records = scopeMap.get(scope); + if (!records) { + records = []; + scopeMap.set(scope, records); + } + records.push(span); + } + return resourceMap; + } + function serializeTraceExportRequest(spans) { + const resourceMap = createResourceMap(spans); + const estimator = new protobuf_size_estimator_1.ProtobufSizeEstimator(); + for (const [resource, scopeMap] of resourceMap) { + estimator.writeTag(1, 2); + serializeResourceSpans(estimator, resource, scopeMap); + } + const writer = new protobuf_writer_1.ProtobufWriter(estimator.pos); + for (const [resource, scopeMap] of resourceMap) { + writer.writeTag(1, 2); + serializeResourceSpans(writer, resource, scopeMap); + } + return writer.finish(); + } + exports.serializeTraceExportRequest = serializeTraceExportRequest; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/trace/protobuf/response-deserializer.js +var require_response_deserializer3 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/trace/protobuf/response-deserializer.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.deserializeExportTraceServiceResponse = void 0; + var protobuf_reader_1 = require_protobuf_reader(); + function deserializePartialSuccess(data) { + const reader = new protobuf_reader_1.ProtobufReader(data); + const result = {}; + while (!reader.isAtEnd()) { + const { fieldNumber, wireType } = reader.readTag(); + switch (fieldNumber) { + case 1: + if (wireType === 0) { + result.rejectedSpans = reader.readVarint(); + } else { + reader.skip(wireType); + } + break; + case 2: + if (wireType === 2) { + result.errorMessage = reader.readString(); + } else { + reader.skip(wireType); + } + break; + default: + reader.skip(wireType); + break; + } + } + return result; + } + function deserializeExportTraceServiceResponse(data) { + const reader = new protobuf_reader_1.ProtobufReader(data); + const result = {}; + while (!reader.isAtEnd()) { + const { fieldNumber, wireType } = reader.readTag(); + switch (fieldNumber) { + case 1: + if (wireType === 2) { + result.partialSuccess = deserializePartialSuccess(reader.readBytes()); + } else { + reader.skip(wireType); + } + break; + default: + reader.skip(wireType); + break; + } + } + return result; + } + exports.deserializeExportTraceServiceResponse = deserializeExportTraceServiceResponse; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/trace/protobuf/trace.js +var require_trace2 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/trace/protobuf/trace.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ProtobufTraceSerializer = void 0; + var trace_serializer_1 = require_trace_serializer(); + var response_deserializer_1 = require_response_deserializer3(); + exports.ProtobufTraceSerializer = { + serializeRequest: (arg) => { + return (0, trace_serializer_1.serializeTraceExportRequest)(arg); + }, + deserializeResponse: (arg) => { + return (0, response_deserializer_1.deserializeExportTraceServiceResponse)(arg); + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/trace/protobuf/index.js +var require_protobuf3 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/trace/protobuf/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ProtobufTraceSerializer = void 0; + var trace_1 = require_trace2(); + Object.defineProperty(exports, "ProtobufTraceSerializer", { enumerable: true, get: function() { + return trace_1.ProtobufTraceSerializer; + } }); + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/common/internal.js +var require_internal = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/common/internal.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.toAnyValue = exports.toKeyValue = exports.toAttributes = exports.createInstrumentationScope = exports.createResource = void 0; + function createResource(resource, encoder) { + const result = { + attributes: toAttributes(resource.attributes, encoder), + droppedAttributesCount: 0 + }; + const schemaUrl = resource.schemaUrl; + if (schemaUrl && schemaUrl !== "") + result.schemaUrl = schemaUrl; + return result; + } + exports.createResource = createResource; + function createInstrumentationScope(scope, encoder) { + const result = { + name: scope.name, + version: scope.version + }; + if (scope.attributes && Object.keys(scope.attributes).length > 0) { + result.attributes = toAttributes(scope.attributes, encoder); + result.droppedAttributesCount = scope.droppedAttributesCount ?? 0; + } + return result; + } + exports.createInstrumentationScope = createInstrumentationScope; + function toAttributes(attributes, encoder) { + return Object.keys(attributes).map((key) => toKeyValue(key, attributes[key], encoder)); + } + exports.toAttributes = toAttributes; + function toKeyValue(key, value, encoder) { + return { + key, + value: toAnyValue(value, encoder) + }; + } + exports.toKeyValue = toKeyValue; + function toAnyValue(value, encoder) { + const t = typeof value; + if (t === "string") + return { stringValue: value }; + if (t === "number") { + if (!Number.isInteger(value)) + return { doubleValue: value }; + return { intValue: value }; + } + if (t === "boolean") + return { boolValue: value }; + if (value instanceof Uint8Array) + return { bytesValue: encoder.encodeUint8Array(value) }; + if (Array.isArray(value)) { + const values = new Array(value.length); + for (let i = 0; i < value.length; i++) { + values[i] = toAnyValue(value[i], encoder); + } + return { arrayValue: { values } }; + } + if (t === "object" && value != null) { + const keys = Object.keys(value); + const values = new Array(keys.length); + for (let i = 0; i < keys.length; i++) { + values[i] = { + key: keys[i], + value: toAnyValue(value[keys[i]], encoder) + }; + } + return { kvlistValue: { values } }; + } + return {}; + } + exports.toAnyValue = toAnyValue; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/logs/internal.js +var require_internal2 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/logs/internal.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.createExportLogsServiceRequest = void 0; + var internal_1 = require_internal(); + function createExportLogsServiceRequest(logRecords, encoder) { + return { + resourceLogs: logRecordsToResourceLogs(logRecords, encoder) + }; + } + exports.createExportLogsServiceRequest = createExportLogsServiceRequest; + function createResourceMap(logRecords) { + const resourceMap = /* @__PURE__ */ new Map(); + for (const record of logRecords) { + const { resource, instrumentationScope } = record; + let ismMap = resourceMap.get(resource); + if (!ismMap) { + ismMap = /* @__PURE__ */ new Map(); + resourceMap.set(resource, ismMap); + } + let records = ismMap.get(instrumentationScope); + if (!records) { + records = []; + ismMap.set(instrumentationScope, records); + } + records.push(record); + } + return resourceMap; + } + function logRecordsToResourceLogs(logRecords, encoder) { + const resourceMap = createResourceMap(logRecords); + return Array.from(resourceMap, ([resource, ismMap]) => { + const processedResource = (0, internal_1.createResource)(resource, encoder); + return { + resource: processedResource, + scopeLogs: Array.from(ismMap, ([, scopeLogs]) => { + return { + scope: (0, internal_1.createInstrumentationScope)(scopeLogs[0].instrumentationScope, encoder), + logRecords: scopeLogs.map((log) => toLogRecord(log, encoder)), + schemaUrl: scopeLogs[0].instrumentationScope.schemaUrl + }; + }), + schemaUrl: processedResource.schemaUrl + }; + }); + } + function toLogRecord(log, encoder) { + return { + timeUnixNano: encoder.encodeHrTime(log.hrTime), + observedTimeUnixNano: encoder.encodeHrTime(log.hrTimeObserved), + severityNumber: toSeverityNumber(log.severityNumber), + severityText: log.severityText, + body: (0, internal_1.toAnyValue)(log.body, encoder), + eventName: log.eventName, + attributes: (0, internal_1.toAttributes)(log.attributes, encoder), + droppedAttributesCount: log.droppedAttributesCount, + flags: log.spanContext?.traceFlags, + traceId: encoder.encodeOptionalSpanContext(log.spanContext?.traceId), + spanId: encoder.encodeOptionalSpanContext(log.spanContext?.spanId) + }; + } + function toSeverityNumber(severityNumber) { + return severityNumber; + } + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/common/utils.js +var require_utils6 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/common/utils.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.JSON_ENCODER = exports.PROTOBUF_ENCODER = exports.encodeAsString = exports.encodeAsLongBits = exports.toLongBits = exports.hrTimeToNanos = void 0; + var core_1 = require_src(); + var hex_to_binary_1 = require_hex_to_binary(); + function hrTimeToNanos(hrTime2) { + const NANOSECONDS = BigInt(1e9); + return BigInt(Math.trunc(hrTime2[0])) * NANOSECONDS + BigInt(Math.trunc(hrTime2[1])); + } + exports.hrTimeToNanos = hrTimeToNanos; + function toLongBits(value) { + const low = Number(BigInt.asUintN(32, value)); + const high = Number(BigInt.asUintN(32, value >> BigInt(32))); + return { low, high }; + } + exports.toLongBits = toLongBits; + function encodeAsLongBits(hrTime2) { + const nanos = hrTimeToNanos(hrTime2); + return toLongBits(nanos); + } + exports.encodeAsLongBits = encodeAsLongBits; + function encodeAsString(hrTime2) { + const nanos = hrTimeToNanos(hrTime2); + return nanos.toString(); + } + exports.encodeAsString = encodeAsString; + var encodeTimestamp = typeof BigInt !== "undefined" ? encodeAsString : core_1.hrTimeToNanoseconds; + function identity(value) { + return value; + } + function optionalHexToBinary(str) { + if (str === void 0) + return void 0; + return (0, hex_to_binary_1.hexToBinary)(str); + } + exports.PROTOBUF_ENCODER = { + encodeHrTime: encodeAsLongBits, + encodeSpanContext: hex_to_binary_1.hexToBinary, + encodeOptionalSpanContext: optionalHexToBinary, + encodeUint8Array: identity + }; + exports.JSON_ENCODER = { + encodeHrTime: encodeTimestamp, + encodeSpanContext: identity, + encodeOptionalSpanContext: identity, + encodeUint8Array: (bytes) => { + if (typeof Buffer !== "undefined") { + return Buffer.from(bytes).toString("base64"); + } + const chars = new Array(bytes.length); + for (let i = 0; i < bytes.length; i++) { + chars[i] = String.fromCharCode(bytes[i]); + } + return btoa(chars.join("")); + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/logs/json/logs.js +var require_logs4 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/logs/json/logs.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.JsonLogsSerializer = void 0; + var internal_1 = require_internal2(); + var utils_1 = require_utils6(); + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + exports.JsonLogsSerializer = { + serializeRequest: (arg) => { + const request = (0, internal_1.createExportLogsServiceRequest)(arg, utils_1.JSON_ENCODER); + const encoder = new TextEncoder(); + return encoder.encode(JSON.stringify(request)); + }, + deserializeResponse: (arg) => { + if (arg.length === 0) { + return {}; + } + const decoder = new TextDecoder(); + try { + return JSON.parse(decoder.decode(arg)); + } catch (err) { + api_1.diag.warn(`Failed to parse logs export response: ${err.message}. Returning empty response`); + return {}; + } + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/logs/json/index.js +var require_json = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/logs/json/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.JsonLogsSerializer = void 0; + var logs_1 = require_logs4(); + Object.defineProperty(exports, "JsonLogsSerializer", { enumerable: true, get: function() { + return logs_1.JsonLogsSerializer; + } }); + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/metrics/internal-types.js +var require_internal_types = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/metrics/internal-types.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.EAggregationTemporality = void 0; + var EAggregationTemporality; + (function(EAggregationTemporality2) { + EAggregationTemporality2[EAggregationTemporality2["AGGREGATION_TEMPORALITY_UNSPECIFIED"] = 0] = "AGGREGATION_TEMPORALITY_UNSPECIFIED"; + EAggregationTemporality2[EAggregationTemporality2["AGGREGATION_TEMPORALITY_DELTA"] = 1] = "AGGREGATION_TEMPORALITY_DELTA"; + EAggregationTemporality2[EAggregationTemporality2["AGGREGATION_TEMPORALITY_CUMULATIVE"] = 2] = "AGGREGATION_TEMPORALITY_CUMULATIVE"; + })(EAggregationTemporality || (exports.EAggregationTemporality = EAggregationTemporality = {})); + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/metrics/internal.js +var require_internal3 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/metrics/internal.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.createExportMetricsServiceRequest = exports.toMetric = exports.toScopeMetrics = exports.toResourceMetrics = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var sdk_metrics_1 = require_src4(); + var internal_types_1 = require_internal_types(); + var internal_1 = require_internal(); + function toResourceMetrics(resourceMetrics, encoder) { + const processedResource = (0, internal_1.createResource)(resourceMetrics.resource, encoder); + return { + resource: processedResource, + schemaUrl: processedResource.schemaUrl, + scopeMetrics: toScopeMetrics(resourceMetrics.scopeMetrics, encoder) + }; + } + exports.toResourceMetrics = toResourceMetrics; + function toScopeMetrics(scopeMetrics, encoder) { + return Array.from(scopeMetrics.map((metrics2) => ({ + scope: (0, internal_1.createInstrumentationScope)(metrics2.scope, encoder), + metrics: metrics2.metrics.map((metricData) => toMetric(metricData, encoder)), + schemaUrl: metrics2.scope.schemaUrl + }))); + } + exports.toScopeMetrics = toScopeMetrics; + function toMetric(metricData, encoder) { + const out = { + name: metricData.descriptor.name, + description: metricData.descriptor.description, + unit: metricData.descriptor.unit + }; + const aggregationTemporality = toAggregationTemporality(metricData.aggregationTemporality); + switch (metricData.dataPointType) { + case sdk_metrics_1.DataPointType.SUM: + out.sum = { + aggregationTemporality, + isMonotonic: metricData.isMonotonic, + dataPoints: toSingularDataPoints(metricData, encoder) + }; + break; + case sdk_metrics_1.DataPointType.GAUGE: + out.gauge = { + dataPoints: toSingularDataPoints(metricData, encoder) + }; + break; + case sdk_metrics_1.DataPointType.HISTOGRAM: + out.histogram = { + aggregationTemporality, + dataPoints: toHistogramDataPoints(metricData, encoder) + }; + break; + case sdk_metrics_1.DataPointType.EXPONENTIAL_HISTOGRAM: + out.exponentialHistogram = { + aggregationTemporality, + dataPoints: toExponentialHistogramDataPoints(metricData, encoder) + }; + break; + } + return out; + } + exports.toMetric = toMetric; + function toSingularDataPoint(dataPoint, valueType, encoder) { + const out = { + attributes: (0, internal_1.toAttributes)(dataPoint.attributes, encoder), + startTimeUnixNano: encoder.encodeHrTime(dataPoint.startTime), + timeUnixNano: encoder.encodeHrTime(dataPoint.endTime) + }; + switch (valueType) { + case api_1.ValueType.INT: + out.asInt = dataPoint.value; + break; + case api_1.ValueType.DOUBLE: + out.asDouble = dataPoint.value; + break; + } + return out; + } + function toSingularDataPoints(metricData, encoder) { + return metricData.dataPoints.map((dataPoint) => { + return toSingularDataPoint(dataPoint, metricData.descriptor.valueType, encoder); + }); + } + function toHistogramDataPoints(metricData, encoder) { + return metricData.dataPoints.map((dataPoint) => { + const histogram = dataPoint.value; + return { + attributes: (0, internal_1.toAttributes)(dataPoint.attributes, encoder), + bucketCounts: histogram.buckets.counts, + explicitBounds: histogram.buckets.boundaries, + count: histogram.count, + sum: histogram.sum, + min: histogram.min, + max: histogram.max, + startTimeUnixNano: encoder.encodeHrTime(dataPoint.startTime), + timeUnixNano: encoder.encodeHrTime(dataPoint.endTime) + }; + }); + } + function toExponentialHistogramDataPoints(metricData, encoder) { + return metricData.dataPoints.map((dataPoint) => { + const histogram = dataPoint.value; + return { + attributes: (0, internal_1.toAttributes)(dataPoint.attributes, encoder), + count: histogram.count, + min: histogram.min, + max: histogram.max, + sum: histogram.sum, + positive: { + offset: histogram.positive.offset, + bucketCounts: histogram.positive.bucketCounts + }, + negative: { + offset: histogram.negative.offset, + bucketCounts: histogram.negative.bucketCounts + }, + scale: histogram.scale, + zeroCount: histogram.zeroCount, + startTimeUnixNano: encoder.encodeHrTime(dataPoint.startTime), + timeUnixNano: encoder.encodeHrTime(dataPoint.endTime) + }; + }); + } + function toAggregationTemporality(temporality) { + switch (temporality) { + case sdk_metrics_1.AggregationTemporality.DELTA: + return internal_types_1.EAggregationTemporality.AGGREGATION_TEMPORALITY_DELTA; + case sdk_metrics_1.AggregationTemporality.CUMULATIVE: + return internal_types_1.EAggregationTemporality.AGGREGATION_TEMPORALITY_CUMULATIVE; + } + } + function createExportMetricsServiceRequest(resourceMetrics, encoder) { + return { + resourceMetrics: resourceMetrics.map((metrics2) => toResourceMetrics(metrics2, encoder)) + }; + } + exports.createExportMetricsServiceRequest = createExportMetricsServiceRequest; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/metrics/json/metrics.js +var require_metrics3 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/metrics/json/metrics.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.JsonMetricsSerializer = void 0; + var internal_1 = require_internal3(); + var utils_1 = require_utils6(); + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + exports.JsonMetricsSerializer = { + serializeRequest: (arg) => { + const request = (0, internal_1.createExportMetricsServiceRequest)([arg], utils_1.JSON_ENCODER); + const encoder = new TextEncoder(); + return encoder.encode(JSON.stringify(request)); + }, + deserializeResponse: (arg) => { + if (arg.length === 0) { + return {}; + } + const decoder = new TextDecoder(); + try { + return JSON.parse(decoder.decode(arg)); + } catch (err) { + api_1.diag.warn(`Failed to parse metrics export response: ${err.message}. Returning empty response`); + return {}; + } + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/metrics/json/index.js +var require_json2 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/metrics/json/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.JsonMetricsSerializer = void 0; + var metrics_1 = require_metrics3(); + Object.defineProperty(exports, "JsonMetricsSerializer", { enumerable: true, get: function() { + return metrics_1.JsonMetricsSerializer; + } }); + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/trace/internal.js +var require_internal4 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/trace/internal.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.createExportTraceServiceRequest = exports.toOtlpSpanEvent = exports.toOtlpLink = exports.sdkSpanToOtlpSpan = void 0; + var internal_1 = require_internal(); + var SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK = 256; + var SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK = 512; + function buildSpanFlagsFrom(traceFlags, isRemote) { + let flags = traceFlags & 255 | SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK; + if (isRemote) { + flags |= SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK; + } + return flags; + } + function sdkSpanToOtlpSpan(span, encoder) { + const ctx = span.spanContext(); + const status = span.status; + const parentSpanId = span.parentSpanContext?.spanId ? encoder.encodeSpanContext(span.parentSpanContext?.spanId) : void 0; + return { + traceId: encoder.encodeSpanContext(ctx.traceId), + spanId: encoder.encodeSpanContext(ctx.spanId), + parentSpanId, + traceState: ctx.traceState?.serialize(), + name: span.name, + // Span kind is offset by 1 because the API does not define a value for unset + kind: span.kind == null ? 0 : span.kind + 1, + startTimeUnixNano: encoder.encodeHrTime(span.startTime), + endTimeUnixNano: encoder.encodeHrTime(span.endTime), + attributes: (0, internal_1.toAttributes)(span.attributes, encoder), + droppedAttributesCount: span.droppedAttributesCount, + events: span.events.map((event) => toOtlpSpanEvent(event, encoder)), + droppedEventsCount: span.droppedEventsCount, + status: { + // API and proto enums share the same values + code: status.code, + message: status.message + }, + links: span.links.map((link) => toOtlpLink(link, encoder)), + droppedLinksCount: span.droppedLinksCount, + flags: buildSpanFlagsFrom(ctx.traceFlags, span.parentSpanContext?.isRemote) + }; + } + exports.sdkSpanToOtlpSpan = sdkSpanToOtlpSpan; + function toOtlpLink(link, encoder) { + return { + attributes: link.attributes ? (0, internal_1.toAttributes)(link.attributes, encoder) : [], + spanId: encoder.encodeSpanContext(link.context.spanId), + traceId: encoder.encodeSpanContext(link.context.traceId), + traceState: link.context.traceState?.serialize(), + droppedAttributesCount: link.droppedAttributesCount || 0, + flags: buildSpanFlagsFrom(link.context.traceFlags, link.context.isRemote) + }; + } + exports.toOtlpLink = toOtlpLink; + function toOtlpSpanEvent(timedEvent, encoder) { + return { + attributes: timedEvent.attributes ? (0, internal_1.toAttributes)(timedEvent.attributes, encoder) : [], + name: timedEvent.name, + timeUnixNano: encoder.encodeHrTime(timedEvent.time), + droppedAttributesCount: timedEvent.droppedAttributesCount || 0 + }; + } + exports.toOtlpSpanEvent = toOtlpSpanEvent; + function createExportTraceServiceRequest(spans, encoder) { + return { + resourceSpans: spanRecordsToResourceSpans(spans, encoder) + }; + } + exports.createExportTraceServiceRequest = createExportTraceServiceRequest; + function createResourceMap(readableSpans) { + const resourceMap = /* @__PURE__ */ new Map(); + for (const record of readableSpans) { + let ilsMap = resourceMap.get(record.resource); + if (!ilsMap) { + ilsMap = /* @__PURE__ */ new Map(); + resourceMap.set(record.resource, ilsMap); + } + const instrumentationScopeKey = `${record.instrumentationScope.name}@${record.instrumentationScope.version || ""}:${record.instrumentationScope.schemaUrl || ""}`; + let records = ilsMap.get(instrumentationScopeKey); + if (!records) { + records = []; + ilsMap.set(instrumentationScopeKey, records); + } + records.push(record); + } + return resourceMap; + } + function spanRecordsToResourceSpans(readableSpans, encoder) { + const resourceMap = createResourceMap(readableSpans); + const out = []; + const entryIterator = resourceMap.entries(); + let entry = entryIterator.next(); + while (!entry.done) { + const [resource, ilmMap] = entry.value; + const scopeResourceSpans = []; + const ilmIterator = ilmMap.values(); + let ilmEntry = ilmIterator.next(); + while (!ilmEntry.done) { + const scopeSpans = ilmEntry.value; + if (scopeSpans.length > 0) { + const spans = scopeSpans.map((readableSpan) => sdkSpanToOtlpSpan(readableSpan, encoder)); + scopeResourceSpans.push({ + scope: (0, internal_1.createInstrumentationScope)(scopeSpans[0].instrumentationScope, encoder), + spans, + schemaUrl: scopeSpans[0].instrumentationScope.schemaUrl + }); + } + ilmEntry = ilmIterator.next(); + } + const processedResource = (0, internal_1.createResource)(resource, encoder); + const transformedSpans = { + resource: processedResource, + scopeSpans: scopeResourceSpans, + schemaUrl: processedResource.schemaUrl + }; + out.push(transformedSpans); + entry = entryIterator.next(); + } + return out; + } + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/trace/json/trace.js +var require_trace3 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/trace/json/trace.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.JsonTraceSerializer = void 0; + var internal_1 = require_internal4(); + var utils_1 = require_utils6(); + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + exports.JsonTraceSerializer = { + serializeRequest: (arg) => { + const request = (0, internal_1.createExportTraceServiceRequest)(arg, utils_1.JSON_ENCODER); + const encoder = new TextEncoder(); + return encoder.encode(JSON.stringify(request)); + }, + deserializeResponse: (arg) => { + if (arg.length === 0) { + return {}; + } + const decoder = new TextDecoder(); + try { + return JSON.parse(decoder.decode(arg)); + } catch (err) { + api_1.diag.warn(`Failed to parse trace export response: ${err.message}. Returning empty response`); + return {}; + } + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/trace/json/index.js +var require_json3 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/trace/json/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.JsonTraceSerializer = void 0; + var trace_1 = require_trace3(); + Object.defineProperty(exports, "JsonTraceSerializer", { enumerable: true, get: function() { + return trace_1.JsonTraceSerializer; + } }); + } +}); + +// node_modules/@opentelemetry/otlp-transformer/build/src/index.js +var require_src5 = __commonJS({ + "node_modules/@opentelemetry/otlp-transformer/build/src/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.JsonTraceSerializer = exports.JsonMetricsSerializer = exports.JsonLogsSerializer = exports.ProtobufTraceSerializer = exports.ProtobufMetricsSerializer = exports.ProtobufLogsSerializer = exports.LogsExporterMetricsHelper = exports.TraceExporterMetricsHelper = exports.MetricsExporterMetricsHelper = void 0; + var metrics_1 = require_metrics(); + Object.defineProperty(exports, "MetricsExporterMetricsHelper", { enumerable: true, get: function() { + return metrics_1.MetricsExporterMetricsHelper; + } }); + var trace_1 = require_trace(); + Object.defineProperty(exports, "TraceExporterMetricsHelper", { enumerable: true, get: function() { + return trace_1.TraceExporterMetricsHelper; + } }); + var logs_1 = require_logs(); + Object.defineProperty(exports, "LogsExporterMetricsHelper", { enumerable: true, get: function() { + return logs_1.LogsExporterMetricsHelper; + } }); + var protobuf_1 = require_protobuf(); + Object.defineProperty(exports, "ProtobufLogsSerializer", { enumerable: true, get: function() { + return protobuf_1.ProtobufLogsSerializer; + } }); + var protobuf_2 = require_protobuf2(); + Object.defineProperty(exports, "ProtobufMetricsSerializer", { enumerable: true, get: function() { + return protobuf_2.ProtobufMetricsSerializer; + } }); + var protobuf_3 = require_protobuf3(); + Object.defineProperty(exports, "ProtobufTraceSerializer", { enumerable: true, get: function() { + return protobuf_3.ProtobufTraceSerializer; + } }); + var json_1 = require_json(); + Object.defineProperty(exports, "JsonLogsSerializer", { enumerable: true, get: function() { + return json_1.JsonLogsSerializer; + } }); + var json_2 = require_json2(); + Object.defineProperty(exports, "JsonMetricsSerializer", { enumerable: true, get: function() { + return json_2.JsonMetricsSerializer; + } }); + var json_3 = require_json3(); + Object.defineProperty(exports, "JsonTraceSerializer", { enumerable: true, get: function() { + return json_3.JsonTraceSerializer; + } }); + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/util.js +function validateAndNormalizeHeaders(partialHeaders) { + const headers = {}; + Object.entries(partialHeaders ?? {}).forEach(([key, value]) => { + if (typeof value !== "undefined") { + headers[key] = String(value); + } else { + diag2.warn(`Header "${key}" has invalid value (${value}) and will be ignored`); + } + }); + return headers; +} +var init_util = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/util.js"() { + init_esm(); + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-configuration.js +function mergeHeaders2(userProvidedHeaders, fallbackHeaders, defaultHeaders) { + return async () => { + const requiredHeaders = { + ...await defaultHeaders() + }; + const headers = {}; + if (fallbackHeaders != null) { + Object.assign(headers, await fallbackHeaders()); + } + if (userProvidedHeaders != null) { + Object.assign(headers, validateAndNormalizeHeaders(await userProvidedHeaders())); + } + return Object.assign(headers, requiredHeaders); + }; +} +function validateUserProvidedUrl(url) { + if (url == null) { + return void 0; + } + try { + const base = globalThis.location?.href; + return new URL(url, base).href; + } catch { + throw new Error(`Configuration: Could not parse user-provided export URL: '${url}'`); + } +} +function mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) { + return { + ...mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration), + headers: mergeHeaders2(userProvidedConfiguration.headers, fallbackConfiguration.headers, defaultConfiguration.headers), + url: validateUserProvidedUrl(userProvidedConfiguration.url) ?? fallbackConfiguration.url ?? defaultConfiguration.url + }; +} +function getHttpConfigurationDefaults(requiredHeaders, signalResourcePath) { + return { + ...getSharedConfigurationDefaults(), + headers: async () => requiredHeaders, + url: "http://localhost:4318/" + signalResourcePath + }; +} +var init_otlp_http_configuration = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-configuration.js"() { + init_shared_configuration(); + init_util(); + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-configuration.js +function httpAgentFactoryFromOptions(options) { + return async (protocol) => { + const isInsecure = protocol === "http:"; + const module = isInsecure ? import("http") : import("https"); + const { Agent } = await module; + if (isInsecure) { + const { ca, cert, key, ...insecureOptions } = options; + return new Agent(insecureOptions); + } + return new Agent(options); + }; +} +function mergeOtlpNodeHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) { + return { + ...mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration), + agentFactory: userProvidedConfiguration.agentFactory ?? fallbackConfiguration.agentFactory ?? defaultConfiguration.agentFactory, + userAgent: userProvidedConfiguration.userAgent + }; +} +function getNodeHttpConfigurationDefaults(requiredHeaders, signalResourcePath) { + return { + ...getHttpConfigurationDefaults(requiredHeaders, signalResourcePath), + agentFactory: httpAgentFactoryFromOptions({ keepAlive: true }) + }; +} +var init_otlp_node_http_configuration = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-configuration.js"() { + init_otlp_http_configuration(); + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/is-export-retryable.js +function isExportHTTPErrorRetryable(statusCode) { + return statusCode === 429 || statusCode === 502 || statusCode === 503 || statusCode === 504; +} +function parseRetryAfterToMills(retryAfter) { + if (retryAfter == null) { + return void 0; + } + const seconds = Number.parseInt(retryAfter, 10); + if (Number.isInteger(seconds)) { + return seconds > 0 ? seconds * 1e3 : -1; + } + const delay = new Date(retryAfter).getTime() - Date.now(); + if (delay >= 0) { + return delay; + } + return 0; +} +var init_is_export_retryable = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/is-export-retryable.js"() { + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-transport-utils.js +import * as zlib from "zlib"; +import { Readable } from "stream"; +function sendWithHttp(request, url, headers, compression, userAgent, agent, data, timeoutMillis) { + return new Promise((resolve2) => { + const parsedUrl = new URL(url); + if (userAgent) { + headers["User-Agent"] = `${userAgent} ${DEFAULT_USER_AGENT}`; + } else { + headers["User-Agent"] = DEFAULT_USER_AGENT; + } + const options = { + method: "POST", + headers, + agent + }; + const req = request(parsedUrl, options, (res) => { + const responseData = []; + let responseSize = 0; + res.on("data", (chunk) => { + responseSize += chunk.length; + if (responseSize > MAX_RESPONSE_BODY_SIZE) { + const sizeError = new Error(`OTLP export response body exceeded size limit of ${MAX_RESPONSE_BODY_SIZE} bytes`); + resolve2({ status: "failure", error: sizeError }); + res.destroy(); + return; + } + responseData.push(chunk); + }); + res.on("end", () => { + if (res.statusCode && res.statusCode <= 299) { + resolve2({ + status: "success", + data: Buffer.concat(responseData) + }); + } else if (res.statusCode && isExportHTTPErrorRetryable(res.statusCode)) { + resolve2({ + status: "retryable", + retryInMillis: parseRetryAfterToMills(res.headers["retry-after"]) + }); + } else { + const error = new OTLPExporterError(res.statusMessage, res.statusCode, Buffer.concat(responseData).toString()); + resolve2({ + status: "failure", + error + }); + } + }); + res.on("error", (error) => { + if (res.statusCode && res.statusCode <= 299) { + resolve2({ + status: "success" + }); + } else if (res.statusCode && isExportHTTPErrorRetryable(res.statusCode)) { + resolve2({ + status: "retryable", + error, + retryInMillis: parseRetryAfterToMills(res.headers["retry-after"]) + }); + } else { + resolve2({ + status: "failure", + error + }); + } + }); + }); + req.setTimeout(timeoutMillis, () => { + req.destroy(); + resolve2({ + status: "retryable", + error: new Error("Request timed out") + }); + }); + req.on("error", (error) => { + if (isHttpTransportNetworkErrorRetryable(error)) { + resolve2({ + status: "retryable", + error + }); + } else { + resolve2({ + status: "failure", + error + }); + } + }); + compressAndSend(req, compression, data, (error) => { + resolve2({ + status: "failure", + error + }); + }); + }); +} +function compressAndSend(req, compression, data, onError) { + let dataStream = readableFromUint8Array(data); + if (compression === "gzip") { + req.setHeader("Content-Encoding", "gzip"); + dataStream = dataStream.on("error", onError).pipe(zlib.createGzip()).on("error", onError); + } + dataStream.pipe(req).on("error", onError); +} +function readableFromUint8Array(buff) { + const readable = new Readable(); + readable.push(buff); + readable.push(null); + return readable; +} +function isHttpTransportNetworkErrorRetryable(error) { + const RETRYABLE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([ + "ECONNRESET", + "ECONNREFUSED", + "EPIPE", + "ETIMEDOUT", + "EAI_AGAIN", + "ENOTFOUND", + "ENETUNREACH", + "EHOSTUNREACH" + ]); + if ("code" in error && typeof error.code === "string") { + return RETRYABLE_NETWORK_ERROR_CODES.has(error.code); + } + return false; +} +var DEFAULT_USER_AGENT, MAX_RESPONSE_BODY_SIZE; +var init_http_transport_utils = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-transport-utils.js"() { + init_is_export_retryable(); + init_types2(); + init_version2(); + DEFAULT_USER_AGENT = `OTel-OTLP-Exporter-JavaScript/${VERSION2}`; + MAX_RESPONSE_BODY_SIZE = 4 * 1024 * 1024; + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-exporter-transport.js +async function requestFunctionFactory(protocol) { + const module = protocol === "http:" ? import("http") : import("https"); + const { request } = await module; + return request; +} +function createHttpExporterTransport(parameters) { + return new HttpExporterTransport(parameters); +} +var HttpExporterTransport; +var init_http_exporter_transport = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-exporter-transport.js"() { + init_http_transport_utils(); + HttpExporterTransport = class { + _utils = null; + _parameters; + constructor(parameters) { + this._parameters = parameters; + } + async send(data, timeoutMillis) { + const { agent, request } = await this._loadUtils(); + const headers = await this._parameters.headers(); + return sendWithHttp(request, this._parameters.url, headers, this._parameters.compression, this._parameters.userAgent, agent, data, timeoutMillis); + } + shutdown() { + } + async _loadUtils() { + let utils = this._utils; + if (utils === null) { + const protocol = new URL(this._parameters.url).protocol; + const [agent, request] = await Promise.all([ + this._parameters.agentFactory(protocol), + requestFunctionFactory(protocol) + ]); + utils = this._utils = { agent, request }; + } + return utils; + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/retrying-transport.js +function getJitter() { + return Math.random() * (2 * JITTER) - JITTER; +} +function createRetryingTransport(options) { + return new RetryingTransport(options.transport); +} +var MAX_ATTEMPTS, INITIAL_BACKOFF, MAX_BACKOFF, BACKOFF_MULTIPLIER, JITTER, RetryingTransport; +var init_retrying_transport = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/retrying-transport.js"() { + init_esm(); + MAX_ATTEMPTS = 5; + INITIAL_BACKOFF = 1e3; + MAX_BACKOFF = 5e3; + BACKOFF_MULTIPLIER = 1.5; + JITTER = 0.2; + RetryingTransport = class { + _transport; + constructor(transport) { + this._transport = transport; + } + retry(data, timeoutMillis, inMillis) { + return new Promise((resolve2, reject) => { + setTimeout(() => { + this._transport.send(data, timeoutMillis).then(resolve2, reject); + }, inMillis); + }); + } + async send(data, timeoutMillis) { + let attempts = MAX_ATTEMPTS; + let nextBackoff = INITIAL_BACKOFF; + const deadline = Date.now() + timeoutMillis; + let result = await this._transport.send(data, timeoutMillis); + while (result.status === "retryable" && attempts > 0) { + attempts--; + const backoff = Math.max(Math.min(nextBackoff * (1 + getJitter()), MAX_BACKOFF), 0); + nextBackoff = nextBackoff * BACKOFF_MULTIPLIER; + const retryInMillis = result.retryInMillis ?? backoff; + const remainingTimeoutMillis = deadline - Date.now(); + if (retryInMillis > remainingTimeoutMillis) { + diag2.info(`Export retry time ${Math.round(retryInMillis)}ms exceeds remaining timeout ${Math.round(remainingTimeoutMillis)}ms, not retrying further.`); + return result; + } + diag2.verbose(`Scheduling export retry in ${Math.round(retryInMillis)}ms`); + result = await this.retry(data, remainingTimeoutMillis, retryInMillis); + } + if (result.status === "success") { + diag2.verbose(`Export succeeded after ${MAX_ATTEMPTS - attempts} retry attempts.`); + } else if (result.status === "retryable") { + diag2.info(`Export failed after maximum retry attempts (${MAX_ATTEMPTS}).`); + } else { + diag2.info(`Export failed with non-retryable error: ${result.error}`); + } + return result; + } + shutdown() { + return this._transport.shutdown(); + } + }; + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-http-export-delegate.js +function createOtlpHttpExporterMetrics(metricsComponentType, exporterMetricsHelper, url, meterProvider) { + return new ExporterMetrics({ + componentType: metricsComponentType, + metricsHelper: exporterMetricsHelper, + url, + meterProvider, + responseAttributesFromError: (error) => { + if (!error) { + return { + [ATTR_HTTP_RESPONSE_STATUS_CODE2]: 200 + }; + } + if (!(error instanceof OTLPExporterError)) { + return {}; + } + return { + [ATTR_HTTP_RESPONSE_STATUS_CODE2]: error.code + }; + } + }); +} +function createOtlpHttpExportDelegate(options, serializer, metricsComponentType, exporterMetricsHelper, meterProvider) { + return createOtlpExportDelegate({ + transport: createRetryingTransport({ + transport: createHttpExporterTransport(options) + }), + serializer, + promiseHandler: createBoundedQueueExportPromiseHandler(options), + metrics: createOtlpHttpExporterMetrics(metricsComponentType, exporterMetricsHelper, options.url, meterProvider) + }, { timeout: options.timeoutMillis }); +} +var init_otlp_http_export_delegate = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-http-export-delegate.js"() { + init_otlp_export_delegate(); + init_http_exporter_transport(); + init_bounded_queue_export_promise_handler(); + init_retrying_transport(); + init_types2(); + init_semconv(); + init_ExporterMetrics(); + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-env-configuration.js +function parseAndValidateTimeoutFromEnv(timeoutEnvVar) { + const envTimeout = (0, import_core3.getNumberFromEnv)(timeoutEnvVar); + if (envTimeout != null) { + if (Number.isFinite(envTimeout) && envTimeout > 0) { + return envTimeout; + } + diag2.warn(`Configuration: ${timeoutEnvVar} is invalid, expected number greater than 0 (actual: ${envTimeout})`); + } + return void 0; +} +function getTimeoutFromEnv(signalIdentifier) { + const specificTimeout = parseAndValidateTimeoutFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_TIMEOUT`); + const nonSpecificTimeout = parseAndValidateTimeoutFromEnv("OTEL_EXPORTER_OTLP_TIMEOUT"); + return specificTimeout ?? nonSpecificTimeout; +} +function parseAndValidateCompressionFromEnv(compressionEnvVar) { + const compression = (0, import_core3.getStringFromEnv)(compressionEnvVar)?.trim(); + if (compression == null || compression === "none" || compression === "gzip") { + return compression; + } + diag2.warn(`Configuration: ${compressionEnvVar} is invalid, expected 'none' or 'gzip' (actual: '${compression}')`); + return void 0; +} +function getCompressionFromEnv(signalIdentifier) { + const specificCompression = parseAndValidateCompressionFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_COMPRESSION`); + const nonSpecificCompression = parseAndValidateCompressionFromEnv("OTEL_EXPORTER_OTLP_COMPRESSION"); + return specificCompression ?? nonSpecificCompression; +} +function getSharedConfigurationFromEnvironment(signalIdentifier) { + return { + timeoutMillis: getTimeoutFromEnv(signalIdentifier), + compression: getCompressionFromEnv(signalIdentifier) + }; +} +var import_core3; +var init_shared_env_configuration = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-env-configuration.js"() { + import_core3 = __toESM(require_src()); + init_esm(); + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-env-configuration.js +import * as fs from "fs"; +import * as path from "path"; +function getStaticHeadersFromEnv(signalIdentifier) { + const signalSpecificRawHeaders = (0, import_core4.getStringFromEnv)(`OTEL_EXPORTER_OTLP_${signalIdentifier}_HEADERS`); + const nonSignalSpecificRawHeaders = (0, import_core4.getStringFromEnv)("OTEL_EXPORTER_OTLP_HEADERS"); + const signalSpecificHeaders = (0, import_core4.parseKeyPairsIntoRecord)(signalSpecificRawHeaders); + const nonSignalSpecificHeaders = (0, import_core4.parseKeyPairsIntoRecord)(nonSignalSpecificRawHeaders); + if (Object.keys(signalSpecificHeaders).length === 0 && Object.keys(nonSignalSpecificHeaders).length === 0) { + return void 0; + } + return Object.assign({}, (0, import_core4.parseKeyPairsIntoRecord)(nonSignalSpecificRawHeaders), (0, import_core4.parseKeyPairsIntoRecord)(signalSpecificRawHeaders)); +} +function appendRootPathToUrlIfNeeded(url) { + try { + const parsedUrl = new URL(url); + return parsedUrl.toString(); + } catch { + diag2.warn(`Configuration: Could not parse environment-provided export URL: '${url}', falling back to undefined`); + return void 0; + } +} +function appendResourcePathToUrl(url, path2) { + try { + new URL(url); + } catch { + diag2.warn(`Configuration: Could not parse environment-provided export URL: '${url}', falling back to undefined`); + return void 0; + } + if (!url.endsWith("/")) { + url = url + "/"; + } + url += path2; + try { + new URL(url); + } catch { + diag2.warn(`Configuration: Provided URL appended with '${path2}' is not a valid URL, using 'undefined' instead of '${url}'`); + return void 0; + } + return url; +} +function getNonSpecificUrlFromEnv(signalResourcePath) { + const envUrl = (0, import_core4.getStringFromEnv)("OTEL_EXPORTER_OTLP_ENDPOINT"); + if (envUrl === void 0) { + return void 0; + } + return appendResourcePathToUrl(envUrl, signalResourcePath); +} +function getSpecificUrlFromEnv(signalIdentifier) { + const envUrl = (0, import_core4.getStringFromEnv)(`OTEL_EXPORTER_OTLP_${signalIdentifier}_ENDPOINT`); + if (envUrl === void 0) { + return void 0; + } + return appendRootPathToUrlIfNeeded(envUrl); +} +function readFileFromEnv(signalSpecificEnvVar, nonSignalSpecificEnvVar, warningMessage) { + const signalSpecificPath = (0, import_core4.getStringFromEnv)(signalSpecificEnvVar); + const nonSignalSpecificPath = (0, import_core4.getStringFromEnv)(nonSignalSpecificEnvVar); + const filePath = signalSpecificPath ?? nonSignalSpecificPath; + if (filePath != null) { + try { + return fs.readFileSync(path.resolve(process.cwd(), filePath)); + } catch { + diag2.warn(warningMessage); + return void 0; + } + } else { + return void 0; + } +} +function getClientCertificateFromEnv(signalIdentifier) { + return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CLIENT_CERTIFICATE`, "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE", "Failed to read client certificate chain file"); +} +function getClientKeyFromEnv(signalIdentifier) { + return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CLIENT_KEY`, "OTEL_EXPORTER_OTLP_CLIENT_KEY", "Failed to read client certificate private key file"); +} +function getRootCertificateFromEnv(signalIdentifier) { + return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CERTIFICATE`, "OTEL_EXPORTER_OTLP_CERTIFICATE", "Failed to read root certificate file"); +} +function getNodeHttpConfigurationFromEnvironment(signalIdentifier, signalResourcePath) { + return { + ...getSharedConfigurationFromEnvironment(signalIdentifier), + url: getSpecificUrlFromEnv(signalIdentifier) ?? getNonSpecificUrlFromEnv(signalResourcePath), + headers: wrapStaticHeadersInFunction(getStaticHeadersFromEnv(signalIdentifier)), + agentFactory: httpAgentFactoryFromOptions({ + keepAlive: true, + ca: getRootCertificateFromEnv(signalIdentifier), + cert: getClientCertificateFromEnv(signalIdentifier), + key: getClientKeyFromEnv(signalIdentifier) + }) + }; +} +var import_core4; +var init_otlp_node_http_env_configuration = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-env-configuration.js"() { + import_core4 = __toESM(require_src()); + init_esm(); + init_shared_env_configuration(); + init_shared_configuration(); + init_otlp_node_http_configuration(); + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-http-options.js +function convertLegacyHeaders(config) { + if (typeof config.headers === "function") { + return config.headers; + } + return wrapStaticHeadersInFunction(config.headers); +} +var init_convert_legacy_http_options = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-http-options.js"() { + init_shared_configuration(); + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-node-http-options.js +function convertLegacyAgentOptions(config) { + if (typeof config.httpAgentOptions === "function") { + return config.httpAgentOptions; + } + let legacy = config.httpAgentOptions; + if (config.keepAlive != null) { + legacy = { keepAlive: config.keepAlive, ...legacy }; + } + if (legacy != null) { + return httpAgentFactoryFromOptions(legacy); + } else { + return void 0; + } +} +function convertLegacyHttpOptions(config, signalIdentifier, signalResourcePath, requiredHeaders) { + if (config.metadata) { + diag2.warn("Metadata cannot be set when using http"); + } + return mergeOtlpNodeHttpConfigurationWithDefaults({ + url: config.url, + headers: convertLegacyHeaders(config), + concurrencyLimit: config.concurrencyLimit, + timeoutMillis: config.timeoutMillis, + compression: config.compression, + agentFactory: convertLegacyAgentOptions(config), + userAgent: config.userAgent + }, getNodeHttpConfigurationFromEnvironment(signalIdentifier, signalResourcePath), getNodeHttpConfigurationDefaults(requiredHeaders, signalResourcePath)); +} +var init_convert_legacy_node_http_options = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-node-http-options.js"() { + init_esm(); + init_otlp_node_http_configuration(); + init_index_node_http(); + init_otlp_node_http_env_configuration(); + init_convert_legacy_http_options(); + } +}); + +// node_modules/@opentelemetry/otlp-exporter-base/build/esm/index-node-http.js +var index_node_http_exports = {}; +__export(index_node_http_exports, { + convertLegacyHttpOptions: () => convertLegacyHttpOptions, + createOtlpHttpExportDelegate: () => createOtlpHttpExportDelegate, + createOtlpHttpExporterMetrics: () => createOtlpHttpExporterMetrics, + getSharedConfigurationFromEnvironment: () => getSharedConfigurationFromEnvironment, + httpAgentFactoryFromOptions: () => httpAgentFactoryFromOptions +}); +var init_index_node_http = __esm({ + "node_modules/@opentelemetry/otlp-exporter-base/build/esm/index-node-http.js"() { + init_otlp_node_http_configuration(); + init_otlp_http_export_delegate(); + init_shared_env_configuration(); + init_convert_legacy_node_http_options(); + } +}); + +// node_modules/@opentelemetry/exporter-trace-otlp-http/build/src/semconv.js +var require_semconv4 = __commonJS({ + "node_modules/@opentelemetry/exporter-trace-otlp-http/build/src/semconv.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.OTEL_COMPONENT_TYPE_VALUE_OTLP_HTTP_SPAN_EXPORTER = void 0; + exports.OTEL_COMPONENT_TYPE_VALUE_OTLP_HTTP_SPAN_EXPORTER = "otlp_http_span_exporter"; + } +}); + +// node_modules/@opentelemetry/exporter-trace-otlp-http/build/src/platform/node/OTLPTraceExporter.js +var require_OTLPTraceExporter = __commonJS({ + "node_modules/@opentelemetry/exporter-trace-otlp-http/build/src/platform/node/OTLPTraceExporter.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.OTLPTraceExporter = void 0; + var otlp_exporter_base_1 = (init_esm3(), __toCommonJS(esm_exports3)); + var otlp_transformer_1 = require_src5(); + var node_http_1 = (init_index_node_http(), __toCommonJS(index_node_http_exports)); + var semconv_1 = require_semconv4(); + var OTLPTraceExporter2 = class extends otlp_exporter_base_1.OTLPExporterBase { + constructor(config = {}) { + super((0, node_http_1.createOtlpHttpExportDelegate)((0, node_http_1.convertLegacyHttpOptions)(config, "TRACES", "v1/traces", { + "Content-Type": "application/json" + }), otlp_transformer_1.JsonTraceSerializer, semconv_1.OTEL_COMPONENT_TYPE_VALUE_OTLP_HTTP_SPAN_EXPORTER, otlp_transformer_1.TraceExporterMetricsHelper, config.selfObsMeterProvider)); + } + }; + exports.OTLPTraceExporter = OTLPTraceExporter2; + } +}); + +// node_modules/@opentelemetry/exporter-trace-otlp-http/build/src/platform/node/index.js +var require_node3 = __commonJS({ + "node_modules/@opentelemetry/exporter-trace-otlp-http/build/src/platform/node/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.OTLPTraceExporter = void 0; + var OTLPTraceExporter_1 = require_OTLPTraceExporter(); + Object.defineProperty(exports, "OTLPTraceExporter", { enumerable: true, get: function() { + return OTLPTraceExporter_1.OTLPTraceExporter; + } }); + } +}); + +// node_modules/@opentelemetry/exporter-trace-otlp-http/build/src/platform/index.js +var require_platform3 = __commonJS({ + "node_modules/@opentelemetry/exporter-trace-otlp-http/build/src/platform/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.OTLPTraceExporter = void 0; + var node_1 = require_node3(); + Object.defineProperty(exports, "OTLPTraceExporter", { enumerable: true, get: function() { + return node_1.OTLPTraceExporter; + } }); + } +}); + +// node_modules/@opentelemetry/exporter-trace-otlp-http/build/src/index.js +var require_src6 = __commonJS({ + "node_modules/@opentelemetry/exporter-trace-otlp-http/build/src/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.OTLPTraceExporter = void 0; + var platform_1 = require_platform3(); + Object.defineProperty(exports, "OTLPTraceExporter", { enumerable: true, get: function() { + return platform_1.OTLPTraceExporter; + } }); + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/enums.js +var require_enums = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/enums.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ExceptionEventName = void 0; + exports.ExceptionEventName = "exception"; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/inspect.js +var require_inspect = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/inspect.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.formatInspect = exports.settledResourceAttributes = exports.inspectCustom = void 0; + exports.inspectCustom = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom"); + function settledResourceAttributes(resource) { + const attrs = {}; + for (const [k, v] of resource.getRawAttributes()) { + if (typeof v?.then === "function") { + continue; + } + if (v != null) { + attrs[k] ??= v; + } + } + return attrs; + } + exports.settledResourceAttributes = settledResourceAttributes; + function formatInspect(className, payload, depth, options, inspect) { + if (typeof depth === "number" && depth < 0) { + const tag = `[${className}]`; + return options?.stylize ? options.stylize(tag, "special") : tag; + } + if (typeof inspect !== "function" || !options) { + return payload; + } + const childOptions = { + ...options, + depth: options.depth == null ? options.depth : options.depth - 1 + }; + return `${className} ${inspect(payload, childOptions)}`; + } + exports.formatInspect = formatInspect; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/Span.js +var require_Span = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/Span.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SpanImpl = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var core_1 = require_src(); + var semantic_conventions_1 = (init_esm2(), __toCommonJS(esm_exports2)); + var enums_1 = require_enums(); + var inspect_1 = require_inspect(); + var SpanImpl = class { + // Below properties are included to implement ReadableSpan for export + // purposes but are not intended to be written-to directly. + _spanContext; + kind; + parentSpanContext; + attributes = {}; + links = []; + events = []; + startTime; + resource; + instrumentationScope; + _droppedAttributesCount = 0; + _droppedEventsCount = 0; + _droppedLinksCount = 0; + _attributesCount = 0; + name; + status = { + code: api_1.SpanStatusCode.UNSET + }; + endTime = [0, 0]; + _ended = false; + _duration = [-1, -1]; + _spanProcessor; + _spanLimits; + _attributeValueLengthLimit; + _recordEndMetrics; + _performanceStartTime; + _performanceOffset; + _startTimeProvided; + /** + * Constructs a new SpanImpl instance. + */ + constructor(opts) { + const now = Date.now(); + this._spanContext = opts.spanContext; + this._performanceStartTime = core_1.otperformance.now(); + this._performanceOffset = now - (this._performanceStartTime + core_1.otperformance.timeOrigin); + this._startTimeProvided = opts.startTime != null; + this._spanLimits = opts.spanLimits; + this._attributeValueLengthLimit = this._spanLimits.attributeValueLengthLimit ?? 0; + this._spanProcessor = opts.spanProcessor; + this.name = opts.name; + this.parentSpanContext = opts.parentSpanContext; + this.kind = opts.kind; + if (opts.links) { + for (const link of opts.links) { + this.addLink(link); + } + } + this.startTime = this._getTime(opts.startTime ?? now); + this.resource = opts.resource; + this.instrumentationScope = opts.scope; + this._recordEndMetrics = opts.recordEndMetrics; + if (opts.attributes != null) { + this.setAttributes(opts.attributes); + } + this._spanProcessor.onStart(this, opts.context); + } + spanContext() { + return this._spanContext; + } + setAttribute(key, value) { + if (value == null || this._isSpanEnded()) + return this; + if (key.length === 0) { + api_1.diag.warn(`Invalid attribute key: ${key}`); + return this; + } + if (!(0, core_1.isAttributeValue)(value)) { + api_1.diag.warn(`Invalid attribute value set for key: ${key}`); + return this; + } + const { attributeCountLimit } = this._spanLimits; + const isNewKey = !Object.prototype.hasOwnProperty.call(this.attributes, key); + if (attributeCountLimit !== void 0 && this._attributesCount >= attributeCountLimit && isNewKey) { + this._droppedAttributesCount++; + return this; + } + this.attributes[key] = this._truncateToSize(value); + if (isNewKey) { + this._attributesCount++; + } + return this; + } + setAttributes(attributes) { + for (const key in attributes) { + if (Object.prototype.hasOwnProperty.call(attributes, key)) { + this.setAttribute(key, attributes[key]); + } + } + return this; + } + /** + * + * @param name Span Name + * @param [attributesOrStartTime] Span attributes or start time + * if type is {@type TimeInput} and 3rd param is undefined + * @param [timeStamp] Specified time stamp for the event + */ + addEvent(name, attributesOrStartTime, timeStamp) { + if (this._isSpanEnded()) + return this; + const { eventCountLimit } = this._spanLimits; + if (eventCountLimit === 0) { + api_1.diag.warn("No events allowed."); + this._droppedEventsCount++; + return this; + } + if (eventCountLimit !== void 0 && this.events.length >= eventCountLimit) { + if (this._droppedEventsCount === 0) { + api_1.diag.debug("Dropping extra events."); + } + this.events.shift(); + this._droppedEventsCount++; + } + if ((0, core_1.isTimeInput)(attributesOrStartTime)) { + if (!(0, core_1.isTimeInput)(timeStamp)) { + timeStamp = attributesOrStartTime; + } + attributesOrStartTime = void 0; + } + const sanitized = (0, core_1.sanitizeAttributes)(attributesOrStartTime); + const { attributePerEventCountLimit } = this._spanLimits; + const attributes = {}; + let droppedAttributesCount = 0; + let eventAttributesCount = 0; + for (const attr in sanitized) { + if (!Object.prototype.hasOwnProperty.call(sanitized, attr)) { + continue; + } + const attrVal = sanitized[attr]; + if (attributePerEventCountLimit !== void 0 && eventAttributesCount >= attributePerEventCountLimit) { + droppedAttributesCount++; + continue; + } + attributes[attr] = this._truncateToSize(attrVal); + eventAttributesCount++; + } + this.events.push({ + name, + attributes, + time: this._getTime(timeStamp), + droppedAttributesCount + }); + return this; + } + addLink(link) { + if (this._isSpanEnded()) + return this; + const { linkCountLimit } = this._spanLimits; + if (linkCountLimit === 0) { + this._droppedLinksCount++; + return this; + } + if (linkCountLimit !== void 0 && this.links.length >= linkCountLimit) { + if (this._droppedLinksCount === 0) { + api_1.diag.debug("Dropping extra links."); + } + this.links.shift(); + this._droppedLinksCount++; + } + const { attributePerLinkCountLimit } = this._spanLimits; + const sanitized = (0, core_1.sanitizeAttributes)(link.attributes); + const attributes = {}; + let droppedAttributesCount = 0; + let linkAttributesCount = 0; + for (const attr in sanitized) { + if (!Object.prototype.hasOwnProperty.call(sanitized, attr)) { + continue; + } + const attrVal = sanitized[attr]; + if (attributePerLinkCountLimit !== void 0 && linkAttributesCount >= attributePerLinkCountLimit) { + droppedAttributesCount++; + continue; + } + attributes[attr] = this._truncateToSize(attrVal); + linkAttributesCount++; + } + const processedLink = { context: link.context }; + if (linkAttributesCount > 0) { + processedLink.attributes = attributes; + } + if (droppedAttributesCount > 0) { + processedLink.droppedAttributesCount = droppedAttributesCount; + } + this.links.push(processedLink); + return this; + } + addLinks(links) { + for (const link of links) { + this.addLink(link); + } + return this; + } + setStatus(status) { + if (this._isSpanEnded()) + return this; + if (status.code === api_1.SpanStatusCode.UNSET) + return this; + if (this.status.code === api_1.SpanStatusCode.OK) + return this; + const newStatus = { code: status.code }; + if (status.code === api_1.SpanStatusCode.ERROR) { + if (typeof status.message === "string") { + newStatus.message = status.message; + } else if (status.message != null) { + api_1.diag.warn(`Dropping invalid status.message of type '${typeof status.message}', expected 'string'`); + } + } + this.status = newStatus; + return this; + } + updateName(name) { + if (this._isSpanEnded()) + return this; + this.name = name; + return this; + } + end(endTime) { + if (this._isSpanEnded()) { + api_1.diag.error(`${this.name} ${this._spanContext.traceId}-${this._spanContext.spanId} - You can only call end() on a span once.`); + return; + } + this.endTime = this._getTime(endTime); + this._duration = (0, core_1.hrTimeDuration)(this.startTime, this.endTime); + if (this._duration[0] < 0) { + api_1.diag.warn("Inconsistent start and end time, startTime > endTime. Setting span duration to 0ms.", this.startTime, this.endTime); + this.endTime = this.startTime.slice(); + this._duration = [0, 0]; + } + if (this._droppedEventsCount > 0) { + api_1.diag.warn(`Dropped ${this._droppedEventsCount} events because eventCountLimit reached`); + } + if (this._droppedLinksCount > 0) { + api_1.diag.warn(`Dropped ${this._droppedLinksCount} links because linkCountLimit reached`); + } + if (this._spanProcessor.onEnding) { + this._spanProcessor.onEnding(this); + } + this._recordEndMetrics?.(); + this._ended = true; + this._spanProcessor.onEnd(this); + } + _getTime(inp) { + if (typeof inp === "number" && inp <= core_1.otperformance.now()) { + return (0, core_1.hrTime)(inp + this._performanceOffset); + } + if (typeof inp === "number") { + return (0, core_1.millisToHrTime)(inp); + } + if (inp instanceof Date) { + return (0, core_1.millisToHrTime)(inp.getTime()); + } + if ((0, core_1.isTimeInputHrTime)(inp)) { + return inp; + } + if (this._startTimeProvided) { + return (0, core_1.millisToHrTime)(Date.now()); + } + const msDuration = core_1.otperformance.now() - this._performanceStartTime; + return (0, core_1.addHrTimes)(this.startTime, (0, core_1.millisToHrTime)(msDuration)); + } + isRecording() { + return this._ended === false; + } + recordException(exception, time) { + const attributes = {}; + if (typeof exception === "string") { + attributes[semantic_conventions_1.ATTR_EXCEPTION_MESSAGE] = exception; + } else if (exception) { + if (exception.code) { + attributes[semantic_conventions_1.ATTR_EXCEPTION_TYPE] = exception.code.toString(); + } else if (exception.name) { + attributes[semantic_conventions_1.ATTR_EXCEPTION_TYPE] = exception.name; + } + if (exception.message) { + attributes[semantic_conventions_1.ATTR_EXCEPTION_MESSAGE] = exception.message; + } + if (exception.stack) { + attributes[semantic_conventions_1.ATTR_EXCEPTION_STACKTRACE] = exception.stack; + } + } + if (attributes[semantic_conventions_1.ATTR_EXCEPTION_TYPE] || attributes[semantic_conventions_1.ATTR_EXCEPTION_MESSAGE]) { + this.addEvent(enums_1.ExceptionEventName, attributes, time); + } else { + api_1.diag.warn(`Failed to record an exception ${exception}`); + } + } + get duration() { + return this._duration; + } + get ended() { + return this._ended; + } + get droppedAttributesCount() { + return this._droppedAttributesCount; + } + get droppedEventsCount() { + return this._droppedEventsCount; + } + get droppedLinksCount() { + return this._droppedLinksCount; + } + _isSpanEnded() { + if (this._ended) { + const error = new Error(`Operation attempted on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`); + api_1.diag.warn(`Cannot execute the operation on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`, error); + } + return this._ended; + } + // Utility function to truncate given value within size + // for value type of string, will truncate to given limit + // for type of non-string, will return same value + _truncateToLimitUtil(value, limit) { + if (value.length <= limit) { + return value; + } + return value.substring(0, limit); + } + /** + * If the given attribute value is of type string and has more characters than given {@code attributeValueLengthLimit} then + * return string with truncated to {@code attributeValueLengthLimit} characters + * + * If the given attribute value is array of strings then + * return new array of strings with each element truncated to {@code attributeValueLengthLimit} characters + * + * Otherwise return same Attribute {@code value} + * + * @param value Attribute value + * @returns truncated attribute value if required, otherwise same value + */ + _truncateToSize(value) { + const limit = this._attributeValueLengthLimit; + if (limit <= 0) { + api_1.diag.warn(`Attribute value limit must be positive, got ${limit}`); + return value; + } + if (typeof value === "string") { + return this._truncateToLimitUtil(value, limit); + } + if (Array.isArray(value)) { + return value.map((val) => typeof val === "string" ? this._truncateToLimitUtil(val, limit) : val); + } + return value; + } + [inspect_1.inspectCustom](depth, options, inspect) { + const payload = { + name: this.name, + kind: this.kind, + spanContext: this._spanContext, + parentSpanContext: this.parentSpanContext, + status: this.status, + startTime: this.startTime, + endTime: this.endTime, + duration: this._duration, + ended: this._ended, + attributes: this.attributes, + events: this.events, + links: this.links, + droppedAttributesCount: this._droppedAttributesCount, + droppedEventsCount: this._droppedEventsCount, + droppedLinksCount: this._droppedLinksCount, + instrumentationScope: this.instrumentationScope, + resource: { attributes: (0, inspect_1.settledResourceAttributes)(this.resource) } + }; + return (0, inspect_1.formatInspect)("SpanImpl", payload, depth, options, inspect); + } + }; + exports.SpanImpl = SpanImpl; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/Sampler.js +var require_Sampler = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/Sampler.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SamplingDecision = void 0; + var SamplingDecision2; + (function(SamplingDecision3) { + SamplingDecision3[SamplingDecision3["NOT_RECORD"] = 0] = "NOT_RECORD"; + SamplingDecision3[SamplingDecision3["RECORD"] = 1] = "RECORD"; + SamplingDecision3[SamplingDecision3["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED"; + })(SamplingDecision2 || (exports.SamplingDecision = SamplingDecision2 = {})); + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/semconv.js +var require_semconv5 = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/semconv.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.OTEL_COMPONENT_TYPE_VALUE_SIMPLE_SPAN_PROCESSOR = exports.OTEL_COMPONENT_TYPE_VALUE_BATCHING_SPAN_PROCESSOR = exports.METRIC_OTEL_SDK_SPAN_STARTED = exports.METRIC_OTEL_SDK_SPAN_LIVE = exports.METRIC_OTEL_SDK_PROCESSOR_SPAN_QUEUE_SIZE = exports.METRIC_OTEL_SDK_PROCESSOR_SPAN_QUEUE_CAPACITY = exports.METRIC_OTEL_SDK_PROCESSOR_SPAN_PROCESSED = exports.ATTR_OTEL_SPAN_SAMPLING_RESULT = exports.ATTR_OTEL_SPAN_PARENT_ORIGIN = exports.ATTR_OTEL_COMPONENT_TYPE = exports.ATTR_OTEL_COMPONENT_NAME = void 0; + exports.ATTR_OTEL_COMPONENT_NAME = "otel.component.name"; + exports.ATTR_OTEL_COMPONENT_TYPE = "otel.component.type"; + exports.ATTR_OTEL_SPAN_PARENT_ORIGIN = "otel.span.parent.origin"; + exports.ATTR_OTEL_SPAN_SAMPLING_RESULT = "otel.span.sampling_result"; + exports.METRIC_OTEL_SDK_PROCESSOR_SPAN_PROCESSED = "otel.sdk.processor.span.processed"; + exports.METRIC_OTEL_SDK_PROCESSOR_SPAN_QUEUE_CAPACITY = "otel.sdk.processor.span.queue.capacity"; + exports.METRIC_OTEL_SDK_PROCESSOR_SPAN_QUEUE_SIZE = "otel.sdk.processor.span.queue.size"; + exports.METRIC_OTEL_SDK_SPAN_LIVE = "otel.sdk.span.live"; + exports.METRIC_OTEL_SDK_SPAN_STARTED = "otel.sdk.span.started"; + exports.OTEL_COMPONENT_TYPE_VALUE_BATCHING_SPAN_PROCESSOR = "batching_span_processor"; + exports.OTEL_COMPONENT_TYPE_VALUE_SIMPLE_SPAN_PROCESSOR = "simple_span_processor"; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/TracerMetrics.js +var require_TracerMetrics = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/TracerMetrics.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.TracerMetrics = void 0; + var Sampler_1 = require_Sampler(); + var semconv_1 = require_semconv5(); + var TracerMetrics = class { + startedSpans; + liveSpans; + constructor(meter) { + this.startedSpans = meter.createCounter(semconv_1.METRIC_OTEL_SDK_SPAN_STARTED, { + unit: "{span}", + description: "The number of created spans." + }); + this.liveSpans = meter.createUpDownCounter(semconv_1.METRIC_OTEL_SDK_SPAN_LIVE, { + unit: "{span}", + description: "The number of currently live spans." + }); + } + startSpan(parentSpanCtx, samplingDecision) { + const samplingDecisionStr = samplingDecisionToString(samplingDecision); + this.startedSpans.add(1, { + [semconv_1.ATTR_OTEL_SPAN_PARENT_ORIGIN]: parentOrigin(parentSpanCtx), + [semconv_1.ATTR_OTEL_SPAN_SAMPLING_RESULT]: samplingDecisionStr + }); + if (samplingDecision === Sampler_1.SamplingDecision.NOT_RECORD) { + return () => { + }; + } + const liveSpanAttributes = { + [semconv_1.ATTR_OTEL_SPAN_SAMPLING_RESULT]: samplingDecisionStr + }; + this.liveSpans.add(1, liveSpanAttributes); + return () => { + this.liveSpans.add(-1, liveSpanAttributes); + }; + } + }; + exports.TracerMetrics = TracerMetrics; + function parentOrigin(parentSpanContext) { + if (!parentSpanContext) { + return "none"; + } + if (parentSpanContext.isRemote) { + return "remote"; + } + return "local"; + } + function samplingDecisionToString(decision) { + switch (decision) { + case Sampler_1.SamplingDecision.RECORD_AND_SAMPLED: + return "RECORD_AND_SAMPLE"; + case Sampler_1.SamplingDecision.RECORD: + return "RECORD_ONLY"; + case Sampler_1.SamplingDecision.NOT_RECORD: + return "DROP"; + } + } + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/version.js +var require_version3 = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/version.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.VERSION = void 0; + exports.VERSION = "2.11.0"; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/Tracer.js +var require_Tracer = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/Tracer.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Tracer = void 0; + var api = (init_esm(), __toCommonJS(esm_exports)); + var core_1 = require_src(); + var Span_1 = require_Span(); + var TracerMetrics_1 = require_TracerMetrics(); + var version_1 = require_version3(); + var inspect_1 = require_inspect(); + var Tracer = class { + _sampler; + _spanLimits; + _idGenerator; + instrumentationScope; + _resource; + _spanProcessor; + _tracerMetrics; + /** + * Constructs a new Tracer instance. + */ + constructor(instrumentationScope, options) { + this.instrumentationScope = instrumentationScope; + this._sampler = options.sampler; + this._spanLimits = options.spanLimits; + this._resource = options.resource; + this._idGenerator = options.idGenerator; + this._spanProcessor = options.spanProcessor; + const meter = options.meterProvider.getMeter("@opentelemetry/sdk-trace", version_1.VERSION); + this._tracerMetrics = new TracerMetrics_1.TracerMetrics(meter); + } + /** + * Starts a new Span or returns the default NoopSpan based on the sampling + * decision. + */ + startSpan(name, options = {}, context2 = api.context.active()) { + if (options.root) { + context2 = api.trace.deleteSpan(context2); + } + const parentSpan = api.trace.getSpan(context2); + if ((0, core_1.isTracingSuppressed)(context2)) { + api.diag.debug("Instrumentation suppressed, returning Noop Span"); + const nonRecordingSpan = api.trace.wrapSpanContext(api.INVALID_SPAN_CONTEXT); + return nonRecordingSpan; + } + const parentSpanContext = parentSpan?.spanContext(); + const spanId = this._idGenerator.generateSpanId(); + let validParentSpanContext; + let traceId; + let traceState; + if (!parentSpanContext || !api.trace.isSpanContextValid(parentSpanContext)) { + traceId = this._idGenerator.generateTraceId(); + } else { + traceId = parentSpanContext.traceId; + traceState = parentSpanContext.traceState; + validParentSpanContext = parentSpanContext; + } + const spanKind = options.kind ?? api.SpanKind.INTERNAL; + const links = (options.links ?? []).map((link) => { + return { + context: link.context, + attributes: (0, core_1.sanitizeAttributes)(link.attributes) + }; + }); + const attributes = (0, core_1.sanitizeAttributes)(options.attributes); + const samplingResult = this._sampler.shouldSample(context2, traceId, name, spanKind, attributes, links); + const recordEndMetrics = this._tracerMetrics.startSpan(parentSpanContext, samplingResult.decision); + traceState = samplingResult.traceState ?? traceState; + const traceFlags = samplingResult.decision === api.SamplingDecision.RECORD_AND_SAMPLED ? api.TraceFlags.SAMPLED : api.TraceFlags.NONE; + const spanContext = { traceId, spanId, traceFlags, traceState }; + if (samplingResult.decision === api.SamplingDecision.NOT_RECORD) { + api.diag.debug("Recording is off, propagating context in a non-recording span"); + const nonRecordingSpan = api.trace.wrapSpanContext(spanContext); + return nonRecordingSpan; + } + const initAttributes = (0, core_1.sanitizeAttributes)(Object.assign(attributes, samplingResult.attributes)); + const span = new Span_1.SpanImpl({ + resource: this._resource, + scope: this.instrumentationScope, + context: context2, + spanContext, + name, + kind: spanKind, + links, + parentSpanContext: validParentSpanContext, + attributes: initAttributes, + startTime: options.startTime, + spanProcessor: this._spanProcessor, + spanLimits: this._spanLimits, + recordEndMetrics + }); + return span; + } + startActiveSpan(name, arg2, arg3, arg4) { + let opts; + let ctx; + let fn; + if (arguments.length < 2) { + return; + } else if (arguments.length === 2) { + fn = arg2; + } else if (arguments.length === 3) { + opts = arg2; + fn = arg3; + } else { + opts = arg2; + ctx = arg3; + fn = arg4; + } + const parentContext = ctx ?? api.context.active(); + const span = this.startSpan(name, opts, parentContext); + const contextWithSpanSet = api.trace.setSpan(parentContext, span); + return api.context.with(contextWithSpanSet, fn, void 0, span); + } + [inspect_1.inspectCustom](depth, options, inspect) { + const payload = { + instrumentationScope: this.instrumentationScope, + resource: { attributes: (0, inspect_1.settledResourceAttributes)(this._resource) }, + spanLimits: this._spanLimits + }; + return (0, inspect_1.formatInspect)("Tracer", payload, depth, options, inspect); + } + }; + exports.Tracer = Tracer; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/MultiSpanProcessor.js +var require_MultiSpanProcessor = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/MultiSpanProcessor.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MultiSpanProcessor = void 0; + var core_1 = require_src(); + var MultiSpanProcessor = class { + _spanProcessors; + constructor(spanProcessors) { + this._spanProcessors = spanProcessors; + } + forceFlush() { + const promises = []; + for (const spanProcessor of this._spanProcessors) { + promises.push(spanProcessor.forceFlush()); + } + return new Promise((resolve2) => { + Promise.all(promises).then(() => { + resolve2(); + }).catch((error) => { + (0, core_1.globalErrorHandler)(error || new Error("MultiSpanProcessor: forceFlush failed")); + resolve2(); + }); + }); + } + onStart(span, context2) { + for (const spanProcessor of this._spanProcessors) { + spanProcessor.onStart(span, context2); + } + } + onEnding(span) { + for (const spanProcessor of this._spanProcessors) { + if (spanProcessor.onEnding) { + spanProcessor.onEnding(span); + } + } + } + onEnd(span) { + for (const spanProcessor of this._spanProcessors) { + spanProcessor.onEnd(span); + } + } + shutdown() { + const promises = []; + for (const spanProcessor of this._spanProcessors) { + promises.push(spanProcessor.shutdown()); + } + return new Promise((resolve2, reject) => { + Promise.all(promises).then(() => { + resolve2(); + }, reject); + }); + } + }; + exports.MultiSpanProcessor = MultiSpanProcessor; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/sampler/AlwaysOffSampler.js +var require_AlwaysOffSampler = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/sampler/AlwaysOffSampler.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.AlwaysOffSampler = void 0; + var Sampler_1 = require_Sampler(); + var AlwaysOffSampler = class { + shouldSample() { + return { + decision: Sampler_1.SamplingDecision.NOT_RECORD + }; + } + toString() { + return "AlwaysOffSampler"; + } + }; + exports.AlwaysOffSampler = AlwaysOffSampler; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/sampler/AlwaysOnSampler.js +var require_AlwaysOnSampler = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/sampler/AlwaysOnSampler.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.AlwaysOnSampler = void 0; + var Sampler_1 = require_Sampler(); + var AlwaysOnSampler2 = class { + shouldSample() { + return { + decision: Sampler_1.SamplingDecision.RECORD_AND_SAMPLED + }; + } + toString() { + return "AlwaysOnSampler"; + } + }; + exports.AlwaysOnSampler = AlwaysOnSampler2; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/sampler/ParentBasedSampler.js +var require_ParentBasedSampler = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/sampler/ParentBasedSampler.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ParentBasedSampler = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var core_1 = require_src(); + var AlwaysOffSampler_1 = require_AlwaysOffSampler(); + var AlwaysOnSampler_1 = require_AlwaysOnSampler(); + var ParentBasedSampler = class { + _root; + _remoteParentSampled; + _remoteParentNotSampled; + _localParentSampled; + _localParentNotSampled; + constructor(config) { + this._root = config.root; + if (!this._root) { + (0, core_1.globalErrorHandler)(new Error("ParentBasedSampler must have a root sampler configured")); + this._root = new AlwaysOnSampler_1.AlwaysOnSampler(); + } + this._remoteParentSampled = config.remoteParentSampled ?? new AlwaysOnSampler_1.AlwaysOnSampler(); + this._remoteParentNotSampled = config.remoteParentNotSampled ?? new AlwaysOffSampler_1.AlwaysOffSampler(); + this._localParentSampled = config.localParentSampled ?? new AlwaysOnSampler_1.AlwaysOnSampler(); + this._localParentNotSampled = config.localParentNotSampled ?? new AlwaysOffSampler_1.AlwaysOffSampler(); + } + shouldSample(context2, traceId, spanName, spanKind, attributes, links) { + const parentContext = api_1.trace.getSpanContext(context2); + if (!parentContext || !(0, api_1.isSpanContextValid)(parentContext)) { + return this._root.shouldSample(context2, traceId, spanName, spanKind, attributes, links); + } + if (parentContext.isRemote) { + if (parentContext.traceFlags & api_1.TraceFlags.SAMPLED) { + return this._remoteParentSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links); + } + return this._remoteParentNotSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links); + } + if (parentContext.traceFlags & api_1.TraceFlags.SAMPLED) { + return this._localParentSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links); + } + return this._localParentNotSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links); + } + toString() { + return `ParentBased{root=${this._root.toString()}, remoteParentSampled=${this._remoteParentSampled.toString()}, remoteParentNotSampled=${this._remoteParentNotSampled.toString()}, localParentSampled=${this._localParentSampled.toString()}, localParentNotSampled=${this._localParentNotSampled.toString()}}`; + } + }; + exports.ParentBasedSampler = ParentBasedSampler; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/export/SpanProcessorMetrics.js +var require_SpanProcessorMetrics = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/export/SpanProcessorMetrics.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SpanProcessorMetrics = void 0; + var semantic_conventions_1 = (init_esm2(), __toCommonJS(esm_exports2)); + var semconv_1 = require_semconv5(); + var componentCounter2 = /* @__PURE__ */ new Map(); + var SpanProcessorMetrics = class { + processedSpans; + queueSize; + queueSizeCallback; + standardAttrs; + droppedAttrs; + constructor(componentType, meter, queueConfig) { + const counter = componentCounter2.get(componentType) ?? 0; + componentCounter2.set(componentType, counter + 1); + this.standardAttrs = { + [semconv_1.ATTR_OTEL_COMPONENT_TYPE]: componentType, + [semconv_1.ATTR_OTEL_COMPONENT_NAME]: `${componentType}/${counter}` + }; + this.droppedAttrs = { + ...this.standardAttrs, + [semantic_conventions_1.ATTR_ERROR_TYPE]: "queue_full" + }; + this.processedSpans = meter.createCounter(semconv_1.METRIC_OTEL_SDK_PROCESSOR_SPAN_PROCESSED, { + unit: "{span}", + description: "The number of spans for which the processing has finished, either successful or failed." + }); + if (queueConfig) { + const { capacity, getQueueSize } = queueConfig; + const queueCapacity = meter.createUpDownCounter(semconv_1.METRIC_OTEL_SDK_PROCESSOR_SPAN_QUEUE_CAPACITY, { + unit: "{span}", + description: "The maximum number of spans the queue of a given instance of an SDK span processor can hold." + }); + queueCapacity.add(capacity, this.standardAttrs); + this.queueSize = meter.createObservableUpDownCounter(semconv_1.METRIC_OTEL_SDK_PROCESSOR_SPAN_QUEUE_SIZE, { + unit: "{span}", + description: "The number of spans in the queue of a given instance of an SDK span processor." + }); + this.queueSizeCallback = (result) => result.observe(getQueueSize(), this.standardAttrs); + this.queueSize.addCallback(this.queueSizeCallback); + } + } + dropSpans(count) { + this.processedSpans.add(count, this.droppedAttrs); + } + finishSpans(count, error) { + if (!error) { + this.processedSpans.add(count, this.standardAttrs); + return; + } + const attrs = { + ...this.standardAttrs, + [semantic_conventions_1.ATTR_ERROR_TYPE]: error.name + }; + this.processedSpans.add(count, attrs); + } + shutdown() { + if (this.queueSize && this.queueSizeCallback) { + this.queueSize.removeCallback(this.queueSizeCallback); + } + } + }; + exports.SpanProcessorMetrics = SpanProcessorMetrics; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/export/BatchSpanProcessorBase.js +var require_BatchSpanProcessorBase = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/export/BatchSpanProcessorBase.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.BatchSpanProcessorBase = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var core_1 = require_src(); + var SpanProcessorMetrics_1 = require_SpanProcessorMetrics(); + var semconv_1 = require_semconv5(); + var BatchSpanProcessorBase = class { + _maxExportBatchSize; + _maxQueueSize; + _scheduledDelayMillis; + _exportTimeoutMillis; + _exporter; + _metrics; + _isExporting = false; + _finishedSpans = []; + _timer; + _shutdownOnce; + _droppedSpansCount = 0; + constructor(options) { + this._exporter = options.exporter; + this._maxExportBatchSize = options.maxExportBatchSize ?? 512; + this._maxQueueSize = options.maxQueueSize ?? 2048; + this._scheduledDelayMillis = options.scheduledDelayMillis ?? 5e3; + this._exportTimeoutMillis = options.exportTimeoutMillis ?? 3e4; + this._shutdownOnce = new core_1.BindOnceFuture(this._shutdown, this); + if (this._maxExportBatchSize > this._maxQueueSize) { + api_1.diag.warn("BatchSpanProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize"); + this._maxExportBatchSize = this._maxQueueSize; + } + const meter = options.selfObsMeterProvider ? options.selfObsMeterProvider.getMeter("@opentelemetry/sdk-trace") : (0, api_1.createNoopMeter)(); + this._metrics = new SpanProcessorMetrics_1.SpanProcessorMetrics(semconv_1.OTEL_COMPONENT_TYPE_VALUE_BATCHING_SPAN_PROCESSOR, meter, { + capacity: this._maxQueueSize, + getQueueSize: () => this._finishedSpans.length + }); + } + forceFlush() { + if (this._shutdownOnce.isCalled) { + return this._shutdownOnce.promise; + } + return this._flushAll(); + } + // does nothing. + onStart(_span, _parentContext) { + } + onEnd(span) { + if (this._shutdownOnce.isCalled) { + return; + } + if ((span.spanContext().traceFlags & api_1.TraceFlags.SAMPLED) === 0) { + return; + } + this._addToBuffer(span); + } + shutdown() { + return this._shutdownOnce.call(); + } + _shutdown() { + return Promise.resolve().then(() => { + return this.onShutdown(); + }).then(() => { + return this._flushAll(); + }).then(() => { + this._metrics.shutdown(); + return this._exporter.shutdown(); + }); + } + /** Add a span in the buffer. */ + _addToBuffer(span) { + if (this._finishedSpans.length >= this._maxQueueSize) { + if (this._droppedSpansCount === 0) { + api_1.diag.debug("maxQueueSize reached, dropping spans"); + } + this._droppedSpansCount++; + this._metrics.dropSpans(1); + return; + } + if (this._droppedSpansCount > 0) { + api_1.diag.warn(`Dropped ${this._droppedSpansCount} spans because maxQueueSize reached`); + this._droppedSpansCount = 0; + } + this._finishedSpans.push(span); + this._maybeStartTimer(); + } + /** + * Send all spans to the exporter respecting the batch size limit + * This function is used only on forceFlush or shutdown, + * for all other cases _flush should be used + * */ + _flushAll() { + return new Promise((resolve2, reject) => { + const promises = []; + const count = Math.ceil(this._finishedSpans.length / this._maxExportBatchSize); + for (let i = 0, j = count; i < j; i++) { + promises.push(this._flushOneBatch()); + } + Promise.all(promises).then(() => { + resolve2(); + }).catch(reject); + }); + } + _flushOneBatch() { + this._clearTimer(); + if (this._finishedSpans.length === 0) { + return Promise.resolve(); + } + return new Promise((resolve2, reject) => { + const timer = setTimeout(() => { + reject(new Error("Timeout")); + }, this._exportTimeoutMillis); + api_1.context.with((0, core_1.suppressTracing)(api_1.context.active()), () => { + let spans; + if (this._finishedSpans.length <= this._maxExportBatchSize) { + spans = this._finishedSpans; + this._finishedSpans = []; + } else { + spans = this._finishedSpans.splice(0, this._maxExportBatchSize); + } + const doExport = () => this._exporter.export(spans, (result) => { + clearTimeout(timer); + this._metrics.finishSpans(spans.length, result.error); + if (result.code === core_1.ExportResultCode.SUCCESS) { + resolve2(); + } else { + reject(result.error ?? new Error("BatchSpanProcessor: span export failed")); + } + }); + let pendingResources = null; + for (let i = 0, len = spans.length; i < len; i++) { + const span = spans[i]; + if (span.resource.asyncAttributesPending && span.resource.waitForAsyncAttributes) { + pendingResources ??= []; + pendingResources.push(span.resource.waitForAsyncAttributes()); + } + } + if (pendingResources === null) { + doExport(); + } else { + Promise.all(pendingResources).then(doExport, (err) => { + (0, core_1.globalErrorHandler)(err); + reject(err); + }); + } + }); + }); + } + _maybeStartTimer() { + if (this._isExporting) + return; + const flush = () => { + this._isExporting = true; + this._flushOneBatch().finally(() => { + this._isExporting = false; + if (this._finishedSpans.length > 0) { + this._clearTimer(); + this._maybeStartTimer(); + } + }).catch((e) => { + this._isExporting = false; + (0, core_1.globalErrorHandler)(e); + }); + }; + if (this._finishedSpans.length >= this._maxExportBatchSize) { + return flush(); + } + if (this._timer !== void 0) + return; + this._timer = setTimeout(() => flush(), this._scheduledDelayMillis); + if (typeof this._timer !== "number") { + this._timer.unref(); + } + } + _clearTimer() { + if (this._timer !== void 0) { + clearTimeout(this._timer); + this._timer = void 0; + } + } + }; + exports.BatchSpanProcessorBase = BatchSpanProcessorBase; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/platform/node/export/BatchSpanProcessor.js +var require_BatchSpanProcessor = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/platform/node/export/BatchSpanProcessor.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.BatchSpanProcessor = void 0; + var BatchSpanProcessorBase_1 = require_BatchSpanProcessorBase(); + var BatchSpanProcessor2 = class extends BatchSpanProcessorBase_1.BatchSpanProcessorBase { + onShutdown() { + } + }; + exports.BatchSpanProcessor = BatchSpanProcessor2; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/platform/node/RandomIdGenerator.js +var require_RandomIdGenerator = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/platform/node/RandomIdGenerator.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.RandomIdGenerator = void 0; + var SPAN_ID_BYTES = 8; + var TRACE_ID_BYTES = 16; + var RandomIdGenerator = class { + /** + * Returns a random 16-byte trace ID formatted/encoded as a 32 lowercase hex + * characters corresponding to 128 bits. + */ + generateTraceId = getIdGenerator(TRACE_ID_BYTES); + /** + * Returns a random 8-byte span ID formatted/encoded as a 16 lowercase hex + * characters corresponding to 64 bits. + */ + generateSpanId = getIdGenerator(SPAN_ID_BYTES); + }; + exports.RandomIdGenerator = RandomIdGenerator; + var SHARED_BUFFER = Buffer.allocUnsafe(TRACE_ID_BYTES); + function getIdGenerator(bytes) { + return function generateId() { + for (let i = 0; i < bytes / 4; i++) { + SHARED_BUFFER.writeUInt32BE(Math.random() * 2 ** 32 >>> 0, i * 4); + } + for (let i = 0; i < bytes; i++) { + if (SHARED_BUFFER[i] > 0) { + break; + } else if (i === bytes - 1) { + SHARED_BUFFER[bytes - 1] = 1; + } + } + return SHARED_BUFFER.toString("hex", 0, bytes); + }; + } + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/platform/node/index.js +var require_node4 = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/platform/node/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.RandomIdGenerator = exports.BatchSpanProcessor = void 0; + var BatchSpanProcessor_1 = require_BatchSpanProcessor(); + Object.defineProperty(exports, "BatchSpanProcessor", { enumerable: true, get: function() { + return BatchSpanProcessor_1.BatchSpanProcessor; + } }); + var RandomIdGenerator_1 = require_RandomIdGenerator(); + Object.defineProperty(exports, "RandomIdGenerator", { enumerable: true, get: function() { + return RandomIdGenerator_1.RandomIdGenerator; + } }); + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/platform/index.js +var require_platform4 = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/platform/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.RandomIdGenerator = exports.BatchSpanProcessor = void 0; + var node_1 = require_node4(); + Object.defineProperty(exports, "BatchSpanProcessor", { enumerable: true, get: function() { + return node_1.BatchSpanProcessor; + } }); + Object.defineProperty(exports, "RandomIdGenerator", { enumerable: true, get: function() { + return node_1.RandomIdGenerator; + } }); + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/TracerProvider.js +var require_TracerProvider = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/TracerProvider.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.TracerProvider = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var resources_1 = require_src3(); + var Tracer_1 = require_Tracer(); + var MultiSpanProcessor_1 = require_MultiSpanProcessor(); + var ParentBasedSampler_1 = require_ParentBasedSampler(); + var AlwaysOnSampler_1 = require_AlwaysOnSampler(); + var platform_1 = require_platform4(); + var inspect_1 = require_inspect(); + var ForceFlushState; + (function(ForceFlushState2) { + ForceFlushState2[ForceFlushState2["resolved"] = 0] = "resolved"; + ForceFlushState2[ForceFlushState2["timeout"] = 1] = "timeout"; + ForceFlushState2[ForceFlushState2["error"] = 2] = "error"; + ForceFlushState2[ForceFlushState2["unresolved"] = 3] = "unresolved"; + })(ForceFlushState || (ForceFlushState = {})); + var TracerProvider = class { + _resource; + _activeSpanProcessor; + _forceFlushTimeoutMillis; + _tracerOptions; + _tracers = /* @__PURE__ */ new Map(); + constructor(options = {}) { + this._forceFlushTimeoutMillis = options.forceFlushTimeoutMillis ?? 3e4; + this._resource = options.resource ?? (0, resources_1.defaultResource)(); + const spanProcessors = options.spanProcessors ?? []; + this._activeSpanProcessor = new MultiSpanProcessor_1.MultiSpanProcessor(spanProcessors); + this._tracerOptions = { + resource: this._resource, + sampler: options.sampler ?? new ParentBasedSampler_1.ParentBasedSampler({ + root: new AlwaysOnSampler_1.AlwaysOnSampler() + }), + spanLimits: { + attributeCountLimit: options.spanLimits?.attributeCountLimit ?? 128, + attributeValueLengthLimit: options.spanLimits?.attributeValueLengthLimit ?? Infinity, + eventCountLimit: options.spanLimits?.eventCountLimit ?? 128, + linkCountLimit: options.spanLimits?.linkCountLimit ?? 128, + attributePerEventCountLimit: options.spanLimits?.attributePerEventCountLimit ?? 128, + attributePerLinkCountLimit: options.spanLimits?.attributePerLinkCountLimit ?? 128 + }, + idGenerator: options.idGenerator || new platform_1.RandomIdGenerator(), + spanProcessor: this._activeSpanProcessor, + meterProvider: options.meterProvider ?? { + getMeter() { + return (0, api_1.createNoopMeter)(); + } + } + }; + } + getTracer(name, version, options) { + const key = `${name}@${version || ""}:${options?.schemaUrl || ""}`; + if (!this._tracers.has(key)) { + this._tracers.set(key, new Tracer_1.Tracer({ name, version, schemaUrl: options?.schemaUrl }, this._tracerOptions)); + } + return this._tracers.get(key); + } + forceFlush(options) { + const timeout = options?.timeoutMillis ?? this._forceFlushTimeoutMillis; + const promises = this._activeSpanProcessor["_spanProcessors"].map((spanProcessor) => { + return new Promise((resolve2) => { + let state; + const timeoutInterval = setTimeout(() => { + resolve2(new Error(`Span processor did not completed within timeout period of ${timeout} ms`)); + state = ForceFlushState.timeout; + }, timeout); + spanProcessor.forceFlush().then(() => { + clearTimeout(timeoutInterval); + if (state !== ForceFlushState.timeout) { + state = ForceFlushState.resolved; + resolve2(state); + } + }).catch((error) => { + clearTimeout(timeoutInterval); + state = ForceFlushState.error; + resolve2(error); + }); + }); + }); + return new Promise((resolve2, reject) => { + Promise.all(promises).then((results) => { + const errors = results.filter((result) => result !== ForceFlushState.resolved); + if (errors.length > 0) { + reject(errors); + } else { + resolve2(); + } + }).catch((error) => reject([error])); + }); + } + shutdown() { + return this._activeSpanProcessor.shutdown(); + } + [inspect_1.inspectCustom](depth, options, inspect) { + const processors = this._activeSpanProcessor["_spanProcessors"]; + const payload = { + resource: { attributes: (0, inspect_1.settledResourceAttributes)(this._resource) }, + tracers: Array.from(this._tracers.keys()), + spanProcessors: processors.map((p) => p.constructor?.name ?? "SpanProcessor") + }; + return (0, inspect_1.formatInspect)("TracerProvider", payload, depth, options, inspect); + } + }; + exports.TracerProvider = TracerProvider; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/export/ConsoleSpanExporter.js +var require_ConsoleSpanExporter = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/export/ConsoleSpanExporter.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ConsoleSpanExporter = void 0; + var core_1 = require_src(); + var ConsoleSpanExporter = class { + /** + * Export spans. + * @param spans + * @param resultCallback + */ + export(spans, resultCallback) { + return this._sendSpans(spans, resultCallback); + } + /** + * Shutdown the exporter. + */ + shutdown() { + this._sendSpans([]); + return this.forceFlush(); + } + /** + * Exports any pending spans in exporter + */ + forceFlush() { + return Promise.resolve(); + } + /** + * converts span info into more readable format + * @param span + */ + _exportInfo(span) { + return { + resource: { + attributes: span.resource.attributes + }, + instrumentationScope: span.instrumentationScope, + traceId: span.spanContext().traceId, + parentSpanContext: span.parentSpanContext, + traceState: span.spanContext().traceState?.serialize(), + name: span.name, + id: span.spanContext().spanId, + kind: span.kind, + timestamp: (0, core_1.hrTimeToMicroseconds)(span.startTime), + duration: (0, core_1.hrTimeToMicroseconds)(span.duration), + attributes: span.attributes, + status: span.status, + events: span.events, + links: span.links + }; + } + /** + * Showing spans in console + * @param spans + * @param done + */ + _sendSpans(spans, done) { + for (const span of spans) { + console.dir(this._exportInfo(span), { depth: 3 }); + } + if (done) { + return done({ code: core_1.ExportResultCode.SUCCESS }); + } + } + }; + exports.ConsoleSpanExporter = ConsoleSpanExporter; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/export/InMemorySpanExporter.js +var require_InMemorySpanExporter = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/export/InMemorySpanExporter.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.InMemorySpanExporter = void 0; + var core_1 = require_src(); + var InMemorySpanExporter = class { + _finishedSpans = []; + /** + * Indicates if the exporter has been "shutdown." + * When false, exported spans will not be stored in-memory. + */ + _stopped = false; + export(spans, resultCallback) { + if (this._stopped) + return resultCallback({ + code: core_1.ExportResultCode.FAILED, + error: new Error("Exporter has been stopped") + }); + this._finishedSpans.push(...spans); + setTimeout(() => resultCallback({ code: core_1.ExportResultCode.SUCCESS }), 0); + } + shutdown() { + this._stopped = true; + this._finishedSpans = []; + return this.forceFlush(); + } + /** + * Exports any pending spans in the exporter + */ + forceFlush() { + return Promise.resolve(); + } + reset() { + this._finishedSpans = []; + } + getFinishedSpans() { + return this._finishedSpans; + } + }; + exports.InMemorySpanExporter = InMemorySpanExporter; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/export/SimpleSpanProcessor.js +var require_SimpleSpanProcessor = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/export/SimpleSpanProcessor.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SimpleSpanProcessor = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var core_1 = require_src(); + var SpanProcessorMetrics_1 = require_SpanProcessorMetrics(); + var semconv_1 = require_semconv5(); + var SimpleSpanProcessor2 = class { + _exporter; + _metrics; + _shutdownOnce; + _pendingExports; + constructor(options) { + this._exporter = options.exporter; + this._shutdownOnce = new core_1.BindOnceFuture(this._shutdown, this); + this._pendingExports = /* @__PURE__ */ new Set(); + const meter = options.selfObsMeterProvider ? options.selfObsMeterProvider.getMeter("@opentelemetry/sdk-trace") : (0, api_1.createNoopMeter)(); + this._metrics = new SpanProcessorMetrics_1.SpanProcessorMetrics(semconv_1.OTEL_COMPONENT_TYPE_VALUE_SIMPLE_SPAN_PROCESSOR, meter); + } + async forceFlush() { + let pendingExportError; + let pendingExportRejected = false; + try { + await Promise.all(Array.from(this._pendingExports)); + } catch (err) { + pendingExportError = err; + pendingExportRejected = true; + } + if (this._exporter.forceFlush) { + await this._exporter.forceFlush(); + } + if (pendingExportRejected) { + throw pendingExportError; + } + } + onStart(_span, _parentContext) { + } + onEnd(span) { + if (this._shutdownOnce.isCalled) { + return; + } + if ((span.spanContext().traceFlags & api_1.TraceFlags.SAMPLED) === 0) { + return; + } + const pendingExport = this._doExport(span); + this._pendingExports.add(pendingExport); + void pendingExport.then(() => { + this._pendingExports.delete(pendingExport); + }, (err) => { + (0, core_1.globalErrorHandler)(err); + this._pendingExports.delete(pendingExport); + }); + } + async _doExport(span) { + if (span.resource.asyncAttributesPending) { + await span.resource.waitForAsyncAttributes?.(); + } + const result = await core_1.internal._export(this._exporter, [span]); + this._metrics.finishSpans(1, result.error); + if (result.code !== core_1.ExportResultCode.SUCCESS) { + throw result.error ?? new Error(`SimpleSpanProcessor: span export failed (status ${result})`); + } + } + shutdown() { + return this._shutdownOnce.call(); + } + _shutdown() { + this._metrics.shutdown(); + return this._exporter.shutdown(); + } + }; + exports.SimpleSpanProcessor = SimpleSpanProcessor2; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/export/NoopSpanProcessor.js +var require_NoopSpanProcessor = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/export/NoopSpanProcessor.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.NoopSpanProcessor = void 0; + var NoopSpanProcessor = class { + onStart(_span, _context) { + } + onEnd(_span) { + } + shutdown() { + return Promise.resolve(); + } + forceFlush() { + return Promise.resolve(); + } + }; + exports.NoopSpanProcessor = NoopSpanProcessor; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/sampler/AlwaysRecordSampler.js +var require_AlwaysRecordSampler = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/sampler/AlwaysRecordSampler.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.createAlwaysRecordSampler = void 0; + var Sampler_1 = require_Sampler(); + function createAlwaysRecordSampler(delegate) { + if (!delegate) { + throw new Error("createAlwaysRecordSampler requires a delegate sampler"); + } + return { + shouldSample(context2, traceId, spanName, spanKind, attributes, links) { + const result = delegate.shouldSample(context2, traceId, spanName, spanKind, attributes, links); + if (result.decision === Sampler_1.SamplingDecision.NOT_RECORD) { + return { + decision: Sampler_1.SamplingDecision.RECORD, + attributes: result.attributes, + traceState: result.traceState + }; + } + return result; + }, + toString() { + return `AlwaysRecordSampler{${delegate.toString()}}`; + } + }; + } + exports.createAlwaysRecordSampler = createAlwaysRecordSampler; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/sampler/TraceIdRatioBasedSampler.js +var require_TraceIdRatioBasedSampler = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/sampler/TraceIdRatioBasedSampler.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.TraceIdRatioBasedSampler = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var Sampler_1 = require_Sampler(); + var TraceIdRatioBasedSampler = class { + _ratio; + _upperBound; + constructor(ratio = 0) { + this._ratio = this._normalize(ratio); + this._upperBound = this._ratio === 1 ? 4294967296 : Math.floor(this._ratio * 4294967295); + } + shouldSample(context2, traceId) { + return { + decision: (0, api_1.isValidTraceId)(traceId) && this._accumulate(traceId) < this._upperBound ? Sampler_1.SamplingDecision.RECORD_AND_SAMPLED : Sampler_1.SamplingDecision.NOT_RECORD + }; + } + toString() { + return `TraceIdRatioBased{${this._ratio}}`; + } + _normalize(ratio) { + if (typeof ratio !== "number" || isNaN(ratio)) + return 0; + return ratio >= 1 ? 1 : ratio <= 0 ? 0 : ratio; + } + _accumulate(traceId) { + let accumulation = 0; + for (let i = 0; i < 32; i += 8) { + let part = 0; + for (let j = 0; j < 8; j++) { + const c = traceId.charCodeAt(i + j); + const v = c < 58 ? c - 48 : c < 71 ? c - 55 : c - 87; + part = part << 4 | v; + } + accumulation = (accumulation ^ part) >>> 0; + } + return accumulation; + } + }; + exports.TraceIdRatioBasedSampler = TraceIdRatioBasedSampler; + } +}); + +// node_modules/@opentelemetry/sdk-trace/build/src/index.js +var require_src7 = __commonJS({ + "node_modules/@opentelemetry/sdk-trace/build/src/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SamplingDecision = exports.TraceIdRatioBasedSampler = exports.ParentBasedSampler = exports.createAlwaysRecordSampler = exports.AlwaysOnSampler = exports.AlwaysOffSampler = exports.NoopSpanProcessor = exports.SimpleSpanProcessor = exports.InMemorySpanExporter = exports.ConsoleSpanExporter = exports.RandomIdGenerator = exports.BatchSpanProcessor = exports.TracerProvider = void 0; + var TracerProvider_1 = require_TracerProvider(); + Object.defineProperty(exports, "TracerProvider", { enumerable: true, get: function() { + return TracerProvider_1.TracerProvider; + } }); + var platform_1 = require_platform4(); + Object.defineProperty(exports, "BatchSpanProcessor", { enumerable: true, get: function() { + return platform_1.BatchSpanProcessor; + } }); + Object.defineProperty(exports, "RandomIdGenerator", { enumerable: true, get: function() { + return platform_1.RandomIdGenerator; + } }); + var ConsoleSpanExporter_1 = require_ConsoleSpanExporter(); + Object.defineProperty(exports, "ConsoleSpanExporter", { enumerable: true, get: function() { + return ConsoleSpanExporter_1.ConsoleSpanExporter; + } }); + var InMemorySpanExporter_1 = require_InMemorySpanExporter(); + Object.defineProperty(exports, "InMemorySpanExporter", { enumerable: true, get: function() { + return InMemorySpanExporter_1.InMemorySpanExporter; + } }); + var SimpleSpanProcessor_1 = require_SimpleSpanProcessor(); + Object.defineProperty(exports, "SimpleSpanProcessor", { enumerable: true, get: function() { + return SimpleSpanProcessor_1.SimpleSpanProcessor; + } }); + var NoopSpanProcessor_1 = require_NoopSpanProcessor(); + Object.defineProperty(exports, "NoopSpanProcessor", { enumerable: true, get: function() { + return NoopSpanProcessor_1.NoopSpanProcessor; + } }); + var AlwaysOffSampler_1 = require_AlwaysOffSampler(); + Object.defineProperty(exports, "AlwaysOffSampler", { enumerable: true, get: function() { + return AlwaysOffSampler_1.AlwaysOffSampler; + } }); + var AlwaysOnSampler_1 = require_AlwaysOnSampler(); + Object.defineProperty(exports, "AlwaysOnSampler", { enumerable: true, get: function() { + return AlwaysOnSampler_1.AlwaysOnSampler; + } }); + var AlwaysRecordSampler_1 = require_AlwaysRecordSampler(); + Object.defineProperty(exports, "createAlwaysRecordSampler", { enumerable: true, get: function() { + return AlwaysRecordSampler_1.createAlwaysRecordSampler; + } }); + var ParentBasedSampler_1 = require_ParentBasedSampler(); + Object.defineProperty(exports, "ParentBasedSampler", { enumerable: true, get: function() { + return ParentBasedSampler_1.ParentBasedSampler; + } }); + var TraceIdRatioBasedSampler_1 = require_TraceIdRatioBasedSampler(); + Object.defineProperty(exports, "TraceIdRatioBasedSampler", { enumerable: true, get: function() { + return TraceIdRatioBasedSampler_1.TraceIdRatioBasedSampler; + } }); + var Sampler_1 = require_Sampler(); + Object.defineProperty(exports, "SamplingDecision", { enumerable: true, get: function() { + return Sampler_1.SamplingDecision; + } }); + } +}); + +// node_modules/@opentelemetry/sdk-trace-base/build/src/config.js +var require_config = __commonJS({ + "node_modules/@opentelemetry/sdk-trace-base/build/src/config.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.buildSamplerFromEnv = exports.loadDefaultConfig = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var core_1 = require_src(); + var sdk_trace_1 = require_src7(); + var TracesSamplerValues; + (function(TracesSamplerValues2) { + TracesSamplerValues2["AlwaysOff"] = "always_off"; + TracesSamplerValues2["AlwaysOn"] = "always_on"; + TracesSamplerValues2["ParentBasedAlwaysOff"] = "parentbased_always_off"; + TracesSamplerValues2["ParentBasedAlwaysOn"] = "parentbased_always_on"; + TracesSamplerValues2["ParentBasedTraceIdRatio"] = "parentbased_traceidratio"; + TracesSamplerValues2["TraceIdRatio"] = "traceidratio"; + })(TracesSamplerValues || (TracesSamplerValues = {})); + var DEFAULT_RATIO = 1; + function loadDefaultConfig() { + return { + sampler: buildSamplerFromEnv(), + forceFlushTimeoutMillis: 3e4, + generalLimits: { + attributeValueLengthLimit: (0, core_1.getNumberFromEnv)("OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? Infinity, + attributeCountLimit: (0, core_1.getNumberFromEnv)("OTEL_ATTRIBUTE_COUNT_LIMIT") ?? 128 + }, + spanLimits: { + attributeValueLengthLimit: (0, core_1.getNumberFromEnv)("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? Infinity, + attributeCountLimit: (0, core_1.getNumberFromEnv)("OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT") ?? 128, + linkCountLimit: (0, core_1.getNumberFromEnv)("OTEL_SPAN_LINK_COUNT_LIMIT") ?? 128, + eventCountLimit: (0, core_1.getNumberFromEnv)("OTEL_SPAN_EVENT_COUNT_LIMIT") ?? 128, + attributePerEventCountLimit: (0, core_1.getNumberFromEnv)("OTEL_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT") ?? 128, + attributePerLinkCountLimit: (0, core_1.getNumberFromEnv)("OTEL_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT") ?? 128 + } + }; + } + exports.loadDefaultConfig = loadDefaultConfig; + function buildSamplerFromEnv() { + const sampler = (0, core_1.getStringFromEnv)("OTEL_TRACES_SAMPLER") ?? TracesSamplerValues.ParentBasedAlwaysOn; + switch (sampler) { + case TracesSamplerValues.AlwaysOn: + return new sdk_trace_1.AlwaysOnSampler(); + case TracesSamplerValues.AlwaysOff: + return new sdk_trace_1.AlwaysOffSampler(); + case TracesSamplerValues.ParentBasedAlwaysOn: + return new sdk_trace_1.ParentBasedSampler({ + root: new sdk_trace_1.AlwaysOnSampler() + }); + case TracesSamplerValues.ParentBasedAlwaysOff: + return new sdk_trace_1.ParentBasedSampler({ + root: new sdk_trace_1.AlwaysOffSampler() + }); + case TracesSamplerValues.TraceIdRatio: + return new sdk_trace_1.TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv()); + case TracesSamplerValues.ParentBasedTraceIdRatio: + return new sdk_trace_1.ParentBasedSampler({ + root: new sdk_trace_1.TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv()) + }); + default: + api_1.diag.error(`OTEL_TRACES_SAMPLER value "${sampler}" invalid, defaulting to "${TracesSamplerValues.ParentBasedAlwaysOn}".`); + return new sdk_trace_1.ParentBasedSampler({ + root: new sdk_trace_1.AlwaysOnSampler() + }); + } + } + exports.buildSamplerFromEnv = buildSamplerFromEnv; + function getSamplerProbabilityFromEnv() { + const probability = (0, core_1.getNumberFromEnv)("OTEL_TRACES_SAMPLER_ARG"); + if (probability == null) { + api_1.diag.error(`OTEL_TRACES_SAMPLER_ARG is blank, defaulting to ${DEFAULT_RATIO}.`); + return DEFAULT_RATIO; + } + if (probability < 0 || probability > 1) { + api_1.diag.error(`OTEL_TRACES_SAMPLER_ARG=${probability} was given, but it is out of range ([0..1]), defaulting to ${DEFAULT_RATIO}.`); + return DEFAULT_RATIO; + } + return probability; + } + } +}); + +// node_modules/@opentelemetry/sdk-trace-base/build/src/utility.js +var require_utility = __commonJS({ + "node_modules/@opentelemetry/sdk-trace-base/build/src/utility.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.reconfigureLimits = exports.DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT = exports.DEFAULT_ATTRIBUTE_COUNT_LIMIT = void 0; + var core_1 = require_src(); + exports.DEFAULT_ATTRIBUTE_COUNT_LIMIT = 128; + exports.DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT = Infinity; + function reconfigureLimits(userConfig2) { + const spanLimits = Object.assign({}, userConfig2.spanLimits); + spanLimits.attributeCountLimit = userConfig2.spanLimits?.attributeCountLimit ?? userConfig2.generalLimits?.attributeCountLimit ?? (0, core_1.getNumberFromEnv)("OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT") ?? (0, core_1.getNumberFromEnv)("OTEL_ATTRIBUTE_COUNT_LIMIT") ?? exports.DEFAULT_ATTRIBUTE_COUNT_LIMIT; + spanLimits.attributeValueLengthLimit = userConfig2.spanLimits?.attributeValueLengthLimit ?? userConfig2.generalLimits?.attributeValueLengthLimit ?? (0, core_1.getNumberFromEnv)("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? (0, core_1.getNumberFromEnv)("OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? exports.DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT; + return Object.assign({}, userConfig2, { spanLimits }); + } + exports.reconfigureLimits = reconfigureLimits; + } +}); + +// node_modules/@opentelemetry/sdk-trace-base/build/src/BasicTracerProvider-shim.js +var require_BasicTracerProvider_shim = __commonJS({ + "node_modules/@opentelemetry/sdk-trace-base/build/src/BasicTracerProvider-shim.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.BasicTracerProvider = void 0; + var core_1 = require_src(); + var config_1 = require_config(); + var utility_1 = require_utility(); + var sdk_trace_1 = require_src7(); + var BasicTracerProvider = class extends sdk_trace_1.TracerProvider { + constructor(config = {}) { + const mergedConfig = (0, core_1.merge)({}, (0, config_1.loadDefaultConfig)(), (0, utility_1.reconfigureLimits)(config)); + delete mergedConfig.generalLimits; + super(mergedConfig); + } + }; + exports.BasicTracerProvider = BasicTracerProvider; + } +}); + +// node_modules/@opentelemetry/sdk-trace-base/build/src/BatchSpanProcessor-shim.js +var require_BatchSpanProcessor_shim = __commonJS({ + "node_modules/@opentelemetry/sdk-trace-base/build/src/BatchSpanProcessor-shim.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.BatchSpanProcessor = void 0; + var core_1 = require_src(); + var sdk_trace_1 = require_src7(); + var BatchSpanProcessor2 = class extends sdk_trace_1.BatchSpanProcessor { + constructor(exporter, config) { + if (!config) { + config = {}; + } + const envFallbacks = [ + ["maxExportBatchSize", "OTEL_BSP_MAX_EXPORT_BATCH_SIZE"], + ["maxQueueSize", "OTEL_BSP_MAX_QUEUE_SIZE"], + ["scheduledDelayMillis", "OTEL_BSP_SCHEDULE_DELAY"], + ["exportTimeoutMillis", "OTEL_BSP_EXPORT_TIMEOUT"] + ]; + for (const [configName, envName] of envFallbacks) { + if (config[configName] === void 0) { + const envFallback = (0, core_1.getNumberFromEnv)(envName); + if (envFallback !== void 0) { + config[configName] = envFallback; + } + } + } + super({ exporter, ...config }); + } + }; + exports.BatchSpanProcessor = BatchSpanProcessor2; + } +}); + +// node_modules/@opentelemetry/sdk-trace-base/build/src/SimpleSpanProcessor-shim.js +var require_SimpleSpanProcessor_shim = __commonJS({ + "node_modules/@opentelemetry/sdk-trace-base/build/src/SimpleSpanProcessor-shim.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SimpleSpanProcessor = void 0; + var sdk_trace_1 = require_src7(); + var SimpleSpanProcessor2 = class extends sdk_trace_1.SimpleSpanProcessor { + constructor(exporter) { + super({ exporter }); + } + }; + exports.SimpleSpanProcessor = SimpleSpanProcessor2; + } +}); + +// node_modules/@opentelemetry/sdk-trace-base/build/src/index-shim.js +var require_index_shim = __commonJS({ + "node_modules/@opentelemetry/sdk-trace-base/build/src/index-shim.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.SamplingDecision = exports.TraceIdRatioBasedSampler = exports.ParentBasedSampler = exports.AlwaysOnSampler = exports.AlwaysOffSampler = exports.NoopSpanProcessor = exports.InMemorySpanExporter = exports.RandomIdGenerator = exports.ConsoleSpanExporter = exports.SimpleSpanProcessor = exports.BatchSpanProcessor = exports.BasicTracerProvider = void 0; + var BasicTracerProvider_shim_1 = require_BasicTracerProvider_shim(); + Object.defineProperty(exports, "BasicTracerProvider", { enumerable: true, get: function() { + return BasicTracerProvider_shim_1.BasicTracerProvider; + } }); + var BatchSpanProcessor_shim_1 = require_BatchSpanProcessor_shim(); + Object.defineProperty(exports, "BatchSpanProcessor", { enumerable: true, get: function() { + return BatchSpanProcessor_shim_1.BatchSpanProcessor; + } }); + var SimpleSpanProcessor_shim_1 = require_SimpleSpanProcessor_shim(); + Object.defineProperty(exports, "SimpleSpanProcessor", { enumerable: true, get: function() { + return SimpleSpanProcessor_shim_1.SimpleSpanProcessor; + } }); + var sdk_trace_1 = require_src7(); + Object.defineProperty(exports, "ConsoleSpanExporter", { enumerable: true, get: function() { + return sdk_trace_1.ConsoleSpanExporter; + } }); + Object.defineProperty(exports, "RandomIdGenerator", { enumerable: true, get: function() { + return sdk_trace_1.RandomIdGenerator; + } }); + Object.defineProperty(exports, "InMemorySpanExporter", { enumerable: true, get: function() { + return sdk_trace_1.InMemorySpanExporter; + } }); + Object.defineProperty(exports, "NoopSpanProcessor", { enumerable: true, get: function() { + return sdk_trace_1.NoopSpanProcessor; + } }); + Object.defineProperty(exports, "AlwaysOffSampler", { enumerable: true, get: function() { + return sdk_trace_1.AlwaysOffSampler; + } }); + Object.defineProperty(exports, "AlwaysOnSampler", { enumerable: true, get: function() { + return sdk_trace_1.AlwaysOnSampler; + } }); + Object.defineProperty(exports, "ParentBasedSampler", { enumerable: true, get: function() { + return sdk_trace_1.ParentBasedSampler; + } }); + Object.defineProperty(exports, "TraceIdRatioBasedSampler", { enumerable: true, get: function() { + return sdk_trace_1.TraceIdRatioBasedSampler; + } }); + Object.defineProperty(exports, "SamplingDecision", { enumerable: true, get: function() { + return sdk_trace_1.SamplingDecision; + } }); + } +}); + +// node_modules/@opentelemetry/context-async-hooks/build/src/AbstractAsyncHooksContextManager.js +var require_AbstractAsyncHooksContextManager = __commonJS({ + "node_modules/@opentelemetry/context-async-hooks/build/src/AbstractAsyncHooksContextManager.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.AbstractAsyncHooksContextManager = void 0; + var events_1 = __require("events"); + var ADD_LISTENER_METHODS = [ + "addListener", + "on", + "once", + "prependListener", + "prependOnceListener" + ]; + var AbstractAsyncHooksContextManager = class { + /** + * Binds a the certain context or the active one to the target function and then returns the target + * @param context A context (span) to be bind to target + * @param target a function or event emitter. When target or one of its callbacks is called, + * the provided context will be used as the active context for the duration of the call. + */ + bind(context2, target) { + if (target instanceof events_1.EventEmitter) { + return this._bindEventEmitter(context2, target); + } + if (typeof target === "function") { + return this._bindFunction(context2, target); + } + return target; + } + _bindFunction(context2, target) { + const manager = this; + const contextWrapper = function(...args) { + return manager.with(context2, () => target.apply(this, args)); + }; + Object.defineProperty(contextWrapper, "length", { + enumerable: false, + configurable: true, + writable: false, + value: target.length + }); + return contextWrapper; + } + /** + * By default, EventEmitter call their callback with their context, which we do + * not want, instead we will bind a specific context to all callbacks that + * go through it. + * @param context the context we want to bind + * @param ee EventEmitter an instance of EventEmitter to patch + */ + _bindEventEmitter(context2, ee) { + const map = this._getPatchMap(ee); + if (map !== void 0) + return ee; + this._createPatchMap(ee); + ADD_LISTENER_METHODS.forEach((methodName) => { + if (ee[methodName] === void 0) + return; + ee[methodName] = this._patchAddListener(ee, ee[methodName], context2); + }); + if (typeof ee.removeListener === "function") { + ee.removeListener = this._patchRemoveListener(ee, ee.removeListener); + } + if (typeof ee.off === "function") { + ee.off = this._patchRemoveListener(ee, ee.off); + } + if (typeof ee.removeAllListeners === "function") { + ee.removeAllListeners = this._patchRemoveAllListeners(ee, ee.removeAllListeners); + } + return ee; + } + /** + * Patch methods that remove a given listener so that we match the "patched" + * version of that listener (the one that propagate context). + * @param ee EventEmitter instance + * @param original reference to the patched method + */ + _patchRemoveListener(ee, original) { + const contextManager = this; + return function(event, listener) { + const events = contextManager._getPatchMap(ee)?.[event]; + if (events === void 0) { + return original.call(this, event, listener); + } + const patchedListener = events.get(listener); + return original.call(this, event, patchedListener || listener); + }; + } + /** + * Patch methods that remove all listeners so we remove our + * internal references for a given event. + * @param ee EventEmitter instance + * @param original reference to the patched method + */ + _patchRemoveAllListeners(ee, original) { + const contextManager = this; + return function(event) { + const map = contextManager._getPatchMap(ee); + if (map !== void 0) { + if (arguments.length === 0) { + contextManager._createPatchMap(ee); + } else if (map[event] !== void 0) { + delete map[event]; + } + } + return original.apply(this, arguments); + }; + } + /** + * Patch methods on an event emitter instance that can add listeners so we + * can force them to propagate a given context. + * @param ee EventEmitter instance + * @param original reference to the patched method + * @param [context] context to propagate when calling listeners + */ + _patchAddListener(ee, original, context2) { + const contextManager = this; + return function(event, listener) { + if (contextManager._wrapped) { + return original.call(this, event, listener); + } + let map = contextManager._getPatchMap(ee); + if (map === void 0) { + map = contextManager._createPatchMap(ee); + } + let listeners = map[event]; + if (listeners === void 0) { + listeners = /* @__PURE__ */ new WeakMap(); + map[event] = listeners; + } + const patchedListener = contextManager.bind(context2, listener); + listeners.set(listener, patchedListener); + contextManager._wrapped = true; + try { + return original.call(this, event, patchedListener); + } finally { + contextManager._wrapped = false; + } + }; + } + _createPatchMap(ee) { + const map = /* @__PURE__ */ Object.create(null); + ee[this._kOtListeners] = map; + return map; + } + _getPatchMap(ee) { + return ee[this._kOtListeners]; + } + _kOtListeners = /* @__PURE__ */ Symbol("OtListeners"); + _wrapped = false; + }; + exports.AbstractAsyncHooksContextManager = AbstractAsyncHooksContextManager; + } +}); + +// node_modules/@opentelemetry/context-async-hooks/build/src/AsyncHooksContextManager.js +var require_AsyncHooksContextManager = __commonJS({ + "node_modules/@opentelemetry/context-async-hooks/build/src/AsyncHooksContextManager.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.AsyncHooksContextManager = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var asyncHooks = __require("async_hooks"); + var AbstractAsyncHooksContextManager_1 = require_AbstractAsyncHooksContextManager(); + var AsyncHooksContextManager = class extends AbstractAsyncHooksContextManager_1.AbstractAsyncHooksContextManager { + _asyncHook; + _contexts = /* @__PURE__ */ new Map(); + _stack = []; + constructor() { + super(); + this._asyncHook = asyncHooks.createHook({ + init: this._init.bind(this), + before: this._before.bind(this), + after: this._after.bind(this), + destroy: this._destroy.bind(this), + promiseResolve: this._destroy.bind(this) + }); + } + active() { + return this._stack[this._stack.length - 1] ?? api_1.ROOT_CONTEXT; + } + with(context2, fn, thisArg, ...args) { + this._enterContext(context2); + try { + return fn.call(thisArg, ...args); + } finally { + this._exitContext(); + } + } + enable() { + this._asyncHook.enable(); + return this; + } + disable() { + this._asyncHook.disable(); + this._contexts.clear(); + this._stack = []; + return this; + } + /** + * Init hook will be called when userland create a async context, setting the + * context as the current one if it exist. + * @param uid id of the async context + * @param type the resource type + */ + _init(uid, type) { + if (type === "TIMERWRAP") + return; + const context2 = this._stack[this._stack.length - 1]; + if (context2 !== void 0) { + this._contexts.set(uid, context2); + } + } + /** + * Destroy hook will be called when a given context is no longer used so we can + * remove its attached context. + * @param uid uid of the async context + */ + _destroy(uid) { + this._contexts.delete(uid); + } + /** + * Before hook is called just before executing a async context. + * @param uid uid of the async context + */ + _before(uid) { + const context2 = this._contexts.get(uid); + if (context2 !== void 0) { + this._enterContext(context2); + } + } + /** + * After hook is called just after completing the execution of a async context. + */ + _after() { + this._exitContext(); + } + /** + * Set the given context as active + */ + _enterContext(context2) { + this._stack.push(context2); + } + /** + * Remove the context at the root of the stack + */ + _exitContext() { + this._stack.pop(); + } + }; + exports.AsyncHooksContextManager = AsyncHooksContextManager; + } +}); + +// node_modules/@opentelemetry/context-async-hooks/build/src/AsyncLocalStorageContextManager.js +var require_AsyncLocalStorageContextManager = __commonJS({ + "node_modules/@opentelemetry/context-async-hooks/build/src/AsyncLocalStorageContextManager.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.AsyncLocalStorageContextManager = void 0; + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var async_hooks_1 = __require("async_hooks"); + var AbstractAsyncHooksContextManager_1 = require_AbstractAsyncHooksContextManager(); + var DisposeOnceToken = class { + _isDisposed = false; + _previousContext; + _asyncLocalStorage; + constructor(previousContext, asyncLocalStorage) { + this._previousContext = previousContext; + this._asyncLocalStorage = asyncLocalStorage; + } + dispose() { + if (this._isDisposed) { + return; + } + this._asyncLocalStorage.enterWith(this._previousContext); + this._isDisposed = true; + } + }; + var AsyncLocalStorageContextManager = class extends AbstractAsyncHooksContextManager_1.AbstractAsyncHooksContextManager { + _asyncLocalStorage; + constructor() { + super(); + this._asyncLocalStorage = new async_hooks_1.AsyncLocalStorage(); + } + active() { + return this._asyncLocalStorage.getStore() ?? api_1.ROOT_CONTEXT; + } + with(context2, fn, thisArg, ...args) { + const cb = thisArg == null ? fn : fn.bind(thisArg); + return this._asyncLocalStorage.run(context2, cb, ...args); + } + enable() { + return this; + } + disable() { + this._asyncLocalStorage.disable(); + return this; + } + /** + * Imperatively sets `context` as active for the current async execution chain + * and operations spawned from it. Returns a {@link ContextManagementToken} whose `dispose()` + * restores the previous context (see {@link ContextManager.attach}). + * + * On Node.js 25.9+, delegates to `AsyncLocalStorage.withScope()` which returns + * a native `RunScope`. On older Node.js versions, falls back to `enterWith()` with + * a manual token. + * + * **Caveat for async functions:** Both `withScope()` and `enterWith()` affect the + * entire current async execution chain. If `attach()` is called inside an async + * function before the first `await`, the context change will leak into the caller's + * context and remain active there until something else restores it. Prefer `with()` + * for async code. + * + * @experimental This API is experimental and may change in minor releases without prior notice. + */ + attach(context2) { + const withScope = this._asyncLocalStorage.withScope; + if (withScope) { + return withScope.call(this._asyncLocalStorage, context2); + } + const previousContext = this.active(); + this._asyncLocalStorage.enterWith(context2); + return new DisposeOnceToken(previousContext, this._asyncLocalStorage); + } + }; + exports.AsyncLocalStorageContextManager = AsyncLocalStorageContextManager; + } +}); + +// node_modules/@opentelemetry/context-async-hooks/build/src/index.js +var require_src8 = __commonJS({ + "node_modules/@opentelemetry/context-async-hooks/build/src/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.AsyncLocalStorageContextManager = exports.AsyncHooksContextManager = void 0; + var AsyncHooksContextManager_1 = require_AsyncHooksContextManager(); + Object.defineProperty(exports, "AsyncHooksContextManager", { enumerable: true, get: function() { + return AsyncHooksContextManager_1.AsyncHooksContextManager; + } }); + var AsyncLocalStorageContextManager_1 = require_AsyncLocalStorageContextManager(); + Object.defineProperty(exports, "AsyncLocalStorageContextManager", { enumerable: true, get: function() { + return AsyncLocalStorageContextManager_1.AsyncLocalStorageContextManager; + } }); + } +}); + +// node_modules/@opentelemetry/sdk-trace-node/build/src/NodeTracerProvider.js +var require_NodeTracerProvider = __commonJS({ + "node_modules/@opentelemetry/sdk-trace-node/build/src/NodeTracerProvider.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.NodeTracerProvider = void 0; + var context_async_hooks_1 = require_src8(); + var sdk_trace_base_1 = require_index_shim(); + var api_1 = (init_esm(), __toCommonJS(esm_exports)); + var core_1 = require_src(); + function setupContextManager(contextManager) { + if (contextManager === null) { + return; + } + if (contextManager === void 0) { + const defaultContextManager = new context_async_hooks_1.AsyncLocalStorageContextManager(); + defaultContextManager.enable(); + api_1.context.setGlobalContextManager(defaultContextManager); + return; + } + contextManager.enable(); + api_1.context.setGlobalContextManager(contextManager); + } + function setupPropagator(propagator) { + if (propagator === null) { + return; + } + if (propagator === void 0) { + api_1.propagation.setGlobalPropagator(new core_1.CompositePropagator({ + propagators: [ + new core_1.W3CTraceContextPropagator(), + new core_1.W3CBaggagePropagator() + ] + })); + return; + } + api_1.propagation.setGlobalPropagator(propagator); + } + var NodeTracerProvider2 = class extends sdk_trace_base_1.BasicTracerProvider { + constructor(config = {}) { + super(config); + } + /** + * Register this TracerProvider for use with the OpenTelemetry API. + * Undefined values may be replaced with defaults, and + * null values will be skipped. + * + * @param config Configuration object for SDK registration + */ + register(config = {}) { + api_1.trace.setGlobalTracerProvider(this); + setupContextManager(config.contextManager); + setupPropagator(config.propagator); + } + }; + exports.NodeTracerProvider = NodeTracerProvider2; + } +}); + +// node_modules/@opentelemetry/sdk-trace-node/build/src/index.js +var require_src9 = __commonJS({ + "node_modules/@opentelemetry/sdk-trace-node/build/src/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.TraceIdRatioBasedSampler = exports.SimpleSpanProcessor = exports.SamplingDecision = exports.RandomIdGenerator = exports.ParentBasedSampler = exports.NoopSpanProcessor = exports.InMemorySpanExporter = exports.ConsoleSpanExporter = exports.BatchSpanProcessor = exports.BasicTracerProvider = exports.AlwaysOnSampler = exports.AlwaysOffSampler = exports.NodeTracerProvider = void 0; + var NodeTracerProvider_1 = require_NodeTracerProvider(); + Object.defineProperty(exports, "NodeTracerProvider", { enumerable: true, get: function() { + return NodeTracerProvider_1.NodeTracerProvider; + } }); + var sdk_trace_base_1 = require_index_shim(); + Object.defineProperty(exports, "AlwaysOffSampler", { enumerable: true, get: function() { + return sdk_trace_base_1.AlwaysOffSampler; + } }); + Object.defineProperty(exports, "AlwaysOnSampler", { enumerable: true, get: function() { + return sdk_trace_base_1.AlwaysOnSampler; + } }); + Object.defineProperty(exports, "BasicTracerProvider", { enumerable: true, get: function() { + return sdk_trace_base_1.BasicTracerProvider; + } }); + Object.defineProperty(exports, "BatchSpanProcessor", { enumerable: true, get: function() { + return sdk_trace_base_1.BatchSpanProcessor; + } }); + Object.defineProperty(exports, "ConsoleSpanExporter", { enumerable: true, get: function() { + return sdk_trace_base_1.ConsoleSpanExporter; + } }); + Object.defineProperty(exports, "InMemorySpanExporter", { enumerable: true, get: function() { + return sdk_trace_base_1.InMemorySpanExporter; + } }); + Object.defineProperty(exports, "NoopSpanProcessor", { enumerable: true, get: function() { + return sdk_trace_base_1.NoopSpanProcessor; + } }); + Object.defineProperty(exports, "ParentBasedSampler", { enumerable: true, get: function() { + return sdk_trace_base_1.ParentBasedSampler; + } }); + Object.defineProperty(exports, "RandomIdGenerator", { enumerable: true, get: function() { + return sdk_trace_base_1.RandomIdGenerator; + } }); + Object.defineProperty(exports, "SamplingDecision", { enumerable: true, get: function() { + return sdk_trace_base_1.SamplingDecision; + } }); + Object.defineProperty(exports, "SimpleSpanProcessor", { enumerable: true, get: function() { + return sdk_trace_base_1.SimpleSpanProcessor; + } }); + Object.defineProperty(exports, "TraceIdRatioBasedSampler", { enumerable: true, get: function() { + return sdk_trace_base_1.TraceIdRatioBasedSampler; + } }); + } +}); + +// src/hooks/entry.ts +import { randomUUID as randomUUID2 } from "node:crypto"; + +// src/application/config.ts +import { readFileSync } from "node:fs"; +import { homedir } from "node:os"; +import { join } from "node:path"; +var DEFAULT_BASE_URL = "https://cloud.langfuse.com"; +var DEFAULT_RELEASE = "0.3.0"; +var DEFAULT_MAX_CAPTURE_CHARS = 2e4; +var DEFAULT_MAX_MEDIA_CHARS = 4e6; +function asText(value) { + if (value === void 0) return void 0; + return typeof value === "string" ? value : String(value); +} +function firstNonEmpty(...values) { + return values.map(asText).find((value) => value !== void 0 && value.trim().length > 0)?.trim(); +} +function userConfig(env, name) { + const normalized = name.toUpperCase(); + return firstNonEmpty( + env[`ZCODE_USER_CONFIG_${normalized}`], + env[`ZCODE_PLUGIN_CONFIG_${normalized}`] + ); +} +function isStoredOption(value) { + return typeof value === "string" || typeof value === "number" || typeof value === "boolean"; +} +function parseStoredOptions(value) { + if (typeof value !== "object" || value === null || Array.isArray(value)) + return {}; + const options = {}; + for (const [key, option2] of Object.entries(value)) { + if (isStoredOption(option2)) options[key] = option2; + } + return options; +} +function readStoredOptions(env) { + const configPaths = [ + env.ZCODE_CONFIG_PATH, + join(homedir(), ".zcode", "cli", "config.json") + ].filter((path2) => Boolean(path2)); + const configuredPluginId = env.ZCODE_PLUGIN_ID; + for (const configPath of configPaths) { + try { + const parsed = JSON.parse(readFileSync(configPath, "utf8")); + if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) + continue; + const plugins = parsed.plugins; + if (typeof plugins !== "object" || plugins === null || Array.isArray(plugins)) + continue; + const options = plugins.options; + if (typeof options !== "object" || options === null || Array.isArray(options)) + continue; + const optionEntries = options; + if (configuredPluginId && optionEntries[configuredPluginId]) { + return parseStoredOptions(optionEntries[configuredPluginId]); + } + } catch { + } + } + return {}; +} +function option(env, storedOptions, name, environmentName) { + return firstNonEmpty( + userConfig(env, name), + env[environmentName], + storedOptions[name] + ); +} +function parseBoolean(value, fallback) { + if (!value) return fallback; + if (["1", "true", "yes", "on"].includes(value.toLowerCase())) return true; + if (["0", "false", "no", "off"].includes(value.toLowerCase())) return false; + return fallback; +} +function parsePositiveInteger(value, fallback) { + if (!value) return fallback; + const parsed = Number.parseInt(value, 10); + if (!Number.isFinite(parsed) || parsed <= 0) return fallback; + return Math.min(parsed, 1e6); +} +function parseMediaChars(value, fallback) { + if (!value) return fallback; + const parsed = Number.parseInt(value, 10); + if (!Number.isFinite(parsed) || parsed < 0) return fallback; + return Math.min(parsed, 2e7); +} +function normalizeBaseUrl(value) { + const candidate = value ?? DEFAULT_BASE_URL; + try { + const url = new URL(candidate); + if (url.protocol !== "https:") return DEFAULT_BASE_URL; + return candidate.replace(/\/+$/, ""); + } catch { + return DEFAULT_BASE_URL; + } +} +function readConfig(env = process.env, storedOptions = readStoredOptions(env)) { + const enabled = parseBoolean( + option(env, storedOptions, "enabled", "LANGFUSE_ENABLED"), + true + ); + const publicKey = option(env, storedOptions, "langfuse_public_key", "LANGFUSE_PUBLIC_KEY") ?? null; + const secretKey = option(env, storedOptions, "langfuse_secret_key", "LANGFUSE_SECRET_KEY") ?? null; + return { + publicKey, + secretKey, + baseUrl: normalizeBaseUrl( + option(env, storedOptions, "langfuse_base_url", "LANGFUSE_BASE_URL") + ), + userId: option(env, storedOptions, "langfuse_user_id", "LANGFUSE_USER_ID") ?? null, + environment: option( + env, + storedOptions, + "langfuse_environment", + "LANGFUSE_ENVIRONMENT" + ) ?? "development", + release: option(env, storedOptions, "langfuse_release", "LANGFUSE_RELEASE") ?? DEFAULT_RELEASE, + enabled, + capturePrompts: parseBoolean( + option(env, storedOptions, "capture_prompts", "LANGFUSE_CAPTURE_PROMPTS"), + true + ), + captureToolInputs: parseBoolean( + option( + env, + storedOptions, + "capture_tool_inputs", + "LANGFUSE_CAPTURE_TOOL_INPUTS" + ), + true + ), + captureToolOutputs: parseBoolean( + option( + env, + storedOptions, + "capture_tool_outputs", + "LANGFUSE_CAPTURE_TOOL_OUTPUTS" + ), + true + ), + maxCaptureChars: parsePositiveInteger( + option( + env, + storedOptions, + "max_capture_chars", + "LANGFUSE_MAX_CAPTURE_CHARS" + ), + DEFAULT_MAX_CAPTURE_CHARS + ), + maxMediaChars: parseMediaChars( + option(env, storedOptions, "max_media_chars", "LANGFUSE_MAX_MEDIA_CHARS"), + DEFAULT_MAX_MEDIA_CHARS + ), + debug: parseBoolean( + option(env, storedOptions, "debug", "LANGFUSE_DEBUG"), + false + ) + }; +} +function isConfigured(config) { + return config.enabled && Boolean(config.publicKey && config.secretKey); +} + +// src/domain/extract.ts +function toJsonValue(value) { + if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") { + return value; + } + if (Array.isArray(value)) { + const values = value.map(toJsonValue); + return values.every((item) => item !== void 0) ? values : void 0; + } + if (typeof value === "object") { + const entries = Object.entries(value); + const result = {}; + for (const [key, item] of entries) { + const parsed = toJsonValue(item); + if (parsed === void 0) return void 0; + result[key] = parsed; + } + return result; + } + return void 0; +} +function valueAt(payload, ...keys) { + for (const key of keys) { + const value = toJsonValue(payload[key]); + if (value !== void 0 && value !== null) return value; + } + return void 0; +} +function asString(value) { + if (typeof value === "string") return value; + if (typeof value === "number" || typeof value === "boolean") + return String(value); + return null; +} +function stringifyValue(value) { + if (typeof value === "string") return value; + if (value === void 0) return ""; + const json = JSON.stringify(value); + return json ?? String(value); +} +function eventName(payload) { + return asString( + valueAt(payload, "hook_event_name", "hookEventName", "event", "event_name") + ); +} +function sessionId(payload) { + const value = asString(valueAt(payload, "session_id", "sessionId")); + return value?.trim() || null; +} +function prompt(payload) { + const value = valueAt( + payload, + "prompt", + "user_prompt", + "userPrompt", + "message" + ); + return value === void 0 ? null : stringifyValue(value); +} +function assistantMessage(payload) { + const value = valueAt( + payload, + "last_assistant_message", + "lastAssistantMessage" + ); + return value === void 0 ? null : stringifyValue(value); +} +function toolId(payload) { + const value = asString( + valueAt(payload, "tool_use_id", "toolUseId", "tool_id", "toolId", "id") + ); + return value?.trim() || null; +} +function toolName(payload) { + return asString( + valueAt(payload, "tool_name", "toolName", "name", "tool") + )?.trim() ?? "unknown"; +} +function toolInput(payload) { + return valueAt(payload, "tool_input", "toolInput", "input", "arguments") ?? null; +} +function toolOutput(payload) { + return valueAt( + payload, + "tool_output", + "toolOutput", + "output", + "result", + "tool_response" + ) ?? null; +} +function toolError(payload) { + return stringifyValue( + valueAt(payload, "error", "error_message", "errorMessage", "message") ?? "Tool failed" + ); +} + +// src/domain/media.ts +var DATA_URI_SOURCE = "data:[^;]+;base64,[A-Za-z0-9+/]+=*"; +function newDataUriPattern() { + return new RegExp(DATA_URI_SOURCE, "g"); +} +var TRUNCATION_MARKER = "\u2026 [truncated]"; +function truncateText(value, maxChars) { + if (value.length <= maxChars) return value; + if (maxChars <= TRUNCATION_MARKER.length) return value.slice(0, maxChars); + return `${value.slice(0, maxChars - TRUNCATION_MARKER.length)}${TRUNCATION_MARKER}`; +} +function isRecord(value) { + return typeof value === "object" && value !== null && !Array.isArray(value); +} +var BASE64_BODY = /^[A-Za-z0-9+/]+={0,2}$/; +var BASE64_IMAGE_KEYS = /* @__PURE__ */ new Set(["img", "image", "image_data", "imageData"]); +function toDataUri(data, mimeType) { + return `data:${mimeType};base64,${data}`; +} +function normalizeImageBlocks(value) { + if (typeof value === "string") return value; + if (Array.isArray(value)) return value.map(normalizeImageBlocks); + if (isRecord(value)) { + if (value.type === "image" && typeof value.data === "string") { + if (BASE64_BODY.test(value.data)) { + const mimeType = typeof value.mimeType === "string" && value.mimeType ? value.mimeType : "image/png"; + return toDataUri(value.data, mimeType); + } + if (value.data.startsWith("data:")) return value.data; + } + const result = {}; + for (const [key, item] of Object.entries(value)) { + if (BASE64_IMAGE_KEYS.has(key.toLowerCase()) && typeof item === "string" && BASE64_BODY.test(item)) { + result[key] = toDataUri(item, "image/png"); + } else { + result[key] = normalizeImageBlocks(item); + } + } + return result; + } + return value; +} +function mimeOf(dataUri) { + const match = /^data:([^;]+);/.exec(dataUri); + return match?.[1] ?? "unknown"; +} +function kiloBytes(dataUri) { + const base64Start = dataUri.indexOf(";base64,"); + const payload = base64Start === -1 ? "" : dataUri.slice(base64Start + 8); + return Math.floor(payload.length * 3 / 4 / 1024); +} +function boundStringWithMedia(value, maxChars, maxMediaChars) { + if (maxMediaChars <= 0) return truncateText(value, maxChars); + const matches = [...value.matchAll(newDataUriPattern())]; + if (matches.length === 0) return truncateText(value, maxChars); + let output = ""; + let last = 0; + let keptMediaChars = 0; + for (const match of matches) { + const start = match.index ?? 0; + const uri = match[0]; + output += truncateText(value.slice(last, start), maxChars); + if (keptMediaChars + uri.length <= maxMediaChars) { + output += uri; + keptMediaChars += uri.length; + } else { + output += `[media ${mimeOf(uri)} ~${kiloBytes(uri)}KB omitted]`; + } + last = start + uri.length; + } + output += truncateText(value.slice(last), maxChars); + return output; +} +function containsMedia(value) { + if (typeof value === "string") + return new RegExp(DATA_URI_SOURCE).test(value); + if (Array.isArray(value)) return value.some(containsMedia); + if (isRecord(value)) return Object.values(value).some(containsMedia); + return false; +} +function boundValuePreservingMedia(value, maxChars, maxMediaChars) { + const normalized = normalizeImageBlocks(value); + const serialized = JSON.stringify(normalized) ?? "null"; + if (serialized.length <= maxChars) return normalized; + if (maxMediaChars <= 0) return truncateText(serialized, maxChars); + return boundStringWithMedia(serialized, maxChars, maxMediaChars); +} + +// src/application/turn-tracker.ts +function createSession(session, now) { + return { + version: 1, + sessionId: session, + startedAt: now, + updatedAt: now, + currentTurn: null + }; +} +function createTurn(id, now, userPrompt) { + return { + id, + prompt: userPrompt, + startedAt: now, + tools: [] + }; +} +function boundValue(value, config) { + return boundValuePreservingMedia( + value, + config.maxCaptureChars, + config.maxMediaChars + ); +} +function sanitizeTurn(turn, config) { + const sanitized = { + ...turn, + prompt: config.capturePrompts && turn.prompt !== null ? boundStringWithMedia( + turn.prompt, + config.maxCaptureChars, + config.maxMediaChars + ) : null, + assistantMessage: config.capturePrompts && turn.assistantMessage !== null ? boundStringWithMedia( + turn.assistantMessage, + config.maxCaptureChars, + config.maxMediaChars + ) : null, + tools: turn.tools.map((tool) => ({ + ...tool, + name: truncateText(tool.name, 256), + input: config.captureToolInputs ? boundValue(tool.input, config) : null, + output: config.captureToolOutputs && tool.output !== null ? boundValue(tool.output, config) : null, + error: config.captureToolOutputs && tool.error !== null ? truncateText(tool.error, config.maxCaptureChars) : null + })) + }; + sanitized.hasMedia = config.maxMediaChars > 0 && containsMedia({ + prompt: sanitized.prompt, + assistantMessage: sanitized.assistantMessage, + tools: sanitized.tools.map((tool) => ({ + input: tool.input, + output: tool.output + })) + }); + return sanitized; +} +function findTool(turn, id, name) { + if (id) { + const byId = turn.tools.find((tool) => tool.id === id); + if (byId) return byId; + } + return [...turn.tools].reverse().find((tool) => tool.endedAt === null && tool.name === name) ?? [...turn.tools].reverse().find((tool) => tool.endedAt === null) ?? null; +} +var TurnTracker = class { + constructor(stateStore, traceSink, config, clock, idGenerator) { + this.stateStore = stateStore; + this.traceSink = traceSink; + this.config = config; + this.clock = clock; + this.idGenerator = idGenerator; + } + stateStore; + traceSink; + config; + clock; + idGenerator; + async handle(payload) { + const name = eventName(payload); + const session = sessionId(payload); + if (!name || !session) return; + let completed = null; + await this.stateStore.withSessionLock(session, async () => { + const now = this.clock.now().toISOString(); + const existing = await this.stateStore.load(session) ?? createSession(session, now); + switch (name) { + case "SessionStart": + existing.updatedAt = now; + await this.stateStore.save(existing); + return; + case "UserPromptSubmit": { + const userPrompt = prompt(payload); + existing.currentTurn = createTurn( + this.idGenerator.next(), + now, + this.config.capturePrompts && userPrompt !== null ? boundStringWithMedia( + userPrompt, + this.config.maxCaptureChars, + this.config.maxMediaChars + ) : null + ); + existing.updatedAt = now; + await this.stateStore.save(existing); + return; + } + case "PreToolUse": + this.recordToolStart(existing, payload, now); + await this.stateStore.save(existing); + return; + case "PostToolUse": + this.recordToolOutput(existing, payload, now, false); + await this.stateStore.save(existing); + return; + case "PostToolUseFailure": + this.recordToolOutput(existing, payload, now, true); + await this.stateStore.save(existing); + return; + case "Stop": + completed = sanitizeTurn( + { + sessionId: session, + turnId: existing.currentTurn?.id ?? this.idGenerator.next(), + prompt: existing.currentTurn?.prompt ?? null, + assistantMessage: assistantMessage(payload), + startedAt: existing.currentTurn?.startedAt ?? now, + endedAt: now, + tools: existing.currentTurn?.tools ?? [], + hasMedia: false + }, + this.config + ); + await this.stateStore.clear(session); + return; + default: + return; + } + }); + if (completed) await this.traceSink.publishTurn(completed); + } + recordToolStart(state, payload, now) { + const turn = state.currentTurn ?? createTurn(this.idGenerator.next(), now, null); + state.currentTurn = turn; + turn.tools.push({ + id: toolId(payload) ?? this.idGenerator.next(), + name: toolName(payload), + input: this.config.captureToolInputs ? boundValue(toolInput(payload), this.config) : null, + output: null, + error: null, + startedAt: now, + endedAt: null + }); + state.updatedAt = now; + } + recordToolOutput(state, payload, now, failed) { + const turn = state.currentTurn ?? createTurn(this.idGenerator.next(), now, null); + state.currentTurn = turn; + const name = toolName(payload); + const tool = findTool(turn, toolId(payload), name); + const output = !failed && this.config.captureToolOutputs ? boundValue(toolOutput(payload), this.config) : null; + const error = failed && this.config.captureToolOutputs ? truncateText(toolError(payload), this.config.maxCaptureChars) : null; + if (tool) { + tool.output = output; + tool.error = error; + tool.endedAt = now; + } else { + turn.tools.push({ + id: toolId(payload) ?? this.idGenerator.next(), + name, + input: null, + output, + error, + startedAt: now, + endedAt: now + }); + } + state.updatedAt = now; + } +}; +var NoopTraceSink = class { + async publishTurn(_turn) { + } +}; + +// src/adapters/json-state-store.ts +import { createHash, randomUUID } from "node:crypto"; +import { + mkdir, + open, + readFile, + rename, + rm, + stat, + writeFile +} from "node:fs/promises"; +import { homedir as homedir2, tmpdir } from "node:os"; +import { join as join2 } from "node:path"; + +// src/domain/identity.ts +var PLUGIN_ID = "zcode-plugin-langfuse"; + +// src/adapters/json-state-store.ts +var LOCK_WAIT_MS = 25; +var LOCK_ATTEMPTS = 160; +var STALE_LOCK_MS = 6e4; +function isRecord2(value) { + return typeof value === "object" && value !== null && !Array.isArray(value); +} +function isJsonValue(value) { + if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") { + return true; + } + if (Array.isArray(value)) return value.every(isJsonValue); + return isRecord2(value) && Object.values(value).every(isJsonValue); +} +function parseToolCall(value) { + if (!isRecord2(value)) return null; + if (typeof value.id !== "string" || typeof value.name !== "string" || !isJsonValue(value.input) || value.output !== null && !isJsonValue(value.output) || value.error !== null && typeof value.error !== "string" || typeof value.startedAt !== "string" || value.endedAt !== null && typeof value.endedAt !== "string") { + return null; + } + return { + id: value.id, + name: value.name, + input: value.input, + output: value.output, + error: value.error, + startedAt: value.startedAt, + endedAt: value.endedAt + }; +} +function parseTurn(value) { + if (!isRecord2(value)) return null; + if (typeof value.id !== "string" || value.prompt !== null && typeof value.prompt !== "string" || typeof value.startedAt !== "string" || !Array.isArray(value.tools)) { + return null; + } + const tools = value.tools.map(parseToolCall); + if (tools.some((tool) => tool === null)) return null; + return { + id: value.id, + prompt: value.prompt, + startedAt: value.startedAt, + tools: tools.filter((tool) => tool !== null) + }; +} +function parseState(value) { + if (!isRecord2(value)) return null; + if (value.version !== 1 || typeof value.sessionId !== "string" || typeof value.startedAt !== "string" || typeof value.updatedAt !== "string") { + return null; + } + const currentTurn = value.currentTurn === null ? null : parseTurn(value.currentTurn); + if (value.currentTurn !== null && currentTurn === null) return null; + return { + version: 1, + sessionId: value.sessionId, + startedAt: value.startedAt, + updatedAt: value.updatedAt, + currentTurn + }; +} +function sessionKey(sessionId2) { + return createHash("sha256").update(sessionId2).digest("hex"); +} +function defaultDataDir() { + return join2( + homedir2() || tmpdir(), + ".zcode", + "cli", + "plugins", + "data", + PLUGIN_ID + ); +} +var JsonStateStore = class { + dataDir; + constructor(dataDir = process.env.ZCODE_PLUGIN_DATA || defaultDataDir()) { + this.dataDir = dataDir; + } + async load(sessionId2) { + try { + const contents = await readFile(this.statePath(sessionId2), "utf8"); + return parseState(JSON.parse(contents)); + } catch { + return null; + } + } + async save(state) { + await mkdir(this.dataDir, { recursive: true, mode: 448 }); + const path2 = this.statePath(state.sessionId); + const temporaryPath = `${path2}.${randomUUID()}.tmp`; + await writeFile(temporaryPath, JSON.stringify(state), { + encoding: "utf8", + mode: 384 + }); + await rename(temporaryPath, path2); + } + async clear(sessionId2) { + await rm(this.statePath(sessionId2), { force: true }); + } + async withSessionLock(sessionId2, task) { + await mkdir(this.dataDir, { recursive: true, mode: 448 }); + const lockPath = this.lockPath(sessionId2); + let acquired = false; + for (let attempt = 0; attempt < LOCK_ATTEMPTS; attempt += 1) { + try { + const handle = await open(lockPath, "wx", 384); + await handle.close(); + acquired = true; + break; + } catch { + await this.removeStaleLock(lockPath); + await new Promise((resolve2) => setTimeout(resolve2, LOCK_WAIT_MS)); + } + } + if (!acquired) + throw new Error("Timed out acquiring the Langfuse state lock"); + try { + return await task(); + } finally { + await rm(lockPath, { force: true }); + } + } + statePath(sessionId2) { + return join2(this.dataDir, `${sessionKey(sessionId2)}.json`); + } + lockPath(sessionId2) { + return join2(this.dataDir, `${sessionKey(sessionId2)}.lock`); + } + async removeStaleLock(lockPath) { + try { + const details = await stat(lockPath); + if (Date.now() - details.mtimeMs > STALE_LOCK_MS) + await rm(lockPath, { force: true }); + } catch { + } + } +}; + +// node_modules/@langfuse/core/dist/index.mjs +init_esm(); +var __defProp2 = Object.defineProperty; +var __export2 = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); +}; +function getEnv(key) { + if (typeof process !== "undefined" && process.env[key]) { + return process.env[key]; + } else if (typeof globalThis !== "undefined") { + return globalThis[key]; + } + return; +} +function base64ToBytes(base64) { + const binString = atob(base64); + return Uint8Array.from(binString, (m) => m.codePointAt(0)); +} +function bytesToBase64(bytes) { + const binString = Array.from(bytes, (byte) => String.fromCharCode(byte)).join( + "" + ); + return btoa(binString); +} +function base64Encode(input) { + if (typeof Buffer !== "undefined") { + return Buffer.from(input, "utf8").toString("base64"); + } + const bytes = new TextEncoder().encode(input); + return bytesToBase64(bytes); +} +var LogLevel = /* @__PURE__ */ ((LogLevel2) => { + LogLevel2[LogLevel2["NONE"] = 4] = "NONE"; + LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR"; + LogLevel2[LogLevel2["WARN"] = 2] = "WARN"; + LogLevel2[LogLevel2["INFO"] = 1] = "INFO"; + LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG"; + return LogLevel2; +})(LogLevel || {}); +function parseLogLevelFromEnv() { + var _a2; + if (typeof process === "object" && "env" in process) { + if (((_a2 = getEnv("LANGFUSE_DEBUG")) == null ? void 0 : _a2.toLowerCase()) === "true") + return 0; + const envValue = getEnv("LANGFUSE_LOG_LEVEL"); + const value = (envValue != null ? envValue : "").toUpperCase(); + switch (value) { + case "NONE": + return 4; + case "ERROR": + return 3; + case "WARN": + return 2; + case "INFO": + return 1; + case "DEBUG": + return 0; + default: + return void 0; + } + } + return void 0; +} +var Logger = class { + /** + * Creates a new Logger instance. + * + * @param config - Configuration options for the logger + */ + constructor(config = { + level: 1 + /* INFO */ + }) { + this.config = { + enableTimestamp: true, + ...config + }; + } + /** + * Determines if a message should be logged based on the current log level. + * + * @param level - The log level to check + * @returns True if the message should be logged, false otherwise + */ + shouldLog(level) { + return level >= this.config.level; + } + /** + * Formats a log message with timestamp, prefix, and log level. + * + * @param level - The log level string + * @param message - The message to format + * @returns The formatted message string + */ + formatMessage(level, message) { + const timestamp = this.config.enableTimestamp ? (/* @__PURE__ */ new Date()).toISOString() : ""; + const prefix = this.config.prefix || "[Langfuse SDK]"; + const parts = [timestamp, prefix, `[${level}]`, message].filter(Boolean); + return parts.join(" "); + } + /** + * Logs an error message. + * + * @param message - The error message to log + * @param args - Additional arguments to pass to console.error + */ + error(message, ...args) { + if (this.shouldLog( + 3 + /* ERROR */ + )) { + console.error(this.formatMessage("ERROR", message), ...args); + } + } + /** + * Logs a warning message. + * + * @param message - The warning message to log + * @param args - Additional arguments to pass to console.warn + */ + warn(message, ...args) { + if (this.shouldLog( + 2 + /* WARN */ + )) { + console.warn(this.formatMessage("WARN", message), ...args); + } + } + /** + * Logs an informational message. + * + * @param message - The info message to log + * @param args - Additional arguments to pass to console.info + */ + info(message, ...args) { + if (this.shouldLog( + 1 + /* INFO */ + )) { + console.info(this.formatMessage("INFO", message), ...args); + } + } + /** + * Logs a debug message. + * + * @param message - The debug message to log + * @param args - Additional arguments to pass to console.debug + */ + debug(message, ...args) { + if (this.shouldLog( + 0 + /* DEBUG */ + )) { + console.debug(this.formatMessage("DEBUG", message), ...args); + } + } + /** + * Sets the minimum log level. + * + * @param level - The new log level + */ + setLevel(level) { + this.config.level = level; + } + /** + * Gets the current log level. + * + * @returns The current log level + */ + getLevel() { + return this.config.level; + } + /** + * Checks if a given log level is enabled. + * Use this to guard expensive operations (like JSON.stringify) before debug logging. + * + * @param level - The log level to check + * @returns True if the level is enabled, false otherwise + * + * @example + * ```typescript + * if (logger.isLevelEnabled(LogLevel.DEBUG)) { + * logger.debug('Expensive data:', JSON.stringify(largeObject)); + * } + * ``` + */ + isLevelEnabled(level) { + return this.shouldLog(level); + } +}; +var _a; +var _LoggerSingleton = class _LoggerSingleton2 { + /** + * Gets the singleton logger instance, creating it if it doesn't exist. + * + * @returns The singleton logger instance + */ + static getInstance() { + if (!_LoggerSingleton2.instance) { + _LoggerSingleton2.instance = new Logger(_LoggerSingleton2.defaultConfig); + } + return _LoggerSingleton2.instance; + } + /** + * Configures the global logger with new settings. + * This will replace the existing logger instance. + * + * @param config - The new logger configuration + */ + static configure(config) { + _LoggerSingleton2.defaultConfig = config; + _LoggerSingleton2.instance = new Logger(config); + } + /** + * Resets the singleton logger instance and configuration. + * Useful for testing or reinitializing the logger. + */ + static reset() { + _LoggerSingleton2.instance = null; + _LoggerSingleton2.defaultConfig = { + level: 1 + /* INFO */ + }; + } +}; +_LoggerSingleton.instance = null; +_LoggerSingleton.defaultConfig = { + level: (_a = parseLogLevelFromEnv()) != null ? _a : 1 + /* INFO */ +}; +var LoggerSingleton = _LoggerSingleton; +var getGlobalLogger = () => { + return LoggerSingleton.getInstance(); +}; +var package_default = { + name: "@langfuse/core", + version: "5.11.1", + description: "Core functions and utilities for Langfuse packages", + type: "module", + sideEffects: false, + main: "./dist/index.cjs", + module: "./dist/index.mjs", + types: "./dist/index.d.ts", + exports: { + ".": { + import: { + types: "./dist/index.d.ts", + default: "./dist/index.mjs" + }, + require: { + types: "./dist/index.d.cts", + default: "./dist/index.cjs" + } + } + }, + scripts: { + build: "tsup", + test: "vitest run", + "test:watch": "vitest", + format: 'prettier --write "src/**/*.ts"', + "format:check": 'prettier --check "src/**/*.ts"', + clean: "rm -rf dist" + }, + author: "Langfuse", + license: "MIT", + repository: { + type: "git", + url: "https://github.com/langfuse/langfuse-js.git", + directory: "packages/core" + }, + files: [ + "dist" + ], + peerDependencies: { + "@opentelemetry/api": "^1.9.0" + }, + devDependencies: { + "@types/node": "^24.1.0" + } +}; +var LANGFUSE_TRACER_NAME = "langfuse-sdk"; +var LANGFUSE_SDK_VERSION = package_default.version; +var LANGFUSE_SDK_EXPERIMENT_ENVIRONMENT = "sdk-experiment"; +var LangfuseOtelSpanAttributes = /* @__PURE__ */ ((LangfuseOtelSpanAttributes2) => { + LangfuseOtelSpanAttributes2["TRACE_NAME"] = "langfuse.trace.name"; + LangfuseOtelSpanAttributes2["TRACE_USER_ID"] = "user.id"; + LangfuseOtelSpanAttributes2["TRACE_SESSION_ID"] = "session.id"; + LangfuseOtelSpanAttributes2["TRACE_TAGS"] = "langfuse.trace.tags"; + LangfuseOtelSpanAttributes2["TRACE_PUBLIC"] = "langfuse.trace.public"; + LangfuseOtelSpanAttributes2["TRACE_METADATA"] = "langfuse.trace.metadata"; + LangfuseOtelSpanAttributes2["TRACE_INPUT"] = "langfuse.trace.input"; + LangfuseOtelSpanAttributes2["TRACE_OUTPUT"] = "langfuse.trace.output"; + LangfuseOtelSpanAttributes2["OBSERVATION_TYPE"] = "langfuse.observation.type"; + LangfuseOtelSpanAttributes2["OBSERVATION_METADATA"] = "langfuse.observation.metadata"; + LangfuseOtelSpanAttributes2["OBSERVATION_LEVEL"] = "langfuse.observation.level"; + LangfuseOtelSpanAttributes2["OBSERVATION_STATUS_MESSAGE"] = "langfuse.observation.status_message"; + LangfuseOtelSpanAttributes2["OBSERVATION_INPUT"] = "langfuse.observation.input"; + LangfuseOtelSpanAttributes2["OBSERVATION_OUTPUT"] = "langfuse.observation.output"; + LangfuseOtelSpanAttributes2["OBSERVATION_COMPLETION_START_TIME"] = "langfuse.observation.completion_start_time"; + LangfuseOtelSpanAttributes2["OBSERVATION_MODEL"] = "langfuse.observation.model.name"; + LangfuseOtelSpanAttributes2["OBSERVATION_MODEL_PARAMETERS"] = "langfuse.observation.model.parameters"; + LangfuseOtelSpanAttributes2["OBSERVATION_USAGE_DETAILS"] = "langfuse.observation.usage_details"; + LangfuseOtelSpanAttributes2["OBSERVATION_COST_DETAILS"] = "langfuse.observation.cost_details"; + LangfuseOtelSpanAttributes2["OBSERVATION_PROMPT_NAME"] = "langfuse.observation.prompt.name"; + LangfuseOtelSpanAttributes2["OBSERVATION_PROMPT_VERSION"] = "langfuse.observation.prompt.version"; + LangfuseOtelSpanAttributes2["ENVIRONMENT"] = "langfuse.environment"; + LangfuseOtelSpanAttributes2["RELEASE"] = "langfuse.release"; + LangfuseOtelSpanAttributes2["VERSION"] = "langfuse.version"; + LangfuseOtelSpanAttributes2["AS_ROOT"] = "langfuse.internal.as_root"; + LangfuseOtelSpanAttributes2["IS_APP_ROOT"] = "langfuse.internal.is_app_root"; + LangfuseOtelSpanAttributes2["EXPERIMENT_ID"] = "langfuse.experiment.id"; + LangfuseOtelSpanAttributes2["EXPERIMENT_NAME"] = "langfuse.experiment.name"; + LangfuseOtelSpanAttributes2["EXPERIMENT_DESCRIPTION"] = "langfuse.experiment.description"; + LangfuseOtelSpanAttributes2["EXPERIMENT_METADATA"] = "langfuse.experiment.metadata"; + LangfuseOtelSpanAttributes2["EXPERIMENT_DATASET_ID"] = "langfuse.experiment.dataset.id"; + LangfuseOtelSpanAttributes2["EXPERIMENT_ITEM_ID"] = "langfuse.experiment.item.id"; + LangfuseOtelSpanAttributes2["EXPERIMENT_ITEM_EXPECTED_OUTPUT"] = "langfuse.experiment.item.expected_output"; + LangfuseOtelSpanAttributes2["EXPERIMENT_ITEM_METADATA"] = "langfuse.experiment.item.metadata"; + LangfuseOtelSpanAttributes2["EXPERIMENT_ITEM_ROOT_OBSERVATION_ID"] = "langfuse.experiment.item.root_observation_id"; + LangfuseOtelSpanAttributes2["TRACE_COMPAT_USER_ID"] = "langfuse.user.id"; + LangfuseOtelSpanAttributes2["TRACE_COMPAT_SESSION_ID"] = "langfuse.session.id"; + return LangfuseOtelSpanAttributes2; +})(LangfuseOtelSpanAttributes || {}); +var annotationQueues_exports = {}; +__export2(annotationQueues_exports, { + AnnotationQueueObjectType: () => AnnotationQueueObjectType, + AnnotationQueueStatus: () => AnnotationQueueStatus +}); +var AnnotationQueueStatus = { + Pending: "PENDING", + Completed: "COMPLETED" +}; +var AnnotationQueueObjectType = { + Trace: "TRACE", + Observation: "OBSERVATION", + Session: "SESSION" +}; +var blobStorageIntegrations_exports = {}; +__export2(blobStorageIntegrations_exports, { + BlobStorageExportFieldGroup: () => BlobStorageExportFieldGroup, + BlobStorageExportFrequency: () => BlobStorageExportFrequency, + BlobStorageExportMode: () => BlobStorageExportMode, + BlobStorageExportSource: () => BlobStorageExportSource, + BlobStorageIntegrationFileType: () => BlobStorageIntegrationFileType, + BlobStorageIntegrationFileTypeResponse: () => BlobStorageIntegrationFileTypeResponse, + BlobStorageIntegrationType: () => BlobStorageIntegrationType, + BlobStorageSyncStatus: () => BlobStorageSyncStatus +}); +var BlobStorageIntegrationType = { + S3: "S3", + S3Compatible: "S3_COMPATIBLE", + AzureBlobStorage: "AZURE_BLOB_STORAGE" +}; +var BlobStorageIntegrationFileType = { + Json: "JSON", + Csv: "CSV", + Jsonl: "JSONL", + Parquet: "PARQUET" +}; +var BlobStorageIntegrationFileTypeResponse = { + Json: "JSON", + Csv: "CSV", + Jsonl: "JSONL", + Parquet: "PARQUET" +}; +var BlobStorageExportMode = { + FullHistory: "FULL_HISTORY", + FromToday: "FROM_TODAY", + FromCustomDate: "FROM_CUSTOM_DATE" +}; +var BlobStorageExportFrequency = { + Every20Minutes: "every_20_minutes", + Hourly: "hourly", + Daily: "daily", + Weekly: "weekly" +}; +var BlobStorageExportSource = { + LegacyTracesObservations: "LEGACY_TRACES_OBSERVATIONS", + ObservationsV2: "OBSERVATIONS_V2", + LegacyTracesAndEnrichedObservations: "LEGACY_TRACES_AND_ENRICHED_OBSERVATIONS" +}; +var BlobStorageExportFieldGroup = { + Core: "core", + Basic: "basic", + Time: "time", + Io: "io", + Metadata: "metadata", + Model: "model", + Usage: "usage", + Prompt: "prompt", + Metrics: "metrics", + Tools: "tools", + TraceContext: "trace_context" +}; +var BlobStorageSyncStatus = { + Idle: "idle", + Running: "running", + Queued: "queued", + UpToDate: "up_to_date", + Disabled: "disabled", + Error: "error" +}; +var commons_exports = {}; +__export2(commons_exports, { + AccessDeniedError: () => AccessDeniedError, + CommentObjectType: () => CommentObjectType, + DatasetItemMediaReferenceField: () => DatasetItemMediaReferenceField, + DatasetStatus: () => DatasetStatus, + Error: () => Error2, + MethodNotAllowedError: () => MethodNotAllowedError, + ModelUsageUnit: () => ModelUsageUnit, + NotFoundError: () => NotFoundError, + ObservationLevel: () => ObservationLevel, + PricingTierAttributeSource: () => PricingTierAttributeSource, + PricingTierOperator: () => PricingTierOperator, + ScoreConfigDataType: () => ScoreConfigDataType, + ScoreDataType: () => ScoreDataType, + ScoreSource: () => ScoreSource, + UnauthorizedError: () => UnauthorizedError +}); +var DatasetItemMediaReferenceField = { + Input: "input", + ExpectedOutput: "expectedOutput", + Metadata: "metadata" +}; +var PricingTierAttributeSource = { + ModelParameters: "model_parameters", + Metadata: "metadata" +}; +var PricingTierOperator = { + Gt: "gt", + Gte: "gte", + Lt: "lt", + Lte: "lte", + Eq: "eq", + Neq: "neq" +}; +var ModelUsageUnit = { + Characters: "CHARACTERS", + Tokens: "TOKENS", + Milliseconds: "MILLISECONDS", + Seconds: "SECONDS", + Images: "IMAGES", + Requests: "REQUESTS" +}; +var ObservationLevel = { + Debug: "DEBUG", + Default: "DEFAULT", + Warning: "WARNING", + Error: "ERROR" +}; +var CommentObjectType = { + Trace: "TRACE", + Observation: "OBSERVATION", + Session: "SESSION", + Prompt: "PROMPT" +}; +var DatasetStatus = { + Active: "ACTIVE", + Archived: "ARCHIVED" +}; +var ScoreSource = { + Annotation: "ANNOTATION", + Api: "API", + Eval: "EVAL" +}; +var ScoreConfigDataType = { + Numeric: "NUMERIC", + Boolean: "BOOLEAN", + Categorical: "CATEGORICAL", + Text: "TEXT" +}; +var ScoreDataType = { + Numeric: "NUMERIC", + Boolean: "BOOLEAN", + Categorical: "CATEGORICAL", + Correction: "CORRECTION", + Text: "TEXT" +}; +var toJson = (value, replacer, space) => { + return JSON.stringify(value, replacer, space); +}; +function fromJson(text, reviver) { + return JSON.parse(text, reviver); +} +var LangfuseAPIError = class _LangfuseAPIError extends Error { + constructor({ + message, + statusCode, + body, + rawResponse + }) { + super(buildMessage({ message, statusCode, body })); + Object.setPrototypeOf(this, _LangfuseAPIError.prototype); + this.statusCode = statusCode; + this.body = body; + this.rawResponse = rawResponse; + } +}; +function buildMessage({ + message, + statusCode, + body +}) { + let lines = []; + if (message != null) { + lines.push(message); + } + if (statusCode != null) { + lines.push(`Status code: ${statusCode.toString()}`); + } + if (body != null) { + lines.push(`Body: ${toJson(body, void 0, 2)}`); + } + return lines.join("\n"); +} +var LangfuseAPITimeoutError = class _LangfuseAPITimeoutError extends Error { + constructor(message) { + super(message); + Object.setPrototypeOf(this, _LangfuseAPITimeoutError.prototype); + } +}; +var Error2 = class _Error extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "Error", + statusCode: 400, + body, + rawResponse + }); + Object.setPrototypeOf(this, _Error.prototype); + } +}; +var UnauthorizedError = class _UnauthorizedError extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "UnauthorizedError", + statusCode: 401, + body, + rawResponse + }); + Object.setPrototypeOf(this, _UnauthorizedError.prototype); + } +}; +var AccessDeniedError = class _AccessDeniedError extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "AccessDeniedError", + statusCode: 403, + body, + rawResponse + }); + Object.setPrototypeOf(this, _AccessDeniedError.prototype); + } +}; +var NotFoundError = class _NotFoundError extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "NotFoundError", + statusCode: 404, + body, + rawResponse + }); + Object.setPrototypeOf(this, _NotFoundError.prototype); + } +}; +var MethodNotAllowedError = class _MethodNotAllowedError extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "MethodNotAllowedError", + statusCode: 405, + body, + rawResponse + }); + Object.setPrototypeOf(this, _MethodNotAllowedError.prototype); + } +}; +var evaluationCommons_exports = {}; +__export2(evaluationCommons_exports, { + CodeEvaluatorSourceCodeLanguage: () => CodeEvaluatorSourceCodeLanguage, + EvaluationRuleArrayOptionsFilterOperator: () => EvaluationRuleArrayOptionsFilterOperator, + EvaluationRuleBooleanFilterOperator: () => EvaluationRuleBooleanFilterOperator, + EvaluationRuleNullFilterOperator: () => EvaluationRuleNullFilterOperator, + EvaluationRuleNumberFilterOperator: () => EvaluationRuleNumberFilterOperator, + EvaluationRuleOptionsFilterOperator: () => EvaluationRuleOptionsFilterOperator, + EvaluationRuleStringFilterOperator: () => EvaluationRuleStringFilterOperator, + EvaluatorOutputScoreType: () => EvaluatorOutputScoreType, + EvaluatorType: () => EvaluatorType, + LegacyEvaluationObject: () => LegacyEvaluationObject, + PromptVariableMappingSource: () => PromptVariableMappingSource +}); +var EvaluatorType = { + LlmAsJudge: "llm_as_judge", + Code: "code" +}; +var CodeEvaluatorSourceCodeLanguage = { + Python: "PYTHON", + Typescript: "TYPESCRIPT" +}; +var PromptVariableMappingSource = { + Input: "input", + Output: "output", + Metadata: "metadata", + ToolCalls: "tool_calls", + ExpectedOutput: "expected_output", + ExperimentItemMetadata: "experiment_item_metadata" +}; +var EvaluatorOutputScoreType = { + Numeric: "NUMERIC", + Boolean: "BOOLEAN", + Categorical: "CATEGORICAL" +}; +var EvaluationRuleStringFilterOperator = { + Equals: "=", + Contains: "contains", + DoesNotContain: "does not contain", + StartsWith: "starts with", + EndsWith: "ends with" +}; +var EvaluationRuleNumberFilterOperator = { + Equals: "=", + GreaterThan: ">", + LessThan: "<", + GreaterThanOrEqual: ">=", + LessThanOrEqual: "<=" +}; +var EvaluationRuleOptionsFilterOperator = { + AnyOf: "any of", + NoneOf: "none of" +}; +var EvaluationRuleArrayOptionsFilterOperator = { + AnyOf: "any of", + NoneOf: "none of", + AllOf: "all of" +}; +var EvaluationRuleBooleanFilterOperator = { + Equals: "=", + NotEquals: "<>" +}; +var EvaluationRuleNullFilterOperator = { + IsNull: "is null", + IsNotNull: "is not null" +}; +var LegacyEvaluationObject = { + Trace: "trace", + Span: "span", + Generation: "generation", + Event: "event", + Agent: "agent", + Tool: "tool", + Chain: "chain", + Retriever: "retriever", + Evaluator: "evaluator", + Embedding: "embedding", + Guardrail: "guardrail", + DatasetItem: "dataset_item" +}; +var evaluationErrors_exports = {}; +__export2(evaluationErrors_exports, { + BadRequestError: () => BadRequestError, + ConflictError: () => ConflictError, + EvaluationAccessDeniedError: () => EvaluationAccessDeniedError, + EvaluationMethodNotAllowedError: () => EvaluationMethodNotAllowedError, + EvaluationNotFoundError: () => EvaluationNotFoundError, + EvaluationUnauthorizedError: () => EvaluationUnauthorizedError, + InternalServerError: () => InternalServerError, + PreconditionFailedError: () => PreconditionFailedError, + PublicApiErrorCode: () => PublicApiErrorCode, + TooManyRequestsError: () => TooManyRequestsError +}); +var PublicApiErrorCode = { + AuthenticationFailed: "authentication_failed", + AccessDenied: "access_denied", + InvalidRequest: "invalid_request", + InvalidQuery: "invalid_query", + InvalidBody: "invalid_body", + ResourceNotFound: "resource_not_found", + Conflict: "conflict", + RateLimited: "rate_limited", + MethodNotAllowed: "method_not_allowed", + InternalError: "internal_error" +}; +var BadRequestError = class _BadRequestError extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "BadRequestError", + statusCode: 400, + body, + rawResponse + }); + Object.setPrototypeOf(this, _BadRequestError.prototype); + } +}; +var EvaluationUnauthorizedError = class _EvaluationUnauthorizedError extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "EvaluationUnauthorizedError", + statusCode: 401, + body, + rawResponse + }); + Object.setPrototypeOf(this, _EvaluationUnauthorizedError.prototype); + } +}; +var EvaluationAccessDeniedError = class _EvaluationAccessDeniedError extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "EvaluationAccessDeniedError", + statusCode: 403, + body, + rawResponse + }); + Object.setPrototypeOf(this, _EvaluationAccessDeniedError.prototype); + } +}; +var EvaluationNotFoundError = class _EvaluationNotFoundError extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "EvaluationNotFoundError", + statusCode: 404, + body, + rawResponse + }); + Object.setPrototypeOf(this, _EvaluationNotFoundError.prototype); + } +}; +var EvaluationMethodNotAllowedError = class _EvaluationMethodNotAllowedError extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "EvaluationMethodNotAllowedError", + statusCode: 405, + body, + rawResponse + }); + Object.setPrototypeOf(this, _EvaluationMethodNotAllowedError.prototype); + } +}; +var ConflictError = class _ConflictError extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "ConflictError", + statusCode: 409, + body, + rawResponse + }); + Object.setPrototypeOf(this, _ConflictError.prototype); + } +}; +var PreconditionFailedError = class _PreconditionFailedError extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "PreconditionFailedError", + statusCode: 412, + body, + rawResponse + }); + Object.setPrototypeOf(this, _PreconditionFailedError.prototype); + } +}; +var TooManyRequestsError = class _TooManyRequestsError extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "TooManyRequestsError", + statusCode: 429, + body, + rawResponse + }); + Object.setPrototypeOf(this, _TooManyRequestsError.prototype); + } +}; +var InternalServerError = class _InternalServerError extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "InternalServerError", + statusCode: 500, + body, + rawResponse + }); + Object.setPrototypeOf(this, _InternalServerError.prototype); + } +}; +var evaluators_exports = {}; +__export2(evaluators_exports, { + EvaluatorChatMessageRole: () => EvaluatorChatMessageRole, + EvaluatorStatus: () => EvaluatorStatus +}); +var EvaluatorChatMessageRole = { + System: "system", + User: "user", + Assistant: "assistant" +}; +var EvaluatorStatus = { + Active: "active", + Paused: "paused" +}; +var feedback_exports = {}; +__export2(feedback_exports, { + FeedbackNotConfiguredError: () => FeedbackNotConfiguredError, + FeedbackTargetType: () => FeedbackTargetType +}); +var FeedbackTargetType = { + Skill: "skill", + McpTool: "mcp-tool", + Cli: "cli", + Docs: "docs", + PublicApi: "public-api", + Other: "other" +}; +var FeedbackNotConfiguredError = class _FeedbackNotConfiguredError extends LangfuseAPIError { + constructor(rawResponse) { + super({ + message: "FeedbackNotConfiguredError", + statusCode: 409, + rawResponse + }); + Object.setPrototypeOf(this, _FeedbackNotConfiguredError.prototype); + } +}; +var health_exports = {}; +__export2(health_exports, { + ServiceUnavailableError: () => ServiceUnavailableError +}); +var ServiceUnavailableError = class _ServiceUnavailableError extends LangfuseAPIError { + constructor(rawResponse) { + super({ + message: "ServiceUnavailableError", + statusCode: 503, + rawResponse + }); + Object.setPrototypeOf(this, _ServiceUnavailableError.prototype); + } +}; +var ingestion_exports = {}; +__export2(ingestion_exports, { + ObservationType: () => ObservationType +}); +var ObservationType = { + Span: "SPAN", + Generation: "GENERATION", + Event: "EVENT", + Agent: "AGENT", + Tool: "TOOL", + Chain: "CHAIN", + Retriever: "RETRIEVER", + Evaluator: "EVALUATOR", + Embedding: "EMBEDDING", + Guardrail: "GUARDRAIL" +}; +var legacy_exports = {}; +__export2(legacy_exports, { + CreateScoreSource: () => CreateScoreSource, + metricsV1: () => metricsV1_exports, + observationsV1: () => observationsV1_exports, + scoreV1: () => scoreV1_exports +}); +var metricsV1_exports = {}; +var observationsV1_exports = {}; +var scoreV1_exports = {}; +__export2(scoreV1_exports, { + CreateScoreSource: () => CreateScoreSource +}); +var CreateScoreSource = { + Api: "API", + Annotation: "ANNOTATION" +}; +var llmConnections_exports = {}; +__export2(llmConnections_exports, { + LlmAdapter: () => LlmAdapter +}); +var LlmAdapter = { + Anthropic: "anthropic", + OpenAi: "openai", + Azure: "azure", + Bedrock: "bedrock", + GoogleVertexAi: "google-vertex-ai", + GoogleAiStudio: "google-ai-studio" +}; +var media_exports = {}; +__export2(media_exports, { + MediaContentType: () => MediaContentType +}); +var MediaContentType = { + ImagePng: "image/png", + ImageJpeg: "image/jpeg", + ImageJpg: "image/jpg", + ImageWebp: "image/webp", + ImageGif: "image/gif", + ImageSvgXml: "image/svg+xml", + ImageTiff: "image/tiff", + ImageBmp: "image/bmp", + ImageAvif: "image/avif", + ImageHeic: "image/heic", + AudioMpeg: "audio/mpeg", + AudioMp3: "audio/mp3", + AudioWav: "audio/wav", + AudioOgg: "audio/ogg", + AudioOga: "audio/oga", + AudioAac: "audio/aac", + AudioMp4: "audio/mp4", + AudioFlac: "audio/flac", + AudioOpus: "audio/opus", + AudioWebm: "audio/webm", + VideoMp4: "video/mp4", + VideoWebm: "video/webm", + VideoOgg: "video/ogg", + VideoMpeg: "video/mpeg", + VideoQuicktime: "video/quicktime", + VideoXMsvideo: "video/x-msvideo", + VideoXMatroska: "video/x-matroska", + TextPlain: "text/plain", + TextHtml: "text/html", + TextCss: "text/css", + TextCsv: "text/csv", + TextMarkdown: "text/markdown", + TextXPython: "text/x-python", + ApplicationJavascript: "application/javascript", + TextXTypescript: "text/x-typescript", + ApplicationXYaml: "application/x-yaml", + ApplicationPdf: "application/pdf", + ApplicationMsword: "application/msword", + ApplicationMsExcel: "application/vnd.ms-excel", + ApplicationOpenxmlSpreadsheet: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", + ApplicationZip: "application/zip", + ApplicationJson: "application/json", + ApplicationXml: "application/xml", + ApplicationOctetStream: "application/octet-stream", + ApplicationOpenxmlWord: "application/vnd.openxmlformats-officedocument.wordprocessingml.document", + ApplicationOpenxmlPresentation: "application/vnd.openxmlformats-officedocument.presentationml.presentation", + ApplicationRtf: "application/rtf", + ApplicationXNdjson: "application/x-ndjson", + ApplicationParquet: "application/vnd.apache.parquet", + ApplicationGzip: "application/gzip", + ApplicationXTar: "application/x-tar", + ApplicationX7ZCompressed: "application/x-7z-compressed" +}; +var models_exports = {}; +__export2(models_exports, { + ModelTokenizerId: () => ModelTokenizerId +}); +var ModelTokenizerId = { + Openai: "openai", + Claude: "claude" +}; +var organizations_exports = {}; +__export2(organizations_exports, { + MembershipRole: () => MembershipRole +}); +var MembershipRole = { + Owner: "OWNER", + Admin: "ADMIN", + Member: "MEMBER", + Viewer: "VIEWER" +}; +var prompts_exports = {}; +__export2(prompts_exports, { + ChatMessageType: () => ChatMessageType, + CreateChatPromptType: () => CreateChatPromptType, + CreateTextPromptType: () => CreateTextPromptType, + PlaceholderMessageType: () => PlaceholderMessageType, + PromptType: () => PromptType +}); +var PromptType = { + Chat: "chat", + Text: "text" +}; +var ChatMessageType = { + Chatmessage: "chatmessage" +}; +var PlaceholderMessageType = { + Placeholder: "placeholder" +}; +var CreateChatPromptType = { + Chat: "chat" +}; +var CreateTextPromptType = { + Text: "text" +}; +var scores_exports = {}; +__export2(scores_exports, { + CreateScoreSource: () => CreateScoreSource +}); +var unstable_exports = {}; +__export2(unstable_exports, { + AccessDeniedError: () => AccessDeniedError2, + BadRequestError: () => BadRequestError2, + ConflictError: () => ConflictError2, + DashboardWidgetChartType: () => DashboardWidgetChartType, + DashboardWidgetMetricAggregation: () => DashboardWidgetMetricAggregation, + DashboardWidgetSortOrder: () => DashboardWidgetSortOrder, + DashboardWidgetView: () => DashboardWidgetView, + DashboardWidgetViewWithLegacy: () => DashboardWidgetViewWithLegacy, + InternalServerError: () => InternalServerError2, + MethodNotAllowedError: () => MethodNotAllowedError2, + NotFoundError: () => NotFoundError2, + PublicApiErrorCode: () => PublicApiErrorCode2, + TooManyRequestsError: () => TooManyRequestsError2, + UnauthorizedError: () => UnauthorizedError2, + dashboardWidgets: () => dashboardWidgets_exports, + dashboards: () => dashboards_exports, + errors: () => errors_exports2 +}); +var dashboardWidgets_exports = {}; +__export2(dashboardWidgets_exports, { + DashboardWidgetChartType: () => DashboardWidgetChartType, + DashboardWidgetMetricAggregation: () => DashboardWidgetMetricAggregation, + DashboardWidgetSortOrder: () => DashboardWidgetSortOrder, + DashboardWidgetView: () => DashboardWidgetView, + DashboardWidgetViewWithLegacy: () => DashboardWidgetViewWithLegacy +}); +var DashboardWidgetView = { + Observations: "observations", + ScoresNumeric: "scores-numeric", + ScoresBoolean: "scores-boolean", + ScoresCategorical: "scores-categorical" +}; +var DashboardWidgetViewWithLegacy = { + Observations: "observations", + ScoresNumeric: "scores-numeric", + ScoresBoolean: "scores-boolean", + ScoresCategorical: "scores-categorical", + Traces: "traces" +}; +var DashboardWidgetChartType = { + LineTimeSeries: "LINE_TIME_SERIES", + AreaTimeSeries: "AREA_TIME_SERIES", + BarTimeSeries: "BAR_TIME_SERIES", + HorizontalBar: "HORIZONTAL_BAR", + VerticalBar: "VERTICAL_BAR", + Pie: "PIE", + Number: "NUMBER", + Histogram: "HISTOGRAM", + PivotTable: "PIVOT_TABLE" +}; +var DashboardWidgetMetricAggregation = { + Sum: "sum", + Avg: "avg", + Count: "count", + Max: "max", + Min: "min", + P50: "p50", + P75: "p75", + P90: "p90", + P95: "p95", + P99: "p99", + Histogram: "histogram", + Uniq: "uniq" +}; +var DashboardWidgetSortOrder = { + Asc: "ASC", + Desc: "DESC" +}; +var dashboards_exports = {}; +var errors_exports2 = {}; +__export2(errors_exports2, { + AccessDeniedError: () => AccessDeniedError2, + BadRequestError: () => BadRequestError2, + ConflictError: () => ConflictError2, + InternalServerError: () => InternalServerError2, + MethodNotAllowedError: () => MethodNotAllowedError2, + NotFoundError: () => NotFoundError2, + PublicApiErrorCode: () => PublicApiErrorCode2, + TooManyRequestsError: () => TooManyRequestsError2, + UnauthorizedError: () => UnauthorizedError2 +}); +var PublicApiErrorCode2 = { + AuthenticationFailed: "authentication_failed", + AccessDenied: "access_denied", + InvalidRequest: "invalid_request", + InvalidQuery: "invalid_query", + InvalidBody: "invalid_body", + ResourceNotFound: "resource_not_found", + Conflict: "conflict", + RateLimited: "rate_limited", + MethodNotAllowed: "method_not_allowed", + InternalError: "internal_error" +}; +var BadRequestError2 = class _BadRequestError2 extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "BadRequestError", + statusCode: 400, + body, + rawResponse + }); + Object.setPrototypeOf(this, _BadRequestError2.prototype); + } +}; +var UnauthorizedError2 = class _UnauthorizedError2 extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "UnauthorizedError", + statusCode: 401, + body, + rawResponse + }); + Object.setPrototypeOf(this, _UnauthorizedError2.prototype); + } +}; +var AccessDeniedError2 = class _AccessDeniedError2 extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "AccessDeniedError", + statusCode: 403, + body, + rawResponse + }); + Object.setPrototypeOf(this, _AccessDeniedError2.prototype); + } +}; +var NotFoundError2 = class _NotFoundError2 extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "NotFoundError", + statusCode: 404, + body, + rawResponse + }); + Object.setPrototypeOf(this, _NotFoundError2.prototype); + } +}; +var MethodNotAllowedError2 = class _MethodNotAllowedError2 extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "MethodNotAllowedError", + statusCode: 405, + body, + rawResponse + }); + Object.setPrototypeOf(this, _MethodNotAllowedError2.prototype); + } +}; +var ConflictError2 = class _ConflictError2 extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "ConflictError", + statusCode: 409, + body, + rawResponse + }); + Object.setPrototypeOf(this, _ConflictError2.prototype); + } +}; +var TooManyRequestsError2 = class _TooManyRequestsError2 extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "TooManyRequestsError", + statusCode: 429, + body, + rawResponse + }); + Object.setPrototypeOf(this, _TooManyRequestsError2.prototype); + } +}; +var InternalServerError2 = class _InternalServerError2 extends LangfuseAPIError { + constructor(body, rawResponse) { + super({ + message: "InternalServerError", + statusCode: 500, + body, + rawResponse + }); + Object.setPrototypeOf(this, _InternalServerError2.prototype); + } +}; +var utils_exports = {}; +__export2(utils_exports, { + pagination: () => pagination_exports +}); +var pagination_exports = {}; +function mergeHeaders(...headersArray) { + const result = {}; + for (const [key, value] of headersArray.filter((headers) => headers != null).flatMap((headers) => Object.entries(headers))) { + if (value != null) { + result[key] = value; + } else if (key in result) { + delete result[key]; + } + } + return result; +} +function mergeOnlyDefinedHeaders(...headersArray) { + const result = {}; + for (const [key, value] of headersArray.filter((headers) => headers != null).flatMap((headers) => Object.entries(headers))) { + if (value != null) { + result[key] = value; + } + } + return result; +} +var defaultQsOptions = { + arrayFormat: "indices", + encode: true +}; +function encodeValue(value, shouldEncode) { + if (value === void 0) { + return ""; + } + if (value === null) { + return ""; + } + const stringValue = String(value); + return shouldEncode ? encodeURIComponent(stringValue) : stringValue; +} +function stringifyObject(obj, prefix = "", options) { + const parts = []; + for (const [key, value] of Object.entries(obj)) { + const fullKey = prefix ? `${prefix}[${key}]` : key; + if (value === void 0) { + continue; + } + if (Array.isArray(value)) { + if (value.length === 0) { + continue; + } + for (let i = 0; i < value.length; i++) { + const item = value[i]; + if (item === void 0) { + continue; + } + if (typeof item === "object" && !Array.isArray(item) && item !== null) { + const arrayKey = options.arrayFormat === "indices" ? `${fullKey}[${i}]` : fullKey; + parts.push( + ...stringifyObject( + item, + arrayKey, + options + ) + ); + } else { + const arrayKey = options.arrayFormat === "indices" ? `${fullKey}[${i}]` : fullKey; + const encodedKey = options.encode ? encodeURIComponent(arrayKey) : arrayKey; + parts.push(`${encodedKey}=${encodeValue(item, options.encode)}`); + } + } + } else if (typeof value === "object" && value !== null) { + if (Object.keys(value).length === 0) { + continue; + } + parts.push( + ...stringifyObject(value, fullKey, options) + ); + } else { + const encodedKey = options.encode ? encodeURIComponent(fullKey) : fullKey; + parts.push(`${encodedKey}=${encodeValue(value, options.encode)}`); + } + } + return parts; +} +function toQueryString(obj, options) { + if (obj == null || typeof obj !== "object") { + return ""; + } + const parts = stringifyObject(obj, "", { + ...defaultQsOptions, + ...options + }); + return parts.join("&"); +} +function createRequestUrl(baseUrl, queryParameters) { + const queryString = toQueryString(queryParameters, { arrayFormat: "repeat" }); + return queryString ? `${baseUrl}?${queryString}` : baseUrl; +} +function getBinaryResponse(response) { + const binaryResponse = { + get bodyUsed() { + return response.bodyUsed; + }, + stream: () => response.body, + arrayBuffer: response.arrayBuffer.bind(response), + blob: response.blob.bind(response) + }; + if ("bytes" in response && typeof response.bytes === "function") { + binaryResponse.bytes = response.bytes.bind(response); + } + return binaryResponse; +} +function isResponseWithBody(response) { + return response.body != null; +} +async function getResponseBody(response, responseType) { + if (!isResponseWithBody(response)) { + return void 0; + } + switch (responseType) { + case "binary-response": + return getBinaryResponse(response); + case "blob": + return await response.blob(); + case "arrayBuffer": + return await response.arrayBuffer(); + case "sse": + return response.body; + case "streaming": + return response.body; + case "text": + return await response.text(); + } + const text = await response.text(); + if (text.length > 0) { + try { + let responseBody = fromJson(text); + return responseBody; + } catch (err) { + return { + ok: false, + error: { + reason: "non-json", + statusCode: response.status, + rawBody: text + } + }; + } + } + return void 0; +} +async function getErrorResponseBody(response) { + var _a2, _b, _c; + let contentType = (_a2 = response.headers.get("Content-Type")) == null ? void 0 : _a2.toLowerCase(); + if (contentType == null || contentType.length === 0) { + return getResponseBody(response); + } + if (contentType.indexOf(";") !== -1) { + contentType = (_c = (_b = contentType.split(";")[0]) == null ? void 0 : _b.trim()) != null ? _c : ""; + } + switch (contentType) { + case "application/hal+json": + case "application/json": + case "application/ld+json": + case "application/problem+json": + case "application/vnd.api+json": + case "text/json": + const text = await response.text(); + return text.length > 0 ? fromJson(text) : void 0; + default: + if (contentType.startsWith("application/vnd.") && contentType.endsWith("+json")) { + const text2 = await response.text(); + return text2.length > 0 ? fromJson(text2) : void 0; + } + return await response.text(); + } +} +async function getFetchFn() { + return fetch; +} +async function getRequestBody({ + body, + type +}) { + if (type.includes("json")) { + return toJson(body); + } else { + return body; + } +} +var TIMEOUT = "timeout"; +function getTimeoutSignal(timeoutMs) { + const controller = new AbortController(); + const abortId = setTimeout(() => controller.abort(TIMEOUT), timeoutMs); + return { signal: controller.signal, abortId }; +} +function anySignal(...args) { + const signals = args.length === 1 && Array.isArray(args[0]) ? args[0] : args; + const controller = new AbortController(); + for (const signal of signals) { + if (signal.aborted) { + controller.abort(signal == null ? void 0 : signal.reason); + break; + } + signal.addEventListener( + "abort", + () => controller.abort(signal == null ? void 0 : signal.reason), + { + signal: controller.signal + } + ); + } + return controller.signal; +} +var makeRequest = async (fetchFn, url, method, headers, requestBody, timeoutMs, abortSignal, withCredentials, duplex) => { + const signals = []; + let timeoutAbortId = void 0; + if (timeoutMs != null) { + const { signal, abortId } = getTimeoutSignal(timeoutMs); + timeoutAbortId = abortId; + signals.push(signal); + } + if (abortSignal != null) { + signals.push(abortSignal); + } + let newSignals = anySignal(signals); + const response = await fetchFn(url, { + method, + headers, + body: requestBody, + signal: newSignals, + credentials: withCredentials ? "include" : void 0, + // @ts-ignore + duplex + }); + if (timeoutAbortId != null) { + clearTimeout(timeoutAbortId); + } + return response; +}; +var Headers; +if (typeof globalThis.Headers !== "undefined") { + Headers = globalThis.Headers; +} else { + Headers = class Headers2 { + constructor(init) { + this.headers = /* @__PURE__ */ new Map(); + if (init) { + if (init instanceof Headers2) { + init.forEach((value, key) => this.append(key, value)); + } else if (Array.isArray(init)) { + for (const [key, value] of init) { + if (typeof key === "string" && typeof value === "string") { + this.append(key, value); + } else { + throw new TypeError( + "Each header entry must be a [string, string] tuple" + ); + } + } + } else { + for (const [key, value] of Object.entries(init)) { + if (typeof value === "string") { + this.append(key, value); + } else { + throw new TypeError("Header values must be strings"); + } + } + } + } + } + append(name, value) { + const key = name.toLowerCase(); + const existing = this.headers.get(key) || []; + this.headers.set(key, [...existing, value]); + } + delete(name) { + const key = name.toLowerCase(); + this.headers.delete(key); + } + get(name) { + const key = name.toLowerCase(); + const values = this.headers.get(key); + return values ? values.join(", ") : null; + } + has(name) { + const key = name.toLowerCase(); + return this.headers.has(key); + } + set(name, value) { + const key = name.toLowerCase(); + this.headers.set(key, [value]); + } + forEach(callbackfn, thisArg) { + const boundCallback = thisArg ? callbackfn.bind(thisArg) : callbackfn; + this.headers.forEach( + (values, key) => boundCallback(values.join(", "), key, this) + ); + } + getSetCookie() { + return this.headers.get("set-cookie") || []; + } + *entries() { + for (const [key, values] of this.headers.entries()) { + yield [key, values.join(", ")]; + } + } + *keys() { + yield* this.headers.keys(); + } + *values() { + for (const values of this.headers.values()) { + yield values.join(", "); + } + } + [Symbol.iterator]() { + return this.entries(); + } + }; +} +var abortRawResponse = { + headers: new Headers(), + redirected: false, + status: 499, + statusText: "Client Closed Request", + type: "error", + url: "" +}; +var unknownRawResponse = { + headers: new Headers(), + redirected: false, + status: 0, + statusText: "Unknown Error", + type: "error", + url: "" +}; +function toRawResponse(response) { + return { + headers: response.headers, + redirected: response.redirected, + status: response.status, + statusText: response.statusText, + type: response.type, + url: response.url + }; +} +var INITIAL_RETRY_DELAY = 1e3; +var MAX_RETRY_DELAY = 6e4; +var DEFAULT_MAX_RETRIES = 2; +var JITTER_FACTOR = 0.2; +function addPositiveJitter(delay) { + const jitterMultiplier = 1 + Math.random() * JITTER_FACTOR; + return delay * jitterMultiplier; +} +function addSymmetricJitter(delay) { + const jitterMultiplier = 1 + (Math.random() - 0.5) * JITTER_FACTOR; + return delay * jitterMultiplier; +} +function getRetryDelayFromHeaders(response, retryAttempt) { + const retryAfter = response.headers.get("Retry-After"); + if (retryAfter) { + const retryAfterSeconds = parseInt(retryAfter, 10); + if (!isNaN(retryAfterSeconds) && retryAfterSeconds > 0) { + return Math.min(retryAfterSeconds * 1e3, MAX_RETRY_DELAY); + } + const retryAfterDate = new Date(retryAfter); + if (!isNaN(retryAfterDate.getTime())) { + const delay = retryAfterDate.getTime() - Date.now(); + if (delay > 0) { + return Math.min(Math.max(delay, 0), MAX_RETRY_DELAY); + } + } + } + const rateLimitReset = response.headers.get("X-RateLimit-Reset"); + if (rateLimitReset) { + const resetTime = parseInt(rateLimitReset, 10); + if (!isNaN(resetTime)) { + const delay = resetTime * 1e3 - Date.now(); + if (delay > 0) { + return addPositiveJitter(Math.min(delay, MAX_RETRY_DELAY)); + } + } + } + return addSymmetricJitter( + Math.min(INITIAL_RETRY_DELAY * Math.pow(2, retryAttempt), MAX_RETRY_DELAY) + ); +} +async function requestWithRetries(requestFn, maxRetries = DEFAULT_MAX_RETRIES) { + let response = await requestFn(); + for (let i = 0; i < maxRetries; ++i) { + if ([408, 429].includes(response.status) || response.status >= 500) { + const delay = getRetryDelayFromHeaders(response, i); + await new Promise((resolve2) => setTimeout(resolve2, delay)); + response = await requestFn(); + } else { + break; + } + } + return response; +} +var Supplier = { + get: async (supplier) => { + if (typeof supplier === "function") { + return supplier(); + } else { + return supplier; + } + } +}; +async function getHeaders(args) { + const newHeaders = {}; + if (args.body !== void 0 && args.contentType != null) { + newHeaders["Content-Type"] = args.contentType; + } + if (args.headers == null) { + return newHeaders; + } + for (const [key, value] of Object.entries(args.headers)) { + const result = await Supplier.get(value); + if (typeof result === "string") { + newHeaders[key] = result; + continue; + } + if (result == null) { + continue; + } + newHeaders[key] = `${result}`; + } + return newHeaders; +} +async function fetcherImpl(args) { + const url = createRequestUrl(args.url, args.queryParameters); + const requestBody = await getRequestBody({ + body: args.body, + type: args.requestType === "json" ? "json" : "other" + }); + const fetchFn = await getFetchFn(); + try { + const response = await requestWithRetries( + async () => makeRequest( + fetchFn, + url, + args.method, + await getHeaders(args), + requestBody, + args.timeoutMs, + args.abortSignal, + args.withCredentials, + args.duplex + ), + args.maxRetries + ); + if (response.status >= 200 && response.status < 400) { + return { + ok: true, + body: await getResponseBody(response, args.responseType), + headers: response.headers, + rawResponse: toRawResponse(response) + }; + } else { + return { + ok: false, + error: { + reason: "status-code", + statusCode: response.status, + body: await getErrorResponseBody(response) + }, + rawResponse: toRawResponse(response) + }; + } + } catch (error) { + if (args.abortSignal != null && args.abortSignal.aborted) { + return { + ok: false, + error: { + reason: "unknown", + errorMessage: "The user aborted a request" + }, + rawResponse: abortRawResponse + }; + } else if (error instanceof Error && error.name === "AbortError") { + return { + ok: false, + error: { + reason: "timeout" + }, + rawResponse: abortRawResponse + }; + } else if (error instanceof Error) { + return { + ok: false, + error: { + reason: "unknown", + errorMessage: error.message + }, + rawResponse: unknownRawResponse + }; + } + return { + ok: false, + error: { + reason: "unknown", + errorMessage: toJson(error) + }, + rawResponse: unknownRawResponse + }; + } +} +var fetcher = fetcherImpl; +var HttpResponsePromise = class _HttpResponsePromise extends Promise { + constructor(promise) { + super((resolve2) => { + resolve2(void 0); + }); + this.innerPromise = promise; + } + /** + * Creates an `HttpResponsePromise` from a function that returns a promise. + * + * @param fn - A function that returns a promise resolving to a `WithRawResponse` object. + * @param args - Arguments to pass to the function. + * @returns An `HttpResponsePromise` instance. + */ + static fromFunction(fn, ...args) { + return new _HttpResponsePromise(fn(...args)); + } + /** + * Creates a function that returns an `HttpResponsePromise` from a function that returns a promise. + * + * @param fn - A function that returns a promise resolving to a `WithRawResponse` object. + * @returns A function that returns an `HttpResponsePromise` instance. + */ + static interceptFunction(fn) { + return (...args) => { + return _HttpResponsePromise.fromPromise(fn(...args)); + }; + } + /** + * Creates an `HttpResponsePromise` from an existing promise. + * + * @param promise - A promise resolving to a `WithRawResponse` object. + * @returns An `HttpResponsePromise` instance. + */ + static fromPromise(promise) { + return new _HttpResponsePromise(promise); + } + /** + * Creates an `HttpResponsePromise` from an executor function. + * + * @param executor - A function that takes resolve and reject callbacks to create a promise. + * @returns An `HttpResponsePromise` instance. + */ + static fromExecutor(executor) { + const promise = new Promise(executor); + return new _HttpResponsePromise(promise); + } + /** + * Creates an `HttpResponsePromise` from a resolved result. + * + * @param result - A `WithRawResponse` object to resolve immediately. + * @returns An `HttpResponsePromise` instance. + */ + static fromResult(result) { + const promise = Promise.resolve(result); + return new _HttpResponsePromise(promise); + } + unwrap() { + if (!this.unwrappedPromise) { + this.unwrappedPromise = this.innerPromise.then(({ data }) => data); + } + return this.unwrappedPromise; + } + /** @inheritdoc */ + then(onfulfilled, onrejected) { + return this.unwrap().then(onfulfilled, onrejected); + } + /** @inheritdoc */ + catch(onrejected) { + return this.unwrap().catch(onrejected); + } + /** @inheritdoc */ + finally(onfinally) { + return this.unwrap().finally(onfinally); + } + /** + * Retrieves the data and raw response. + * + * @returns A promise resolving to a `WithRawResponse` object. + */ + async withRawResponse() { + return await this.innerPromise; + } +}; +var url_exports = {}; +__export2(url_exports, { + join: () => join3, + toQueryString: () => toQueryString +}); +function join3(base, ...segments) { + if (!base) { + return ""; + } + if (segments.length === 0) { + return base; + } + if (base.includes("://")) { + let url; + try { + url = new URL(base); + } catch { + return joinPath(base, ...segments); + } + const lastSegment = segments[segments.length - 1]; + const shouldPreserveTrailingSlash = lastSegment && lastSegment.endsWith("/"); + for (const segment of segments) { + const cleanSegment = trimSlashes(segment); + if (cleanSegment) { + url.pathname = joinPathSegments(url.pathname, cleanSegment); + } + } + if (shouldPreserveTrailingSlash && !url.pathname.endsWith("/")) { + url.pathname += "/"; + } + return url.toString(); + } + return joinPath(base, ...segments); +} +function joinPath(base, ...segments) { + if (segments.length === 0) { + return base; + } + let result = base; + const lastSegment = segments[segments.length - 1]; + const shouldPreserveTrailingSlash = lastSegment && lastSegment.endsWith("/"); + for (const segment of segments) { + const cleanSegment = trimSlashes(segment); + if (cleanSegment) { + result = joinPathSegments(result, cleanSegment); + } + } + if (shouldPreserveTrailingSlash && !result.endsWith("/")) { + result += "/"; + } + return result; +} +function joinPathSegments(left, right) { + if (left.endsWith("/")) { + return left + right; + } + return left + "/" + right; +} +function trimSlashes(str) { + if (!str) return str; + let start = 0; + let end = str.length; + if (str.startsWith("/")) start = 1; + if (str.endsWith("/")) end = str.length - 1; + return start === 0 && end === str.length ? str : str.slice(start, end); +} +function base64ToBytes2(base64) { + const binString = atob(base64); + return Uint8Array.from(binString, (m) => m.codePointAt(0)); +} +function bytesToBase642(bytes) { + const binString = String.fromCodePoint(...bytes); + return btoa(binString); +} +function base64Encode2(input) { + if (typeof Buffer !== "undefined") { + return Buffer.from(input, "utf8").toString("base64"); + } + const bytes = new TextEncoder().encode(input); + return bytesToBase642(bytes); +} +function base64Decode2(input) { + if (typeof Buffer !== "undefined") { + return Buffer.from(input, "base64").toString("utf8"); + } + const bytes = base64ToBytes2(input); + return new TextDecoder().decode(bytes); +} +var BASIC_AUTH_HEADER_PREFIX = /^Basic /i; +var BasicAuth = { + toAuthorizationHeader: (basicAuth) => { + if (basicAuth == null) { + return void 0; + } + const token = base64Encode2(`${basicAuth.username}:${basicAuth.password}`); + return `Basic ${token}`; + }, + fromAuthorizationHeader: (header) => { + const credentials = header.replace(BASIC_AUTH_HEADER_PREFIX, ""); + const decoded = base64Decode2(credentials); + const [username, password] = decoded.split(":", 2); + if (username == null || password == null) { + throw new Error("Invalid basic auth"); + } + return { + username, + password + }; + } +}; +var AnnotationQueues = class { + constructor(_options) { + this._options = _options; + } + /** + * Get all annotation queues + * + * @param {LangfuseAPI.GetAnnotationQueuesRequest} request + * @param {AnnotationQueues.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.annotationQueues.listQueues() + */ + listQueues(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__listQueues(request, requestOptions) + ); + } + async __listQueues(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { page, limit } = request; + const _queryParams = {}; + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/annotation-queues" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/annotation-queues." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Create an annotation queue + * + * @param {LangfuseAPI.CreateAnnotationQueueRequest} request + * @param {AnnotationQueues.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.annotationQueues.createQueue({ + * name: "name", + * description: undefined, + * scoreConfigIds: ["scoreConfigIds", "scoreConfigIds"] + * }) + */ + createQueue(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__createQueue(request, requestOptions) + ); + } + async __createQueue(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/annotation-queues" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/annotation-queues." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get an annotation queue by ID + * + * @param {string} queueId - The unique identifier of the annotation queue + * @param {AnnotationQueues.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.annotationQueues.getQueue("queueId") + */ + getQueue(queueId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getQueue(queueId, requestOptions) + ); + } + async __getQueue(queueId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/annotation-queues/${encodeURIComponent(queueId)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/annotation-queues/{queueId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get items for a specific annotation queue + * + * @param {string} queueId - The unique identifier of the annotation queue + * @param {LangfuseAPI.GetAnnotationQueueItemsRequest} request + * @param {AnnotationQueues.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.annotationQueues.listQueueItems("queueId") + */ + listQueueItems(queueId, request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__listQueueItems(queueId, request, requestOptions) + ); + } + async __listQueueItems(queueId, request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { status, page, limit } = request; + const _queryParams = {}; + if (status != null) { + _queryParams["status"] = status; + } + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/annotation-queues/${encodeURIComponent(queueId)}/items` + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/annotation-queues/{queueId}/items." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a specific item from an annotation queue + * + * @param {string} queueId - The unique identifier of the annotation queue + * @param {string} itemId - The unique identifier of the annotation queue item + * @param {AnnotationQueues.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.annotationQueues.getQueueItem("queueId", "itemId") + */ + getQueueItem(queueId, itemId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getQueueItem(queueId, itemId, requestOptions) + ); + } + async __getQueueItem(queueId, itemId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/annotation-queues/${encodeURIComponent(queueId)}/items/${encodeURIComponent(itemId)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/annotation-queues/{queueId}/items/{itemId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Add an item to an annotation queue + * + * @param {string} queueId - The unique identifier of the annotation queue + * @param {LangfuseAPI.CreateAnnotationQueueItemRequest} request + * @param {AnnotationQueues.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.annotationQueues.createQueueItem("queueId", { + * objectId: "objectId", + * objectType: "TRACE", + * status: undefined + * }) + */ + createQueueItem(queueId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__createQueueItem(queueId, request, requestOptions) + ); + } + async __createQueueItem(queueId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/annotation-queues/${encodeURIComponent(queueId)}/items` + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/annotation-queues/{queueId}/items." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Update an annotation queue item + * + * @param {string} queueId - The unique identifier of the annotation queue + * @param {string} itemId - The unique identifier of the annotation queue item + * @param {LangfuseAPI.UpdateAnnotationQueueItemRequest} request + * @param {AnnotationQueues.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.annotationQueues.updateQueueItem("queueId", "itemId", { + * status: undefined + * }) + */ + updateQueueItem(queueId, itemId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__updateQueueItem(queueId, itemId, request, requestOptions) + ); + } + async __updateQueueItem(queueId, itemId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/annotation-queues/${encodeURIComponent(queueId)}/items/${encodeURIComponent(itemId)}` + ), + method: "PATCH", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PATCH /api/public/annotation-queues/{queueId}/items/{itemId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Remove an item from an annotation queue + * + * @param {string} queueId - The unique identifier of the annotation queue + * @param {string} itemId - The unique identifier of the annotation queue item + * @param {AnnotationQueues.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.annotationQueues.deleteQueueItem("queueId", "itemId") + */ + deleteQueueItem(queueId, itemId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__deleteQueueItem(queueId, itemId, requestOptions) + ); + } + async __deleteQueueItem(queueId, itemId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/annotation-queues/${encodeURIComponent(queueId)}/items/${encodeURIComponent(itemId)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/annotation-queues/{queueId}/items/{itemId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Create an assignment for a user to an annotation queue + * + * @param {string} queueId - The unique identifier of the annotation queue + * @param {LangfuseAPI.AnnotationQueueAssignmentRequest} request + * @param {AnnotationQueues.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.annotationQueues.createQueueAssignment("queueId", { + * userId: "userId" + * }) + */ + createQueueAssignment(queueId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__createQueueAssignment(queueId, request, requestOptions) + ); + } + async __createQueueAssignment(queueId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/annotation-queues/${encodeURIComponent(queueId)}/assignments` + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/annotation-queues/{queueId}/assignments." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete an assignment for a user to an annotation queue + * + * @param {string} queueId - The unique identifier of the annotation queue + * @param {LangfuseAPI.AnnotationQueueAssignmentRequest} request + * @param {AnnotationQueues.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.annotationQueues.deleteQueueAssignment("queueId", { + * userId: "userId" + * }) + */ + deleteQueueAssignment(queueId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__deleteQueueAssignment(queueId, request, requestOptions) + ); + } + async __deleteQueueAssignment(queueId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/annotation-queues/${encodeURIComponent(queueId)}/assignments` + ), + method: "DELETE", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/annotation-queues/{queueId}/assignments." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var BlobStorageIntegrations = class { + constructor(_options) { + this._options = _options; + } + /** + * Get all blob storage integrations for the organization (requires organization-scoped API key) + * + * @param {BlobStorageIntegrations.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.blobStorageIntegrations.getBlobStorageIntegrations() + */ + getBlobStorageIntegrations(requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getBlobStorageIntegrations(requestOptions) + ); + } + async __getBlobStorageIntegrations(requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/integrations/blob-storage" + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/integrations/blob-storage." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Create or update a blob storage integration for a specific project (requires organization-scoped API key). The configuration is validated by performing a test upload to the bucket. + * + * @param {LangfuseAPI.CreateBlobStorageIntegrationRequest} request + * @param {BlobStorageIntegrations.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.blobStorageIntegrations.upsertBlobStorageIntegration({ + * projectId: "projectId", + * type: "S3", + * bucketName: "bucketName", + * endpoint: undefined, + * region: "region", + * accessKeyId: undefined, + * secretAccessKey: undefined, + * prefix: undefined, + * exportFrequency: "every_20_minutes", + * enabled: true, + * forcePathStyle: true, + * fileType: "JSON", + * exportMode: "FULL_HISTORY", + * exportStartDate: undefined, + * compressed: undefined, + * exportSource: undefined, + * exportFieldGroups: undefined + * }) + */ + upsertBlobStorageIntegration(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__upsertBlobStorageIntegration(request, requestOptions) + ); + } + async __upsertBlobStorageIntegration(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/integrations/blob-storage" + ), + method: "PUT", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PUT /api/public/integrations/blob-storage." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get the sync status of a blob storage integration by integration ID (requires organization-scoped API key) + * + * @param {string} id + * @param {BlobStorageIntegrations.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.blobStorageIntegrations.getBlobStorageIntegrationStatus("id") + */ + getBlobStorageIntegrationStatus(id, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getBlobStorageIntegrationStatus(id, requestOptions) + ); + } + async __getBlobStorageIntegrationStatus(id, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/integrations/blob-storage/${encodeURIComponent(id)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/integrations/blob-storage/{id}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete a blob storage integration by ID (requires organization-scoped API key) + * + * @param {string} id + * @param {BlobStorageIntegrations.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.blobStorageIntegrations.deleteBlobStorageIntegration("id") + */ + deleteBlobStorageIntegration(id, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__deleteBlobStorageIntegration(id, requestOptions) + ); + } + async __deleteBlobStorageIntegration(id, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/integrations/blob-storage/${encodeURIComponent(id)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/integrations/blob-storage/{id}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Comments = class { + constructor(_options) { + this._options = _options; + } + /** + * Create a comment. Comments may be attached to different object types (trace, observation, session, prompt). + * + * @param {LangfuseAPI.CreateCommentRequest} request + * @param {Comments.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.comments.create({ + * projectId: "projectId", + * objectType: "objectType", + * objectId: "objectId", + * content: "content", + * authorUserId: undefined + * }) + */ + create(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__create(request, requestOptions) + ); + } + async __create(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/comments" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/comments." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get all comments + * + * @param {LangfuseAPI.GetCommentsRequest} request + * @param {Comments.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.comments.get() + */ + get(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__get(request, requestOptions) + ); + } + async __get(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { page, limit, objectType, objectId, authorUserId } = request; + const _queryParams = {}; + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + if (objectType != null) { + _queryParams["objectType"] = objectType; + } + if (objectId != null) { + _queryParams["objectId"] = objectId; + } + if (authorUserId != null) { + _queryParams["authorUserId"] = authorUserId; + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/comments" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/comments." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a comment by id + * + * @param {string} commentId - The unique langfuse identifier of a comment + * @param {Comments.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.comments.getById("commentId") + */ + getById(commentId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getById(commentId, requestOptions) + ); + } + async __getById(commentId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/comments/${encodeURIComponent(commentId)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/comments/{commentId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var DatasetItems = class { + constructor(_options) { + this._options = _options; + } + /** + * Create a dataset item + * + * @param {LangfuseAPI.CreateDatasetItemRequest} request + * @param {DatasetItems.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.datasetItems.create({ + * datasetName: "datasetName", + * input: undefined, + * expectedOutput: undefined, + * metadata: undefined, + * sourceTraceId: undefined, + * sourceObservationId: undefined, + * id: undefined, + * status: undefined + * }) + */ + create(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__create(request, requestOptions) + ); + } + async __create(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/dataset-items" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/dataset-items." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a dataset item + * + * @param {string} id + * @param {DatasetItems.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.datasetItems.get("id") + */ + get(id, requestOptions) { + return HttpResponsePromise.fromPromise(this.__get(id, requestOptions)); + } + async __get(id, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/dataset-items/${encodeURIComponent(id)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/dataset-items/{id}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get dataset items. Optionally specify a version to get the items as they existed at that point in time. + * Note: If version parameter is provided, datasetName must also be provided. + * + * @param {LangfuseAPI.GetDatasetItemsRequest} request + * @param {DatasetItems.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.datasetItems.list() + */ + list(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__list(request, requestOptions) + ); + } + async __list(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { + datasetName, + sourceTraceId, + sourceObservationId, + version, + page, + limit + } = request; + const _queryParams = {}; + if (datasetName != null) { + _queryParams["datasetName"] = datasetName; + } + if (sourceTraceId != null) { + _queryParams["sourceTraceId"] = sourceTraceId; + } + if (sourceObservationId != null) { + _queryParams["sourceObservationId"] = sourceObservationId; + } + if (version != null) { + _queryParams["version"] = version; + } + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/dataset-items" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/dataset-items." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete a dataset item and all its run items. This action is irreversible. + * + * @param {string} id + * @param {DatasetItems.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.datasetItems.delete("id") + */ + delete(id, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__delete(id, requestOptions) + ); + } + async __delete(id, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/dataset-items/${encodeURIComponent(id)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/dataset-items/{id}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var DatasetRunItems = class { + constructor(_options) { + this._options = _options; + } + /** + * Create a dataset run item + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. In Langfuse v4, create experiment data via the SDK experiment runner or the OpenTelemetry endpoint at POST /api/public/otel/v1/traces. Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {LangfuseAPI.CreateDatasetRunItemRequest} request + * @param {DatasetRunItems.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.datasetRunItems.create({ + * runName: "runName", + * runDescription: undefined, + * metadata: undefined, + * datasetItemId: "datasetItemId", + * observationId: undefined, + * traceId: undefined, + * datasetVersion: undefined, + * createdAt: undefined + * }) + */ + create(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__create(request, requestOptions) + ); + } + async __create(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/dataset-run-items" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/dataset-run-items." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * List dataset run items + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. In Langfuse v4, dataset run items are replaced by experiment items; use `GET /api/public/experiment-items?fromStartTime=&toStartTime=` instead. Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {LangfuseAPI.ListDatasetRunItemsRequest} request + * @param {DatasetRunItems.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.datasetRunItems.list({ + * datasetId: "datasetId", + * runName: "runName" + * }) + */ + list(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__list(request, requestOptions) + ); + } + async __list(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { datasetId, runName, page, limit } = request; + const _queryParams = {}; + _queryParams["datasetId"] = datasetId; + _queryParams["runName"] = runName; + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/dataset-run-items" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/dataset-run-items." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Datasets = class { + constructor(_options) { + this._options = _options; + } + /** + * Get all datasets + * + * @param {LangfuseAPI.GetDatasetsRequest} request + * @param {Datasets.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.datasets.list() + */ + list(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__list(request, requestOptions) + ); + } + async __list(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { page, limit } = request; + const _queryParams = {}; + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/v2/datasets" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/v2/datasets." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a dataset + * + * @param {string} datasetName + * @param {Datasets.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.datasets.get("datasetName") + */ + get(datasetName, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__get(datasetName, requestOptions) + ); + } + async __get(datasetName, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/v2/datasets/${encodeURIComponent(datasetName)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/v2/datasets/{datasetName}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Create a dataset + * + * @param {LangfuseAPI.CreateDatasetRequest} request + * @param {Datasets.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.datasets.create({ + * name: "name", + * description: undefined, + * metadata: undefined, + * inputSchema: undefined, + * expectedOutputSchema: undefined + * }) + */ + create(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__create(request, requestOptions) + ); + } + async __create(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/v2/datasets" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/v2/datasets." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a dataset run and its items + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. In Langfuse v4, dataset runs are replaced by experiments; use GET /api/public/experiments instead. Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {string} datasetName + * @param {string} runName + * @param {Datasets.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.datasets.getRun("datasetName", "runName") + */ + getRun(datasetName, runName, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getRun(datasetName, runName, requestOptions) + ); + } + async __getRun(datasetName, runName, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/datasets/${encodeURIComponent(datasetName)}/runs/${encodeURIComponent(runName)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/datasets/{datasetName}/runs/{runName}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete a dataset run and all its run items. This action is irreversible. + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. In Langfuse v4, dataset runs are replaced by experiments. Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {string} datasetName + * @param {string} runName + * @param {Datasets.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.datasets.deleteRun("datasetName", "runName") + */ + deleteRun(datasetName, runName, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__deleteRun(datasetName, runName, requestOptions) + ); + } + async __deleteRun(datasetName, runName, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/datasets/${encodeURIComponent(datasetName)}/runs/${encodeURIComponent(runName)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/datasets/{datasetName}/runs/{runName}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get dataset runs + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. In Langfuse v4, dataset runs are replaced by experiments; use GET /api/public/experiments instead. Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {string} datasetName + * @param {LangfuseAPI.GetDatasetRunsRequest} request + * @param {Datasets.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.datasets.getRuns("datasetName") + */ + getRuns(datasetName, request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getRuns(datasetName, request, requestOptions) + ); + } + async __getRuns(datasetName, request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { page, limit } = request; + const _queryParams = {}; + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/datasets/${encodeURIComponent(datasetName)}/runs` + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/datasets/{datasetName}/runs." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var EvaluationRules = class { + constructor(_options) { + this._options = _options; + } + /** + * Create an evaluation rule using stable evaluator identifiers. + * + * An evaluation rule defines **which** incoming observations should be evaluated and how prompt variables should be populated. + * + * Key behavior: + * - rule names are not identifiers and do not need to be unique + * - rules always use the latest version of each associated evaluator + * - an enabled rule requires at least one evaluator assignment + * - omit `sampling` to evaluate every matching observation + * - omit `filter` to match every incoming observation + * - `datasetId` is the public filter name for selecting experiment datasets + * + * @param {LangfuseAPI.CreateEvaluationRuleRequest} request + * @param {EvaluationRules.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.BadRequestError} + * @throws {@link LangfuseAPI.EvaluationUnauthorizedError} + * @throws {@link LangfuseAPI.EvaluationAccessDeniedError} + * @throws {@link LangfuseAPI.EvaluationNotFoundError} + * @throws {@link LangfuseAPI.EvaluationMethodNotAllowedError} + * @throws {@link LangfuseAPI.ConflictError} + * @throws {@link LangfuseAPI.TooManyRequestsError} + * @throws {@link LangfuseAPI.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.evaluationRules.create({ + * name: "name", + * enabled: true, + * sampling: undefined, + * filter: undefined, + * evaluatorAssignments: [{ + * evaluatorId: "evaluatorId", + * variableMapping: undefined + * }, { + * evaluatorId: "evaluatorId", + * variableMapping: undefined + * }] + * }) + */ + create(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__create(request, requestOptions) + ); + } + async __create(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/v2/evaluation-rules" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new EvaluationUnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new EvaluationAccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new EvaluationNotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new EvaluationMethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 409: + throw new ConflictError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/v2/evaluation-rules." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * List evaluation rules in newest-first creation order. + * + * This includes legacy trace and dataset rules so they can be inspected and migrated. Treat the cursor as opaque and return it unchanged. + * + * @param {LangfuseAPI.ListEvaluationRulesRequest} request + * @param {EvaluationRules.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.BadRequestError} + * @throws {@link LangfuseAPI.EvaluationUnauthorizedError} + * @throws {@link LangfuseAPI.EvaluationAccessDeniedError} + * @throws {@link LangfuseAPI.EvaluationMethodNotAllowedError} + * @throws {@link LangfuseAPI.TooManyRequestsError} + * @throws {@link LangfuseAPI.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.evaluationRules.list() + */ + list(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__list(request, requestOptions) + ); + } + async __list(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { limit, cursor } = request; + const _queryParams = {}; + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + if (cursor != null) { + _queryParams["cursor"] = cursor; + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/v2/evaluation-rules" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new EvaluationUnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new EvaluationAccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new EvaluationMethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/v2/evaluation-rules." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get one evaluation rule, including a legacy trace or dataset rule, by its stable identifier. + * + * @param {string} evaluationRuleId - Stable evaluation-rule identifier returned by the evaluation-rule endpoints. + * @param {EvaluationRules.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.EvaluationUnauthorizedError} + * @throws {@link LangfuseAPI.EvaluationAccessDeniedError} + * @throws {@link LangfuseAPI.EvaluationNotFoundError} + * @throws {@link LangfuseAPI.EvaluationMethodNotAllowedError} + * @throws {@link LangfuseAPI.TooManyRequestsError} + * @throws {@link LangfuseAPI.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.evaluationRules.get("evaluationRuleId") + */ + get(evaluationRuleId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__get(evaluationRuleId, requestOptions) + ); + } + async __get(evaluationRuleId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/v2/evaluation-rules/${encodeURIComponent(evaluationRuleId)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 401: + throw new EvaluationUnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new EvaluationAccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new EvaluationNotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new EvaluationMethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/v2/evaluation-rules/{evaluationRuleId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Update an evaluation rule by its stable identifier. + * + * Provide only the fields to change. Providing `evaluatorAssignments` replaces the complete assignment list. Replacing the list with an empty array disables the rule. Setting `enabled=true` is rejected when the resulting assignment list is empty, including when both fields are sent in the same request. + * + * Legacy trace and dataset rules follow the existing lifecycle restrictions: they can be deactivated with `enabled=false`, but their name, filters, sampling, and evaluator assignments cannot be changed. + * + * @param {string} evaluationRuleId - Stable evaluation-rule identifier returned by the evaluation-rule endpoints. + * @param {LangfuseAPI.UpdateEvaluationRuleRequest} request + * @param {EvaluationRules.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.BadRequestError} + * @throws {@link LangfuseAPI.EvaluationUnauthorizedError} + * @throws {@link LangfuseAPI.EvaluationAccessDeniedError} + * @throws {@link LangfuseAPI.EvaluationNotFoundError} + * @throws {@link LangfuseAPI.EvaluationMethodNotAllowedError} + * @throws {@link LangfuseAPI.ConflictError} + * @throws {@link LangfuseAPI.TooManyRequestsError} + * @throws {@link LangfuseAPI.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.evaluationRules.update("evaluationRuleId", { + * name: undefined, + * enabled: undefined, + * sampling: undefined, + * filter: undefined, + * evaluatorAssignments: undefined + * }) + */ + update(evaluationRuleId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__update(evaluationRuleId, request, requestOptions) + ); + } + async __update(evaluationRuleId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/v2/evaluation-rules/${encodeURIComponent(evaluationRuleId)}` + ), + method: "PATCH", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new EvaluationUnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new EvaluationAccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new EvaluationNotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new EvaluationMethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 409: + throw new ConflictError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PATCH /api/public/v2/evaluation-rules/{evaluationRuleId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete an evaluation rule. + * + * This removes the live-ingestion rule only. It does not delete associated evaluators or scores already produced by them. + * + * Legacy trace and dataset rules can also be deleted. Their evaluators and previously produced scores are preserved. + * + * @param {string} evaluationRuleId - Stable evaluation-rule identifier returned by the evaluation-rule endpoints. + * @param {EvaluationRules.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.EvaluationUnauthorizedError} + * @throws {@link LangfuseAPI.EvaluationAccessDeniedError} + * @throws {@link LangfuseAPI.EvaluationNotFoundError} + * @throws {@link LangfuseAPI.EvaluationMethodNotAllowedError} + * @throws {@link LangfuseAPI.TooManyRequestsError} + * @throws {@link LangfuseAPI.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.evaluationRules.delete("evaluationRuleId") + */ + delete(evaluationRuleId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__delete(evaluationRuleId, requestOptions) + ); + } + async __delete(evaluationRuleId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/v2/evaluation-rules/${encodeURIComponent(evaluationRuleId)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 401: + throw new EvaluationUnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new EvaluationAccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new EvaluationNotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new EvaluationMethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/v2/evaluation-rules/{evaluationRuleId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Evaluators = class { + constructor(_options) { + this._options = _options; + } + /** + * Create an evaluator in the authenticated project. + * + * An evaluator defines **how** Langfuse should score data. LLM-as-a-judge evaluators define a prompt, expected structured output, and optional model configuration. Code evaluators define source code and a runtime language. + * + * This always creates a new evaluator with version `1`. Names are not identifiers and do not need to be unique. + * + * @param {LangfuseAPI.CreateEvaluatorRequest} request + * @param {Evaluators.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.BadRequestError} + * @throws {@link LangfuseAPI.EvaluationUnauthorizedError} + * @throws {@link LangfuseAPI.EvaluationAccessDeniedError} + * @throws {@link LangfuseAPI.EvaluationMethodNotAllowedError} + * @throws {@link LangfuseAPI.PreconditionFailedError} + * @throws {@link LangfuseAPI.TooManyRequestsError} + * @throws {@link LangfuseAPI.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.evaluators.create({ + * type: "llm_as_judge", + * name: "name", + * description: undefined, + * type: "llm_as_judge", + * prompt: "prompt", + * modelConfig: undefined, + * variableMapping: undefined, + * outputDefinition: { + * dataType: "NUMERIC", + * dataType: "NUMERIC", + * minValue: undefined, + * maxValue: undefined, + * scoreReasoningInstructions: undefined, + * scoreValueInstructions: undefined + * } + * }) + */ + create(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__create(request, requestOptions) + ); + } + async __create(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/v2/evaluators" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new EvaluationUnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new EvaluationAccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new EvaluationMethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 412: + throw new PreconditionFailedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/v2/evaluators." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * List evaluators in newest-first creation order. + * + * Every evaluator includes its latest definition and version metadata flattened into the evaluator object, plus associated evaluation rules. Treat the cursor as opaque and return it unchanged. + * + * @param {LangfuseAPI.ListEvaluatorsRequest} request + * @param {Evaluators.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.BadRequestError} + * @throws {@link LangfuseAPI.EvaluationUnauthorizedError} + * @throws {@link LangfuseAPI.EvaluationAccessDeniedError} + * @throws {@link LangfuseAPI.EvaluationMethodNotAllowedError} + * @throws {@link LangfuseAPI.TooManyRequestsError} + * @throws {@link LangfuseAPI.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.evaluators.list() + */ + list(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__list(request, requestOptions) + ); + } + async __list(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { limit, cursor } = request; + const _queryParams = {}; + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + if (cursor != null) { + _queryParams["cursor"] = cursor; + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/v2/evaluators" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new EvaluationUnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new EvaluationAccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new EvaluationMethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/v2/evaluators." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get one evaluator by its stable identifier. + * + * The response includes the evaluator's latest definition and version metadata flattened into the evaluator object, plus associated evaluation rules. Use the version-history endpoint when older definitions are needed. + * + * @param {string} evaluatorId - Stable evaluator identifier returned by the evaluator endpoints. + * @param {Evaluators.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.EvaluationUnauthorizedError} + * @throws {@link LangfuseAPI.EvaluationAccessDeniedError} + * @throws {@link LangfuseAPI.EvaluationNotFoundError} + * @throws {@link LangfuseAPI.EvaluationMethodNotAllowedError} + * @throws {@link LangfuseAPI.TooManyRequestsError} + * @throws {@link LangfuseAPI.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.evaluators.get("evaluatorId") + */ + get(evaluatorId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__get(evaluatorId, requestOptions) + ); + } + async __get(evaluatorId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/v2/evaluators/${encodeURIComponent(evaluatorId)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 401: + throw new EvaluationUnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new EvaluationAccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new EvaluationNotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new EvaluationMethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/v2/evaluators/{evaluatorId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Update an evaluator by its stable identifier. + * + * Provide only the top-level fields to change. Metadata-only changes do not create a version. Evaluator type cannot change. + * + * Definition fields are flattened into the request. To replace a definition, include `type` and every definition field for that type. Definition fields are replaced as a complete unit rather than merged. For LLM-as-a-judge evaluators, omitting or setting `modelConfig` to `null` selects the project's default evaluation model. + * + * Replacing a definition automatically returns an evaluator paused by an invalid or missing model configuration to `active`, while preserving its id and evaluation-rule assignments. Pauses caused by provider authentication, billing, connectivity, account state, or an unknown legacy reason remain paused until the explicit reactivation check succeeds. + * + * @param {string} evaluatorId - Stable evaluator identifier returned by the evaluator endpoints. + * @param {LangfuseAPI.UpdateEvaluatorRequest} request + * @param {Evaluators.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.BadRequestError} + * @throws {@link LangfuseAPI.EvaluationUnauthorizedError} + * @throws {@link LangfuseAPI.EvaluationAccessDeniedError} + * @throws {@link LangfuseAPI.EvaluationNotFoundError} + * @throws {@link LangfuseAPI.EvaluationMethodNotAllowedError} + * @throws {@link LangfuseAPI.ConflictError} + * @throws {@link LangfuseAPI.PreconditionFailedError} + * @throws {@link LangfuseAPI.TooManyRequestsError} + * @throws {@link LangfuseAPI.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.evaluators.update("evaluatorId", { + * name: undefined, + * description: undefined + * }) + */ + update(evaluatorId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__update(evaluatorId, request, requestOptions) + ); + } + async __update(evaluatorId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/v2/evaluators/${encodeURIComponent(evaluatorId)}` + ), + method: "PATCH", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new EvaluationUnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new EvaluationAccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new EvaluationNotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new EvaluationMethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 409: + throw new ConflictError( + _response.error.body, + _response.rawResponse + ); + case 412: + throw new PreconditionFailedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PATCH /api/public/v2/evaluators/{evaluatorId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete an evaluator and all of its stored versions. + * + * Associated evaluation-rule assignments are also removed. Scores already produced by the evaluator are preserved. + * + * @param {string} evaluatorId - Stable evaluator identifier returned by the evaluator endpoints. + * @param {Evaluators.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.EvaluationUnauthorizedError} + * @throws {@link LangfuseAPI.EvaluationAccessDeniedError} + * @throws {@link LangfuseAPI.EvaluationNotFoundError} + * @throws {@link LangfuseAPI.EvaluationMethodNotAllowedError} + * @throws {@link LangfuseAPI.TooManyRequestsError} + * @throws {@link LangfuseAPI.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.evaluators.delete("evaluatorId") + */ + delete(evaluatorId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__delete(evaluatorId, requestOptions) + ); + } + async __delete(evaluatorId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/v2/evaluators/${encodeURIComponent(evaluatorId)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 401: + throw new EvaluationUnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new EvaluationAccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new EvaluationNotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new EvaluationMethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/v2/evaluators/{evaluatorId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * List an evaluator's version history in newest-first order. + * + * This endpoint is intended for history and audit use cases. Ordinary clients can use the flattened `version` and definition fields on the evaluator response. + * + * @param {string} evaluatorId - Stable evaluator identifier returned by the evaluator endpoints. + * @param {LangfuseAPI.ListEvaluatorVersionsRequest} request + * @param {Evaluators.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.BadRequestError} + * @throws {@link LangfuseAPI.EvaluationUnauthorizedError} + * @throws {@link LangfuseAPI.EvaluationAccessDeniedError} + * @throws {@link LangfuseAPI.EvaluationNotFoundError} + * @throws {@link LangfuseAPI.EvaluationMethodNotAllowedError} + * @throws {@link LangfuseAPI.TooManyRequestsError} + * @throws {@link LangfuseAPI.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.evaluators.listVersions("evaluatorId") + */ + listVersions(evaluatorId, request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__listVersions(evaluatorId, request, requestOptions) + ); + } + async __listVersions(evaluatorId, request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { limit, cursor } = request; + const _queryParams = {}; + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + if (cursor != null) { + _queryParams["cursor"] = cursor; + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/v2/evaluators/${encodeURIComponent(evaluatorId)}/versions` + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new EvaluationUnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new EvaluationAccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new EvaluationNotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new EvaluationMethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/v2/evaluators/{evaluatorId}/versions." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Experiments = class { + constructor(_options) { + this._options = _options; + } + /** + * List experiments with cursor-based pagination. Results are ordered by + * latest experiment activity descending. + * + * @param {LangfuseAPI.ListExperimentsRequest} request + * @param {Experiments.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.experiments.list({ + * fromStartTime: "2024-01-15T09:30:00Z" + * }) + */ + list(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__list(request, requestOptions) + ); + } + async __list(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { + fields, + limit, + scoreLimit, + cursor, + fromStartTime, + toStartTime, + id, + name, + datasetId, + filter + } = request; + const _queryParams = {}; + if (fields != null) { + _queryParams["fields"] = fields; + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + if (scoreLimit != null) { + _queryParams["scoreLimit"] = scoreLimit.toString(); + } + if (cursor != null) { + _queryParams["cursor"] = cursor; + } + _queryParams["fromStartTime"] = fromStartTime; + if (toStartTime != null) { + _queryParams["toStartTime"] = toStartTime; + } + if (id != null) { + _queryParams["id"] = id; + } + if (name != null) { + _queryParams["name"] = name; + } + if (datasetId != null) { + _queryParams["datasetId"] = datasetId; + } + if (filter != null) { + _queryParams["filter"] = filter; + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/experiments" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/experiments." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * List experiment items with cursor-based pagination. Use this endpoint + * to export experiment item inputs, outputs, expected outputs, metadata, + * and optionally item/trace scores. Results are ordered by time + * descending. + * + * @param {LangfuseAPI.ListExperimentItemsRequest} request + * @param {Experiments.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.experiments.listItems({ + * fromStartTime: "2024-01-15T09:30:00Z" + * }) + */ + listItems(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__listItems(request, requestOptions) + ); + } + async __listItems(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { + fields, + limit, + scoreLimit, + cursor, + fromStartTime, + toStartTime, + experimentId, + experimentName, + experimentItemId, + datasetId, + filter + } = request; + const _queryParams = {}; + if (fields != null) { + _queryParams["fields"] = fields; + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + if (scoreLimit != null) { + _queryParams["scoreLimit"] = scoreLimit.toString(); + } + if (cursor != null) { + _queryParams["cursor"] = cursor; + } + _queryParams["fromStartTime"] = fromStartTime; + if (toStartTime != null) { + _queryParams["toStartTime"] = toStartTime; + } + if (experimentId != null) { + _queryParams["experimentId"] = experimentId; + } + if (experimentName != null) { + _queryParams["experimentName"] = experimentName; + } + if (experimentItemId != null) { + _queryParams["experimentItemId"] = experimentItemId; + } + if (datasetId != null) { + _queryParams["datasetId"] = datasetId; + } + if (filter != null) { + _queryParams["filter"] = filter; + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/experiment-items" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/experiment-items." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Feedback = class { + constructor(_options) { + this._options = _options; + } + /** + * Submit explicit user-approved feedback about Langfuse skills, MCP tools, CLI, docs, or public API. Do not include secrets, credentials, customer data, trace payloads, or unrelated use-case details. + * + * Not available in the HIPAA cloud region. + * + * @param {LangfuseAPI.SubmitFeedbackRequest} request + * @param {Feedback.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.FeedbackNotConfiguredError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.feedback.submit({ + * targetType: "skill", + * target: "target", + * feedback: "feedback", + * goal: undefined, + * referenceUrl: undefined + * }) + */ + submit(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__submit(request, requestOptions) + ); + } + async __submit(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/feedback" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 409: + throw new FeedbackNotConfiguredError( + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/feedback." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Health = class { + constructor(_options) { + this._options = _options; + } + /** + * Check health of API and database + * + * @param {Health.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.ServiceUnavailableError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.health.health() + */ + health(requestOptions) { + return HttpResponsePromise.fromPromise(this.__health(requestOptions)); + } + async __health(requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/health" + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 503: + throw new ServiceUnavailableError(_response.rawResponse); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/health." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Ingestion = class { + constructor(_options) { + this._options = _options; + } + /** + * **Legacy endpoint for batch ingestion for Langfuse Observability.** + * + * -> Please use the OpenTelemetry endpoint (`/api/public/otel/v1/traces`). Learn more: https://langfuse.com/integrations/native/opentelemetry + * + * Within each batch, there can be multiple events. + * Each event has a type, an id, a timestamp, metadata and a body. + * Internally, we refer to this as the "event envelope" as it tells us something about the event but not the trace. + * We use the event id within this envelope to deduplicate messages to avoid processing the same event twice, i.e. the event id should be unique per request. + * The event.body.id is the ID of the actual trace and will be used for updates and will be visible within the Langfuse App. + * I.e. if you want to update a trace, you'd use the same body id, but separate event IDs. + * + * Notes: + * - Introduction to data model: https://langfuse.com/docs/observability/data-model + * - Batch sizes are limited to 3.5 MB in total. You need to adjust the number of events per batch accordingly. + * - The API does not return a 4xx status code for input errors. Instead, it responds with a 207 status code, which includes a list of the encountered errors. + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. Send data via the OpenTelemetry endpoint at `POST /api/public/otel/v1/traces` instead, see the [OpenTelemetry integration docs](https://langfuse.com/integrations/native/opentelemetry). Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {LangfuseAPI.IngestionRequest} request + * @param {Ingestion.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.ingestion.batch({ + * batch: [{ + * type: "trace-create", + * id: "abcdef-1234-5678-90ab", + * timestamp: "2022-01-01T00:00:00.000Z", + * body: { + * id: "abcdef-1234-5678-90ab", + * timestamp: "2022-01-01T00:00:00.000Z", + * environment: "production", + * name: "My Trace", + * userId: "1234-5678-90ab-cdef", + * input: "My input", + * output: "My output", + * sessionId: "1234-5678-90ab-cdef", + * release: "1.0.0", + * version: "1.0.0", + * metadata: "My metadata", + * tags: ["tag1", "tag2"], + * "public": true + * } + * }] + * }) + * + * @example + * await client.ingestion.batch({ + * batch: [{ + * type: "span-create", + * id: "abcdef-1234-5678-90ab", + * timestamp: "2022-01-01T00:00:00.000Z", + * body: { + * id: "abcdef-1234-5678-90ab", + * traceId: "1234-5678-90ab-cdef", + * startTime: "2022-01-01T00:00:00.000Z", + * environment: "test" + * } + * }] + * }) + * + * @example + * await client.ingestion.batch({ + * batch: [{ + * type: "score-create", + * id: "abcdef-1234-5678-90ab", + * timestamp: "2022-01-01T00:00:00.000Z", + * body: { + * id: "abcdef-1234-5678-90ab", + * traceId: "1234-5678-90ab-cdef", + * name: "My Score", + * value: 0.9, + * environment: "default" + * } + * }] + * }) + */ + batch(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__batch(request, requestOptions) + ); + } + async __batch(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/ingestion" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/ingestion." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var MetricsV1 = class { + constructor(_options) { + this._options = _options; + } + /** + * Get metrics from the Langfuse project using a query object. + * + * Consider using the [v2 metrics endpoint](/api-reference#tag/metricsv2/GET/api/public/v2/metrics) for better performance. + * + * For more details, see the [Metrics API documentation](https://langfuse.com/docs/metrics/features/metrics-api). + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. Use `GET /api/public/v2/metrics?query=` instead. Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {LangfuseAPI.legacy.GetMetricsRequest} request + * @param {MetricsV1.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.legacy.metricsV1.metrics({ + * query: "query" + * }) + */ + metrics(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__metrics(request, requestOptions) + ); + } + async __metrics(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { query } = request; + const _queryParams = {}; + _queryParams["query"] = query; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/metrics" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/metrics." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var ObservationsV1 = class { + constructor(_options) { + this._options = _options; + } + /** + * Get a observation + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. Use `GET /api/public/v2/observations?fromStartTime=&toStartTime=` instead. Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {string} observationId - The unique langfuse identifier of an observation, can be an event, span or generation + * @param {ObservationsV1.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.legacy.observationsV1.get("observationId") + */ + get(observationId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__get(observationId, requestOptions) + ); + } + async __get(observationId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/observations/${encodeURIComponent(observationId)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/observations/{observationId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a list of observations. + * + * Consider using the [v2 observations endpoint](/api-reference#tag/observationsv2/GET/api/public/v2/observations) for cursor-based pagination and field selection. + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. Use `GET /api/public/v2/observations?fromStartTime=&toStartTime=` instead. Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {LangfuseAPI.legacy.GetObservationsRequest} request + * @param {ObservationsV1.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.legacy.observationsV1.getMany() + */ + getMany(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getMany(request, requestOptions) + ); + } + async __getMany(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { + page, + limit, + name, + userId, + type: type_, + traceId, + level, + parentObservationId, + environment, + fromStartTime, + toStartTime, + version, + filter + } = request; + const _queryParams = {}; + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + if (name != null) { + _queryParams["name"] = name; + } + if (userId != null) { + _queryParams["userId"] = userId; + } + if (type_ != null) { + _queryParams["type"] = type_; + } + if (traceId != null) { + _queryParams["traceId"] = traceId; + } + if (level != null) { + _queryParams["level"] = level; + } + if (parentObservationId != null) { + _queryParams["parentObservationId"] = parentObservationId; + } + if (environment != null) { + if (Array.isArray(environment)) { + _queryParams["environment"] = environment.map((item) => item); + } else { + _queryParams["environment"] = environment; + } + } + if (fromStartTime != null) { + _queryParams["fromStartTime"] = fromStartTime; + } + if (toStartTime != null) { + _queryParams["toStartTime"] = toStartTime; + } + if (version != null) { + _queryParams["version"] = version; + } + if (filter != null) { + _queryParams["filter"] = filter; + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/observations" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/observations." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Scores = class { + constructor(_options) { + this._options = _options; + } + /** + * Create a score (supports trace, observation, session, and dataset run scores) + * + * @param {LangfuseAPI.CreateScoreRequest} request + * @param {Scores.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scores.create({ + * id: undefined, + * traceId: undefined, + * sessionId: undefined, + * observationId: undefined, + * datasetRunId: undefined, + * name: "name", + * value: 1.1, + * comment: undefined, + * metadata: undefined, + * environment: undefined, + * queueId: undefined, + * dataType: undefined, + * configId: undefined, + * source: undefined + * }) + */ + create(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__create(request, requestOptions) + ); + } + async __create(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/scores" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/scores." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a list of scores (supports both trace and session scores) + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. Use `GET /api/public/v3/scores` instead. Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {LangfuseAPI.GetScoresRequest} request + * @param {Scores.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scores.getMany() + */ + getMany(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getMany(request, requestOptions) + ); + } + async __getMany(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { + page, + limit, + userId, + name, + fromTimestamp, + toTimestamp, + environment, + source, + operator, + value, + scoreIds, + configId, + sessionId: sessionId2, + datasetRunId, + traceId, + observationId, + queueId, + dataType, + traceTags, + fields, + filter + } = request; + const _queryParams = {}; + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + if (userId != null) { + _queryParams["userId"] = userId; + } + if (name != null) { + _queryParams["name"] = name; + } + if (fromTimestamp != null) { + _queryParams["fromTimestamp"] = fromTimestamp; + } + if (toTimestamp != null) { + _queryParams["toTimestamp"] = toTimestamp; + } + if (environment != null) { + if (Array.isArray(environment)) { + _queryParams["environment"] = environment.map((item) => item); + } else { + _queryParams["environment"] = environment; + } + } + if (source != null) { + _queryParams["source"] = source; + } + if (operator != null) { + _queryParams["operator"] = operator; + } + if (value != null) { + _queryParams["value"] = value.toString(); + } + if (scoreIds != null) { + _queryParams["scoreIds"] = scoreIds; + } + if (configId != null) { + _queryParams["configId"] = configId; + } + if (sessionId2 != null) { + _queryParams["sessionId"] = sessionId2; + } + if (datasetRunId != null) { + _queryParams["datasetRunId"] = datasetRunId; + } + if (traceId != null) { + _queryParams["traceId"] = traceId; + } + if (observationId != null) { + _queryParams["observationId"] = observationId; + } + if (queueId != null) { + _queryParams["queueId"] = queueId; + } + if (dataType != null) { + _queryParams["dataType"] = dataType; + } + if (traceTags != null) { + if (Array.isArray(traceTags)) { + _queryParams["traceTags"] = traceTags.map((item) => item); + } else { + _queryParams["traceTags"] = traceTags; + } + } + if (fields != null) { + _queryParams["fields"] = fields; + } + if (filter != null) { + _queryParams["filter"] = filter; + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/v2/scores" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/v2/scores." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a score (supports both trace and session scores) + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. Use `GET /api/public/v3/scores` with the `id` filter instead. Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {string} scoreId - The unique langfuse identifier of a score + * @param {Scores.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scores.getById("scoreId") + */ + getById(scoreId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getById(scoreId, requestOptions) + ); + } + async __getById(scoreId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/v2/scores/${encodeURIComponent(scoreId)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/v2/scores/{scoreId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var ScoreV1 = class { + constructor(_options) { + this._options = _options; + } + /** + * Create a score (supports both trace and session scores) + * + * @deprecated Use `client.scores.create()` instead. + * Compatibility alias managed by scripts/patch-generated-score-create-alias.mjs + */ + create(request, requestOptions) { + return new Scores(this._options).create(request, requestOptions); + } + /** + * Delete a score (supports both trace and session scores) + * + * @param {string} scoreId - The unique langfuse identifier of a score + * @param {ScoreV1.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.legacy.scoreV1.delete("scoreId") + */ + delete(scoreId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__delete(scoreId, requestOptions) + ); + } + async __delete(scoreId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/scores/${encodeURIComponent(scoreId)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { data: void 0, rawResponse: _response.rawResponse }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/scores/{scoreId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Legacy = class { + constructor(_options) { + this._options = _options; + } + get metricsV1() { + var _a2; + return (_a2 = this._metricsV1) != null ? _a2 : this._metricsV1 = new MetricsV1(this._options); + } + get observationsV1() { + var _a2; + return (_a2 = this._observationsV1) != null ? _a2 : this._observationsV1 = new ObservationsV1(this._options); + } + get scoreV1() { + var _a2; + return (_a2 = this._scoreV1) != null ? _a2 : this._scoreV1 = new ScoreV1(this._options); + } +}; +var LlmConnections = class { + constructor(_options) { + this._options = _options; + } + /** + * Get all LLM connections in a project + * + * @param {LangfuseAPI.GetLlmConnectionsRequest} request + * @param {LlmConnections.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.llmConnections.list() + */ + list(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__list(request, requestOptions) + ); + } + async __list(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { page, limit } = request; + const _queryParams = {}; + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/llm-connections" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/llm-connections." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Create or update an LLM connection. The connection is upserted on provider. + * + * @param {LangfuseAPI.UpsertLlmConnectionRequest} request + * @param {LlmConnections.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.llmConnections.upsert({ + * provider: "provider", + * adapter: "anthropic", + * secretKey: "secretKey", + * baseURL: undefined, + * customModels: undefined, + * withDefaultModels: undefined, + * extraHeaders: undefined, + * config: undefined + * }) + */ + upsert(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__upsert(request, requestOptions) + ); + } + async __upsert(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/llm-connections" + ), + method: "PUT", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PUT /api/public/llm-connections." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete an LLM connection by id. Evaluators that depend on the deleted connection are automatically paused. + * + * @param {string} id + * @param {LlmConnections.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.llmConnections.delete("id") + */ + delete(id, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__delete(id, requestOptions) + ); + } + async __delete(id, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/llm-connections/${encodeURIComponent(id)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/llm-connections/{id}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Media = class { + constructor(_options) { + this._options = _options; + } + /** + * Get a media record + * + * @param {string} mediaId - The unique langfuse identifier of a media record + * @param {Media.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.media.get("mediaId") + */ + get(mediaId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__get(mediaId, requestOptions) + ); + } + async __get(mediaId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/media/${encodeURIComponent(mediaId)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/media/{mediaId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Patch a media record + * + * @param {string} mediaId - The unique langfuse identifier of a media record + * @param {LangfuseAPI.PatchMediaBody} request + * @param {Media.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.media.patch("mediaId", { + * uploadedAt: "2024-01-15T09:30:00Z", + * uploadHttpStatus: 1, + * uploadHttpError: undefined, + * uploadTimeMs: undefined + * }) + */ + patch(mediaId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__patch(mediaId, request, requestOptions) + ); + } + async __patch(mediaId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/media/${encodeURIComponent(mediaId)}` + ), + method: "PATCH", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { data: void 0, rawResponse: _response.rawResponse }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PATCH /api/public/media/{mediaId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a presigned upload URL for a media record + * + * @param {LangfuseAPI.GetMediaUploadUrlRequest} request + * @param {Media.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.media.getUploadUrl({ + * traceId: undefined, + * observationId: undefined, + * datasetId: undefined, + * datasetItemId: undefined, + * contentType: "image/png", + * contentLength: 1, + * sha256Hash: "sha256Hash", + * field: "field" + * }) + */ + getUploadUrl(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getUploadUrl(request, requestOptions) + ); + } + async __getUploadUrl(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/media" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/media." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Metrics = class { + constructor(_options) { + this._options = _options; + } + /** + * Get metrics from the Langfuse project using a query object. V2 endpoint with optimized performance. + * + * ## V2 Differences + * - Supports `observations`, `scores-numeric`, `scores-boolean`, and `scores-categorical` views only (traces view not supported) + * - Direct access to tags and release fields on observations + * - Semantic-root filtering and grouping through the v2-only `isRootObservation` dimension + * - Backwards-compatible: traceName, traceRelease, traceVersion dimensions are still available on observations view + * - High cardinality dimensions are not supported and will return a 400 error (see below) + * + * For more details, see the [Metrics API documentation](https://langfuse.com/docs/metrics/features/metrics-api). + * + * ## Available Views + * + * ### observations + * Query observation-level data (spans, generations, events). + * + * **Dimensions:** + * - `environment` - Deployment environment (e.g., production, staging) + * - `type` - Type of observation (SPAN, GENERATION, EVENT) + * - `name` - Name of the observation + * - `level` - Logging level of the observation + * - `version` - Version of the observation + * - `tags` - User-defined tags + * - `release` - Release version + * - `traceName` - Name of the parent trace (backwards-compatible) + * - `traceRelease` - Release version of the parent trace (backwards-compatible, maps to release) + * - `traceVersion` - Version of the parent trace (backwards-compatible, maps to version) + * - `providedModelName` - Name of the model used + * - `promptName` - Name of the prompt used + * - `promptVersion` - Version of the prompt used + * - `isRootObservation` - Boolean semantic-root status. `true` includes physical roots and app roots whose SDK parent is external (so `parentObservationId` may be non-null). + * - `startTimeMonth` - Month of start_time in YYYY-MM format + * + * **Measures:** + * - `count` - Total number of observations + * - `latency` - Observation latency (milliseconds) + * - `streamingLatency` - Generation latency from completion start to end (milliseconds) + * - `inputTokens` - Sum of input tokens consumed + * - `outputTokens` - Sum of output tokens produced + * - `totalTokens` - Sum of all tokens consumed + * - `outputTokensPerSecond` - Output tokens per second + * - `tokensPerSecond` - Total tokens per second + * - `inputCost` - Input cost (USD) + * - `outputCost` - Output cost (USD) + * - `totalCost` - Total cost (USD) + * - `timeToFirstToken` - Time to first token (milliseconds) + * - `countScores` - Number of scores attached to the observation + * + * ### scores-numeric + * Query numeric and boolean score data. + * + * **Dimensions:** + * - `environment` - Deployment environment + * - `name` - Name of the score (e.g., accuracy, toxicity) + * - `source` - Origin of the score (API, ANNOTATION, EVAL) + * - `dataType` - Data type (NUMERIC, BOOLEAN) + * - `configId` - Identifier of the score config + * - `timestampMonth` - Month in YYYY-MM format + * - `timestampDay` - Day in YYYY-MM-DD format + * - `value` - Numeric value of the score + * - `traceName` - Name of the parent trace + * - `tags` - Tags + * - `traceRelease` - Release version + * - `traceVersion` - Version + * - `observationName` - Name of the associated observation + * - `observationModelName` - Model name of the associated observation + * - `observationPromptName` - Prompt name of the associated observation + * - `observationPromptVersion` - Prompt version of the associated observation + * + * **Measures:** + * - `count` - Total number of scores + * - `value` - Score value (for aggregations) + * + * ### scores-boolean + * Query boolean score data. It has the same score and parent trace/observation dimensions as scores-numeric, plus: + * + * **Dimensions:** + * - `booleanValue` - Boolean value for true/false grouping and filtering + * + * **Measures:** + * - `count` - Total number of boolean scores + * - `value` - Numeric 0/1 score value; `avg` returns the true-rate + * + * ### scores-categorical + * Query categorical score data. Same dimensions as scores-numeric except uses `stringValue` instead of `value`. + * + * **Measures:** + * - `count` - Total number of scores + * + * ## High Cardinality Dimensions + * The following dimensions cannot be used as grouping dimensions in v2 metrics API as they can cause performance issues. + * Use them in filters instead. + * + * **observations view:** + * - `id` - Use traceId filter to narrow down results + * - `traceId` - Use traceId filter instead + * - `userId` - Use userId filter instead + * - `sessionId` - Use sessionId filter instead + * - `parentObservationId` - Use parentObservationId filter instead + * + * **scores-numeric / scores-boolean / scores-categorical views:** + * - `id` - Use specific filters to narrow down results + * - `traceId` - Use traceId filter instead + * - `userId` - Use userId filter instead + * - `sessionId` - Use sessionId filter instead + * - `observationId` - Use observationId filter instead + * + * ## Aggregations + * Available aggregation functions: `sum`, `avg`, `count`, `max`, `min`, `p50`, `p75`, `p90`, `p95`, `p99`, `histogram` + * + * ## Time Granularities + * Available granularities for timeDimension: `auto`, `minute`, `hour`, `day`, `week`, `month` + * - `auto` bins the data into approximately 50 buckets based on the time range + * + * @param {LangfuseAPI.GetMetricsV2Request} request + * @param {Metrics.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.metrics.metrics({ + * query: "query" + * }) + */ + metrics(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__metrics(request, requestOptions) + ); + } + async __metrics(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { query } = request; + const _queryParams = {}; + _queryParams["query"] = query; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/v2/metrics" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/v2/metrics." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Models = class { + constructor(_options) { + this._options = _options; + } + /** + * Create a model + * + * @param {LangfuseAPI.CreateModelRequest} request + * @param {Models.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.models.create({ + * modelName: "modelName", + * matchPattern: "matchPattern", + * startDate: undefined, + * unit: "CHARACTERS", + * inputPrice: undefined, + * outputPrice: undefined, + * totalPrice: undefined, + * pricingTiers: undefined, + * tokenizerId: undefined, + * tokenizerConfig: undefined + * }) + */ + create(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__create(request, requestOptions) + ); + } + async __create(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/models" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/models." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Create or replace a project-owned model using its id. Built-in models cannot be modified. + * + * @param {string} id + * @param {LangfuseAPI.CreateModelRequest} request + * @param {Models.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.models.upsert("id", { + * modelName: "modelName", + * matchPattern: "matchPattern", + * startDate: undefined, + * unit: "CHARACTERS", + * inputPrice: undefined, + * outputPrice: undefined, + * totalPrice: undefined, + * pricingTiers: undefined, + * tokenizerId: undefined, + * tokenizerConfig: undefined + * }) + */ + upsert(id, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__upsert(id, request, requestOptions) + ); + } + async __upsert(id, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/models/${encodeURIComponent(id)}` + ), + method: "PUT", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PUT /api/public/models/{id}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get all models + * + * @param {LangfuseAPI.GetModelsRequest} request + * @param {Models.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.models.list() + */ + list(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__list(request, requestOptions) + ); + } + async __list(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { page, limit } = request; + const _queryParams = {}; + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/models" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/models." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a model + * + * @param {string} id + * @param {Models.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.models.get("id") + */ + get(id, requestOptions) { + return HttpResponsePromise.fromPromise(this.__get(id, requestOptions)); + } + async __get(id, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/models/${encodeURIComponent(id)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/models/{id}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete a model. Cannot delete models managed by Langfuse. You can create your own definition with the same modelName to override the definition though. + * + * @param {string} id + * @param {Models.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.models.delete("id") + */ + delete(id, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__delete(id, requestOptions) + ); + } + async __delete(id, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/models/${encodeURIComponent(id)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { data: void 0, rawResponse: _response.rawResponse }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/models/{id}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Observations = class { + constructor(_options) { + this._options = _options; + } + /** + * Get a list of observations with cursor-based pagination and flexible field selection. + * + * ## Cursor-based Pagination + * This endpoint uses cursor-based pagination for efficient traversal of large datasets. + * The cursor is returned in the response metadata and should be passed in subsequent requests + * to retrieve the next page of results. + * + * ## Field Selection + * Use the `fields` parameter to control which observation fields are returned: + * - `core` - Always included: id, traceId, startTime, endTime, projectId, parentObservationId, type + * - `basic` - name, level, statusMessage, version, environment, bookmarked, public, userId, sessionId, isRootObservation + * - `time` - completionStartTime, createdAt, updatedAt + * - `io` - input, output + * - `metadata` - metadata (truncated to 200 chars by default, use `expandMetadata` to get full values) + * - `model` - model, internalModelId, modelParameters + * - `usage` - usageDetails, costDetails, totalCost, usagePricingTierName + * - `prompt` - promptId, promptName, promptVersion + * - `metrics` - latency, timeToFirstToken + * - `trace_context` - tags, release, traceName + * + * If not specified, `core` and `basic` field groups are returned. + * + * ## Filters + * Multiple filtering options are available via query parameters or the structured `filter` parameter. + * When using the `filter` parameter, it takes precedence over individual query parameter filters. + * + * @param {LangfuseAPI.GetObservationsV2Request} request + * @param {Observations.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.observations.getMany() + */ + getMany(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getMany(request, requestOptions) + ); + } + async __getMany(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { + fields, + expandMetadata, + limit, + cursor, + parseIoAsJson, + name, + userId, + sessionId: sessionId2, + type: type_, + traceId, + level, + parentObservationId, + isRootObservation, + environment, + fromStartTime, + toStartTime, + version, + filter + } = request; + const _queryParams = {}; + if (fields != null) { + _queryParams["fields"] = fields; + } + if (expandMetadata != null) { + _queryParams["expandMetadata"] = expandMetadata; + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + if (cursor != null) { + _queryParams["cursor"] = cursor; + } + if (parseIoAsJson != null) { + _queryParams["parseIoAsJson"] = parseIoAsJson.toString(); + } + if (name != null) { + _queryParams["name"] = name; + } + if (userId != null) { + _queryParams["userId"] = userId; + } + if (sessionId2 != null) { + _queryParams["sessionId"] = sessionId2; + } + if (type_ != null) { + _queryParams["type"] = type_; + } + if (traceId != null) { + _queryParams["traceId"] = traceId; + } + if (level != null) { + _queryParams["level"] = level; + } + if (parentObservationId != null) { + _queryParams["parentObservationId"] = parentObservationId; + } + if (isRootObservation != null) { + _queryParams["isRootObservation"] = isRootObservation.toString(); + } + if (environment != null) { + if (Array.isArray(environment)) { + _queryParams["environment"] = environment.map((item) => item); + } else { + _queryParams["environment"] = environment; + } + } + if (fromStartTime != null) { + _queryParams["fromStartTime"] = fromStartTime; + } + if (toStartTime != null) { + _queryParams["toStartTime"] = toStartTime; + } + if (version != null) { + _queryParams["version"] = version; + } + if (filter != null) { + _queryParams["filter"] = filter; + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/v2/observations" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/v2/observations." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Opentelemetry = class { + constructor(_options) { + this._options = _options; + } + /** + * **OpenTelemetry Traces Ingestion Endpoint** + * + * This endpoint implements the OTLP/HTTP specification for trace ingestion, providing native OpenTelemetry integration for Langfuse Observability. + * + * **Supported Formats:** + * - Binary Protobuf: `Content-Type: application/x-protobuf` + * - JSON Protobuf: `Content-Type: application/json` + * - Supports gzip compression via `Content-Encoding: gzip` header + * + * **Specification Compliance:** + * - Conforms to [OTLP/HTTP Trace Export](https://opentelemetry.io/docs/specs/otlp/#otlphttp) + * - Implements `ExportTraceServiceRequest` message format + * + * **Documentation:** + * - Integration guide: https://langfuse.com/integrations/native/opentelemetry + * - Data model: https://langfuse.com/docs/observability/data-model + * + * @param {LangfuseAPI.OtelTraceRequest} request + * @param {Opentelemetry.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.opentelemetry.exportTraces({ + * resourceSpans: [{ + * resource: { + * attributes: [{ + * key: "service.name", + * value: { + * stringValue: "my-service" + * } + * }, { + * key: "service.version", + * value: { + * stringValue: "1.0.0" + * } + * }] + * }, + * scopeSpans: [{ + * scope: { + * name: "langfuse-sdk", + * version: "2.60.3" + * }, + * spans: [{ + * traceId: "0123456789abcdef0123456789abcdef", + * spanId: "0123456789abcdef", + * name: "my-operation", + * kind: 1, + * startTimeUnixNano: "1747872000000000000", + * endTimeUnixNano: "1747872001000000000", + * attributes: [{ + * key: "langfuse.observation.type", + * value: { + * stringValue: "generation" + * } + * }], + * status: {} + * }] + * }] + * }] + * }) + */ + exportTraces(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__exportTraces(request, requestOptions) + ); + } + async __exportTraces(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/otel/v1/traces" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/otel/v1/traces." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Organizations = class { + constructor(_options) { + this._options = _options; + } + /** + * Get all memberships for the organization associated with the API key (requires organization-scoped API key) + * + * @param {Organizations.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.organizations.getOrganizationMemberships() + */ + getOrganizationMemberships(requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getOrganizationMemberships(requestOptions) + ); + } + async __getOrganizationMemberships(requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/organizations/memberships" + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/organizations/memberships." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Create or update a membership for the organization associated with the API key (requires organization-scoped API key) + * + * @param {LangfuseAPI.MembershipRequest} request + * @param {Organizations.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.organizations.updateOrganizationMembership({ + * userId: "userId", + * role: "OWNER" + * }) + */ + updateOrganizationMembership(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__updateOrganizationMembership(request, requestOptions) + ); + } + async __updateOrganizationMembership(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/organizations/memberships" + ), + method: "PUT", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PUT /api/public/organizations/memberships." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete a membership from the organization associated with the API key (requires organization-scoped API key) + * + * @param {LangfuseAPI.DeleteMembershipRequest} request + * @param {Organizations.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.organizations.deleteOrganizationMembership({ + * userId: "userId" + * }) + */ + deleteOrganizationMembership(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__deleteOrganizationMembership(request, requestOptions) + ); + } + async __deleteOrganizationMembership(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/organizations/memberships" + ), + method: "DELETE", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/organizations/memberships." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get all memberships for a specific project (requires organization-scoped API key) + * + * @param {string} projectId + * @param {Organizations.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.organizations.getProjectMemberships("projectId") + */ + getProjectMemberships(projectId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getProjectMemberships(projectId, requestOptions) + ); + } + async __getProjectMemberships(projectId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/projects/${encodeURIComponent(projectId)}/memberships` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/projects/{projectId}/memberships." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Create or update a membership for a specific project (requires organization-scoped API key). The user must already be a member of the organization. + * + * @param {string} projectId + * @param {LangfuseAPI.MembershipRequest} request + * @param {Organizations.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.organizations.updateProjectMembership("projectId", { + * userId: "userId", + * role: "OWNER" + * }) + */ + updateProjectMembership(projectId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__updateProjectMembership(projectId, request, requestOptions) + ); + } + async __updateProjectMembership(projectId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/projects/${encodeURIComponent(projectId)}/memberships` + ), + method: "PUT", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PUT /api/public/projects/{projectId}/memberships." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete a membership from a specific project (requires organization-scoped API key). The user must be a member of the organization. + * + * @param {string} projectId + * @param {LangfuseAPI.DeleteMembershipRequest} request + * @param {Organizations.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.organizations.deleteProjectMembership("projectId", { + * userId: "userId" + * }) + */ + deleteProjectMembership(projectId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__deleteProjectMembership(projectId, request, requestOptions) + ); + } + async __deleteProjectMembership(projectId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/projects/${encodeURIComponent(projectId)}/memberships` + ), + method: "DELETE", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/projects/{projectId}/memberships." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get all projects for the organization associated with the API key (requires organization-scoped API key) + * + * @param {Organizations.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.organizations.getOrganizationProjects() + */ + getOrganizationProjects(requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getOrganizationProjects(requestOptions) + ); + } + async __getOrganizationProjects(requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/organizations/projects" + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/organizations/projects." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get all API keys for the organization associated with the API key (requires organization-scoped API key) + * + * @param {Organizations.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.organizations.getOrganizationApiKeys() + */ + getOrganizationApiKeys(requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getOrganizationApiKeys(requestOptions) + ); + } + async __getOrganizationApiKeys(requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/organizations/apiKeys" + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/organizations/apiKeys." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Projects = class { + constructor(_options) { + this._options = _options; + } + /** + * Get Project associated with API key (requires project-scoped API key). You can use GET /api/public/organizations/projects to get all projects with an organization-scoped key. + * + * @param {Projects.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.projects.get() + */ + get(requestOptions) { + return HttpResponsePromise.fromPromise(this.__get(requestOptions)); + } + async __get(requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/projects" + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/projects." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Create a new project (requires organization-scoped API key) + * + * @param {LangfuseAPI.CreateProjectRequest} request + * @param {Projects.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.projects.create({ + * name: "name", + * metadata: undefined, + * retention: 1 + * }) + */ + create(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__create(request, requestOptions) + ); + } + async __create(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/projects" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/projects." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Update a project by ID (requires organization-scoped API key). + * + * @param {string} projectId + * @param {LangfuseAPI.UpdateProjectRequest} request + * @param {Projects.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.projects.update("projectId", { + * name: "name", + * metadata: undefined, + * retention: undefined + * }) + */ + update(projectId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__update(projectId, request, requestOptions) + ); + } + async __update(projectId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/projects/${encodeURIComponent(projectId)}` + ), + method: "PUT", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PUT /api/public/projects/{projectId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete a project by ID (requires organization-scoped API key). Project deletion is processed asynchronously. + * + * @param {string} projectId + * @param {Projects.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.projects.delete("projectId") + */ + delete(projectId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__delete(projectId, requestOptions) + ); + } + async __delete(projectId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/projects/${encodeURIComponent(projectId)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/projects/{projectId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get all API keys for a project (requires organization-scoped API key) + * + * @param {string} projectId + * @param {Projects.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.projects.getApiKeys("projectId") + */ + getApiKeys(projectId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getApiKeys(projectId, requestOptions) + ); + } + async __getApiKeys(projectId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/projects/${encodeURIComponent(projectId)}/apiKeys` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/projects/{projectId}/apiKeys." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Create a new API key for a project (requires organization-scoped API key) + * + * @param {string} projectId + * @param {LangfuseAPI.CreateApiKeyRequest} request + * @param {Projects.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.projects.createApiKey("projectId", { + * note: undefined, + * publicKey: undefined, + * secretKey: undefined + * }) + */ + createApiKey(projectId, request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__createApiKey(projectId, request, requestOptions) + ); + } + async __createApiKey(projectId, request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/projects/${encodeURIComponent(projectId)}/apiKeys` + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/projects/{projectId}/apiKeys." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete an API key for a project (requires organization-scoped API key) + * + * @param {string} projectId + * @param {string} apiKeyId + * @param {Projects.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.projects.deleteApiKey("projectId", "apiKeyId") + */ + deleteApiKey(projectId, apiKeyId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__deleteApiKey(projectId, apiKeyId, requestOptions) + ); + } + async __deleteApiKey(projectId, apiKeyId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/projects/${encodeURIComponent(projectId)}/apiKeys/${encodeURIComponent(apiKeyId)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/projects/{projectId}/apiKeys/{apiKeyId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var PromptVersion = class { + constructor(_options) { + this._options = _options; + } + /** + * Update labels for a specific prompt version + * + * @param {string} name - The name of the prompt. If the prompt is in a folder (e.g., "folder/subfolder/prompt-name"), + * the folder path must be URL encoded. + * @param {number} version - Version of the prompt to update + * @param {LangfuseAPI.UpdatePromptRequest} request + * @param {PromptVersion.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.promptVersion.update("name", 1, { + * newLabels: ["newLabels", "newLabels"] + * }) + */ + update(name, version, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__update(name, version, request, requestOptions) + ); + } + async __update(name, version, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/v2/prompts/${encodeURIComponent(name)}/versions/${encodeURIComponent(version)}` + ), + method: "PATCH", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PATCH /api/public/v2/prompts/{name}/versions/{version}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Prompts = class { + constructor(_options) { + this._options = _options; + } + /** + * Get a prompt + * + * @param {string} promptName - The name of the prompt. If the prompt is in a folder (e.g., "folder/subfolder/prompt-name"), + * the folder path must be URL encoded. + * @param {LangfuseAPI.GetPromptRequest} request + * @param {Prompts.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.prompts.get("promptName") + */ + get(promptName, request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__get(promptName, request, requestOptions) + ); + } + async __get(promptName, request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { version, label, resolve: resolve2 } = request; + const _queryParams = {}; + if (version != null) { + _queryParams["version"] = version.toString(); + } + if (label != null) { + _queryParams["label"] = label; + } + if (resolve2 != null) { + _queryParams["resolve"] = resolve2.toString(); + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/v2/prompts/${encodeURIComponent(promptName)}` + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/v2/prompts/{promptName}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a list of prompt names with versions and labels + * + * @param {LangfuseAPI.ListPromptsMetaRequest} request + * @param {Prompts.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.prompts.list() + */ + list(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__list(request, requestOptions) + ); + } + async __list(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { name, label, tag, page, limit, fromUpdatedAt, toUpdatedAt } = request; + const _queryParams = {}; + if (name != null) { + _queryParams["name"] = name; + } + if (label != null) { + _queryParams["label"] = label; + } + if (tag != null) { + _queryParams["tag"] = tag; + } + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + if (fromUpdatedAt != null) { + _queryParams["fromUpdatedAt"] = fromUpdatedAt; + } + if (toUpdatedAt != null) { + _queryParams["toUpdatedAt"] = toUpdatedAt; + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/v2/prompts" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/v2/prompts." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Create a new version for the prompt with the given `name` + * + * @param {LangfuseAPI.CreatePromptRequest} request + * @param {Prompts.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.prompts.create({ + * name: "name", + * prompt: [{ + * role: "role", + * content: "content", + * type: undefined + * }, { + * role: "role", + * content: "content", + * type: undefined + * }], + * config: undefined, + * type: "chat", + * labels: undefined, + * tags: undefined, + * commitMessage: undefined + * }) + */ + create(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__create(request, requestOptions) + ); + } + async __create(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/v2/prompts" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/v2/prompts." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete prompt versions. If neither version nor label is specified, all versions of the prompt are deleted. + * + * @param {string} promptName - The name of the prompt + * @param {LangfuseAPI.DeletePromptRequest} request + * @param {Prompts.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.prompts.delete("promptName") + */ + delete(promptName, request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__delete(promptName, request, requestOptions) + ); + } + async __delete(promptName, request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { label, version } = request; + const _queryParams = {}; + if (label != null) { + _queryParams["label"] = label; + } + if (version != null) { + _queryParams["version"] = version.toString(); + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/v2/prompts/${encodeURIComponent(promptName)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { data: void 0, rawResponse: _response.rawResponse }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/v2/prompts/{promptName}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Scim = class { + constructor(_options) { + this._options = _options; + } + /** + * Get SCIM Service Provider Configuration (requires organization-scoped API key) + * + * @param {Scim.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scim.getServiceProviderConfig() + */ + getServiceProviderConfig(requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getServiceProviderConfig(requestOptions) + ); + } + async __getServiceProviderConfig(requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/scim/ServiceProviderConfig" + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/scim/ServiceProviderConfig." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get SCIM Resource Types (requires organization-scoped API key) + * + * @param {Scim.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scim.getResourceTypes() + */ + getResourceTypes(requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getResourceTypes(requestOptions) + ); + } + async __getResourceTypes(requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/scim/ResourceTypes" + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/scim/ResourceTypes." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get SCIM Schemas (requires organization-scoped API key) + * + * @param {Scim.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scim.getSchemas() + */ + getSchemas(requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getSchemas(requestOptions) + ); + } + async __getSchemas(requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/scim/Schemas" + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/scim/Schemas." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * List users in the organization (requires organization-scoped API key) + * + * @param {LangfuseAPI.ListUsersRequest} request + * @param {Scim.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scim.listUsers() + */ + listUsers(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__listUsers(request, requestOptions) + ); + } + async __listUsers(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { filter, startIndex, count } = request; + const _queryParams = {}; + if (filter != null) { + _queryParams["filter"] = filter; + } + if (startIndex != null) { + _queryParams["startIndex"] = startIndex.toString(); + } + if (count != null) { + _queryParams["count"] = count.toString(); + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/scim/Users" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/scim/Users." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Create a new user in the organization (requires organization-scoped API key) + * + * @param {LangfuseAPI.CreateUserRequest} request + * @param {Scim.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scim.createUser({ + * userName: "userName", + * name: { + * formatted: undefined + * }, + * emails: undefined, + * active: undefined, + * password: undefined + * }) + */ + createUser(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__createUser(request, requestOptions) + ); + } + async __createUser(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/scim/Users" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/scim/Users." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a specific user by ID (requires organization-scoped API key) + * + * @param {string} userId + * @param {Scim.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scim.getUser("userId") + */ + getUser(userId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getUser(userId, requestOptions) + ); + } + async __getUser(userId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/scim/Users/${encodeURIComponent(userId)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/scim/Users/{userId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Remove a user from the organization (requires organization-scoped API key). Note that this only removes the user from the organization but does not delete the user entity itself. + * + * @param {string} userId + * @param {Scim.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scim.deleteUser("userId") + */ + deleteUser(userId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__deleteUser(userId, requestOptions) + ); + } + async __deleteUser(userId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/scim/Users/${encodeURIComponent(userId)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/scim/Users/{userId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var ScoreConfigs = class { + constructor(_options) { + this._options = _options; + } + /** + * Create a score configuration (config). Score configs are used to define the structure of scores + * + * @param {LangfuseAPI.CreateScoreConfigRequest} request + * @param {ScoreConfigs.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scoreConfigs.create({ + * name: "name", + * dataType: "NUMERIC", + * categories: undefined, + * minValue: undefined, + * maxValue: undefined, + * description: undefined + * }) + */ + create(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__create(request, requestOptions) + ); + } + async __create(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/score-configs" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/score-configs." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get all score configs + * + * @param {LangfuseAPI.GetScoreConfigsRequest} request + * @param {ScoreConfigs.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scoreConfigs.get() + */ + get(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__get(request, requestOptions) + ); + } + async __get(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { page, limit } = request; + const _queryParams = {}; + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/score-configs" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/score-configs." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a score config + * + * @param {string} configId - The unique langfuse identifier of a score config + * @param {ScoreConfigs.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scoreConfigs.getById("configId") + */ + getById(configId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getById(configId, requestOptions) + ); + } + async __getById(configId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/score-configs/${encodeURIComponent(configId)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/score-configs/{configId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Update a score config + * + * @param {string} configId - The unique langfuse identifier of a score config + * @param {LangfuseAPI.UpdateScoreConfigRequest} request + * @param {ScoreConfigs.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scoreConfigs.update("configId", { + * isArchived: undefined, + * name: undefined, + * categories: undefined, + * minValue: undefined, + * maxValue: undefined, + * description: undefined + * }) + */ + update(configId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__update(configId, request, requestOptions) + ); + } + async __update(configId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/score-configs/${encodeURIComponent(configId)}` + ), + method: "PATCH", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PATCH /api/public/score-configs/{configId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var ScoresV3 = class { + constructor(_options) { + this._options = _options; + } + /** + * Get a list of scores with a polymorphic `value` field (v3). + * + * The `value` field type depends on `dataType`: + * - `NUMERIC` → number + * - `BOOLEAN` → boolean + * - `CATEGORICAL`, `TEXT`, `CORRECTION` → string + * + * The response always includes the core fields: id, projectId, name, + * value, dataType, source, timestamp, environment, createdAt, updatedAt. + * + * Additional field groups can be requested via the `fields` parameter: + * - `details` — adds comment, configId, metadata + * - `subject` — adds the subject object describing the entity the score + * is attached to: kind (trace, observation, session, or experiment), + * id, and traceId for observation-level scores + * - `annotation` — adds authorUserId, queueId + * + * Unknown group names return HTTP 400. + * + * @param {LangfuseAPI.GetScoresV3Request} request + * @param {ScoresV3.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.scoresV3.getManyV3() + */ + getManyV3(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__getManyV3(request, requestOptions) + ); + } + async __getManyV3(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { + limit, + cursor, + fields, + id, + name, + source, + dataType, + environment, + configId, + queueId, + authorUserId, + value, + valueMin, + valueMax, + traceId, + sessionId: sessionId2, + observationId, + experimentId, + fromTimestamp, + toTimestamp + } = request; + const _queryParams = {}; + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + if (cursor != null) { + _queryParams["cursor"] = cursor; + } + if (fields != null) { + _queryParams["fields"] = fields; + } + if (id != null) { + _queryParams["id"] = id; + } + if (name != null) { + _queryParams["name"] = name; + } + if (source != null) { + _queryParams["source"] = source; + } + if (dataType != null) { + _queryParams["dataType"] = dataType; + } + if (environment != null) { + _queryParams["environment"] = environment; + } + if (configId != null) { + _queryParams["configId"] = configId; + } + if (queueId != null) { + _queryParams["queueId"] = queueId; + } + if (authorUserId != null) { + _queryParams["authorUserId"] = authorUserId; + } + if (value != null) { + _queryParams["value"] = value; + } + if (valueMin != null) { + _queryParams["valueMin"] = valueMin.toString(); + } + if (valueMax != null) { + _queryParams["valueMax"] = valueMax.toString(); + } + if (traceId != null) { + _queryParams["traceId"] = traceId; + } + if (sessionId2 != null) { + _queryParams["sessionId"] = sessionId2; + } + if (observationId != null) { + _queryParams["observationId"] = observationId; + } + if (experimentId != null) { + _queryParams["experimentId"] = experimentId; + } + if (fromTimestamp != null) { + _queryParams["fromTimestamp"] = fromTimestamp; + } + if (toTimestamp != null) { + _queryParams["toTimestamp"] = toTimestamp; + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/v3/scores" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/v3/scores." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Sessions = class { + constructor(_options) { + this._options = _options; + } + /** + * Get sessions. + * + * This legacy endpoint is not recommended for new data extraction workflows. + * Use the v2 observations endpoint with a bounded time range and group rows by + * `sessionId` instead: + * `GET /api/public/v2/observations?fromStartTime=&toStartTime=`. + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. In Langfuse v4, read session data via `GET /api/public/v2/observations?filter=&fromStartTime=&toStartTime=`. Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {LangfuseAPI.GetSessionsRequest} request + * @param {Sessions.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.sessions.list() + */ + list(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__list(request, requestOptions) + ); + } + async __list(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { page, limit, fromTimestamp, toTimestamp, environment } = request; + const _queryParams = {}; + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + if (fromTimestamp != null) { + _queryParams["fromTimestamp"] = fromTimestamp; + } + if (toTimestamp != null) { + _queryParams["toTimestamp"] = toTimestamp; + } + if (environment != null) { + if (Array.isArray(environment)) { + _queryParams["environment"] = environment.map((item) => item); + } else { + _queryParams["environment"] = environment; + } + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/sessions" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/sessions." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a session. + * + * Please note that `traces` on this endpoint are not paginated. For large + * sessions or new data extraction workflows, use the v2 observations endpoint + * with a URL-encoded `sessionId` filter and a bounded time range: + * `GET /api/public/v2/observations?filter=&fromStartTime=&toStartTime=`. + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. In Langfuse v4, read session data via `GET /api/public/v2/observations?filter=&fromStartTime=&toStartTime=`. Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {string} sessionId - The unique id of a session + * @param {Sessions.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.sessions.get("sessionId") + */ + get(sessionId2, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__get(sessionId2, requestOptions) + ); + } + async __get(sessionId2, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/sessions/${encodeURIComponent(sessionId2)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/sessions/{sessionId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Trace = class { + constructor(_options) { + this._options = _options; + } + /** + * Get a specific trace + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. In Langfuse v4, read span and trace data via `GET /api/public/v2/observations?fromStartTime=&toStartTime=`. Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {string} traceId - The unique langfuse identifier of a trace + * @param {LangfuseAPI.GetTraceRequest} request + * @param {Trace.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.trace.get("traceId") + */ + get(traceId, request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__get(traceId, request, requestOptions) + ); + } + async __get(traceId, request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { fields } = request; + const _queryParams = {}; + if (fields != null) { + _queryParams["fields"] = fields; + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/traces/${encodeURIComponent(traceId)}` + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/traces/{traceId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete a specific trace + * + * @param {string} traceId - The unique langfuse identifier of the trace to delete + * @param {Trace.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.trace.delete("traceId") + */ + delete(traceId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__delete(traceId, requestOptions) + ); + } + async __delete(traceId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/traces/${encodeURIComponent(traceId)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/traces/{traceId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get list of traces + * + * @deprecated On Langfuse Cloud, Langfuse v3 is deprecated and this endpoint will be removed on November 16, 2026. In Langfuse v4, read span and trace data via `GET /api/public/v2/observations?fromStartTime=&toStartTime=`. Self-hosted deployments are unaffected by this date; the endpoint becomes unavailable when they upgrade to Langfuse v4. + * + * @param {LangfuseAPI.GetTracesRequest} request + * @param {Trace.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.trace.list() + */ + list(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__list(request, requestOptions) + ); + } + async __list(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { + page, + limit, + userId, + name, + sessionId: sessionId2, + fromTimestamp, + toTimestamp, + orderBy, + tags, + version, + release, + environment, + fields, + filter + } = request; + const _queryParams = {}; + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + if (userId != null) { + _queryParams["userId"] = userId; + } + if (name != null) { + _queryParams["name"] = name; + } + if (sessionId2 != null) { + _queryParams["sessionId"] = sessionId2; + } + if (fromTimestamp != null) { + _queryParams["fromTimestamp"] = fromTimestamp; + } + if (toTimestamp != null) { + _queryParams["toTimestamp"] = toTimestamp; + } + if (orderBy != null) { + _queryParams["orderBy"] = orderBy; + } + if (tags != null) { + if (Array.isArray(tags)) { + _queryParams["tags"] = tags.map((item) => item); + } else { + _queryParams["tags"] = tags; + } + } + if (version != null) { + _queryParams["version"] = version; + } + if (release != null) { + _queryParams["release"] = release; + } + if (environment != null) { + if (Array.isArray(environment)) { + _queryParams["environment"] = environment.map((item) => item); + } else { + _queryParams["environment"] = environment; + } + } + if (fields != null) { + _queryParams["fields"] = fields; + } + if (filter != null) { + _queryParams["filter"] = filter; + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/traces" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/traces." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete multiple traces + * + * @param {LangfuseAPI.DeleteTracesRequest} request + * @param {Trace.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.trace.deleteMultiple({ + * traceIds: ["traceIds", "traceIds"] + * }) + */ + deleteMultiple(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__deleteMultiple(request, requestOptions) + ); + } + async __deleteMultiple(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/traces" + ), + method: "DELETE", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/traces." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var DashboardWidgets = class { + constructor(_options) { + this._options = _options; + } + /** + * List dashboard widgets in the project, ordered by most recently + * updated first. + * + * Responses may include legacy `traces` widgets created before this + * API existed. New widgets cannot be created with `view: traces`. + * + * @param {LangfuseAPI.unstable.ListDashboardWidgetsRequest} request + * @param {DashboardWidgets.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.unstable.BadRequestError} + * @throws {@link LangfuseAPI.unstable.UnauthorizedError} + * @throws {@link LangfuseAPI.unstable.AccessDeniedError} + * @throws {@link LangfuseAPI.unstable.MethodNotAllowedError} + * @throws {@link LangfuseAPI.unstable.TooManyRequestsError} + * @throws {@link LangfuseAPI.unstable.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.unstable.dashboardWidgets.list() + */ + list(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__list(request, requestOptions) + ); + } + async __list(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { page, limit } = request; + const _queryParams = {}; + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/unstable/dashboard-widgets" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new unstable_exports.BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new unstable_exports.UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new unstable_exports.AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new unstable_exports.MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new unstable_exports.TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new unstable_exports.InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/unstable/dashboard-widgets." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Create a dashboard widget (a standalone chart definition you place on + * any dashboard). + * + * This endpoint creates the widget only; place it on a dashboard via + * `POST /dashboards/{dashboardId}/placements`. + * + * Supported views are `observations`, `scores-numeric`, `scores-boolean`, and `scores-categorical`. + * The legacy `traces` view is not supported by this unstable API. + * Widgets are created as v2 internally. + * + * `chartConfig` is optional and defaults to the plain config for + * `chartType`; when `chartConfig.type` is given it must match + * `chartType`. + * + * Unstable API note: + * - This surface may evolve while dashboard/widget APIs are being finalized. + * + * @param {LangfuseAPI.unstable.CreateDashboardWidgetRequest} request + * @param {DashboardWidgets.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.unstable.BadRequestError} + * @throws {@link LangfuseAPI.unstable.UnauthorizedError} + * @throws {@link LangfuseAPI.unstable.AccessDeniedError} + * @throws {@link LangfuseAPI.unstable.MethodNotAllowedError} + * @throws {@link LangfuseAPI.unstable.TooManyRequestsError} + * @throws {@link LangfuseAPI.unstable.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.unstable.dashboardWidgets.create({ + * name: "Total cost by model", + * description: "Total model cost grouped by provided model name.", + * view: "observations", + * dimensions: [{ + * field: "providedModelName" + * }], + * metrics: [{ + * measure: "totalCost", + * agg: "sum" + * }], + * filters: [], + * chartType: "HORIZONTAL_BAR", + * chartConfig: { + * row_limit: 10 + * } + * }) + */ + create(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__create(request, requestOptions) + ); + } + async __create(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/unstable/dashboard-widgets" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new unstable_exports.BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new unstable_exports.UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new unstable_exports.AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new unstable_exports.MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new unstable_exports.TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new unstable_exports.InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/unstable/dashboard-widgets." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a dashboard widget by id. + * + * The response may use `view: traces` for legacy widgets. + * + * @param {string} widgetId + * @param {DashboardWidgets.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.unstable.BadRequestError} + * @throws {@link LangfuseAPI.unstable.UnauthorizedError} + * @throws {@link LangfuseAPI.unstable.AccessDeniedError} + * @throws {@link LangfuseAPI.unstable.NotFoundError} + * @throws {@link LangfuseAPI.unstable.MethodNotAllowedError} + * @throws {@link LangfuseAPI.unstable.TooManyRequestsError} + * @throws {@link LangfuseAPI.unstable.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.unstable.dashboardWidgets.get("widgetId") + */ + get(widgetId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__get(widgetId, requestOptions) + ); + } + async __get(widgetId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/unstable/dashboard-widgets/${encodeURIComponent(widgetId)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new unstable_exports.BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new unstable_exports.UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new unstable_exports.AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new unstable_exports.NotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new unstable_exports.MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new unstable_exports.TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new unstable_exports.InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/unstable/dashboard-widgets/{widgetId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Update a dashboard widget. + * + * All fields are optional; at least one field is required. + * Changing `chartType` without sending `chartConfig` resets the config + * to the new chart type's defaults. When `chartConfig.type` is given + * it must match the widget's (possibly updated) `chartType`. + * + * `view` cannot be changed to the legacy `traces` value. Existing + * `traces` widgets may be updated on other fields. + * + * @param {string} widgetId + * @param {LangfuseAPI.unstable.UpdateDashboardWidgetRequest} request + * @param {DashboardWidgets.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.unstable.BadRequestError} + * @throws {@link LangfuseAPI.unstable.UnauthorizedError} + * @throws {@link LangfuseAPI.unstable.AccessDeniedError} + * @throws {@link LangfuseAPI.unstable.NotFoundError} + * @throws {@link LangfuseAPI.unstable.MethodNotAllowedError} + * @throws {@link LangfuseAPI.unstable.TooManyRequestsError} + * @throws {@link LangfuseAPI.unstable.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.unstable.dashboardWidgets.update("widgetId", { + * name: undefined, + * description: undefined, + * view: undefined, + * dimensions: undefined, + * metrics: undefined, + * filters: undefined, + * chartType: undefined, + * chartConfig: undefined + * }) + */ + update(widgetId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__update(widgetId, request, requestOptions) + ); + } + async __update(widgetId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/unstable/dashboard-widgets/${encodeURIComponent(widgetId)}` + ), + method: "PATCH", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new unstable_exports.BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new unstable_exports.UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new unstable_exports.AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new unstable_exports.NotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new unstable_exports.MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new unstable_exports.TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new unstable_exports.InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PATCH /api/public/unstable/dashboard-widgets/{widgetId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete a dashboard widget. + * + * The API returns `409` while the widget is still placed on a dashboard. + * Remove those placements first. + * + * @param {string} widgetId + * @param {DashboardWidgets.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.unstable.BadRequestError} + * @throws {@link LangfuseAPI.unstable.UnauthorizedError} + * @throws {@link LangfuseAPI.unstable.AccessDeniedError} + * @throws {@link LangfuseAPI.unstable.NotFoundError} + * @throws {@link LangfuseAPI.unstable.MethodNotAllowedError} + * @throws {@link LangfuseAPI.unstable.ConflictError} + * @throws {@link LangfuseAPI.unstable.TooManyRequestsError} + * @throws {@link LangfuseAPI.unstable.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.unstable.dashboardWidgets.delete("widgetId") + */ + delete(widgetId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__delete(widgetId, requestOptions) + ); + } + async __delete(widgetId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/unstable/dashboard-widgets/${encodeURIComponent(widgetId)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new unstable_exports.BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new unstable_exports.UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new unstable_exports.AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new unstable_exports.NotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new unstable_exports.MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 409: + throw new unstable_exports.ConflictError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new unstable_exports.TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new unstable_exports.InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/unstable/dashboard-widgets/{widgetId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Dashboards = class { + constructor(_options) { + this._options = _options; + } + /** + * List dashboards in the project, ordered by most recently updated + * first. + * + * @param {LangfuseAPI.unstable.ListDashboardsRequest} request + * @param {Dashboards.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.unstable.BadRequestError} + * @throws {@link LangfuseAPI.unstable.UnauthorizedError} + * @throws {@link LangfuseAPI.unstable.AccessDeniedError} + * @throws {@link LangfuseAPI.unstable.MethodNotAllowedError} + * @throws {@link LangfuseAPI.unstable.TooManyRequestsError} + * @throws {@link LangfuseAPI.unstable.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.unstable.dashboards.list() + */ + list(request = {}, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__list(request, requestOptions) + ); + } + async __list(request = {}, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + const { page, limit } = request; + const _queryParams = {}; + if (page != null) { + _queryParams["page"] = page.toString(); + } + if (limit != null) { + _queryParams["limit"] = limit.toString(); + } + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/unstable/dashboards" + ), + method: "GET", + headers: _headers, + queryParameters: { ..._queryParams, ...requestOptions == null ? void 0 : requestOptions.queryParams }, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new unstable_exports.BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new unstable_exports.UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new unstable_exports.AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new unstable_exports.MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new unstable_exports.TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new unstable_exports.InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/unstable/dashboards." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Create a dashboard. + * + * @param {LangfuseAPI.unstable.CreateDashboardRequest} request + * @param {Dashboards.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.unstable.BadRequestError} + * @throws {@link LangfuseAPI.unstable.UnauthorizedError} + * @throws {@link LangfuseAPI.unstable.AccessDeniedError} + * @throws {@link LangfuseAPI.unstable.NotFoundError} + * @throws {@link LangfuseAPI.unstable.MethodNotAllowedError} + * @throws {@link LangfuseAPI.unstable.TooManyRequestsError} + * @throws {@link LangfuseAPI.unstable.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.unstable.dashboards.create({ + * name: "name", + * description: undefined, + * definition: undefined, + * filters: undefined + * }) + */ + create(request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__create(request, requestOptions) + ); + } + async __create(request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + "/api/public/unstable/dashboards" + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new unstable_exports.BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new unstable_exports.UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new unstable_exports.AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new unstable_exports.NotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new unstable_exports.MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new unstable_exports.TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new unstable_exports.InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/unstable/dashboards." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Get a dashboard by id. + * + * @param {string} dashboardId + * @param {Dashboards.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.unstable.BadRequestError} + * @throws {@link LangfuseAPI.unstable.UnauthorizedError} + * @throws {@link LangfuseAPI.unstable.AccessDeniedError} + * @throws {@link LangfuseAPI.unstable.NotFoundError} + * @throws {@link LangfuseAPI.unstable.MethodNotAllowedError} + * @throws {@link LangfuseAPI.unstable.TooManyRequestsError} + * @throws {@link LangfuseAPI.unstable.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.unstable.dashboards.get("dashboardId") + */ + get(dashboardId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__get(dashboardId, requestOptions) + ); + } + async __get(dashboardId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/unstable/dashboards/${encodeURIComponent(dashboardId)}` + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new unstable_exports.BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new unstable_exports.UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new unstable_exports.AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new unstable_exports.NotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new unstable_exports.MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new unstable_exports.TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new unstable_exports.InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling GET /api/public/unstable/dashboards/{dashboardId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Update a dashboard's name, description, definition, or filters. + * + * @param {string} dashboardId + * @param {LangfuseAPI.unstable.UpdateDashboardRequest} request + * @param {Dashboards.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.unstable.BadRequestError} + * @throws {@link LangfuseAPI.unstable.UnauthorizedError} + * @throws {@link LangfuseAPI.unstable.AccessDeniedError} + * @throws {@link LangfuseAPI.unstable.NotFoundError} + * @throws {@link LangfuseAPI.unstable.MethodNotAllowedError} + * @throws {@link LangfuseAPI.unstable.TooManyRequestsError} + * @throws {@link LangfuseAPI.unstable.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.unstable.dashboards.update("dashboardId", { + * name: undefined, + * description: undefined, + * definition: undefined, + * filters: undefined + * }) + */ + update(dashboardId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__update(dashboardId, request, requestOptions) + ); + } + async __update(dashboardId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/unstable/dashboards/${encodeURIComponent(dashboardId)}` + ), + method: "PATCH", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new unstable_exports.BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new unstable_exports.UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new unstable_exports.AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new unstable_exports.NotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new unstable_exports.MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new unstable_exports.TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new unstable_exports.InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PATCH /api/public/unstable/dashboards/{dashboardId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Delete a dashboard. + * + * @param {string} dashboardId + * @param {Dashboards.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.unstable.BadRequestError} + * @throws {@link LangfuseAPI.unstable.UnauthorizedError} + * @throws {@link LangfuseAPI.unstable.AccessDeniedError} + * @throws {@link LangfuseAPI.unstable.NotFoundError} + * @throws {@link LangfuseAPI.unstable.MethodNotAllowedError} + * @throws {@link LangfuseAPI.unstable.TooManyRequestsError} + * @throws {@link LangfuseAPI.unstable.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.unstable.dashboards.delete("dashboardId") + */ + delete(dashboardId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__delete(dashboardId, requestOptions) + ); + } + async __delete(dashboardId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/unstable/dashboards/${encodeURIComponent(dashboardId)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new unstable_exports.BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new unstable_exports.UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new unstable_exports.AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new unstable_exports.NotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new unstable_exports.MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new unstable_exports.TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new unstable_exports.InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/unstable/dashboards/{dashboardId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Add a placement to a dashboard grid (see `DashboardPlacement` for + * grid semantics). + * + * `id` and the position fields are optional: when omitted, the + * placement gets a server-generated id and is appended below all + * existing tiles as a 6x6 tile. Returns the created placement. + * + * The referenced widget must exist in the same project or be a + * Langfuse-managed widget. The API returns `409` if a placement with + * the same `id` already exists on the dashboard. + * + * @param {string} dashboardId + * @param {LangfuseAPI.unstable.CreateDashboardPlacementRequest} request + * @param {Dashboards.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.unstable.BadRequestError} + * @throws {@link LangfuseAPI.unstable.UnauthorizedError} + * @throws {@link LangfuseAPI.unstable.AccessDeniedError} + * @throws {@link LangfuseAPI.unstable.NotFoundError} + * @throws {@link LangfuseAPI.unstable.MethodNotAllowedError} + * @throws {@link LangfuseAPI.unstable.ConflictError} + * @throws {@link LangfuseAPI.unstable.TooManyRequestsError} + * @throws {@link LangfuseAPI.unstable.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.unstable.dashboards.addPlacement("dashboardId", { + * type: "widget", + * id: undefined, + * widgetId: "widgetId", + * x: undefined, + * y: undefined, + * width: undefined, + * height: undefined + * }) + */ + addPlacement(dashboardId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__addPlacement(dashboardId, request, requestOptions) + ); + } + async __addPlacement(dashboardId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/unstable/dashboards/${encodeURIComponent(dashboardId)}/placements` + ), + method: "POST", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new unstable_exports.BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new unstable_exports.UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new unstable_exports.AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new unstable_exports.NotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new unstable_exports.MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 409: + throw new unstable_exports.ConflictError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new unstable_exports.TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new unstable_exports.InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling POST /api/public/unstable/dashboards/{dashboardId}/placements." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Move or resize a placement. All fields are optional; at least one is + * required. Omitted fields keep their current value. The placement's + * content (widget/preset reference) and id cannot change — delete and + * re-add the placement to swap content. Returns the updated placement. + * + * @param {string} dashboardId + * @param {string} placementId + * @param {LangfuseAPI.unstable.UpdateDashboardPlacementRequest} request + * @param {Dashboards.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.unstable.BadRequestError} + * @throws {@link LangfuseAPI.unstable.UnauthorizedError} + * @throws {@link LangfuseAPI.unstable.AccessDeniedError} + * @throws {@link LangfuseAPI.unstable.NotFoundError} + * @throws {@link LangfuseAPI.unstable.MethodNotAllowedError} + * @throws {@link LangfuseAPI.unstable.TooManyRequestsError} + * @throws {@link LangfuseAPI.unstable.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.unstable.dashboards.updatePlacement("dashboardId", "placementId", { + * x: undefined, + * y: undefined, + * width: undefined, + * height: undefined + * }) + */ + updatePlacement(dashboardId, placementId, request, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__updatePlacement(dashboardId, placementId, request, requestOptions) + ); + } + async __updatePlacement(dashboardId, placementId, request, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/unstable/dashboards/${encodeURIComponent(dashboardId)}/placements/${encodeURIComponent(placementId)}` + ), + method: "PATCH", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + requestType: "json", + body: request, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new unstable_exports.BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new unstable_exports.UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new unstable_exports.AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new unstable_exports.NotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new unstable_exports.MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new unstable_exports.TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new unstable_exports.InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling PATCH /api/public/unstable/dashboards/{dashboardId}/placements/{placementId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + /** + * Remove a placement from a dashboard grid without deleting the referenced widget. + * + * @param {string} dashboardId + * @param {string} placementId + * @param {Dashboards.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link LangfuseAPI.unstable.BadRequestError} + * @throws {@link LangfuseAPI.unstable.UnauthorizedError} + * @throws {@link LangfuseAPI.unstable.AccessDeniedError} + * @throws {@link LangfuseAPI.unstable.NotFoundError} + * @throws {@link LangfuseAPI.unstable.MethodNotAllowedError} + * @throws {@link LangfuseAPI.unstable.TooManyRequestsError} + * @throws {@link LangfuseAPI.unstable.InternalServerError} + * @throws {@link LangfuseAPI.Error} + * @throws {@link LangfuseAPI.UnauthorizedError} + * @throws {@link LangfuseAPI.AccessDeniedError} + * @throws {@link LangfuseAPI.MethodNotAllowedError} + * @throws {@link LangfuseAPI.NotFoundError} + * + * @example + * await client.unstable.dashboards.deletePlacement("dashboardId", "placementId") + */ + deletePlacement(dashboardId, placementId, requestOptions) { + return HttpResponsePromise.fromPromise( + this.__deletePlacement(dashboardId, placementId, requestOptions) + ); + } + async __deletePlacement(dashboardId, placementId, requestOptions) { + var _a2, _b, _c, _d, _e, _f, _g, _h; + let _headers = mergeHeaders( + (_a2 = this._options) == null ? void 0 : _a2.headers, + mergeOnlyDefinedHeaders({ + Authorization: await this._getAuthorizationHeader(), + "X-Langfuse-Sdk-Name": (_c = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkName) != null ? _c : (_b = this._options) == null ? void 0 : _b.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": (_e = requestOptions == null ? void 0 : requestOptions.xLangfuseSdkVersion) != null ? _e : (_d = this._options) == null ? void 0 : _d.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": (_g = requestOptions == null ? void 0 : requestOptions.xLangfusePublicKey) != null ? _g : (_f = this._options) == null ? void 0 : _f.xLangfusePublicKey + }), + requestOptions == null ? void 0 : requestOptions.headers + ); + const _response = await fetcher({ + url: url_exports.join( + (_h = await Supplier.get(this._options.baseUrl)) != null ? _h : await Supplier.get(this._options.environment), + `/api/public/unstable/dashboards/${encodeURIComponent(dashboardId)}/placements/${encodeURIComponent(placementId)}` + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions == null ? void 0 : requestOptions.queryParams, + timeoutMs: (requestOptions == null ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1e3 : 6e4, + maxRetries: requestOptions == null ? void 0 : requestOptions.maxRetries, + abortSignal: requestOptions == null ? void 0 : requestOptions.abortSignal + }); + if (_response.ok) { + return { + data: _response.body, + rawResponse: _response.rawResponse + }; + } + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new unstable_exports.BadRequestError( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new unstable_exports.UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new unstable_exports.AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new unstable_exports.NotFoundError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new unstable_exports.MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 429: + throw new unstable_exports.TooManyRequestsError( + _response.error.body, + _response.rawResponse + ); + case 500: + throw new unstable_exports.InternalServerError( + _response.error.body, + _response.rawResponse + ); + case 400: + throw new Error2( + _response.error.body, + _response.rawResponse + ); + case 401: + throw new UnauthorizedError( + _response.error.body, + _response.rawResponse + ); + case 403: + throw new AccessDeniedError( + _response.error.body, + _response.rawResponse + ); + case 405: + throw new MethodNotAllowedError( + _response.error.body, + _response.rawResponse + ); + case 404: + throw new NotFoundError( + _response.error.body, + _response.rawResponse + ); + default: + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse + }); + } + } + switch (_response.error.reason) { + case "non-json": + throw new LangfuseAPIError({ + statusCode: _response.error.statusCode, + body: _response.error.rawBody, + rawResponse: _response.rawResponse + }); + case "timeout": + throw new LangfuseAPITimeoutError( + "Timeout exceeded when calling DELETE /api/public/unstable/dashboards/{dashboardId}/placements/{placementId}." + ); + case "unknown": + throw new LangfuseAPIError({ + message: _response.error.errorMessage, + rawResponse: _response.rawResponse + }); + } + } + async _getAuthorizationHeader() { + const username = await Supplier.get(this._options.username); + const password = await Supplier.get(this._options.password); + if (username != null && password != null) { + return BasicAuth.toAuthorizationHeader({ + username, + password + }); + } + return void 0; + } +}; +var Unstable = class { + constructor(_options) { + this._options = _options; + } + get dashboardWidgets() { + var _a2; + return (_a2 = this._dashboardWidgets) != null ? _a2 : this._dashboardWidgets = new DashboardWidgets(this._options); + } + get dashboards() { + var _a2; + return (_a2 = this._dashboards) != null ? _a2 : this._dashboards = new Dashboards(this._options); + } +}; +var LangfuseAPIClient = class { + constructor(_options) { + this._options = { + ..._options, + headers: mergeHeaders( + { + "X-Langfuse-Sdk-Name": _options == null ? void 0 : _options.xLangfuseSdkName, + "X-Langfuse-Sdk-Version": _options == null ? void 0 : _options.xLangfuseSdkVersion, + "X-Langfuse-Public-Key": _options == null ? void 0 : _options.xLangfusePublicKey + }, + _options == null ? void 0 : _options.headers + ) + }; + } + get annotationQueues() { + var _a2; + return (_a2 = this._annotationQueues) != null ? _a2 : this._annotationQueues = new AnnotationQueues(this._options); + } + get blobStorageIntegrations() { + var _a2; + return (_a2 = this._blobStorageIntegrations) != null ? _a2 : this._blobStorageIntegrations = new BlobStorageIntegrations( + this._options + ); + } + get comments() { + var _a2; + return (_a2 = this._comments) != null ? _a2 : this._comments = new Comments(this._options); + } + get datasetItems() { + var _a2; + return (_a2 = this._datasetItems) != null ? _a2 : this._datasetItems = new DatasetItems(this._options); + } + get datasetRunItems() { + var _a2; + return (_a2 = this._datasetRunItems) != null ? _a2 : this._datasetRunItems = new DatasetRunItems(this._options); + } + get datasets() { + var _a2; + return (_a2 = this._datasets) != null ? _a2 : this._datasets = new Datasets(this._options); + } + get evaluationRules() { + var _a2; + return (_a2 = this._evaluationRules) != null ? _a2 : this._evaluationRules = new EvaluationRules(this._options); + } + get evaluators() { + var _a2; + return (_a2 = this._evaluators) != null ? _a2 : this._evaluators = new Evaluators(this._options); + } + get experiments() { + var _a2; + return (_a2 = this._experiments) != null ? _a2 : this._experiments = new Experiments(this._options); + } + get feedback() { + var _a2; + return (_a2 = this._feedback) != null ? _a2 : this._feedback = new Feedback(this._options); + } + get health() { + var _a2; + return (_a2 = this._health) != null ? _a2 : this._health = new Health(this._options); + } + get ingestion() { + var _a2; + return (_a2 = this._ingestion) != null ? _a2 : this._ingestion = new Ingestion(this._options); + } + get legacy() { + var _a2; + return (_a2 = this._legacy) != null ? _a2 : this._legacy = new Legacy(this._options); + } + get llmConnections() { + var _a2; + return (_a2 = this._llmConnections) != null ? _a2 : this._llmConnections = new LlmConnections(this._options); + } + get media() { + var _a2; + return (_a2 = this._media) != null ? _a2 : this._media = new Media(this._options); + } + get metrics() { + var _a2; + return (_a2 = this._metrics) != null ? _a2 : this._metrics = new Metrics(this._options); + } + get models() { + var _a2; + return (_a2 = this._models) != null ? _a2 : this._models = new Models(this._options); + } + get observations() { + var _a2; + return (_a2 = this._observations) != null ? _a2 : this._observations = new Observations(this._options); + } + get opentelemetry() { + var _a2; + return (_a2 = this._opentelemetry) != null ? _a2 : this._opentelemetry = new Opentelemetry(this._options); + } + get organizations() { + var _a2; + return (_a2 = this._organizations) != null ? _a2 : this._organizations = new Organizations(this._options); + } + get projects() { + var _a2; + return (_a2 = this._projects) != null ? _a2 : this._projects = new Projects(this._options); + } + get promptVersion() { + var _a2; + return (_a2 = this._promptVersion) != null ? _a2 : this._promptVersion = new PromptVersion(this._options); + } + get prompts() { + var _a2; + return (_a2 = this._prompts) != null ? _a2 : this._prompts = new Prompts(this._options); + } + get scim() { + var _a2; + return (_a2 = this._scim) != null ? _a2 : this._scim = new Scim(this._options); + } + get scoreConfigs() { + var _a2; + return (_a2 = this._scoreConfigs) != null ? _a2 : this._scoreConfigs = new ScoreConfigs(this._options); + } + get scoresV3() { + var _a2; + return (_a2 = this._scoresV3) != null ? _a2 : this._scoresV3 = new ScoresV3(this._options); + } + get scores() { + var _a2; + return (_a2 = this._scores) != null ? _a2 : this._scores = new Scores(this._options); + } + get sessions() { + var _a2; + return (_a2 = this._sessions) != null ? _a2 : this._sessions = new Sessions(this._options); + } + get trace() { + var _a2; + return (_a2 = this._trace) != null ? _a2 : this._trace = new Trace(this._options); + } + get unstable() { + var _a2; + return (_a2 = this._unstable) != null ? _a2 : this._unstable = new Unstable(this._options); + } +}; +var LangfuseMedia = class { + /** + * Creates a new LangfuseMedia instance. + * + * @param params - Media parameters specifying the source and content + * + * @example + * ```typescript + * // Create from base64 data URI + * const media = new LangfuseMedia({ + * source: "base64_data_uri", + * base64DataUri: "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQ..." + * }); + * ``` + */ + constructor(params) { + const { source } = params; + this._source = source; + if (source === "base64_data_uri") { + const [contentBytesParsed, contentTypeParsed] = this.parseBase64DataUri( + params.base64DataUri + ); + this._contentBytes = contentBytesParsed; + this._contentType = contentTypeParsed; + } else { + this._contentBytes = params.contentBytes; + this._contentType = params.contentType; + } + } + /** + * Parses a base64 data URI to extract content bytes and type. + * + * @param data - The base64 data URI string + * @returns Tuple of [contentBytes, contentType] or [undefined, undefined] on error + * @private + */ + parseBase64DataUri(data) { + try { + if (!data || typeof data !== "string") { + throw new Error("Data URI is not a string"); + } + if (!data.startsWith("data:")) { + throw new Error("Data URI does not start with 'data:'"); + } + const [header, actualData] = data.slice(5).split(",", 2); + if (!header || !actualData) { + throw new Error("Invalid URI"); + } + const headerParts = header.split(";"); + if (!headerParts.includes("base64")) { + throw new Error("Data is not base64 encoded"); + } + const contentType = headerParts[0]; + if (!contentType) { + throw new Error("Content type is empty"); + } + return [base64ToBytes(actualData), contentType]; + } catch (error) { + getGlobalLogger().error("Error parsing base64 data URI", error); + return [void 0, void 0]; + } + } + /** + * Gets a unique identifier for this media based on its content hash. + * + * The ID is derived from the first 22 characters of the URL-safe base64-encoded + * SHA-256 hash of the content. + * + * @returns The unique media ID, or null if hash generation failed + * + * @example + * ```typescript + * const media = new LangfuseMedia({...}); + * console.log(media.id); // "A1B2C3D4E5F6G7H8I9J0K1" + * ``` + */ + async getId() { + const contentSha256Hash = await this.getSha256Hash(); + if (!contentSha256Hash) return null; + const urlSafeContentHash = contentSha256Hash.replaceAll("+", "-").replaceAll("/", "_"); + return urlSafeContentHash.slice(0, 22); + } + /** + * Gets the length of the media content in bytes. + * + * @returns The content length in bytes, or undefined if no content is available + */ + get contentLength() { + var _a2; + return (_a2 = this._contentBytes) == null ? void 0 : _a2.length; + } + /** + * Gets the SHA-256 hash of the media content. + * + * The hash is used for content integrity verification and generating unique media IDs. + * Returns undefined if crypto is not available or hash generation fails. + * + * @returns The base64-encoded SHA-256 hash, or undefined if unavailable + */ + async getSha256Hash() { + if (!this._contentBytes) { + return void 0; + } + try { + const hash = await crypto.subtle.digest("SHA-256", this._contentBytes); + return bytesToBase64(new Uint8Array(hash)); + } catch (error) { + getGlobalLogger().warn( + "[Langfuse] Failed to generate SHA-256 hash for media content:", + error + ); + return void 0; + } + } + /** + * Gets the media reference tag for embedding in trace data. + * + * The tag format is: `@@@langfuseMedia:type=|id=|source=@@@` + * This tag can be embedded in trace attributes and will be replaced with actual + * media content when the trace is viewed in Langfuse. + * + * @returns The media reference tag, or null if required data is missing + * + * @example + * ```typescript + * const media = new LangfuseMedia({...}); + * console.log(media.tag); + * // "@@@langfuseMedia:type=image/png|id=A1B2C3D4E5F6G7H8I9J0K1|source=base64_data_uri@@@" + * ``` + */ + async getTag() { + const id = await this.getId(); + if (!this._contentType || !this._source || !id) return null; + return `@@@langfuseMedia:type=${this._contentType}|id=${id}|source=${this._source}@@@`; + } + /** + * Gets the media content as a base64 data URI. + * + * @returns The complete data URI string, or null if no content is available + * + * @example + * ```typescript + * const media = new LangfuseMedia({...}); + * console.log(media.base64DataUri); + * // "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB..." + * ``` + */ + get base64DataUri() { + if (!this._contentBytes) return null; + return `data:${this._contentType};base64,${bytesToBase64(this._contentBytes)}`; + } + /** + * Serializes the media to JSON (returns the base64 data URI). + * + * @returns The base64 data URI, or null if no content is available + */ + toJSON() { + return this.base64DataUri; + } +}; +async function uploadMedia(params) { + var _a2; + const { + apiClient, + media, + traceId, + observationId, + datasetId, + datasetItemId, + field, + maxRetries = 3, + baseDelay = 1e3 + } = params; + const logger = (_a2 = params.logger) != null ? _a2 : getGlobalLogger(); + const contentSha256Hash = await media.getSha256Hash(); + if (!media.contentLength || !media._contentType || !contentSha256Hash || !media._contentBytes) { + throw new Error("Cannot upload media: media content is incomplete."); + } + const { uploadUrl, mediaId } = await apiClient.media.getUploadUrl({ + contentLength: media.contentLength, + traceId, + observationId, + datasetId, + datasetItemId, + field, + contentType: media._contentType, + sha256Hash: contentSha256Hash + }); + if (!uploadUrl) { + logger.debug( + `Media status: Media with ID ${mediaId} already uploaded. Skipping duplicate upload.` + ); + return; + } + const clientSideMediaId = await media.getId(); + if (clientSideMediaId !== mediaId) { + throw new Error( + `Media integrity error: Media ID mismatch between SDK (${clientSideMediaId}) and Server (${mediaId}). Upload cancelled.` + ); + } + logger.debug(`Uploading media ${mediaId}...`); + const startTime = Date.now(); + const uploadResponse = await uploadWithBackoff({ + uploadUrl, + contentBytes: media._contentBytes, + contentType: media._contentType, + contentSha256Hash, + maxRetries, + baseDelay + }); + if (!uploadResponse) { + throw new Error("Media upload process failed"); + } + const uploadSucceeded = uploadResponse.status === 200 || uploadResponse.status === 201; + await apiClient.media.patch(mediaId, { + uploadedAt: (/* @__PURE__ */ new Date()).toISOString(), + uploadHttpStatus: uploadResponse.status, + uploadHttpError: await uploadResponse.text(), + uploadTimeMs: Date.now() - startTime + }); + logger.debug(`Media upload status reported for ${mediaId}`); + if (!uploadSucceeded) { + throw new Error( + `Media upload failed with HTTP ${uploadResponse.status} after ${maxRetries} retries.` + ); + } +} +async function uploadWithBackoff(params) { + const { + uploadUrl, + contentType, + contentSha256Hash, + contentBytes, + maxRetries, + baseDelay + } = params; + for (let attempt = 0; attempt <= maxRetries; attempt++) { + try { + let parsedHostname; + try { + parsedHostname = new URL(uploadUrl).hostname; + } catch { + parsedHostname = ""; + } + const isSelfHostedGcsBucket = parsedHostname === "storage.googleapis.com" || parsedHostname.endsWith(".storage.googleapis.com"); + const headers = isSelfHostedGcsBucket ? { "Content-Type": contentType } : { + "Content-Type": contentType, + "x-amz-checksum-sha256": contentSha256Hash, + "x-ms-blob-type": "BlockBlob" + }; + const uploadResponse = await fetch(uploadUrl, { + method: "PUT", + // Recent fetch typings narrow BodyInit to an ArrayBuffer-backed view, + // while Uint8Array now defaults to Uint8Array. The + // media bytes are always ArrayBuffer-backed, so assert the narrower type. + body: contentBytes, + headers + }); + if (attempt < maxRetries && uploadResponse.status !== 200 && uploadResponse.status !== 201) { + throw new Error(`Upload failed with status ${uploadResponse.status}`); + } + return uploadResponse; + } catch (e) { + if (attempt === maxRetries) { + throw e; + } + const delay = baseDelay * Math.pow(2, attempt); + const jitter = Math.random() * 1e3; + await new Promise((resolve2) => setTimeout(resolve2, delay + jitter)); + } + } + return void 0; +} +var experimentKeys = [ + "experimentId", + "experimentName", + "experimentMetadata", + "experimentDatasetId", + "experimentItemId", + "experimentItemMetadata", + "experimentItemRootObservationId" +]; +var LangfuseOtelContextKeys = { + userId: createContextKey("langfuse_user_id"), + sessionId: createContextKey("langfuse_session_id"), + metadata: createContextKey("langfuse_metadata"), + version: createContextKey("langfuse_version"), + tags: createContextKey("langfuse_tags"), + traceName: createContextKey("langfuse_trace_name"), + environment: createContextKey("langfuse_environment"), + promptName: createContextKey("langfuse_prompt_name"), + promptVersion: createContextKey("langfuse_prompt_version"), + // Experiments + experimentId: createContextKey("langfuse_experiment_id"), + experimentName: createContextKey("langfuse_experiment_name"), + experimentMetadata: createContextKey("langfuse_experiment_metadata"), + experimentDatasetId: createContextKey("langfuse_experiment_dataset_id"), + experimentItemId: createContextKey("langfuse_experiment_item_id"), + experimentItemMetadata: createContextKey("langfuse_experiment_item_metadata"), + experimentItemRootObservationId: createContextKey( + "langfuse_experiment_item_root_observation_id" + ) +}; +var LANGFUSE_BAGGAGE_PREFIX = "langfuse_"; +var LANGFUSE_BAGGAGE_TAGS_SEPARATOR = ","; +var LANGFUSE_TRACE_ID_BAGGAGE_KEY = "langfuse_trace_id"; +function getLangfuseTraceIdFromBaggage(context2) { + const baggage = propagation.getBaggage(context2); + const entry = baggage == null ? void 0 : baggage.getEntry(LANGFUSE_TRACE_ID_BAGGAGE_KEY); + if (!(entry == null ? void 0 : entry.value)) return void 0; + return entry.value.toLowerCase(); +} +function getPropagatedAttributesFromContext(context2) { + const propagatedAttributes = {}; + const baggage = propagation.getBaggage(context2); + if (baggage) { + baggage.getAllEntries().forEach(([baggageKey, baggageEntry]) => { + if (baggageKey === LANGFUSE_TRACE_ID_BAGGAGE_KEY) return; + if (baggageKey.startsWith(LANGFUSE_BAGGAGE_PREFIX)) { + const spanKey = getSpanKeyFromBaggageKey(baggageKey); + if (spanKey) { + if (spanKey === "langfuse.environment") { + if (isValidEnvironment(baggageEntry.value)) { + propagatedAttributes[spanKey] = baggageEntry.value; + } + return; + } + if (spanKey === "langfuse.observation.prompt.version" && /^\d+$/.test(baggageEntry.value)) { + propagatedAttributes[spanKey] = Number(baggageEntry.value); + return; + } + const isMergedTags = baggageKey == getBaggageKeyForPropagatedKey("tags"); + propagatedAttributes[spanKey] = isMergedTags ? baggageEntry.value.split(LANGFUSE_BAGGAGE_TAGS_SEPARATOR) : baggageEntry.value; + } + } + }); + } + const userId = context2.getValue(LangfuseOtelContextKeys["userId"]); + if (userId && typeof userId === "string") { + const spanKey = getSpanKeyForPropagatedKey("userId"); + propagatedAttributes[spanKey] = userId; + } + const sessionId2 = context2.getValue(LangfuseOtelContextKeys["sessionId"]); + if (sessionId2 && typeof sessionId2 === "string") { + const spanKey = getSpanKeyForPropagatedKey("sessionId"); + propagatedAttributes[spanKey] = sessionId2; + } + const version = context2.getValue(LangfuseOtelContextKeys["version"]); + if (version && typeof version === "string") { + const spanKey = getSpanKeyForPropagatedKey("version"); + propagatedAttributes[spanKey] = version; + } + const traceName = context2.getValue(LangfuseOtelContextKeys["traceName"]); + if (traceName && typeof traceName === "string") { + const spanKey = getSpanKeyForPropagatedKey("traceName"); + propagatedAttributes[spanKey] = traceName; + } + const environment = context2.getValue(LangfuseOtelContextKeys["environment"]); + if (isValidEnvironment(environment)) { + propagatedAttributes[ + "langfuse.environment" + /* ENVIRONMENT */ + ] = environment; + } + const tags = context2.getValue(LangfuseOtelContextKeys["tags"]); + if (tags && Array.isArray(tags)) { + const spanKey = getSpanKeyForPropagatedKey("tags"); + propagatedAttributes[spanKey] = tags; + } + const promptName = context2.getValue(LangfuseOtelContextKeys["promptName"]); + if (promptName && typeof promptName === "string") { + const spanKey = getSpanKeyForPropagatedKey("promptName"); + propagatedAttributes[spanKey] = promptName; + } + const promptVersion = context2.getValue( + LangfuseOtelContextKeys["promptVersion"] + ); + if (typeof promptVersion === "number") { + const spanKey = getSpanKeyForPropagatedKey("promptVersion"); + propagatedAttributes[spanKey] = promptVersion; + } + const metadata = context2.getValue(LangfuseOtelContextKeys["metadata"]); + if (metadata && typeof metadata === "object" && metadata !== null) { + for (const [k, v] of Object.entries(metadata)) { + const spanKey = `${"langfuse.trace.metadata"}.${k}`; + propagatedAttributes[spanKey] = String(v); + } + } + for (const key of experimentKeys) { + const contextKey = LangfuseOtelContextKeys[key]; + const value = context2.getValue(contextKey); + if (value && typeof value === "string") { + const spanKey = getSpanKeyForPropagatedKey(key); + propagatedAttributes[spanKey] = value; + } + } + if (propagatedAttributes[getSpanKeyForPropagatedKey("experimentItemRootObservationId")]) { + propagatedAttributes[ + "langfuse.environment" + /* ENVIRONMENT */ + ] = LANGFUSE_SDK_EXPERIMENT_ENVIRONMENT; + } + return propagatedAttributes; +} +var ENVIRONMENT_VALUE_PATTERN = /^(?!langfuse)[a-z0-9_-]+$/; +function isValidEnvironment(value) { + const logger = getGlobalLogger(); + if (typeof value !== "string") { + if (value !== void 0) { + logger.warn( + "Propagated attribute 'environment' must be a string. Dropping value." + ); + } + return false; + } + if (value.length > 40) { + logger.warn( + `Propagated attribute 'environment' value is over 40 characters (${value.length} chars). Dropping value.` + ); + return false; + } + if (!ENVIRONMENT_VALUE_PATTERN.test(value)) { + logger.warn( + "Propagated attribute 'environment' must be a lowercase alphanumeric string with optional hyphens or underscores and must not start with 'langfuse'. Dropping value." + ); + return false; + } + return true; +} +function getSpanKeyForPropagatedKey(key) { + switch (key) { + case "userId": + return "user.id"; + case "sessionId": + return "session.id"; + case "version": + return "langfuse.version"; + case "traceName": + return "langfuse.trace.name"; + case "environment": + return "langfuse.environment"; + case "metadata": + return "langfuse.trace.metadata"; + case "tags": + return "langfuse.trace.tags"; + case "promptName": + return "langfuse.observation.prompt.name"; + case "promptVersion": + return "langfuse.observation.prompt.version"; + case "experimentId": + return "langfuse.experiment.id"; + case "experimentName": + return "langfuse.experiment.name"; + case "experimentMetadata": + return "langfuse.experiment.metadata"; + case "experimentDatasetId": + return "langfuse.experiment.dataset.id"; + case "experimentItemId": + return "langfuse.experiment.item.id"; + case "experimentItemMetadata": + return "langfuse.experiment.item.metadata"; + case "experimentItemRootObservationId": + return "langfuse.experiment.item.root_observation_id"; + default: { + const fallback = key; + throw Error("Unhandled propagated key", fallback); + } + } +} +function getBaggageKeyForPropagatedKey(key) { + switch (key) { + case "userId": + return `${LANGFUSE_BAGGAGE_PREFIX}user_id`; + case "sessionId": + return `${LANGFUSE_BAGGAGE_PREFIX}session_id`; + case "version": + return `${LANGFUSE_BAGGAGE_PREFIX}version`; + case "traceName": + return `${LANGFUSE_BAGGAGE_PREFIX}trace_name`; + case "environment": + return `${LANGFUSE_BAGGAGE_PREFIX}environment`; + case "metadata": + return `${LANGFUSE_BAGGAGE_PREFIX}metadata`; + case "tags": + return `${LANGFUSE_BAGGAGE_PREFIX}tags`; + case "promptName": + return `${LANGFUSE_BAGGAGE_PREFIX}prompt_name`; + case "promptVersion": + return `${LANGFUSE_BAGGAGE_PREFIX}prompt_version`; + case "experimentId": + return `${LANGFUSE_BAGGAGE_PREFIX}experiment_id`; + case "experimentName": + return `${LANGFUSE_BAGGAGE_PREFIX}experiment_name`; + case "experimentMetadata": + return `${LANGFUSE_BAGGAGE_PREFIX}experiment_metadata`; + case "experimentDatasetId": + return `${LANGFUSE_BAGGAGE_PREFIX}experiment_dataset_id`; + case "experimentItemId": + return `${LANGFUSE_BAGGAGE_PREFIX}experiment_item_id`; + case "experimentItemMetadata": + return `${LANGFUSE_BAGGAGE_PREFIX}experiment_item_metadata`; + case "experimentItemRootObservationId": + return `${LANGFUSE_BAGGAGE_PREFIX}experiment_item_root_observation_id`; + default: { + const fallback = key; + throw Error("Unhandled propagated key", fallback); + } + } +} +function getSpanKeyFromBaggageKey(baggageKey) { + if (!baggageKey.startsWith(LANGFUSE_BAGGAGE_PREFIX)) return; + const suffix = baggageKey.slice(LANGFUSE_BAGGAGE_PREFIX.length); + if (suffix.startsWith("metadata_")) { + const metadataKey = suffix.slice("metadata_".length); + return `${"langfuse.trace.metadata"}.${metadataKey}`; + } + switch (suffix) { + case "user_id": + return getSpanKeyForPropagatedKey("userId"); + case "session_id": + return getSpanKeyForPropagatedKey("sessionId"); + case "version": + return getSpanKeyForPropagatedKey("version"); + case "trace_name": + return getSpanKeyForPropagatedKey("traceName"); + case "environment": + return getSpanKeyForPropagatedKey("environment"); + case "tags": + return getSpanKeyForPropagatedKey("tags"); + case "prompt_name": + return getSpanKeyForPropagatedKey("promptName"); + case "prompt_version": + return getSpanKeyForPropagatedKey("promptVersion"); + case "experiment_id": + return getSpanKeyForPropagatedKey("experimentId"); + case "experiment_name": + return getSpanKeyForPropagatedKey("experimentName"); + case "experiment_metadata": + return getSpanKeyForPropagatedKey("experimentMetadata"); + case "experiment_dataset_id": + return getSpanKeyForPropagatedKey("experimentDatasetId"); + case "experiment_item_id": + return getSpanKeyForPropagatedKey("experimentItemId"); + case "experiment_item_metadata": + return getSpanKeyForPropagatedKey("experimentItemMetadata"); + case "experiment_item_root_observation_id": + return getSpanKeyForPropagatedKey("experimentItemRootObservationId"); + } +} + +// node_modules/@langfuse/otel/dist/index.mjs +var import_core6 = __toESM(require_src(), 1); +var import_exporter_trace_otlp_http = __toESM(require_src6(), 1); +var import_sdk_trace_base = __toESM(require_index_shim(), 1); +var MediaService = class { + constructor(params) { + this.pendingMediaUploads = /* @__PURE__ */ new Set(); + this.apiClient = params.apiClient; + } + get logger() { + return getGlobalLogger(); + } + async flush() { + await Promise.all(Array.from(this.pendingMediaUploads)); + } + async process(span) { + var _a2; + const mediaAttributes = [ + LangfuseOtelSpanAttributes.OBSERVATION_INPUT, + LangfuseOtelSpanAttributes.TRACE_INPUT, + LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT, + LangfuseOtelSpanAttributes.TRACE_OUTPUT, + LangfuseOtelSpanAttributes.OBSERVATION_METADATA, + LangfuseOtelSpanAttributes.TRACE_METADATA + ]; + for (const mediaAttribute of mediaAttributes) { + const mediaRelevantAttributeKeys = Object.keys(span.attributes).filter( + (attributeName) => attributeName.startsWith(mediaAttribute) + ); + for (const key of mediaRelevantAttributeKeys) { + const value = span.attributes[key]; + if (typeof value !== "string") { + this.logger.warn( + `Span attribute ${mediaAttribute} is not a stringified object. Skipping media handling.` + ); + continue; + } + let mediaReplacedValue = value; + const regex = /data:[^;]+;base64,[A-Za-z0-9+/]+=*/g; + const foundMedia = [...new Set((_a2 = value.match(regex)) != null ? _a2 : [])]; + if (foundMedia.length === 0) continue; + for (const mediaDataUri of foundMedia) { + const media = new LangfuseMedia({ + base64DataUri: mediaDataUri, + source: "base64_data_uri" + }); + const langfuseMediaTag = await media.getTag(); + if (!langfuseMediaTag) { + this.logger.warn( + "Failed to create Langfuse media tag. Skipping media item." + ); + continue; + } + this.scheduleUpload({ + span, + media, + field: mediaAttribute.includes("input") ? "input" : mediaAttribute.includes("output") ? "output" : "metadata" + // todo: make more robust + }); + mediaReplacedValue = mediaReplacedValue.replaceAll( + mediaDataUri, + langfuseMediaTag + ); + } + span.attributes[key] = mediaReplacedValue; + } + } + if (["ai", "gen_ai"].includes(span.instrumentationScope.name)) { + const aiSDKMediaAttributes = ["ai.prompt.messages", "ai.prompt"]; + for (const mediaAttribute of aiSDKMediaAttributes) { + const value = span.attributes[mediaAttribute]; + if (!value || typeof value !== "string") { + continue; + } + let mediaReplacedValue = value; + try { + const parsed = JSON.parse(value); + if (Array.isArray(parsed)) { + for (const message of parsed) { + if (Array.isArray(message["content"])) { + const contentParts = message["content"]; + for (const part of contentParts) { + if (part["type"] === "file") { + let base64Content = null; + const mediaType = part["mediaType"]; + if (typeof part["data"] === "string" && !part["data"].startsWith("http")) { + base64Content = part["data"]; + } + if (typeof part["image"] === "string" && !part["image"].startsWith("http")) { + base64Content = part["image"]; + } + if (!base64Content || typeof mediaType !== "string") { + continue; + } + mediaReplacedValue = await this.replaceBytesMedia({ + span, + mediaReplacedValue, + base64Content, + contentType: mediaType, + field: "input" + }); + } + } + } + } + } + span.attributes[mediaAttribute] = mediaReplacedValue; + } catch (err) { + this.logger.warn( + `Failed to handle media for AI SDK attribute ${mediaAttribute} for span ${span.spanContext().spanId}`, + err + ); + } + } + const aiSDKV7MediaAttributes = [ + { attribute: "gen_ai.input.messages", field: "input" }, + { attribute: "gen_ai.output.messages", field: "output" } + ]; + for (const { attribute, field } of aiSDKV7MediaAttributes) { + const value = span.attributes[attribute]; + if (!value || typeof value !== "string") { + continue; + } + let mediaReplacedValue = value; + try { + const parsed = JSON.parse(value); + if (Array.isArray(parsed)) { + for (const message of parsed) { + if (!Array.isArray(message["parts"])) { + continue; + } + for (const part of message["parts"]) { + const content = part["content"]; + const mediaType = part["mime_type"]; + if (part["type"] !== "blob" || typeof content !== "string" || !content || typeof mediaType !== "string" || content.startsWith("http")) { + continue; + } + const normalizedContent = normalizeBase64Content(content); + if (!normalizedContent) { + continue; + } + mediaReplacedValue = await this.replaceBytesMedia({ + span, + mediaReplacedValue, + base64Content: normalizedContent.base64Content, + contentToReplace: content, + contentType: mediaType, + field + }); + } + } + } + span.attributes[attribute] = mediaReplacedValue; + } catch (err) { + this.logger.warn( + `Failed to handle media for AI SDK v7 attribute ${attribute} for span ${span.spanContext().spanId}`, + err + ); + } + } + } + } + async replaceBytesMedia(params) { + var _a2; + const media = new LangfuseMedia({ + contentType: params.contentType, + contentBytes: base64ToBytes(params.base64Content), + source: "bytes" + }); + const langfuseMediaTag = await media.getTag(); + if (!langfuseMediaTag) { + this.logger.warn( + "Failed to create Langfuse media tag. Skipping media item." + ); + return params.mediaReplacedValue; + } + this.scheduleUpload({ + span: params.span, + media, + field: params.field + }); + return params.mediaReplacedValue.replaceAll( + (_a2 = params.contentToReplace) != null ? _a2 : params.base64Content, + langfuseMediaTag + ); + } + scheduleUpload(params) { + const { span, field, media } = params; + const uploadPromise = this.handleUpload({ + media, + traceId: span.spanContext().traceId, + observationId: span.spanContext().spanId, + field + }).catch((err) => { + this.logger.error("Media upload failed with error: ", err); + }); + this.pendingMediaUploads.add(uploadPromise); + uploadPromise.finally(() => { + this.pendingMediaUploads.delete(uploadPromise); + }); + } + async handleUpload({ + media, + traceId, + observationId, + field + }) { + try { + await uploadMedia({ + apiClient: this.apiClient, + media, + traceId, + observationId, + field, + logger: this.logger + }); + } catch (err) { + this.logger.error(`Error processing media item: ${err}`); + } + } +}; +function normalizeBase64Content(content) { + if (!content.startsWith("data:")) { + return { base64Content: content }; + } + const base64Start = content.indexOf(";base64,"); + if (base64Start === -1) { + return; + } + const base64Content = content.slice(base64Start + ";base64,".length); + if (!base64Content) { + return; + } + return { base64Content }; +} +var KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES = [ + LANGFUSE_TRACER_NAME, + "agent_framework", + "ai", + "haystack", + "langsmith", + "litellm", + "openinference", + "opentelemetry.instrumentation.anthropic", + "opentelemetry.instrumentation.aws_bedrock", + "opentelemetry.instrumentation.bedrock", + "opentelemetry.instrumentation.gemini", + "opentelemetry.instrumentation.google_genai", + "opentelemetry.instrumentation.google_generativeai", + "opentelemetry.instrumentation.openai", + "opentelemetry.instrumentation.openai_v2", + "opentelemetry.instrumentation.vertex_ai", + "opentelemetry.instrumentation.vertexai", + "strands-agents", + "vllm" +]; +var EXACT_LLM_INSTRUMENTATION_SCOPES = /* @__PURE__ */ new Set(["ai"]); +function isLangfuseSpan(span) { + return span.instrumentationScope.name === LANGFUSE_TRACER_NAME; +} +function isGenAISpan(span) { + return Object.keys(span.attributes).some( + (attributeKey) => attributeKey.startsWith("gen_ai.") + ); +} +function isKnownLLMInstrumentor(span) { + const scope = span.instrumentationScope.name; + return KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES.some( + (prefix) => scope === prefix || !EXACT_LLM_INSTRUMENTATION_SCOPES.has(prefix) && scope.startsWith(`${prefix}.`) + ); +} +function isDefaultExportSpan(span) { + return isLangfuseSpan(span) || isGenAISpan(span) || isKnownLLMInstrumentor(span); +} +var LangfuseSpanProcessor = class { + /** + * Creates a new LangfuseSpanProcessor instance. + * + * @param params - Configuration parameters for the processor + * + * @example + * ```typescript + * const processor = new LangfuseSpanProcessor({ + * publicKey: 'pk_...', + * secretKey: 'sk_...', + * environment: 'staging', + * flushAt: 10, + * flushInterval: 2, + * mask: ({ data }) => { + * // Custom masking logic + * return typeof data === 'string' + * ? data.replace(/secret_\w+/g, 'secret_***') + * : data; + * }, + * shouldExportSpan: ({ otelSpan }) => { + * // Full override of default filtering: + * // export only spans from specific services + * return otelSpan.name.startsWith("my-service"); + * } + * }); + * ``` + */ + constructor(params) { + this.pendingEndedSpans = /* @__PURE__ */ new Set(); + this.spanExportExpectationById = /* @__PURE__ */ new Map(); + var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n; + const logger = getGlobalLogger(); + const publicKey = (_a2 = params == null ? void 0 : params.publicKey) != null ? _a2 : getEnv("LANGFUSE_PUBLIC_KEY"); + const secretKey = (_b = params == null ? void 0 : params.secretKey) != null ? _b : getEnv("LANGFUSE_SECRET_KEY"); + const baseUrl = (_e = (_d = (_c = params == null ? void 0 : params.baseUrl) != null ? _c : getEnv("LANGFUSE_BASE_URL")) != null ? _d : getEnv("LANGFUSE_BASEURL")) != null ? _e : ( + // legacy v2 + "https://cloud.langfuse.com" + ); + if (!(params == null ? void 0 : params.exporter) && !publicKey) { + logger.warn( + "No exporter configured and no public key provided in constructor or as LANGFUSE_PUBLIC_KEY env var. Span exports will fail." + ); + } + if (!(params == null ? void 0 : params.exporter) && !secretKey) { + logger.warn( + "No exporter configured and no secret key provided in constructor or as LANGFUSE_SECRET_KEY env var. Span exports will fail." + ); + } + const flushAt = (_f = params == null ? void 0 : params.flushAt) != null ? _f : getEnv("LANGFUSE_FLUSH_AT"); + const flushIntervalSeconds = (_g = params == null ? void 0 : params.flushInterval) != null ? _g : getEnv("LANGFUSE_FLUSH_INTERVAL"); + const authHeaderValue = base64Encode(`${publicKey}:${secretKey}`); + const timeoutSeconds = (_i = params == null ? void 0 : params.timeout) != null ? _i : Number((_h = getEnv("LANGFUSE_TIMEOUT")) != null ? _h : 5); + const envMediaUploadEnabled = getEnv("LANGFUSE_MEDIA_UPLOAD_ENABLED"); + const mediaUploadEnabled = (_j = params == null ? void 0 : params.mediaUploadEnabled) != null ? _j : envMediaUploadEnabled ? !["false", "0"].includes(envMediaUploadEnabled.toLowerCase()) : true; + const exporter = (_k = params == null ? void 0 : params.exporter) != null ? _k : new import_exporter_trace_otlp_http.OTLPTraceExporter({ + url: `${baseUrl}/api/public/otel/v1/traces`, + headers: { + Authorization: `Basic ${authHeaderValue}`, + "x-langfuse-sdk-name": "javascript", + "x-langfuse-sdk-version": LANGFUSE_SDK_VERSION, + "x-langfuse-public-key": publicKey != null ? publicKey : "", + ...params == null ? void 0 : params.additionalHeaders + }, + timeoutMillis: timeoutSeconds * 1e3 + }); + this.processor = (params == null ? void 0 : params.exportMode) === "immediate" ? new import_sdk_trace_base.SimpleSpanProcessor(exporter) : new import_sdk_trace_base.BatchSpanProcessor(exporter, { + maxExportBatchSize: flushAt ? Number(flushAt) : void 0, + scheduledDelayMillis: flushIntervalSeconds ? Number(flushIntervalSeconds) * 1e3 : void 0 + }); + this.publicKey = publicKey; + this.baseUrl = baseUrl; + this.environment = (_l = params == null ? void 0 : params.environment) != null ? _l : getEnv("LANGFUSE_TRACING_ENVIRONMENT"); + this.release = (_m = params == null ? void 0 : params.release) != null ? _m : getEnv("LANGFUSE_RELEASE"); + this.mask = params == null ? void 0 : params.mask; + this.shouldExportSpan = (_n = params == null ? void 0 : params.shouldExportSpan) != null ? _n : ({ otelSpan }) => isDefaultExportSpan(otelSpan); + this.mediaUploadEnabled = mediaUploadEnabled; + this.apiClient = new LangfuseAPIClient({ + baseUrl: this.baseUrl, + username: this.publicKey, + password: secretKey, + xLangfusePublicKey: this.publicKey, + xLangfuseSdkVersion: LANGFUSE_SDK_VERSION, + xLangfuseSdkName: "javascript", + environment: "", + // noop as baseUrl is set + headers: params == null ? void 0 : params.additionalHeaders + }); + this.mediaService = new MediaService({ apiClient: this.apiClient }); + logger.debug("Initialized LangfuseSpanProcessor with params:", { + publicKey, + baseUrl, + environment: this.environment, + release: this.release, + timeoutSeconds, + flushAt, + flushIntervalSeconds, + mediaUploadEnabled + }); + } + get logger() { + return getGlobalLogger(); + } + /** + * Called when a span is started. Adds environment, release, and propagated attributes to the span. + * + * @param span - The span that was started + * @param parentContext - The parent context + * + * @override + */ + onStart(span, parentContext) { + const propagatedAttributes = getPropagatedAttributesFromContext(parentContext); + if (span.attributes[LangfuseOtelSpanAttributes.OBSERVATION_PROMPT_NAME] != null) { + delete propagatedAttributes[LangfuseOtelSpanAttributes.OBSERVATION_PROMPT_NAME]; + delete propagatedAttributes[LangfuseOtelSpanAttributes.OBSERVATION_PROMPT_VERSION]; + } + span.setAttributes({ + [LangfuseOtelSpanAttributes.ENVIRONMENT]: this.environment, + [LangfuseOtelSpanAttributes.RELEASE]: this.release, + ...propagatedAttributes + }); + try { + this.markAppRootCandidate(span, parentContext); + } catch (err) { + this.logger.debug( + "App-root start-time check failed. Span will not be marked as app root.", + { spanName: span.name }, + err + ); + } + return this.processor.onStart(span, parentContext); + } + /** + * Called when a span ends. Processes the span for export to Langfuse. + * + * This method: + * 1. Checks if the span should be exported using shouldExportSpan + * (custom override or default smart filter) + * 2. Applies data masking to sensitive attributes + * 3. Handles media content extraction and upload + * 4. Logs span details in debug mode + * 5. Passes the span to the parent processor for export + * + * @param span - The span that ended + * + * @override + */ + onEnd(span) { + this.spanExportExpectationById.delete(span.spanContext().spanId); + const processEndedSpanPromise = this.processEndedSpan(span).catch((err) => { + this.logger.error(err); + }); + this.pendingEndedSpans.add(processEndedSpanPromise); + void processEndedSpanPromise.finally( + () => this.pendingEndedSpans.delete(processEndedSpanPromise) + ); + } + async flush() { + await Promise.all(Array.from(this.pendingEndedSpans)); + await this.mediaService.flush(); + } + /** + * Forces an immediate flush of all pending spans and media uploads. + * + * @returns Promise that resolves when all pending operations are complete + * + * @override + */ + async forceFlush() { + await this.flush(); + return this.processor.forceFlush(); + } + /** + * Gracefully shuts down the processor, ensuring all pending operations are completed. + * + * @returns Promise that resolves when shutdown is complete + * + * @override + */ + async shutdown() { + await this.flush(); + return this.processor.shutdown(); + } + async processEndedSpan(span) { + var _a2, _b; + try { + if (this.shouldExportSpan({ otelSpan: span }) === false) { + this.logger.debug("Dropped span due to shouldExportSpan filter.", { + spanName: span.name, + instrumentationScope: span.instrumentationScope.name + }); + return; + } + } catch (err) { + this.logger.error( + "shouldExportSpan failed with error. Dropping span.", + { + spanName: span.name, + instrumentationScope: span.instrumentationScope.name + }, + err + ); + return; + } + await this.applyMaskInPlace(span); + if (this.mediaUploadEnabled) { + await this.mediaService.process(span); + } + if (this.logger.isLevelEnabled(LogLevel.DEBUG)) { + this.logger.debug( + `Processed span: +${JSON.stringify( + { + name: span.name, + traceId: span.spanContext().traceId, + spanId: span.spanContext().spanId, + parentSpanId: (_b = (_a2 = span.parentSpanContext) == null ? void 0 : _a2.spanId) != null ? _b : null, + attributes: span.attributes, + startTime: new Date((0, import_core6.hrTimeToMilliseconds)(span.startTime)), + endTime: new Date((0, import_core6.hrTimeToMilliseconds)(span.endTime)), + durationMs: (0, import_core6.hrTimeToMilliseconds)(span.duration), + kind: span.kind, + status: span.status, + resource: span.resource.attributes, + instrumentationScope: span.instrumentationScope + }, + null, + 2 + )}` + ); + } + this.processor.onEnd(span); + } + markAppRootCandidate(span, parentContext) { + var _a2; + const traceId = span.spanContext().traceId; + const spanId = span.spanContext().spanId; + const parentSpanId = (_a2 = span.parentSpanContext) == null ? void 0 : _a2.spanId; + const expectedExportedAtStart = this.isExpectedExportedAtStart(span); + const propagatedClaim = getLangfuseTraceIdFromBaggage(parentContext); + const isParentExpectedExported = parentSpanId !== void 0 ? this.spanExportExpectationById.get(parentSpanId) === true : false; + const suppressedByParentClaim = propagatedClaim === traceId; + this.spanExportExpectationById.set(spanId, expectedExportedAtStart); + const markAppRoot = expectedExportedAtStart && !isParentExpectedExported && !suppressedByParentClaim; + if (markAppRoot) { + span.setAttribute(LangfuseOtelSpanAttributes.IS_APP_ROOT, true); + } + } + isExpectedExportedAtStart(span) { + const readable = span; + try { + return this.shouldExportSpan({ otelSpan: readable }) === true; + } catch (err) { + this.logger.debug( + "shouldExportSpan threw during app-root start-time check. Span will not be marked as app root.", + { + spanName: span.name, + instrumentationScope: readable.instrumentationScope.name + }, + err + ); + return false; + } + } + async applyMaskInPlace(span) { + const maskCandidates = [ + LangfuseOtelSpanAttributes.OBSERVATION_INPUT, + LangfuseOtelSpanAttributes.TRACE_INPUT, + LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT, + LangfuseOtelSpanAttributes.TRACE_OUTPUT, + LangfuseOtelSpanAttributes.OBSERVATION_METADATA, + LangfuseOtelSpanAttributes.TRACE_METADATA + ]; + for (const maskCandidate of maskCandidates) { + if (maskCandidate in span.attributes) { + span.attributes[maskCandidate] = await this.applyMask( + span.attributes[maskCandidate] + ); + } + } + } + async applyMask(data) { + if (!this.mask) return data; + try { + return await this.mask({ data }); + } catch (err) { + this.logger.warn( + `Applying mask function failed due to error, fully masking property. Error: ${err}` + ); + return ""; + } + } +}; + +// node_modules/@langfuse/tracing/dist/index.mjs +init_esm(); +init_esm(); +function createTraceAttributes({ + input, + output +} = {}) { + const attributes = { + [LangfuseOtelSpanAttributes.TRACE_INPUT]: _serialize(input), + [LangfuseOtelSpanAttributes.TRACE_OUTPUT]: _serialize(output) + }; + return Object.fromEntries( + Object.entries(attributes).filter(([_, v]) => v != null) + ); +} +function createObservationAttributes(type, attributes) { + const { + metadata, + input, + output, + level, + statusMessage, + version, + environment, + completionStartTime, + model, + modelParameters, + usageDetails, + costDetails, + prompt: prompt2 + } = attributes; + let otelAttributes = { + [LangfuseOtelSpanAttributes.OBSERVATION_TYPE]: type, + [LangfuseOtelSpanAttributes.OBSERVATION_LEVEL]: level, + [LangfuseOtelSpanAttributes.OBSERVATION_STATUS_MESSAGE]: statusMessage, + [LangfuseOtelSpanAttributes.VERSION]: version, + [LangfuseOtelSpanAttributes.ENVIRONMENT]: environment, + [LangfuseOtelSpanAttributes.OBSERVATION_INPUT]: _serialize(input), + [LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT]: _serialize(output), + [LangfuseOtelSpanAttributes.OBSERVATION_MODEL]: model, + [LangfuseOtelSpanAttributes.OBSERVATION_USAGE_DETAILS]: _serialize(usageDetails), + [LangfuseOtelSpanAttributes.OBSERVATION_COST_DETAILS]: _serialize(costDetails), + [LangfuseOtelSpanAttributes.OBSERVATION_COMPLETION_START_TIME]: _serialize(completionStartTime), + [LangfuseOtelSpanAttributes.OBSERVATION_MODEL_PARAMETERS]: _serialize(modelParameters), + ...prompt2 && !prompt2.isFallback ? { + [LangfuseOtelSpanAttributes.OBSERVATION_PROMPT_NAME]: prompt2.name, + [LangfuseOtelSpanAttributes.OBSERVATION_PROMPT_VERSION]: prompt2.version + } : {}, + ..._flattenAndSerializeMetadata(metadata, "observation") + }; + return Object.fromEntries( + Object.entries(otelAttributes).filter(([_, v]) => v != null) + ); +} +function _serialize(obj) { + try { + if (typeof obj === "string") return obj; + return obj != null ? JSON.stringify(obj) : void 0; + } catch { + return ""; + } +} +function _flattenAndSerializeMetadata(metadata, type) { + const prefix = type === "observation" ? LangfuseOtelSpanAttributes.OBSERVATION_METADATA : LangfuseOtelSpanAttributes.TRACE_METADATA; + const metadataAttributes = {}; + if (metadata === void 0 || metadata === null) { + return metadataAttributes; + } + if (typeof metadata !== "object" || Array.isArray(metadata)) { + const serialized = _serialize(metadata); + if (serialized) { + metadataAttributes[prefix] = serialized; + } + } else { + for (const [key, value] of Object.entries(metadata)) { + const serialized = typeof value === "string" ? value : _serialize(value); + if (serialized) { + metadataAttributes[`${prefix}.${key}`] = serialized; + } + } + } + return metadataAttributes; +} +var LANGFUSE_GLOBAL_SYMBOL = /* @__PURE__ */ Symbol.for("langfuse"); +function createState() { + return { + isolatedTracerProvider: null + }; +} +function getGlobalState() { + const initialState = createState(); + try { + const g = globalThis; + if (typeof g !== "object" || g === null) { + getGlobalLogger().warn( + "globalThis is not available, using fallback state" + ); + return initialState; + } + if (!g[LANGFUSE_GLOBAL_SYMBOL]) { + Object.defineProperty(g, LANGFUSE_GLOBAL_SYMBOL, { + value: initialState, + writable: false, + // lock the slot (not the contents) + configurable: false, + enumerable: false + }); + } + return g[LANGFUSE_GLOBAL_SYMBOL]; + } catch (err) { + if (err instanceof Error) { + getGlobalLogger().error(`Failed to access global state: ${err.message}`); + } else { + getGlobalLogger().error(`Failed to access global state: ${String(err)}`); + } + return initialState; + } +} +function setLangfuseTracerProvider(provider) { + getGlobalState().isolatedTracerProvider = provider; +} +function getLangfuseTracerProvider() { + const { isolatedTracerProvider } = getGlobalState(); + if (isolatedTracerProvider) return isolatedTracerProvider; + return trace.getTracerProvider(); +} +function getLangfuseTracer() { + return getLangfuseTracerProvider().getTracer( + LANGFUSE_TRACER_NAME, + LANGFUSE_SDK_VERSION + ); +} +var LangfuseBaseObservation = class { + constructor(params) { + var _a2; + this.otelSpan = params.otelSpan; + this.id = params.otelSpan.spanContext().spanId; + this.traceId = params.otelSpan.spanContext().traceId; + this.type = params.type; + this.otelSpan.setAttributes( + createObservationAttributes(params.type, (_a2 = params.attributes) != null ? _a2 : {}) + ); + } + /** Gets the Langfuse OpenTelemetry tracer instance */ + get tracer() { + return getLangfuseTracer(); + } + /** + * Ends the observation, marking it as complete. + * + * @param endTime - Optional end time, defaults to current time + */ + end(endTime) { + this.otelSpan.end(endTime); + } + updateOtelSpanAttributes(attributes) { + this.otelSpan.setAttributes( + createObservationAttributes(this.type, attributes) + ); + } + /** + * Set trace-level input and output for the trace this observation belongs to. + * + * @deprecated This is a legacy method for backward compatibility with Langfuse platform + * features that still rely on trace-level input/output (e.g., legacy LLM-as-a-judge + * evaluators). It will be removed in a future major version. + * + * For setting other trace attributes (userId, sessionId, metadata, tags, version), + * use {@link propagateAttributes} instead. + * + * @param attributes - Input and output data to associate with the trace + * @returns The observation instance for method chaining + * + * @example + * ```typescript + * const span = startObservation('my-operation'); + * span.setTraceIO({ + * input: { query: 'user question' }, + * output: { response: 'assistant answer' } + * }); + * ``` + */ + setTraceIO(attributes) { + this.otelSpan.setAttributes(createTraceAttributes(attributes)); + return this; + } + /** + * Make the trace this observation belongs to publicly accessible via its URL. + * + * When a trace is published, anyone with the trace link can view the full trace + * without needing to be logged in to Langfuse. This action cannot be undone + * programmatically - once any span in a trace is published, the entire trace + * becomes public. + * + * @returns The observation instance for method chaining + * + * @example + * ```typescript + * const span = startObservation('my-operation'); + * span.setTraceAsPublic(); + * ``` + */ + setTraceAsPublic() { + this.otelSpan.setAttributes({ + [LangfuseOtelSpanAttributes.TRACE_PUBLIC]: true + }); + return this; + } + startObservation(name, attributes, options) { + const { asType = "span" } = options || {}; + return startObservation(name, attributes, { + asType, + // typecast necessary as ts cannot narrow the type correctly + parentSpanContext: this.otelSpan.spanContext() + }); + } +}; +var LangfuseSpan = class extends LangfuseBaseObservation { + constructor(params) { + super({ ...params, type: "span" }); + } + /** + * Updates this span with new attributes. + * + * @param attributes - Span attributes to set + * @returns This span for method chaining + * + * @example + * ```typescript + * span.update({ + * output: { result: 'success' }, + * level: 'DEFAULT', + * metadata: { duration: 150 } + * }); + * ``` + */ + update(attributes) { + super.updateOtelSpanAttributes(attributes); + return this; + } +}; +var LangfuseAgent = class extends LangfuseBaseObservation { + constructor(params) { + super({ ...params, type: "agent" }); + } + /** + * Updates this agent observation with new attributes. + * + * @param attributes - Agent attributes to set + * @returns This agent for method chaining + * + * @example + * ```typescript + * agent.update({ + * output: { + * taskCompleted: true, + * iterationsUsed: 5, + * toolsInvoked: ['web-search', 'calculator', 'summarizer'], + * finalResult: 'Research completed with high confidence' + * }, + * metadata: { + * efficiency: 0.85, + * qualityScore: 0.92, + * resourcesConsumed: { tokens: 15000, apiCalls: 12 } + * } + * }); + * ``` + */ + update(attributes) { + super.updateOtelSpanAttributes(attributes); + return this; + } +}; +var LangfuseTool = class extends LangfuseBaseObservation { + constructor(params) { + super({ ...params, type: "tool" }); + } + /** + * Updates this tool observation with new attributes. + * + * @param attributes - Tool attributes to set + * @returns This tool for method chaining + * + * @example + * ```typescript + * tool.update({ + * output: { + * result: searchResults, + * count: searchResults.length, + * relevanceScore: 0.89, + * executionTime: 1250 + * }, + * metadata: { + * cacheHit: false, + * apiCost: 0.025, + * rateLimitRemaining: 950 + * } + * }); + * ``` + */ + update(attributes) { + super.updateOtelSpanAttributes(attributes); + return this; + } +}; +var LangfuseChain = class extends LangfuseBaseObservation { + constructor(params) { + super({ ...params, type: "chain" }); + } + /** + * Updates this chain observation with new attributes. + * + * @param attributes - Chain attributes to set + * @returns This chain for method chaining + * + * @example + * ```typescript + * chain.update({ + * output: { + * stepsCompleted: 5, + * stepsSuccessful: 4, + * finalResult: processedData, + * pipelineEfficiency: 0.87 + * }, + * metadata: { + * bottleneckStep: 'data-validation', + * parallelizationOpportunities: ['step-2', 'step-3'], + * optimizationSuggestions: ['cache-intermediate-results'] + * } + * }); + * ``` + */ + update(attributes) { + super.updateOtelSpanAttributes(attributes); + return this; + } +}; +var LangfuseRetriever = class extends LangfuseBaseObservation { + constructor(params) { + super({ ...params, type: "retriever" }); + } + /** + * Updates this retriever observation with new attributes. + * + * @param attributes - Retriever attributes to set + * @returns This retriever for method chaining + */ + update(attributes) { + super.updateOtelSpanAttributes(attributes); + return this; + } +}; +var LangfuseEvaluator = class extends LangfuseBaseObservation { + constructor(params) { + super({ ...params, type: "evaluator" }); + } + /** + * Updates this evaluator observation with new attributes. + * + * @param attributes - Evaluator attributes to set + * @returns This evaluator for method chaining + */ + update(attributes) { + super.updateOtelSpanAttributes(attributes); + return this; + } +}; +var LangfuseGuardrail = class extends LangfuseBaseObservation { + constructor(params) { + super({ ...params, type: "guardrail" }); + } + /** + * Updates this guardrail observation with new attributes. + * + * @param attributes - Guardrail attributes to set + * @returns This guardrail for method chaining + */ + update(attributes) { + super.updateOtelSpanAttributes(attributes); + return this; + } +}; +var LangfuseGeneration = class extends LangfuseBaseObservation { + constructor(params) { + super({ ...params, type: "generation" }); + } + update(attributes) { + this.updateOtelSpanAttributes(attributes); + return this; + } +}; +var LangfuseEmbedding = class extends LangfuseBaseObservation { + constructor(params) { + super({ ...params, type: "embedding" }); + } + /** + * Updates this embedding observation with new attributes. + * + * @param attributes - Embedding attributes to set + * @returns This embedding for method chaining + */ + update(attributes) { + this.updateOtelSpanAttributes(attributes); + return this; + } +}; +var LangfuseEvent = class extends LangfuseBaseObservation { + constructor(params) { + super({ ...params, type: "event" }); + this.otelSpan.end(params.timestamp); + } +}; +function createOtelSpan(params) { + return getLangfuseTracer().startSpan( + params.name, + { startTime: params.startTime }, + createParentContext(params.parentSpanContext) + ); +} +function createParentContext(parentSpanContext) { + if (!parentSpanContext) return; + return trace.setSpanContext(context.active(), parentSpanContext); +} +function startObservation(name, attributes, options) { + var _a2; + const { asType = "span", ...observationOptions } = options || {}; + const otelSpan = createOtelSpan({ + name, + ...observationOptions + }); + switch (asType) { + case "generation": + return new LangfuseGeneration({ + otelSpan, + attributes + }); + case "embedding": + return new LangfuseEmbedding({ + otelSpan, + attributes + }); + case "agent": + return new LangfuseAgent({ + otelSpan, + attributes + }); + case "tool": + return new LangfuseTool({ + otelSpan, + attributes + }); + case "chain": + return new LangfuseChain({ + otelSpan, + attributes + }); + case "retriever": + return new LangfuseRetriever({ + otelSpan, + attributes + }); + case "evaluator": + return new LangfuseEvaluator({ + otelSpan, + attributes + }); + case "guardrail": + return new LangfuseGuardrail({ + otelSpan, + attributes + }); + case "event": { + const timestamp = (_a2 = observationOptions == null ? void 0 : observationOptions.startTime) != null ? _a2 : /* @__PURE__ */ new Date(); + return new LangfuseEvent({ + otelSpan, + attributes, + timestamp + }); + } + case "span": + default: + return new LangfuseSpan({ + otelSpan, + attributes + }); + } +} + +// src/adapters/langfuse-sink.ts +var import_sdk_trace_node = __toESM(require_src9(), 1); +var TRACE_NAME = "ZCode Turn"; +var BASE_TAGS = ["zcode", "zcode-hook"]; +var FLUSH_BUDGET_MS = 8e3; +var MEDIA_FLUSH_BUDGET_MS = 13e3; +var SHUTDOWN_BUDGET_MS = 5e3; +function chatInput(prompt2) { + return prompt2 === null ? void 0 : { role: "user", content: prompt2 }; +} +function chatOutput(message) { + return message === null ? void 0 : { role: "assistant", content: message }; +} +async function withBudget(task, budgetMs) { + let timer; + try { + await Promise.race([ + task, + new Promise((resolve2) => { + timer = setTimeout(resolve2, budgetMs); + timer.unref?.(); + }) + ]); + } finally { + clearTimeout(timer); + } +} +var LangfuseTraceSink = class { + constructor(config) { + this.config = config; + } + config; + async publishTurn(turn) { + if (!this.config.publicKey || !this.config.secretKey) return; + const traceAttributes = { + [LangfuseOtelSpanAttributes.TRACE_NAME]: TRACE_NAME, + [LangfuseOtelSpanAttributes.TRACE_SESSION_ID]: turn.sessionId, + [LangfuseOtelSpanAttributes.TRACE_TAGS]: BASE_TAGS, + ...this.config.userId ? { [LangfuseOtelSpanAttributes.TRACE_USER_ID]: this.config.userId } : {} + }; + const processor = new LangfuseSpanProcessor({ + publicKey: this.config.publicKey, + secretKey: this.config.secretKey, + baseUrl: this.config.baseUrl, + environment: this.config.environment, + release: this.config.release, + // Default batched mode plus the explicit forceFlush below collapses the + // whole turn into one OTLP request. Immediate mode exports spans one + // request at a time; a tool-heavy turn then overruns the flush budget + // and silently drops the tail (root span and generation). + exportMode: "batched", + // Data URIs preserved under max_media_chars are detected and uploaded by + // the processor; zero disables both preservation and upload. + mediaUploadEnabled: this.config.maxMediaChars > 0, + // Capture flags and size limits above are the only privacy levers; the + // media path only ever sees content that already passed them. + timeout: FLUSH_BUDGET_MS / 1e3, + shouldExportSpan: ({ otelSpan }) => isLangfuseSpan(otelSpan) + }); + const flushBudgetMs = turn.hasMedia && this.config.maxMediaChars > 0 ? MEDIA_FLUSH_BUDGET_MS : FLUSH_BUDGET_MS; + const baseOnStart = processor.onStart.bind(processor); + processor.onStart = (span, parentContext) => { + baseOnStart(span, parentContext); + span.setAttributes(traceAttributes); + }; + const provider = new import_sdk_trace_node.NodeTracerProvider({ + spanProcessors: [processor], + sampler: new import_sdk_trace_node.AlwaysOnSampler(), + spanLimits: { + attributeValueLengthLimit: Infinity, + attributeCountLimit: Infinity + } + }); + setLangfuseTracerProvider(provider); + try { + const root = startObservation(TRACE_NAME, { + input: chatInput(turn.prompt), + metadata: { + source: "zcode", + plugin: PLUGIN_ID, + turnId: turn.turnId, + toolCount: turn.tools.length + } + }, { asType: "span", startTime: new Date(turn.startedAt) }); + for (const tool of turn.tools) { + const span = root.startObservation(`tool.${tool.name}`, { + input: tool.input, + metadata: { + toolId: tool.id, + startedAt: tool.startedAt, + endedAt: tool.endedAt + } + }, { asType: "tool" }); + if (tool.error) { + span.update({ + output: { error: tool.error }, + level: "ERROR", + statusMessage: tool.error + }); + } else { + span.update({ output: tool.output }); + } + span.end(); + } + const generation = root.startObservation("zcode.assistant", { + input: chatInput(turn.prompt), + output: chatOutput(turn.assistantMessage), + metadata: { turnId: turn.turnId } + }, { asType: "generation" }); + generation.end(); + root.update({ output: chatOutput(turn.assistantMessage) }); + root.end(); + await withBudget(processor.forceFlush(), flushBudgetMs); + } finally { + setLangfuseTracerProvider(null); + await withBudget(provider.shutdown(), SHUTDOWN_BUDGET_MS); + } + } +}; + +// src/hooks/entry.ts +function isRecord3(value) { + return typeof value === "object" && value !== null && !Array.isArray(value); +} +function parsePayload(raw) { + if (!raw.trim()) return {}; + try { + const parsed = JSON.parse(raw); + return isRecord3(parsed) ? parsed : {}; + } catch { + return {}; + } +} +async function readStdin() { + let raw = ""; + process.stdin.setEncoding("utf8"); + for await (const chunk of process.stdin) raw += chunk; + return raw; +} +function diagnostics(enabled, message) { + if (enabled) process.stderr.write(`[${PLUGIN_ID}] ${message} +`); +} +console.info = console.error; +console.log = console.error; +console.debug = console.error; +async function main() { + const config = readConfig(); + const payload = parsePayload(await readStdin()); + const event = eventName(payload) ?? "unknown"; + const session = sessionId(payload) ?? "?"; + diagnostics(config.debug, `event=${event} session=${session}`); + const sink = isConfigured(config) ? new LangfuseTraceSink(config) : new NoopTraceSink(); + const tracker = new TurnTracker( + new JsonStateStore(), + sink, + config, + { now: () => /* @__PURE__ */ new Date() }, + { next: randomUUID2 } + ); + try { + await tracker.handle(payload); + } catch (error) { + const kind = error instanceof Error ? error.name : "unknown"; + diagnostics(config.debug, `hook failed open (${kind})`); + } + process.stdout.write("{}\n"); +} +await main(); diff --git a/plugins/zcode-plugin-langfuse/hooks/hooks.json b/plugins/zcode-plugin-langfuse/hooks/hooks.json new file mode 100644 index 0000000..ab20687 --- /dev/null +++ b/plugins/zcode-plugin-langfuse/hooks/hooks.json @@ -0,0 +1,91 @@ +{ + "description": "Langfuse observability hooks for ZCode.", + "hooks": { + "SessionStart": [ + { + "hooks": [ + { + "type": "process", + "command": "node", + "args": [ + "${ZCODE_PLUGIN_ROOT}/hooks/entry.mjs" + ], + "timeoutMs": 5000, + "statusMessage": "Langfuse: preparing session tracing…" + } + ] + } + ], + "UserPromptSubmit": [ + { + "hooks": [ + { + "type": "process", + "command": "node", + "args": [ + "${ZCODE_PLUGIN_ROOT}/hooks/entry.mjs" + ], + "timeoutMs": 5000 + } + ] + } + ], + "PreToolUse": [ + { + "hooks": [ + { + "type": "process", + "command": "node", + "args": [ + "${ZCODE_PLUGIN_ROOT}/hooks/entry.mjs" + ], + "timeoutMs": 5000 + } + ] + } + ], + "PostToolUse": [ + { + "hooks": [ + { + "type": "process", + "command": "node", + "args": [ + "${ZCODE_PLUGIN_ROOT}/hooks/entry.mjs" + ], + "timeoutMs": 5000 + } + ] + } + ], + "PostToolUseFailure": [ + { + "hooks": [ + { + "type": "process", + "command": "node", + "args": [ + "${ZCODE_PLUGIN_ROOT}/hooks/entry.mjs" + ], + "timeoutMs": 5000 + } + ] + } + ], + "Stop": [ + { + "hooks": [ + { + "type": "process", + "command": "node", + "args": [ + "${ZCODE_PLUGIN_ROOT}/hooks/entry.mjs" + ], + "timeoutMs": 20000, + "statusMessage": "Langfuse: sending trace…" + } + ] + } + ] + } +}