diff --git a/.changeset/clickstack-sdks.md b/.changeset/clickstack-sdks.md new file mode 100644 index 0000000000..16aaacfdb4 --- /dev/null +++ b/.changeset/clickstack-sdks.md @@ -0,0 +1,45 @@ +--- +'@hyperdx/api': minor +'@hyperdx/app': minor +--- + +feat: self-instrument with `@clickhouse/clickstack-node` and +`@clickhouse/clickstack-browser` instead of `@hyperdx/node-opentelemetry` and +`@hyperdx/browser` + +HyperDX's own telemetry changes shape. HTTP spans use the stable semantic +convention keys (`http.request.method`, `http.response.status_code`, +`url.full`). pino records come from the `@opentelemetry/instrumentation-pino` +scope with real severity numbers instead of the `node-logger` scope with +severity number 0. Console capture covers every `console` call in the API, and +browser console output is recorded as log records instead of spans. Uncaught +exceptions are recorded as FATAL log records, and API errors as an exception +event on the Express span instead of a separate error span. + +Browser telemetry records the user as `user.id`, `user.email` and `user.name` +instead of `userEmail` and `userName`, keeps the team name as `teamName`, and no +longer records a `user navigated` action. Browser fetch and XHR spans no longer +record request and response headers or bodies. Browser sessions restart once +after the upgrade. The per-signal browser endpoints and +`NEXT_PUBLIC_OTEL_RESOURCE_ATTRIBUTES` work as before. Browser traces and logs +are now sent gzip-compressed every 5 seconds. If the browser sends to a +collector other than ClickStack's, its CORS `allowed_headers` must be `"*"` or +include `content-type` and `content-encoding` (and `authorization`), and a proxy +in front of it must forward `Content-Encoding` unchanged. + +The Next.js server now sends its own telemetry in production builds too, not +only under `next dev`, when `HYPERDX_API_KEY` or `OTEL_EXPORTER_OTLP_HEADERS` is +set. `HDX_EXPORTER_ENABLED=false` turns it off along with browser telemetry. It +reports under its own service name, the configured one plus `-next` +(`hdx-oss-app-next` in the docker-compose `app` service and when no name is +set), so its spans stay apart from the API's and the browser's. The HyperDX +images now default `OTEL_SERVICE_NAME` to `hdx-oss-app`. Each `/api` request +adds Next.js server spans for the proxy hop. Requests for build and `public/` +assets, such as `/_next/static/*`, `/__ENV.js` and `/pyodide/*`, are not traced. + +`HYPERDX_API_KEY` still enables self-instrumentation. Without +`OTEL_EXPORTER_OTLP_ENDPOINT`, server-side self-telemetry now goes to +`http://localhost:4318` instead of `https://in-otel.hyperdx.io`, so set the +endpoint explicitly. `HDX_NODE_*` variables are no longer read. For request +headers and bodies set `OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_*` and +`CLICKSTACK_CAPTURE_HTTP_BODY`. diff --git a/.changeset/collector-cors-max-age.md b/.changeset/collector-cors-max-age.md new file mode 100644 index 0000000000..264c7d33a6 --- /dev/null +++ b/.changeset/collector-cors-max-age.md @@ -0,0 +1,10 @@ +--- +'@hyperdx/api': patch +'@hyperdx/otel-collector': patch +--- + +fix: let browsers cache the collector's CORS preflights for 10 minutes + +The OTLP receiver now answers preflights with `Access-Control-Max-Age: 600`. +Without it, browsers cached a preflight for only 5 seconds, which is how often +the browser SDK exports, so about half of its requests were preflights. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index e37d95c5b9..fd948ba21e 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -214,6 +214,11 @@ yarn dev:down To enable self-instrumentation and demo logs, you can set the `HYPERDX_API_KEY` to your ingestion key (visit the Team settings page after creating your account). +The API and the Next.js server pass it to the ClickStack SDK +(`@clickhouse/clickstack-node`) as `apiKey`, and the browser SDK +(`@clickhouse/clickstack-browser`) gets it from `/api/config`. The API and the +alert task report as `hdx-oss-dev-api`, the Next.js server as +`hdx-oss-dev-app-next`, and the browser as `hdx-oss-dev-app`. To do this, create a `.env.local` file in the root of the project and add the following: diff --git a/LOCAL.md b/LOCAL.md index 8ee39f52e0..7a218147f2 100644 --- a/LOCAL.md +++ b/LOCAL.md @@ -38,7 +38,7 @@ Configuring instrumentation for ClickStack Local is similar to configuring it fo Most instrumentations can be configured using the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable. Ex: `OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318`. -If you're using a ClickStack maintained SDK, you may need to give a non-empty `HYPERDX_API_KEY` as well, API keys are not validated in ClickStack Local and therefore can be any non-empty value. +If you're using a ClickStack SDK, pass the key as the `apiKey` init option. `@clickhouse/clickstack-node` also accepts `OTEL_EXPORTER_OTLP_HEADERS=authorization=`, and `@clickhouse/clickstack-browser` only takes `apiKey`. Older HyperDX SDKs (`@hyperdx/*`) may need a non-empty `HYPERDX_API_KEY` instead. API keys are not validated in ClickStack Local and therefore can be any non-empty value. ## Customizing Ports diff --git a/agent_docs/observability.md b/agent_docs/observability.md index 758ed5edb3..d19c2e922d 100644 --- a/agent_docs/observability.md +++ b/agent_docs/observability.md @@ -47,7 +47,7 @@ All manual instrumentation in `packages/api` goes through | Helper | Purpose | | --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ | | `withSpan(name, fn, opts?)` | Run an async unit of work in an active span. Records exceptions, sets OK/ERROR status, always ends the span. | -| `setBusinessContext({ teamId, userId, email, ...extra })` | Attach standardized incident-remediation context to the trace + active span. | +| `setBusinessContext({ teamId, userId, email, ...extra })` | Attach standardized incident-remediation context to the active span and the request's HTTP server span. | | `getStaticFeatureFlags()` | Returns the static (env/compile-time) feature-flag states as `feature_flag.*` attributes. | | `getCounter(name, opts?)` / `getHistogram(name, opts?)` | Memoized OTel instrument accessors. Always use these instead of `meter.create*`. | | `recordDuration(histogram, fn, attrs?)` | Run `fn`, recording its wall-clock duration on a histogram (even on throw). | @@ -57,10 +57,10 @@ types, so a single import is usually enough. ### Tracing -Rely on the ClickStack SDK auto-instrumentation (HTTP, Express, Mongo, etc.) for -the common path. Add a **manual span only for a meaningful unit of work** that -auto-instrumentation can't see - a background job step, a fan-out, an expensive -computation, an external tool invocation. +Rely on the ClickStack SDK (`@clickhouse/clickstack-node`) auto-instrumentation +(HTTP, Express, Mongo, etc.) for the common path. Add a **manual span only for a +meaningful unit of work** that auto-instrumentation can't see - a background job +step, a fan-out, an expensive computation, an external tool invocation. ```ts import { withSpan } from '@/utils/instrumentation'; @@ -91,8 +91,10 @@ Span rules to follow (from the Instrumentation Score spec): ### Business context Attach team/user context as early as possible (at the auth boundary or the top -of a job). `setBusinessContext` writes both to the whole trace (via the ClickStack -SDK, requires `HDX_NODE_BETA_MODE=1`) and to the active span. +of a job). `setBusinessContext` writes to the active span and, inside an HTTP +request, to the request's HTTP server span, so the context stays on the request +even when the active span is a short Express middleware span. Other spans in the +trace do not get it. ```ts import { diff --git a/agent_docs/tech_stack.md b/agent_docs/tech_stack.md index efe0f3c552..b28d0d0a7f 100644 --- a/agent_docs/tech_stack.md +++ b/agent_docs/tech_stack.md @@ -19,7 +19,7 @@ - **Database**: ClickHouse (telemetry data), MongoDB via Mongoose (metadata) - **Authentication**: Passport.js with local strategy - **Validation**: Zod schemas -- **Telemetry**: Self-instrumented with `@hyperdx/node-opentelemetry` +- **Telemetry**: Self-instrumented with `@clickhouse/clickstack-node` (API and Next.js server) and `@clickhouse/clickstack-browser` (frontend) ## Common Utilities (`packages/common-utils`) diff --git a/docker/hyperdx/Dockerfile b/docker/hyperdx/Dockerfile index 5c0bbeb53f..4aa309c0ac 100644 --- a/docker/hyperdx/Dockerfile +++ b/docker/hyperdx/Dockerfile @@ -86,6 +86,8 @@ COPY --from=app ./pages ./packages/app/pages COPY --from=app ./public ./packages/app/public COPY --from=app ./styles ./packages/app/styles COPY --from=app ./types ./packages/app/types +# next build finds instrumentation.ts only next to pages/, not under src/ +COPY --from=app ./instrumentation.ts ./instrumentation-client.ts ./packages/app/ # Build inputs for public/whats-new.json, generated by next.config.mjs for the # in-app "What's new" section: the root changelog it parses and the parser # itself. WORKDIR is /app, and next.config resolves the changelog as @@ -116,6 +118,10 @@ ARG CODE_VERSION ENV CODE_VERSION=$CODE_VERSION ENV OTEL_RESOURCE_ATTRIBUTES="service.version=$CODE_VERSION" +# Service name for HyperDX's own telemetry, sent only when HYPERDX_API_KEY or +# OTEL_EXPORTER_OTLP_HEADERS is set. The API and alert task use it as is, the +# Next.js server adds "-next". Override it with -e OTEL_SERVICE_NAME=. +ENV OTEL_SERVICE_NAME=hdx-oss-app ENV NODE_ENV=production # Remove package managers from production image (not needed at runtime) @@ -155,6 +161,10 @@ ARG USER_GID=10001 ENV CODE_VERSION=$CODE_VERSION ENV OTEL_RESOURCE_ATTRIBUTES="service.version=$CODE_VERSION" +# Service name for HyperDX's own telemetry, sent only when HYPERDX_API_KEY or +# OTEL_EXPORTER_OTLP_HEADERS is set. The API and alert task use it as is, the +# Next.js server adds "-next". Override it with -e OTEL_SERVICE_NAME=. +ENV OTEL_SERVICE_NAME=hdx-oss-app # Copy from otel collector bases COPY --from=ocb-builder --chmod=755 /build/output/otelcol-hyperdx /otelcontribcol COPY --from=otel_collector_opampsupervisor_base --chmod=755 /usr/local/bin/opampsupervisor /usr/local/bin/opampsupervisor diff --git a/docker/otel-collector/config.standalone.yaml b/docker/otel-collector/config.standalone.yaml index fef3097db6..810935b3b4 100644 --- a/docker/otel-collector/config.standalone.yaml +++ b/docker/otel-collector/config.standalone.yaml @@ -11,6 +11,9 @@ receivers: cors: allowed_origins: ['*'] allowed_headers: ['*'] + # Lets browsers cache preflights for 10 minutes, see + # buildOtelCollectorConfig() + max_age: 600 include_metadata: true endpoint: '0.0.0.0:4318' diff --git a/packages/api/.env.development b/packages/api/.env.development index d97b0ff888..c937acea83 100644 --- a/packages/api/.env.development +++ b/packages/api/.env.development @@ -3,9 +3,10 @@ HYPERDX_LOG_LEVEL=debug # Development only: keep sessions valid across nodemon restarts. EXPRESS_SESSION_SECRET="local-development-only" FRONTEND_URL="http://localhost:${HYPERDX_APP_PORT}" -HDX_NODE_ADVANCED_NETWORK_CAPTURE=1 -HDX_NODE_BETA_MODE=1 -HDX_NODE_CONSOLE_CAPTURE=1 +# Self-telemetry request and response capture. Booleans must be `true`. +CLICKSTACK_CAPTURE_HTTP_BODY=true +OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST="user-agent,content-type,x-request-id,referer" +OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE="content-type,content-length" MONGO_URI="mongodb://localhost:${HDX_DEV_MONGO_PORT}/hyperdx" NODE_ENV=development OTEL_SERVICE_NAME="hdx-oss-dev-api" diff --git a/packages/api/bin/hyperdx b/packages/api/bin/hyperdx index f8820ff135..051749ceb1 100755 --- a/packages/api/bin/hyperdx +++ b/packages/api/bin/hyperdx @@ -4,19 +4,18 @@ set -e SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" API_BUILD_DIR="${SCRIPT_DIR}/../build" -# shellcheck disable=SC2086 -# NODE_REQUIRE_FLAGS is intentionally unquoted for word-splitting into -r -NODE_REQUIRE_FLAGS="-r @hyperdx/node-opentelemetry/build/src/tracing" +# Self-telemetry preload, see src/telemetry.ts +TELEMETRY_PRELOAD="${API_BUILD_DIR}/telemetry.js" command="$1" shift 2>/dev/null || true case "$command" in api) - exec node $NODE_REQUIRE_FLAGS "$API_BUILD_DIR/index.js" "$@" + exec node -r "$TELEMETRY_PRELOAD" "$API_BUILD_DIR/index.js" "$@" ;; task) - exec node $NODE_REQUIRE_FLAGS "$API_BUILD_DIR/tasks/index.js" "$@" + exec node -r "$TELEMETRY_PRELOAD" "$API_BUILD_DIR/tasks/index.js" "$@" ;; *) echo "Usage: hyperdx [args...]" diff --git a/packages/api/package.json b/packages/api/package.json index 390af6805e..263e58274b 100644 --- a/packages/api/package.json +++ b/packages/api/package.json @@ -20,15 +20,18 @@ "@ai-sdk/openai": "^4.0.78", "@ai-sdk/otel": "^1.0.116", "@braintree/sanitize-url": "^7.1.1", + "@clickhouse/clickstack-node": "^1.0.2", "@clickhouse/client-common": "1.23.0-head.fae5998.1", "@esm2cjs/p-queue": "^7.3.0", "@hyperdx/common-utils": "^0.33.0", - "@hyperdx/node-opentelemetry": "^0.9.0", "@hyperdx/passport-local-mongoose": "^9.0.1", "@modelcontextprotocol/sdk": "^1.27.1", - "@opentelemetry/api": "^1.8.0", - "@opentelemetry/host-metrics": "^0.35.5", - "@opentelemetry/sdk-metrics": "^1.30.1", + "@opentelemetry/api": "~1.9.1", + "@opentelemetry/api-logs": "^0.223.0", + "@opentelemetry/core": "^2.12.0", + "@opentelemetry/otlp-transformer": "^0.223.0", + "@opentelemetry/resources": "^2.12.0", + "@opentelemetry/sdk-logs": "^0.223.0", "@slack/webhook": "^7.0.0", "@types/node": "^22.15.18", "ai": "^7.0.116", @@ -98,9 +101,9 @@ }, "scripts": { "start": "node ./build/index.js", - "dev": "DOTENV_CONFIG_PATH=.env.development nodemon --exec 'ts-node' --transpile-only -r tsconfig-paths/register -r dotenv-expand/config -r '@hyperdx/node-opentelemetry/build/src/tracing' ./src/index.ts", + "dev": "DOTENV_CONFIG_PATH=.env.development nodemon --exec 'ts-node' --transpile-only -r tsconfig-paths/register -r dotenv-expand/config -r ./src/telemetry.ts ./src/index.ts", "dev:mcp": "npx @modelcontextprotocol/inspector", - "dev-task": "DOTENV_CONFIG_PATH=.env.development nodemon --exec 'ts-node' --transpile-only -r tsconfig-paths/register -r dotenv-expand/config -r '@hyperdx/node-opentelemetry/build/src/tracing' ./src/tasks/index.ts", + "dev-task": "DOTENV_CONFIG_PATH=.env.development nodemon --exec 'ts-node' --transpile-only -r tsconfig-paths/register -r dotenv-expand/config -r ./src/telemetry.ts ./src/tasks/index.ts", "build": "rimraf ./build && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json && cp -r ./src/opamp/proto ./build/opamp/", "build:vercel": "rimraf ./build && tsc -p tsconfig.vercel.json && tsc-alias -p tsconfig.vercel.json && cp -r ./src/opamp/proto ./build/opamp/", "lint": "npx eslint . --ext .ts --max-warnings 302", diff --git a/packages/api/src/__tests__/telemetry.test.ts b/packages/api/src/__tests__/telemetry.test.ts new file mode 100644 index 0000000000..9bfc242583 --- /dev/null +++ b/packages/api/src/__tests__/telemetry.test.ts @@ -0,0 +1,82 @@ +const mockInit = jest.fn(); +let mockIsMainThread = true; + +jest.mock('@clickhouse/clickstack-node', () => ({ + init: (...args: unknown[]) => mockInit(...args), +})); +jest.mock('node:worker_threads', () => ({ + get isMainThread() { + return mockIsMainThread; + }, +})); + +describe('telemetry preload', () => { + const originalEnv = { ...process.env }; + + const runPreload = (env: Record) => { + delete process.env.HYPERDX_API_KEY; + delete process.env.OTEL_EXPORTER_OTLP_HEADERS; + delete process.env.NODE_ENV; + Object.assign(process.env, env); + jest.isolateModules(() => { + jest.requireActual('@/telemetry'); + }); + }; + + beforeEach(() => { + mockInit.mockClear(); + mockIsMainThread = true; + }); + + afterAll(() => { + process.env = originalEnv; + }); + + it('does not start the SDK without a key or OTLP headers', () => { + runPreload({ HYPERDX_API_KEY: ' ', OTEL_EXPORTER_OTLP_HEADERS: '' }); + + expect(mockInit).not.toHaveBeenCalled(); + }); + + it('passes HYPERDX_API_KEY as the apiKey', () => { + runPreload({ HYPERDX_API_KEY: 'ingest-key', NODE_ENV: 'production' }); + + expect(mockInit).toHaveBeenCalledWith({ + apiKey: 'ingest-key', + instrumentations: undefined, + }); + }); + + it('appends the key to OTLP headers that have no authorization entry', () => { + runPreload({ + HYPERDX_API_KEY: 'ingest,key', + OTEL_EXPORTER_OTLP_HEADERS: 'x-scope-orgid=acme', + }); + + expect(process.env.OTEL_EXPORTER_OTLP_HEADERS).toBe( + 'x-scope-orgid=acme,authorization=ingest%2Ckey', + ); + expect(mockInit).toHaveBeenCalledWith( + expect.objectContaining({ apiKey: undefined }), + ); + }); + + it('enables host metrics only in development', () => { + runPreload({ HYPERDX_API_KEY: 'ingest-key', NODE_ENV: 'development' }); + + expect(mockInit).toHaveBeenCalledWith({ + apiKey: 'ingest-key', + instrumentations: { + '@opentelemetry/instrumentation-host-metrics': { enabled: true }, + }, + }); + }); + + it('does not start a second SDK in a worker thread', () => { + mockIsMainThread = false; + + runPreload({ HYPERDX_API_KEY: 'ingest-key' }); + + expect(mockInit).not.toHaveBeenCalled(); + }); +}); diff --git a/packages/api/src/index.ts b/packages/api/src/index.ts index f8bfbbf38a..e0ec79f8cc 100644 --- a/packages/api/src/index.ts +++ b/packages/api/src/index.ts @@ -1,6 +1,4 @@ -import { getHyperDXMetricReader } from '@hyperdx/node-opentelemetry/build/src/metrics'; -import { HostMetrics } from '@opentelemetry/host-metrics'; -import { MeterProvider, MetricReader } from '@opentelemetry/sdk-metrics'; +import { flush } from '@clickhouse/clickstack-node'; import { serializeError } from 'serialize-error'; import * as config from '@/config'; @@ -8,25 +6,21 @@ import Server from '@/server'; import { isOperationalError } from '@/utils/errors'; import logger from '@/utils/logger'; -if (config.IS_DEV) { - // Start collecting host metrics - const meterProvider = new MeterProvider({ - // FIXME: missing selectCardinalityLimit property - readers: [getHyperDXMetricReader() as unknown as MetricReader], - }); - const hostMetrics = new HostMetrics({ meterProvider }); - hostMetrics.start(); -} - const server = new Server(); +// process.exit() skips the SDK's exit-time flush, so export what is buffered +// first. Before init (no key set) flush() resolves at once. +const exitAfterFlush = (code: number) => { + void flush().finally(() => process.exit(code)); +}; + process.on('uncaughtException', (err: Error) => { logger.error({ err: serializeError(err) }, 'Uncaught exception'); // FIXME: disable server restart until // we make sure all expected exceptions are handled properly if (config.IS_DEV && !isOperationalError(err)) { - process.exit(1); + exitAfterFlush(1); } }); @@ -41,5 +35,5 @@ server.start().catch(e => { // orchestrator restarts us instead of lingering as a zombie that listens // but can never serve (https://github.com/ClickHouse/ClickStack/issues/2966). logger.error({ err: serializeError(e) }, 'Server start failed, exiting'); - process.exit(1); + exitAfterFlush(1); }); diff --git a/packages/api/src/mcp/__tests__/tracing.test.ts b/packages/api/src/mcp/__tests__/tracing.test.ts index aab68793c2..042eeecc4f 100644 --- a/packages/api/src/mcp/__tests__/tracing.test.ts +++ b/packages/api/src/mcp/__tests__/tracing.test.ts @@ -58,9 +58,10 @@ jest.mock('@opentelemetry/api', () => ({ }, })); -jest.mock('@hyperdx/node-opentelemetry', () => ({ - __esModule: true, - setTraceAttributes: jest.fn(), +// The real package would read helpers off the mocked @opentelemetry/api at +// load time. Only setBusinessContext uses it, and these tests never call it. +jest.mock('@opentelemetry/core', () => ({ + getRPCMetadata: jest.fn(), })); jest.mock('@/config', () => ({ diff --git a/packages/api/src/mcp/app.ts b/packages/api/src/mcp/app.ts index 94b05777eb..bf77bf4765 100644 --- a/packages/api/src/mcp/app.ts +++ b/packages/api/src/mcp/app.ts @@ -1,9 +1,9 @@ -import { setTraceAttributes } from '@hyperdx/node-opentelemetry'; import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js'; import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'; import express from 'express'; import { validateUserAccessKey } from '@/middleware/auth'; +import { setBusinessContext } from '@/utils/instrumentation'; import logger from '@/utils/logger'; import rateLimiter, { rateLimiterKeyGenerator } from '@/utils/rateLimiter'; @@ -63,7 +63,7 @@ app.post('/', mcpRateLimiter, validateUserAccessKey, async (req, res) => { mcpClient: userAgentClientInfo(req.get('User-Agent')), }; - setTraceAttributes({ + setBusinessContext({ 'mcp.team.id': context.teamId, 'mcp.user.id': userId, }); diff --git a/packages/api/src/middleware/__tests__/error.test.ts b/packages/api/src/middleware/__tests__/error.test.ts index 9f1b960a6d..3427ff64ea 100644 --- a/packages/api/src/middleware/__tests__/error.test.ts +++ b/packages/api/src/middleware/__tests__/error.test.ts @@ -6,11 +6,13 @@ const mockRecordException = jest.fn(); const mockSetAttribute = jest.fn(); const mockLogger = { warn: jest.fn(), error: jest.fn(), debug: jest.fn() }; -jest.mock('@hyperdx/node-opentelemetry', () => ({ - recordException: (...args: unknown[]) => mockRecordException(...args), -})); jest.mock('@opentelemetry/api', () => ({ - trace: { getActiveSpan: () => ({ setAttribute: mockSetAttribute }) }, + trace: { + getActiveSpan: () => ({ + setAttribute: mockSetAttribute, + recordException: mockRecordException, + }), + }, })); jest.mock('@/config', () => ({ IS_PROD: false })); jest.mock('@/utils/instrumentation', () => ({ @@ -59,11 +61,6 @@ describe('appErrorHandler', () => { }); }); - it('skips recordException (benign background noise)', () => { - invoke(abortErr); - expect(mockRecordException).not.toHaveBeenCalled(); - }); - it('records how far the upload got on the span', () => { invoke(abortErr); expect(mockSetAttribute).toHaveBeenCalledWith( @@ -83,13 +80,18 @@ describe('appErrorHandler', () => { code: 'ECONNABORTED', }); - it('stays a non-operational error: logged at error, recorded', () => { + it('stays a non-operational error: logged at error, counted', () => { invoke(timeoutErr); expect(mockLogger.error).toHaveBeenCalledTimes(1); expect(mockLogger.debug).not.toHaveBeenCalled(); - expect(mockRecordException).toHaveBeenCalledTimes(1); expect(lastCounterAttrs()).toMatchObject({ operational: false }); }); + + it('leaves exception recording to the Express instrumentation', () => { + // Recording here too would put the exception on the trace twice. + invoke(timeoutErr); + expect(mockRecordException).not.toHaveBeenCalled(); + }); }); describe('error_type label boundedness', () => { diff --git a/packages/api/src/middleware/error.ts b/packages/api/src/middleware/error.ts index 2e90daf0a4..397bb77eac 100644 --- a/packages/api/src/middleware/error.ts +++ b/packages/api/src/middleware/error.ts @@ -1,4 +1,3 @@ -import { recordException } from '@hyperdx/node-opentelemetry'; import { trace } from '@opentelemetry/api'; import type { NextFunction, Request, Response } from 'express'; @@ -61,7 +60,13 @@ export const appErrorHandler = ( }); // Attach connection-level context to the active span so a single trace shows - // why the request failed and, for aborts, how far the upload got. + // why the request failed and, for aborts, how far the upload got. Error + // handlers run outside the Express layer spans, so this is the HTTP server + // span. The exception itself is not recorded here, because the Express + // instrumentation already records an error thrown in a middleware or route, + // or passed to next(), on that layer's span (except the non-last handlers of + // a multi-handler router.use(), which it does not wrap), and the HTTP + // instrumentation marks a 5xx server span as an error. const activeSpan = trace.getActiveSpan(); if (activeSpan) { if (parserErrorType) { @@ -94,18 +99,6 @@ export const appErrorHandler = ( ? 'Invalid JSON payload' : 'Something went wrong :('; - // A client disconnect is expected background noise, not an exception worth - // surfacing in error tracking (the auto-instrumented parser span already - // recorded it), so we skip recordException for it. - if (!clientDisconnect) { - void recordException(err, { - mechanism: { - type: 'generic', - handled: userFacingErrorMessage ? true : false, - }, - }); - } - if (!res.headersSent) { res.status(statusCode).json({ message: userFacingErrorMessage, diff --git a/packages/api/src/opamp/controllers/__tests__/opampController.test.ts b/packages/api/src/opamp/controllers/__tests__/opampController.test.ts index b6d274e970..dd6523c452 100644 --- a/packages/api/src/opamp/controllers/__tests__/opampController.test.ts +++ b/packages/api/src/opamp/controllers/__tests__/opampController.test.ts @@ -110,6 +110,18 @@ describe('opampController', () => { }); }); + describe('buildOtelCollectorConfig otlp/hyperdx CORS', () => { + it('lets browsers cache preflights for 10 minutes', () => { + const cfg = buildOtelCollectorConfig([]); + + expect(cfg.receivers['otlp/hyperdx']?.protocols.http.cors).toEqual({ + allowed_origins: ['*'], + allowed_headers: ['*'], + max_age: 600, + }); + }); + }); + describe('buildOtelCollectorConfig otlp/hyperdx authentication', () => { it('accepts bare and bearer-prefixed authorization values for each API key', () => { const cfg = buildOtelCollectorConfig([ diff --git a/packages/api/src/opamp/controllers/opampController.ts b/packages/api/src/opamp/controllers/opampController.ts index ed777c8348..13d567d966 100644 --- a/packages/api/src/opamp/controllers/opampController.ts +++ b/packages/api/src/opamp/controllers/opampController.ts @@ -63,6 +63,7 @@ type CollectorConfig = { cors: { allowed_origins: string[]; allowed_headers: string[]; + max_age: number; }; include_metadata: boolean; auth?: { @@ -206,6 +207,11 @@ export const buildOtelCollectorConfig = ( cors: { allowed_origins: ['*'], allowed_headers: ['*'], + // Without Access-Control-Max-Age, Chrome caches a preflight for only 5 s, which is + // how often the browser SDK exports, so about half of its requests were preflights. + // Ten minutes already removes nearly all of them while keeping a policy change from + // lingering in browsers. + max_age: 600, }, include_metadata: true, }, diff --git a/packages/api/src/server.ts b/packages/api/src/server.ts index a6a1c3d732..2f7351b1f2 100644 --- a/packages/api/src/server.ts +++ b/packages/api/src/server.ts @@ -1,3 +1,4 @@ +import { shutdown as shutdownTelemetry } from '@clickhouse/clickstack-node'; import http from 'http'; import gracefulShutdown from 'http-graceful-shutdown'; import { serializeError } from 'serialize-error'; @@ -10,6 +11,7 @@ import { connectDBWithRetry, mongooseConnection } from '@/models'; import opampApp from '@/opamp/app'; import { setupTeamDefaults } from '@/setupDefaults'; import logger from '@/utils/logger'; +import { runOnceAfterAll } from '@/utils/runOnceAfterAll'; import { verifySessionSecret } from '@/utils/sessionSecret'; import { verifyTokenEncryption } from '@/utils/tokenEncryption'; @@ -71,7 +73,14 @@ export default class Server { }); if (this.shouldHandleGracefulShutdown) { - [this.appServer, this.opampServer].forEach(server => { + const servers = [this.appServer, this.opampServer]; + // Each server's forceExit calls process.exit() once its own onShutdown + // settles, so both wait here: telemetry stops once, after the slower + // server has drained, and neither exits before then. + const shutdownTelemetryOnce = runOnceAfterAll(servers.length, () => + shutdownTelemetry(), + ); + servers.forEach(server => { gracefulShutdown(server, { signals: 'SIGINT SIGTERM', timeout: 10000, // 10 secs @@ -80,10 +89,19 @@ export default class Server { preShutdown: async () => { // needed operation before httpConnections are shutted down }, - onShutdown: this.shutdown, - finally: () => { - logger.info('Server gracefully shut down...'); - }, // finally function (sync) - e.g. for logging + onShutdown: async signal => { + try { + await this.shutdown(signal); + // Logged here rather than in the `finally` option, which runs + // after the SDK has stopped and so would not be exported. + logger.info('Server gracefully shut down...'); + } finally { + // forceExit calls process.exit(), which skips the SDK's own + // exit-time flush. Before init (no key set) this resolves at + // once. + await shutdownTelemetryOnce(); + } + }, }); }); } diff --git a/packages/api/src/tasks/__tests__/index.test.ts b/packages/api/src/tasks/__tests__/index.test.ts new file mode 100644 index 0000000000..68fe037151 --- /dev/null +++ b/packages/api/src/tasks/__tests__/index.test.ts @@ -0,0 +1,112 @@ +const mockShutdown = jest.fn, []>(); +const mockCronStop = jest.fn(); +const mockCronFrom = jest.fn((_options: unknown) => ({ stop: mockCronStop })); +const mockConfig = { + CODE_VERSION: 'test', + RUN_SCHEDULED_TASKS_EXTERNALLY: false, +}; + +jest.mock('@clickhouse/clickstack-node', () => ({ + shutdown: () => mockShutdown(), +})); +jest.mock('cron', () => ({ + CronJob: { from: (options: unknown) => mockCronFrom(options) }, +})); +jest.mock('@/config', () => mockConfig); +jest.mock('@/utils/logger', () => ({ + __esModule: true, + default: { info: jest.fn(), warn: jest.fn(), error: jest.fn() }, +})); +jest.mock('@/tasks/checkAlerts', () => ({ + __esModule: true, + default: jest.fn(), +})); +jest.mock('@/tasks/provisionDashboards', () => ({ + __esModule: true, + default: jest.fn(), +})); + +const flushPromises = () => new Promise(resolve => setImmediate(resolve)); + +describe('tasks entry point', () => { + const originalArgv = process.argv; + // Jest's process copy forwards exitCode to the real process. + const originalExitCode = process.exitCode; + let processOn: jest.SpyInstance; + let processExit: jest.SpyInstance; + let finishShutdown: () => void; + + const loadTasks = () => { + process.argv = ['node', 'tasks', 'ping-pong']; + jest.isolateModules(() => { + jest.requireActual('@/tasks/index'); + }); + }; + + const handlerFor = (event: string) => { + const call = processOn.mock.calls.find(([name]) => name === event); + if (!call) { + throw new Error(`No ${event} handler registered`); + } + return call[1]; + }; + + beforeEach(() => { + jest.clearAllMocks(); + mockShutdown.mockReturnValue( + new Promise(resolve => { + finishShutdown = resolve; + }), + ); + processOn = jest.spyOn(process, 'on').mockReturnValue(process); + processExit = jest.spyOn(process, 'exit').mockImplementation(); + jest.spyOn(console, 'log').mockImplementation(); + }); + + afterEach(() => { + jest.restoreAllMocks(); + process.argv = originalArgv; + process.exitCode = originalExitCode; + }); + + it('stops the cron job and shuts down once, exiting with the first code', async () => { + mockConfig.RUN_SCHEDULED_TASKS_EXTERNALLY = false; + loadTasks(); + expect(mockCronFrom).toHaveBeenCalledTimes(1); + + handlerFor('uncaughtException')(new Error('first')); + handlerFor('unhandledRejection')(new Error('second')); + handlerFor('uncaughtException')(new Error('third')); + + expect(mockCronStop).toHaveBeenCalledTimes(1); + expect(mockShutdown).toHaveBeenCalledTimes(1); + expect(mockCronStop.mock.invocationCallOrder[0]).toBeLessThan( + mockShutdown.mock.invocationCallOrder[0], + ); + expect(process.exitCode).toBe(1); + expect(processExit).not.toHaveBeenCalled(); + + finishShutdown(); + await flushPromises(); + + expect(processExit).toHaveBeenCalledTimes(1); + expect(processExit).toHaveBeenCalledWith(1); + }); + + it('keeps exit code 0 when a rejection arrives during the one-shot shutdown', async () => { + mockConfig.RUN_SCHEDULED_TASKS_EXTERNALLY = true; + loadTasks(); + await flushPromises(); + expect(mockCronFrom).not.toHaveBeenCalled(); + expect(mockShutdown).toHaveBeenCalledTimes(1); + + handlerFor('unhandledRejection')(new Error('late')); + expect(mockShutdown).toHaveBeenCalledTimes(1); + + finishShutdown(); + await flushPromises(); + + expect(processExit).toHaveBeenCalledTimes(1); + expect(processExit).toHaveBeenCalledWith(0); + }); +}); diff --git a/packages/api/src/tasks/__tests__/usageStats.test.ts b/packages/api/src/tasks/__tests__/usageStats.test.ts new file mode 100644 index 0000000000..7bcc32b568 --- /dev/null +++ b/packages/api/src/tasks/__tests__/usageStats.test.ts @@ -0,0 +1,135 @@ +import { context, ROOT_CONTEXT, trace, TraceFlags } from '@opentelemetry/api'; +import { SeverityNumber } from '@opentelemetry/api-logs'; +import os from 'os'; + +import { sendUsageStats } from '@/tasks/usageStats'; + +const USAGE_STATS_URL = 'https://in-otel.hyperdx.io/v1/logs'; +const USAGE_STATS_API_KEY = '3f26ffad-14cf-4fb7-9dc9-e64fa0b84ee0'; + +// jest.setup.ts replaces the global fetch with a jest.fn. +const mockFetch = jest.mocked(fetch); + +const sentRequest = async () => { + expect(mockFetch).toHaveBeenCalledTimes(1); + const [url, init] = mockFetch.mock.calls[0]; + return { url, init, body: await new Response(init?.body).json() }; +}; + +describe('sendUsageStats', () => { + const originalEnv = { ...process.env }; + + beforeAll(() => { + // Headers meant for the operator's collector, which must not reach + // HyperDX. + process.env.OTEL_EXPORTER_OTLP_HEADERS = + 'x-secret=1,Authorization=self-key'; + process.env.OTEL_EXPORTER_OTLP_LOGS_HEADERS = 'x-logs=2'; + }); + + beforeEach(() => { + mockFetch.mockReset(); + mockFetch.mockResolvedValue(new Response(null, { status: 200 })); + }); + + afterEach(() => { + jest.restoreAllMocks(); + }); + + afterAll(() => { + process.env = originalEnv; + }); + + it('posts one record to the usage stats endpoint with only its own key', async () => { + const timeoutSpy = jest.spyOn(AbortSignal, 'timeout'); + // A traced caller, so the record would pick up its span without an + // explicit context. + jest.spyOn(context, 'active').mockReturnValue( + trace.setSpanContext(ROOT_CONTEXT, { + traceId: '0af7651916cd43dd8448eb211c80319c', + spanId: 'b7ad6b7169203331', + traceFlags: TraceFlags.SAMPLED, + }), + ); + + await sendUsageStats({ + clusterId: 'cluster-1', + userCounts: 2, + chStats: { rows: 10 }, + }); + + const { url, init, body } = await sentRequest(); + expect(url).toBe(USAGE_STATS_URL); + expect(init?.method).toBe('POST'); + expect(init?.headers).toEqual({ + authorization: USAGE_STATS_API_KEY, + 'content-type': 'application/json', + }); + expect(timeoutSpy).toHaveBeenCalledWith(10_000); + + expect(body.resourceLogs).toHaveLength(1); + const [resourceLogs] = body.resourceLogs; + expect(resourceLogs.resource.attributes).toContainEqual({ + key: 'service.name', + value: { stringValue: 'hyperdx-oss-usage-stats' }, + }); + expect(resourceLogs.scopeLogs).toHaveLength(1); + const [scopeLogs] = resourceLogs.scopeLogs; + expect(scopeLogs.scope.name).toBe('node-logger'); + expect(scopeLogs.logRecords).toHaveLength(1); + const [record] = scopeLogs.logRecords; + expect(record.body).toEqual({ + stringValue: 'track-hyperdx-oss-usage-stats', + }); + expect(record.severityNumber).toBe(SeverityNumber.INFO); + expect(record.severityText).toBe('info'); + expect(record).not.toHaveProperty('traceId'); + expect(record).not.toHaveProperty('spanId'); + expect(record.attributes).toEqual([ + { key: 'clusterId', value: { stringValue: 'cluster-1' } }, + { key: 'userCounts', value: { intValue: 2 } }, + { + key: 'chStats', + value: { + kvlistValue: { values: [{ key: 'rows', value: { intValue: 10 } }] }, + }, + }, + { key: 'time', value: { intValue: expect.any(Number) } }, + { key: 'pid', value: { intValue: process.pid } }, + { key: 'hostname', value: { stringValue: os.hostname() } }, + ]); + }); + + it('sends NaN as null and drops undefined fields, as the pino records did', async () => { + await sendUsageStats({ + clusterId: undefined, + chStats: { avgDaySize: NaN, rows: 10 }, + }); + + const { body } = await sentRequest(); + const [record] = body.resourceLogs[0].scopeLogs[0].logRecords; + expect(record.attributes).not.toContainEqual( + expect.objectContaining({ key: 'clusterId' }), + ); + expect(record.attributes).toContainEqual({ + key: 'chStats', + value: { + kvlistValue: { + values: [ + // An empty AnyValue, which is how OTLP JSON carries null + { key: 'avgDaySize', value: {} }, + { key: 'rows', value: { intValue: 10 } }, + ], + }, + }, + }); + }); + + it('resolves when the request fails', async () => { + mockFetch.mockRejectedValue(new Error('connect ECONNREFUSED')); + await expect(sendUsageStats({ userCounts: 1 })).resolves.toBeUndefined(); + + mockFetch.mockResolvedValue(new Response(null, { status: 503 })); + await expect(sendUsageStats({ userCounts: 1 })).resolves.toBeUndefined(); + }); +}); diff --git a/packages/api/src/tasks/index.ts b/packages/api/src/tasks/index.ts index 10439f8fa7..99ead9a0ef 100644 --- a/packages/api/src/tasks/index.ts +++ b/packages/api/src/tasks/index.ts @@ -1,3 +1,4 @@ +import { shutdown } from '@clickhouse/clickstack-node'; import { CronJob } from 'cron'; import minimist from 'minimist'; import { serializeError } from 'serialize-error'; @@ -54,6 +55,27 @@ async function main(argv: TaskArgs): Promise { }); } +let cronJob: CronJob | undefined; +let exiting = false; + +// process.exit() skips the SDK's exit-time flush, so a one-shot task would +// drop its own span and duration metric. Before init shutdown() resolves at +// once. The first call decides the exit code: a later exception or rejection +// must not start a second shutdown or exit with another code. +const exitAfterShutdown = (code: number) => { + if (exiting) { + return; + } + exiting = true; + // Not awaited: with waitForCompletion it waits for the running tick, which + // may be the one that failed. + void cronJob?.stop(); + // The SDK's shutdown timer does not hold the event loop open, so the + // process can end on its own before process.exit() runs. + process.exitCode = code; + void shutdown().finally(() => process.exit(code)); +}; + // Entry point const argv = asTaskArgs(minimist(process.argv.slice(2))); @@ -69,7 +91,7 @@ const instrumentedMain = timeExec(main, duration => { if (!RUN_SCHEDULED_TASKS_EXTERNALLY) { logger.info('In-app cron job is enabled'); // run cron job every 1 minute - CronJob.from({ + cronJob = CronJob.from({ cronTime: '0 * * * * *', waitForCompletion: true, onTick: async () => instrumentedMain(argv), @@ -83,23 +105,23 @@ if (!RUN_SCHEDULED_TASKS_EXTERNALLY) { logger.warn('In-app cron job is disabled'); instrumentedMain(argv) .then(() => { - process.exit(0); + exitAfterShutdown(0); }) .catch(err => { console.log(err); logger.error({ err: serializeError(err) }, 'Task execution failed'); - process.exit(1); + exitAfterShutdown(1); }); } process.on('uncaughtException', (err: Error) => { console.log(err); logger.error({ err: serializeError(err) }, 'Uncaught exception'); - process.exit(1); + exitAfterShutdown(1); }); process.on('unhandledRejection', (err: any) => { console.log(err); logger.error({ err: serializeError(err) }, 'Unhandled rejection'); - process.exit(1); + exitAfterShutdown(1); }); diff --git a/packages/api/src/tasks/usageStats.ts b/packages/api/src/tasks/usageStats.ts index f226f24eae..451f0372f3 100644 --- a/packages/api/src/tasks/usageStats.ts +++ b/packages/api/src/tasks/usageStats.ts @@ -1,9 +1,25 @@ import { ResponseJSON } from '@hyperdx/common-utils/dist/clickhouse'; import { MetricsDataType, SourceKind } from '@hyperdx/common-utils/dist/types'; -import * as HyperDX from '@hyperdx/node-opentelemetry'; +import { context, ROOT_CONTEXT } from '@opentelemetry/api'; +import { type AnyValueMap, SeverityNumber } from '@opentelemetry/api-logs'; +import { + type ExportResult, + ExportResultCode, + suppressTracing, +} from '@opentelemetry/core'; +import { JsonLogsSerializer } from '@opentelemetry/otlp-transformer'; +import { + defaultResource, + resourceFromAttributes, +} from '@opentelemetry/resources'; +import { + BatchLogRecordProcessor, + LoggerProvider, + type LogRecordExporter, + type ReadableLogRecord, +} from '@opentelemetry/sdk-logs'; import ms from 'ms'; import os from 'os'; -import pino from 'pino'; import { ClickhouseClient } from '@/clickhouse'; import * as config from '@/config'; @@ -12,30 +28,108 @@ import { Source, SourceDocument } from '@/models/source'; import Team from '@/models/team'; import User from '@/models/user'; -// Lazily construct the pino logger so the thread-stream worker isn't spawned -// at module-load time. Importing this file (e.g. via api-app.ts during tests) -// would otherwise create a worker thread that keeps Jest from exiting cleanly. -// The logger is only instantiated when usage stats are actually reported, -// which is gated by USAGE_STATS_ENABLED && !IS_CI in api-app.ts. -let usageStatsLogger: pino.Logger | null = null; -function getUsageStatsLogger(): pino.Logger { - if (!usageStatsLogger) { - usageStatsLogger = pino({ - level: 'info', - transport: { - targets: [ - HyperDX.getPinoTransport('info', { - headers: { - Authorization: '3f26ffad-14cf-4fb7-9dc9-e64fa0b84ee0', // hyperdx usage stats service api key - }, - baseUrl: 'https://in-otel.hyperdx.io/v1/logs', - service: 'hyperdx-oss-usage-stats', - }), - ], +const USAGE_STATS_SERVICE_NAME = 'hyperdx-oss-usage-stats'; +const USAGE_STATS_URL = 'https://in-otel.hyperdx.io/v1/logs'; +const USAGE_STATS_API_KEY = '3f26ffad-14cf-4fb7-9dc9-e64fa0b84ee0'; // hyperdx usage stats service api key +const USAGE_STATS_TIMEOUT_MS = ms('10s'); + +async function postUsageStats( + logs: ReadableLogRecord[], +): Promise { + try { + const payload = JsonLogsSerializer.serializeRequest(logs); + const response = await fetch(USAGE_STATS_URL, { + method: 'POST', + headers: { + authorization: USAGE_STATS_API_KEY, + 'content-type': 'application/json', }, + // Copied because fetch's types accept only ArrayBuffer-backed views. + body: payload && new Uint8Array(payload), + signal: AbortSignal.timeout(USAGE_STATS_TIMEOUT_MS), }); + // An unread body holds the connection until garbage collection. + await response.body?.cancel(); + if (!response.ok) { + return { + code: ExportResultCode.FAILED, + error: new Error(`Usage stats export failed: HTTP ${response.status}`), + }; + } + return { code: ExportResultCode.SUCCESS }; + } catch (e) { + return { + code: ExportResultCode.FAILED, + error: e instanceof Error ? e : new Error(String(e)), + }; + } +} + +// Not OTLPLogExporter: it merges the OTEL_EXPORTER_OTLP_*HEADERS variables +// into every request, which would send headers meant for the operator's +// collector, such as its API keys, to HyperDX. +class UsageStatsExporter implements LogRecordExporter { + export( + logs: ReadableLogRecord[], + resultCallback: (result: ExportResult) => void, + ): void { + // The batch processor already suppresses tracing around export(). Doing it + // here as well keeps that true if the processor changes, and ROOT_CONTEXT + // keeps the caller's span and baggage out of the request. + void context + .with(suppressTracing(ROOT_CONTEXT), () => postUsageStats(logs)) + .then(resultCallback); } - return usageStatsLogger; + + async forceFlush(): Promise {} + + async shutdown(): Promise {} +} + +// A provider of its own, not the global one: usage stats go to HyperDX with +// their own key and never to the operator's collector. Created on the first +// report, which api-app.ts gates on USAGE_STATS_ENABLED && !IS_CI, so +// importing this module sets nothing up. +let usageStatsProvider: LoggerProvider | null = null; +function getUsageStatsProvider(): LoggerProvider { + if (!usageStatsProvider) { + usageStatsProvider = new LoggerProvider({ + resource: defaultResource().merge( + resourceFromAttributes({ 'service.name': USAGE_STATS_SERVICE_NAME }), + ), + processors: [ + new BatchLogRecordProcessor({ exporter: new UsageStatsExporter() }), + ], + }); + } + return usageStatsProvider; +} + +export async function sendUsageStats(fields: AnyValueMap): Promise { + const provider = getUsageStatsProvider(); + const time = Date.now(); + // The pino records this replaced went through JSON, which turned NaN (from + // parseInt on a null ClickHouse value) into null and dropped undefined + // fields. The OTLP JSON encoder writes NaN as a null doubleValue instead, + // which the collector rejects along with the whole report. + const jsonFields: AnyValueMap = JSON.parse(JSON.stringify(fields)); + // The scope name of the pino records this replaced. + provider.getLogger('node-logger').emit({ + body: 'track-hyperdx-oss-usage-stats', + severityNumber: SeverityNumber.INFO, + severityText: 'info', + timestamp: time, + // HyperDX never sees this deployment's traces, so do not link to them. + context: ROOT_CONTEXT, + // The pino records this replaced carried time, pid and hostname. + attributes: { + ...jsonFields, + time, + pid: process.pid, + hostname: os.hostname(), + }, + }); + await provider.forceFlush(); } function extractTableNames(source: SourceDocument): string[] { @@ -143,39 +237,36 @@ async function getUsageStats() { getClickhouseTableSize(), ]); const clusterId = team[0]?._id.toString(); - getUsageStatsLogger().info( - { - clusterId, - version: config.CODE_VERSION, - userCounts, - os: { - arch: os.arch(), - freemem: os.freemem(), - uptime: os.uptime(), - }, - chStats: { - tables: chTables.reduce( - (acc, curr) => ({ - ...acc, - [curr.table]: { - avgDaySize: parseInt(curr.avgDaySize), - days: parseInt(curr.days), - lastModified: new Date(curr.latestModification).getTime(), - maxTime: new Date(curr.max_time).getTime(), - minTime: new Date(curr.min_time).getTime(), - rows: parseInt(curr.rows), - size: parseInt(curr.size), - }, - }), - {}, - ), - rows: chTables.reduce((acc, curr) => acc + parseInt(curr.rows), 0), - size: chTables.reduce((acc, curr) => acc + parseInt(curr.size), 0), - }, - timestamp: nowInMs, + await sendUsageStats({ + clusterId, + version: config.CODE_VERSION, + userCounts, + os: { + arch: os.arch(), + freemem: os.freemem(), + uptime: os.uptime(), }, - 'track-hyperdx-oss-usage-stats', - ); + chStats: { + tables: chTables.reduce( + (acc, curr) => ({ + ...acc, + [curr.table]: { + avgDaySize: parseInt(curr.avgDaySize), + days: parseInt(curr.days), + lastModified: new Date(curr.latestModification).getTime(), + maxTime: new Date(curr.max_time).getTime(), + minTime: new Date(curr.min_time).getTime(), + rows: parseInt(curr.rows), + size: parseInt(curr.size), + }, + }), + {}, + ), + rows: chTables.reduce((acc, curr) => acc + parseInt(curr.rows), 0), + size: chTables.reduce((acc, curr) => acc + parseInt(curr.size), 0), + }, + timestamp: nowInMs, + }); } catch { // ignore } diff --git a/packages/api/src/telemetry.ts b/packages/api/src/telemetry.ts new file mode 100644 index 0000000000..e7e05032e1 --- /dev/null +++ b/packages/api/src/telemetry.ts @@ -0,0 +1,38 @@ +/** + * Self-telemetry preload, loaded with `-r` ahead of the API and the task + * runner (bin/hyperdx, the dev scripts, the e2e web server). + * + * This wraps the ClickStack SDK instead of preloading its `register` entry + * because the SDK never reads HYPERDX_API_KEY, and it would start without a + * key and send to localhost:4318. decideSelfTelemetry keeps the old HyperDX + * SDK's key handling and start condition, shared with the Next.js server. + * + * It imports nothing from the app, and from common-utils only a module without + * dependencies: modules loaded before init() are not instrumented. + */ +import { isMainThread } from 'node:worker_threads'; + +import { init } from '@clickhouse/clickstack-node'; +import { decideSelfTelemetry } from '@hyperdx/common-utils/dist/selfTelemetry'; + +const telemetry = decideSelfTelemetry(process.env); + +// `-r` preloads also run in worker threads, such as the pino transport, and +// init() in a worker starts a second SDK there. +if (isMainThread && telemetry.start) { + if (telemetry.otlpHeaders !== undefined) { + process.env.OTEL_EXPORTER_OTLP_HEADERS = telemetry.otlpHeaders; + } + init({ + apiKey: telemetry.apiKey, + // Only set in development, where host metrics were collected before. It + // applies to every process this preloads, so the dev API and the dev task + // runner both report them. An explicit `enabled` value would override the + // operator's OTEL_NODE_ENABLED_INSTRUMENTATIONS and _DISABLED_ lists + // elsewhere. + instrumentations: + process.env.NODE_ENV === 'development' + ? { '@opentelemetry/instrumentation-host-metrics': { enabled: true } } + : undefined, + }); +} diff --git a/packages/api/src/utils/__tests__/instrumentation.test.ts b/packages/api/src/utils/__tests__/instrumentation.test.ts index 369d090002..312d7e17f0 100644 --- a/packages/api/src/utils/__tests__/instrumentation.test.ts +++ b/packages/api/src/utils/__tests__/instrumentation.test.ts @@ -1,4 +1,4 @@ -// Mock OpenTelemetry + the HyperDX SDK before importing the module under test. +// Mock OpenTelemetry before importing the module under test. const mockSpan = { setAttribute: jest.fn(), @@ -8,6 +8,11 @@ const mockSpan = { end: jest.fn(), }; +const mockServerSpan = { + setAttributes: jest.fn(), + isRecording: jest.fn(() => true), +}; + const mockTracer = { startActiveSpan: ( _name: string, @@ -23,11 +28,15 @@ const mockMeter = { createHistogram: jest.fn(() => mockHistogram), }; -const mockSetTraceAttributes = jest.fn(); +const mockActiveContext = {}; +const mockGetRPCMetadata = jest.fn(); jest.mock('@opentelemetry/api', () => ({ __esModule: true, default: { + context: { + active: () => mockActiveContext, + }, trace: { getTracer: () => mockTracer, getActiveSpan: () => mockSpan, @@ -40,9 +49,8 @@ jest.mock('@opentelemetry/api', () => ({ SpanKind: { INTERNAL: 0, SERVER: 1, CLIENT: 2, PRODUCER: 3, CONSUMER: 4 }, })); -jest.mock('@hyperdx/node-opentelemetry', () => ({ - __esModule: true, - setTraceAttributes: (...args: unknown[]) => mockSetTraceAttributes(...args), +jest.mock('@opentelemetry/core', () => ({ + getRPCMetadata: (...args: unknown[]) => mockGetRPCMetadata(...args), })); jest.mock('@/config', () => ({ @@ -109,40 +117,76 @@ describe('instrumentation', () => { }); describe('setBusinessContext', () => { - it('maps team/user/email to standardized keys on trace and span', () => { + const expected = { + 'hyperdx.team.id': 'team-1', + 'user.id': 'user-1', + 'user.email': 'a@b.com', + }; + + it('maps team/user/email to standardized keys on the active and server spans', () => { + mockGetRPCMetadata.mockReturnValue({ span: mockServerSpan }); + setBusinessContext({ teamId: 'team-1', userId: 'user-1', email: 'a@b.com', }); - const expected = { - 'hyperdx.team.id': 'team-1', - 'user.id': 'user-1', - 'user.email': 'a@b.com', - }; - expect(mockSetTraceAttributes).toHaveBeenCalledWith(expected); + expect(mockGetRPCMetadata).toHaveBeenCalledWith(mockActiveContext); expect(mockSpan.setAttributes).toHaveBeenCalledWith(expected); + expect(mockServerSpan.setAttributes).toHaveBeenCalledWith(expected); + }); + + it('sets the attributes once when the server span is the active span', () => { + mockGetRPCMetadata.mockReturnValue({ span: mockSpan }); + + setBusinessContext({ teamId: 'team-1' }); + + expect(mockSpan.setAttributes).toHaveBeenCalledTimes(1); + }); + + it('sets only the active span outside an HTTP request', () => { + mockGetRPCMetadata.mockReturnValue(undefined); + + setBusinessContext({ teamId: 'team-1' }); + + expect(mockSpan.setAttributes).toHaveBeenCalledWith({ + 'hyperdx.team.id': 'team-1', + }); + expect(mockServerSpan.setAttributes).not.toHaveBeenCalled(); + }); + + it('skips a server span that has already ended', () => { + mockGetRPCMetadata.mockReturnValue({ span: mockServerSpan }); + mockServerSpan.isRecording.mockReturnValueOnce(false); + + setBusinessContext({ teamId: 'team-1' }); + + expect(mockServerSpan.setAttributes).not.toHaveBeenCalled(); }); it('passes through extra attributes and skips nullish values', () => { + mockGetRPCMetadata.mockReturnValue({ span: mockServerSpan }); + setBusinessContext({ teamId: 'team-1', userId: null, 'feature_flag.local_app_mode': true, }); - expect(mockSetTraceAttributes).toHaveBeenCalledWith({ + expect(mockServerSpan.setAttributes).toHaveBeenCalledWith({ 'hyperdx.team.id': 'team-1', 'feature_flag.local_app_mode': true, }); }); it('is a no-op when there is nothing to set', () => { + mockGetRPCMetadata.mockReturnValue({ span: mockServerSpan }); + setBusinessContext({}); - expect(mockSetTraceAttributes).not.toHaveBeenCalled(); expect(mockSpan.setAttributes).not.toHaveBeenCalled(); + expect(mockServerSpan.setAttributes).not.toHaveBeenCalled(); }); }); diff --git a/packages/api/src/utils/__tests__/runOnceAfterAll.test.ts b/packages/api/src/utils/__tests__/runOnceAfterAll.test.ts new file mode 100644 index 0000000000..8887982c19 --- /dev/null +++ b/packages/api/src/utils/__tests__/runOnceAfterAll.test.ts @@ -0,0 +1,47 @@ +import { runOnceAfterAll } from '@/utils/runOnceAfterAll'; + +const flushPromises = () => new Promise(resolve => setImmediate(resolve)); + +describe('runOnceAfterAll', () => { + it('runs once, after the last caller arrives', async () => { + const fn = jest.fn(async () => {}); + const arrive = runOnceAfterAll(2, fn); + + let firstSettled = false; + const first = arrive().then(() => { + firstSettled = true; + }); + await flushPromises(); + expect(fn).not.toHaveBeenCalled(); + expect(firstSettled).toBe(false); + + await Promise.all([first, arrive()]); + expect(fn).toHaveBeenCalledTimes(1); + + await arrive(); + expect(fn).toHaveBeenCalledTimes(1); + }); + + it('settles every caller only when fn settles', async () => { + let finish = () => {}; + const arrive = runOnceAfterAll( + 2, + () => + new Promise(resolve => { + finish = resolve; + }), + ); + + const settled: string[] = []; + const callers = [ + arrive().then(() => settled.push('app')), + arrive().then(() => settled.push('opamp')), + ]; + await flushPromises(); + expect(settled).toEqual([]); + + finish(); + await Promise.all(callers); + expect(settled).toEqual(['app', 'opamp']); + }); +}); diff --git a/packages/api/src/utils/instrumentation.ts b/packages/api/src/utils/instrumentation.ts index 096bb2dc5a..39e8e3ff09 100644 --- a/packages/api/src/utils/instrumentation.ts +++ b/packages/api/src/utils/instrumentation.ts @@ -1,4 +1,3 @@ -import { setTraceAttributes } from '@hyperdx/node-opentelemetry'; import opentelemetry, { Attributes, AttributeValue, @@ -9,6 +8,7 @@ import opentelemetry, { SpanKind, SpanStatusCode, } from '@opentelemetry/api'; +import { getRPCMetadata } from '@opentelemetry/core'; import { performance } from 'perf_hooks'; import { @@ -103,16 +103,19 @@ export type BusinessContext = { }; /** - * Attaches incident-remediation context to the whole trace (via the HyperDX - * SDK) and to the active span. Standardizes the attribute keys so team/user + * Attaches incident-remediation context to the active span and to the + * request's HTTP server span. Standardizes the attribute keys so team/user * context is consistent across every code path. * + * The server span covers the whole request. The Express instrumentation makes + * each middleware and route span active while it runs, so in middleware the + * active span alone is a short-lived child. Other spans of the trace do not + * get these attributes. + * * User attributes follow the OTel `user.*` semantic conventions (currently * experimental). Team has no OTel equivalent, so it stays under the `hyperdx.*` - * namespace. Note these are the server-side API trace attributes and are - * distinct from the browser-RUM session attributes (`userEmail`, `userName`). - * - * NOTE: trace-wide attributes require `HDX_NODE_BETA_MODE=1`. + * namespace. The browser SDK's setUser (AppNav.tsx) records the same `user.*` + * keys on RUM telemetry. */ export function setBusinessContext(context: BusinessContext): void { const { teamId, userId, email, ...extra } = context; @@ -137,8 +140,15 @@ export function setBusinessContext(context: BusinessContext): void { return; } - setTraceAttributes(attributes); - opentelemetry.trace.getActiveSpan()?.setAttributes(attributes); + const activeSpan = opentelemetry.trace.getActiveSpan(); + activeSpan?.setAttributes(attributes); + + // The HTTP instrumentation keeps the server span in the request context's + // RPC metadata. There is none outside a request, as in scheduled tasks. + const serverSpan = getRPCMetadata(opentelemetry.context.active())?.span; + if (serverSpan && serverSpan !== activeSpan && serverSpan.isRecording()) { + serverSpan.setAttributes(attributes); + } } /** diff --git a/packages/api/src/utils/logger.ts b/packages/api/src/utils/logger.ts index 162005d667..22f4238e8b 100644 --- a/packages/api/src/utils/logger.ts +++ b/packages/api/src/utils/logger.ts @@ -1,7 +1,3 @@ -import { - getPinoMixinFunction, - getPinoTransport, -} from '@hyperdx/node-opentelemetry'; import type { Request, Response } from 'express'; import pino from 'pino'; import pinoHttp from 'pino-http'; @@ -10,54 +6,29 @@ import * as config from '@/config'; const MAX_LEVEL = config.HYPERDX_LOG_LEVEL || 'info'; -const hyperdxTransport = config.HYPERDX_API_KEY - ? getPinoTransport(MAX_LEVEL, { - detectResources: true, - }) - : null; - -// Configure transport based on environment and whether HyperDX is enabled -const getTransport = () => { - const targets: any[] = []; - - // Add HyperDX transport if API key is configured - if (hyperdxTransport) { - targets.push(hyperdxTransport); - } - - if (config.IS_DEV || config.IS_CI) { - // In development, use pino-pretty for nice console output - targets.push({ - target: 'pino-pretty', - level: MAX_LEVEL, - options: { - colorize: true, - translateTime: 'SYS:standard', - ignore: 'pid,hostname,trace_id,span_id,trace_flags', - }, - }); - } else { - targets.push({ - target: 'pino/file', - level: MAX_LEVEL, - options: { destination: 1 }, // this writes to STDOUT - }); - } - - // If only one target, return it directly; otherwise return multi-transport - if (targets.length === 0) { - return undefined; - } else if (targets.length === 1) { - return targets[0]; - } else { - return { targets }; - } -}; +// Only the local output. When the SDK is running, its pino instrumentation +// exports every record and adds trace_id, span_id and trace_flags to it. +const transport: pino.TransportSingleOptions = + config.IS_DEV || config.IS_CI + ? { + // In development, use pino-pretty for nice console output + target: 'pino-pretty', + options: { + colorize: true, + translateTime: 'SYS:standard', + ignore: 'pid,hostname,trace_id,span_id,trace_flags', + }, + } + : { + target: 'pino/file', + options: { destination: 1 }, // this writes to STDOUT + }; // pino-http's default request serializer copies `req.headers` verbatim, and // in production the serializers below are left enabled, so without this the // Authorization bearer and session cookie are written to stdout and shipped -// off-box via the HyperDX transport. +// off-box by the SDK's pino instrumentation, which exports the redacted +// record. export const REDACTED_PATHS = [ 'req.headers.authorization', 'req.headers.cookie', @@ -114,8 +85,7 @@ export function selectRequestSerializers(isDevOrCi: boolean): { const logger = pino({ level: MAX_LEVEL, - transport: getTransport(), - mixin: getPinoMixinFunction, + transport, redact: { paths: REDACTED_PATHS, censor: '[REDACTED]' }, }); diff --git a/packages/api/src/utils/runOnceAfterAll.ts b/packages/api/src/utils/runOnceAfterAll.ts new file mode 100644 index 0000000000..da2b311618 --- /dev/null +++ b/packages/api/src/utils/runOnceAfterAll.ts @@ -0,0 +1,23 @@ +/** + * Returns a function that each of `count` callers calls and awaits. `fn` runs + * once, after the last of them has called it, and every caller's promise + * settles when `fn` does. + */ +export function runOnceAfterAll( + count: number, + fn: () => Promise, +): () => Promise { + let arrived = 0; + let release = () => {}; + const allArrived = new Promise(resolve => { + release = resolve; + }); + const done = allArrived.then(fn); + return () => { + arrived += 1; + if (arrived >= count) { + release(); + } + return done; + }; +} diff --git a/packages/app/Dockerfile b/packages/app/Dockerfile index 22f98b0c61..8f371d86ca 100644 --- a/packages/app/Dockerfile +++ b/packages/app/Dockerfile @@ -60,6 +60,8 @@ COPY ./packages/app/pages ./packages/app/pages COPY ./packages/app/public ./packages/app/public COPY ./packages/app/styles ./packages/app/styles COPY ./packages/app/types ./packages/app/types +# next build finds instrumentation.ts only next to pages/, not under src/ +COPY ./packages/app/instrumentation.ts ./packages/app/instrumentation-client.ts ./packages/app/ # Build inputs for public/whats-new.json, generated by next.config.mjs for the # in-app "What's new" section: the root changelog it parses (next.config resolves # it as /app/packages/app/../../CHANGELOG.md) and the parser itself. The build diff --git a/packages/app/instrumentation-client.ts b/packages/app/instrumentation-client.ts new file mode 100644 index 0000000000..180d51fcbe --- /dev/null +++ b/packages/app/instrumentation-client.ts @@ -0,0 +1,33 @@ +import { env } from 'next-runtime-env'; +import { init } from '@clickhouse/clickstack-browser'; + +import { IS_LOCAL_MODE } from '@/config'; +import type { NextApiConfigResponseData } from '@/types'; +import { getBrowserInitOptions } from '@/utils/browserTelemetry'; + +// Next.js runs this file once per page load, before hydration. The collector +// settings come from /api/config at request time so they can change without a +// rebuild, which is why init waits for the fetch. +function startBrowserTelemetry(config: NextApiConfigResponseData | undefined) { + if (!config?.apiKey) { + console.warn('No API key found to enable OTEL exporter'); + return; + } + + init( + getBrowserInitOptions({ + config, + resourceAttributes: env('NEXT_PUBLIC_OTEL_RESOURCE_ATTRIBUTES') ?? '', + serviceVersion: process.env.NEXT_PUBLIC_APP_VERSION, + }), + ); +} + +if (!IS_LOCAL_MODE) { + fetch('/api/config') + .then(res => res.json()) + .then(startBrowserTelemetry) + .catch(() => { + // Telemetry is optional, so a failed config fetch must not surface + }); +} diff --git a/packages/app/instrumentation.ts b/packages/app/instrumentation.ts new file mode 100644 index 0000000000..4b48483153 --- /dev/null +++ b/packages/app/instrumentation.ts @@ -0,0 +1,11 @@ +// This file sits next to pages/ because next build looks for it only there, +// not in src/. The Dockerfiles copy it (and instrumentation-client.ts) by name. +export async function register() { + // The edge build drops this branch, so it never bundles the Node.js SDK + if (process.env.NEXT_RUNTIME === 'nodejs') { + const { startNextServerTelemetry } = await import( + '@/utils/nextServerTelemetry' + ); + await startNextServerTelemetry(); + } +} diff --git a/packages/app/jest.config.js b/packages/app/jest.config.js index c9b6a4a561..4ef891f96d 100644 --- a/packages/app/jest.config.js +++ b/packages/app/jest.config.js @@ -27,6 +27,8 @@ module.exports = { '^remark-gfm$': '/src/__mocks__/remark-gfm.ts', '^react-syntax-highlighter$': '/src/__mocks__/react-syntax-highlighter.tsx', + '^@clickhouse/clickstack-browser$': + '/src/__mocks__/clickstack-browser.ts', // @clickhouse/click-ui depends on ESM-only lodash-es; lodash has the same API. '^lodash-es$': 'lodash', '^lodash-es/(.*)$': 'lodash/$1', diff --git a/packages/app/next.config.mjs b/packages/app/next.config.mjs index 849eae6ba0..27af08398d 100644 --- a/packages/app/next.config.mjs +++ b/packages/app/next.config.mjs @@ -111,8 +111,7 @@ const nextConfig = { '@opentelemetry/instrumentation', '@opentelemetry/sdk-node', '@opentelemetry/auto-instrumentations-node', - '@hyperdx/node-opentelemetry', - '@hyperdx/instrumentation-sentry-node', + '@clickhouse/clickstack-node', // Outside of Vercel preview deployments, the `/api/[...all]` catch-all // proxies to a separately-deployed API service and never imports the // `@hyperdx/api` package at runtime. Mark it (and its subpaths) as a diff --git a/packages/app/package.json b/packages/app/package.json index d2fb34b072..829742797e 100644 --- a/packages/app/package.json +++ b/packages/app/package.json @@ -27,6 +27,8 @@ }, "dependencies": { "@clickhouse/click-ui": "^0.12.0", + "@clickhouse/clickstack-browser": "^1.2.0", + "@clickhouse/clickstack-node": "^1.0.2", "@codemirror/autocomplete": "^6.0.0", "@codemirror/lang-json": "^6.0.1", "@codemirror/lang-sql": "^6.7.0", @@ -38,9 +40,7 @@ "@dnd-kit/utilities": "^3.2.2", "@hookform/resolvers": "^3.9.0", "@hyperdx/api": "workspace:*", - "@hyperdx/browser": "^0.22.1", "@hyperdx/common-utils": "^0.33.0", - "@hyperdx/node-opentelemetry": "^0.9.0", "@mantine/core": "^9.0.0", "@mantine/dates": "^9.0.0", "@mantine/dropzone": "^9.0.0", @@ -48,6 +48,8 @@ "@mantine/hooks": "^9.0.0", "@mantine/notifications": "^9.0.0", "@mantine/spotlight": "^9.0.0", + "@opentelemetry/api": "~1.9.1", + "@opentelemetry/browser-sdk": "^0.6.0", "@prometheus-io/codemirror-promql": "^0.311.3", "@rrweb/replay": "2.1.1", "@tabler/icons-react": "^3.39.0", diff --git a/packages/app/pages/_app.tsx b/packages/app/pages/_app.tsx index 14382f4b13..54c437f8b0 100644 --- a/packages/app/pages/_app.tsx +++ b/packages/app/pages/_app.tsx @@ -2,10 +2,8 @@ import React, { useEffect } from 'react'; import type { NextPage } from 'next'; import type { AppProps } from 'next/app'; import Head from 'next/head'; -import { env } from 'next-runtime-env'; import randomUUID from 'crypto-randomuuid'; import { enableMapSet } from 'immer'; -import HyperDX from '@hyperdx/browser'; import { MutationCache, QueryCache, @@ -15,12 +13,10 @@ import { import { ReactQueryDevtools } from '@tanstack/react-query-devtools'; import { usePageTitle } from '@/brand'; -import { IS_LOCAL_MODE, parseResourceAttributes } from '@/config'; import { MANTINE_FONT_MAP } from '@/config/fonts'; import { ibmPlexMono, inter, roboto, robotoMono } from '@/fonts'; import { fetchServerVersion, installHdxDebug } from '@/hdxDebug'; import { ThemeWrapper } from '@/ThemeWrapper'; -import { NextApiConfigResponseData } from '@/types'; import { ConfirmProvider } from '@/useConfirm'; import { SystemColorSchemeScript, @@ -124,45 +120,6 @@ export default function MyApp({ Component, pageProps }: AppPropsWithLayout) { fetchServerVersion(); }, []); - // port to react query ? (needs to wrap with QueryClientProvider) - useEffect(() => { - if (IS_LOCAL_MODE) { - return; - } - fetch('/api/config') - .then(res => res.json()) - .then((_jsonData?: NextApiConfigResponseData) => { - if (_jsonData?.apiKey) { - const frontendAttrs = parseResourceAttributes( - env('NEXT_PUBLIC_OTEL_RESOURCE_ATTRIBUTES') ?? '', - ); - HyperDX.init({ - apiKey: _jsonData.apiKey, - consoleCapture: true, - maskAllInputs: true, - maskAllText: true, - // service.version is applied last so it always reflects the - // NEXT_PUBLIC_APP_VERSION and cannot be overridden by - // NEXT_PUBLIC_OTEL_RESOURCE_ATTRIBUTES. - otelResourceAttributes: { - ...frontendAttrs, - 'service.version': process.env.NEXT_PUBLIC_APP_VERSION, - }, - service: _jsonData.serviceName, - // tracePropagationTargets: [new RegExp(hostname ?? 'localhost', 'i')], - url: _jsonData.collectorUrl, - tracesUrl: _jsonData.collectorTracesUrl, - logsUrl: _jsonData.collectorLogsUrl, - }); - } else { - console.warn('No API key found to enable OTEL exporter'); - } - }) - .catch(() => { - // ignore - }); - }, []); - useEffect(() => { // Apply font classes to html so next/font CSS variables resolve. // _document.tsx sets these server-side; re-apply on the client so diff --git a/packages/app/playwright.config.ts b/packages/app/playwright.config.ts index a0cd862caf..ac4064c71a 100644 --- a/packages/app/playwright.config.ts +++ b/packages/app/playwright.config.ts @@ -12,6 +12,11 @@ const API_PORT = process.env.HDX_E2E_API_PORT || '21000'; const APP_PORT = process.env.HDX_E2E_APP_PORT || '21300'; const APP_LOCAL_PORT = process.env.HDX_E2E_APP_LOCAL_PORT || '21200'; +// next dev loads .env.development, which sets HYPERDX_API_KEY, so without this the +// e2e Next server and browser export HyperDX's own telemetry to collector ports that +// do not exist in e2e. The failed exports add retries and load to parallel runs. +const NO_SELF_TELEMETRY = 'HDX_EXPORTER_ENABLED=false'; + // Timeout configuration constants (in milliseconds) const TEST_TIMEOUT_MS = 60 * 1000; // 60 seconds per test const API_SERVER_STARTUP_TIMEOUT_MS = 120 * 1000; // 2 minutes for API to start @@ -95,7 +100,7 @@ export default defineConfig({ // Full-stack mode: Start API and App servers (infrastructure started separately) { // Connections/sources come from env (injected by run-e2e.js from e2e-fixtures.json) - command: `cd ../api && ${process.env.MONGO_URI ? `MONGO_URI="${process.env.MONGO_URI}"` : ''} DOTENV_CONFIG_PATH=.env.e2e npx ts-node --transpile-only -r tsconfig-paths/register -r dotenv-expand/config -r @hyperdx/node-opentelemetry/build/src/tracing src/index.ts`, + command: `cd ../api && ${process.env.MONGO_URI ? `MONGO_URI="${process.env.MONGO_URI}"` : ''} DOTENV_CONFIG_PATH=.env.e2e npx ts-node --transpile-only -r tsconfig-paths/register -r dotenv-expand/config -r ./src/telemetry.ts src/index.ts`, port: parseInt(API_PORT, 10), reuseExistingServer: !process.env.CI, timeout: API_SERVER_STARTUP_TIMEOUT_MS, @@ -105,8 +110,8 @@ export default defineConfig({ { // Full UI: Alerts + Dashboards. Not local mode; Alerts enabled; command: USE_DEV - ? `SERVER_URL=http://localhost:${API_PORT} PORT=${APP_PORT} NEXT_DIST_DIR=.next-e2e NEXT_PUBLIC_ENABLE_ALERT_DETAILS=true NEXT_PUBLIC_ENABLE_PROMQL=true NEXT_PUBLIC_ENABLE_ADHOC_FILTERS=true next dev --webpack` - : `SERVER_URL=http://localhost:${API_PORT} PORT=${APP_PORT} NEXT_DIST_DIR=.next-e2e NEXT_PUBLIC_ENABLE_ALERT_DETAILS=true NEXT_PUBLIC_ENABLE_PROMQL=true NEXT_PUBLIC_ENABLE_ADHOC_FILTERS=true yarn build && SERVER_URL=http://localhost:${API_PORT} PORT=${APP_PORT} NEXT_DIST_DIR=.next-e2e NEXT_PUBLIC_ENABLE_ALERT_DETAILS=true NEXT_PUBLIC_ENABLE_PROMQL=true NEXT_PUBLIC_ENABLE_ADHOC_FILTERS=true yarn start`, + ? `${NO_SELF_TELEMETRY} SERVER_URL=http://localhost:${API_PORT} PORT=${APP_PORT} NEXT_DIST_DIR=.next-e2e NEXT_PUBLIC_ENABLE_ALERT_DETAILS=true NEXT_PUBLIC_ENABLE_PROMQL=true NEXT_PUBLIC_ENABLE_ADHOC_FILTERS=true next dev --webpack` + : `${NO_SELF_TELEMETRY} SERVER_URL=http://localhost:${API_PORT} PORT=${APP_PORT} NEXT_DIST_DIR=.next-e2e NEXT_PUBLIC_ENABLE_ALERT_DETAILS=true NEXT_PUBLIC_ENABLE_PROMQL=true NEXT_PUBLIC_ENABLE_ADHOC_FILTERS=true yarn build && ${NO_SELF_TELEMETRY} SERVER_URL=http://localhost:${API_PORT} PORT=${APP_PORT} NEXT_DIST_DIR=.next-e2e NEXT_PUBLIC_ENABLE_ALERT_DETAILS=true NEXT_PUBLIC_ENABLE_PROMQL=true NEXT_PUBLIC_ENABLE_ADHOC_FILTERS=true yarn start`, port: parseInt(APP_PORT, 10), reuseExistingServer: !process.env.CI, timeout: APP_SERVER_STARTUP_TIMEOUT_MS, @@ -117,8 +122,8 @@ export default defineConfig({ : { // Local mode: Frontend only command: USE_DEV - ? `NEXT_PUBLIC_IS_LOCAL_MODE=true PORT=${APP_LOCAL_PORT} NEXT_DIST_DIR=.next-e2e next dev --webpack` - : `NEXT_PUBLIC_IS_LOCAL_MODE=true NEXT_DIST_DIR=.next-e2e yarn build && NEXT_PUBLIC_IS_LOCAL_MODE=true PORT=${APP_LOCAL_PORT} NEXT_DIST_DIR=.next-e2e yarn start`, + ? `${NO_SELF_TELEMETRY} NEXT_PUBLIC_IS_LOCAL_MODE=true PORT=${APP_LOCAL_PORT} NEXT_DIST_DIR=.next-e2e next dev --webpack` + : `${NO_SELF_TELEMETRY} NEXT_PUBLIC_IS_LOCAL_MODE=true NEXT_DIST_DIR=.next-e2e yarn build && ${NO_SELF_TELEMETRY} NEXT_PUBLIC_IS_LOCAL_MODE=true PORT=${APP_LOCAL_PORT} NEXT_DIST_DIR=.next-e2e yarn start`, port: parseInt(APP_LOCAL_PORT, 10), reuseExistingServer: !process.env.CI, timeout: APP_SERVER_STARTUP_TIMEOUT_MS, diff --git a/packages/app/src/DBSearchPage.tsx b/packages/app/src/DBSearchPage.tsx index 4466eadd8c..2a90cae9c6 100644 --- a/packages/app/src/DBSearchPage.tsx +++ b/packages/app/src/DBSearchPage.tsx @@ -26,7 +26,6 @@ import { import { useForm, useWatch } from 'react-hook-form'; import { z } from 'zod'; import { zodResolver } from '@hookform/resolvers/zod'; -import HyperDX from '@hyperdx/browser'; import { ClickHouseQueryError, ColumnMeta, @@ -149,6 +148,7 @@ import { usePrevious, withMapKeyAlias, } from '@/utils'; +import { recordAction } from '@/utils/browserTelemetry'; import ChartSQLPreview, { SQLPreview } from './components/ChartSQLPreview'; import DBSqlRowTableWithSideBar from './components/DBSqlRowTableWithSidebar'; @@ -1012,7 +1012,7 @@ export function useSearchTelemetry({ // telemetry. useEffect(() => { if (completedSearch == null || !completedSearch.emit) return; - HyperDX.addAction('search executed', { + recordAction('search executed', { latency_ms: completedSearch.latency_ms, source_id: completedSearch.source_id, }); diff --git a/packages/app/src/__mocks__/clickstack-browser.ts b/packages/app/src/__mocks__/clickstack-browser.ts new file mode 100644 index 0000000000..c284315ddb --- /dev/null +++ b/packages/app/src/__mocks__/clickstack-browser.ts @@ -0,0 +1,21 @@ +import type * as ClickStackBrowser from '@clickhouse/clickstack-browser'; + +// @clickhouse/clickstack-browser and its OpenTelemetry browser dependencies +// are ESM-only, which Jest (with transformIgnorePatterns: ['/node_modules/']) +// cannot parse. Unit tests never start RUM, so each export behaves as the SDK +// does before init. +export const init: typeof ClickStackBrowser.init = jest.fn(); +export const getSessionId: typeof ClickStackBrowser.getSessionId = jest.fn( + () => null, +); +export const startNewSession: typeof ClickStackBrowser.startNewSession = + jest.fn(); +export const pauseReplay: typeof ClickStackBrowser.pauseReplay = jest.fn(); +export const resumeReplay: typeof ClickStackBrowser.resumeReplay = jest.fn(); +export const shutdown: typeof ClickStackBrowser.shutdown = jest.fn(() => + Promise.resolve(), +); +export const recordException: typeof ClickStackBrowser.recordException = + jest.fn(); +export const setUser: typeof ClickStackBrowser.setUser = jest.fn(); +export const setAttributes: typeof ClickStackBrowser.setAttributes = jest.fn(); diff --git a/packages/app/src/__tests__/hdxDebug.test.ts b/packages/app/src/__tests__/hdxDebug.test.ts index 40bd113d08..a0900c111b 100644 --- a/packages/app/src/__tests__/hdxDebug.test.ts +++ b/packages/app/src/__tests__/hdxDebug.test.ts @@ -14,12 +14,14 @@ const baseConfig = { IS_PROMQL_ENABLED: false, }; -function loadHdxDebug(configOverrides: Partial = {}) { +function loadHdxDebug( + configOverrides: Partial = {}, + sessionId: string | null = null, +) { jest.resetModules(); jest.doMock('@/config', () => ({ ...baseConfig, ...configOverrides })); - jest.doMock('@hyperdx/browser', () => ({ - __esModule: true, - default: { getSessionId: () => undefined }, + jest.doMock('@clickhouse/clickstack-browser', () => ({ + getSessionId: () => sessionId, })); jest.doMock('@/utils/clipboard', () => ({ copyTextToClipboard: jest.fn().mockResolvedValue(true), @@ -172,6 +174,20 @@ describe('report identity + features', () => { }); }); +describe('report session line', () => { + it('reports N/A until the RUM SDK has a session', () => { + const report = reportFor(loadHdxDebug()); + expect(report).toContain('session: N/A'); + expect(window.hdx?.sessionId()).toBeUndefined(); + }); + + it('reports the RUM session id once there is one', () => { + const report = reportFor(loadHdxDebug({}, 'abc123')); + expect(report).toContain('session: abc123'); + expect(window.hdx?.sessionId()).toBe('abc123'); + }); +}); + describe('report url line', () => { afterEach(() => { window.history.replaceState(null, '', '/'); diff --git a/packages/app/src/__tests__/useSearchTelemetry.test.tsx b/packages/app/src/__tests__/useSearchTelemetry.test.tsx index 15892b5b67..d6877ae0c6 100644 --- a/packages/app/src/__tests__/useSearchTelemetry.test.tsx +++ b/packages/app/src/__tests__/useSearchTelemetry.test.tsx @@ -7,10 +7,9 @@ jest.mock('@/layout', () => ({ withAppNav: (component: unknown) => component, })); -const mockAddAction = jest.fn(); -jest.mock('@hyperdx/browser', () => ({ - __esModule: true, - default: { addAction: (...args: unknown[]) => mockAddAction(...args) }, +const mockRecordAction = jest.fn(); +jest.mock('@/utils/browserTelemetry', () => ({ + recordAction: (...args: unknown[]) => mockRecordAction(...args), })); let mockExplainData: unknown[] | undefined = undefined; @@ -83,8 +82,8 @@ describe('useSearchTelemetry', () => { }); expect(result.current.searchElapsedMs).toBeGreaterThanOrEqual(0); - expect(mockAddAction).toHaveBeenCalledTimes(1); - expect(mockAddAction).toHaveBeenCalledWith('search executed', { + expect(mockRecordAction).toHaveBeenCalledTimes(1); + expect(mockRecordAction).toHaveBeenCalledWith('search executed', { latency_ms: expect.any(Number), source_id: 'my-source', }); @@ -108,8 +107,8 @@ describe('useSearchTelemetry', () => { rerender({ isAnyQueryFetching: false, isLive: false, sourceId: 'src-a' }); }); - expect(mockAddAction).toHaveBeenCalledTimes(1); - expect(mockAddAction).toHaveBeenCalledWith('search executed', { + expect(mockRecordAction).toHaveBeenCalledTimes(1); + expect(mockRecordAction).toHaveBeenCalledWith('search executed', { latency_ms: expect.any(Number), source_id: 'src-a', }); @@ -119,7 +118,7 @@ describe('useSearchTelemetry', () => { rerender({ isAnyQueryFetching: false, isLive: false, sourceId: 'src-b' }); }); - expect(mockAddAction).toHaveBeenCalledTimes(1); // still just 1 + expect(mockRecordAction).toHaveBeenCalledTimes(1); // still just 1 }); it('does NOT emit during live-tail ticks (P0 fix)', async () => { @@ -140,7 +139,7 @@ describe('useSearchTelemetry', () => { rerender({ isAnyQueryFetching: false, isLive: true, sourceId: 'src' }); }); - expect(mockAddAction).not.toHaveBeenCalled(); + expect(mockRecordAction).not.toHaveBeenCalled(); }); it('measures elapsed time during live tail for display but does NOT emit', async () => { @@ -163,7 +162,7 @@ describe('useSearchTelemetry', () => { // Latency is surfaced for display ... expect(result.current.searchElapsedMs).toBeGreaterThanOrEqual(0); // ... but live-tail cycles are never reported to telemetry. - expect(mockAddAction).not.toHaveBeenCalled(); + expect(mockRecordAction).not.toHaveBeenCalled(); }); it('keeps the previous elapsed value when a live-tail poll starts (no blink)', async () => { @@ -224,7 +223,7 @@ describe('useSearchTelemetry', () => { // Two emits (one per false transition) — the clock was re-anchored // only on the first genuine false→true, so elapsed on both are valid numbers - expect(mockAddAction).toHaveBeenCalledTimes(2); + expect(mockRecordAction).toHaveBeenCalledTimes(2); expect(firstElapsed).toBeGreaterThanOrEqual(0); expect(result.current.searchElapsedMs).toBeGreaterThanOrEqual(0); }); @@ -247,7 +246,7 @@ describe('useSearchTelemetry', () => { }); expect(result.current.searchElapsedMs).toBeNull(); - expect(mockAddAction).not.toHaveBeenCalled(); + expect(mockRecordAction).not.toHaveBeenCalled(); }); it('falls back to empty string source_id when sourceId is null', async () => { @@ -267,7 +266,7 @@ describe('useSearchTelemetry', () => { rerender({ isAnyQueryFetching: false, isLive: false, sourceId: null }); }); - expect(mockAddAction).toHaveBeenCalledWith('search executed', { + expect(mockRecordAction).toHaveBeenCalledWith('search executed', { latency_ms: expect.any(Number), source_id: '', }); @@ -290,7 +289,7 @@ describe('useSearchTelemetry', () => { rerender({ isAnyQueryFetching: false, isLive: false, sourceId: 'src' }); }); - expect(mockAddAction).not.toHaveBeenCalled(); + expect(mockRecordAction).not.toHaveBeenCalled(); }); }); diff --git a/packages/app/src/components/AppNav/AppNav.components.tsx b/packages/app/src/components/AppNav/AppNav.components.tsx index ab4994d3c3..98515aca33 100644 --- a/packages/app/src/components/AppNav/AppNav.components.tsx +++ b/packages/app/src/components/AppNav/AppNav.components.tsx @@ -2,6 +2,11 @@ import React from 'react'; import Link from 'next/link'; import cx from 'classnames'; import { Badge } from '@clickhouse/click-ui'; +import { + setAttributes, + setUser, + startNewSession, +} from '@clickhouse/clickstack-browser'; import { Avatar, Button, @@ -174,6 +179,12 @@ export const AppNavUserMenu = ({ leftSection={} component={Link} href={logoutUrl} + onClick={() => { + // The next user on this device gets a RUM session of their own + setUser(null); + setAttributes(null); + startNewSession(); + }} > Logout diff --git a/packages/app/src/components/AppNav/AppNav.tsx b/packages/app/src/components/AppNav/AppNav.tsx index ff77863ba2..33c41c2fce 100644 --- a/packages/app/src/components/AppNav/AppNav.tsx +++ b/packages/app/src/components/AppNav/AppNav.tsx @@ -4,7 +4,7 @@ import Router, { useRouter } from 'next/router'; import Script from 'next/script'; import cx from 'classnames'; import { Badge } from '@clickhouse/click-ui'; -import HyperDX from '@hyperdx/browser'; +import { setAttributes, setUser } from '@clickhouse/clickstack-browser'; import { SavedSearchListApiResponse } from '@hyperdx/common-utils/dist/types'; import { Anchor, Collapse, Flex, Group, ScrollArea, Text } from '@mantine/core'; import { useDisclosure, useFocusTrap, useLocalStorage } from '@mantine/hooks'; @@ -218,21 +218,11 @@ export default function AppNav({ fixed = false }: { fixed?: boolean }) { const ghostWidth = isMobileNavOpen && !fixed ? reservedWidth : reservedWidth + 1; - useEffect(() => { - HyperDX.addAction('user navigated', { - route: pathname, - query: JSON.stringify(query), - }); - }, [pathname, query]); - useEffect(() => { if (meData != null) { - HyperDX.enableAdvancedNetworkCapture(); - HyperDX.setGlobalAttributes({ - userEmail: meData.email, - userName: meData.name, - teamName: meData.team.name, - }); + setUser({ id: meData.id, email: meData.email, name: meData.name }); + // Un-namespaced because the Sessions page reads teamName (sessions.ts) + setAttributes({ teamName: meData.team.name }); // Fold user/team ids + per-user toggles into window.hdx for debug reports. setHdxIdentity({ userId: meData.id, diff --git a/packages/app/src/components/AppNav/AppNavFeedback.tsx b/packages/app/src/components/AppNav/AppNavFeedback.tsx index 0109dceef0..8a34a83331 100644 --- a/packages/app/src/components/AppNav/AppNavFeedback.tsx +++ b/packages/app/src/components/AppNav/AppNavFeedback.tsx @@ -1,6 +1,5 @@ import React, { useCallback, useState } from 'react'; import { useRouter } from 'next/router'; -import HyperDX from '@hyperdx/browser'; import { ActionIcon, Box, Button, Group, Text, Textarea } from '@mantine/core'; import { useLocalStorage } from '@mantine/hooks'; import { @@ -11,6 +10,7 @@ import { } from '@tabler/icons-react'; import { IS_LOCAL_MODE } from '@/config'; +import { recordAction } from '@/utils/browserTelemetry'; import { AppNavContext } from './AppNav.components'; @@ -82,7 +82,7 @@ const AppNavFeedbackInner = () => { (newVote: FeedbackVote) => { setVote(newVote); setState('voted'); - HyperDX.addAction('user feedback vote', { + recordAction('user feedback vote', { vote: newVote ?? '', ...pageContext(), }); @@ -93,7 +93,7 @@ const AppNavFeedbackInner = () => { const [dismissed, setDismissed] = useState(false); const handleSubmit = useCallback(() => { - HyperDX.addAction('user feedback comment', { + recordAction('user feedback comment', { vote: vote ?? '', comment, ...pageContext(), diff --git a/packages/app/src/components/RevealSnippet/RevealSnippet.stories.tsx b/packages/app/src/components/RevealSnippet/RevealSnippet.stories.tsx index 2c701c89ad..696817e66d 100644 --- a/packages/app/src/components/RevealSnippet/RevealSnippet.stories.tsx +++ b/packages/app/src/components/RevealSnippet/RevealSnippet.stories.tsx @@ -359,7 +359,7 @@ export const NullableSecret: Story = { */ export const NoSecrets: Story = { render: () => ( - + diff --git a/packages/app/src/components/__tests__/AppNavUserMenu.test.tsx b/packages/app/src/components/__tests__/AppNavUserMenu.test.tsx index 0aee4d2178..d52680ee44 100644 --- a/packages/app/src/components/__tests__/AppNavUserMenu.test.tsx +++ b/packages/app/src/components/__tests__/AppNavUserMenu.test.tsx @@ -1,15 +1,24 @@ import React from 'react'; -import { screen } from '@testing-library/react'; +import { + setAttributes, + setUser, + startNewSession, +} from '@clickhouse/clickstack-browser'; +import { fireEvent, screen } from '@testing-library/react'; import { AppNavContext, AppNavUserMenu, } from '@/components/AppNav/AppNav.components'; -const renderAppNavUserMenu = (userName?: string) => { +const renderAppNavUserMenu = (userName?: string, logoutUrl?: string) => { return renderWithMantine( - + , ); }; @@ -28,4 +37,15 @@ describe('AppNavUserMenu', () => { expect(screen.getByText('U')).toBeInTheDocument(); expect(screen.getByText('User')).toBeInTheDocument(); }); + + it('starts a fresh RUM session without the user on logout', async () => { + renderAppNavUserMenu('Ada Lovelace', '/api/logout'); + + fireEvent.click(screen.getByTestId('user-menu-trigger')); + fireEvent.click(await screen.findByTestId('logout-menu-item')); + + expect(setUser).toHaveBeenCalledWith(null); + expect(setAttributes).toHaveBeenCalledWith(null); + expect(startNewSession).toHaveBeenCalledTimes(1); + }); }); diff --git a/packages/app/src/hdxDebug.ts b/packages/app/src/hdxDebug.ts index c5d5981e7d..d2d3c5e5c2 100644 --- a/packages/app/src/hdxDebug.ts +++ b/packages/app/src/hdxDebug.ts @@ -1,5 +1,5 @@ import { z } from 'zod'; -import HyperDX from '@hyperdx/browser'; +import { getSessionId } from '@clickhouse/clickstack-browser'; import { APP_VERSION, @@ -134,14 +134,10 @@ export function setHdxIdentity(next: { dynamicFeatures = next.features ?? {}; } -// The RUM SDK only initializes in non-local mode and after /api/config resolves, -// so this accessor must tolerate it being absent. -function safeSessionId(): string | undefined { - try { - return HyperDX.getSessionId(); - } catch { - return undefined; - } +// Null until the RUM SDK has started, which needs /api/config and never happens +// in local mode. +function sessionId(): string | undefined { + return getSessionId() ?? undefined; } function getDevice(): HdxDevice { @@ -195,7 +191,7 @@ function buildReport(): string { `platform: ${device.platform}`, `language: ${device.language}`, `ua: ${device.userAgent}`, - `session: ${safeSessionId() || 'N/A'}`, + `session: ${sessionId() || 'N/A'}`, ]; return lines.join('\n'); } @@ -236,7 +232,7 @@ export function installHdxDebug(): void { get device() { return getDevice(); }, - sessionId: safeSessionId, + sessionId, report: buildReport, copy: async () => { const text = buildReport(); diff --git a/packages/app/src/instrumentation.ts b/packages/app/src/instrumentation.ts deleted file mode 100644 index c25e36eb2e..0000000000 --- a/packages/app/src/instrumentation.ts +++ /dev/null @@ -1,9 +0,0 @@ -export async function register() { - if (process.env.NEXT_RUNTIME === 'nodejs') { - const { init } = await import('@hyperdx/node-opentelemetry'); - init({ - apiKey: process.env.HYPERDX_API_KEY, - additionalInstrumentations: [], // optional, default: [] - }); - } -} diff --git a/packages/app/src/utils/__tests__/browserTelemetry.test.ts b/packages/app/src/utils/__tests__/browserTelemetry.test.ts new file mode 100644 index 0000000000..a7be89fd44 --- /dev/null +++ b/packages/app/src/utils/__tests__/browserTelemetry.test.ts @@ -0,0 +1,71 @@ +import { trace } from '@opentelemetry/api'; + +import { getBrowserInitOptions, recordAction } from '@/utils/browserTelemetry'; + +afterEach(() => { + jest.restoreAllMocks(); +}); + +describe('recordAction', () => { + it('ends a span named after the action with its attributes', () => { + const tracer = trace.getTracer('test'); + const span = tracer.startSpan('probe'); + const end = jest.spyOn(span, 'end'); + const startSpan = jest.spyOn(tracer, 'startSpan').mockReturnValue(span); + const getTracer = jest.spyOn(trace, 'getTracer').mockReturnValue(tracer); + + recordAction('search executed', { latency_ms: 12, source_id: 's1' }); + + expect(getTracer).toHaveBeenCalledWith('custom-action'); + expect(startSpan).toHaveBeenCalledWith('search executed', { + attributes: { latency_ms: 12, source_id: 's1' }, + }); + expect(end).toHaveBeenCalledTimes(1); + }); +}); + +describe('getBrowserInitOptions', () => { + it('maps the app config onto the SDK options', () => { + expect( + getBrowserInitOptions({ + config: { + apiKey: 'key', + serviceName: 'hdx-app', + collectorUrl: 'https://otel.example.com', + collectorTracesUrl: 'https://traces.example.com/v1/traces', + collectorLogsUrl: 'https://logs.example.com/v1/logs', + }, + resourceAttributes: + 'deployment.environment.name=prod,team=core,service.version=9', + serviceVersion: '2.0.0', + }), + ).toEqual({ + endpoint: 'https://otel.example.com', + tracesEndpoint: 'https://traces.example.com/v1/traces', + logsEndpoint: 'https://logs.example.com/v1/logs', + apiKey: 'key', + serviceName: 'hdx-app', + serviceVersion: '2.0.0', + resourceAttributes: { + 'deployment.environment.name': 'prod', + team: 'core', + 'service.version': '9', + }, + console: 'debug', + maskAllText: true, + maskAllInputs: true, + }); + }); + + it('leaves unset per-signal URLs and resource attributes empty', () => { + const options = getBrowserInitOptions({ + config: { serviceName: 'hdx-app', collectorUrl: 'http://localhost:4318' }, + resourceAttributes: '', + serviceVersion: undefined, + }); + + expect(options.tracesEndpoint).toBeUndefined(); + expect(options.logsEndpoint).toBeUndefined(); + expect(options.resourceAttributes).toEqual({}); + }); +}); diff --git a/packages/app/src/utils/__tests__/nextServerTelemetry.test.ts b/packages/app/src/utils/__tests__/nextServerTelemetry.test.ts new file mode 100644 index 0000000000..c9833046a3 --- /dev/null +++ b/packages/app/src/utils/__tests__/nextServerTelemetry.test.ts @@ -0,0 +1,200 @@ +import { + getNextServerServiceName, + isStaticAssetRequest, + startNextServerTelemetry, +} from '@/utils/nextServerTelemetry'; + +const mockInit = jest.fn(); +let mockExporterEnabled = true; +let mockBasePath = ''; + +jest.mock('@clickhouse/clickstack-node', () => ({ + init: (...args: unknown[]) => mockInit(...args), +})); +jest.mock('@/config', () => ({ + ...jest.requireActual('@/config'), + get HDX_EXPORTER_ENABLED() { + return mockExporterEnabled; + }, + get BASE_PATH() { + return mockBasePath; + }, +})); + +describe('getNextServerServiceName', () => { + it('suffixes OTEL_SERVICE_NAME', () => { + expect( + getNextServerServiceName({ + OTEL_SERVICE_NAME: 'hdx-oss-dev-app', + OTEL_RESOURCE_ATTRIBUTES: 'service.name=other', + }), + ).toBe('hdx-oss-dev-app-next'); + }); + + it('falls back to service.name in OTEL_RESOURCE_ATTRIBUTES', () => { + expect( + getNextServerServiceName({ + OTEL_SERVICE_NAME: ' ', + OTEL_RESOURCE_ATTRIBUTES: 'service.version=1, service.name = my%20app', + }), + ).toBe('my app-next'); + }); + + it('falls back to hdx-oss-app', () => { + expect( + getNextServerServiceName({ + OTEL_RESOURCE_ATTRIBUTES: 'service.version=1', + }), + ).toBe('hdx-oss-app-next'); + }); + + // The SDK drops the whole variable for any of these, so the API would not + // report the name either + it.each([ + ['a value it cannot decode', 'service.name=%E0'], + ['an unencoded =', 'service.name=acme,k8s.pod.labels=app=web'], + ['an entry without =', 'service.name=acme,region'], + ['an empty key', 'service.name=acme,=web'], + ['a value over 255 characters', `service.name=acme,t=${'a'.repeat(256)}`], + ])('ignores OTEL_RESOURCE_ATTRIBUTES with %s', (_case, attributes) => { + expect( + getNextServerServiceName({ OTEL_RESOURCE_ATTRIBUTES: attributes }), + ).toBe('hdx-oss-app-next'); + }); + + it('suffixes a name that already ends in -next', () => { + expect( + getNextServerServiceName({ OTEL_SERVICE_NAME: 'hyperdx-next' }), + ).toBe('hyperdx-next-next'); + }); +}); + +describe('isStaticAssetRequest', () => { + it.each([ + '/_next/static/chunks/main.js', + '/_next/static/css/app.css?v=1', + '/_next/webpack-hmr?id=1', + '/__nextjs_original-stack-frames', + '/__ENV.js', + '/whats-new.json', + '/favicons/clickstack/favicon.svg', + '/pyodide/pyodide.js', + '/pyodide/pyodide.asm.wasm', + '/drain3-0.9.11-py3-none-any.whl', + ])('skips %s', url => { + expect(isStaticAssetRequest(url, '')).toBe(true); + }); + + it.each([ + '/api/me', + '/search', + '/_next/data/build/search.json', + '/__ENV.js.map', + undefined, + ])('keeps %s', url => { + expect(isStaticAssetRequest(url, '')).toBe(false); + }); + + it('matches below the base path', () => { + expect(isStaticAssetRequest('/hdx/_next/static/a.js', '/hdx')).toBe(true); + expect(isStaticAssetRequest('/hdx/__ENV.js', '/hdx')).toBe(true); + expect(isStaticAssetRequest('/hdx/api/me', '/hdx')).toBe(false); + }); +}); + +describe('startNextServerTelemetry', () => { + const originalEnv = { ...process.env }; + + const start = async (env: Record) => { + for (const key of [ + 'HYPERDX_API_KEY', + 'OTEL_EXPORTER_OTLP_HEADERS', + 'OTEL_SERVICE_NAME', + 'OTEL_RESOURCE_ATTRIBUTES', + 'OTEL_LOG_LEVEL', + ]) { + delete process.env[key]; + } + Object.assign(process.env, env); + await startNextServerTelemetry(); + }; + + // The hook reads only the URL of the IncomingMessage it gets + const ignoreHook = (): ((request: { url?: string }) => boolean) => + mockInit.mock.calls[0][0].instrumentations[ + '@opentelemetry/instrumentation-http' + ].ignoreIncomingRequestHook; + + beforeEach(() => { + mockInit.mockClear(); + mockExporterEnabled = true; + mockBasePath = ''; + }); + + afterAll(() => { + process.env = originalEnv; + }); + + it('does not start without a key or OTLP headers', async () => { + await start({ OTEL_SERVICE_NAME: 'hdx-app' }); + + expect(mockInit).not.toHaveBeenCalled(); + expect(process.env.OTEL_SERVICE_NAME).toBe('hdx-app'); + }); + + it('does not start when HDX_EXPORTER_ENABLED is false', async () => { + mockExporterEnabled = false; + + await start({ HYPERDX_API_KEY: 'ingest-key' }); + + expect(mockInit).not.toHaveBeenCalled(); + }); + + it('starts with its own service name and a quieter diag level', async () => { + await start({ + HYPERDX_API_KEY: 'ingest-key', + OTEL_SERVICE_NAME: 'hdx-app', + }); + + expect(mockInit).toHaveBeenCalledWith({ + apiKey: 'ingest-key', + instrumentations: { + '@opentelemetry/instrumentation-http': { + ignoreIncomingRequestHook: expect.any(Function), + }, + }, + }); + expect(process.env.OTEL_SERVICE_NAME).toBe('hdx-app-next'); + expect(process.env.OTEL_LOG_LEVEL).toBe('error'); + }); + + it("keeps the operator's OTEL_LOG_LEVEL", async () => { + await start({ HYPERDX_API_KEY: 'ingest-key', OTEL_LOG_LEVEL: 'debug' }); + + expect(process.env.OTEL_LOG_LEVEL).toBe('debug'); + }); + + it('appends the key to OTLP headers that have no authorization entry', async () => { + await start({ + HYPERDX_API_KEY: 'ingest-key', + OTEL_EXPORTER_OTLP_HEADERS: 'x-scope-orgid=acme', + }); + + expect(process.env.OTEL_EXPORTER_OTLP_HEADERS).toBe( + 'x-scope-orgid=acme,authorization=ingest-key', + ); + expect(mockInit).toHaveBeenCalledWith( + expect.objectContaining({ apiKey: undefined }), + ); + }); + + it('skips static asset requests below the base path', async () => { + mockBasePath = '/hdx'; + + await start({ HYPERDX_API_KEY: 'ingest-key' }); + + const hook = ignoreHook(); + expect(hook({ url: '/hdx/_next/static/a.js' })).toBe(true); + expect(hook({ url: '/hdx/api/me' })).toBe(false); + }); +}); diff --git a/packages/app/src/utils/browserTelemetry.ts b/packages/app/src/utils/browserTelemetry.ts new file mode 100644 index 0000000000..d1df918fa7 --- /dev/null +++ b/packages/app/src/utils/browserTelemetry.ts @@ -0,0 +1,53 @@ +import type { ClickStackBrowserOptions } from '@clickhouse/clickstack-browser'; +import { type Attributes, trace } from '@opentelemetry/api'; + +import { parseResourceAttributes } from '@/config'; +import type { NextApiConfigResponseData } from '@/types'; + +/** + * Records a user action as a zero-duration span, the replacement for the old + * SDK's addAction. The browser SDK adds session.id and user.* to it. + */ +export function recordAction(name: string, attributes: Attributes): void { + // The scope the old addAction used. The session replay timeline finds + // custom events by it (utils/sessions.ts, SessionEventList.tsx). + trace.getTracer('custom-action').startSpan(name, { attributes }).end(); +} + +type BrowserTelemetryConfig = Pick< + NextApiConfigResponseData, + | 'apiKey' + | 'collectorUrl' + | 'collectorTracesUrl' + | 'collectorLogsUrl' + | 'serviceName' +>; + +/** Maps the app's telemetry settings onto the browser SDK's init options. */ +export function getBrowserInitOptions({ + config, + resourceAttributes, + serviceVersion, +}: { + config: BrowserTelemetryConfig; + /** The raw NEXT_PUBLIC_OTEL_RESOURCE_ATTRIBUTES value. */ + resourceAttributes: string; + serviceVersion: string | undefined; +}): ClickStackBrowserOptions { + return { + endpoint: config.collectorUrl, + // An empty per-signal URL, as from a variable set to '', makes the SDK + // build that signal's URL from endpoint + tracesEndpoint: config.collectorTracesUrl, + logsEndpoint: config.collectorLogsUrl, + apiKey: config.apiKey, + serviceName: config.serviceName, + // Wins over a service.version in resourceAttributes, as before the upgrade + serviceVersion, + resourceAttributes: parseResourceAttributes(resourceAttributes), + // The old SDK's consoleCapture recorded every console level + console: 'debug', + maskAllText: true, + maskAllInputs: true, + }; +} diff --git a/packages/app/src/utils/nextServerTelemetry.ts b/packages/app/src/utils/nextServerTelemetry.ts new file mode 100644 index 0000000000..a091c765a0 --- /dev/null +++ b/packages/app/src/utils/nextServerTelemetry.ts @@ -0,0 +1,140 @@ +import { decideSelfTelemetry } from '@hyperdx/common-utils/dist/selfTelemetry'; + +import { BASE_PATH, HDX_EXPORTER_ENABLED } from '@/config'; + +// Used only when no name is configured, in which case the API reports +// unknown_service:node. It is the name docker-compose gives the API. +const DEFAULT_SERVICE_NAME = 'hdx-oss-app'; +const SERVICE_NAME_SUFFIX = '-next'; + +// Build and public/ assets were half of this server's incoming spans. Pages, +// /api and /_next/data requests keep theirs. A new file in public/ needs an +// entry here. +const STATIC_PATH_PREFIXES = [ + '/_next/static/', + '/_next/webpack-hmr', + // The dev overlay's stack frame and source map requests + '/__nextjs', + '/favicons/', + '/pyodide/', +]; +const STATIC_PATHS = ['/__ENV.js', '/whats-new.json']; +// The Python packages the Patterns view installs from the public/ root +const STATIC_PATH_SUFFIXES = ['.whl']; + +// The SDK's limit for resource attribute keys and values +const MAX_RESOURCE_ATTRIBUTE_LENGTH = 255; + +/** + * A stricter twin of `parseResourceAttributes` in src/config.ts, which splits + * each entry at its first `=` and skips entries without a key. This one + * follows the EnvDetector in `@opentelemetry/resources`, which drops the whole + * variable when any entry is malformed or longer than 255 characters, so the + * Next server picks the same service.name as the SDK and never one the API + * would not report. + */ +function serviceNameFromResourceAttributes(raw: string | undefined) { + let serviceName: string | undefined; + for (const entry of (raw ?? '').split(',')) { + if (entry.trim() === '') { + continue; + } + const parts = entry.split('='); + if (parts.length !== 2 || parts[0].trim() === '') { + return undefined; + } + let key: string; + let value: string; + try { + key = decodeURIComponent(parts[0].trim()); + value = decodeURIComponent(parts[1].trim()); + } catch { + return undefined; + } + if ( + key.length > MAX_RESOURCE_ATTRIBUTE_LENGTH || + value.length > MAX_RESOURCE_ATTRIBUTE_LENGTH + ) { + return undefined; + } + if (key === 'service.name') { + serviceName = value; + } + } + return serviceName || undefined; +} + +/** + * The HyperDX image (the docker-compose app service, which sets hdx-oss-app) + * and the all-in-one image run the API, the check-alerts task and this server + * in one container with one OTEL_SERVICE_NAME, so this server reports as that + * name plus `-next`. + */ +export function getNextServerServiceName( + env: Record, +): string { + const base = + env.OTEL_SERVICE_NAME?.trim() || + serviceNameFromResourceAttributes(env.OTEL_RESOURCE_ATTRIBUTES) || + DEFAULT_SERVICE_NAME; + return `${base}${SERVICE_NAME_SUFFIX}`; +} + +export function isStaticAssetRequest( + url: string | undefined, + basePath: string, +): boolean { + const path = (url ?? '').split('?')[0]; + const appPath = + basePath && path.startsWith(`${basePath}/`) + ? path.slice(basePath.length) + : path; + return ( + STATIC_PATHS.includes(appPath) || + STATIC_PATH_PREFIXES.some(prefix => appPath.startsWith(prefix)) || + STATIC_PATH_SUFFIXES.some(suffix => appPath.endsWith(suffix)) + ); +} + +/** Called from register() in instrumentation.ts in the Node.js runtime. */ +export async function startNextServerTelemetry(): Promise { + // Operators who set HDX_EXPORTER_ENABLED=false to turn off the app's own + // telemetry (it hides the browser key in /api/config) never got Next server + // telemetry either, because production builds did not load + // instrumentation.ts before. + if (!HDX_EXPORTER_ENABLED) { + return; + } + const telemetry = decideSelfTelemetry(process.env); + if (!telemetry.start) { + return; + } + if (telemetry.otlpHeaders !== undefined) { + process.env.OTEL_EXPORTER_OTLP_HEADERS = telemetry.otlpHeaders; + } + + // The variable beats both init's serviceName option and a service.name in + // OTEL_RESOURCE_ATTRIBUTES, so writing it is enough. The browser takes its + // name from NEXT_PUBLIC_OTEL_SERVICE_NAME and is not affected. + process.env.OTEL_SERVICE_NAME = getNextServerServiceName(process.env); + + // Next sets http.route on the outer HTTP server span once the request + // handler settles, and for proxied /api requests that span has already + // ended, so the SDK's default warn level prints a diag line per request. + // Export failures are diag errors and still print. An operator's + // OTEL_LOG_LEVEL wins. + process.env.OTEL_LOG_LEVEL ??= 'error'; + + const { init } = await import('@clickhouse/clickstack-node'); + init({ + apiKey: telemetry.apiKey, + instrumentations: { + // The SDK merges its header capture and body hooks into this entry, so + // they keep working. + '@opentelemetry/instrumentation-http': { + ignoreIncomingRequestHook: request => + isStaticAssetRequest(request.url, BASE_PATH), + }, + }, + }); +} diff --git a/packages/common-utils/src/__tests__/selfTelemetry.test.ts b/packages/common-utils/src/__tests__/selfTelemetry.test.ts new file mode 100644 index 0000000000..1ce0e1273d --- /dev/null +++ b/packages/common-utils/src/__tests__/selfTelemetry.test.ts @@ -0,0 +1,54 @@ +import { decideSelfTelemetry } from '@/selfTelemetry'; + +describe('decideSelfTelemetry', () => { + it('does not start without a key or OTLP headers', () => { + expect(decideSelfTelemetry({})).toEqual({ start: false }); + }); + + it('treats blank values as unset', () => { + expect( + decideSelfTelemetry({ + HYPERDX_API_KEY: ' ', + OTEL_EXPORTER_OTLP_HEADERS: '', + }), + ).toEqual({ start: false }); + }); + + it('passes a trimmed HYPERDX_API_KEY as the apiKey', () => { + expect(decideSelfTelemetry({ HYPERDX_API_KEY: ' ingest-key ' })).toEqual({ + start: true, + apiKey: 'ingest-key', + otlpHeaders: undefined, + }); + }); + + it('starts on OTLP headers alone and leaves them as they are', () => { + expect( + decideSelfTelemetry({ + OTEL_EXPORTER_OTLP_HEADERS: 'authorization=ingest-key', + }), + ).toEqual({ start: true, apiKey: undefined, otlpHeaders: undefined }); + }); + + it('appends the encoded key to OTLP headers without an authorization entry', () => { + expect( + decideSelfTelemetry({ + HYPERDX_API_KEY: 'ingest,key', + OTEL_EXPORTER_OTLP_HEADERS: ' x-scope-orgid=acme ', + }), + ).toEqual({ + start: true, + apiKey: undefined, + otlpHeaders: 'x-scope-orgid=acme,authorization=ingest%2Ckey', + }); + }); + + it('keeps an authorization entry already in the OTLP headers', () => { + expect( + decideSelfTelemetry({ + HYPERDX_API_KEY: 'ingest-key', + OTEL_EXPORTER_OTLP_HEADERS: 'x-scope-orgid=acme, Authorization =other', + }), + ).toEqual({ start: true, apiKey: 'ingest-key', otlpHeaders: undefined }); + }); +}); diff --git a/packages/common-utils/src/selfTelemetry.ts b/packages/common-utils/src/selfTelemetry.ts new file mode 100644 index 0000000000..8d043d9dd1 --- /dev/null +++ b/packages/common-utils/src/selfTelemetry.ts @@ -0,0 +1,65 @@ +/** + * Shared by the API's self-telemetry preload and the Next.js server + * instrumentation, which both wrap the ClickStack SDK's init(). + * + * It has no imports so the API preload can load it before init() without + * loading anything the SDK would then fail to instrument. + */ + +/** + * The variables the decision reads. The index signature lets `process.env` + * through TypeScript's check for objects that share no named property. + */ +export type SelfTelemetryEnv = { + HYPERDX_API_KEY?: string; + OTEL_EXPORTER_OTLP_HEADERS?: string; + [name: string]: string | undefined; +}; + +export type SelfTelemetryDecision = + | { start: false } + | { + start: true; + /** The init() apiKey option. Unset when the key went into otlpHeaders. */ + apiKey: string | undefined; + /** + * The OTEL_EXPORTER_OTLP_HEADERS value to write before init(), when the + * key had to be appended to it. Unset when the variable stays as it is. + */ + otlpHeaders: string | undefined; + }; + +const hasAuthorization = (headers: string) => + headers + .split(',') + .some( + entry => entry.split('=')[0].trim().toLowerCase() === 'authorization', + ); + +export function decideSelfTelemetry( + env: SelfTelemetryEnv, +): SelfTelemetryDecision { + const apiKey = env.HYPERDX_API_KEY?.trim() || undefined; + const otlpHeaders = env.OTEL_EXPORTER_OTLP_HEADERS?.trim() || undefined; + + // The old HyperDX SDK skipped init without a key or OTLP headers, and the + // ClickStack SDK always starts. Without this gate, deployments that never + // exported HyperDX's own telemetry would start sending it to localhost:4318, + // which is the bundled collector in the all-in-one image. + if (!apiKey && !otlpHeaders) { + return { start: false }; + } + + // The SDK ignores apiKey when OTEL_EXPORTER_OTLP_HEADERS is set. The old SDK + // appended the key to those headers, so do the same unless they already + // carry one, in which case the SDK warns that the key is ignored. + if (apiKey && otlpHeaders && !hasAuthorization(otlpHeaders)) { + return { + start: true, + apiKey: undefined, + otlpHeaders: `${otlpHeaders},authorization=${encodeURIComponent(apiKey)}`, + }; + } + + return { start: true, apiKey, otlpHeaders: undefined }; +} diff --git a/scripts/ci/ratchet-baseline.json b/scripts/ci/ratchet-baseline.json index 21457c9e1e..9a3c07f24e 100644 --- a/scripts/ci/ratchet-baseline.json +++ b/scripts/ci/ratchet-baseline.json @@ -1,6 +1,6 @@ { "api": { - "as-any": 89, + "as-any": 88, "ts-ignore": 0, "eslint-disable": 36, "@source": 0 @@ -8,7 +8,7 @@ "app": { "as-any": 213, "ts-ignore": 0, - "eslint-disable": 142, + "eslint-disable": 141, "@source": 0 }, "cli": { diff --git a/yarn.lock b/yarn.lock index 0d4d19959e..b8009a3c03 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2852,24 +2852,6 @@ __metadata: languageName: node linkType: hard -"@babel/runtime@npm:^7.21.0": - version: 7.22.5 - resolution: "@babel/runtime@npm:7.22.5" - dependencies: - regenerator-runtime: "npm:^0.13.11" - checksum: 10c0/11dcaeecd2246857ccf22f939fcae28a58d29e410607bfa28b95d9b03e298a3e3df8a530e22637d5bfccfc1661fb39cc50c06b404b5d53454bd93889c7dd3eb8 - languageName: node - linkType: hard - -"@babel/runtime@npm:~7.18.3": - version: 7.18.9 - resolution: "@babel/runtime@npm:7.18.9" - dependencies: - regenerator-runtime: "npm:^0.13.4" - checksum: 10c0/f996fca79e2cd3c80289c2655e95358254f0437ca28cf10ec4343498dd4a59002fc506d5ce6f37019f1a961e8f26ce43523844ee5a87412d32c17a8ef2f608ee - languageName: node - linkType: hard - "@babel/template@npm:^7.24.6, @babel/template@npm:^7.27.2": version: 7.27.2 resolution: "@babel/template@npm:7.27.2" @@ -3305,6 +3287,46 @@ __metadata: languageName: node linkType: hard +"@clickhouse/clickstack-browser@npm:^1.2.0": + version: 1.2.0 + resolution: "@clickhouse/clickstack-browser@npm:1.2.0" + dependencies: + "@opentelemetry/api-logs": "npm:^0.223.0" + "@opentelemetry/browser-instrumentation": "npm:^0.9.0" + "@opentelemetry/core": "npm:^2.12.0" + "@opentelemetry/instrumentation-long-task": "npm:^0.67.0" + "@opentelemetry/otlp-transformer": "npm:^0.223.0" + "@opentelemetry/resources": "npm:^2.12.0" + "@opentelemetry/sdk-logs": "npm:^0.223.0" + "@opentelemetry/sdk-trace": "npm:^2.12.0" + "@opentelemetry/semantic-conventions": "npm:^1.43.0" + "@rrweb/record": "npm:~2.2.0" + peerDependencies: + "@opentelemetry/api": ">=1.9.1 <1.10.0" + "@opentelemetry/browser-sdk": ^0.6.0 + checksum: 10c0/794386d9d3675bd350d977ab5c6c7f4375313221fcf72911d6259683a61a28658c1393ab2ba615e45e589b55bd3774bc4661421b02c3d6a7c084940fcd85bc72 + languageName: node + linkType: hard + +"@clickhouse/clickstack-node@npm:^1.0.2": + version: 1.0.2 + resolution: "@clickhouse/clickstack-node@npm:1.0.2" + dependencies: + "@opentelemetry/api-logs": "npm:^0.223.0" + "@opentelemetry/auto-instrumentations-node": "npm:^0.81.0" + "@opentelemetry/core": "npm:^2.12.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/instrumentation-console": "npm:^0.5.0" + "@opentelemetry/resources": "npm:^2.12.0" + "@opentelemetry/sdk-node": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.43.0" + import-in-the-middle: "npm:^3.5.2" + peerDependencies: + "@opentelemetry/api": ">=1.9.1 <1.10.0" + checksum: 10c0/5bfe331b719ea11b69f131ca5b5072e3c58372bd4ab5c7582c5138a3141b1d2caf69fd8029f9567172558b6800147fc7503df9e711d69ff3546b585cd6f8f497 + languageName: node + linkType: hard + "@clickhouse/client-common@npm:1.23.0-head.fae5998.1": version: 1.23.0-head.fae5998.1 resolution: "@clickhouse/client-common@npm:1.23.0-head.fae5998.1" @@ -4652,13 +4674,13 @@ __metadata: languageName: node linkType: hard -"@grpc/grpc-js@npm:^1.7.1": - version: 1.14.5 - resolution: "@grpc/grpc-js@npm:1.14.5" +"@grpc/grpc-js@npm:^1.14.3": + version: 1.14.7 + resolution: "@grpc/grpc-js@npm:1.14.7" dependencies: "@grpc/proto-loader": "npm:^0.8.0" "@js-sdsl/ordered-map": "npm:^4.4.2" - checksum: 10c0/25a44d80127ed166181fc3db25d9815a62081e33331938bdae31830296ec94a1c8ed3ade79fae26642ec3158e97a79936145c680f95c19528ffff334cca491e0 + checksum: 10c0/9f6dd28237edbd868f4aeb775f2c9f51a57b1b5ed35cc8dad36cd7b1c7d40010abe3bcba525035fea99dbbffa800a2ead88f57f08af2f623c0962861b68a059a languageName: node linkType: hard @@ -4747,15 +4769,18 @@ __metadata: "@ai-sdk/openai": "npm:^4.0.78" "@ai-sdk/otel": "npm:^1.0.116" "@braintree/sanitize-url": "npm:^7.1.1" + "@clickhouse/clickstack-node": "npm:^1.0.2" "@clickhouse/client-common": "npm:1.23.0-head.fae5998.1" "@esm2cjs/p-queue": "npm:^7.3.0" "@hyperdx/common-utils": "npm:^0.33.0" - "@hyperdx/node-opentelemetry": "npm:^0.9.0" "@hyperdx/passport-local-mongoose": "npm:^9.0.1" "@modelcontextprotocol/sdk": "npm:^1.27.1" - "@opentelemetry/api": "npm:^1.8.0" - "@opentelemetry/host-metrics": "npm:^0.35.5" - "@opentelemetry/sdk-metrics": "npm:^1.30.1" + "@opentelemetry/api": "npm:~1.9.1" + "@opentelemetry/api-logs": "npm:^0.223.0" + "@opentelemetry/core": "npm:^2.12.0" + "@opentelemetry/otlp-transformer": "npm:^0.223.0" + "@opentelemetry/resources": "npm:^2.12.0" + "@opentelemetry/sdk-logs": "npm:^0.223.0" "@opentelemetry/sdk-trace-base": "npm:^1.30.1" "@slack/webhook": "npm:^7.0.0" "@stoplight/spectral-cli": "npm:^6.15.0" @@ -4829,6 +4854,8 @@ __metadata: dependencies: "@chromatic-com/storybook": "npm:^4.1.3" "@clickhouse/click-ui": "npm:^0.12.0" + "@clickhouse/clickstack-browser": "npm:^1.2.0" + "@clickhouse/clickstack-node": "npm:^1.0.2" "@codemirror/autocomplete": "npm:^6.0.0" "@codemirror/lang-json": "npm:^6.0.1" "@codemirror/lang-sql": "npm:^6.7.0" @@ -4842,9 +4869,7 @@ __metadata: "@eslint/compat": "npm:^2.0.0" "@hookform/resolvers": "npm:^3.9.0" "@hyperdx/api": "workspace:*" - "@hyperdx/browser": "npm:^0.22.1" "@hyperdx/common-utils": "npm:^0.33.0" - "@hyperdx/node-opentelemetry": "npm:^0.9.0" "@mantine/core": "npm:^9.0.0" "@mantine/dates": "npm:^9.0.0" "@mantine/dropzone": "npm:^9.0.0" @@ -4853,6 +4878,8 @@ __metadata: "@mantine/notifications": "npm:^9.0.0" "@mantine/spotlight": "npm:^9.0.0" "@next/eslint-plugin-next": "npm:^16.3.4" + "@opentelemetry/api": "npm:~1.9.1" + "@opentelemetry/browser-sdk": "npm:^0.6.0" "@playwright/test": "npm:^1.57.0" "@prometheus-io/codemirror-promql": "npm:^0.311.3" "@rrweb/replay": "npm:2.1.1" @@ -4955,16 +4982,6 @@ __metadata: languageName: unknown linkType: soft -"@hyperdx/browser@npm:^0.22.1": - version: 0.22.1 - resolution: "@hyperdx/browser@npm:0.22.1" - dependencies: - "@hyperdx/otel-web": "npm:0.16.4" - "@hyperdx/otel-web-session-recorder": "npm:0.16.2" - checksum: 10c0/60a53e056e41fa74061c8d4d6e1a083b8daeb8ac5995d57c44146fd7e2adc16cf3e070514ce31439fc8f317018e2e773eee34af435c247d84467509f149dde86 - languageName: node - linkType: hard - "@hyperdx/cli@workspace:packages/cli": version: 0.0.0-use.local resolution: "@hyperdx/cli@workspace:packages/cli" @@ -5061,42 +5078,6 @@ __metadata: languageName: unknown linkType: soft -"@hyperdx/instrumentation-exception@npm:^0.1.0": - version: 0.1.0 - resolution: "@hyperdx/instrumentation-exception@npm:0.1.0" - dependencies: - "@hyperdx/instrumentation-sentry-node": "npm:^0.1.0" - "@opentelemetry/core": "npm:^1.24.1" - "@opentelemetry/instrumentation": "npm:^0.51.1" - "@opentelemetry/semantic-conventions": "npm:^1.24.1" - "@sentry/core": "npm:^8.7.0" - "@sentry/types": "npm:^8.7.0" - "@sentry/utils": "npm:^8.7.0" - json-stringify-safe: "npm:^5.0.1" - shimmer: "npm:^1.2.1" - tslib: "npm:^2.5.3" - peerDependencies: - "@opentelemetry/api": ^1.3.0 - checksum: 10c0/f0a5dcf5c3da19d6b7ebac21a627a2e7ca203b3210b33c52219b4af4c3e87186525fa58518ddfd7d18f29c3c84059187c5259b991902e62af1669225cdd74990 - languageName: node - linkType: hard - -"@hyperdx/instrumentation-sentry-node@npm:^0.1.0": - version: 0.1.0 - resolution: "@hyperdx/instrumentation-sentry-node@npm:0.1.0" - dependencies: - "@opentelemetry/core": "npm:^1.24.1" - "@opentelemetry/instrumentation": "npm:^0.51.1" - "@opentelemetry/semantic-conventions": "npm:^1.24.1" - json-stringify-safe: "npm:^5.0.1" - shimmer: "npm:^1.2.1" - tslib: "npm:^2.5.3" - peerDependencies: - "@opentelemetry/api": ^1.3.0 - checksum: 10c0/10f64b58adc2ec567be739e05aed96baf78dc2a51ab68e7179a9912445416ecd8d7be9ead0bfbcbbf4490cfb0dcc1dfc680becc4cf1a0c63131ee087a68859c7 - languageName: node - linkType: hard - "@hyperdx/lucene@npm:^3.1.1": version: 3.1.1 resolution: "@hyperdx/lucene@npm:3.1.1" @@ -5104,101 +5085,12 @@ __metadata: languageName: node linkType: hard -"@hyperdx/node-opentelemetry@npm:^0.9.0": - version: 0.9.0 - resolution: "@hyperdx/node-opentelemetry@npm:0.9.0" - dependencies: - "@hyperdx/instrumentation-exception": "npm:^0.1.0" - "@hyperdx/instrumentation-sentry-node": "npm:^0.1.0" - "@opentelemetry/api": "npm:^1.8.0" - "@opentelemetry/api-logs": "npm:^0.57.2" - "@opentelemetry/auto-instrumentations-node": "npm:^0.56.1" - "@opentelemetry/core": "npm:^1.30.1" - "@opentelemetry/exporter-logs-otlp-grpc": "npm:^0.57.2" - "@opentelemetry/exporter-logs-otlp-http": "npm:^0.57.2" - "@opentelemetry/exporter-metrics-otlp-grpc": "npm:^0.57.2" - "@opentelemetry/exporter-metrics-otlp-proto": "npm:^0.57.2" - "@opentelemetry/exporter-trace-otlp-grpc": "npm:^0.57.2" - "@opentelemetry/exporter-trace-otlp-proto": "npm:^0.57.2" - "@opentelemetry/instrumentation": "npm:^0.57.2" - "@opentelemetry/instrumentation-http": "npm:^0.57.2" - "@opentelemetry/instrumentation-runtime-node": "npm:^0.12.2" - "@opentelemetry/resources": "npm:^1.30.1" - "@opentelemetry/sdk-logs": "npm:^0.57.2" - "@opentelemetry/sdk-metrics": "npm:^1.30.1" - "@opentelemetry/sdk-node": "npm:^0.57.2" - "@opentelemetry/sdk-trace-base": "npm:^1.30.1" - "@opentelemetry/semantic-conventions": "npm:^1.30.0" - cli-spinners: "npm:^2.9.2" - json-stringify-safe: "npm:^5.0.1" - lodash.isobject: "npm:^3.0.2" - lodash.isplainobject: "npm:^4.0.6" - lodash.isstring: "npm:^4.0.1" - node-fetch: "npm:^2.7.0" - open: "npm:^8.4.2" - ora: "npm:^5.4.1" - pino-abstract-transport: "npm:^1.2.0" - semver: "npm:^7.6.2" - shimmer: "npm:^1.2.1" - tslib: "npm:^2.5.3" - winston-transport: "npm:^4.7.0" - bin: - opentelemetry-instrument: build/bin/opentelemetry-instrument.js - checksum: 10c0/dc4101e78b1aca867377b68568a29ad2c1a12ae79ecd07486fbd152d1bc9d4b057469154cb49c7b4a8f6f690f9851d0cb497381bd7dd11ce11bca71e0f884981 - languageName: node - linkType: hard - "@hyperdx/otel-collector@workspace:packages/otel-collector": version: 0.0.0-use.local resolution: "@hyperdx/otel-collector@workspace:packages/otel-collector" languageName: unknown linkType: soft -"@hyperdx/otel-web-session-recorder@npm:0.16.2": - version: 0.16.2 - resolution: "@hyperdx/otel-web-session-recorder@npm:0.16.2" - dependencies: - "@babel/runtime": "npm:~7.18.3" - "@opentelemetry/api": "npm:^1.8.0" - "@opentelemetry/core": "npm:^1.24.1" - "@opentelemetry/resources": "npm:^1.24.1" - fflate: "npm:0.7.4" - long: "npm:^5.2.3" - protobufjs: "npm:~6.11.2" - rrweb: "npm:1.1.3" - type-fest: "npm:4.20.1" - peerDependencies: - "@hyperdx/otel-web": ^0.16.2 - checksum: 10c0/0cc6259efa293e532f5aa2a62f2473a1c595c80b1f71c6907b95e92222b70ddbbc21e117bb3b4cc557919f984cf9605e7d03f78708d52eac1d079b1701aa50d3 - languageName: node - linkType: hard - -"@hyperdx/otel-web@npm:0.16.4": - version: 0.16.4 - resolution: "@hyperdx/otel-web@npm:0.16.4" - dependencies: - "@babel/runtime": "npm:^7.21.0" - "@hyperdx/instrumentation-exception": "npm:^0.1.0" - "@opentelemetry/api": "npm:^1.8.0" - "@opentelemetry/core": "npm:^1.24.1" - "@opentelemetry/exporter-trace-otlp-http": "npm:^0.51.1" - "@opentelemetry/instrumentation": "npm:^0.51.1" - "@opentelemetry/instrumentation-document-load": "npm:^0.38.0" - "@opentelemetry/instrumentation-fetch": "npm:^0.51.1" - "@opentelemetry/instrumentation-user-interaction": "npm:^0.38.0" - "@opentelemetry/instrumentation-xml-http-request": "npm:^0.51.1" - "@opentelemetry/resources": "npm:^1.24.1" - "@opentelemetry/sdk-trace-base": "npm:~1.24.1" - "@opentelemetry/sdk-trace-web": "npm:~1.24.1" - "@opentelemetry/semantic-conventions": "npm:^1.24.1" - json-stringify-safe: "npm:^5.0.1" - lodash: "npm:^4.17.23" - shimmer: "npm:^1.2.1" - web-vitals: "npm:^3.3.2" - checksum: 10c0/fe549fec7e4955254a973c9dd2834968b39958984a8d619f18216c71a95484e28b593a2e264819bd22fc3922f75ff6960779b6d02e51fd7e42a9a6926f892141 - languageName: node - linkType: hard - "@hyperdx/passport-local-mongoose@npm:^9.0.1": version: 9.0.1 resolution: "@hyperdx/passport-local-mongoose@npm:9.0.1" @@ -6968,156 +6860,144 @@ __metadata: languageName: node linkType: hard -"@opentelemetry/api-logs@npm:0.51.1": - version: 0.51.1 - resolution: "@opentelemetry/api-logs@npm:0.51.1" - dependencies: - "@opentelemetry/api": "npm:^1.0.0" - checksum: 10c0/bb469406a1b6f8310c2623b66688d1187731f55516fe3866090ac048d0f58ff88e7d2ad050378d66ca9ce9074529385c884c3a47a8200275abf4dd83b0eaf90a - languageName: node - linkType: hard - -"@opentelemetry/api-logs@npm:0.57.2, @opentelemetry/api-logs@npm:^0.57.1, @opentelemetry/api-logs@npm:^0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/api-logs@npm:0.57.2" +"@opentelemetry/api-logs@npm:0.223.0, @opentelemetry/api-logs@npm:^0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/api-logs@npm:0.223.0" dependencies: "@opentelemetry/api": "npm:^1.3.0" - checksum: 10c0/1e514d3fd4ca68e7e8b008794a95ee0562a5d9e1d3ebb02647b245afaa6c2d72cc14e99e3ea47a1d1007f8a965c62bfb6170e1aa26756230bea063cfde2898bf + checksum: 10c0/3be606243df08c7356d584d48194464050f3c379d63a92cc059de4f45dd5e81bbd7810f0a95419bed71fe4b790d2e495663eaf563f2e67bde30b381182add32e languageName: node linkType: hard -"@opentelemetry/api@npm:1.9.1": +"@opentelemetry/api@npm:1.9.1, @opentelemetry/api@npm:~1.9.1": version: 1.9.1 resolution: "@opentelemetry/api@npm:1.9.1" checksum: 10c0/c608485fc8b5a91e1f7e05e843b45b509307456b31cd2ad365933d90813e40ebfedf179f1451c762037e82d7c76aa8500e95d2da3609f640a1206cde5322cd14 languageName: node linkType: hard -"@opentelemetry/api@npm:^1.0.0": - version: 1.4.1 - resolution: "@opentelemetry/api@npm:1.4.1" - checksum: 10c0/5ee641d3d64c91e87ee328fc22251fc70c809a3c744e51e595ca77c0bd3cad933b77a79beb4dac66b811e5068941cef9da58c1ec217c0748a01f598e08a7ae66 - languageName: node - linkType: hard - -"@opentelemetry/api@npm:^1.3.0, @opentelemetry/api@npm:^1.8.0": +"@opentelemetry/api@npm:^1.3.0": version: 1.9.0 resolution: "@opentelemetry/api@npm:1.9.0" checksum: 10c0/9aae2fe6e8a3a3eeb6c1fdef78e1939cf05a0f37f8a4fae4d6bf2e09eb1e06f966ece85805626e01ba5fab48072b94f19b835449e58b6d26720ee19a58298add languageName: node linkType: hard -"@opentelemetry/auto-instrumentations-node@npm:^0.56.1": - version: 0.56.1 - resolution: "@opentelemetry/auto-instrumentations-node@npm:0.56.1" - dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/instrumentation-amqplib": "npm:^0.46.1" - "@opentelemetry/instrumentation-aws-lambda": "npm:^0.50.3" - "@opentelemetry/instrumentation-aws-sdk": "npm:^0.49.1" - "@opentelemetry/instrumentation-bunyan": "npm:^0.45.1" - "@opentelemetry/instrumentation-cassandra-driver": "npm:^0.45.1" - "@opentelemetry/instrumentation-connect": "npm:^0.43.1" - "@opentelemetry/instrumentation-cucumber": "npm:^0.14.1" - "@opentelemetry/instrumentation-dataloader": "npm:^0.16.1" - "@opentelemetry/instrumentation-dns": "npm:^0.43.1" - "@opentelemetry/instrumentation-express": "npm:^0.47.1" - "@opentelemetry/instrumentation-fastify": "npm:^0.44.2" - "@opentelemetry/instrumentation-fs": "npm:^0.19.1" - "@opentelemetry/instrumentation-generic-pool": "npm:^0.43.1" - "@opentelemetry/instrumentation-graphql": "npm:^0.47.1" - "@opentelemetry/instrumentation-grpc": "npm:^0.57.1" - "@opentelemetry/instrumentation-hapi": "npm:^0.45.2" - "@opentelemetry/instrumentation-http": "npm:^0.57.1" - "@opentelemetry/instrumentation-ioredis": "npm:^0.47.1" - "@opentelemetry/instrumentation-kafkajs": "npm:^0.7.1" - "@opentelemetry/instrumentation-knex": "npm:^0.44.1" - "@opentelemetry/instrumentation-koa": "npm:^0.47.1" - "@opentelemetry/instrumentation-lru-memoizer": "npm:^0.44.1" - "@opentelemetry/instrumentation-memcached": "npm:^0.43.1" - "@opentelemetry/instrumentation-mongodb": "npm:^0.52.0" - "@opentelemetry/instrumentation-mongoose": "npm:^0.46.1" - "@opentelemetry/instrumentation-mysql": "npm:^0.45.1" - "@opentelemetry/instrumentation-mysql2": "npm:^0.45.2" - "@opentelemetry/instrumentation-nestjs-core": "npm:^0.44.1" - "@opentelemetry/instrumentation-net": "npm:^0.43.1" - "@opentelemetry/instrumentation-pg": "npm:^0.51.1" - "@opentelemetry/instrumentation-pino": "npm:^0.46.1" - "@opentelemetry/instrumentation-redis": "npm:^0.46.1" - "@opentelemetry/instrumentation-redis-4": "npm:^0.46.1" - "@opentelemetry/instrumentation-restify": "npm:^0.45.1" - "@opentelemetry/instrumentation-router": "npm:^0.44.1" - "@opentelemetry/instrumentation-socket.io": "npm:^0.46.1" - "@opentelemetry/instrumentation-tedious": "npm:^0.18.1" - "@opentelemetry/instrumentation-undici": "npm:^0.10.1" - "@opentelemetry/instrumentation-winston": "npm:^0.44.1" - "@opentelemetry/resource-detector-alibaba-cloud": "npm:^0.30.1" - "@opentelemetry/resource-detector-aws": "npm:^1.12.0" - "@opentelemetry/resource-detector-azure": "npm:^0.6.1" - "@opentelemetry/resource-detector-container": "npm:^0.6.1" - "@opentelemetry/resource-detector-gcp": "npm:^0.33.1" - "@opentelemetry/resources": "npm:^1.24.0" - "@opentelemetry/sdk-node": "npm:^0.57.1" +"@opentelemetry/auto-instrumentations-node@npm:^0.81.0": + version: 0.81.2 + resolution: "@opentelemetry/auto-instrumentations-node@npm:0.81.2" + dependencies: + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/instrumentation-amqplib": "npm:^0.70.0" + "@opentelemetry/instrumentation-aws-lambda": "npm:^0.75.0" + "@opentelemetry/instrumentation-aws-sdk": "npm:^0.78.0" + "@opentelemetry/instrumentation-bunyan": "npm:^0.68.0" + "@opentelemetry/instrumentation-cassandra-driver": "npm:^0.68.0" + "@opentelemetry/instrumentation-connect": "npm:^0.66.0" + "@opentelemetry/instrumentation-cucumber": "npm:^0.39.0" + "@opentelemetry/instrumentation-dataloader": "npm:^0.40.0" + "@opentelemetry/instrumentation-dns": "npm:^0.66.0" + "@opentelemetry/instrumentation-express": "npm:^0.71.1" + "@opentelemetry/instrumentation-fs": "npm:^0.42.0" + "@opentelemetry/instrumentation-generic-pool": "npm:^0.66.0" + "@opentelemetry/instrumentation-graphql": "npm:^0.71.0" + "@opentelemetry/instrumentation-grpc": "npm:^0.223.0" + "@opentelemetry/instrumentation-hapi": "npm:^0.69.0" + "@opentelemetry/instrumentation-host-metrics": "npm:^0.6.0" + "@opentelemetry/instrumentation-http": "npm:^0.223.0" + "@opentelemetry/instrumentation-ioredis": "npm:^0.71.0" + "@opentelemetry/instrumentation-kafkajs": "npm:^0.32.0" + "@opentelemetry/instrumentation-knex": "npm:^0.67.0" + "@opentelemetry/instrumentation-koa": "npm:^0.71.0" + "@opentelemetry/instrumentation-lru-memoizer": "npm:^0.67.0" + "@opentelemetry/instrumentation-memcached": "npm:^0.66.0" + "@opentelemetry/instrumentation-mongodb": "npm:^0.76.0" + "@opentelemetry/instrumentation-mongoose": "npm:^0.69.0" + "@opentelemetry/instrumentation-mysql": "npm:^0.69.1" + "@opentelemetry/instrumentation-mysql2": "npm:^0.69.0" + "@opentelemetry/instrumentation-nestjs-core": "npm:^0.70.0" + "@opentelemetry/instrumentation-net": "npm:^0.67.0" + "@opentelemetry/instrumentation-openai": "npm:^0.21.0" + "@opentelemetry/instrumentation-oracledb": "npm:^0.48.0" + "@opentelemetry/instrumentation-pg": "npm:^0.76.0" + "@opentelemetry/instrumentation-pino": "npm:^0.69.0" + "@opentelemetry/instrumentation-redis": "npm:^0.71.0" + "@opentelemetry/instrumentation-restify": "npm:^0.68.0" + "@opentelemetry/instrumentation-router": "npm:^0.67.0" + "@opentelemetry/instrumentation-runtime-node": "npm:^0.36.1" + "@opentelemetry/instrumentation-socket.io": "npm:^0.70.0" + "@opentelemetry/instrumentation-tedious": "npm:^0.42.0" + "@opentelemetry/instrumentation-undici": "npm:^0.33.0" + "@opentelemetry/instrumentation-winston": "npm:^0.68.1" + "@opentelemetry/resource-detector-alibaba-cloud": "npm:^0.38.0" + "@opentelemetry/resource-detector-aws": "npm:^2.23.0" + "@opentelemetry/resource-detector-azure": "npm:^0.31.0" + "@opentelemetry/resource-detector-container": "npm:^0.8.14" + "@opentelemetry/resource-detector-gcp": "npm:^0.58.0" + "@opentelemetry/resources": "npm:^2.0.0" + "@opentelemetry/sdk-node": "npm:^0.223.0" peerDependencies: "@opentelemetry/api": ^1.4.1 - checksum: 10c0/20fa3fec19dc7f8a868793a5b1bdc18e8014dafec5184208e885f0ee607b4bc298ec5631aa905a79e35ed801f5d8a7273a89691c4e45c96fa62805f206fafbc2 + "@opentelemetry/core": ^2.0.0 + checksum: 10c0/be388bfc6e5bf3adc2e7b58312bf8904576928776d478c9b40a54a6319b75886f9320af3fed9379b4bea9f508f02c955a800d163ef4fdf2998eb1e98246121ad languageName: node linkType: hard -"@opentelemetry/context-async-hooks@npm:1.30.1": - version: 1.30.1 - resolution: "@opentelemetry/context-async-hooks@npm:1.30.1" - peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.10.0" - checksum: 10c0/3e8114d360060a5225226d2fcd8df08cd542246003790a7f011c0774bc60b8a931f46f4c6673f3977a7d9bba717de6ee028cae51b752c2567053d7f46ed3eba3 - languageName: node - linkType: hard - -"@opentelemetry/core@npm:1.12.0": - version: 1.12.0 - resolution: "@opentelemetry/core@npm:1.12.0" +"@opentelemetry/browser-instrumentation@npm:^0.9.0": + version: 0.9.0 + resolution: "@opentelemetry/browser-instrumentation@npm:0.9.0" dependencies: - "@opentelemetry/semantic-conventions": "npm:1.12.0" + "@opentelemetry/api-logs": "npm:^0.223.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.43.0" + web-vitals: "npm:^6.2.3" peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.5.0" - checksum: 10c0/2fa217d4aaa6c31be4b672c814fe25d4e14eff6429a78c28190f87ecf2d2c47c3b0b3e20e53f3f2724c068dbb6c7e87deb4008bb3855d7e2687f78d12247cee7 + "@opentelemetry/api": ^1.9.1 + checksum: 10c0/5b368bac00a01b9dd0df882e635bada9e213901dcaf74d0ad7003d5adf0ed11a1b26b1c0dabf00774b754d6726cda169bc9431f97552d5becc389e2db5e1b89c languageName: node linkType: hard -"@opentelemetry/core@npm:1.21.0": - version: 1.21.0 - resolution: "@opentelemetry/core@npm:1.21.0" +"@opentelemetry/browser-sdk@npm:^0.6.0": + version: 0.6.0 + resolution: "@opentelemetry/browser-sdk@npm:0.6.0" dependencies: - "@opentelemetry/semantic-conventions": "npm:1.21.0" + "@opentelemetry/api-logs": "npm:^0.223.0" + "@opentelemetry/core": "npm:^2.12.0" + "@opentelemetry/exporter-logs-otlp-http": "npm:^0.223.0" + "@opentelemetry/exporter-trace-otlp-http": "npm:^0.223.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/resources": "npm:^2.12.0" + "@opentelemetry/sdk-logs": "npm:^0.223.0" + "@opentelemetry/sdk-trace": "npm:^2.12.0" + "@opentelemetry/semantic-conventions": "npm:^1.43.0" peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.8.0" - checksum: 10c0/e6f1adcd224944f725ccfc4a337cb20405cb2081fa0a2a66a47a9044b248f47318f43c6d140e8ebbd4082d8657894e9d1a8e1a10db112ca8896c6bc4494c346c + "@opentelemetry/api": ^1.9.1 + checksum: 10c0/e78572a474b80735ef5dc17ed4b30f50576df122535a1b6be355c40214eadd03ebdf1fb17e14a5b4a68066a94864eafe1c6cd9d70fc298173dcd18c78c0a4030 languageName: node linkType: hard -"@opentelemetry/core@npm:1.24.1": - version: 1.24.1 - resolution: "@opentelemetry/core@npm:1.24.1" +"@opentelemetry/configuration@npm:0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/configuration@npm:0.223.0" dependencies: - "@opentelemetry/semantic-conventions": "npm:1.24.1" + "@opentelemetry/core": "npm:2.12.0" + yaml: "npm:^2.8.3" peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.9.0" - checksum: 10c0/e7af32d4253542ee42be74618cef56813ddec878950421d7e51384bde33c5a09f9aeb4391cc9617e1d117091597d1d96a6b80658fb0453a93bcf2d4d316b149d + "@opentelemetry/api": ^1.9.0 + checksum: 10c0/351110987ff43f75b0e6af18623f8f3e71d4a489b965af10a601a5befba7d721b07dc2c6fc31b7604d3dbae81488da28d010a80c2a0e88a0ab933d1f2d26a75b languageName: node linkType: hard -"@opentelemetry/core@npm:1.25.1": - version: 1.25.1 - resolution: "@opentelemetry/core@npm:1.25.1" - dependencies: - "@opentelemetry/semantic-conventions": "npm:1.25.1" +"@opentelemetry/context-async-hooks@npm:2.12.0": + version: 2.12.0 + resolution: "@opentelemetry/context-async-hooks@npm:2.12.0" peerDependencies: "@opentelemetry/api": ">=1.0.0 <1.10.0" - checksum: 10c0/37270396fe3546e454f5a6e8cab0e5777e49a8e4e56ef05644c4e458b3ba7c662f57ad1ba2dd936ddaef54cbe985abd7cee0d3e9188dfdc0e3b3d446c3484337 + checksum: 10c0/fc4185cc643562527532cc5de985edc963a02a68aa1cf6ec517da5602cb51620ea9ffd2201f0fb75295eb9eb7d281a517598a081eeda79a905245a110f21282c languageName: node linkType: hard -"@opentelemetry/core@npm:1.30.1, @opentelemetry/core@npm:^1.0.0, @opentelemetry/core@npm:^1.24.1, @opentelemetry/core@npm:^1.25.0, @opentelemetry/core@npm:^1.25.1, @opentelemetry/core@npm:^1.26.0, @opentelemetry/core@npm:^1.30.1, @opentelemetry/core@npm:^1.8.0": +"@opentelemetry/core@npm:1.30.1": version: 1.30.1 resolution: "@opentelemetry/core@npm:1.30.1" dependencies: @@ -7128,1016 +7008,861 @@ __metadata: languageName: node linkType: hard -"@opentelemetry/core@npm:^1.1.0": - version: 1.15.2 - resolution: "@opentelemetry/core@npm:1.15.2" +"@opentelemetry/core@npm:2.12.0, @opentelemetry/core@npm:^2.0.0, @opentelemetry/core@npm:^2.12.0, @opentelemetry/core@npm:^2.9.0": + version: 2.12.0 + resolution: "@opentelemetry/core@npm:2.12.0" dependencies: - "@opentelemetry/semantic-conventions": "npm:1.15.2" + "@opentelemetry/semantic-conventions": "npm:^1.29.0" peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.5.0" - checksum: 10c0/330f5905edec32f965151f2b314ae73344ac28672ea2c41ac41687413ac91dcd5c7ab99590dac9870ce189bb3d2a73a780c98e7bf1c8826c4c197a5698db96a4 + "@opentelemetry/api": ">=1.0.0 <1.10.0" + checksum: 10c0/e0d0338d314ca827b4395acf8c7eb8f88a58fd63f1effc6068ba4dd8e3443e02e5796333ae6723fb926a7e6c18dd6d2102f5cc7e531b185618562dadbf6cad71 languageName: node linkType: hard -"@opentelemetry/exporter-logs-otlp-grpc@npm:0.57.2, @opentelemetry/exporter-logs-otlp-grpc@npm:^0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/exporter-logs-otlp-grpc@npm:0.57.2" +"@opentelemetry/exporter-logs-otlp-grpc@npm:0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/exporter-logs-otlp-grpc@npm:0.223.0" dependencies: - "@grpc/grpc-js": "npm:^1.7.1" - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/otlp-exporter-base": "npm:0.57.2" - "@opentelemetry/otlp-grpc-exporter-base": "npm:0.57.2" - "@opentelemetry/otlp-transformer": "npm:0.57.2" - "@opentelemetry/sdk-logs": "npm:0.57.2" + "@opentelemetry/otlp-exporter-base": "npm:0.223.0" + "@opentelemetry/otlp-grpc-exporter-base": "npm:0.223.0" + "@opentelemetry/otlp-transformer": "npm:0.223.0" + "@opentelemetry/sdk-logs": "npm:0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/321b7667c37d204ebf1ae02d1250703e5c089f4079282b4f22723ed70d5a7a8cea5f90990845850ed072662d7c862888556c358b5e4fb6f9917497abec402f8b + checksum: 10c0/c6ba6213d9dc960297220e30e86104afbe295016800a5c17efef46ad262e321c34956747eeba1b8c0c4db2de1b50bf2537b75768c8b16baf5ddacfa96cc6cc67 languageName: node linkType: hard -"@opentelemetry/exporter-logs-otlp-http@npm:0.57.2, @opentelemetry/exporter-logs-otlp-http@npm:^0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/exporter-logs-otlp-http@npm:0.57.2" +"@opentelemetry/exporter-logs-otlp-http@npm:0.223.0, @opentelemetry/exporter-logs-otlp-http@npm:^0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/exporter-logs-otlp-http@npm:0.223.0" dependencies: - "@opentelemetry/api-logs": "npm:0.57.2" - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/otlp-exporter-base": "npm:0.57.2" - "@opentelemetry/otlp-transformer": "npm:0.57.2" - "@opentelemetry/sdk-logs": "npm:0.57.2" + "@opentelemetry/otlp-exporter-base": "npm:0.223.0" + "@opentelemetry/otlp-transformer": "npm:0.223.0" + "@opentelemetry/sdk-logs": "npm:0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/3823a5fc66a134e7ca6b60cafad9a4180fc7782c9ffd45fd5ce8bcf4459ec633beb5c0103f9caedffadb85937dfe40b871f6115c852cdbb45d3c7645a3d8baac + checksum: 10c0/9f159081a9aae65134cbf21b8d47961eab4721a72a6130d8e4140cdcbe4f11b7e6ad6bc4732c8517e9d3b3bc9a457350cae7e46d9c64ac9df2b1e0f1b238404b languageName: node linkType: hard -"@opentelemetry/exporter-logs-otlp-proto@npm:0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/exporter-logs-otlp-proto@npm:0.57.2" +"@opentelemetry/exporter-logs-otlp-proto@npm:0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/exporter-logs-otlp-proto@npm:0.223.0" dependencies: - "@opentelemetry/api-logs": "npm:0.57.2" - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/otlp-exporter-base": "npm:0.57.2" - "@opentelemetry/otlp-transformer": "npm:0.57.2" - "@opentelemetry/resources": "npm:1.30.1" - "@opentelemetry/sdk-logs": "npm:0.57.2" - "@opentelemetry/sdk-trace-base": "npm:1.30.1" + "@opentelemetry/otlp-exporter-base": "npm:0.223.0" + "@opentelemetry/otlp-transformer": "npm:0.223.0" + "@opentelemetry/sdk-logs": "npm:0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/2bf929bd50cf837a48e57deed45ad9e7dc531818fad7bb89740ab3af0044f5479817d691458c507a3d052d6b7c00fa5ab1a2b55a1b185a28828fe1c177019895 + checksum: 10c0/ac012ffe406e2465ea450725e6bdecd5131de5e65d38b50e2f62df2cfd9b27f369878dfc25ead7dec444a495b21f4145c0a25ca71bff0fbf53de489792a3989b languageName: node linkType: hard -"@opentelemetry/exporter-metrics-otlp-grpc@npm:0.57.2, @opentelemetry/exporter-metrics-otlp-grpc@npm:^0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/exporter-metrics-otlp-grpc@npm:0.57.2" +"@opentelemetry/exporter-metrics-otlp-grpc@npm:0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/exporter-metrics-otlp-grpc@npm:0.223.0" dependencies: - "@grpc/grpc-js": "npm:^1.7.1" - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/exporter-metrics-otlp-http": "npm:0.57.2" - "@opentelemetry/otlp-exporter-base": "npm:0.57.2" - "@opentelemetry/otlp-grpc-exporter-base": "npm:0.57.2" - "@opentelemetry/otlp-transformer": "npm:0.57.2" - "@opentelemetry/resources": "npm:1.30.1" - "@opentelemetry/sdk-metrics": "npm:1.30.1" + "@opentelemetry/exporter-metrics-otlp-http": "npm:0.223.0" + "@opentelemetry/otlp-grpc-exporter-base": "npm:0.223.0" + "@opentelemetry/otlp-transformer": "npm:0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/b23a5e74c367d47d854e97a16775b29c4df0b893ed9b8c8bb5969b412d21bffcfa65bb95e60405c8976242257e7c6206080cb29d8de1954aff0d7d179c21a95d + checksum: 10c0/1a7a78cc415788f5d24511c478c05f37f891ca8982f452d0fdb87f20fa34494a5b2b6acc3aa5e5e07c9f0d6dc345b7f85a9c6ca9cedf9fb3d97f2e0354e3666d languageName: node linkType: hard -"@opentelemetry/exporter-metrics-otlp-http@npm:0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/exporter-metrics-otlp-http@npm:0.57.2" +"@opentelemetry/exporter-metrics-otlp-http@npm:0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/exporter-metrics-otlp-http@npm:0.223.0" dependencies: - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/otlp-exporter-base": "npm:0.57.2" - "@opentelemetry/otlp-transformer": "npm:0.57.2" - "@opentelemetry/resources": "npm:1.30.1" - "@opentelemetry/sdk-metrics": "npm:1.30.1" + "@opentelemetry/core": "npm:2.12.0" + "@opentelemetry/otlp-exporter-base": "npm:0.223.0" + "@opentelemetry/otlp-transformer": "npm:0.223.0" + "@opentelemetry/resources": "npm:2.12.0" + "@opentelemetry/sdk-metrics": "npm:2.12.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/06732d21aa32bdcd981447eeeeac76660e2d81de92abb10e8baade3c8d8c119f3c0fa25ca26b4dd913c65bd849e99dd9571409fac12771ceba118c6686c40460 + checksum: 10c0/6db9827b6704ec088f0cf52b19fed565797682015c402990e0c0d397dbe4260daf9fec25cb479124fb25cfb31ad4657039002bf664d6e1820205563b615e425d languageName: node linkType: hard -"@opentelemetry/exporter-metrics-otlp-proto@npm:0.57.2, @opentelemetry/exporter-metrics-otlp-proto@npm:^0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/exporter-metrics-otlp-proto@npm:0.57.2" +"@opentelemetry/exporter-metrics-otlp-proto@npm:0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/exporter-metrics-otlp-proto@npm:0.223.0" dependencies: - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/exporter-metrics-otlp-http": "npm:0.57.2" - "@opentelemetry/otlp-exporter-base": "npm:0.57.2" - "@opentelemetry/otlp-transformer": "npm:0.57.2" - "@opentelemetry/resources": "npm:1.30.1" - "@opentelemetry/sdk-metrics": "npm:1.30.1" + "@opentelemetry/exporter-metrics-otlp-http": "npm:0.223.0" + "@opentelemetry/otlp-exporter-base": "npm:0.223.0" + "@opentelemetry/otlp-transformer": "npm:0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/2897b56c7a8823b6060211a78d41a2cd91f5142c6f26bf66ed945ba6f1e1a7f2d156444dd907f3916a458dc0dc3605331e05c11aa8e5810b7289db2527207a2d + checksum: 10c0/9450ae3cbc88abef6b40f658d48d141dbad4f45afe39527dcc9e8b2959f9bf142d22648b478e3680a73ae63f02fa2139a8229a8173aebfb4abd85c6a6262ed06 languageName: node linkType: hard -"@opentelemetry/exporter-prometheus@npm:0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/exporter-prometheus@npm:0.57.2" +"@opentelemetry/exporter-prometheus@npm:0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/exporter-prometheus@npm:0.223.0" dependencies: - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/resources": "npm:1.30.1" - "@opentelemetry/sdk-metrics": "npm:1.30.1" + "@opentelemetry/core": "npm:2.12.0" + "@opentelemetry/resources": "npm:2.12.0" + "@opentelemetry/sdk-metrics": "npm:2.12.0" + "@opentelemetry/semantic-conventions": "npm:^1.29.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/158a4bf256c0a7985964c32dacd9384d268f5573cbe41db1fa6d315440c87b3f8f7b7165749c3db9c8540f80dc573e08a15ce1326138ecc1c90d064142756a1f + checksum: 10c0/c6a596ab91d1165fb4b31abc9535dd79c17ac1deb0b1d604173a8ac1ef6d6bed2906f3a53d0bdf79679282b78ebdea34710a15d4d47b007bcde5ad788194e342 languageName: node linkType: hard -"@opentelemetry/exporter-trace-otlp-grpc@npm:0.57.2, @opentelemetry/exporter-trace-otlp-grpc@npm:^0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/exporter-trace-otlp-grpc@npm:0.57.2" +"@opentelemetry/exporter-trace-otlp-grpc@npm:0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/exporter-trace-otlp-grpc@npm:0.223.0" dependencies: - "@grpc/grpc-js": "npm:^1.7.1" - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/otlp-exporter-base": "npm:0.57.2" - "@opentelemetry/otlp-grpc-exporter-base": "npm:0.57.2" - "@opentelemetry/otlp-transformer": "npm:0.57.2" - "@opentelemetry/resources": "npm:1.30.1" - "@opentelemetry/sdk-trace-base": "npm:1.30.1" + "@opentelemetry/otlp-exporter-base": "npm:0.223.0" + "@opentelemetry/otlp-grpc-exporter-base": "npm:0.223.0" + "@opentelemetry/otlp-transformer": "npm:0.223.0" + "@opentelemetry/sdk-trace": "npm:2.12.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/ac88a7978f231db1d327af0c26807f01230807d4f80a04119cc487aaafed287b9383e0511895d438b76ec35d66e0243ed5ad3eecdcf797caab5f2624c4e28bb4 + checksum: 10c0/678b487d942773debaedf583e79318c9e9e8144bab37a8cc3333c74876bf6936c01e8f8bcc6358370e6d06af50b0cd3f2ec33ee26833a9e43c3f2325fd5e8058 languageName: node linkType: hard -"@opentelemetry/exporter-trace-otlp-http@npm:0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/exporter-trace-otlp-http@npm:0.57.2" +"@opentelemetry/exporter-trace-otlp-http@npm:0.223.0, @opentelemetry/exporter-trace-otlp-http@npm:^0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/exporter-trace-otlp-http@npm:0.223.0" dependencies: - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/otlp-exporter-base": "npm:0.57.2" - "@opentelemetry/otlp-transformer": "npm:0.57.2" - "@opentelemetry/resources": "npm:1.30.1" - "@opentelemetry/sdk-trace-base": "npm:1.30.1" + "@opentelemetry/otlp-exporter-base": "npm:0.223.0" + "@opentelemetry/otlp-transformer": "npm:0.223.0" + "@opentelemetry/sdk-trace": "npm:2.12.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/ccf0f8c573173ed3e735dc007600ec0cc04469f85784acff69fcdaa3423d25f87068618d1454b725f684fbc72481d0d383dac02406a27ba750ce38321bfe718a - languageName: node - linkType: hard - -"@opentelemetry/exporter-trace-otlp-http@npm:^0.51.1": - version: 0.51.1 - resolution: "@opentelemetry/exporter-trace-otlp-http@npm:0.51.1" - dependencies: - "@opentelemetry/core": "npm:1.24.1" - "@opentelemetry/otlp-exporter-base": "npm:0.51.1" - "@opentelemetry/otlp-transformer": "npm:0.51.1" - "@opentelemetry/resources": "npm:1.24.1" - "@opentelemetry/sdk-trace-base": "npm:1.24.1" - peerDependencies: - "@opentelemetry/api": ^1.0.0 - checksum: 10c0/e0909eafab0f4c0a8ca5e37d18f07771f361bfa95b9d57bfb09e69e11abb783c04c3008c6a7eb1aa79e20eb857d1cd142025872f2dc70d8ae8a74830bf3cf2e0 + checksum: 10c0/0c22aa441b9d688064e4ca3693f5e270801a9a80e52d4203e58cdf2d0e83ec2ea16367612a4ae3d9ca4bf4d706a2cb5c2924c9dfd798b18f49e4e2278ac3158f languageName: node linkType: hard -"@opentelemetry/exporter-trace-otlp-proto@npm:0.57.2, @opentelemetry/exporter-trace-otlp-proto@npm:^0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/exporter-trace-otlp-proto@npm:0.57.2" +"@opentelemetry/exporter-trace-otlp-proto@npm:0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/exporter-trace-otlp-proto@npm:0.223.0" dependencies: - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/otlp-exporter-base": "npm:0.57.2" - "@opentelemetry/otlp-transformer": "npm:0.57.2" - "@opentelemetry/resources": "npm:1.30.1" - "@opentelemetry/sdk-trace-base": "npm:1.30.1" + "@opentelemetry/otlp-exporter-base": "npm:0.223.0" + "@opentelemetry/otlp-transformer": "npm:0.223.0" + "@opentelemetry/sdk-trace": "npm:2.12.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/34d82615d81cd02ba2ab02e76122a4957197d6383270a8983d10558df4f765ccbb81a68e559e73380faf4c3f7815efa7b345c0ca36929c07aab679b64808d08f + checksum: 10c0/a825dad88996154878804c63cc0223b5db3235a5aff304112bf1693c671656ed9eb6c48c270167e293a3651c6c22f4b895dc081c738d66c52701fc0911401e34 languageName: node linkType: hard -"@opentelemetry/exporter-zipkin@npm:1.30.1": - version: 1.30.1 - resolution: "@opentelemetry/exporter-zipkin@npm:1.30.1" +"@opentelemetry/exporter-zipkin@npm:2.12.0": + version: 2.12.0 + resolution: "@opentelemetry/exporter-zipkin@npm:2.12.0" dependencies: - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/resources": "npm:1.30.1" - "@opentelemetry/sdk-trace-base": "npm:1.30.1" - "@opentelemetry/semantic-conventions": "npm:1.28.0" + "@opentelemetry/core": "npm:2.12.0" + "@opentelemetry/resources": "npm:2.12.0" + "@opentelemetry/sdk-trace": "npm:2.12.0" + "@opentelemetry/semantic-conventions": "npm:^1.29.0" peerDependencies: "@opentelemetry/api": ^1.0.0 - checksum: 10c0/e2918387c0ddc1835779f5551f5f04b3c1331643f05e3cf6019abf169de035c55be8112a30d5ee0dfef6938cbe260e84c426d5a46bce6f9eb6b2c9b916a425f6 + checksum: 10c0/a0210fbeee84acb5252260f38091c6bedd2246a4451ad1e07429469f40b63992adad954ba87576d9a0b15ef3db140b432ab54e8dd1dc9bd5c9d8ea2acbbd27dd languageName: node linkType: hard -"@opentelemetry/host-metrics@npm:^0.35.5": - version: 0.35.5 - resolution: "@opentelemetry/host-metrics@npm:0.35.5" +"@opentelemetry/instrumentation-amqplib@npm:^0.70.0": + version: 0.70.0 + resolution: "@opentelemetry/instrumentation-amqplib@npm:0.70.0" dependencies: - systeminformation: "npm:5.23.8" + "@opentelemetry/core": "npm:^2.0.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.33.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/3065ab9f8b2f02e26d12298d9a8171cf8370b0af0fd2dd08f7b14685a2587093e31aa46e4a04563c9833914990dcaa7ab858cb7d8f2a0d129f2d41a604df9243 + checksum: 10c0/b0579101a9e24dc20d2bbd81bde9f1da05c13beae5a15893e3d754c0bb09e5202977893b097815b23380ce0bec67151cf1b023ea1c672b83b95bb8da0c4b6b2d languageName: node linkType: hard -"@opentelemetry/instrumentation-amqplib@npm:^0.46.1": - version: 0.46.1 - resolution: "@opentelemetry/instrumentation-amqplib@npm:0.46.1" +"@opentelemetry/instrumentation-aws-lambda@npm:^0.75.0": + version: 0.75.0 + resolution: "@opentelemetry/instrumentation-aws-lambda@npm:0.75.0" dependencies: - "@opentelemetry/core": "npm:^1.8.0" - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/propagator-aws-xray": "npm:^2.1.4" "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@types/aws-lambda": "npm:^8.10.155" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/4a8b870ccaa64cfd200663ec14385aca7eeb7146124d82e566f3d48678f237c9a56661ae3401345fe0dce5c56366ae02a312dc7905eb4fd6e073df2cface30fb + checksum: 10c0/3e616dba42eec8c6860885aba6669654498328a0bab77483079a52d70f3f33007ff72f4ee6f1b43ed44871365620abb16e9d3d68a51cb048e853be9b3f09a441 languageName: node linkType: hard -"@opentelemetry/instrumentation-aws-lambda@npm:^0.50.3": - version: 0.50.3 - resolution: "@opentelemetry/instrumentation-aws-lambda@npm:0.50.3" +"@opentelemetry/instrumentation-aws-sdk@npm:^0.78.0": + version: 0.78.0 + resolution: "@opentelemetry/instrumentation-aws-sdk@npm:0.78.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" - "@types/aws-lambda": "npm:8.10.147" + "@opentelemetry/core": "npm:^2.0.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.34.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/40bd0394946214a66f4f1b6a26cf53e0e238edfb8df8a72d4a2f9913e7bca50c07d8e32cd6fd93434bef15bb784cff8c490f62368cca4ab9285f2394626a930e + checksum: 10c0/0b722756a61f3d589ef92fcd5bf186dc4dae9691fb51018d1b8ff85e26a76aa2c0d6afc0ae3fe955ba313002c3b51509658ba996ac366ec369fbf86bc8af041b languageName: node linkType: hard -"@opentelemetry/instrumentation-aws-sdk@npm:^0.49.1": - version: 0.49.1 - resolution: "@opentelemetry/instrumentation-aws-sdk@npm:0.49.1" +"@opentelemetry/instrumentation-bunyan@npm:^0.68.0": + version: 0.68.0 + resolution: "@opentelemetry/instrumentation-bunyan@npm:0.68.0" dependencies: - "@opentelemetry/core": "npm:^1.8.0" - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/propagation-utils": "npm:^0.30.16" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/api-logs": "npm:^0.223.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.41.1" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/9b1d0f7c3704f78eaee6c380c929bd43c2b2f95d5c1c057ec8a26589a71764bd58f8bd4a32a5b30bafd2aa5c414e43eb28c08cd86985dba7da778b8a44df842f + checksum: 10c0/64ecd65e39477b49f1fc20305fb8f0898ff4fccdcd5dfa7f5af1f4dfab55ad8bf53f4986b09d52d3c0c6ac7e9502c544f89dc78b4a3ea300d9ab104a57164c93 languageName: node linkType: hard -"@opentelemetry/instrumentation-bunyan@npm:^0.45.1": - version: 0.45.1 - resolution: "@opentelemetry/instrumentation-bunyan@npm:0.45.1" +"@opentelemetry/instrumentation-cassandra-driver@npm:^0.68.0": + version: 0.68.0 + resolution: "@opentelemetry/instrumentation-cassandra-driver@npm:0.68.0" dependencies: - "@opentelemetry/api-logs": "npm:^0.57.1" - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@types/bunyan": "npm:1.8.11" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.37.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/791529b7e5736c55549d72d89b8a7e465e95eba5298e49f0a8547e8a6ff088ba2b2cff06cd70dbdb7dd9063df1f9aad14e2722bd755b28794cf59739e1ec8db3 + checksum: 10c0/9a1fa66d889d13e6a99335bb12b4c515e387a746131e119ede9caf95d9d2368b9f5749b3c4aa68f5ebb7e158efba77773c55d0971ebf9900b08c5de5383a28fa languageName: node linkType: hard -"@opentelemetry/instrumentation-cassandra-driver@npm:^0.45.1": - version: 0.45.1 - resolution: "@opentelemetry/instrumentation-cassandra-driver@npm:0.45.1" +"@opentelemetry/instrumentation-connect@npm:^0.66.0": + version: 0.66.0 + resolution: "@opentelemetry/instrumentation-connect@npm:0.66.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/core": "npm:^2.0.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@types/connect": "npm:3.4.38" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/6401c6a94a945515fd71a49d1f086210c464ce4b3d7072cad28c7ba9287887d4404d31f8b34aab0b807f68b3befc6a7e0bb923a000febd947e95c960b3673c59 + checksum: 10c0/b5dea959a74cf896382bf351ab8bfc5613a35f6a4845d00dc8161d4dedaa0f3acc8a1243cc63667064404a20efa6ae09059f80ef62a7a55819f3d82ecb30da6a languageName: node linkType: hard -"@opentelemetry/instrumentation-connect@npm:^0.43.1": - version: 0.43.1 - resolution: "@opentelemetry/instrumentation-connect@npm:0.43.1" +"@opentelemetry/instrumentation-console@npm:^0.5.0": + version: 0.5.0 + resolution: "@opentelemetry/instrumentation-console@npm:0.5.0" dependencies: - "@opentelemetry/core": "npm:^1.8.0" - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" - "@types/connect": "npm:3.4.38" + "@opentelemetry/api-logs": "npm:^0.223.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" peerDependencies: - "@opentelemetry/api": ^1.3.0 - checksum: 10c0/a7e2629fbfa775f2d1a6b2c9387e27809db16177cf6de89159017d7353c270c6c84d81550c58ccc51ea72c2304b1fcb911499440451d8df6954cc1f4e654eb64 + "@opentelemetry/api": ^1.9.1 + checksum: 10c0/6af16c1b8f3af42735598e2b5a23391f5243643e226d39ab12410c1223f8c2ca00dcf47c3066c1ee0beea76a013eb63fbfcac9c5b57617ef7dbf1ad4486f517c languageName: node linkType: hard -"@opentelemetry/instrumentation-cucumber@npm:^0.14.1": - version: 0.14.1 - resolution: "@opentelemetry/instrumentation-cucumber@npm:0.14.1" +"@opentelemetry/instrumentation-cucumber@npm:^0.39.0": + version: 0.39.0 + resolution: "@opentelemetry/instrumentation-cucumber@npm:0.39.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/instrumentation": "npm:^0.223.0" "@opentelemetry/semantic-conventions": "npm:^1.27.0" peerDependencies: "@opentelemetry/api": ^1.0.0 - checksum: 10c0/73481d39f5d0a9e97ca700afed52db38774d7266b9370b72d3fe0f10de8a9978616908bfbf80ec5be22e67602610fdce5bf7026f8d13333be4bf05654c89c97c + checksum: 10c0/bf358f857f777ceef4496389ba35f0558eaf9a14e5b03da7da7db6f62c38189eed1d89251636c79768df1fc4c58452c0678104a409f8d5f64ff34927ee8ae400 languageName: node linkType: hard -"@opentelemetry/instrumentation-dataloader@npm:^0.16.1": - version: 0.16.1 - resolution: "@opentelemetry/instrumentation-dataloader@npm:0.16.1" +"@opentelemetry/instrumentation-dataloader@npm:^0.40.0": + version: 0.40.0 + resolution: "@opentelemetry/instrumentation-dataloader@npm:0.40.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/instrumentation": "npm:^0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/83bd0267672cc3e8709401e1f107612aed3bb72faedfed76fe25e174b19c41f65d503bc3a666ba0872bbef8c31adcefb8884982f785fa3b0df28eec40b6578aa + checksum: 10c0/70daab40e59dc8cc5f4f3ad35caf9c225f2d82771069b3a7050b5bfec29107b3ca6a58002c1df9acc21be6c27330305d8e8965a93bfb4c77df994f4fe1b35d72 languageName: node linkType: hard -"@opentelemetry/instrumentation-dns@npm:^0.43.1": - version: 0.43.1 - resolution: "@opentelemetry/instrumentation-dns@npm:0.43.1" +"@opentelemetry/instrumentation-dns@npm:^0.66.0": + version: 0.66.0 + resolution: "@opentelemetry/instrumentation-dns@npm:0.66.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/instrumentation": "npm:^0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/ae747e168222890470f638a4e720f641d845b512e857ee57326012697a0858e40ba9dbb59000c87bb0b09b3c0af8b072acafdc66098019a22042f1e79b248e9d + checksum: 10c0/c8f883ded91b652a28ab0bff801821e975e66b2d968b112eb1fbfd1630696718f8ae4a44e95975cd156f1f00480740c2405c0880a3640956761d10d5adf18850 languageName: node linkType: hard -"@opentelemetry/instrumentation-document-load@npm:^0.38.0": - version: 0.38.0 - resolution: "@opentelemetry/instrumentation-document-load@npm:0.38.0" +"@opentelemetry/instrumentation-express@npm:^0.71.1": + version: 0.71.1 + resolution: "@opentelemetry/instrumentation-express@npm:0.71.1" dependencies: - "@opentelemetry/core": "npm:^1.8.0" - "@opentelemetry/instrumentation": "npm:^0.51.0" - "@opentelemetry/sdk-trace-base": "npm:^1.0.0" - "@opentelemetry/sdk-trace-web": "npm:^1.15.0" - "@opentelemetry/semantic-conventions": "npm:^1.22.0" - peerDependencies: - "@opentelemetry/api": ^1.3.0 - checksum: 10c0/720f023963b3e7fa555e7e56b3f24f686661c05c70161350c638c4a198e3fe7a345443738f8045e6e8cbd34606a25e6c960af128618aa71b086348e2a6c0f4c7 - languageName: node - linkType: hard - -"@opentelemetry/instrumentation-express@npm:^0.47.1": - version: 0.47.1 - resolution: "@opentelemetry/instrumentation-express@npm:0.47.1" - dependencies: - "@opentelemetry/core": "npm:^1.8.0" - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/core": "npm:^2.9.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" "@opentelemetry/semantic-conventions": "npm:^1.27.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/eca448eb088857c7c0c7d0a1875b9e20a990b23e2f64355d2e645618d3f5c038efb9d605009a6d8fa1e05243d0ccef14b9aa1effffee693fd071de3cc39ad3d1 + checksum: 10c0/69e5fc75dd93a843b853a34ae5660cbc01188fef80167391c8a34374989ac545580a89791a11c43fe40a6721aebc2b6e627a75d39ae9b3cd018be89aecfbe529 languageName: node linkType: hard -"@opentelemetry/instrumentation-fastify@npm:^0.44.2": - version: 0.44.2 - resolution: "@opentelemetry/instrumentation-fastify@npm:0.44.2" +"@opentelemetry/instrumentation-fs@npm:^0.42.0": + version: 0.42.0 + resolution: "@opentelemetry/instrumentation-fs@npm:0.42.0" dependencies: - "@opentelemetry/core": "npm:^1.8.0" - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/core": "npm:^2.9.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/2306bbf9b59e5d29002b9c14493de92817e268c92587b285a0a4bbeece4a3f791db8e0d1be0e22ad9f6a97075071aa5c3269cf2d219e378480dc1ceafbf2927c + checksum: 10c0/c2fba7bac5a488e7afaf4912ca60b183117e22350c8abec853301c6a59b24471882aa23a260eed670dfb81fd9138db6792b6ee6b39560fe89cb686bb9e82227f languageName: node linkType: hard -"@opentelemetry/instrumentation-fetch@npm:^0.51.1": - version: 0.51.1 - resolution: "@opentelemetry/instrumentation-fetch@npm:0.51.1" +"@opentelemetry/instrumentation-generic-pool@npm:^0.66.0": + version: 0.66.0 + resolution: "@opentelemetry/instrumentation-generic-pool@npm:0.66.0" dependencies: - "@opentelemetry/core": "npm:1.24.1" - "@opentelemetry/instrumentation": "npm:0.51.1" - "@opentelemetry/sdk-trace-web": "npm:1.24.1" - "@opentelemetry/semantic-conventions": "npm:1.24.1" - peerDependencies: - "@opentelemetry/api": ^1.0.0 - checksum: 10c0/ec28f862ceb91eaac383263b2a5322d40cd47f87fa743e4ae731920d239049b7c105bb59bc8d55af7f517fef0b1e176aba35652dced77be32959ca8e78234087 - languageName: node - linkType: hard - -"@opentelemetry/instrumentation-fs@npm:^0.19.1": - version: 0.19.1 - resolution: "@opentelemetry/instrumentation-fs@npm:0.19.1" - dependencies: - "@opentelemetry/core": "npm:^1.8.0" - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/instrumentation": "npm:^0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/8bf714658c0fcc34ba7db4c28af3196690f756a9b4fb6d1b6cab59938a7b5c1e40e834c518b39085e744915c0c384ca6d997a8a97901955732acf3af0cba6e7f + checksum: 10c0/5b49fd633e07dfc50c1a66e90f446abde376610cb6acf70cf5a8600c5f19a8779d9e9a2fab5a68f69b1243cddd26a48aa5053c281732debd7d8a8117e5ffd0df languageName: node linkType: hard -"@opentelemetry/instrumentation-generic-pool@npm:^0.43.1": - version: 0.43.1 - resolution: "@opentelemetry/instrumentation-generic-pool@npm:0.43.1" +"@opentelemetry/instrumentation-graphql@npm:^0.71.0": + version: 0.71.0 + resolution: "@opentelemetry/instrumentation-graphql@npm:0.71.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/instrumentation": "npm:^0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/bdc95146d1f6f5dcf5922af8161c4954b9feeb505a01c5e61b1246ed67909dc1f6e72ad067839f085a4977e863246e7e4b468c814cf4104f35fcc20fb570eac2 + checksum: 10c0/14c6d55f142bc81ff74bef18382806d22a309650e28c19df65a420413a674031f2ba7a595e7ac1346284ed4b77ed825c7023b8597876b68bd54033d62bdf0357 languageName: node linkType: hard -"@opentelemetry/instrumentation-graphql@npm:^0.47.1": - version: 0.47.1 - resolution: "@opentelemetry/instrumentation-graphql@npm:0.47.1" +"@opentelemetry/instrumentation-grpc@npm:^0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/instrumentation-grpc@npm:0.223.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/instrumentation": "npm:0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.29.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/d5cfeb668b5ea4e4d97d8433c642457ac9f7f2023278a84a183b4c4c2cc43bbae3eac916ff7176ef8492661877560b519663c52eb2fad0a8a1f00718a0449aa6 + checksum: 10c0/a90a218eedc7928190651d6e5d829f15925bf71c67e98cb32cc831e11ba23fd69beaf8c9d4977798eeb98566377113ba415c30e5448ba437b24cd4dfd528f4c5 languageName: node linkType: hard -"@opentelemetry/instrumentation-grpc@npm:^0.57.1": - version: 0.57.2 - resolution: "@opentelemetry/instrumentation-grpc@npm:0.57.2" +"@opentelemetry/instrumentation-hapi@npm:^0.69.0": + version: 0.69.0 + resolution: "@opentelemetry/instrumentation-hapi@npm:0.69.0" dependencies: - "@opentelemetry/instrumentation": "npm:0.57.2" - "@opentelemetry/semantic-conventions": "npm:1.28.0" + "@opentelemetry/core": "npm:^2.9.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.27.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/dd5d28907c1ab88ff9de16fd1267c40c1c1a7db0d26267b4b5c7f77837d567aa45167fc9838a9907e43ded94924ccedd4ff2a6c1411e152edb290d518561c4fb + checksum: 10c0/288f0d462426747d8c6af4b38b43d3dd9ed71622aedbb3ab7247ca12f23a7377baed28043ba6bd57e97782d41161a3ad9b545e5a0350378520f44c3accbddba7 languageName: node linkType: hard -"@opentelemetry/instrumentation-hapi@npm:^0.45.2": - version: 0.45.2 - resolution: "@opentelemetry/instrumentation-hapi@npm:0.45.2" +"@opentelemetry/instrumentation-host-metrics@npm:^0.6.0": + version: 0.6.0 + resolution: "@opentelemetry/instrumentation-host-metrics@npm:0.6.0" dependencies: - "@opentelemetry/core": "npm:^1.8.0" - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + systeminformation: "npm:^5.31.6" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/bb491327ce86d8f1f7e2a12621a00dbf921e1fc3e9b64f975fc23e443d92bcd6ef779b34349214871763d459650da219c5e23bb1fdd1bc261fa0f92190521b2e + checksum: 10c0/d9f8025927c6f7f4948d682b0447d6bf9b79029d1863f0f2686e50821d6250a1f44163ea7136a1460c679c796e54136ff37ec8737ec11cdb7df9979452473cc9 languageName: node linkType: hard -"@opentelemetry/instrumentation-http@npm:^0.57.1, @opentelemetry/instrumentation-http@npm:^0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/instrumentation-http@npm:0.57.2" +"@opentelemetry/instrumentation-http@npm:^0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/instrumentation-http@npm:0.223.0" dependencies: - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/instrumentation": "npm:0.57.2" - "@opentelemetry/semantic-conventions": "npm:1.28.0" + "@opentelemetry/core": "npm:2.12.0" + "@opentelemetry/instrumentation": "npm:0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.29.0" forwarded-parse: "npm:2.1.2" - semver: "npm:^7.5.2" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/b95a1b61cddabd32358fa565a4fcf5c17e8340907b171dcdf2a104533c9afdee821efa7b82dabb3123318dcc66272b0a7b8c37c44fc87e593cb8138a7a63fc23 + checksum: 10c0/24edf71293780b1ca1384fd599ef7cf75393aa3047ed26c1041759e407e1d5bcee88948695b43133994d87f20b54faf0e8a7d090be1689ce9f71141478866e96 languageName: node linkType: hard -"@opentelemetry/instrumentation-ioredis@npm:^0.47.1": - version: 0.47.1 - resolution: "@opentelemetry/instrumentation-ioredis@npm:0.47.1" +"@opentelemetry/instrumentation-ioredis@npm:^0.71.0": + version: 0.71.0 + resolution: "@opentelemetry/instrumentation-ioredis@npm:0.71.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/redis-common": "npm:^0.36.2" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/redis-common": "npm:^0.38.3" + "@opentelemetry/semantic-conventions": "npm:^1.33.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/ec741778041cecc133a143292d66631c99311bf098db8f03276a48b87fe18826eec4513e4de70bb555ef50268db6520442e9a2f7752f7ea9b5a3e8363fecb8c9 + checksum: 10c0/fe7413ae48ef14bddd2281cbd1e0928bf5668f987b44dca7567ce74b14d1ced981b2e0777eebcb1191a94d94f1f2f87ce6973fbbcdd109ef67f63e2a475de7ce languageName: node linkType: hard -"@opentelemetry/instrumentation-kafkajs@npm:^0.7.1": - version: 0.7.1 - resolution: "@opentelemetry/instrumentation-kafkajs@npm:0.7.1" +"@opentelemetry/instrumentation-kafkajs@npm:^0.32.0": + version: 0.32.0 + resolution: "@opentelemetry/instrumentation-kafkajs@npm:0.32.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.30.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/440a479ec65414da706f15b5c2ff82235ea8b11701e811ae235af5e8f01bee7e639223243e9f18550ce55cc94b8cdaa8a72297ded55f1c7993f1d95488c2b02e + checksum: 10c0/cdfa03f7b7828a7f0c9868c83896f55b902b7749400738e280dd0c0c01c3cd417628be698be364fd1b1bffe645a163312a0be84ee8d37e7f980c04d5f3237d6c languageName: node linkType: hard -"@opentelemetry/instrumentation-knex@npm:^0.44.1": - version: 0.44.1 - resolution: "@opentelemetry/instrumentation-knex@npm:0.44.1" +"@opentelemetry/instrumentation-knex@npm:^0.67.0": + version: 0.67.0 + resolution: "@opentelemetry/instrumentation-knex@npm:0.67.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.33.1" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/75dcbda2c412cc448ac95238899d92846bda14bb21a1c9e9bc0c51fd48dcedb6064c2a8ab9e53d112945748d50513ecda13afbc4c0f24a884674d2a485f0efcd + checksum: 10c0/2cb7461a1e5ac94b5dce0a5fcf8fbdf3ea8829b6e5912bb68ce9308ab7280bb7aacea4e1a5563622cbc6af33969af765c1888de771a708f04c5ca74756794249 languageName: node linkType: hard -"@opentelemetry/instrumentation-koa@npm:^0.47.1": - version: 0.47.1 - resolution: "@opentelemetry/instrumentation-koa@npm:0.47.1" +"@opentelemetry/instrumentation-koa@npm:^0.71.0": + version: 0.71.0 + resolution: "@opentelemetry/instrumentation-koa@npm:0.71.0" dependencies: - "@opentelemetry/core": "npm:^1.8.0" - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/core": "npm:^2.9.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.36.0" peerDependencies: - "@opentelemetry/api": ^1.3.0 - checksum: 10c0/a1c5433da1265f1f8da3e46ebe085a3ddba3e16f43c5f44bd41082a0839f6bdf9a6a737b80b0d2f2a05d1ef2c23e2b0a4f7e55858bf1e32570b4c150c69135bc + "@opentelemetry/api": ^1.9.0 + checksum: 10c0/031aa0a8662b20a77457ae07d1a8496a4481bd558f9212f0d867ff33ac1f34d1d24927e4a110c2b4d6a48f2c86ba91385221643c04a66af1a3425f036ed4d7d3 languageName: node linkType: hard -"@opentelemetry/instrumentation-lru-memoizer@npm:^0.44.1": - version: 0.44.1 - resolution: "@opentelemetry/instrumentation-lru-memoizer@npm:0.44.1" +"@opentelemetry/instrumentation-long-task@npm:^0.67.0": + version: 0.67.0 + resolution: "@opentelemetry/instrumentation-long-task@npm:0.67.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/core": "npm:^2.9.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/5728d0b6ed560ba8426546ab30ef251cbe9f25a130abc8bea0d7635b51cc29fbade4d00c7b1869fa0543fe54891799483fe0f6fb4073d1bf5d12dbdd543aaae5 + checksum: 10c0/151df6c3f108ecd32e128adce5bacbe76f1380a35e0ae210379a7b6f1f2360589bcb484d185b074dd26ca03f86b930430164192d43082757b334fe78f3a10da3 languageName: node linkType: hard -"@opentelemetry/instrumentation-memcached@npm:^0.43.1": - version: 0.43.1 - resolution: "@opentelemetry/instrumentation-memcached@npm:0.43.1" +"@opentelemetry/instrumentation-lru-memoizer@npm:^0.67.0": + version: 0.67.0 + resolution: "@opentelemetry/instrumentation-lru-memoizer@npm:0.67.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" - "@types/memcached": "npm:^2.2.6" + "@opentelemetry/instrumentation": "npm:^0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/a0e4cd09b88c4586113812464c88dbdd322022398525af6e229381b187786ac621a955450f5f9be907122adca92ffe80617f68e39efb514d167d7e5459798e7b + checksum: 10c0/3419ae17778801d4665be73dbc2524fc5c7bd9da00c049b40c88ddc93c799e26d7ccb7b2daf736b55bdd7bfc2d3a0b457e7b2d65f0d67adc699653a130628adf languageName: node linkType: hard -"@opentelemetry/instrumentation-mongodb@npm:^0.52.0": - version: 0.52.0 - resolution: "@opentelemetry/instrumentation-mongodb@npm:0.52.0" +"@opentelemetry/instrumentation-memcached@npm:^0.66.0": + version: 0.66.0 + resolution: "@opentelemetry/instrumentation-memcached@npm:0.66.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.33.0" + "@types/memcached": "npm:^2.2.6" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/dcd072a296369a6b254a809e3708e5f9842ac9f8c61700bfa2014872fa6e6ca65adfa5efdbf9021df57e749dea2cddd828351e73cb581370b8b97693c06df7e8 + checksum: 10c0/d29843c184d88757fb6d23e35f47bb88646d625b6e6a63a16907dcfd54190880516aaa519eaa4129829601f094ab490f0a5e6147c31a2e494df0a3b5447fb7f6 languageName: node linkType: hard -"@opentelemetry/instrumentation-mongoose@npm:^0.46.1": - version: 0.46.1 - resolution: "@opentelemetry/instrumentation-mongoose@npm:0.46.1" +"@opentelemetry/instrumentation-mongodb@npm:^0.76.0": + version: 0.76.0 + resolution: "@opentelemetry/instrumentation-mongodb@npm:0.76.0" dependencies: - "@opentelemetry/core": "npm:^1.8.0" - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.33.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/69378d41df172c2edb8b36042e751936837bb1cbee11ee72a3d1608c6d7f609d79beec2020b25de72086553ad9d85347642c4066e0b4e96d442513b29ac4f0aa + checksum: 10c0/61cfcfb17952147d22b26fb8924717bd265f13291007ec6f2d5bdc7df4141bdcd090103e6224f3fca6ab6bfe80af86968db2894e936f7bab414ad761455533b8 languageName: node linkType: hard -"@opentelemetry/instrumentation-mysql2@npm:^0.45.2": - version: 0.45.2 - resolution: "@opentelemetry/instrumentation-mysql2@npm:0.45.2" +"@opentelemetry/instrumentation-mongoose@npm:^0.69.0": + version: 0.69.0 + resolution: "@opentelemetry/instrumentation-mongoose@npm:0.69.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" - "@opentelemetry/sql-common": "npm:^0.40.1" + "@opentelemetry/core": "npm:^2.9.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.33.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/8ac62064b32facfddd7d47ba0bce9689d2277ba4ef74348655faffe818522c919654c5bf1a5fac211a75f2093fbd588a14cba278c353da2f60d1919d58d419aa + checksum: 10c0/610b53a7577cf005f1524c02e070a8b59de5c5d278214b2eedd943377177bfe9836a2d71b5766420eda84bb5298be07eb49b1dd2d7fff1980022503aee549c95 languageName: node linkType: hard -"@opentelemetry/instrumentation-mysql@npm:^0.45.1": - version: 0.45.1 - resolution: "@opentelemetry/instrumentation-mysql@npm:0.45.1" +"@opentelemetry/instrumentation-mysql2@npm:^0.69.0": + version: 0.69.0 + resolution: "@opentelemetry/instrumentation-mysql2@npm:0.69.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" - "@types/mysql": "npm:2.15.26" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.33.0" + "@opentelemetry/sql-common": "npm:^0.42.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/c820a6929fe2e010dacb8962d40fdb8c9ac95c265efc74f478eadc021b2a3add9ce8d303c4bda20af01327564f487c9e052e710d9e975d7f17a5918d802d7ae4 + checksum: 10c0/332a5c58ba64f050cd449995e5ead1126f6741c8bcfa48400368b28575f585b1dd2a7c5595339602cc0128ffe10653b7207e1ebeea089796885ba76ff98696f8 languageName: node linkType: hard -"@opentelemetry/instrumentation-nestjs-core@npm:^0.44.1": - version: 0.44.1 - resolution: "@opentelemetry/instrumentation-nestjs-core@npm:0.44.1" +"@opentelemetry/instrumentation-mysql@npm:^0.69.1": + version: 0.69.1 + resolution: "@opentelemetry/instrumentation-mysql@npm:0.69.1" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.33.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/bd9f4b931305f9e184aeaf0fe2c36c1a88579012f5d43a2f029a4dd147d0c77c24301aaa6096ab84cc439a8c57ca43abbf1de4d67faa3c7235707975ae631080 + checksum: 10c0/b7b1dc7f662dc03650d7514705324606e09e9a3b12c12cb5dbcbe771c80608497c9e568ea2d52494d8b1f45f1004f222e6f5adb3ae5b8c8b25b100957382457b languageName: node linkType: hard -"@opentelemetry/instrumentation-net@npm:^0.43.1": - version: 0.43.1 - resolution: "@opentelemetry/instrumentation-net@npm:0.43.1" +"@opentelemetry/instrumentation-nestjs-core@npm:^0.70.0": + version: 0.70.0 + resolution: "@opentelemetry/instrumentation-nestjs-core@npm:0.70.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.30.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/aadbaa06d6334267e75596ad093438ebf9d3b9f72dfaa89cc12459b537ba24ccf02323756ef78aded31bcb1018e51eb129eed4fe19b59c08327298452fd022bc + checksum: 10c0/44ef2a4eeed92e10e6129355a684dd5e3982dfcb6fbc823a33c66ec49222fdff899ece8e732e92823551fe7ac4e36bd7c2e972f0c7711648727faa464826fc81 languageName: node linkType: hard -"@opentelemetry/instrumentation-pg@npm:^0.51.1": - version: 0.51.1 - resolution: "@opentelemetry/instrumentation-pg@npm:0.51.1" +"@opentelemetry/instrumentation-net@npm:^0.67.0": + version: 0.67.0 + resolution: "@opentelemetry/instrumentation-net@npm:0.67.0" dependencies: - "@opentelemetry/core": "npm:^1.26.0" - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" - "@opentelemetry/sql-common": "npm:^0.40.1" - "@types/pg": "npm:8.6.1" - "@types/pg-pool": "npm:2.0.6" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.33.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/fff3dcc092b959601a20c20e19c27d39d6386e6bc2b7014c1be5a5e22c0e275bf9980dad758b1f7824b1448a6178e13938b6bb2da53095f410fbb4d248b5ede6 + checksum: 10c0/a54e1ed66d44db521877673cb9c56e0e2132a40123c31765112b179911108954e555016a6c7bdf1f6a254bb868362b75112941329ecf55e40ed125749604811f languageName: node linkType: hard -"@opentelemetry/instrumentation-pino@npm:^0.46.1": - version: 0.46.1 - resolution: "@opentelemetry/instrumentation-pino@npm:0.46.1" +"@opentelemetry/instrumentation-openai@npm:^0.21.0": + version: 0.21.0 + resolution: "@opentelemetry/instrumentation-openai@npm:0.21.0" dependencies: - "@opentelemetry/api-logs": "npm:^0.57.1" - "@opentelemetry/core": "npm:^1.25.0" - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/api-logs": "npm:^0.223.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.36.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/aa8e20ff91fa9883dc4f1361580472fa8489dc8f23bb5567b8c66c399f1ff235698a1e546e6a939204aefc81f7baf7e0688aee2f4be3ab37bb4a6ea2500fcdf5 + checksum: 10c0/c59a80d3720b1df90d71e6ea1cbfd3d5f28a1a2791c2eda7d1a59f565e2d383cf562b5a160c6d732c66418424dc865082ff661b8c6df3aa39bab1002a8f221c2 languageName: node linkType: hard -"@opentelemetry/instrumentation-redis-4@npm:^0.46.1": - version: 0.46.1 - resolution: "@opentelemetry/instrumentation-redis-4@npm:0.46.1" +"@opentelemetry/instrumentation-oracledb@npm:^0.48.0": + version: 0.48.0 + resolution: "@opentelemetry/instrumentation-oracledb@npm:0.48.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/redis-common": "npm:^0.36.2" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/core": "npm:^2.9.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.34.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/df0bdd865e254c9b4c0339ce5aabf3698d99b8ab8cf8ea1aa57ffa13620f2193fda247ed43ec4ccc6edadab1ffec5cc263038ab6f3c9e96ef000ee232b9181f8 + checksum: 10c0/93e32064286562841ffbfe5c2efb15cd3d339814ebd156dea453ac2cf9cab095d67c8005e2ebd79ba34f2c2542827ce2ee20a4fef4457f2765cee1a5a7034f87 languageName: node linkType: hard -"@opentelemetry/instrumentation-redis@npm:^0.46.1": - version: 0.46.1 - resolution: "@opentelemetry/instrumentation-redis@npm:0.46.1" +"@opentelemetry/instrumentation-pg@npm:^0.76.0": + version: 0.76.0 + resolution: "@opentelemetry/instrumentation-pg@npm:0.76.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/redis-common": "npm:^0.36.2" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/core": "npm:^2.9.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.34.0" + "@opentelemetry/sql-common": "npm:^0.42.0" + "@types/pg": "npm:8.15.6" + "@types/pg-pool": "npm:2.0.7" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/e70f3d4ea8933aa5eeafe3d643a69f1dbcc0d26d24a0dadb5833aaf964cfc5c92600cdc775a33c6449521719364e19ba9be839f436aec12aee52e8586fa90c7d + checksum: 10c0/b7557905aa7928308bcc417af59fea935fbe65ac7c44d68d6edd13e9aeac8ac67a4c88f5cb0c3ebd6f5e9d32d5724e42ba375dd5e93533a7116e8cc27f29cb6f languageName: node linkType: hard -"@opentelemetry/instrumentation-restify@npm:^0.45.1": - version: 0.45.1 - resolution: "@opentelemetry/instrumentation-restify@npm:0.45.1" +"@opentelemetry/instrumentation-pino@npm:^0.69.0": + version: 0.69.0 + resolution: "@opentelemetry/instrumentation-pino@npm:0.69.0" dependencies: - "@opentelemetry/core": "npm:^1.8.0" - "@opentelemetry/instrumentation": "npm:^0.57.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/api-logs": "npm:^0.223.0" + "@opentelemetry/core": "npm:^2.9.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.41.1" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/df3428db1d9d4a1dca070490213841cb87b93cdb61807208408f92ce7bf5b1b99cd7f907168383a942b3f6cd7a0d2723c49b4df4a48d4f233086fdbfd17915a4 + checksum: 10c0/71ea470a7cf8af5a1c86b2ba4c1a45b30eaab513279c0bbeeed6acf1d4efba4f7d83edb0cc3c59521376654e8f5b1c2ae46d51b744edf85da77a523e843fdbdc languageName: node linkType: hard -"@opentelemetry/instrumentation-router@npm:^0.44.1": - version: 0.44.1 - resolution: "@opentelemetry/instrumentation-router@npm:0.44.1" +"@opentelemetry/instrumentation-redis@npm:^0.71.0": + version: 0.71.0 + resolution: "@opentelemetry/instrumentation-redis@npm:0.71.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/redis-common": "npm:^0.38.3" "@opentelemetry/semantic-conventions": "npm:^1.27.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/d9d9672b8fdcc59fc226475fe6e49f6eea856879eac08aa03bd6d251cdb417e56747f1a6e82dbd232854b3d4ca16f38e8c80e0ff16114aab898f23eb18a2528c - languageName: node - linkType: hard - -"@opentelemetry/instrumentation-runtime-node@npm:^0.12.2": - version: 0.12.2 - resolution: "@opentelemetry/instrumentation-runtime-node@npm:0.12.2" - dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" - peerDependencies: - "@opentelemetry/api": ^1.3.0 - checksum: 10c0/91c7daff3f5fe9b75f799a413eec03bb9d34519a9d7229960ad6a5d2c29201dc902caca70050908c0a98aedbdcb9f55bb0a5be9baf3e6cd792e7da51150d1369 + checksum: 10c0/1639be7d5d9700f234cb85b78b881077fc88965a27ad2fe96e3e4cfa686cca1effdb812f2173a6827172c99d4387903642a655662b413867be6fd193fc8af6bc languageName: node linkType: hard -"@opentelemetry/instrumentation-socket.io@npm:^0.46.1": - version: 0.46.1 - resolution: "@opentelemetry/instrumentation-socket.io@npm:0.46.1" +"@opentelemetry/instrumentation-restify@npm:^0.68.0": + version: 0.68.0 + resolution: "@opentelemetry/instrumentation-restify@npm:0.68.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/core": "npm:^2.9.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" "@opentelemetry/semantic-conventions": "npm:^1.27.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/ed6be04ce334d5de6c3284ed0e85c43bef8594c17fff29e7328bb8bfd58552633e5f11560ba648ac44fdf0d27290383d83b1b9774c12cc279362781810949583 + checksum: 10c0/3ef6c09ecf2e760144395c70eeaa4b8b585eea35f8205231a1d17a94703ac9de2d1bd484c6c80c1aada17b0b7221d235f342c3cca5ad3be289012708f483edc0 languageName: node linkType: hard -"@opentelemetry/instrumentation-tedious@npm:^0.18.1": - version: 0.18.1 - resolution: "@opentelemetry/instrumentation-tedious@npm:0.18.1" +"@opentelemetry/instrumentation-router@npm:^0.67.0": + version: 0.67.0 + resolution: "@opentelemetry/instrumentation-router@npm:0.67.0" dependencies: - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/instrumentation": "npm:^0.223.0" "@opentelemetry/semantic-conventions": "npm:^1.27.0" - "@types/tedious": "npm:^4.0.14" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/fda9ac4dc89998a2cf739a70f06b1d6eebf98fe22713dc3fbca4a1119dc289d83c91ada4a3cea37f39a34c69978ae21ff9b599c27beaee128879b993677696dc + checksum: 10c0/9bf06975da0f4a657940dce33c6c56edd0d9c9d48eff8dc37c306683b001def9159690089b8abe9972091205604fb0ea53f0924eca1501ba1adf04f735fc7e00 languageName: node linkType: hard -"@opentelemetry/instrumentation-undici@npm:^0.10.1": - version: 0.10.1 - resolution: "@opentelemetry/instrumentation-undici@npm:0.10.1" +"@opentelemetry/instrumentation-runtime-node@npm:^0.36.1": + version: 0.36.1 + resolution: "@opentelemetry/instrumentation-runtime-node@npm:0.36.1" dependencies: - "@opentelemetry/core": "npm:^1.8.0" - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/api-logs": "npm:^0.223.0" + "@opentelemetry/core": "npm:^2.0.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" peerDependencies: - "@opentelemetry/api": ^1.7.0 - checksum: 10c0/3958f291d14f2f7bb5e3b957487444ffee449d8ea76c973ca09b9669258d37e98b3797c7167190c5038802529cc6b539bdf6efc7887398ec9b53d3ba51c90bda + "@opentelemetry/api": ^1.3.0 + checksum: 10c0/5f4abed3586d333967a1a17613a5493ab1017bcf98abde9763952c7baa94aefe50b0a04b48393cc05de9413a1bfd3db619bb3a7a851b0aaec7df1fa3499b4eb7 languageName: node linkType: hard -"@opentelemetry/instrumentation-user-interaction@npm:^0.38.0": - version: 0.38.0 - resolution: "@opentelemetry/instrumentation-user-interaction@npm:0.38.0" +"@opentelemetry/instrumentation-socket.io@npm:^0.70.0": + version: 0.70.0 + resolution: "@opentelemetry/instrumentation-socket.io@npm:0.70.0" dependencies: - "@opentelemetry/core": "npm:^1.8.0" - "@opentelemetry/instrumentation": "npm:^0.51.0" - "@opentelemetry/sdk-trace-web": "npm:^1.8.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - zone.js: ^0.11.4 || ^0.13.0 || ^0.14.0 - checksum: 10c0/57c4c441d9b987ddad6dc656fb5fecc42f0fb81adee2ca7e3b962763994bda8ec7d3337edc8b8e69a6b7e3cd2d93fb3a989bd8382bbeb4d87c15db1a303787a4 + checksum: 10c0/72413f1c47de5a19d3480b28f8fd9ee64a9ad4652d8a6649958561a2ef0ca71fcfab1f2c503f13e44df758752de1061c7591f2f32ec767515ac13a8b201000c4 languageName: node linkType: hard -"@opentelemetry/instrumentation-winston@npm:^0.44.1": - version: 0.44.1 - resolution: "@opentelemetry/instrumentation-winston@npm:0.44.1" +"@opentelemetry/instrumentation-tedious@npm:^0.42.0": + version: 0.42.0 + resolution: "@opentelemetry/instrumentation-tedious@npm:0.42.0" dependencies: - "@opentelemetry/api-logs": "npm:^0.57.1" - "@opentelemetry/instrumentation": "npm:^0.57.1" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.33.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/dc32175ae8791efab0e6d2f242535824472675658fc1467f3defd291638bf064baab0a39bbe90b848da348fbb93491d15b2f8374f4d03abf810a7f78da45049e + checksum: 10c0/2f75991f6ba95d235830242dd8776e262a5646b53fd81ab9e90c546d34a3f507001850976ba471929c7af786851abb276a79e86d3b0651593c62ed28eb5e9b6b languageName: node linkType: hard -"@opentelemetry/instrumentation-xml-http-request@npm:^0.51.1": - version: 0.51.1 - resolution: "@opentelemetry/instrumentation-xml-http-request@npm:0.51.1" +"@opentelemetry/instrumentation-undici@npm:^0.33.0": + version: 0.33.0 + resolution: "@opentelemetry/instrumentation-undici@npm:0.33.0" dependencies: - "@opentelemetry/core": "npm:1.24.1" - "@opentelemetry/instrumentation": "npm:0.51.1" - "@opentelemetry/sdk-trace-web": "npm:1.24.1" - "@opentelemetry/semantic-conventions": "npm:1.24.1" + "@opentelemetry/core": "npm:^2.9.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" + "@opentelemetry/semantic-conventions": "npm:^1.24.0" peerDependencies: - "@opentelemetry/api": ^1.0.0 - checksum: 10c0/9ca8a99bd0d5e3a08d953be1bd09f6baa6f8ad75740ca9cc21d0a5a3bf184ffc971226c0f83b88b0b1f22f25e03821a902393e5b970efdbe473c9a8662fcf94b + "@opentelemetry/api": ^1.7.0 + checksum: 10c0/64e2efb9f86064b698c992908fbc0bb93e362976b49f30ab4cdd601a1b3aa8db6da74532f0c28f691ce395c6176c6a6efbf00e86c2c0dc56806825ab867b6fbb languageName: node linkType: hard -"@opentelemetry/instrumentation@npm:0.51.1, @opentelemetry/instrumentation@npm:^0.51.0, @opentelemetry/instrumentation@npm:^0.51.1": - version: 0.51.1 - resolution: "@opentelemetry/instrumentation@npm:0.51.1" +"@opentelemetry/instrumentation-winston@npm:^0.68.1": + version: 0.68.1 + resolution: "@opentelemetry/instrumentation-winston@npm:0.68.1" dependencies: - "@opentelemetry/api-logs": "npm:0.51.1" - "@types/shimmer": "npm:^1.0.2" - import-in-the-middle: "npm:1.7.4" - require-in-the-middle: "npm:^7.1.1" - semver: "npm:^7.5.2" - shimmer: "npm:^1.2.1" + "@opentelemetry/api-logs": "npm:^0.223.0" + "@opentelemetry/instrumentation": "npm:^0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/39e02944becc7ee54c257b17ddef239b4d4e0c9c52223a74a32b0399b8cfe8bbd86af41f6940b85ab05481de0504a59f17fd2e8e5b6a32b5f0314f2a57d2e101 + checksum: 10c0/5034027e1d973bcc338e6bcceb3dc75873edd30368cd270e8eca0c0c526e8ed16d0eb4614a514c6e5871008919bf2aa163cf991bdf230bfc16562e18ea799268 languageName: node linkType: hard -"@opentelemetry/instrumentation@npm:0.57.2, @opentelemetry/instrumentation@npm:^0.57.1, @opentelemetry/instrumentation@npm:^0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/instrumentation@npm:0.57.2" +"@opentelemetry/instrumentation@npm:0.223.0, @opentelemetry/instrumentation@npm:^0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/instrumentation@npm:0.223.0" dependencies: - "@opentelemetry/api-logs": "npm:0.57.2" - "@types/shimmer": "npm:^1.2.0" - import-in-the-middle: "npm:^1.8.1" - require-in-the-middle: "npm:^7.1.1" - semver: "npm:^7.5.2" - shimmer: "npm:^1.2.1" + "@opentelemetry/api-logs": "npm:0.223.0" + import-in-the-middle: "npm:^3.0.0" + require-in-the-middle: "npm:^8.0.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/79ca65b66357665d19f89da7027da25ea1c6b55ecdacb0a99534923743c80deb9282870db563de8ae284b13e7e0aab8413efa1937f199deeaef069e07c7e4875 - languageName: node - linkType: hard - -"@opentelemetry/otlp-exporter-base@npm:0.51.1": - version: 0.51.1 - resolution: "@opentelemetry/otlp-exporter-base@npm:0.51.1" - dependencies: - "@opentelemetry/core": "npm:1.24.1" - peerDependencies: - "@opentelemetry/api": ^1.0.0 - checksum: 10c0/5274013e6b23ac1e2e422c9ba0041553621414aaecd0643caa526c32ff08811d0e266b3a3eda526e0e64651fad8ce77a4eeb43850415240d36df26ff5a81914b + checksum: 10c0/91d376a6625ed005655b27492922068f0d2fbe04372002407a6498d96e953b0b4669a97b9946cc49286a28082195b6db849ad35583b9772bc3a359b4e672756f languageName: node linkType: hard -"@opentelemetry/otlp-exporter-base@npm:0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/otlp-exporter-base@npm:0.57.2" +"@opentelemetry/otlp-exporter-base@npm:0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/otlp-exporter-base@npm:0.223.0" dependencies: - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/otlp-transformer": "npm:0.57.2" + "@opentelemetry/core": "npm:2.12.0" + "@opentelemetry/otlp-transformer": "npm:0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/56e0b7f3c7ff38a53c7976d87dc6bb4d4830f3be42c93f6d079d66b7e4f9f6004f62b853149e831ae936782716fb7ea7a7ca7871527fa7d09d73a2aa90880d21 + checksum: 10c0/94a27d295ba1acebe253c2ca379a0de15423032899c939653e38950c09f0eccdb09347fe3938e57089e52568c4f0e97a1282c36e6c355ba5f999d1fd32970637 languageName: node linkType: hard -"@opentelemetry/otlp-grpc-exporter-base@npm:0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/otlp-grpc-exporter-base@npm:0.57.2" +"@opentelemetry/otlp-grpc-exporter-base@npm:0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/otlp-grpc-exporter-base@npm:0.223.0" dependencies: - "@grpc/grpc-js": "npm:^1.7.1" - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/otlp-exporter-base": "npm:0.57.2" - "@opentelemetry/otlp-transformer": "npm:0.57.2" + "@grpc/grpc-js": "npm:^1.14.3" + "@opentelemetry/core": "npm:2.12.0" + "@opentelemetry/otlp-exporter-base": "npm:0.223.0" + "@opentelemetry/otlp-transformer": "npm:0.223.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/4a5ced2720061a6833b8210e0c606211393da98e0701087dc803c333e04a186550224408c7d82960c6cc07c96b1ab9c16b918cafdc9b77c27bc2f3781b6de6b1 + checksum: 10c0/549e2123fddb386e59055bbe375d0e010e021a8a9044579d5ebfd7864f400b77fa3e867d087cd47e2c1be036b0c4f7744f328fae3d9f592d3c4ead0c7d2a3efc languageName: node linkType: hard -"@opentelemetry/otlp-transformer@npm:0.51.1": - version: 0.51.1 - resolution: "@opentelemetry/otlp-transformer@npm:0.51.1" +"@opentelemetry/otlp-transformer@npm:0.223.0, @opentelemetry/otlp-transformer@npm:^0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/otlp-transformer@npm:0.223.0" dependencies: - "@opentelemetry/api-logs": "npm:0.51.1" - "@opentelemetry/core": "npm:1.24.1" - "@opentelemetry/resources": "npm:1.24.1" - "@opentelemetry/sdk-logs": "npm:0.51.1" - "@opentelemetry/sdk-metrics": "npm:1.24.1" - "@opentelemetry/sdk-trace-base": "npm:1.24.1" - peerDependencies: - "@opentelemetry/api": ">=1.3.0 <1.9.0" - checksum: 10c0/55082908439568f862f24cc714561d3b424cae8e726359c03bbe42f33868d8297fa30d93bcf6f475169ccceaf97ac47ba514e426871a83c8dfe0d2779e3644f3 - languageName: node - linkType: hard - -"@opentelemetry/otlp-transformer@npm:0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/otlp-transformer@npm:0.57.2" - dependencies: - "@opentelemetry/api-logs": "npm:0.57.2" - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/resources": "npm:1.30.1" - "@opentelemetry/sdk-logs": "npm:0.57.2" - "@opentelemetry/sdk-metrics": "npm:1.30.1" - "@opentelemetry/sdk-trace-base": "npm:1.30.1" - protobufjs: "npm:^7.3.0" + "@opentelemetry/api-logs": "npm:0.223.0" + "@opentelemetry/core": "npm:2.12.0" + "@opentelemetry/resources": "npm:2.12.0" + "@opentelemetry/sdk-logs": "npm:0.223.0" + "@opentelemetry/sdk-metrics": "npm:2.12.0" + "@opentelemetry/sdk-trace": "npm:2.12.0" peerDependencies: "@opentelemetry/api": ^1.3.0 - checksum: 10c0/094979421768c5ac0672d1ce62bbc710a8cc836eb24e1cdfe5fb2c5c55908d19cf35fd6810cd266e7444d5677087846d5a8959df5886dfe1774199a3ae1d50a4 + checksum: 10c0/5d6ba136f950864b5843c7df273d29289598f822e33a31bc7ef2cd29962460206e6c6dc163182f6ba2fdb52f2568ea7c893be8ee96356570da0709bcd440fd52 languageName: node linkType: hard -"@opentelemetry/propagation-utils@npm:^0.30.16": - version: 0.30.16 - resolution: "@opentelemetry/propagation-utils@npm:0.30.16" +"@opentelemetry/propagator-aws-xray@npm:^2.1.4": + version: 2.2.0 + resolution: "@opentelemetry/propagator-aws-xray@npm:2.2.0" peerDependencies: - "@opentelemetry/api": ^1.0.0 - checksum: 10c0/a6fa69694f9a5231a188846cec2989ec929d4caf4e74ddea133fc69c6b96072f80b67a919c5b967f50f49f5929b1e327ab1800666b1920fb63c3e10f580195f0 + "@opentelemetry/api": ">=1.0.0 <1.10.0" + checksum: 10c0/2fa665a1e867a8ff3fb3875db5d302a8f3c625337ae18378f9bc0a29633484e61b9fb8c3d2b5f1096b285b92a96c4615af4e5adfbca2a971dcee3b604953e5ba languageName: node linkType: hard -"@opentelemetry/propagator-b3@npm:1.30.1": - version: 1.30.1 - resolution: "@opentelemetry/propagator-b3@npm:1.30.1" +"@opentelemetry/propagator-b3@npm:2.12.0": + version: 2.12.0 + resolution: "@opentelemetry/propagator-b3@npm:2.12.0" dependencies: - "@opentelemetry/core": "npm:1.30.1" + "@opentelemetry/core": "npm:2.12.0" peerDependencies: "@opentelemetry/api": ">=1.0.0 <1.10.0" - checksum: 10c0/aeeaa6325e2d970a207a396b98562e05578688ffd047e64544c441456702c593a74b614216c0360ee0f63bb7c3cf39b63f74c0f59c8580a1aac067970cee9bc2 + checksum: 10c0/f8e86e373fed5995b2b498985430d39f0b6ba310b14ba4ef55fc03c60b4e8bde082628859b3a2f013234d83c64951e0e988733231e7e17279c19e2d67a90c4df languageName: node linkType: hard -"@opentelemetry/propagator-jaeger@npm:1.30.1": - version: 1.30.1 - resolution: "@opentelemetry/propagator-jaeger@npm:1.30.1" +"@opentelemetry/propagator-jaeger@npm:2.12.0": + version: 2.12.0 + resolution: "@opentelemetry/propagator-jaeger@npm:2.12.0" dependencies: - "@opentelemetry/core": "npm:1.30.1" + "@opentelemetry/core": "npm:2.12.0" peerDependencies: "@opentelemetry/api": ">=1.0.0 <1.10.0" - checksum: 10c0/e828d67768150bb23b4e75589bc6e9a3ae28e50a6ba6f6e737cf14fd33ab4108fb0aa84d363045e7e591b89a55bef4b8823fbd1734f64f7bb918338b78b86881 + checksum: 10c0/a2ee2dbf8da9530bfe7c021016c6c29c9ba5d6bfbab1efbb9fe47342e9f99c4046cdc99f009f1cda48f18c0188cde434b289399a91b0abf52b7d98ac80ec5c03 languageName: node linkType: hard -"@opentelemetry/redis-common@npm:^0.36.2": - version: 0.36.2 - resolution: "@opentelemetry/redis-common@npm:0.36.2" - checksum: 10c0/4cb831628551b9f13dca8d65897e300ff7be0e256b77f455a26fb053bbdfc7997b27d066ab1402ca929e7ac77598e0d593f91762d8af9f798c19ba1524e9d078 +"@opentelemetry/redis-common@npm:^0.38.3": + version: 0.38.3 + resolution: "@opentelemetry/redis-common@npm:0.38.3" + checksum: 10c0/e978eca4e322efdb3635797d4109d2195c1c0e815d2e24caab0e9ab619c9e62316622e97de5b46faa5e15a735c36135377c14ced9aec1566a25e91b5cc9f8d94 languageName: node linkType: hard -"@opentelemetry/resource-detector-alibaba-cloud@npm:^0.30.1": - version: 0.30.1 - resolution: "@opentelemetry/resource-detector-alibaba-cloud@npm:0.30.1" +"@opentelemetry/resource-detector-alibaba-cloud@npm:^0.38.0": + version: 0.38.0 + resolution: "@opentelemetry/resource-detector-alibaba-cloud@npm:0.38.0" dependencies: - "@opentelemetry/core": "npm:^1.26.0" - "@opentelemetry/resources": "npm:^1.10.0" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/core": "npm:^2.0.0" + "@opentelemetry/resources": "npm:^2.0.0" peerDependencies: "@opentelemetry/api": ^1.0.0 - checksum: 10c0/b38649acaa973cc1c7781fd64aaa6f680f5276ab66e0ebd98fbd36395bafcae693e372ed89e2ed08707ac07caf54999717dafe4aedc61a7f92132f514caec770 + checksum: 10c0/8d50960170bd713695fba77443862fafc6ae73c724c096ab754c2f9143ac110bd22f6eb4bdeafbed9d37e2d52dac4bfe4fe47ef0c46a54faf73b9431a0bd5818 languageName: node linkType: hard -"@opentelemetry/resource-detector-aws@npm:^1.12.0": - version: 1.12.0 - resolution: "@opentelemetry/resource-detector-aws@npm:1.12.0" +"@opentelemetry/resource-detector-aws@npm:^2.23.0": + version: 2.23.0 + resolution: "@opentelemetry/resource-detector-aws@npm:2.23.0" dependencies: - "@opentelemetry/core": "npm:^1.0.0" - "@opentelemetry/resources": "npm:^1.10.0" + "@opentelemetry/core": "npm:^2.0.0" + "@opentelemetry/resources": "npm:^2.0.0" "@opentelemetry/semantic-conventions": "npm:^1.27.0" peerDependencies: "@opentelemetry/api": ^1.0.0 - checksum: 10c0/af8634d040358d19839678ab3b7e1b6429ee9a58f852749201cc4cfa522628c68d4a615f3e4f6b9f56388ef364f583620551983e241ad064fe55c5595904ede8 + checksum: 10c0/d0c1689e87a1fe49d7b1f4ecaf403982b1642e2d195662150371e9cc64f973d027893422235420704c80f3299fffc8bf769e124a4cd269713b14c0906623975a languageName: node linkType: hard -"@opentelemetry/resource-detector-azure@npm:^0.6.1": - version: 0.6.1 - resolution: "@opentelemetry/resource-detector-azure@npm:0.6.1" +"@opentelemetry/resource-detector-azure@npm:^0.31.0": + version: 0.31.0 + resolution: "@opentelemetry/resource-detector-azure@npm:0.31.0" dependencies: - "@opentelemetry/core": "npm:^1.25.1" - "@opentelemetry/resources": "npm:^1.10.1" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/core": "npm:^2.0.0" + "@opentelemetry/resources": "npm:^2.0.0" + "@opentelemetry/semantic-conventions": "npm:^1.37.0" peerDependencies: "@opentelemetry/api": ^1.0.0 - checksum: 10c0/c6f63739bc766baea2a9caf86be22d1d6cbf94f58b934c5344be6a61fd3b917bb2dc82891365ed0f396a811715efb60b4a1f1e22dd4ad2c3b1d31903167459ba + checksum: 10c0/c0f45ff0cdfef42e48ce3e14c7ceabe035f3cd145e72841b55a49e1f9d83a0461e760210c9f8b7ae7355b67e50841fe0d341f5b3ded4ff5c19adb20b6f938e51 languageName: node linkType: hard -"@opentelemetry/resource-detector-container@npm:^0.6.1": - version: 0.6.1 - resolution: "@opentelemetry/resource-detector-container@npm:0.6.1" +"@opentelemetry/resource-detector-container@npm:^0.8.14": + version: 0.8.14 + resolution: "@opentelemetry/resource-detector-container@npm:0.8.14" dependencies: - "@opentelemetry/core": "npm:^1.26.0" - "@opentelemetry/resources": "npm:^1.10.0" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" + "@opentelemetry/core": "npm:^2.0.0" + "@opentelemetry/resources": "npm:^2.0.0" peerDependencies: "@opentelemetry/api": ^1.0.0 - checksum: 10c0/c3cf745d62657dd8d32c44cd326b645c74397f4159c055d2b4c0b432e95982f9dacae1de3fbad3d5e586993c80f44505a64bc74f8fd164df02c9c18d2b4a4217 + checksum: 10c0/fd9c54a3465265c18f0b3ddf569abdab455007bd3cc253e27b89442d38b0c63e3930968887c9fd9b2ef5cd0b5abcb85969be43aa33411ca94b5942df9bfaaa59 languageName: node linkType: hard -"@opentelemetry/resource-detector-gcp@npm:^0.33.1": - version: 0.33.1 - resolution: "@opentelemetry/resource-detector-gcp@npm:0.33.1" +"@opentelemetry/resource-detector-gcp@npm:^0.58.0": + version: 0.58.0 + resolution: "@opentelemetry/resource-detector-gcp@npm:0.58.0" dependencies: - "@opentelemetry/core": "npm:^1.0.0" - "@opentelemetry/resources": "npm:^1.10.0" - "@opentelemetry/semantic-conventions": "npm:^1.27.0" - gcp-metadata: "npm:^6.0.0" + "@opentelemetry/core": "npm:^2.0.0" + "@opentelemetry/resources": "npm:^2.0.0" + gcp-metadata: "npm:^8.0.0" peerDependencies: "@opentelemetry/api": ^1.0.0 - checksum: 10c0/c09639fbfd3836879d685e831794c4f118c2b9978d87bce710fe92f50c9c1ab53d6937ca9ffbe1022435a22667cffa7187b23aa953867c088573eb28a062d7a6 - languageName: node - linkType: hard - -"@opentelemetry/resources@npm:1.12.0": - version: 1.12.0 - resolution: "@opentelemetry/resources@npm:1.12.0" - dependencies: - "@opentelemetry/core": "npm:1.12.0" - "@opentelemetry/semantic-conventions": "npm:1.12.0" - peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.5.0" - checksum: 10c0/a2fca297798297f649fa71534bb16001145c957ab4733fb186bb6a2d60b3741a436e1b11327448f7338ed75ed8abbcf89509ddfcdaf37fbe782814a78818a3e1 - languageName: node - linkType: hard - -"@opentelemetry/resources@npm:1.21.0": - version: 1.21.0 - resolution: "@opentelemetry/resources@npm:1.21.0" - dependencies: - "@opentelemetry/core": "npm:1.21.0" - "@opentelemetry/semantic-conventions": "npm:1.21.0" - peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.8.0" - checksum: 10c0/0ac61b835e20d3323e1e6a5c74cbb64a9200e165724d6d1449f01bd18a0c5af3da854dacdc729cdb4ed00cb740639c76d6cd7c638ad6efffc23f9da0de36406a - languageName: node - linkType: hard - -"@opentelemetry/resources@npm:1.24.1": - version: 1.24.1 - resolution: "@opentelemetry/resources@npm:1.24.1" - dependencies: - "@opentelemetry/core": "npm:1.24.1" - "@opentelemetry/semantic-conventions": "npm:1.24.1" - peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.9.0" - checksum: 10c0/b2f68c153231bdca6491d6050d43d84c7679f44783eaca9daa9bdb3381b5bbdb54eb6de472e9177bc1c161b0bc83423af59e5e356cce8f7880fece757a0106b6 + checksum: 10c0/605bc69b0ec63b179f5df2e7d20c9d4f5cb30ad1ae3c1e0d8cb94f4117485f7870a0bdfa327a1ee56f0aee092265c1896dcad8c6450b6b6bac202db3ae45acf0 languageName: node linkType: hard -"@opentelemetry/resources@npm:1.30.1, @opentelemetry/resources@npm:^1.10.0, @opentelemetry/resources@npm:^1.30.1": +"@opentelemetry/resources@npm:1.30.1": version: 1.30.1 resolution: "@opentelemetry/resources@npm:1.30.1" dependencies: @@ -8149,139 +7874,96 @@ __metadata: languageName: node linkType: hard -"@opentelemetry/resources@npm:^1.10.1, @opentelemetry/resources@npm:^1.24.0, @opentelemetry/resources@npm:^1.24.1": - version: 1.25.1 - resolution: "@opentelemetry/resources@npm:1.25.1" - dependencies: - "@opentelemetry/core": "npm:1.25.1" - "@opentelemetry/semantic-conventions": "npm:1.25.1" - peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.10.0" - checksum: 10c0/4edbf04945c7647b9af847f2f8abccabb54f4f8935fd75c199dc22879f8b7927ac50fac8e877ef48e81c586a08d63bbfe41c345caf94a8ce2c623fa99bb8e999 - languageName: node - linkType: hard - -"@opentelemetry/sdk-logs@npm:0.51.1": - version: 0.51.1 - resolution: "@opentelemetry/sdk-logs@npm:0.51.1" +"@opentelemetry/resources@npm:2.12.0, @opentelemetry/resources@npm:^2.0.0, @opentelemetry/resources@npm:^2.12.0": + version: 2.12.0 + resolution: "@opentelemetry/resources@npm:2.12.0" dependencies: - "@opentelemetry/core": "npm:1.24.1" - "@opentelemetry/resources": "npm:1.24.1" + "@opentelemetry/core": "npm:2.12.0" + "@opentelemetry/semantic-conventions": "npm:^1.29.0" peerDependencies: - "@opentelemetry/api": ">=1.4.0 <1.9.0" - "@opentelemetry/api-logs": ">=0.39.1" - checksum: 10c0/8359ce836c7431f1bbd915d42c885b01351351a4090cfd99f5e88d4549700c24128f03e99daac22adcef307c9417c6dddc0ed8af0d8e31b4dbc15516d75b4093 + "@opentelemetry/api": ">=1.3.0 <1.10.0" + checksum: 10c0/ef3f8470b9ada8406fa4e4a0f002ca31537c1b7fe61f06102fb9023c97a56b0d978c687dd392539f1e005c20f0467f6a1c66f9c43e8d31c2900023164529f2bc languageName: node linkType: hard -"@opentelemetry/sdk-logs@npm:0.57.2, @opentelemetry/sdk-logs@npm:^0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/sdk-logs@npm:0.57.2" +"@opentelemetry/sdk-logs@npm:0.223.0, @opentelemetry/sdk-logs@npm:^0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/sdk-logs@npm:0.223.0" dependencies: - "@opentelemetry/api-logs": "npm:0.57.2" - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/resources": "npm:1.30.1" + "@opentelemetry/api-logs": "npm:0.223.0" + "@opentelemetry/core": "npm:2.12.0" + "@opentelemetry/resources": "npm:2.12.0" + "@opentelemetry/semantic-conventions": "npm:^1.29.0" peerDependencies: "@opentelemetry/api": ">=1.4.0 <1.10.0" - checksum: 10c0/dda61cf656a93d2f5ef1ca0495db59bfa33efc8ca7ee11018850a9ff78ee0459fb0393e70be7ae5d3cd084e0652d36fbf5778c7b3e9028c6668f9bf0d6c9473e + checksum: 10c0/18f7b608f52845a0404c2eacc03e3156f75bb6e901a53c4c0ba43e6bf103f7760e4e4e932d971a6ed6e8ab82db124f6dad7381f920fb6060516e09a8d7b33445 languageName: node linkType: hard -"@opentelemetry/sdk-metrics@npm:1.24.1": - version: 1.24.1 - resolution: "@opentelemetry/sdk-metrics@npm:1.24.1" - dependencies: - "@opentelemetry/core": "npm:1.24.1" - "@opentelemetry/resources": "npm:1.24.1" - lodash.merge: "npm:^4.6.2" - peerDependencies: - "@opentelemetry/api": ">=1.3.0 <1.9.0" - checksum: 10c0/a9e374851d44f67ec64f72721f9f2f9fae7ecf4ddb9dafdd80322b846b31421f29cdaf1aacb7e6944030319405d9d14cb9bd26ce51a23df4eb1061812c0b407c - languageName: node - linkType: hard - -"@opentelemetry/sdk-metrics@npm:1.30.1, @opentelemetry/sdk-metrics@npm:^1.30.1": - version: 1.30.1 - resolution: "@opentelemetry/sdk-metrics@npm:1.30.1" - dependencies: - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/resources": "npm:1.30.1" +"@opentelemetry/sdk-metrics@npm:2.12.0": + version: 2.12.0 + resolution: "@opentelemetry/sdk-metrics@npm:2.12.0" + dependencies: + "@opentelemetry/core": "npm:2.12.0" + "@opentelemetry/resources": "npm:2.12.0" + peerDependencies: + "@opentelemetry/api": ">=1.9.0 <1.10.0" + checksum: 10c0/ade35092d89de10ff3fe5058c632bf26c2dc21a74336e7946bd46156f58f85aab048fb30367cb091494b099242711895b27624efb31e78551ee6b2d05eee0c52 + languageName: node + linkType: hard + +"@opentelemetry/sdk-node@npm:^0.223.0": + version: 0.223.0 + resolution: "@opentelemetry/sdk-node@npm:0.223.0" + dependencies: + "@opentelemetry/api-logs": "npm:0.223.0" + "@opentelemetry/configuration": "npm:0.223.0" + "@opentelemetry/context-async-hooks": "npm:2.12.0" + "@opentelemetry/core": "npm:2.12.0" + "@opentelemetry/exporter-logs-otlp-grpc": "npm:0.223.0" + "@opentelemetry/exporter-logs-otlp-http": "npm:0.223.0" + "@opentelemetry/exporter-logs-otlp-proto": "npm:0.223.0" + "@opentelemetry/exporter-metrics-otlp-grpc": "npm:0.223.0" + "@opentelemetry/exporter-metrics-otlp-http": "npm:0.223.0" + "@opentelemetry/exporter-metrics-otlp-proto": "npm:0.223.0" + "@opentelemetry/exporter-prometheus": "npm:0.223.0" + "@opentelemetry/exporter-trace-otlp-grpc": "npm:0.223.0" + "@opentelemetry/exporter-trace-otlp-http": "npm:0.223.0" + "@opentelemetry/exporter-trace-otlp-proto": "npm:0.223.0" + "@opentelemetry/exporter-zipkin": "npm:2.12.0" + "@opentelemetry/instrumentation": "npm:0.223.0" + "@opentelemetry/otlp-exporter-base": "npm:0.223.0" + "@opentelemetry/otlp-grpc-exporter-base": "npm:0.223.0" + "@opentelemetry/propagator-b3": "npm:2.12.0" + "@opentelemetry/propagator-jaeger": "npm:2.12.0" + "@opentelemetry/resources": "npm:2.12.0" + "@opentelemetry/sdk-logs": "npm:0.223.0" + "@opentelemetry/sdk-metrics": "npm:2.12.0" + "@opentelemetry/sdk-trace": "npm:2.12.0" + "@opentelemetry/sdk-trace-base": "npm:2.12.0" + "@opentelemetry/sdk-trace-node": "npm:2.12.0" + "@opentelemetry/semantic-conventions": "npm:^1.29.0" peerDependencies: "@opentelemetry/api": ">=1.3.0 <1.10.0" - checksum: 10c0/7e60178e61eaf49db5d74f6c3701706762d71d370044253c72bb5668dba3a435030ed6847605ee55d0e1b8908ad123a2517b5f00415a2fb3d98468a0a318e3c0 + checksum: 10c0/5650b5399040e965536977e98cc47b3e30eadf792e579013ccb680172b5beef33c0380ffeb1d9e0714e19c35cd4d90ce11aef3372534f9d822d2c8131e55e7d1 languageName: node linkType: hard -"@opentelemetry/sdk-node@npm:^0.57.1, @opentelemetry/sdk-node@npm:^0.57.2": - version: 0.57.2 - resolution: "@opentelemetry/sdk-node@npm:0.57.2" +"@opentelemetry/sdk-trace-base@npm:2.12.0": + version: 2.12.0 + resolution: "@opentelemetry/sdk-trace-base@npm:2.12.0" dependencies: - "@opentelemetry/api-logs": "npm:0.57.2" - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/exporter-logs-otlp-grpc": "npm:0.57.2" - "@opentelemetry/exporter-logs-otlp-http": "npm:0.57.2" - "@opentelemetry/exporter-logs-otlp-proto": "npm:0.57.2" - "@opentelemetry/exporter-metrics-otlp-grpc": "npm:0.57.2" - "@opentelemetry/exporter-metrics-otlp-http": "npm:0.57.2" - "@opentelemetry/exporter-metrics-otlp-proto": "npm:0.57.2" - "@opentelemetry/exporter-prometheus": "npm:0.57.2" - "@opentelemetry/exporter-trace-otlp-grpc": "npm:0.57.2" - "@opentelemetry/exporter-trace-otlp-http": "npm:0.57.2" - "@opentelemetry/exporter-trace-otlp-proto": "npm:0.57.2" - "@opentelemetry/exporter-zipkin": "npm:1.30.1" - "@opentelemetry/instrumentation": "npm:0.57.2" - "@opentelemetry/resources": "npm:1.30.1" - "@opentelemetry/sdk-logs": "npm:0.57.2" - "@opentelemetry/sdk-metrics": "npm:1.30.1" - "@opentelemetry/sdk-trace-base": "npm:1.30.1" - "@opentelemetry/sdk-trace-node": "npm:1.30.1" - "@opentelemetry/semantic-conventions": "npm:1.28.0" + "@opentelemetry/core": "npm:2.12.0" + "@opentelemetry/resources": "npm:2.12.0" + "@opentelemetry/sdk-trace": "npm:2.12.0" + "@opentelemetry/semantic-conventions": "npm:^1.29.0" peerDependencies: "@opentelemetry/api": ">=1.3.0 <1.10.0" - checksum: 10c0/5897cc13a01a23bc49823f0f6fbad86d9efef20e9ee8d211eb7b45ef2995fcd2b9ca8212d81a3adaf7dd8e877e19634a89c7f64ea4c3076c23d8526f6816d183 - languageName: node - linkType: hard - -"@opentelemetry/sdk-trace-base@npm:1.12.0": - version: 1.12.0 - resolution: "@opentelemetry/sdk-trace-base@npm:1.12.0" - dependencies: - "@opentelemetry/core": "npm:1.12.0" - "@opentelemetry/resources": "npm:1.12.0" - "@opentelemetry/semantic-conventions": "npm:1.12.0" - peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.5.0" - checksum: 10c0/93267087ec5602a8c4230c87016f22dd3736364e672f5ba239c98f32bfa61fff6bd0b24778ca5b879ca0a92733bbbf7348ed9fc20c924a7b1504bd5356124be4 - languageName: node - linkType: hard - -"@opentelemetry/sdk-trace-base@npm:1.21.0": - version: 1.21.0 - resolution: "@opentelemetry/sdk-trace-base@npm:1.21.0" - dependencies: - "@opentelemetry/core": "npm:1.21.0" - "@opentelemetry/resources": "npm:1.21.0" - "@opentelemetry/semantic-conventions": "npm:1.21.0" - peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.8.0" - checksum: 10c0/0d68bfb614c45713185d20ad6aa766f38060fc5716d4fd196bb3195386f8bf22e3a9a56d3ec2a2c6753f9edb0d0b0e780f0d271a2d50ca866440ae624b4268ab - languageName: node - linkType: hard - -"@opentelemetry/sdk-trace-base@npm:1.24.1, @opentelemetry/sdk-trace-base@npm:~1.24.1": - version: 1.24.1 - resolution: "@opentelemetry/sdk-trace-base@npm:1.24.1" - dependencies: - "@opentelemetry/core": "npm:1.24.1" - "@opentelemetry/resources": "npm:1.24.1" - "@opentelemetry/semantic-conventions": "npm:1.24.1" - peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.9.0" - checksum: 10c0/071783367b06410e4e4bf4626bc560e664ccfa5eff497fe645db99b6074702259dba1c56ed8b003e9c0949ba53cd55d32aae1d46fa7bd47da1186f3d941a9713 + checksum: 10c0/cd1de7e881f60a98047d662915b74b7b39cde69a51e9fc146fb4f02af4df4441a785af57e7ad267ea22bbc6ac19c5497684b51d7407573c2aef51f9e402aea4b languageName: node linkType: hard -"@opentelemetry/sdk-trace-base@npm:1.30.1, @opentelemetry/sdk-trace-base@npm:^1.0.0, @opentelemetry/sdk-trace-base@npm:^1.30.1": +"@opentelemetry/sdk-trace-base@npm:^1.30.1": version: 1.30.1 resolution: "@opentelemetry/sdk-trace-base@npm:1.30.1" dependencies: @@ -8294,93 +7976,29 @@ __metadata: languageName: node linkType: hard -"@opentelemetry/sdk-trace-node@npm:1.30.1": - version: 1.30.1 - resolution: "@opentelemetry/sdk-trace-node@npm:1.30.1" +"@opentelemetry/sdk-trace-node@npm:2.12.0": + version: 2.12.0 + resolution: "@opentelemetry/sdk-trace-node@npm:2.12.0" dependencies: - "@opentelemetry/context-async-hooks": "npm:1.30.1" - "@opentelemetry/core": "npm:1.30.1" - "@opentelemetry/propagator-b3": "npm:1.30.1" - "@opentelemetry/propagator-jaeger": "npm:1.30.1" - "@opentelemetry/sdk-trace-base": "npm:1.30.1" - semver: "npm:^7.5.2" + "@opentelemetry/context-async-hooks": "npm:2.12.0" + "@opentelemetry/core": "npm:2.12.0" + "@opentelemetry/sdk-trace-base": "npm:2.12.0" peerDependencies: "@opentelemetry/api": ">=1.0.0 <1.10.0" - checksum: 10c0/8ae1c2b49389d45bc9419e106c47fa3b91cb39708281dc7dfb7dab8e4d98d5bb27c1758a5521722840bca37bb825d4b8b1571e19ab88a7884867f994e29a5989 - languageName: node - linkType: hard - -"@opentelemetry/sdk-trace-web@npm:1.24.1, @opentelemetry/sdk-trace-web@npm:~1.24.1": - version: 1.24.1 - resolution: "@opentelemetry/sdk-trace-web@npm:1.24.1" - dependencies: - "@opentelemetry/core": "npm:1.24.1" - "@opentelemetry/sdk-trace-base": "npm:1.24.1" - "@opentelemetry/semantic-conventions": "npm:1.24.1" - peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.9.0" - checksum: 10c0/b08e6814b8d80d06d86b503466d25786da9c0edf569a069838e3ce49483b163167554f449412842622959f35bea86b2a95ed3f0ddb7009fcfb605d148f83c640 + checksum: 10c0/988c6d5f6536e103b619c7375841672da7193f49f046f4b9d33dc91dcbcc9495b4adb64cac0d029d5c7d17b6b13b46c4140ae118f30dc46641d2be3513550813 languageName: node linkType: hard -"@opentelemetry/sdk-trace-web@npm:^1.15.0": - version: 1.21.0 - resolution: "@opentelemetry/sdk-trace-web@npm:1.21.0" - dependencies: - "@opentelemetry/core": "npm:1.21.0" - "@opentelemetry/sdk-trace-base": "npm:1.21.0" - "@opentelemetry/semantic-conventions": "npm:1.21.0" - peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.8.0" - checksum: 10c0/1e07ddd72eb66f89402d78e710d71b730228c6a8b550f20294249cddf34e0fa8d75cae42bafdb86effc5f26668144dd4b06810420f077010cdb3412fe8403317 - languageName: node - linkType: hard - -"@opentelemetry/sdk-trace-web@npm:^1.8.0": - version: 1.12.0 - resolution: "@opentelemetry/sdk-trace-web@npm:1.12.0" +"@opentelemetry/sdk-trace@npm:2.12.0, @opentelemetry/sdk-trace@npm:^2.12.0": + version: 2.12.0 + resolution: "@opentelemetry/sdk-trace@npm:2.12.0" dependencies: - "@opentelemetry/core": "npm:1.12.0" - "@opentelemetry/sdk-trace-base": "npm:1.12.0" - "@opentelemetry/semantic-conventions": "npm:1.12.0" + "@opentelemetry/core": "npm:2.12.0" + "@opentelemetry/resources": "npm:2.12.0" + "@opentelemetry/semantic-conventions": "npm:^1.29.0" peerDependencies: - "@opentelemetry/api": ">=1.0.0 <1.5.0" - checksum: 10c0/e711ce4fe97d3075e183a9c62609a64ec36a13656cdaaaf4d03a9a2a791d043d1e27fb815ad71dc5e1604e1e5e371ccb7a55d8a06848d1fbd1dee27d37e0946b - languageName: node - linkType: hard - -"@opentelemetry/semantic-conventions@npm:1.12.0": - version: 1.12.0 - resolution: "@opentelemetry/semantic-conventions@npm:1.12.0" - checksum: 10c0/d1fa8361b347ee8cf66da7caea3e0feb52ebdb02cfae294c5d4e0e5caedb56abd384706d51317f768b828cfab46b6dde66623ce2a6602c2720abda317d6b144d - languageName: node - linkType: hard - -"@opentelemetry/semantic-conventions@npm:1.15.2": - version: 1.15.2 - resolution: "@opentelemetry/semantic-conventions@npm:1.15.2" - checksum: 10c0/84428c3703e5bd0fb8e3f99cad0a48feb2ac03fec025f3a5691745486a89e446ea8fdf701c334d9dbb70a0c9f7053af777105f4ebc58fb1c602edb9aef918b28 - languageName: node - linkType: hard - -"@opentelemetry/semantic-conventions@npm:1.21.0": - version: 1.21.0 - resolution: "@opentelemetry/semantic-conventions@npm:1.21.0" - checksum: 10c0/ba1eabdbe5cdc04cbb7ce28f2df91fc95000e14861eb93937cfc7768d29c7e57692eb4fb2645f6ba87ae046acc1d1e27e4e6415e46e03015d54a6fdaf8e9635b - languageName: node - linkType: hard - -"@opentelemetry/semantic-conventions@npm:1.24.1": - version: 1.24.1 - resolution: "@opentelemetry/semantic-conventions@npm:1.24.1" - checksum: 10c0/5a3707860b70df8430745ef4ef99810a6d61d770942c217ac25ef8d6840a6b17b943c1ebe4da4a118dee0e3b1e71da3c16e2790f3c3a7e7e6b171e8d1944f73e - languageName: node - linkType: hard - -"@opentelemetry/semantic-conventions@npm:1.25.1": - version: 1.25.1 - resolution: "@opentelemetry/semantic-conventions@npm:1.25.1" - checksum: 10c0/fb1d6349e91f142c82931e89e0242215be8248e77919b6faa7e259757e499183546c9b4046de72b053b5222453bc74fff70280d2b4d1229484ba7b2c07f16a3a + "@opentelemetry/api": ">=1.3.0 <1.10.0" + checksum: 10c0/bc36d6c3c0a007e0e1f928a7e3c9e6e6d130e157efab8da36a07a624000c2fd25309c0a3d42d4e58f6b30ae233cddfbc6270c2a8566c9f611b9d964f5b7ea8a6 languageName: node linkType: hard @@ -8391,21 +8009,21 @@ __metadata: languageName: node linkType: hard -"@opentelemetry/semantic-conventions@npm:^1.22.0, @opentelemetry/semantic-conventions@npm:^1.24.1, @opentelemetry/semantic-conventions@npm:^1.27.0, @opentelemetry/semantic-conventions@npm:^1.30.0": - version: 1.34.0 - resolution: "@opentelemetry/semantic-conventions@npm:1.34.0" - checksum: 10c0/a51a32a5cf5c803bd2125a680d0abacbff632f3b255d0fe52379dac191114a0e8d72a34f9c46c5483ccfe91c4061c309f3cf61a19d11347e2a69779e82cfefd0 +"@opentelemetry/semantic-conventions@npm:^1.24.0, @opentelemetry/semantic-conventions@npm:^1.27.0, @opentelemetry/semantic-conventions@npm:^1.29.0, @opentelemetry/semantic-conventions@npm:^1.30.0, @opentelemetry/semantic-conventions@npm:^1.33.0, @opentelemetry/semantic-conventions@npm:^1.33.1, @opentelemetry/semantic-conventions@npm:^1.34.0, @opentelemetry/semantic-conventions@npm:^1.36.0, @opentelemetry/semantic-conventions@npm:^1.37.0, @opentelemetry/semantic-conventions@npm:^1.41.1, @opentelemetry/semantic-conventions@npm:^1.43.0": + version: 1.44.0 + resolution: "@opentelemetry/semantic-conventions@npm:1.44.0" + checksum: 10c0/38ce72dfe254e16177903cc42475eecdfd312d20487133a84d1ab8d97c452acabb186e0069ddcd9a8ba1f65d76535dfec670ce059ef4265f8f29fc395b0db5f0 languageName: node linkType: hard -"@opentelemetry/sql-common@npm:^0.40.1": - version: 0.40.1 - resolution: "@opentelemetry/sql-common@npm:0.40.1" +"@opentelemetry/sql-common@npm:^0.42.0": + version: 0.42.0 + resolution: "@opentelemetry/sql-common@npm:0.42.0" dependencies: - "@opentelemetry/core": "npm:^1.1.0" + "@opentelemetry/core": "npm:^2.0.0" peerDependencies: "@opentelemetry/api": ^1.1.0 - checksum: 10c0/60a70358f0c94f610e2995333e96b406626d67d03d38ed03b15a3461ad0f8d64afbf6275cca7cb58fe955ecdce832f3ffc9b73f9d88503bba5d2a620bbd6d351 + checksum: 10c0/de51b4938c2b2032618004ca842d6a8a683a6d710676d5fd39569e84a6658cc00581fb43a63c17f6e737ba686d82104aa7ad1ab1879bc1e6351b724f4a105fab languageName: node linkType: hard @@ -9104,13 +8722,6 @@ __metadata: languageName: node linkType: hard -"@protobufjs/codegen@npm:^2.0.4": - version: 2.0.4 - resolution: "@protobufjs/codegen@npm:2.0.4" - checksum: 10c0/26ae337c5659e41f091606d16465bbcc1df1f37cc1ed462438b1f67be0c1e28dfb2ca9f294f39100c52161aef82edf758c95d6d75650a1ddf31f7ddee1440b43 - languageName: node - linkType: hard - "@protobufjs/codegen@npm:^2.0.5": version: 2.0.5 resolution: "@protobufjs/codegen@npm:2.0.5" @@ -9118,13 +8729,6 @@ __metadata: languageName: node linkType: hard -"@protobufjs/eventemitter@npm:^1.1.0": - version: 1.1.0 - resolution: "@protobufjs/eventemitter@npm:1.1.0" - checksum: 10c0/1eb0a75180e5206d1033e4138212a8c7089a3d418c6dfa5a6ce42e593a4ae2e5892c4ef7421f38092badba4040ea6a45f0928869989411001d8c1018ea9a6e70 - languageName: node - linkType: hard - "@protobufjs/eventemitter@npm:^1.1.1": version: 1.1.1 resolution: "@protobufjs/eventemitter@npm:1.1.1" @@ -9132,16 +8736,6 @@ __metadata: languageName: node linkType: hard -"@protobufjs/fetch@npm:^1.1.0": - version: 1.1.0 - resolution: "@protobufjs/fetch@npm:1.1.0" - dependencies: - "@protobufjs/aspromise": "npm:^1.1.1" - "@protobufjs/inquire": "npm:^1.1.0" - checksum: 10c0/cda6a3dc2d50a182c5865b160f72077aac197046600091dbb005dd0a66db9cce3c5eaed6d470ac8ed49d7bcbeef6ee5f0bc288db5ff9a70cbd003e5909065233 - languageName: node - linkType: hard - "@protobufjs/fetch@npm:^1.1.1": version: 1.1.1 resolution: "@protobufjs/fetch@npm:1.1.1" @@ -9151,24 +8745,10 @@ __metadata: languageName: node linkType: hard -"@protobufjs/float@npm:^1.0.2": - version: 1.0.2 - resolution: "@protobufjs/float@npm:1.0.2" - checksum: 10c0/18f2bdede76ffcf0170708af15c9c9db6259b771e6b84c51b06df34a9c339dbbeec267d14ce0bddd20acc142b1d980d983d31434398df7f98eb0c94a0eb79069 - languageName: node - linkType: hard - -"@protobufjs/inquire@npm:^1.1.0": - version: 1.1.0 - resolution: "@protobufjs/inquire@npm:1.1.0" - checksum: 10c0/64372482efcba1fb4d166a2664a6395fa978b557803857c9c03500e0ac1013eb4b1aacc9ed851dd5fc22f81583670b4f4431bae186f3373fedcfde863ef5921a - languageName: node - linkType: hard - -"@protobufjs/inquire@npm:^1.1.1": - version: 1.1.1 - resolution: "@protobufjs/inquire@npm:1.1.1" - checksum: 10c0/a638d981adabdbdd61fba04e5045e0d2f98fa557eb0e705482a6dc25e84318bc736b0cd4aaee5d6b9941f121b488ece872c203af2a665b6dfefa95c903bb0cc8 +"@protobufjs/float@npm:^1.0.2": + version: 1.0.2 + resolution: "@protobufjs/float@npm:1.0.2" + checksum: 10c0/18f2bdede76ffcf0170708af15c9c9db6259b771e6b84c51b06df34a9c339dbbeec267d14ce0bddd20acc142b1d980d983d31434398df7f98eb0c94a0eb79069 languageName: node linkType: hard @@ -9193,7 +8773,7 @@ __metadata: languageName: node linkType: hard -"@protobufjs/utf8@npm:^1.1.0, @protobufjs/utf8@npm:^1.1.1": +"@protobufjs/utf8@npm:^1.1.1": version: 1.1.1 resolution: "@protobufjs/utf8@npm:1.1.1" checksum: 10c0/641fc145f00626405e8984b6e90b9edcbcc072ffc82d0647ca3176e09c730b2d022f988e65f011a7a17e2e4d77cde7733643aa10d8ac2bfa30f134dbcad553fd @@ -10279,6 +9859,17 @@ __metadata: languageName: node linkType: hard +"@rrweb/record@npm:~2.2.0": + version: 2.2.0 + resolution: "@rrweb/record@npm:2.2.0" + dependencies: + "@rrweb/types": "npm:^2.2.0" + "@rrweb/utils": "npm:^2.2.0" + rrweb: "npm:^2.2.0" + checksum: 10c0/23c5af50c50e706b8505a368a0064716ed12a7fe0831eaefccec08ceff5bf8e6a14a6ba5abc97943a7b238efe1dbb07b6be7b5f8b51a25d9a5a1548fe59473a3 + languageName: node + linkType: hard + "@rrweb/replay@npm:2.1.1": version: 2.1.1 resolution: "@rrweb/replay@npm:2.1.1" @@ -10296,6 +9887,13 @@ __metadata: languageName: node linkType: hard +"@rrweb/types@npm:^2.2.0": + version: 2.2.0 + resolution: "@rrweb/types@npm:2.2.0" + checksum: 10c0/ff1f59601ca8f854218190d683bbbc527166bba0f15be6d9cffd924dedb2505083f175e3b64b5193b677baddad1a446f817dac9e7a98727d977fb69f53492edd + languageName: node + linkType: hard + "@rrweb/utils@npm:^2.1.1": version: 2.1.1 resolution: "@rrweb/utils@npm:2.1.1" @@ -10303,6 +9901,13 @@ __metadata: languageName: node linkType: hard +"@rrweb/utils@npm:^2.2.0": + version: 2.2.0 + resolution: "@rrweb/utils@npm:2.2.0" + checksum: 10c0/e54cd099c160a965965a83aee0fffb864c3a2f22b68e3af7b93212d59c82376b35a1ab4135eaf372e4093cd4ecb70da99b4472036893143369de85f38528cba7 + languageName: node + linkType: hard + "@rtsao/scc@npm:^1.1.0": version: 1.1.0 resolution: "@rtsao/scc@npm:1.1.0" @@ -10324,32 +9929,6 @@ __metadata: languageName: node linkType: hard -"@sentry/core@npm:^8.7.0": - version: 8.13.0 - resolution: "@sentry/core@npm:8.13.0" - dependencies: - "@sentry/types": "npm:8.13.0" - "@sentry/utils": "npm:8.13.0" - checksum: 10c0/327bbe2cd7e0d931ff70138f2d339a67a3880b8d1311a2743a5ecd631a6bbd4ad818a0d0777ceef5a6cc4b93f6dbf233629c722f1f23c80687639ba6c2fab0a2 - languageName: node - linkType: hard - -"@sentry/types@npm:8.13.0, @sentry/types@npm:^8.7.0": - version: 8.13.0 - resolution: "@sentry/types@npm:8.13.0" - checksum: 10c0/c17d0b1e530cc93330f8085b4d40baa5090c5fcf7b2a611eee50aae588299577ff86a8db8a0452e4b8ed1b84eb73fdff774c6d98d926f589b9dd0c85a1341cfb - languageName: node - linkType: hard - -"@sentry/utils@npm:8.13.0, @sentry/utils@npm:^8.7.0": - version: 8.13.0 - resolution: "@sentry/utils@npm:8.13.0" - dependencies: - "@sentry/types": "npm:8.13.0" - checksum: 10c0/95ade7ba583bdfde63c8a8f44726defd60a471af23431b74628dce7062d71ba90a0238190022ab49d1eb1386c6867734a3a03554047b86b896c676308f300d17 - languageName: node - linkType: hard - "@sinclair/typebox@npm:^0.27.8": version: 0.27.8 resolution: "@sinclair/typebox@npm:0.27.8" @@ -11387,10 +10966,10 @@ __metadata: languageName: node linkType: hard -"@types/aws-lambda@npm:8.10.147": - version: 8.10.147 - resolution: "@types/aws-lambda@npm:8.10.147" - checksum: 10c0/c77bcb18a935fb26f5b1164aaadf46b3d11d6c001a95c6e9f2ff72f7d9ed4e7f28075a3abf9f9585cc75510acbc29c7a6441e66727902eae1bd39ac8dc28351e +"@types/aws-lambda@npm:^8.10.155": + version: 8.10.164 + resolution: "@types/aws-lambda@npm:8.10.164" + checksum: 10c0/cc78160e3b76e78a28cc232780777e3ca91cde0a021c14d816dcefeb45dfcd912f0ed409dbeb1516b08c1af1b764a6664e61838672cd6645f6387e57d682548b languageName: node linkType: hard @@ -11454,15 +11033,6 @@ __metadata: languageName: node linkType: hard -"@types/bunyan@npm:1.8.11": - version: 1.8.11 - resolution: "@types/bunyan@npm:1.8.11" - dependencies: - "@types/node": "npm:*" - checksum: 10c0/07d762499307a1c3f04f56f2c62417b909f86f6090cee29b73a00dde323a4463cfd2e78888598cb1cd3b1eb88e6c47ef2a58e17f119dae27ff04cd361c0a1d4c - languageName: node - linkType: hard - "@types/chai@npm:^5.2.2": version: 5.2.3 resolution: "@types/chai@npm:5.2.3" @@ -11890,13 +11460,6 @@ __metadata: languageName: node linkType: hard -"@types/long@npm:^4.0.1": - version: 4.0.2 - resolution: "@types/long@npm:4.0.2" - checksum: 10c0/42ec66ade1f72ff9d143c5a519a65efc7c1c77be7b1ac5455c530ae9acd87baba065542f8847522af2e3ace2cc999f3ad464ef86e6b7352eece34daf88f8c924 - languageName: node - linkType: hard - "@types/luxon@npm:~3.7.0": version: 3.7.1 resolution: "@types/luxon@npm:3.7.1" @@ -11973,15 +11536,6 @@ __metadata: languageName: node linkType: hard -"@types/mysql@npm:2.15.26": - version: 2.15.26 - resolution: "@types/mysql@npm:2.15.26" - dependencies: - "@types/node": "npm:*" - checksum: 10c0/3cf279e7db05d56c0544532a4380b9079f579092379a04c8138bd5cf88dda5b31208ac2d23ce7dbf4e3a3f43aaeed44e72f9f19f726518f308efe95a7435619a - languageName: node - linkType: hard - "@types/node@npm:*, @types/node@npm:^22.15.18": version: 22.15.18 resolution: "@types/node@npm:22.15.18" @@ -12083,12 +11637,12 @@ __metadata: languageName: node linkType: hard -"@types/pg-pool@npm:2.0.6": - version: 2.0.6 - resolution: "@types/pg-pool@npm:2.0.6" +"@types/pg-pool@npm:2.0.7": + version: 2.0.7 + resolution: "@types/pg-pool@npm:2.0.7" dependencies: "@types/pg": "npm:*" - checksum: 10c0/41965d4d0b677c54ce45d36add760e496d356b78019cb062d124af40287cf6b0fd4d86e3b0085f443856c185983a60c8b0795ff76d15683e2a93c62f5ac0125f + checksum: 10c0/4935bc2e5af3990f3f80abd83af5d38e2c3fb01edea4f301fe2ef2c07173646cd06ec361dd0231a4085be405bb54e924a861ae6d0a3bf88b907f331b5a79111a languageName: node linkType: hard @@ -12103,14 +11657,14 @@ __metadata: languageName: node linkType: hard -"@types/pg@npm:8.6.1": - version: 8.6.1 - resolution: "@types/pg@npm:8.6.1" +"@types/pg@npm:8.15.6": + version: 8.15.6 + resolution: "@types/pg@npm:8.15.6" dependencies: "@types/node": "npm:*" pg-protocol: "npm:*" pg-types: "npm:^2.2.0" - checksum: 10c0/8d16660c9a4f050d6d5e391c59f9a62e9d377a2a6a7eb5865f8828082dbdfeab700fd707e585f42d67b29e796b32863aea5bd6d5cbb8ceda2d598da5d0c61693 + checksum: 10c0/7f93f83a4da0dc6133918f824d826fa34e78fb8cf86392d28a0e095c836c6910c014ced5d4b364d83e8485a65ce369adeb9663b14ba301241d4c0f80073007f3 languageName: node linkType: hard @@ -12219,13 +11773,6 @@ __metadata: languageName: node linkType: hard -"@types/shimmer@npm:^1.0.2, @types/shimmer@npm:^1.2.0": - version: 1.2.0 - resolution: "@types/shimmer@npm:1.2.0" - checksum: 10c0/6f7bfe1b55601cfc3ae713fc74a03341f3834253b8b91cb2add926d5949e4a63f7e666f59c2a6e40a883a5f9e2f3e3af10f9d3aed9b60fced0bda87659e58d8d - languageName: node - linkType: hard - "@types/sqlstring@npm:^2.3.0, @types/sqlstring@npm:^2.3.2": version: 2.3.2 resolution: "@types/sqlstring@npm:2.3.2" @@ -12273,15 +11820,6 @@ __metadata: languageName: node linkType: hard -"@types/tedious@npm:^4.0.14": - version: 4.0.14 - resolution: "@types/tedious@npm:4.0.14" - dependencies: - "@types/node": "npm:*" - checksum: 10c0/d2914f8e9b5b998e4275ec5f0130cba1c2fb47e75616b5c125a65ef6c1db2f1dc3f978c7900693856a15d72bbb4f4e94f805537a4ecb6dc126c64415d31c0590 - languageName: node - linkType: hard - "@types/tough-cookie@npm:*": version: 4.0.5 resolution: "@types/tough-cookie@npm:4.0.5" @@ -12289,13 +11827,6 @@ __metadata: languageName: node linkType: hard -"@types/triple-beam@npm:^1.3.2": - version: 1.3.2 - resolution: "@types/triple-beam@npm:1.3.2" - checksum: 10c0/2e936cff7cde9df7da854a54a5f63e0a434b2ae1d6c1eb6de5f7a0b1107b023b3c272abecbba28614a54b8831226b29e37a49e3e34a7490a6a24d770a5b44eb9 - languageName: node - linkType: hard - "@types/ungap__structured-clone@npm:^1.2.0": version: 1.2.0 resolution: "@types/ungap__structured-clone@npm:1.2.0" @@ -13161,15 +12692,6 @@ __metadata: languageName: node linkType: hard -"acorn-import-attributes@npm:^1.9.5": - version: 1.9.5 - resolution: "acorn-import-attributes@npm:1.9.5" - peerDependencies: - acorn: ^8 - checksum: 10c0/5926eaaead2326d5a86f322ff1b617b0f698aa61dc719a5baa0e9d955c9885cc71febac3fb5bacff71bbf2c4f9c12db2056883c68c53eb962c048b952e1e013d - languageName: node - linkType: hard - "acorn-import-phases@npm:^1.0.3": version: 1.0.4 resolution: "acorn-import-phases@npm:1.0.4" @@ -13195,15 +12717,6 @@ __metadata: languageName: node linkType: hard -"acorn@npm:^8.14.0": - version: 8.14.1 - resolution: "acorn@npm:8.14.1" - bin: - acorn: bin/acorn - checksum: 10c0/dbd36c1ed1d2fa3550140000371fcf721578095b18777b85a79df231ca093b08edc6858d75d6e48c73e431c174dcf9214edbd7e6fa5911b93bd8abfa54e47123 - languageName: node - linkType: hard - "acorn@npm:^8.15.0": version: 8.15.0 resolution: "acorn@npm:8.15.0" @@ -13231,15 +12744,6 @@ __metadata: languageName: node linkType: hard -"acorn@npm:^8.8.2": - version: 8.10.0 - resolution: "acorn@npm:8.10.0" - bin: - acorn: bin/acorn - checksum: 10c0/deaeebfbea6e40f6c0e1070e9b0e16e76ba484de54cbd735914d1d41d19169a450de8630b7a3a0c4e271a3b0c0b075a3427ad1a40d8a69f8747c0e8cb02ee3e2 - languageName: node - linkType: hard - "adjust-sourcemap-loader@npm:^4.0.0": version: 4.0.0 resolution: "adjust-sourcemap-loader@npm:4.0.0" @@ -14938,13 +14442,6 @@ __metadata: languageName: node linkType: hard -"cjs-module-lexer@npm:^1.2.2": - version: 1.2.3 - resolution: "cjs-module-lexer@npm:1.2.3" - checksum: 10c0/0de9a9c3fad03a46804c0d38e7b712fb282584a9c7ef1ed44cae22fb71d9bb600309d66a9711ac36a596fd03422f5bb03e021e8f369c12a39fa1786ae531baab - languageName: node - linkType: hard - "cjs-module-lexer@npm:^1.2.3": version: 1.3.1 resolution: "cjs-module-lexer@npm:1.3.1" @@ -14959,6 +14456,13 @@ __metadata: languageName: node linkType: hard +"cjs-module-lexer@npm:^2.2.0": + version: 2.3.0 + resolution: "cjs-module-lexer@npm:2.3.0" + checksum: 10c0/9a6b9ca6f3c4734e108afa7a9cdf9ebf180329e1f94729a8a054102b2d66f5bbd62beb6a7b25ed8b0feca561c96542f34583fe5f0a72691751ff3ab718f5690f + languageName: node + linkType: hard + "class-variance-authority@npm:^0.7.1": version: 0.7.1 resolution: "class-variance-authority@npm:0.7.1" @@ -16150,7 +15654,7 @@ __metadata: languageName: node linkType: hard -"debug@npm:4.4.3, debug@npm:^4.4.3": +"debug@npm:4.4.3, debug@npm:^4.3.5, debug@npm:^4.4.3": version: 4.4.3 resolution: "debug@npm:4.4.3" dependencies: @@ -16328,13 +15832,6 @@ __metadata: languageName: node linkType: hard -"define-lazy-prop@npm:^2.0.0": - version: 2.0.0 - resolution: "define-lazy-prop@npm:2.0.0" - checksum: 10c0/db6c63864a9d3b7dc9def55d52764968a5af296de87c1b2cc71d8be8142e445208071953649e0386a8cc37cfcf9a2067a47207f1eb9ff250c2a269658fdae422 - languageName: node - linkType: hard - "define-properties@npm:^1.1.3, define-properties@npm:^1.2.1": version: 1.2.1 resolution: "define-properties@npm:1.2.1" @@ -17083,6 +16580,13 @@ __metadata: languageName: node linkType: hard +"es-module-lexer@npm:^3.0.3": + version: 3.0.4 + resolution: "es-module-lexer@npm:3.0.4" + checksum: 10c0/6e89027c3ce2e78c577bee234d3cf9e41035b6622cc2d399bffda322556f09735a864b3c7729da8528c96ec8cf00d93d7d418cdedb6765e9e4d228954fbfde3d + languageName: node + linkType: hard + "es-object-atoms@npm:1.1.1, es-object-atoms@npm:^1.0.0, es-object-atoms@npm:^1.1.1": version: 1.1.1 resolution: "es-object-atoms@npm:1.1.1" @@ -18551,13 +18055,6 @@ __metadata: languageName: node linkType: hard -"fecha@npm:^4.2.0": - version: 4.2.3 - resolution: "fecha@npm:4.2.3" - checksum: 10c0/0e895965959cf6a22bb7b00f0bf546f2783836310f510ddf63f463e1518d4c96dec61ab33fdfd8e79a71b4856a7c865478ce2ee8498d560fe125947703c9b1cf - languageName: node - linkType: hard - "fetch-blob@npm:^3.1.2, fetch-blob@npm:^3.1.4": version: 3.2.0 resolution: "fetch-blob@npm:3.2.0" @@ -18568,20 +18065,6 @@ __metadata: languageName: node linkType: hard -"fflate@npm:0.7.4": - version: 0.7.4 - resolution: "fflate@npm:0.7.4" - checksum: 10c0/5e749eb3a6ed61a0f6c55756abf9f4258f06f60505db689e22d18503dd252ca5af656d32668e4b7b20714adf8b313febf695d23863a8352f23e325baee0f672d - languageName: node - linkType: hard - -"fflate@npm:^0.4.4": - version: 0.4.8 - resolution: "fflate@npm:0.4.8" - checksum: 10c0/29d1eddaaa5deab61b1c6b0d21282adacadbc4d2c01e94d8b1ee784398151673b9c563e53f97a801bc410a1ae55e8de5378114a743430e643e7a0644ba8e5a42 - languageName: node - linkType: hard - "figures@npm:3.2.0": version: 3.2.0 resolution: "figures@npm:3.2.0" @@ -19069,25 +18552,26 @@ __metadata: languageName: node linkType: hard -"gaxios@npm:^6.0.0": - version: 6.3.0 - resolution: "gaxios@npm:6.3.0" +"gaxios@npm:7.1.3": + version: 7.1.3 + resolution: "gaxios@npm:7.1.3" dependencies: extend: "npm:^3.0.2" https-proxy-agent: "npm:^7.0.1" - is-stream: "npm:^2.0.0" - node-fetch: "npm:^2.6.9" - checksum: 10c0/89b390d6a3776fcb706dc9ef9728c424595fca15afb6a7c6fb8a164a06708203189cd71e39f1617ece39e1d7ec6964f8882b2cafaf1b823a02175f758c1b8738 + node-fetch: "npm:^3.3.2" + rimraf: "npm:^5.0.1" + checksum: 10c0/a4a1cdf9a392c0c22e9734a40dca5a77a2903f505b939a50f1e68e312458b1289b7993d2f72d011426e89657cae77a3aa9fc62fb140e8ba90a1faa31fdbde4d2 languageName: node linkType: hard -"gcp-metadata@npm:^6.0.0": - version: 6.1.0 - resolution: "gcp-metadata@npm:6.1.0" +"gcp-metadata@npm:^8.0.0": + version: 8.1.4 + resolution: "gcp-metadata@npm:8.1.4" dependencies: - gaxios: "npm:^6.0.0" + gaxios: "npm:7.1.3" + google-logging-utils: "npm:1.1.3" json-bigint: "npm:^1.0.0" - checksum: 10c0/0f84f8c0b974e79d0da0f3063023486e53d7982ce86c4b5871e4ee3b1fc4e7f76fcc05f6342aa0ded5023f1a499c21ab97743a498b31f3aa299905226d1f66ab + checksum: 10c0/dffba44f5192d73c515f04fd9ce7da89e5d05403d75c93d308bb3909044721038eac581cd08652679eaf570b232c65fae8591ba06ec8370945e1ca94609ab8aa languageName: node linkType: hard @@ -19307,7 +18791,7 @@ __metadata: languageName: node linkType: hard -"glob@npm:^10.2.2, glob@npm:^10.3.10": +"glob@npm:^10.2.2, glob@npm:^10.3.10, glob@npm:^10.3.7": version: 10.5.0 resolution: "glob@npm:10.5.0" dependencies: @@ -19448,6 +18932,13 @@ __metadata: languageName: node linkType: hard +"google-logging-utils@npm:1.1.3": + version: 1.1.3 + resolution: "google-logging-utils@npm:1.1.3" + checksum: 10c0/e65201c7e96543bd1423b9324013736646b9eed60941e0bfa47b9bfd146d2f09cf3df1c99ca60b7d80a726075263ead049ee72de53372cb8458c3bc55c2c1e59 + languageName: node + linkType: hard + "gopd@npm:1.2.0, gopd@npm:^1.0.1, gopd@npm:^1.2.0": version: 1.2.0 resolution: "gopd@npm:1.2.0" @@ -20202,27 +19693,14 @@ __metadata: languageName: node linkType: hard -"import-in-the-middle@npm:1.7.4": - version: 1.7.4 - resolution: "import-in-the-middle@npm:1.7.4" - dependencies: - acorn: "npm:^8.8.2" - acorn-import-attributes: "npm:^1.9.5" - cjs-module-lexer: "npm:^1.2.2" - module-details-from-path: "npm:^1.0.3" - checksum: 10c0/3ba4ce34c2f1287dcfab375179dcbc7af5358dced56fbe3713ff48780d2f0ca3a1778f1435af5f4e18f14c70a34013a344279a35a1b6e219eaa18fd959666058 - languageName: node - linkType: hard - -"import-in-the-middle@npm:^1.8.1": - version: 1.14.0 - resolution: "import-in-the-middle@npm:1.14.0" +"import-in-the-middle@npm:^3.0.0, import-in-the-middle@npm:^3.5.2": + version: 3.5.3 + resolution: "import-in-the-middle@npm:3.5.3" dependencies: - acorn: "npm:^8.14.0" - acorn-import-attributes: "npm:^1.9.5" - cjs-module-lexer: "npm:^1.2.2" - module-details-from-path: "npm:^1.0.3" - checksum: 10c0/7df8bff5cf8f3dc98d9e49b6e83b39bc5571d6afbeeaa7f783829e6f4a201329595f51f7c037ee7db395bb3866625d056edcd3f112a93f0e1f31930dbd8ec437 + cjs-module-lexer: "npm:^2.2.0" + es-module-lexer: "npm:^3.0.3" + module-details-from-path: "npm:^1.0.4" + checksum: 10c0/f342bb5b83d2c7e2e7c3f87832f6ee020c15b0c478895e4a597524d7827a51e206acba2755fedc346026eb9d7748bc89c7eda7b289a10e13a84f9f35eb60ea34 languageName: node linkType: hard @@ -20636,7 +20114,7 @@ __metadata: languageName: node linkType: hard -"is-docker@npm:^2.0.0, is-docker@npm:^2.1.1": +"is-docker@npm:^2.0.0": version: 2.2.1 resolution: "is-docker@npm:2.2.1" bin: @@ -22149,13 +21627,6 @@ __metadata: languageName: node linkType: hard -"json-stringify-safe@npm:^5.0.1": - version: 5.0.1 - resolution: "json-stringify-safe@npm:5.0.1" - checksum: 10c0/7dbf35cd0411d1d648dceb6d59ce5857ec939e52e4afc37601aa3da611f0987d5cee5b38d58329ceddf3ed48bd7215229c8d52059ab01f2444a338bf24ed0f37 - languageName: node - linkType: hard - "json5@npm:2.2.3, json5@npm:^2.1.2, json5@npm:^2.2.2, json5@npm:^2.2.3": version: 2.2.3 resolution: "json5@npm:2.2.3" @@ -22575,13 +22046,6 @@ __metadata: languageName: node linkType: hard -"lodash.isobject@npm:^3.0.2": - version: 3.0.2 - resolution: "lodash.isobject@npm:3.0.2" - checksum: 10c0/da4c8480d98b16835b59380b2fbd43c54081acd9466febb788ba77c434384349e0bec162d1c4e89f613f21687b2b6d8384d8a112b80da00c78d28d9915a5cdde - languageName: node - linkType: hard - "lodash.isplainobject@npm:^4.0.6": version: 4.0.6 resolution: "lodash.isplainobject@npm:4.0.6" @@ -22589,13 +22053,6 @@ __metadata: languageName: node linkType: hard -"lodash.isstring@npm:^4.0.1": - version: 4.0.1 - resolution: "lodash.isstring@npm:4.0.1" - checksum: 10c0/09eaf980a283f9eef58ef95b30ec7fee61df4d6bf4aba3b5f096869cc58f24c9da17900febc8ffd67819b4e29de29793190e88dc96983db92d84c95fa85d1c92 - languageName: node - linkType: hard - "lodash.memoize@npm:^4.1.2": version: 4.1.2 resolution: "lodash.memoize@npm:4.1.2" @@ -22645,7 +22102,7 @@ __metadata: languageName: node linkType: hard -"lodash@npm:^4.17.20, lodash@npm:^4.17.21, lodash@npm:^4.17.23, lodash@npm:^4.18.1": +"lodash@npm:^4.17.20, lodash@npm:^4.17.21, lodash@npm:^4.18.1": version: 4.18.1 resolution: "lodash@npm:4.18.1" checksum: 10c0/757228fc68805c59789e82185135cf85f05d0b2d3d54631d680ca79ec21944ec8314d4533639a14b8bcfbd97a517e78960933041a5af17ecb693ec6eecb99a27 @@ -22681,28 +22138,7 @@ __metadata: languageName: node linkType: hard -"logform@npm:^2.3.2": - version: 2.5.1 - resolution: "logform@npm:2.5.1" - dependencies: - "@colors/colors": "npm:1.5.0" - "@types/triple-beam": "npm:^1.3.2" - fecha: "npm:^4.2.0" - ms: "npm:^2.1.1" - safe-stable-stringify: "npm:^2.3.1" - triple-beam: "npm:^1.3.0" - checksum: 10c0/d11c36b4c42063abc816fda2fd149cff9969a9943d42afd95ddd1426804980b4e92e24f2ea6a9916fd490224b1c97578734a37d3b40ce3a9418495ce52e8ef23 - languageName: node - linkType: hard - -"long@npm:^4.0.0": - version: 4.0.0 - resolution: "long@npm:4.0.0" - checksum: 10c0/50a6417d15b06104dbe4e3d4a667c39b137f130a9108ea8752b352a4cfae047531a3ac351c181792f3f8768fe17cca6b0f406674a541a86fb638aaac560d83ed - languageName: node - linkType: hard - -"long@npm:^5.0.0, long@npm:^5.2.3": +"long@npm:^5.0.0": version: 5.2.3 resolution: "long@npm:5.2.3" checksum: 10c0/6a0da658f5ef683b90330b1af76f06790c623e148222da9d75b60e266bbf88f803232dd21464575681638894a84091616e7f89557aa087fd14116c0f4e0e43d9 @@ -23909,13 +23345,6 @@ __metadata: languageName: node linkType: hard -"mitt@npm:^1.1.3": - version: 1.2.0 - resolution: "mitt@npm:1.2.0" - checksum: 10c0/81a0f22b7ac1a0ab5f17489e811641ad589b5e9d2a46a25adac19c8c0ba9c3b50bef7b287582357de25eaa0a47e5d4ced63ea8b8641ba6ca1d1f39d3ec47bb11 - languageName: node - linkType: hard - "mitt@npm:^3.0.0, mitt@npm:^3.0.1": version: 3.0.1 resolution: "mitt@npm:3.0.1" @@ -23946,6 +23375,13 @@ __metadata: languageName: node linkType: hard +"module-details-from-path@npm:^1.0.4": + version: 1.0.4 + resolution: "module-details-from-path@npm:1.0.4" + checksum: 10c0/10863413e96dab07dee917eae07afe46f7bf853065cc75a7d2a718adf67574857fb64f8a2c0c9af12ac733a9a8cf652db7ed39b95f7a355d08106cb9cc50c83b + languageName: node + linkType: hard + "mongodb-connection-string-url@npm:^2.6.0": version: 2.6.0 resolution: "mongodb-connection-string-url@npm:2.6.0" @@ -24363,7 +23799,7 @@ __metadata: languageName: node linkType: hard -"node-fetch@npm:^2.6.0, node-fetch@npm:^2.6.9, node-fetch@npm:^2.7.0": +"node-fetch@npm:^2.6.0, node-fetch@npm:^2.7.0": version: 2.7.0 resolution: "node-fetch@npm:2.7.0" dependencies: @@ -24388,6 +23824,17 @@ __metadata: languageName: node linkType: hard +"node-fetch@npm:^3.3.2": + version: 3.3.2 + resolution: "node-fetch@npm:3.3.2" + dependencies: + data-uri-to-buffer: "npm:^4.0.0" + fetch-blob: "npm:^3.1.4" + formdata-polyfill: "npm:^4.0.10" + checksum: 10c0/f3d5e56190562221398c9f5750198b34cf6113aa304e34ee97c94fd300ec578b25b2c2906edba922050fce983338fde0d5d34fcb0fc3336ade5bd0e429ad7538 + languageName: node + linkType: hard + "node-gyp@npm:latest": version: 10.2.0 resolution: "node-gyp@npm:10.2.0" @@ -24968,17 +24415,6 @@ __metadata: languageName: node linkType: hard -"open@npm:^8.4.2": - version: 8.4.2 - resolution: "open@npm:8.4.2" - dependencies: - define-lazy-prop: "npm:^2.0.0" - is-docker: "npm:^2.1.1" - is-wsl: "npm:^2.2.0" - checksum: 10c0/bb6b3a58401dacdb0aad14360626faf3fb7fba4b77816b373495988b724fb48941cad80c1b65d62bb31a17609b2cd91c41a181602caea597ca80dfbcc27e84c9 - languageName: node - linkType: hard - "optionator@npm:^0.9.3": version: 0.9.3 resolution: "optionator@npm:0.9.3" @@ -24993,7 +24429,7 @@ __metadata: languageName: node linkType: hard -"ora@npm:5.4.1, ora@npm:^5.4.1": +"ora@npm:5.4.1": version: 5.4.1 resolution: "ora@npm:5.4.1" dependencies: @@ -25773,16 +25209,6 @@ __metadata: languageName: node linkType: hard -"pino-abstract-transport@npm:^1.2.0": - version: 1.2.0 - resolution: "pino-abstract-transport@npm:1.2.0" - dependencies: - readable-stream: "npm:^4.0.0" - split2: "npm:^4.0.0" - checksum: 10c0/b4ab59529b7a91f488440147fc58ee0827a6c1c5ca3627292339354b1381072c1a6bfa9b46d03ad27872589e8477ecf74da12cf286e1e6b665ac64a3b806bf07 - languageName: node - linkType: hard - "pino-abstract-transport@npm:^2.0.0": version: 2.0.0 resolution: "pino-abstract-transport@npm:2.0.0" @@ -26414,26 +25840,6 @@ __metadata: languageName: node linkType: hard -"protobufjs@npm:^7.3.0": - version: 7.5.8 - resolution: "protobufjs@npm:7.5.8" - dependencies: - "@protobufjs/aspromise": "npm:^1.1.2" - "@protobufjs/base64": "npm:^1.1.2" - "@protobufjs/codegen": "npm:^2.0.5" - "@protobufjs/eventemitter": "npm:^1.1.0" - "@protobufjs/fetch": "npm:^1.1.0" - "@protobufjs/float": "npm:^1.0.2" - "@protobufjs/inquire": "npm:^1.1.1" - "@protobufjs/path": "npm:^1.1.2" - "@protobufjs/pool": "npm:^1.1.0" - "@protobufjs/utf8": "npm:^1.1.1" - "@types/node": "npm:>=13.7.0" - long: "npm:^5.0.0" - checksum: 10c0/25968259084a634e035f865febd5a31f75bdaee4fda6fba4e14c57019024e7cada859b470eb69350f430fbd0d509c805249b9fe8a6c44a57a0b484a1ef685751 - languageName: node - linkType: hard - "protobufjs@npm:^7.5.5": version: 7.6.2 resolution: "protobufjs@npm:7.6.2" @@ -26473,30 +25879,6 @@ __metadata: languageName: node linkType: hard -"protobufjs@npm:~6.11.2": - version: 6.11.4 - resolution: "protobufjs@npm:6.11.4" - dependencies: - "@protobufjs/aspromise": "npm:^1.1.2" - "@protobufjs/base64": "npm:^1.1.2" - "@protobufjs/codegen": "npm:^2.0.4" - "@protobufjs/eventemitter": "npm:^1.1.0" - "@protobufjs/fetch": "npm:^1.1.0" - "@protobufjs/float": "npm:^1.0.2" - "@protobufjs/inquire": "npm:^1.1.0" - "@protobufjs/path": "npm:^1.1.2" - "@protobufjs/pool": "npm:^1.1.0" - "@protobufjs/utf8": "npm:^1.1.0" - "@types/long": "npm:^4.0.1" - "@types/node": "npm:>=13.7.0" - long: "npm:^4.0.0" - bin: - pbjs: bin/pbjs - pbts: bin/pbts - checksum: 10c0/c244d7b9b6d3258193da5c0d1e558dfb47f208ae345e209f90ec45c9dca911b90fa17e937892a9a39a4136ab9886981aae9efdf6039f7baff4f7225f5eeb9812 - languageName: node - linkType: hard - "proxy-addr@npm:~2.0.7": version: 2.0.8 resolution: "proxy-addr@npm:2.0.8" @@ -27396,13 +26778,6 @@ __metadata: languageName: node linkType: hard -"regenerator-runtime@npm:^0.13.11, regenerator-runtime@npm:^0.13.4": - version: 0.13.11 - resolution: "regenerator-runtime@npm:0.13.11" - checksum: 10c0/12b069dc774001fbb0014f6a28f11c09ebfe3c0d984d88c9bced77fdb6fedbacbca434d24da9ae9371bfbf23f754869307fb51a4c98a8b8b18e5ef748677ca24 - languageName: node - linkType: hard - "regenerator-runtime@npm:^0.14.0": version: 0.14.0 resolution: "regenerator-runtime@npm:0.14.0" @@ -27588,14 +26963,13 @@ __metadata: languageName: node linkType: hard -"require-in-the-middle@npm:^7.1.1": - version: 7.1.1 - resolution: "require-in-the-middle@npm:7.1.1" +"require-in-the-middle@npm:^8.0.0": + version: 8.0.1 + resolution: "require-in-the-middle@npm:8.0.1" dependencies: - debug: "npm:^4.1.1" + debug: "npm:^4.3.5" module-details-from-path: "npm:^1.0.3" - resolve: "npm:^1.22.1" - checksum: 10c0/45c7b9e2dcc534c9ebd70d7e1cf3dfe135dede70a5740867fcb7f1bc930479096a36c9e9f57fd0949f7010724d8cf503144bdfbdd1b69296a45b49fc78c32abf + checksum: 10c0/4b3d29adfff873585dceffa9ddb8f33bb6599001ddff758503e0e5ade2ae6d20d691314125bb13679fa75a19893338e11953d4702dd2fea181e95c0f8316b29b languageName: node linkType: hard @@ -27851,6 +27225,17 @@ __metadata: languageName: node linkType: hard +"rimraf@npm:^5.0.1": + version: 5.0.10 + resolution: "rimraf@npm:5.0.10" + dependencies: + glob: "npm:^10.3.7" + bin: + rimraf: dist/esm/bin.mjs + checksum: 10c0/7da4fd0e15118ee05b918359462cfa1e7fe4b1228c7765195a45b55576e8c15b95db513b8466ec89129666f4af45ad978a3057a02139afba1a63512a2d9644cc + languageName: node + linkType: hard + "ripemd160@npm:^2.0.0, ripemd160@npm:^2.0.1": version: 2.0.2 resolution: "ripemd160@npm:2.0.2" @@ -27984,6 +27369,15 @@ __metadata: languageName: node linkType: hard +"rrdom@npm:^2.2.0": + version: 2.2.0 + resolution: "rrdom@npm:2.2.0" + dependencies: + rrweb-snapshot: "npm:^2.2.0" + checksum: 10c0/8b8ba98f06c2c82d16a25da31cc15a51c7111f64e8eb27a664ae85f3f46581549321a3ffc0d4cfb66c381414869b30db23963a2e6d228ed107c53e64791be240 + languageName: node + linkType: hard + "rrweb-cssom@npm:^0.8.0": version: 0.8.0 resolution: "rrweb-cssom@npm:0.8.0" @@ -27991,13 +27385,6 @@ __metadata: languageName: node linkType: hard -"rrweb-snapshot@npm:^1.1.14": - version: 1.1.14 - resolution: "rrweb-snapshot@npm:1.1.14" - checksum: 10c0/1b4bbd801ec7bb68a720dd6e6112f49184e34f017f4516509506b25b04ff820922770f386e4945fcfeab4a35de68c6f278c14acd61bf48daf8654dc0de00dc85 - languageName: node - linkType: hard - "rrweb-snapshot@npm:^2.1.1": version: 2.1.1 resolution: "rrweb-snapshot@npm:2.1.1" @@ -28007,17 +27394,12 @@ __metadata: languageName: node linkType: hard -"rrweb@npm:1.1.3": - version: 1.1.3 - resolution: "rrweb@npm:1.1.3" +"rrweb-snapshot@npm:^2.2.0": + version: 2.2.0 + resolution: "rrweb-snapshot@npm:2.2.0" dependencies: - "@types/css-font-loading-module": "npm:0.0.7" - "@xstate/fsm": "npm:^1.4.0" - base64-arraybuffer: "npm:^1.0.1" - fflate: "npm:^0.4.4" - mitt: "npm:^1.1.3" - rrweb-snapshot: "npm:^1.1.14" - checksum: 10c0/fc4555a29d59f9800b545d2a14e8903c8e5928a62aa7d66f39310490219970dd6ab0e5205c0eb5fef8248c17d19c23358c03a25ce1c094c7b5d42d813e3cf2b8 + postcss: "npm:^8.4.38" + checksum: 10c0/ee8b8d8184a53ac6b17e56c89536817665bdc9a10e950bec905b9a4143e81880f1fc65ee03e72b025923afe5fcac587a9c202243907f8526bd9b4d39d673f558 languageName: node linkType: hard @@ -28037,6 +27419,22 @@ __metadata: languageName: node linkType: hard +"rrweb@npm:^2.2.0": + version: 2.2.0 + resolution: "rrweb@npm:2.2.0" + dependencies: + "@rrweb/types": "npm:^2.2.0" + "@rrweb/utils": "npm:^2.2.0" + "@types/css-font-loading-module": "npm:0.0.7" + "@xstate/fsm": "npm:^1.4.0" + base64-arraybuffer: "npm:^1.0.1" + mitt: "npm:^3.0.0" + rrdom: "npm:^2.2.0" + rrweb-snapshot: "npm:^2.2.0" + checksum: 10c0/d6517d5085390b3eb2a4557fc4353e8417ef438f35a71a5f4065f5f1a8f418bcd090d342586e6f55aa606f86c9f51ad0ee3d648018dabcc445f3622d90e6d10b + languageName: node + linkType: hard + "run-applescript@npm:7.0.0": version: 7.0.0 resolution: "run-applescript@npm:7.0.0" @@ -28297,7 +27695,7 @@ __metadata: languageName: node linkType: hard -"semver@npm:^7.3.5, semver@npm:^7.3.7, semver@npm:^7.3.8, semver@npm:^7.5.2": +"semver@npm:^7.3.5, semver@npm:^7.3.7, semver@npm:^7.3.8": version: 7.5.2 resolution: "semver@npm:7.5.2" dependencies: @@ -28308,7 +27706,7 @@ __metadata: languageName: node linkType: hard -"semver@npm:^7.6.0, semver@npm:^7.6.2": +"semver@npm:^7.6.0": version: 7.6.2 resolution: "semver@npm:7.6.2" bin: @@ -28640,13 +28038,6 @@ __metadata: languageName: node linkType: hard -"shimmer@npm:^1.2.1": - version: 1.2.1 - resolution: "shimmer@npm:1.2.1" - checksum: 10c0/ae8b27c389db2a00acfc8da90240f11577685a8f3e40008f826a3bea8b4f3b3ecd305c26be024b4a0fd3b123d132c1569d6e238097960a9a543b6c60760fb46a - languageName: node - linkType: hard - "side-channel-list@npm:^1.0.0": version: 1.0.0 resolution: "side-channel-list@npm:1.0.0" @@ -30343,13 +29734,6 @@ __metadata: languageName: node linkType: hard -"triple-beam@npm:^1.3.0": - version: 1.3.0 - resolution: "triple-beam@npm:1.3.0" - checksum: 10c0/a6da96495f25b6c04b3629df5161c7eb84760927943f16665fd8dcd3a643daadf73d69eee78306b4b68d606937f22f8703afe763bc8d3723632ffb1f3a798493 - languageName: node - linkType: hard - "trough@npm:^2.0.0": version: 2.1.0 resolution: "trough@npm:2.1.0" @@ -30556,13 +29940,6 @@ __metadata: languageName: node linkType: hard -"tslib@npm:^2.5.3": - version: 2.6.0 - resolution: "tslib@npm:2.6.0" - checksum: 10c0/8d18020a8b9e70ecc529a744c883c095f177805efdbc9786bd50bd82a46c17547923133c5444fbcaf1f7f1c44e0e29c89f73ecf6d8fd1039668024a073a81dc6 - languageName: node - linkType: hard - "tslib@npm:^2.6.2": version: 2.7.0 resolution: "tslib@npm:2.7.0" @@ -30674,13 +30051,6 @@ __metadata: languageName: node linkType: hard -"type-fest@npm:4.20.1": - version: 4.20.1 - resolution: "type-fest@npm:4.20.1" - checksum: 10c0/c31da16fe170a74c5b7e102e70e764ba8ec6ade128e782a56f842aefa07307df5a6353e6b5601d3b30ff2d856d8b955f89813df639e4758fedcf8e426b2d854e - languageName: node - linkType: hard - "type-fest@npm:^0.13.1": version: 0.13.1 resolution: "type-fest@npm:0.13.1" @@ -31521,10 +30891,10 @@ __metadata: languageName: node linkType: hard -"web-vitals@npm:^3.3.2": - version: 3.3.2 - resolution: "web-vitals@npm:3.3.2" - checksum: 10c0/fabfc58eedcee59741958e09bcb365facbb8b229521762e374fd9ab7c64e29f80ddf3a70e7959388f455936c3aca416c24b8dd938de5e56d5fcb2691aea5c4c8 +"web-vitals@npm:^6.2.3": + version: 6.2.3 + resolution: "web-vitals@npm:6.2.3" + checksum: 10c0/d7db74ab8503f069db0f697b1b1318670062616a1b46464abde98dc599ffbf71c0080f39bfe739ed122da12f6980fe882d471e86a78fedad61a4bfa1abffa32c languageName: node linkType: hard @@ -31877,17 +31247,6 @@ __metadata: languageName: node linkType: hard -"winston-transport@npm:^4.7.0": - version: 4.7.0 - resolution: "winston-transport@npm:4.7.0" - dependencies: - logform: "npm:^2.3.2" - readable-stream: "npm:^3.6.0" - triple-beam: "npm:^1.3.0" - checksum: 10c0/cd16f3d0ab56697f93c4899e0eb5f89690f291bb6cf309194819789326a7c7ed943ef00f0b2fab513b114d371314368bde1a7ae6252ad1516181a79f90199cd2 - languageName: node - linkType: hard - "wordwrap@npm:^1.0.0": version: 1.0.0 resolution: "wordwrap@npm:1.0.0" @@ -32091,6 +31450,15 @@ __metadata: languageName: node linkType: hard +"yaml@npm:^2.8.3": + version: 2.9.1 + resolution: "yaml@npm:2.9.1" + bin: + yaml: bin.mjs + checksum: 10c0/9d06676ef02b89559a8b10a71882bd2cdae81e8393dc8dbc871615c3259475d9609ad973d19cb3c9e71e72d6206e3d1e7aa241c7e55f3d16fd2e77db305827d6 + languageName: node + linkType: hard + "yargs-parser@npm:21.1.1, yargs-parser@npm:^21.1.1": version: 21.1.1 resolution: "yargs-parser@npm:21.1.1"