diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml index 028d68dab..c8014ea98 100644 --- a/.github/workflows/e2e.yml +++ b/.github/workflows/e2e.yml @@ -17,6 +17,7 @@ jobs: uses: actions/checkout@v3 with: fetch-depth: 0 + submodules: recursive - name: ⎔ Setup pnpm uses: pnpm/action-setup@v2.2.4 @@ -29,6 +30,9 @@ jobs: node-version: 18 cache: "pnpm" + - name: Install Protoc + uses: arduino/setup-protoc@v3 + - name: 📥 Download deps run: pnpm install --frozen-lockfile @@ -43,7 +47,10 @@ jobs: # Build packages pnpm run build --filter @references/nextjs-test^... + cd apps/webapp && pnpm run build:server + cd ../.. pnpm --filter @trigger.dev/database generate + pnpm --filter @trigger.dev/otlp-importer generate # Move trigger-cli bin to correct place pnpm install --frozen-lockfile diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index cb954be9d..206408420 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -8,7 +8,6 @@ on: - "**.md" - ".github/CODEOWNERS" - ".github/ISSUE_TEMPLATE/**" - jobs: release: @@ -39,6 +38,9 @@ jobs: node-version: 18 cache: "pnpm" + - name: Install Protoc + uses: arduino/setup-protoc@v3 + - name: 📥 Download deps run: pnpm install --frozen-lockfile diff --git a/.github/workflows/typecheck.yml b/.github/workflows/typecheck.yml index 1d32f6945..55ecf7c0a 100644 --- a/.github/workflows/typecheck.yml +++ b/.github/workflows/typecheck.yml @@ -22,6 +22,9 @@ jobs: node-version: 18 cache: "pnpm" + - name: Install Protoc + uses: arduino/setup-protoc@v3 + - name: 📥 Download deps run: pnpm install --frozen-lockfile diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index 39fc79d66..030b2b6b0 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -22,6 +22,9 @@ jobs: node-version: 18 cache: "pnpm" + - name: Install Protoc + uses: arduino/setup-protoc@v3 + - name: ⎔ Setup Deno uses: denoland/setup-deno@v1 with: diff --git a/.gitignore b/.gitignore index c83ebf244..2fdaed720 100644 --- a/.gitignore +++ b/.gitignore @@ -53,4 +53,5 @@ apps/**/public/build /playwright-report/ /playwright/.cache/ -.cosine \ No newline at end of file +.cosine +.trigger/ \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 000000000..a284e2e66 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "packages/otlp-importer/protos"] + path = packages/otlp-importer/protos + url = https://github.com/open-telemetry/opentelemetry-proto.git diff --git a/.vscode/launch.json b/.vscode/launch.json index 37375ca33..769c365b3 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -28,6 +28,14 @@ "envFile": "${workspaceFolder}/references/job-catalog/.env", "cwd": "${workspaceFolder}/references/job-catalog", "sourceMaps": true + }, + { + "type": "node-terminal", + "request": "launch", + "name": "Debug V3 Dev CLI", + "command": "pnpm exec trigger.dev dev", + "cwd": "${workspaceFolder}/references/v3-catalog", + "sourceMaps": true } ] } diff --git a/apps/webapp/app/entry.server.tsx b/apps/webapp/app/entry.server.tsx index fb097ff59..12831e723 100644 --- a/apps/webapp/app/entry.server.tsx +++ b/apps/webapp/app/entry.server.tsx @@ -194,3 +194,5 @@ function logError(error: unknown, request?: Request) { } const sqsEventConsumer = singleton("sqsEventConsumer", getSharedSqsEventConsumer); + +export { wss } from "./v3/handleWebsockets.server"; diff --git a/apps/webapp/app/models/project.server.ts b/apps/webapp/app/models/project.server.ts index 2c5b67d00..5865cd845 100644 --- a/apps/webapp/app/models/project.server.ts +++ b/apps/webapp/app/models/project.server.ts @@ -1,10 +1,12 @@ -import { nanoid } from "nanoid"; +import { nanoid, customAlphabet } from "nanoid"; import slug from "slug"; import { prisma } from "~/db.server"; import type { Project } from "@trigger.dev/database"; import { Organization, createEnvironment } from "./organization.server"; export type { Project } from "@trigger.dev/database"; +const externalRefGenerator = customAlphabet("abcdefghijklmnopqrstuvwxyz", 20); + export async function createProject( { organizationSlug, name, userId }: { organizationSlug: string; name: string; userId: string }, attemptCount = 0 @@ -53,6 +55,7 @@ export async function createProject( slug: organizationSlug, }, }, + externalRef: externalRefGenerator(), }, include: { organization: { diff --git a/apps/webapp/app/routes/api.v1.authorization-code.ts b/apps/webapp/app/routes/api.v1.authorization-code.ts index d49868971..b924b6750 100644 --- a/apps/webapp/app/routes/api.v1.authorization-code.ts +++ b/apps/webapp/app/routes/api.v1.authorization-code.ts @@ -1,6 +1,6 @@ import type { ActionFunctionArgs } from "@remix-run/server-runtime"; import { json } from "@remix-run/server-runtime"; -import { CreateAuthorizationCodeResponse } from "@trigger.dev/core"; +import { CreateAuthorizationCodeResponse } from "@trigger.dev/core/v3"; import { env } from "~/env.server"; import { logger } from "~/services/logger.server"; import { createAuthorizationCode } from "~/services/personalAccessToken.server"; diff --git a/apps/webapp/app/routes/api.v1.projects.$projectRef.background-workers.ts b/apps/webapp/app/routes/api.v1.projects.$projectRef.background-workers.ts new file mode 100644 index 000000000..28d5f8251 --- /dev/null +++ b/apps/webapp/app/routes/api.v1.projects.$projectRef.background-workers.ts @@ -0,0 +1,55 @@ +import { ActionFunctionArgs, json } from "@remix-run/server-runtime"; +import { CreateBackgroundWorkerRequestBody } from "@trigger.dev/core/v3"; +import { z } from "zod"; +import { authenticateApiRequest } from "~/services/apiAuth.server"; +import { logger } from "~/services/logger.server"; +import { CreateBackgroundWorkerService } from "~/v3/services/createBackgroundWorker.server"; + +const ParamsSchema = z.object({ + projectRef: z.string(), +}); + +export async function action({ request, params }: ActionFunctionArgs) { + // Ensure this is a POST request + if (request.method.toUpperCase() !== "POST") { + return { status: 405, body: "Method Not Allowed" }; + } + + const parsedParams = ParamsSchema.safeParse(params); + + if (!parsedParams.success) { + return json({ error: "Invalid params" }, { status: 400 }); + } + + // Next authenticate the request + const authenticationResult = await authenticateApiRequest(request); + + if (!authenticationResult) { + logger.info("Invalid or missing api key", { url: request.url }); + return json({ error: "Invalid or Missing API key" }, { status: 401 }); + } + + const authenticatedEnv = authenticationResult.environment; + + const { projectRef } = parsedParams.data; + + const rawBody = await request.json(); + const body = CreateBackgroundWorkerRequestBody.safeParse(rawBody); + + if (!body.success) { + return json({ error: "Invalid body", issues: body.error.issues }, { status: 400 }); + } + + const service = new CreateBackgroundWorkerService(); + + const backgroundWorker = await service.call(projectRef, authenticatedEnv, body.data); + + return json( + { + id: backgroundWorker.friendlyId, + version: backgroundWorker.version, + contentHash: backgroundWorker.contentHash, + }, + { status: 200 } + ); +} diff --git a/apps/webapp/app/routes/api.v1.projects.$projectRef.dev.ts b/apps/webapp/app/routes/api.v1.projects.$projectRef.dev.ts new file mode 100644 index 000000000..8b25e2142 --- /dev/null +++ b/apps/webapp/app/routes/api.v1.projects.$projectRef.dev.ts @@ -0,0 +1,64 @@ +import type { LoaderFunctionArgs } from "@remix-run/server-runtime"; +import { json } from "@remix-run/server-runtime"; +import { GetProjectDevResponse } from "@trigger.dev/core/v3"; +import { z } from "zod"; +import { prisma } from "~/db.server"; +import { logger } from "~/services/logger.server"; +import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server"; + +const ParamsSchema = z.object({ + projectRef: z.string(), +}); + +export async function loader({ request, params }: LoaderFunctionArgs) { + logger.info("projects get dev env", { url: request.url }); + + const authenticationResult = await authenticateApiRequestWithPersonalAccessToken(request); + + if (!authenticationResult) { + return json({ error: "Invalid or Missing Access Token" }, { status: 401 }); + } + + const parsedParams = ParamsSchema.safeParse(params); + + if (!parsedParams.success) { + return json({ error: "Invalid Params" }, { status: 400 }); + } + + const projectRef = parsedParams.data.projectRef; + + const project = await prisma.project.findUnique({ + where: { + externalRef: projectRef, + organization: { + members: { + some: { + userId: authenticationResult.userId, + }, + }, + }, + }, + include: { + environments: { + where: { + orgMember: { + userId: authenticationResult.userId, + }, + }, + }, + }, + }); + + if (!project) { + return json({ error: "Project not found" }, { status: 404 }); + } + + const devEnvironment = project.environments[0]; + + const result: GetProjectDevResponse = { + apiKey: devEnvironment.apiKey, + name: project.name, + }; + + return json(result); +} diff --git a/apps/webapp/app/routes/api.v1.tasks.$taskId.trigger.ts b/apps/webapp/app/routes/api.v1.tasks.$taskId.trigger.ts new file mode 100644 index 000000000..7a1611150 --- /dev/null +++ b/apps/webapp/app/routes/api.v1.tasks.$taskId.trigger.ts @@ -0,0 +1,85 @@ +import type { ActionFunctionArgs } from "@remix-run/server-runtime"; +import { json } from "@remix-run/server-runtime"; +import { parseTriggerTaskRequestBody } from "@trigger.dev/core/v3"; +import { z } from "zod"; +import { authenticateApiRequest } from "~/services/apiAuth.server"; +import { logger } from "~/services/logger.server"; +import { TriggerTaskService } from "~/v3/services/triggerTask.server"; + +const ParamsSchema = z.object({ + taskId: z.string(), +}); + +const HeadersSchema = z.object({ + "idempotency-key": z.string().optional().nullable(), + "trigger-version": z.string().optional().nullable(), + traceparent: z.string().optional(), + tracestate: z.string().optional(), +}); + +export async function action({ request, params }: ActionFunctionArgs) { + // Ensure this is a POST request + if (request.method.toUpperCase() !== "POST") { + return { status: 405, body: "Method Not Allowed" }; + } + + // Next authenticate the request + const authenticationResult = await authenticateApiRequest(request); + + if (!authenticationResult) { + return json({ error: "Invalid or Missing API key" }, { status: 401 }); + } + + const rawHeaders = Object.fromEntries(request.headers); + + const headers = HeadersSchema.safeParse(rawHeaders); + + if (!headers.success) { + return json({ error: "Invalid headers" }, { status: 400 }); + } + + const { + "idempotency-key": idempotencyKey, + "trigger-version": triggerVersion, + traceparent, + tracestate, + } = headers.data; + + const { taskId } = ParamsSchema.parse(params); + + // Now parse the request body + const anyBody = await request.json(); + + const body = parseTriggerTaskRequestBody(anyBody); + + if (!body.success) { + return json({ error: "Invalid request body" }, { status: 400 }); + } + + logger.debug("Triggering task", { + taskId, + idempotencyKey, + triggerVersion, + body: body.data, + }); + + const service = new TriggerTaskService(); + + try { + const run = await service.call(taskId, authenticationResult.environment, body.data, { + idempotencyKey: idempotencyKey ?? undefined, + triggerVersion: triggerVersion ?? undefined, + traceContext: traceparent ? { traceparent, tracestate } : undefined, + }); + + return json({ + id: run.friendlyId, + }); + } catch (error) { + if (error instanceof Error) { + return json({ error: error.message }, { status: 400 }); + } + + return json({ error: "Something went wrong" }, { status: 500 }); + } +} diff --git a/apps/webapp/app/routes/api.v1.token.ts b/apps/webapp/app/routes/api.v1.token.ts index 03c1841d7..082debc1c 100644 --- a/apps/webapp/app/routes/api.v1.token.ts +++ b/apps/webapp/app/routes/api.v1.token.ts @@ -3,7 +3,7 @@ import { json } from "@remix-run/server-runtime"; import { GetPersonalAccessTokenRequestSchema, GetPersonalAccessTokenResponse, -} from "@trigger.dev/core"; +} from "@trigger.dev/core/v3"; import { generateErrorMessage } from "zod-error"; import { logger } from "~/services/logger.server"; import { getPersonalAccessTokenFromAuthorizationCode } from "~/services/personalAccessToken.server"; diff --git a/apps/webapp/app/routes/api.v2.whoami.ts b/apps/webapp/app/routes/api.v2.whoami.ts index 8d5c6cdf5..e5bb4cf61 100644 --- a/apps/webapp/app/routes/api.v2.whoami.ts +++ b/apps/webapp/app/routes/api.v2.whoami.ts @@ -1,6 +1,6 @@ import type { LoaderFunctionArgs } from "@remix-run/server-runtime"; import { json } from "@remix-run/server-runtime"; -import { WhoAmIResponse } from "@trigger.dev/core"; +import { WhoAmIResponse } from "@trigger.dev/core/v3"; import { prisma } from "~/db.server"; import { logger } from "~/services/logger.server"; import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server"; diff --git a/apps/webapp/app/routes/otel.v1.logs.ts b/apps/webapp/app/routes/otel.v1.logs.ts new file mode 100644 index 000000000..0554a2942 --- /dev/null +++ b/apps/webapp/app/routes/otel.v1.logs.ts @@ -0,0 +1,13 @@ +import { ActionFunctionArgs } from "@remix-run/server-runtime"; +import { ExportLogsServiceRequest, ExportLogsServiceResponse } from "@trigger.dev/otlp-importer"; +import { otlpExporter } from "~/v3/otlpExporter.server"; + +export async function action({ request }: ActionFunctionArgs) { + const buffer = await request.arrayBuffer(); + + const exportRequest = ExportLogsServiceRequest.decode(new Uint8Array(buffer)); + + const exportResponse = await otlpExporter.exportLogs(exportRequest); + + return new Response(ExportLogsServiceResponse.encode(exportResponse).finish(), { status: 200 }); +} diff --git a/apps/webapp/app/routes/otel.v1.traces.ts b/apps/webapp/app/routes/otel.v1.traces.ts new file mode 100644 index 000000000..2e0677877 --- /dev/null +++ b/apps/webapp/app/routes/otel.v1.traces.ts @@ -0,0 +1,13 @@ +import { ActionFunctionArgs } from "@remix-run/server-runtime"; +import { ExportTraceServiceRequest, ExportTraceServiceResponse } from "@trigger.dev/otlp-importer"; +import { otlpExporter } from "~/v3/otlpExporter.server"; + +export async function action({ request }: ActionFunctionArgs) { + const buffer = await request.arrayBuffer(); + + const exportRequest = ExportTraceServiceRequest.decode(new Uint8Array(buffer)); + + const exportResponse = await otlpExporter.exportTraces(exportRequest); + + return new Response(ExportTraceServiceResponse.encode(exportResponse).finish(), { status: 200 }); +} diff --git a/apps/webapp/app/services/events/sqsEventConsumer.ts b/apps/webapp/app/services/events/sqsEventConsumer.ts index 5be623896..a1ccd3bda 100644 --- a/apps/webapp/app/services/events/sqsEventConsumer.ts +++ b/apps/webapp/app/services/events/sqsEventConsumer.ts @@ -144,8 +144,4 @@ export function getSharedSqsEventConsumer() { return consumer; } - - console.log( - "The SqsEventConsumer is disabled because AWS credentials are missing. This is OK as this is an optional feature." - ); } diff --git a/apps/webapp/app/services/telemetry.server.ts b/apps/webapp/app/services/telemetry.server.ts index 62a3e4ea3..d6d83b23d 100644 --- a/apps/webapp/app/services/telemetry.server.ts +++ b/apps/webapp/app/services/telemetry.server.ts @@ -115,7 +115,11 @@ class Telemetry { }; project = { - identify: ({ project }: { project: Project }) => { + identify: ({ + project, + }: { + project: Pick; + }) => { if (this.#posthogClient === undefined) return; this.#posthogClient.groupIdentify({ groupType: "project", diff --git a/apps/webapp/app/v3/dynamicFlushScheduler.server.ts b/apps/webapp/app/v3/dynamicFlushScheduler.server.ts new file mode 100644 index 000000000..3a82fcf93 --- /dev/null +++ b/apps/webapp/app/v3/dynamicFlushScheduler.server.ts @@ -0,0 +1,68 @@ +export type DynamicFlushSchedulerConfig = { + batchSize: number; + flushInterval: number; + callback: (batch: T[]) => Promise; +}; + +export class DynamicFlushScheduler { + private batchQueue: T[][]; // Adjust the type according to your data structure + private currentBatch: T[]; // Adjust the type according to your data structure + private readonly BATCH_SIZE: number; + private readonly FLUSH_INTERVAL: number; + private flushTimer: NodeJS.Timeout | null; + private readonly callback: (batch: T[]) => Promise; + + constructor(config: DynamicFlushSchedulerConfig) { + this.batchQueue = []; + this.currentBatch = []; + this.BATCH_SIZE = config.batchSize; + this.FLUSH_INTERVAL = config.flushInterval; + this.callback = config.callback; + this.flushTimer = null; + this.startFlushTimer(); + } + + addToBatch(items: T[]): void { + this.currentBatch.push(...items); + + if (this.currentBatch.length >= this.BATCH_SIZE) { + this.batchQueue.push(this.currentBatch); + this.currentBatch = []; + this.flushNextBatch(); + this.resetFlushTimer(); + } + } + + private startFlushTimer(): void { + this.flushTimer = setInterval(() => this.checkAndFlush(), this.FLUSH_INTERVAL); + } + + private resetFlushTimer(): void { + if (this.flushTimer) { + clearInterval(this.flushTimer); + } + this.startFlushTimer(); + } + + private checkAndFlush(): void { + if (this.currentBatch.length > 0) { + this.batchQueue.push(this.currentBatch); + this.currentBatch = []; + } + this.flushNextBatch(); + } + + private async flushNextBatch(): Promise { + if (this.batchQueue.length === 0) return; + + const batchToFlush = this.batchQueue.shift(); + try { + await this.callback(batchToFlush!); + if (this.batchQueue.length > 0) { + this.flushNextBatch(); + } + } catch (error) { + console.error("Error inserting batch:", error); + } + } +} diff --git a/apps/webapp/app/v3/eventRepository.server.ts b/apps/webapp/app/v3/eventRepository.server.ts new file mode 100644 index 000000000..035812c63 --- /dev/null +++ b/apps/webapp/app/v3/eventRepository.server.ts @@ -0,0 +1,265 @@ +import { Prisma, TaskEventStatus, type TaskEventKind } from "@trigger.dev/database"; +import { PrismaClient, prisma } from "~/db.server"; +import { RandomIdGenerator } from "@opentelemetry/sdk-trace-base"; +import { Attributes, ROOT_CONTEXT, propagation, trace } from "@opentelemetry/api"; +import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions"; +import { SemanticInternalAttributes } from "@trigger.dev/core/v3"; +import { flattenAttributes } from "@trigger.dev/core/v3"; +import { AuthenticatedEnvironment } from "~/services/apiAuth.server"; +import { DynamicFlushScheduler } from "./dynamicFlushScheduler.server"; +import { logger } from "~/services/logger.server"; + +export type CreatableEvent = Omit< + Prisma.TaskEventCreateInput, + "id" | "createdAt" | "properties" | "metadata" | "style" | "output" +> & { + properties: Attributes; + metadata: Attributes | undefined; + style: Attributes | undefined; + output: Attributes | undefined; +}; + +export type CreatableEventKind = TaskEventKind; +export type CreatableEventStatus = TaskEventStatus; +export type CreatableEventEnvironmentType = CreatableEvent["environmentType"]; + +export type TraceAttributes = Partial< + Pick< + CreatableEvent, + "attemptId" | "isError" | "runId" | "output" | "metadata" | "properties" | "style" + > +>; + +export type SetAttribute = (key: keyof T, value: T[keyof T]) => void; + +export type TraceEventOptions = { + kind?: CreatableEventKind; + context?: Record; + attributes: TraceAttributes; + environment: AuthenticatedEnvironment; + taskSlug: string; +}; + +export type EventBuilder = { + traceId: string; + spanId: string; + setAttribute: SetAttribute; +}; + +export type EventRepoConfig = { + batchSize: number; + batchInterval: number; +}; + +export class EventRepository { + private readonly _flushScheduler: DynamicFlushScheduler; + + private _randomIdGenerator = new RandomIdGenerator(); + + constructor(private db: PrismaClient = prisma, private readonly _config: EventRepoConfig) { + this._flushScheduler = new DynamicFlushScheduler({ + batchSize: _config.batchSize, + flushInterval: _config.batchInterval, + callback: this.#flushBatch.bind(this), + }); + } + + async insert(event: CreatableEvent) { + this._flushScheduler.addToBatch([event]); + } + + async insertMany(events: CreatableEvent[]) { + this._flushScheduler.addToBatch(events); + } + + public async traceEvent( + message: string, + options: TraceEventOptions, + callback: ( + e: EventBuilder, + traceContext: Record + ) => Promise + ): Promise { + const propagatedContext = extractContextFromCarrier(options.context ?? {}); + + const start = process.hrtime.bigint(); + const startTime = new Date(); + + const traceId = propagatedContext?.traceparent?.traceId ?? this.generateTraceId(); + const parentId = propagatedContext?.traceparent?.spanId; + const tracestate = propagatedContext?.tracestate; + const spanId = this.generateSpanId(); + + logger.info("traceEvent", { + traceId, + parentId, + tracestate, + spanId, + context: options.context, + propagatedContext, + }); + + const traceContext = { + traceparent: `00-${traceId}-${spanId}-01`, + }; + + const eventBuilder = { + traceId, + spanId, + setAttribute: (key: keyof TraceAttributes, value: TraceAttributes[keyof TraceAttributes]) => { + if (value) { + // We need to merge the attributes with the existing attributes + const existingValue = options.attributes[key]; + + if (existingValue && typeof existingValue === "object" && typeof value === "object") { + // @ts-ignore + options.attributes[key] = { ...existingValue, ...value }; + } else { + // @ts-ignore + options.attributes[key] = value; + } + } + }, + }; + + const result = await callback(eventBuilder, traceContext); + + const duration = process.hrtime.bigint() - start; + + const metadata = { + [SemanticInternalAttributes.ENVIRONMENT_ID]: options.environment.id, + [SemanticInternalAttributes.ENVIRONMENT_TYPE]: options.environment.type, + [SemanticInternalAttributes.ORGANIZATION_ID]: options.environment.organizationId, + [SemanticInternalAttributes.PROJECT_ID]: options.environment.projectId, + [SemanticInternalAttributes.PROJECT_REF]: options.environment.project.externalRef, + [SemanticInternalAttributes.RUN_ID]: options.attributes.runId, + [SemanticInternalAttributes.TASK_SLUG]: options.taskSlug, + [SemanticResourceAttributes.SERVICE_NAME]: "api server", + [SemanticResourceAttributes.SERVICE_NAMESPACE]: "trigger.dev", + ...options.attributes.metadata, + }; + + const style = { + [SemanticInternalAttributes.STYLE_ICON]: "play", + }; + + if (!options.attributes.runId) { + throw new Error("runId is required"); + } + + const event: CreatableEvent = { + traceId, + spanId, + parentId, + tracestate, + duration: duration, + message: message, + serviceName: "api server", + serviceNamespace: "trigger.dev", + level: "TRACE", + kind: options.kind, + status: "OK", + startTime: startTime, + environmentId: options.environment.id, + environmentType: options.environment.type, + organizationId: options.environment.organizationId, + projectId: options.environment.projectId, + projectRef: options.environment.project.externalRef, + runId: options.attributes.runId, + taskSlug: options.taskSlug, + properties: { + ...style, + ...(flattenAttributes(metadata, SemanticInternalAttributes.METADATA) as Record< + string, + string + >), + }, + metadata: metadata, + style: stripAttributePrefix(style, SemanticInternalAttributes.STYLE), + output: undefined, + }; + + this._flushScheduler.addToBatch([event]); + + return result; + } + + async #flushBatch(batch: CreatableEvent[]) { + const events = excludePartialEventsWithCorrespondingFullEvent(batch); + + await this.db.taskEvent.createMany({ + data: events as Prisma.TaskEventCreateManyInput[], + }); + } + + public generateTraceId() { + return this._randomIdGenerator.generateTraceId(); + } + + public generateSpanId() { + return this._randomIdGenerator.generateSpanId(); + } +} +export const eventRepository = new EventRepository(prisma, { + batchSize: 100, + batchInterval: 5000, +}); + +export function stripAttributePrefix(attributes: Attributes, prefix: string) { + const result: Attributes = {}; + + for (const [key, value] of Object.entries(attributes)) { + if (key.startsWith(prefix)) { + result[key.slice(prefix.length + 1)] = value; + } else { + result[key] = value; + } + } + return result; +} + +/** + * Filters out partial events from a batch of creatable events, excluding those that have a corresponding full event. + * @param batch - The batch of creatable events to filter. + * @returns The filtered array of creatable events, excluding partial events with corresponding full events. + */ +function excludePartialEventsWithCorrespondingFullEvent(batch: CreatableEvent[]): CreatableEvent[] { + const partialEvents = batch.filter((event) => event.isPartial); + const fullEvents = batch.filter((event) => !event.isPartial); + + return fullEvents.concat( + partialEvents.filter((partialEvent) => { + return !fullEvents.some((fullEvent) => fullEvent.spanId === partialEvent.spanId); + }) + ); +} + +function extractContextFromCarrier(carrier: Record) { + const traceparent = carrier["traceparent"]; + const tracestate = carrier["tracestate"]; + + return { + traceparent: parseTraceparent(traceparent), + tracestate, + }; +} + +function parseTraceparent(traceparent?: string): { traceId: string; spanId: string } | undefined { + if (!traceparent) { + return undefined; + } + + const parts = traceparent.split("-"); + + if (parts.length !== 4) { + return undefined; + } + + const [version, traceId, spanId, flags] = parts; + + if (version !== "00") { + return undefined; + } + + return { traceId, spanId }; +} diff --git a/apps/webapp/app/v3/friendlyIdentifiers.ts b/apps/webapp/app/v3/friendlyIdentifiers.ts new file mode 100644 index 000000000..ebe5e7900 --- /dev/null +++ b/apps/webapp/app/v3/friendlyIdentifiers.ts @@ -0,0 +1,7 @@ +import { customAlphabet } from "nanoid"; + +const idGenerator = customAlphabet("123456789abcdefghijkmnopqrstuvwxyz", 21); + +export function generateFriendlyId(prefix: string) { + return `${prefix}_${idGenerator()}`; +} diff --git a/apps/webapp/app/v3/handleWebsockets.server.ts b/apps/webapp/app/v3/handleWebsockets.server.ts new file mode 100644 index 000000000..6a704ce9e --- /dev/null +++ b/apps/webapp/app/v3/handleWebsockets.server.ts @@ -0,0 +1,452 @@ +import { + BackgroundWorkerClientMessages, + TaskRunExecutionResult, + TaskRunExecution, + ZodMessageHandler, + ZodMessageSender, + clientWebsocketMessages, + serverWebsocketMessages, + TaskRunExecutionPayload, +} from "@trigger.dev/core/v3"; +import { BackgroundWorker, BackgroundWorkerTask } from "@trigger.dev/database"; +import { Evt } from "evt"; +import { randomUUID } from "node:crypto"; +import { IncomingMessage } from "node:http"; +import { WebSocketServer } from "ws"; +import { PrismaClientOrTransaction, prisma } from "~/db.server"; +import { AuthenticatedEnvironment, authenticateApiKey } from "~/services/apiAuth.server"; +import { logger } from "~/services/logger.server"; +import { singleton } from "../utils/singleton"; +import { generateFriendlyId } from "./friendlyIdentifiers"; + +export const wss = singleton("wss", initalizeWebSocketServer); + +let handlers: Map; + +function initalizeWebSocketServer() { + const server = new WebSocketServer({ noServer: true }); + + server.on("connection", handleWebSocketConnection); + + handlers = new Map(); + + return server; +} + +async function handleWebSocketConnection(ws: WebSocket, req: IncomingMessage) { + const authHeader = req.headers.authorization; + + if (!authHeader || typeof authHeader !== "string") { + ws.close(1008, "Missing Authorization header"); + return; + } + + const [authType, apiKey] = authHeader.split(" "); + + if (authType !== "Bearer" || !apiKey) { + ws.close(1008, "Invalid Authorization header"); + return; + } + + const authenticationResult = await authenticateApiKey(apiKey); + + if (!authenticationResult) { + ws.close(1008, "Invalid API key"); + return; + } + + const authenticatedEnv = authenticationResult.environment; + + const handler = new WebsocketHandlers(ws, authenticatedEnv); + + handlers.set(handler.id, handler); + + handler.onClose.attach((closeEvent) => { + logger.debug("Websocket closed", { closeEvent }); + + handlers.delete(handler.id); + }); + + await handler.start(); +} + +class WebsocketHandlers { + public id: string; + public onClose: Evt = new Evt(); + + private backgroundWorkerHandlers: Map = new Map(); + private _sender: ZodMessageSender; + + constructor(public ws: WebSocket, public authenticatedEnv: AuthenticatedEnvironment) { + this.id = randomUUID(); + + ws.addEventListener("message", this.#handleMessage.bind(this)); + ws.addEventListener("close", this.#handleClose.bind(this)); + ws.addEventListener("error", this.#handleError.bind(this)); + + this._sender = new ZodMessageSender({ + schema: serverWebsocketMessages, + sender: async (message) => { + ws.send(JSON.stringify(message)); + }, + }); + } + + async start() { + this._sender.send("SERVER_READY", { id: this.id }); + } + + async #handleMessage(ev: MessageEvent) { + const data = JSON.parse(ev.data.toString()); + + logger.debug("Websocket message received", { data }); + + const handler = new ZodMessageHandler({ + schema: clientWebsocketMessages, + messages: { + READY_FOR_TASKS: async (payload) => { + const handler = new BackgroundWorkerHandler( + payload.backgroundWorkerId, + this.authenticatedEnv, + this._sender + ); + + this.backgroundWorkerHandlers.set(handler.id, handler); + + await handler.start(); + }, + WORKER_DEPRECATED: async (payload) => { + const handler = this.backgroundWorkerHandlers.get(payload.backgroundWorkerId); + + if (!handler) { + logger.error("Failed to find background worker handler", { + backgroundWorkerId: payload.backgroundWorkerId, + }); + return; + } + + await handler.deprecate(); + }, + BACKGROUND_WORKER_MESSAGE: async (payload) => { + const handler = this.backgroundWorkerHandlers.get(payload.backgroundWorkerId); + + if (!handler) { + logger.error("Failed to find background worker handler", { + backgroundWorkerId: payload.backgroundWorkerId, + }); + return; + } + + await handler.handleMessage(payload.data); + }, + }, + }); + + await handler.handleMessage(data); + } + + async #handleClose(ev: CloseEvent) { + for (const handler of this.backgroundWorkerHandlers.values()) { + await handler.stop(); + } + + this.backgroundWorkerHandlers.clear(); + + this.onClose.post(ev); + } + + async #handleError(ev: Event) { + logger.error("Websocket error", { ev }); + } +} + +class BackgroundWorkerHandler { + private _backgroundWorker: BackgroundWorker | undefined; + private _backgroundWorkerTasks: Array | undefined; + private _abortController: AbortController = new AbortController(); + private _deprecated: boolean = false; + + constructor( + public id: string, + public env: AuthenticatedEnvironment, + private sender: ZodMessageSender + ) {} + + async start() { + const backgroundWorker = await prisma.backgroundWorker.findUnique({ + where: { friendlyId: this.id, runtimeEnvironmentId: this.env.id }, + include: { + tasks: true, + }, + }); + + if (!backgroundWorker) { + logger.error("Failed to find background worker", { id: this.id }); + return; + } + + this._backgroundWorker = backgroundWorker; + this._backgroundWorkerTasks = backgroundWorker.tasks; + + logger.debug("Background worker ready", { backgroundWorker }); + + this.#startRunLoop().catch((err) => { + logger.error("Background worker runloop error", { err }); + }); + } + + async handleMessage(message: BackgroundWorkerClientMessages) { + switch (message.type) { + case "TASK_RUN_COMPLETED": { + await this.#handleTaskRunCompleted(message.completion); + + break; + } + } + } + + async stop() { + this._abortController.abort(); + } + + // This will cause the background worker to stop accepting new tasks + // it will still look for tasks locked to it + async deprecate() { + this._deprecated = true; + } + + async #handleTaskRunCompleted(completion: TaskRunExecutionResult) { + logger.debug("Task run completed", { taskRunCompletion: completion }); + + if (completion.ok) { + await prisma.taskRunAttempt.update({ + where: { friendlyId: completion.id }, + data: { + status: "COMPLETED", + completedAt: new Date(), + output: completion.output, + outputType: completion.outputType, + }, + }); + } else { + await prisma.taskRunAttempt.update({ + where: { friendlyId: completion.id }, + data: { + status: "FAILED", + completedAt: new Date(), + error: completion.error, + }, + }); + } + } + + // Every 1 second, we'll check for new tasks to run and send them to the client + // if the abort controller is aborted, we'll stop the runloop + async #startRunLoop() { + while (!this._abortController.signal.aborted) { + const { payloads, returnReservedTasksToPending } = await this.#reserveTaskRuns(); + + if (payloads.length > 0) { + logger.debug("Sending task run payloads to client", { payloads }); + + if (this._abortController.signal.aborted) { + // Return reserverd task runs to pending + await returnReservedTasksToPending(); + + return; + } + + this.sender.send("BACKGROUND_WORKER_MESSAGE", { + backgroundWorkerId: this.id, + data: { + type: "EXECUTE_RUNS", + payloads, + }, + }); + } + + await new Promise((resolve) => setTimeout(resolve, 1000)); + } + } + + async #reserveTaskRuns(): Promise<{ + payloads: Array; + returnReservedTasksToPending: () => Promise; + }> { + const allPayloads: Array = []; + const allReturnReservedTasksToPending: Array<() => Promise> = []; + + if (!this._backgroundWorkerTasks) { + return { payloads: allPayloads, returnReservedTasksToPending: async () => {} }; + } + + for (const task of this._backgroundWorkerTasks) { + const { payloads, returnReservedTasksToPending } = await this.#reserveTaskRunsForTask(task); + + allPayloads.push(...payloads); + allReturnReservedTasksToPending.push(returnReservedTasksToPending); + } + + const returnReservedTasksToPending = async () => { + await Promise.all(allReturnReservedTasksToPending); + }; + + return { payloads: allPayloads, returnReservedTasksToPending }; + } + + async #findTaskRunsForTask(task: BackgroundWorkerTask, tx: PrismaClientOrTransaction) { + if (this._deprecated) { + // Only find task runs that are locked to this worker + return tx.taskRun.findMany({ + where: { + taskIdentifier: task.slug, + lockedAt: { equals: null }, + runtimeEnvironmentId: task.runtimeEnvironmentId, + lockedToVersionId: this._backgroundWorker!.id, + }, + include: { + attempts: { + take: 1, + orderBy: { number: "desc" }, + }, + tags: true, + }, + orderBy: { createdAt: "asc" }, + take: 10, + }); + } + + return tx.taskRun.findMany({ + where: { + OR: [{ lockedToVersionId: null }, { lockedToVersionId: this._backgroundWorker!.id }], + AND: { + taskIdentifier: task.slug, + lockedAt: { equals: null }, + runtimeEnvironmentId: task.runtimeEnvironmentId, + }, + }, + include: { + attempts: { + take: 1, + orderBy: { number: "desc" }, + }, + tags: true, + }, + orderBy: { createdAt: "asc" }, + take: 10, + }); + } + + async #reserveTaskRunsForTask(task: BackgroundWorkerTask): Promise<{ + payloads: Array; + returnReservedTasksToPending: () => Promise; + }> { + return await prisma.$transaction(async (tx) => { + const taskRuns = await this.#findTaskRunsForTask(task, tx); + + await tx.taskRun.updateMany({ + where: { + id: { + in: taskRuns.map((taskRun) => taskRun.id), + }, + }, + data: { + lockedAt: new Date(), + lockedById: task.id, + }, + }); + + const attempts = taskRuns.map((taskRun) => { + const attemptFriendlyId = generateFriendlyId("attempt"); + + const create = { + number: taskRun.attempts[0] ? taskRun.attempts[0].number + 1 : 1, + friendlyId: attemptFriendlyId, + taskRunId: taskRun.id, + startedAt: new Date(), + backgroundWorkerId: task.workerId, + backgroundWorkerTaskId: task.id, + status: "EXECUTING" as const, + }; + + const execution = { + task: { + id: task.slug, + filePath: task.filePath, + exportName: task.exportName, + }, + attempt: { + id: attemptFriendlyId, + number: taskRun.attempts[0] ? taskRun.attempts[0].number + 1 : 1, + startedAt: new Date(), + backgroundWorkerId: this.id, + backgroundWorkerTaskId: task.id, + status: "EXECUTING" as const, + }, + run: { + id: taskRun.friendlyId, + payload: taskRun.payload, + payloadType: taskRun.payloadType, + context: taskRun.context, + createdAt: taskRun.createdAt, + tags: taskRun.tags.map((tag) => tag.name), + }, + environment: { + id: this.env.id, + slug: this.env.slug, + type: this.env.type, + }, + organization: { + id: this.env.organization.id, + slug: this.env.organization.slug, + name: this.env.organization.title, + }, + project: { + id: this.env.project.id, + ref: this.env.project.externalRef, + slug: this.env.project.slug, + name: this.env.project.name, + }, + }; + + return { create, execution, traceContext: taskRun.traceContext as Record }; + }); + + await tx.taskRunAttempt.createMany({ + data: attempts.map(({ create }) => create), + }); + + const returnReservedTasksToPending = async () => { + await prisma.taskRun.updateMany({ + where: { + id: { + in: attempts.map(({ create }) => create.taskRunId), + }, + }, + data: { + lockedAt: null, + lockedById: null, + }, + }); + + await prisma.taskRunAttempt.updateMany({ + where: { + friendlyId: { + in: attempts.map(({ create }) => create.friendlyId), + }, + }, + data: { + status: "FAILED", + completedAt: new Date(), + error: "Worker stopped", + }, + }); + }; + + return { + payloads: attempts.map(({ execution, traceContext }) => ({ execution, traceContext })), + returnReservedTasksToPending, + }; + }); + } +} diff --git a/apps/webapp/app/v3/otlpExporter.server.ts b/apps/webapp/app/v3/otlpExporter.server.ts new file mode 100644 index 000000000..ff85579d6 --- /dev/null +++ b/apps/webapp/app/v3/otlpExporter.server.ts @@ -0,0 +1,488 @@ +import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions"; +import { SemanticInternalAttributes } from "@trigger.dev/core/v3"; +import { + AnyValue, + ExportLogsServiceRequest, + ExportLogsServiceResponse, + ExportTraceServiceRequest, + ExportTraceServiceResponse, + KeyValue, + ResourceLogs, + ResourceSpans, + SeverityNumber, + Span, + Span_Event, + Span_Link, + Span_SpanKind, + Status_StatusCode, +} from "@trigger.dev/otlp-importer"; +import { + CreatableEventKind, + CreatableEventStatus, + EventRepository, + eventRepository, + type CreatableEvent, + CreatableEventEnvironmentType, +} from "./eventRepository.server"; + +export type OTLPExporterConfig = { + batchSize: number; + batchInterval: number; +}; + +class OTLPExporter { + constructor(private readonly _eventRepository: EventRepository) {} + + async exportTraces(request: ExportTraceServiceRequest): Promise { + const events = this.#filterResourceSpans(request.resourceSpans).flatMap((resourceSpan) => { + return convertSpansToCreateableEvents(resourceSpan); + }); + + this._eventRepository.insertMany(events); + + return ExportTraceServiceResponse.create(); + } + + async exportLogs(request: ExportLogsServiceRequest): Promise { + const events = this.#filterResourceLogs(request.resourceLogs).flatMap((resourceLog) => { + return convertLogsToCreateableEvents(resourceLog); + }); + + this._eventRepository.insertMany(events); + + return ExportLogsServiceResponse.create(); + } + + #filterResourceSpans( + resourceSpans: ExportTraceServiceRequest["resourceSpans"] + ): ExportTraceServiceRequest["resourceSpans"] { + return resourceSpans.filter((resourceSpan) => { + const triggerAttribute = resourceSpan.resource?.attributes.find( + (attribute) => attribute.key === SemanticInternalAttributes.TRIGGER + ); + + if (!triggerAttribute) return false; + + return isBoolValue(triggerAttribute.value) ? triggerAttribute.value.value.boolValue : false; + }); + } + + #filterResourceLogs( + resourceLogs: ExportLogsServiceRequest["resourceLogs"] + ): ExportLogsServiceRequest["resourceLogs"] { + return resourceLogs.filter((resourceLog) => { + const attribute = resourceLog.resource?.attributes.find( + (attribute) => attribute.key === SemanticInternalAttributes.TRIGGER + ); + + if (!attribute) return false; + + return isBoolValue(attribute.value) ? attribute.value.value.boolValue : false; + }); + } +} + +function convertLogsToCreateableEvents(resourceLog: ResourceLogs): Array { + const resourceAttributes = resourceLog.resource?.attributes ?? []; + + const resourceProperties = extractResourceProperties(resourceAttributes); + + return resourceLog.scopeLogs.flatMap((scopeLog) => { + return scopeLog.logRecords.map((log) => { + return { + traceId: binaryToHex(log.traceId), + spanId: eventRepository.generateSpanId(), + parentId: binaryToHex(log.spanId), + message: isStringValue(log.body) ? log.body.value.stringValue : `${log.severityText} log`, + isPartial: false, + kind: "INTERNAL", + level: logLevelToEventLevel(log.severityNumber), + status: logLevelToEventStatus(log.severityNumber), + startTime: convertUnixNanoToDate(log.timeUnixNano), + properties: { + ...convertKeyValueItemsToMap(log.attributes ?? [], [ + SemanticInternalAttributes.SPAN_ID, + SemanticInternalAttributes.SPAN_PARTIAL, + ]), + ...convertKeyValueItemsToMap( + resourceAttributes, + [SemanticInternalAttributes.TRIGGER], + SemanticInternalAttributes.METADATA + ), + }, + style: convertKeyValueItemsToMap( + pickAttributes(log.attributes ?? [], SemanticInternalAttributes.STYLE), + [] + ), + output: convertKeyValueItemsToMap( + pickAttributes(log.attributes ?? [], SemanticInternalAttributes.OUTPUT), + [] + ), + ...resourceProperties, + }; + }); + }); +} + +function convertSpansToCreateableEvents(resourceSpan: ResourceSpans): Array { + const resourceAttributes = resourceSpan.resource?.attributes ?? []; + + const resourceProperties = extractResourceProperties(resourceAttributes); + + return resourceSpan.scopeSpans.flatMap((scopeSpan) => { + return scopeSpan.spans.map((span) => { + const isPartial = isPartialSpan(span); + + return { + traceId: binaryToHex(span.traceId), + spanId: isPartial + ? extractStringAttribute( + span?.attributes ?? [], + SemanticInternalAttributes.SPAN_ID, + binaryToHex(span.spanId) + ) + : binaryToHex(span.spanId), + parentId: binaryToHex(span.parentSpanId), + message: span.name, + isPartial, + kind: spanKindToEventKind(span.kind), + level: "TRACE", + status: spanStatusToEventStatus(span.status), + startTime: convertUnixNanoToDate(span.startTimeUnixNano), + links: spanLinksToEventLinks(span.links ?? []), + events: spanEventsToEventEvents(span.events ?? []), + duration: span.endTimeUnixNano - span.startTimeUnixNano, + properties: { + ...convertKeyValueItemsToMap(span.attributes ?? [], [ + SemanticInternalAttributes.SPAN_ID, + SemanticInternalAttributes.SPAN_PARTIAL, + ]), + ...convertKeyValueItemsToMap( + resourceAttributes, + [SemanticInternalAttributes.TRIGGER], + SemanticInternalAttributes.METADATA + ), + }, + style: convertKeyValueItemsToMap( + pickAttributes(span.attributes ?? [], SemanticInternalAttributes.STYLE), + [] + ), + output: convertKeyValueItemsToMap( + pickAttributes(span.attributes ?? [], SemanticInternalAttributes.OUTPUT), + [] + ), + ...resourceProperties, + }; + }); + }); +} + +function extractResourceProperties(attributes: KeyValue[]) { + return { + metadata: convertKeyValueItemsToMap(attributes, [SemanticInternalAttributes.TRIGGER]), + serviceName: extractStringAttribute( + attributes, + SemanticResourceAttributes.SERVICE_NAME, + "unknown" + ), + serviceNamespace: extractStringAttribute( + attributes, + SemanticResourceAttributes.SERVICE_NAMESPACE, + "unknown" + ), + environmentId: extractStringAttribute( + attributes, + SemanticInternalAttributes.ENVIRONMENT_ID, + "unknown" + ), + environmentType: extractStringAttribute( + attributes, + SemanticInternalAttributes.ENVIRONMENT_TYPE, + "unknown" + ) as CreatableEventEnvironmentType, + organizationId: extractStringAttribute( + attributes, + SemanticInternalAttributes.ORGANIZATION_ID, + "unknown" + ), + projectId: extractStringAttribute(attributes, SemanticInternalAttributes.PROJECT_ID, "unknown"), + projectRef: extractStringAttribute( + attributes, + SemanticInternalAttributes.PROJECT_REF, + "unknown" + ), + runId: extractStringAttribute(attributes, SemanticInternalAttributes.RUN_ID, "unknown"), + attemptId: extractStringAttribute(attributes, SemanticInternalAttributes.ATTEMPT_ID), + taskSlug: extractStringAttribute(attributes, SemanticInternalAttributes.TASK_SLUG, "unknown"), + taskPath: extractStringAttribute(attributes, SemanticInternalAttributes.TASK_PATH), + taskExportName: extractStringAttribute(attributes, SemanticInternalAttributes.TASK_EXPORT_NAME), + workerId: extractStringAttribute(attributes, SemanticInternalAttributes.WORKER_ID), + workerVersion: extractStringAttribute(attributes, SemanticInternalAttributes.WORKER_VERSION), + }; +} + +function pickAttributes(attributes: KeyValue[], prefix: string): KeyValue[] { + return attributes + .filter((attribute) => attribute.key.startsWith(prefix)) + .map((attribute) => { + return { + key: attribute.key.replace(`${prefix}.`, ""), + value: attribute.value, + }; + }); +} + +function convertKeyValueItemsToMap( + attributes: KeyValue[], + filteredKeys: string[] = [], + prefix?: string +): Record { + return attributes.reduce( + (map: Record, attribute) => { + if (filteredKeys.includes(attribute.key)) return map; + + map[`${prefix ? `${prefix}.` : ""}${attribute.key}`] = isStringValue(attribute.value) + ? attribute.value.value.stringValue + : isIntValue(attribute.value) + ? Number(attribute.value.value.intValue) + : isDoubleValue(attribute.value) + ? attribute.value.value.doubleValue + : isBoolValue(attribute.value) + ? attribute.value.value.boolValue + : isBytesValue(attribute.value) + ? binaryToHex(attribute.value.value.bytesValue) + : undefined; + + return map; + }, + {} + ); +} + +function spanLinksToEventLinks(links: Span_Link[]): CreatableEvent["links"] { + return links.map((link) => { + return { + traceId: binaryToHex(link.traceId), + spanId: binaryToHex(link.spanId), + tracestate: link.traceState, + properties: convertKeyValueItemsToMap(link.attributes ?? []), + }; + }); +} + +function spanEventsToEventEvents(events: Span_Event[]): CreatableEvent["events"] { + return events.map((event) => { + return { + name: event.name, + time: convertUnixNanoToDate(event.timeUnixNano), + properties: convertKeyValueItemsToMap(event.attributes ?? []), + }; + }); +} + +function spanStatusToEventStatus(status: Span["status"]): CreatableEventStatus { + if (!status) return "UNSET"; + + switch (status.code) { + case Status_StatusCode.OK: { + return "OK"; + } + case Status_StatusCode.ERROR: { + return "ERROR"; + } + case Status_StatusCode.UNSET: { + return "UNSET"; + } + default: { + return "UNSET"; + } + } +} + +function spanKindToEventKind(kind: Span["kind"]): CreatableEventKind { + switch (kind) { + case Span_SpanKind.CLIENT: { + return "CLIENT"; + } + case Span_SpanKind.SERVER: { + return "SERVER"; + } + case Span_SpanKind.CONSUMER: { + return "CONSUMER"; + } + case Span_SpanKind.PRODUCER: { + return "PRODUCER"; + } + default: { + return "INTERNAL"; + } + } +} + +function logLevelToEventLevel(level: SeverityNumber): CreatableEvent["level"] { + switch (level) { + case SeverityNumber.TRACE: + case SeverityNumber.TRACE2: + case SeverityNumber.TRACE3: + case SeverityNumber.TRACE4: { + return "TRACE"; + } + case SeverityNumber.DEBUG: + case SeverityNumber.DEBUG2: + case SeverityNumber.DEBUG3: + case SeverityNumber.DEBUG4: { + return "DEBUG"; + } + case SeverityNumber.INFO: + case SeverityNumber.INFO2: + case SeverityNumber.INFO3: + case SeverityNumber.INFO4: { + return "INFO"; + } + case SeverityNumber.WARN: + case SeverityNumber.WARN2: + case SeverityNumber.WARN3: + case SeverityNumber.WARN4: { + return "WARN"; + } + case SeverityNumber.ERROR: + case SeverityNumber.ERROR2: + case SeverityNumber.ERROR3: + case SeverityNumber.ERROR4: { + return "ERROR"; + } + case SeverityNumber.FATAL: + case SeverityNumber.FATAL2: + case SeverityNumber.FATAL3: + case SeverityNumber.FATAL4: { + return "ERROR"; + } + default: { + return "INFO"; + } + } +} + +function logLevelToEventStatus(level: SeverityNumber): CreatableEventStatus { + switch (level) { + case SeverityNumber.TRACE: + case SeverityNumber.TRACE2: + case SeverityNumber.TRACE3: + case SeverityNumber.TRACE4: { + return "OK"; + } + case SeverityNumber.DEBUG: + case SeverityNumber.DEBUG2: + case SeverityNumber.DEBUG3: + case SeverityNumber.DEBUG4: { + return "OK"; + } + case SeverityNumber.INFO: + case SeverityNumber.INFO2: + case SeverityNumber.INFO3: + case SeverityNumber.INFO4: { + return "OK"; + } + case SeverityNumber.WARN: + case SeverityNumber.WARN2: + case SeverityNumber.WARN3: + case SeverityNumber.WARN4: { + return "OK"; + } + case SeverityNumber.ERROR: + case SeverityNumber.ERROR2: + case SeverityNumber.ERROR3: + case SeverityNumber.ERROR4: { + return "ERROR"; + } + case SeverityNumber.FATAL: + case SeverityNumber.FATAL2: + case SeverityNumber.FATAL3: + case SeverityNumber.FATAL4: { + return "ERROR"; + } + default: { + return "OK"; + } + } +} + +function convertUnixNanoToDate(unixNano: bigint): Date { + return new Date(Number(unixNano / BigInt(1_000_000))); +} + +function extractStringAttribute(attributes: KeyValue[], name: string): string | undefined; +function extractStringAttribute(attributes: KeyValue[], name: string, fallback: string): string; +function extractStringAttribute( + attributes: KeyValue[], + name: string, + fallback?: string +): string | undefined { + const attribute = attributes.find((attribute) => attribute.key === name); + + if (!attribute) return fallback; + + return isStringValue(attribute?.value) ? attribute.value.value.stringValue : fallback; +} + +function isPartialSpan(span: Span): boolean { + if (!span.attributes) return false; + + const attribute = span.attributes.find( + (attribute) => attribute.key === SemanticInternalAttributes.SPAN_PARTIAL + ); + + if (!attribute) return false; + + return isBoolValue(attribute.value) ? attribute.value.value.boolValue : false; +} + +function isBoolValue( + value: AnyValue | undefined +): value is { value: { $case: "boolValue"; boolValue: boolean } } { + if (!value) return false; + + return (value.value && value.value.$case === "boolValue")!!; +} + +function isStringValue( + value: AnyValue | undefined +): value is { value: { $case: "stringValue"; stringValue: string } } { + if (!value) return false; + + return (value.value && value.value.$case === "stringValue")!!; +} + +function isIntValue( + value: AnyValue | undefined +): value is { value: { $case: "intValue"; intValue: bigint } } { + if (!value) return false; + + return (value.value && value.value.$case === "intValue")!!; +} + +function isDoubleValue( + value: AnyValue | undefined +): value is { value: { $case: "doubleValue"; doubleValue: number } } { + if (!value) return false; + + return (value.value && value.value.$case === "doubleValue")!!; +} + +function isBytesValue( + value: AnyValue | undefined +): value is { value: { $case: "bytesValue"; bytesValue: Buffer } } { + if (!value) return false; + + return (value.value && value.value.$case === "bytesValue")!!; +} + +function binaryToHex(buffer: Buffer): string; +function binaryToHex(buffer: Buffer | undefined): string | undefined; +function binaryToHex(buffer: Buffer | undefined): string | undefined { + if (!buffer) return undefined; + + return Buffer.from(Array.from(buffer)).toString("hex"); +} + +export const otlpExporter = new OTLPExporter(eventRepository); diff --git a/apps/webapp/app/v3/services/createBackgroundWorker.server.ts b/apps/webapp/app/v3/services/createBackgroundWorker.server.ts new file mode 100644 index 000000000..99378d70b --- /dev/null +++ b/apps/webapp/app/v3/services/createBackgroundWorker.server.ts @@ -0,0 +1,106 @@ +import { CreateBackgroundWorkerRequestBody } from "@trigger.dev/core/v3"; +import type { BackgroundWorker } from "@trigger.dev/database"; +import { PrismaClient, prisma } from "~/db.server"; +import { AuthenticatedEnvironment } from "~/services/apiAuth.server"; +import { logger } from "~/services/logger.server"; +import { generateFriendlyId } from "../friendlyIdentifiers"; + +export class CreateBackgroundWorkerService { + #prismaClient: PrismaClient; + + constructor(prismaClient: PrismaClient = prisma) { + this.#prismaClient = prismaClient; + } + + public async call( + projectRef: string, + environment: AuthenticatedEnvironment, + body: CreateBackgroundWorkerRequestBody + ): Promise { + const project = await this.#prismaClient.project.findUniqueOrThrow({ + where: { + externalRef: projectRef, + environments: { + some: { + id: environment.id, + }, + }, + }, + include: { + backgroundWorkers: { + where: { + runtimeEnvironmentId: environment.id, + }, + orderBy: { + createdAt: "desc", + }, + take: 1, + }, + }, + }); + + const latestBackgroundWorker = project.backgroundWorkers[0]; + + if (latestBackgroundWorker?.contentHash === body.metadata.contentHash) { + return latestBackgroundWorker; + } + + const nextVersion = calculateNextBuildVersion(project.backgroundWorkers[0]?.version); + + logger.debug(`Creating background worker`, { + nextVersion, + lastVersion: project.backgroundWorkers[0]?.version, + }); + + const backgroundWorker = await this.#prismaClient.backgroundWorker.create({ + data: { + friendlyId: generateFriendlyId("worker"), + version: nextVersion, + runtimeEnvironmentId: environment.id, + projectId: project.id, + metadata: body.metadata, + contentHash: body.metadata.contentHash, + }, + }); + + for (const task of body.metadata.tasks) { + await this.#prismaClient.backgroundWorkerTask.create({ + data: { + friendlyId: generateFriendlyId("task"), + projectId: project.id, + runtimeEnvironmentId: environment.id, + workerId: backgroundWorker.id, + slug: task.id, + filePath: task.filePath, + exportName: task.exportName, + }, + }); + } + + return backgroundWorker; + } +} + +// Calculate next build version based on the previous version +// Version formats are YYYYMMDD.1, YYYYMMDD.2, etc. +// If there is no previous version, start at Todays date and .1 +function calculateNextBuildVersion(latestVersion?: string | null): string { + const today = new Date(); + const year = today.getFullYear(); + const month = today.getMonth() + 1; + const day = today.getDate(); + const todayFormatted = `${year}${month < 10 ? "0" : ""}${month}${day < 10 ? "0" : ""}${day}`; + + if (!latestVersion) { + return `${todayFormatted}.1`; + } + + const [date, buildNumber] = latestVersion.split("."); + + if (date === todayFormatted) { + const nextBuildNumber = parseInt(buildNumber, 10) + 1; + return `${date}.${nextBuildNumber}`; + } + + return `${todayFormatted}.1`; +} diff --git a/apps/webapp/app/v3/services/triggerTask.server.ts b/apps/webapp/app/v3/services/triggerTask.server.ts new file mode 100644 index 000000000..481a0621b --- /dev/null +++ b/apps/webapp/app/v3/services/triggerTask.server.ts @@ -0,0 +1,94 @@ +import { SemanticInternalAttributes, TriggerTaskRequestBody } from "@trigger.dev/core/v3"; +import { flattenAttributes } from "@trigger.dev/core/v3"; +import { nanoid } from "nanoid"; +import { PrismaClient, prisma } from "~/db.server"; +import { AuthenticatedEnvironment } from "~/services/apiAuth.server"; +import { eventRepository } from "../eventRepository.server"; +import { generateFriendlyId } from "../friendlyIdentifiers"; + +export type TriggerTaskServiceOptions = { + idempotencyKey?: string; + triggerVersion?: string; + traceContext?: Record; +}; + +export class TriggerTaskService { + #prismaClient: PrismaClient; + + constructor(prismaClient: PrismaClient = prisma) { + this.#prismaClient = prismaClient; + } + + public async call( + taskId: string, + environment: AuthenticatedEnvironment, + body: TriggerTaskRequestBody, + options: TriggerTaskServiceOptions = {} + ) { + const idempotencyKey = options.idempotencyKey ?? nanoid(); + + const existingRun = await this.#prismaClient.taskRun.findUnique({ + where: { + runtimeEnvironmentId_idempotencyKey: { + runtimeEnvironmentId: environment.id, + idempotencyKey, + }, + }, + }); + + if (existingRun) { + return existingRun; + } + + return await eventRepository.traceEvent( + `Triggering task ${taskId}`, + { + context: options.traceContext, + kind: "SERVER", + environment, + taskSlug: taskId, + attributes: { + metadata: { + ...flattenAttributes(body.payload, SemanticInternalAttributes.PAYLOAD), + }, + style: { + icon: "play", + }, + }, + }, + async (event, traceContext) => { + const parentAttempt = body.options?.parentAttempt + ? await this.#prismaClient.taskRunAttempt.findUnique({ + where: { + friendlyId: body.options.parentAttempt, + }, + }) + : undefined; + + const taskRun = await this.#prismaClient.taskRun.create({ + data: { + friendlyId: generateFriendlyId("run"), + runtimeEnvironmentId: environment.id, + projectId: environment.projectId, + idempotencyKey, + taskIdentifier: taskId, + payload: JSON.stringify(body.payload), + payloadType: "application/json", + context: body.context, + traceContext: traceContext, + traceId: event.traceId, + spanId: event.spanId, + parentAttemptId: parentAttempt?.id, + lockedToVersionId: body.options?.lockToCurrentVersion + ? parentAttempt?.backgroundWorkerId + : undefined, + }, + }); + + event.setAttribute("runId", taskRun.friendlyId); + + return taskRun; + } + ); + } +} diff --git a/apps/webapp/app/v3/tracing.server.ts b/apps/webapp/app/v3/tracing.server.ts new file mode 100644 index 000000000..7c32ff2d7 --- /dev/null +++ b/apps/webapp/app/v3/tracing.server.ts @@ -0,0 +1,42 @@ +import api, { DiagConsoleLogger, DiagLogLevel } from "@opentelemetry/api"; +import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http"; +import { Resource } from "@opentelemetry/resources"; +import { ConsoleSpanExporter } from "@opentelemetry/sdk-trace-base"; +import { NodeTracerProvider, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-node"; +import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions"; +import { + LoggerProvider, + SimpleLogRecordProcessor, + ConsoleLogRecordExporter, +} from "@opentelemetry/sdk-logs"; +import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http"; + +api.diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.ALL); + +const provider = new NodeTracerProvider({ + forceFlushTimeoutMillis: 500, + resource: new Resource({ + [SemanticResourceAttributes.SERVICE_NAME]: "trigger.dev", + }), +}); + +const exporter = new OTLPTraceExporter({ + url: "http://0.0.0.0:4318/v1/traces", + timeoutMillis: 1000, +}); + +provider.addSpanProcessor(new SimpleSpanProcessor(exporter)); +provider.register(); + +const logExporter = new OTLPLogExporter({ + url: "http://0.0.0.0:4318/v1/logs", +}); + +// To start a logger, you first need to initialize the Logger provider. +const loggerProvider = new LoggerProvider(); +// Add a processor to export log record +loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(logExporter)); + +// To create a log record, you first need to get a Logger instance +export const logger = loggerProvider.getLogger("default"); +export const tracer = provider.getTracer("trigger.dev", "3.0.0.dp.1"); diff --git a/apps/webapp/package.json b/apps/webapp/package.json index 4864aa924..a677fdd08 100644 --- a/apps/webapp/package.json +++ b/apps/webapp/package.json @@ -8,8 +8,7 @@ "build:db:seed": "esbuild --platform=node --bundle --minify --format=cjs ./prisma/seed.ts --outdir=prisma", "build:remix": "remix build", "build:server": "esbuild --platform=node --format=cjs ./server.ts --outdir=build", - "dev": "cross-env PORT=3030 remix dev", - "dev:manual": "cross-env PORT=3030 remix dev -c \"node ./build/server.js\"", + "dev": "cross-env PORT=3030 remix dev -c \"node ./build/server.js\"", "format": "prettier --write .", "lint": "eslint --cache --cache-location ./node_modules/.cache/eslint .", "start": "cross-env NODE_ENV=production node --max-old-space-size=8192 ./build/server.js", @@ -48,6 +47,15 @@ "@highlight-run/react": "^3.2.0", "@internationalized/date": "^3.5.1", "@lezer/highlight": "^1.1.6", + "@opentelemetry/api": "^1.7.0", + "@opentelemetry/core": "^1.21.0", + "@opentelemetry/exporter-logs-otlp-http": "^0.48.0", + "@opentelemetry/exporter-trace-otlp-http": "^0.48.0", + "@opentelemetry/resources": "^1.21.0", + "@opentelemetry/sdk-logs": "^0.48.0", + "@opentelemetry/sdk-trace-base": "^1.21.0", + "@opentelemetry/sdk-trace-node": "^1.21.0", + "@opentelemetry/semantic-conventions": "^1.21.0", "@radix-ui/react-alert-dialog": "^1.0.4", "@radix-ui/react-dialog": "^1.0.3", "@radix-ui/react-label": "^2.0.1", @@ -75,6 +83,7 @@ "@trigger.dev/core": "workspace:*", "@trigger.dev/core-backend": "workspace:*", "@trigger.dev/database": "workspace:*", + "@trigger.dev/otlp-importer": "workspace:*", "@trigger.dev/sdk": "workspace:*", "@trigger.dev/yalt": "workspace:*", "@types/pg": "8.6.6", @@ -87,6 +96,7 @@ "cross-env": "^7.0.3", "cuid": "^2.1.8", "emails": "workspace:*", + "evt": "^2.4.13", "express": "^4.18.1", "framer-motion": "^10.12.11", "graphile-worker": "^0.13.0", @@ -131,6 +141,8 @@ "tailwindcss-animate": "^1.0.5", "tiny-invariant": "^1.2.0", "ulid": "^2.3.0", + "ulidx": "^2.2.1", + "ws": "^8.11.0", "zod": "3.22.3", "zod-error": "1.5.0", "zod-validation-error": "^1.5.0" @@ -175,6 +187,7 @@ "@types/simple-oauth2": "^5.0.4", "@types/slug": "^5.0.3", "@types/tar": "^6.1.4", + "@types/ws": "^8.5.3", "@typescript-eslint/eslint-plugin": "^5.59.6", "@typescript-eslint/parser": "^5.59.6", "autoprefixer": "^10.4.13", diff --git a/apps/webapp/prisma/seedCloud.ts b/apps/webapp/prisma/seedCloud.ts index 6cf134b34..f242a644d 100644 --- a/apps/webapp/prisma/seedCloud.ts +++ b/apps/webapp/prisma/seedCloud.ts @@ -40,6 +40,7 @@ export async function seedCloud(prisma: PrismaClient) { create: { name: "My Project", slug: "my-project-123", + externalRef: "my-project-123", }, }, }, diff --git a/apps/webapp/server.ts b/apps/webapp/server.ts index ba9b82a6d..c1693d9c8 100644 --- a/apps/webapp/server.ts +++ b/apps/webapp/server.ts @@ -3,6 +3,8 @@ import express from "express"; import compression from "compression"; import morgan from "morgan"; import { createRequestHandler } from "@remix-run/express"; +import { WebSocketServer } from "ws"; +import { broadcastDevReady, logDevReady } from "@remix-run/server-runtime"; const app = express(); @@ -38,28 +40,29 @@ app.use(morgan("tiny")); const MODE = process.env.NODE_ENV; const BUILD_DIR = path.join(process.cwd(), "build"); +const build = require(BUILD_DIR); app.all( "*", - MODE === "production" - ? createRequestHandler({ build: require(BUILD_DIR) }) - : (...args) => { - purgeRequireCache(); - const requestHandler = createRequestHandler({ - build: require(BUILD_DIR), - mode: MODE, - }); - return requestHandler(...args); - } + createRequestHandler({ + build, + mode: MODE, + }) ); const port = process.env.REMIX_APP_PORT || process.env.PORT || 3000; if (process.env.HTTP_SERVER_DISABLED !== "true") { + const wss: WebSocketServer | undefined = build.entry.module.wss; + const server = app.listen(port, () => { - // require the built app so we're ready when the first request comes in - require(BUILD_DIR); - console.log(`✅ app ready: http://localhost:${port}`); + console.log(`✅ app ready: http://localhost:${port} [NODE_ENV: ${MODE}]`); + + if (MODE === "development") { + broadcastDevReady(build) + .then(() => logDevReady(build)) + .catch(console.error); + } }); server.keepAliveTimeout = 65 * 1000; @@ -73,21 +76,34 @@ if (process.env.HTTP_SERVER_DISABLED !== "true") { } }); }); + + server.on("upgrade", async (req, socket, head) => { + console.log( + `Attemping to upgrade connection at url ${req.url} with headers: ${JSON.stringify( + req.headers + )}` + ); + + const url = new URL(req.url ?? "", "http://localhost"); + + // Only upgrade the connecting if the path is `/ws` + if (url.pathname !== "/ws") { + socket.destroy( + new Error( + "Cannot connect because of invalid path: Please include `/ws` in the path of your upgrade request." + ) + ); + return; + } + + console.log(`Client connected, upgrading their connection...`); + + // Handle the WebSocket connection + wss?.handleUpgrade(req, socket, head, (ws) => { + wss?.emit("connection", ws, req); + }); + }); } else { require(BUILD_DIR); console.log(`✅ app ready (skipping http server)`); } - -function purgeRequireCache() { - // purge require cache on requests for "server side HMR" this won't let - // you have in-memory objects between requests in development, - // alternatively you can set up nodemon/pm2-dev to restart the server on - // file changes, we prefer the DX of this though, so we've included it - // for you by default - for (const key in require.cache) { - if (key.startsWith(BUILD_DIR)) { - // eslint-disable-next-line @typescript-eslint/no-dynamic-delete - delete require.cache[key]; - } - } -} diff --git a/apps/webapp/tsconfig.json b/apps/webapp/tsconfig.json index de26bf4b1..9556b5fbc 100644 --- a/apps/webapp/tsconfig.json +++ b/apps/webapp/tsconfig.json @@ -29,6 +29,8 @@ "@trigger.dev/database/*": ["../../packages/database/src/*"], "@trigger.dev/yalt": ["../../packages/yalt/src/index"], "@trigger.dev/yalt/*": ["../../packages/yalt/src/*"], + "@trigger.dev/otlp-importer": ["../../packages/otlp-importer/src/index"], + "@trigger.dev/otlp-importer/*": ["../../packages/otlp-importer/src/*"], "emails": ["../../packages/emails/src/index"], "emails/*": ["../../packages/emails/src/*"] }, diff --git a/config-packages/tsup/package.json b/config-packages/tsup/package.json index fca78c6a8..a54939e7f 100644 --- a/config-packages/tsup/package.json +++ b/config-packages/tsup/package.json @@ -6,7 +6,7 @@ "main": "./src/index.ts", "types": "./src/index.ts", "dependencies": { - "esbuild": "^0.19.2", + "esbuild": "^0.19.11", "tsup": "^8.0.1" }, "devDependencies": { diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml index 7c6f6cc58..4c53b0c13 100644 --- a/docker/docker-compose.yml +++ b/docker/docker-compose.yml @@ -54,9 +54,13 @@ services: ports: - 6379:6379 - redisinsight: - image: redislabs/redisinsight:latest - ports: - - "8001:8001" + otel-collector: + image: otel/opentelemetry-collector-contrib:latest + command: ["--config", "/etc/otel-collector-config.yaml"] volumes: - - redis-data:/redisinsight + - ./otel-collector-config.yaml:/etc/otel-collector-config.yaml + ports: + - "55680:55680" + - "55681:55681" + - "4317:4317" # OTLP gRPC receiver + - "4318:4318" # OTLP http receiver diff --git a/docker/otel-collector-config.yaml b/docker/otel-collector-config.yaml new file mode 100644 index 000000000..98d32016f --- /dev/null +++ b/docker/otel-collector-config.yaml @@ -0,0 +1,32 @@ +receivers: + otlp: + protocols: + grpc: + endpoint: 0.0.0.0:4317 + http: + endpoint: 0.0.0.0:4318 + +processors: + batch: + +exporters: + otlp: + endpoint: "api.honeycomb.io:443" + headers: + "x-honeycomb-team": "7e999faWC62210wKXMAHNM" + logging: + verbosity: normal + otlphttp: + endpoint: "http://host.docker.internal:3030/otel" + compression: none + +service: + pipelines: + traces: + receivers: [otlp] + processors: [batch] + exporters: [otlp, otlphttp] + logs: + receivers: [otlp] + processors: [batch] + exporters: [otlp, otlphttp] diff --git a/package.json b/package.json index e09024e78..23e540dda 100644 --- a/package.json +++ b/package.json @@ -19,7 +19,7 @@ "format": "prettier . --write --config prettier.config.js", "generate": "turbo run generate", "lint": "turbo run lint", - "docker": "docker-compose -p triggerdotdev-docker -f docker/docker-compose.yml up -d", + "docker": "docker-compose -p triggerdotdev-docker -f docker/docker-compose.yml up -d --build --remove-orphans", "docker:stop": "docker-compose -p triggerdotdev-docker -f docker/docker-compose.yml stop", "dev:docker": "docker-compose -p triggerdotdev-dev-docker -f docker/dev-compose.yml up -d", "dev:docker:build": "docker-compose -p triggerdotdev-dev-docker -f docker/dev-compose.yml up -d --build", diff --git a/packages/cli-v3/package.json b/packages/cli-v3/package.json index 0ce0cf5cb..01e621726 100644 --- a/packages/cli-v3/package.json +++ b/packages/cli-v3/package.json @@ -32,35 +32,56 @@ "type": "module", "exports": "./dist/index.js", "bin": { - "trigger-v3-cli": "./dist/index.js" + "trigger.dev": "./dist/index.js" }, "devDependencies": { "@trigger.dev/core": "workspace:*", "@trigger.dev/tsconfig": "workspace:*", "@types/gradient-string": "^1.1.2", "@types/mock-fs": "^4.13.1", - "@types/node": "16", - "@types/node-fetch": "^2.6.2", + "@types/node": "18", + "@types/object-hash": "^3.0.6", + "@types/react": "^18.2.48", "@types/ws": "^8.5.3", + "npm-run-all": "^4.1.5", "open": "^10.0.3", "p-retry": "^6.1.0", "rimraf": "^3.0.2", - "tsup": "^6.5.0", + "tsup": "^8.0.1", "type-fest": "^3.6.0", - "typescript": "^4.9.5", + "typescript": "^5.3.3", "vitest": "^0.34.4", "xdg-app-paths": "^8.3.0" }, "scripts": { "typecheck": "tsc", - "build": "tsup", - "dev": "tsup --watch", + "build": "npm run clean && run-p build:**", + "build:main": "tsup", + "build:facade": "tsup --config tsup.facade.config.ts", + "dev": "npm run clean && run-p dev:**", + "dev:main": "tsup --watch", + "dev:facade": "tsup --config tsup.facade.config.ts --watch", "clean": "rimraf dist", "start": "node dist/index.js", "test": "vitest" }, "dependencies": { "@clack/prompts": "^0.7.0", + "@opentelemetry/api": "^1.7.0", + "@opentelemetry/api-logs": "^0.48.0", + "@opentelemetry/auto-instrumentations-node": "^0.40.3", + "@opentelemetry/exporter-collector": "^0.25.0", + "@opentelemetry/exporter-logs-otlp-http": "^0.48.0", + "@opentelemetry/exporter-trace-otlp-http": "^0.48.0", + "@opentelemetry/instrumentation": "^0.48.0", + "@opentelemetry/instrumentation-fetch": "^0.48.0", + "@opentelemetry/instrumentation-http": "^0.48.0", + "@opentelemetry/resources": "^1.21.0", + "@opentelemetry/sdk-logs": "^0.48.0", + "@opentelemetry/sdk-node": "^0.48.0", + "@opentelemetry/sdk-trace-base": "^1.21.0", + "@opentelemetry/sdk-trace-node": "^1.21.0", + "@opentelemetry/semantic-conventions": "^1.21.0", "@trigger.dev/core": "workspace:*", "@types/degit": "^2.8.3", "chalk": "^5.2.0", @@ -69,22 +90,35 @@ "commander": "^9.4.1", "degit": "^2.8.4", "dotenv": "^16.3.1", + "esbuild": "^0.19.11", + "evt": "^2.4.13", "execa": "^7.0.0", + "find-up": "^7.0.0", "gradient-string": "^2.0.2", + "import-meta-resolve": "^4.0.0", + "ink": "^4.4.1", "liquidjs": "^10.9.2", "mock-fs": "^5.2.0", "nanoid": "^4.0.2", "node-fetch": "^3.3.0", "npm-check-updates": "^16.12.2", + "object-hash": "^3.0.0", + "p-throttle": "^6.1.0", + "partysocket": "^0.0.17", "posthog-node": "^3.1.1", "proxy-agent": "^6.3.0", + "react": "^18.2.0", + "react-error-boundary": "^4.0.12", "simple-git": "^3.19.0", + "source-map": "^0.7.4", + "supports-color": "^9.4.0", + "terminal-link": "^3.0.0", "update-check": "^1.5.4", "url": "^0.11.1", - "ws": "^8.11.0", + "ws": "^8.12.0", "zod": "3.22.3" }, "engines": { "node": ">=18.0.0" } -} +} \ No newline at end of file diff --git a/packages/cli-v3/src/apiClient.ts b/packages/cli-v3/src/apiClient.ts index 88b2599a7..2dfbdbd82 100644 --- a/packages/cli-v3/src/apiClient.ts +++ b/packages/cli-v3/src/apiClient.ts @@ -2,13 +2,17 @@ import { z } from "zod"; import { CreateAuthorizationCodeResponseSchema, GetPersonalAccessTokenResponseSchema, + GetProjectDevResponse, + CreateBackgroundWorkerRequestBody, WhoAmIResponseSchema, -} from "@trigger.dev/core"; + CreateBackgroundWorkerResponse, +} from "@trigger.dev/core/v3"; export class ApiClient { - constructor(private readonly apiURL: string) { - this.apiURL = apiURL; - } + constructor( + private readonly apiURL: string, + private readonly accessToken?: string + ) {} async createAuthorizationCode() { return zodfetch( @@ -29,10 +33,46 @@ export class ApiClient { }); } - async whoAmI({ accessToken }: { accessToken: string }) { + async whoAmI() { + if (!this.accessToken) { + throw new Error("whoAmI: No access token"); + } + return zodfetch(WhoAmIResponseSchema, `${this.apiURL}/api/v2/whoami`, { headers: { - Authorization: `Bearer ${accessToken}`, + Authorization: `Bearer ${this.accessToken}`, + "Content-Type": "application/json", + }, + }); + } + + async createBackgroundWorker(projectRef: string, body: CreateBackgroundWorkerRequestBody) { + if (!this.accessToken) { + throw new Error("indexProject: No access token"); + } + + return zodfetch( + CreateBackgroundWorkerResponse, + `${this.apiURL}/api/v1/projects/${projectRef}/background-workers`, + { + method: "POST", + headers: { + Authorization: `Bearer ${this.accessToken}`, + "Content-Type": "application/json", + }, + body: JSON.stringify(body), + } + ); + } + + async getProjectDevEnv({ projectRef }: { projectRef: string }) { + if (!this.accessToken) { + throw new Error("getProjectDevEnv: No access token"); + } + + return zodfetch(GetProjectDevResponse, `${this.apiURL}/api/v1/projects/${projectRef}/dev`, { + headers: { + Authorization: `Bearer ${this.accessToken}`, "Content-Type": "application/json", }, }); diff --git a/packages/cli-v3/src/cli/common.ts b/packages/cli-v3/src/cli/common.ts new file mode 100644 index 000000000..d11f03ee3 --- /dev/null +++ b/packages/cli-v3/src/cli/common.ts @@ -0,0 +1,7 @@ +import { z } from "zod"; + +export const CommonCommandOptions = z.object({ + logLevel: z.enum(["debug", "info", "log", "warn", "error", "none"]).default("log"), +}); + +export type CommonCommandOptions = z.infer; diff --git a/packages/cli-v3/src/cli/index.ts b/packages/cli-v3/src/cli/index.ts index b0a0c8cfd..92449e0d8 100644 --- a/packages/cli-v3/src/cli/index.ts +++ b/packages/cli-v3/src/cli/index.ts @@ -1,12 +1,13 @@ import { Command } from "commander"; -import { devCommand } from "../commands/dev"; -import { updateCommand } from "../commands/update"; -import { whoamiCommand } from "../commands/whoami.js"; -import { COMMAND_NAME } from "../consts"; -import { getVersion } from "../utilities/getVersion"; -import { printInitialBanner } from "../utilities/initialBanner"; -import { login, loginCommand } from "../commands/login"; import { z } from "zod"; +import { configureDevCommand } from "../commands/dev.js"; +import { loginCommand } from "../commands/login.js"; +import { logoutCommand } from "../commands/logout.js"; +import { updateCommand } from "../commands/update.js"; +import { configureWhoamiCommand } from "../commands/whoami.js"; +import { COMMAND_NAME } from "../consts.js"; +import { getVersion } from "../utilities/getVersion.js"; +import { printInitialBanner } from "../utilities/initialBanner.js"; export const program = new Command(); @@ -39,30 +40,23 @@ program } }); -//todo update for the new version -//todo add usage instructions to the README program - .command("dev") - .description("Run your Trigger.dev tasks locally") - .argument("[path]", "The path to the project", ".") - .option("-p, --port ", "Override the local port your server is on") - .option("-H, --hostname ", "Override the hostname on which the application is served") - .option("-e, --env-file ", "Override the name of the env file to load") - .option( - "-i, --client-id ", - "The ID of the client to use for this project. Will use the value from the package.json file if not provided." - ) + .command("logout") + .description("Logout of Trigger.dev") .version(getVersion(), "-v, --version", "Display the version number") - .action(async (path, options) => { + .action(async (options) => { try { - await printInitialBanner(); - await devCommand(path, options); + await printInitialBanner(false); + await logoutCommand(options); + //todo login command } catch (e) { //todo error reporting throw e; } }); +configureDevCommand(program); + program .command("update") .description( @@ -75,20 +69,4 @@ program await updateCommand(path, options); }); -program - .command("whoami") - .description("display the current logged in user and project details") - .option( - "-a, --api-url ", - "Override the API URL, defaults to https://cloud.trigger.dev", - "https://cloud.trigger.dev" - ) - .version(getVersion(), "-v, --version", "Display the version number") - .action(async (options) => { - try { - await printInitialBanner(); - await whoamiCommand(options); - } catch (e) { - throw e; - } - }); +configureWhoamiCommand(program); diff --git a/packages/cli-v3/src/commands/dev.ts b/packages/cli-v3/src/commands/dev.ts deleted file mode 100644 index 3c10ab1d0..000000000 --- a/packages/cli-v3/src/commands/dev.ts +++ /dev/null @@ -1,39 +0,0 @@ -import childProcess from "child_process"; -import util from "util"; -import { z } from "zod"; -import { telemetryClient } from "../telemetry/telemetry"; -import { logger } from "../utilities/logger"; -import { resolvePath } from "../utilities/parseNameAndPath"; -import { RequireKeys } from "../utilities/requiredKeys"; - -const asyncExecFile = util.promisify(childProcess.execFile); - -export const DevCommandOptionsSchema = z.object({ - port: z.coerce.number().optional(), - hostname: z.string().optional(), - envFile: z.string().optional(), - clientId: z.string().optional(), -}); - -export type DevCommandOptions = z.infer; -type ResolvedOptions = RequireKeys; - -const formattedDate = new Intl.DateTimeFormat("en", { - hour: "numeric", - minute: "numeric", - second: "numeric", -}); - -export async function devCommand(path: string, anyOptions: any) { - telemetryClient.dev.started(path, anyOptions); - - const result = DevCommandOptionsSchema.safeParse(anyOptions); - if (!result.success) { - logger.error(result.error.message); - - return; - } - const options = result.data; - - const resolvedPath = resolvePath(path); -} diff --git a/packages/cli-v3/src/commands/dev.tsx b/packages/cli-v3/src/commands/dev.tsx new file mode 100644 index 000000000..4519feb5e --- /dev/null +++ b/packages/cli-v3/src/commands/dev.tsx @@ -0,0 +1,692 @@ +import { + CreateBackgroundWorkerRequestBody, + TaskResource, + ZodMessageHandler, + ZodMessageSender, + clientWebsocketMessages, + serverWebsocketMessages, +} from "@trigger.dev/core/v3"; +import chalk from "chalk"; +import { watch } from "chokidar"; +import { Command } from "commander"; +import { BuildContext, context } from "esbuild"; +import { findUp } from "find-up"; +import { resolve as importResolve } from "import-meta-resolve"; +import { Box, Text, render, useApp, useInput } from "ink"; +import { createHash } from "node:crypto"; +import fs, { readFileSync } from "node:fs"; +import { ClientRequestArgs } from "node:http"; +import { basename, dirname, join, relative, resolve } from "node:path"; +import { pathToFileURL } from "node:url"; +import pThrottle from "p-throttle"; +import { WebSocket } from "partysocket"; +import React, { Suspense, useEffect } from "react"; +import { ClientOptions, WebSocket as wsWebSocket } from "ws"; +import { z } from "zod"; +import * as packageJson from "../../package.json"; +import { ApiClient } from "../apiClient.js"; +import { CLOUD_API_URL } from "../consts.js"; +import { BackgroundWorker, BackgroundWorkerCoordinator } from "../dev/backgroundWorker.js"; +import { printStandloneInitialBanner } from "../utilities/initialBanner.js"; +import { logger } from "../utilities/logger.js"; +import { RequireKeys } from "../utilities/requiredKeys.js"; +import { isLoggedIn } from "../utilities/session.js"; +import { CommonCommandOptions } from "../cli/common.js"; + +const CONFIG_FILES = ["trigger.config.js", "trigger.config.mjs"]; + +const ConfigSchema = z.object({ + project: z.string(), + triggerDirectories: z.string().array().optional(), + triggerUrl: z.string().optional(), + projectDir: z.string().optional(), +}); + +type Config = z.infer; +type ResolvedConfig = RequireKeys; +type TaskFile = { + triggerDir: string; + filePath: string; + importPath: string; + importName: string; +}; + +let apiClient: ApiClient | undefined; + +const DevCommandOptions = CommonCommandOptions; + +type DevCommandOptions = z.infer; + +export function configureDevCommand(program: Command) { + program + .command("dev") + .description("Run your Trigger.dev tasks locally") + .argument("[path]", "The path to the project", ".") + .option( + "-l, --log-level ", + "The log level to use (debug, info, log, warn, error, none)", + "log" + ) + .action(async (path, options) => { + try { + await devCommand(path, options); + } catch (e) { + //todo error reporting + throw e; + } + }); +} + +export async function devCommand(dir: string, anyOptions: unknown) { + const options = DevCommandOptions.safeParse(anyOptions); + + if (!options.success) { + throw new Error(`Invalid options: ${options.error}`); + } + + const authorization = await isLoggedIn(); + + if (!authorization.ok) { + logger.error("You must login first. Use `trigger.dev login` to login."); + process.exitCode = 1; + return; + } + + let watcher; + + try { + const devInstance = await startDev(dir, options.data, authorization.config); + watcher = devInstance.watcher; + const { waitUntilExit } = devInstance.devReactElement; + await waitUntilExit(); + } finally { + await watcher?.close(); + } +} + +async function startDev( + dir: string, + options: DevCommandOptions, + authorization: { apiUrl: string; accessToken: string } +) { + let watcher: ReturnType | undefined; + let rerender: (node: React.ReactNode) => void | undefined; + + try { + if (options.logLevel) { + logger.loggerLevel = options.logLevel; + } + + await printStandloneInitialBanner(true); + + const configPath = await getConfigPath(dir); + let config = await readConfig(configPath); + + watcher = watch(configPath, { + persistent: true, + }).on("change", async (_event) => { + config = await readConfig(configPath); + logger.log(`${basename(configPath)} changed...`); + logger.debug("New config", { config }); + rerender(await getDevReactElement(config, authorization)); + }); + + async function getDevReactElement( + configParam: ResolvedConfig, + authorization: { apiUrl: string; accessToken: string } + ) { + const accessToken = authorization.accessToken; + const apiUrl = authorization.apiUrl; + + apiClient = new ApiClient(apiUrl, accessToken); + + const devEnv = await apiClient.getProjectDevEnv({ projectRef: config.project }); + + if (!devEnv.success) { + throw new Error(devEnv.error); + } + + const environmentClient = new ApiClient(apiUrl, devEnv.data.apiKey); + + return ( + + ); + } + + const devReactElement = render(await getDevReactElement(config, authorization)); + + rerender = devReactElement.rerender; + + return { + devReactElement, + watcher, + stop: async () => { + devReactElement.unmount(); + await watcher?.close(); + }, + }; + } catch (e) { + await watcher?.close(); + throw e; + } +} + +type DevProps = { + config: ResolvedConfig; + apiUrl: string; + apiKey: string; + environmentClient: ApiClient; + projectName: string; +}; + +function useDev({ config, apiUrl, apiKey, environmentClient, projectName }: DevProps) { + useEffect(() => { + const websocketUrl = new URL(apiUrl); + websocketUrl.protocol = websocketUrl.protocol.replace("http", "ws"); + websocketUrl.pathname = `/ws`; + + const websocket = new WebSocket(websocketUrl.href, [], { + WebSocket: WebsocketFactory(apiKey), + connectionTimeout: 10000, + maxRetries: 6, + }); + + websocket.addEventListener("open", (foo) => {}); + websocket.addEventListener("close", (event) => {}); + websocket.addEventListener("error", (event) => {}); + + const sender = new ZodMessageSender({ + schema: clientWebsocketMessages, + sender: async (message) => { + websocket?.send(JSON.stringify(message)); + }, + }); + + const backgroundWorkerCoordinator = new BackgroundWorkerCoordinator( + `${apiUrl}/projects/v3/${config.project}` + ); + + backgroundWorkerCoordinator.onTaskCompleted.attach( + async ({ backgroundWorkerId, completion }) => { + await sender.send("BACKGROUND_WORKER_MESSAGE", { + backgroundWorkerId, + data: { + type: "TASK_RUN_COMPLETED", + completion, + }, + }); + } + ); + + backgroundWorkerCoordinator.onWorkerRegistered.attach(async ({ id, worker, record }) => { + await sender.send("READY_FOR_TASKS", { + backgroundWorkerId: id, + }); + }); + + backgroundWorkerCoordinator.onWorkerDeprecated.attach(async ({ id }) => { + await sender.send("WORKER_DEPRECATED", { + backgroundWorkerId: id, + }); + }); + + websocket.addEventListener("message", async (event) => { + const data = JSON.parse( + typeof event.data === "string" ? event.data : new TextDecoder("utf-8").decode(event.data) + ); + + const messageHandler = new ZodMessageHandler({ + schema: serverWebsocketMessages, + messages: { + SERVER_READY: async (payload) => {}, + BACKGROUND_WORKER_MESSAGE: async (payload) => { + await backgroundWorkerCoordinator.handleMessage( + payload.backgroundWorkerId, + payload.data + ); + }, + }, + }); + + await messageHandler.handleMessage(data); + }); + + let ctx: BuildContext | undefined; + + async function runBuild() { + if (ctx) { + await ctx.cancel(); + await ctx.dispose(); + } + + let latestWorkerContentHash: string | undefined; + + const taskFiles = await gatherTaskFiles(config); + + const workerFacade = readFileSync( + new URL(importResolve("./worker-facade.js", import.meta.url)).href.replace("file://", ""), + "utf-8" + ); + const entryPointContents = workerFacade.replace( + "__TASKS__", + createTaskFileImports(taskFiles) + ); + + let firstBuild = true; + + logger.log(chalk.dim("⎔ Building background worker...")); + + ctx = await context({ + stdin: { + contents: entryPointContents, + resolveDir: process.cwd(), + sourcefile: "__entryPoint.ts", + }, + bundle: true, + metafile: true, + write: false, + minify: false, + sourcemap: true, + logLevel: "silent", + platform: "node", + format: "esm", + target: ["node18", "es2020"], + outdir: "out", + define: { + TRIGGER_API_URL: `"${config.triggerUrl}"`, + }, + banner: { + js: "import { createRequire } from 'module';const require = createRequire(import.meta.url);", + }, + plugins: [ + { + name: "trigger.dev v3", + setup(build) { + build.onEnd(async (result) => { + if (result.errors.length > 0) return; + if (!result || !result.outputFiles) { + logger.error("Build failed: no result"); + return; + } + + if (!firstBuild) { + logger.log(chalk.dim("⎔ Rebuilding background worker...")); + } + + const metaOutputKey = join("out", `stdin.js`); + + const metaOutput = result.metafile!.outputs[metaOutputKey]; + + if (!metaOutput) { + throw new Error(`Could not find metafile`); + } + + const outputFileKey = join(config.projectDir, metaOutputKey); + const outputFile = result.outputFiles.find((file) => file.path === outputFileKey); + + if (!outputFile) { + throw new Error( + `Could not find output file for entry point ${metaOutput.entryPoint}` + ); + } + + const sourceMapFileKey = join(config.projectDir, `${metaOutputKey}.map`); + const sourceMapFile = result.outputFiles.find( + (file) => file.path === sourceMapFileKey + ); + + if (!sourceMapFile) { + throw new Error( + `Could not find source map file for entry point ${metaOutput.entryPoint}` + ); + } + + const md5Hasher = createHash("md5"); + md5Hasher.update(Buffer.from(outputFile.contents.buffer)); + + const contentHash = md5Hasher.digest("hex"); + + if (latestWorkerContentHash === contentHash) { + logger.log(chalk.dim("⎔ No changes detected, skipping build...")); + + logger.debug(`No changes detected, skipping build`); + return; + } + + // Create a file at join(dir, ".trigger", path) with the fileContents + const fullPath = join(config.projectDir, ".trigger", `${contentHash}.mjs`); + + await fs.promises.mkdir(dirname(fullPath), { recursive: true }); + await fs.promises.writeFile(fullPath, outputFile.text); + const sourceMapPath = `${fullPath}.map`; + await fs.promises.writeFile(sourceMapPath, sourceMapFile.text); + + const backgroundWorker = new BackgroundWorker(fullPath, { + projectDir: config.projectDir, + env: { + TRIGGER_API_URL: apiUrl, + TRIGGER_API_KEY: apiKey, + }, + }); + + await backgroundWorker.initialize(); + + latestWorkerContentHash = contentHash; + + let packageVersion: string | undefined; + + const taskResources: Array = []; + + if (!backgroundWorker.tasks) { + throw new Error(`Background Worker started without tasks`); + } + + for (const task of backgroundWorker.tasks) { + taskResources.push({ + id: task.id, + filePath: task.filePath, + exportName: task.exportName, + }); + + packageVersion = task.packageVersion; + } + + if (!packageVersion) { + throw new Error(`Background Worker started without package version`); + } + + const backgroundWorkerBody: CreateBackgroundWorkerRequestBody = { + localOnly: true, + metadata: { + packageVersion, + // This is a hack to get around the funky node16 typescript module resolution issue + cliPackageVersion: packageJson.version, + tasks: taskResources, + contentHash: contentHash, + }, + }; + + const backgroundWorkerRecord = await environmentClient.createBackgroundWorker( + config.project, + backgroundWorkerBody + ); + + if (!backgroundWorkerRecord.success) { + throw new Error(backgroundWorkerRecord.error); + } + + backgroundWorker.metadata = backgroundWorkerRecord.data; + + if (firstBuild) { + logger.log( + chalk.green( + `Background worker started (${backgroundWorkerRecord.data.version})` + ) + ); + } else { + logger.log( + chalk.dim(`Background worker rebuilt (${backgroundWorkerRecord.data.version})`) + ); + } + + firstBuild = false; + + await backgroundWorkerCoordinator.registerWorker( + backgroundWorkerRecord.data, + backgroundWorker + ); + }); + }, + }, + ], + }); + + await ctx.watch(); + } + + const throttle = pThrottle({ + limit: 2, + interval: 1000, + }); + + const throttledRebuild = throttle(runBuild); + + const taskFileWatcher = watch( + config.triggerDirectories.map((triggerDir) => `${triggerDir}/*.ts`), + { + ignoreInitial: true, + } + ); + + taskFileWatcher.on("add", async (path) => { + throttledRebuild().catch((error) => { + logger.error(error); + }); + }); + + taskFileWatcher.on("unlink", async (path) => { + throttledRebuild().catch((error) => { + logger.error(error); + }); + }); + + throttledRebuild().catch((error) => { + logger.error(error); + }); + + return () => { + logger.debug(`Shutting down dev session for ${config.project}`); + + taskFileWatcher.close(); + + websocket?.close(); + backgroundWorkerCoordinator.close(); + ctx?.dispose().catch((error) => { + console.error(error); + }); + }; + }, [config, apiUrl, apiKey, environmentClient]); +} + +function DevUI(props: DevProps) { + return ( + + + + ); +} + +function DevUIImp(props: DevProps) { + const dev = useDev(props); + + return ( + <> + + + ); +} + +function useHotkeys() { + const { exit } = useApp(); + + useInput(async (input, key) => { + if (key.return) { + console.log(""); + return; + } + switch (input.toLowerCase()) { + // clear console + case "c": + console.clear(); + // This console.log causes Ink to re-render the `DevSession` component. + // Couldn't find a better way to tell it to do so... + console.log(); + break; + // open browser + case "b": { + break; + } + // toggle inspector + // case "d": { + // if (inspect) { + // await openInspector(inspectorPort, props.worker); + // } + // break; + // } + + // shut down + case "q": + case "x": + exit(); + break; + default: + // nothing? + break; + } + }); +} + +function HotKeys() { + useHotkeys(); + + return ( + + [b] + open a browser, + [c] + clear console, + [x] + to exit + + ); +} + +function WebsocketFactory(apiKey: string) { + return class extends wsWebSocket { + constructor(address: string | URL, options?: ClientOptions | ClientRequestArgs) { + super(address, { ...(options ?? {}), headers: { Authorization: `Bearer ${apiKey}` } }); + } + }; +} + +function createTaskFileImports(taskFiles: TaskFile[]) { + return taskFiles + .map( + (taskFile) => + `import * as ${taskFile.importName} from "./${taskFile.importPath}"; TaskFileImports["${ + taskFile.importName + }"] = ${taskFile.importName}; TaskFiles["${taskFile.importName}"] = ${JSON.stringify( + taskFile + )};` + ) + .join("\n"); +} + +// Find all the top-level .js or .ts files in the trigger directories +async function gatherTaskFiles(config: ResolvedConfig): Promise> { + const taskFiles: Array = []; + + for (const triggerDir of config.triggerDirectories) { + const files = await fs.promises.readdir(triggerDir, { withFileTypes: true }); + for (const file of files) { + if (!file.isFile()) continue; + if (!file.name.endsWith(".js") && !file.name.endsWith(".ts")) continue; + + const fullPath = join(triggerDir, file.name); + + const filePath = relative(config.projectDir, fullPath); + const importPath = filePath.replace(/\.(js|ts)$/, ""); + const importName = importPath.replace(/\//g, "_"); + + taskFiles.push({ triggerDir, importPath, importName, filePath }); + } + } + + return taskFiles; +} + +async function getConfigPath(dir: string): Promise { + const path = await findUp(CONFIG_FILES, { cwd: dir }); + + if (!path) { + throw new Error("No config file found."); + } + + return path; +} + +async function readConfig(path: string): Promise { + try { + // import the config file + const userConfigModule = await import(`${pathToFileURL(path).href}?_ts=${Date.now()}`); + const rawConfig = await normalizeConfig(userConfigModule ? userConfigModule.default : {}); + const config = ConfigSchema.parse(rawConfig); + + return resolveConfig(path, config); + } catch (error) { + console.error(`Failed to load config file at ${path}`); + throw error; + } +} + +async function resolveConfig(path: string, config: Config): Promise { + if (!config.triggerDirectories) { + config.triggerDirectories = await findTriggerDirectories(path); + } + + config.triggerDirectories = resolveTriggerDirectories(config.triggerDirectories); + + if (!config.triggerUrl) { + config.triggerUrl = CLOUD_API_URL; + } + + if (!config.projectDir) { + config.projectDir = dirname(path); + } + + return config as ResolvedConfig; +} + +async function normalizeConfig(config: any): Promise { + if (typeof config === "function") { + config = config(); + } + + return await config; +} + +function resolveTriggerDirectories(dirs: string[]): string[] { + return dirs.map((dir) => resolve(dir)); +} + +const IGNORED_DIRS = ["node_modules", ".git", "dist", "build"]; + +async function findTriggerDirectories(filePath: string): Promise { + const dirPath = dirname(filePath); + return getTriggerDirectories(dirPath); +} + +async function getTriggerDirectories(dirPath: string): Promise { + const entries = await fs.promises.readdir(dirPath, { withFileTypes: true }); + const triggerDirectories: string[] = []; + + for (const entry of entries) { + if (!entry.isDirectory() || IGNORED_DIRS.includes(entry.name)) continue; + + const fullPath = join(dirPath, entry.name); + + if (entry.name === "trigger") { + triggerDirectories.push(fullPath); + } + + triggerDirectories.push(...(await getTriggerDirectories(fullPath))); + } + + return triggerDirectories; +} diff --git a/packages/cli-v3/src/commands/login.ts b/packages/cli-v3/src/commands/login.ts index 75b68b197..11b8911e9 100644 --- a/packages/cli-v3/src/commands/login.ts +++ b/packages/cli-v3/src/commands/login.ts @@ -1,12 +1,12 @@ import { intro, log, outro, select, spinner } from "@clack/prompts"; import open from "open"; import pRetry, { AbortError } from "p-retry"; -import { ApiClient } from "../apiClient"; -import { ApiUrlOptionsSchema } from "../cli"; -import { chalkLink } from "../utilities/colors"; -import { readAuthConfigFile, writeAuthConfigFile } from "../utilities/configFiles"; -import { logger } from "../utilities/logger"; -import { whoAmI } from "./whoami"; +import { ApiClient } from "../apiClient.js"; +import { ApiUrlOptionsSchema } from "../cli/index.js"; +import { chalkLink } from "../utilities/colors.js"; +import { readAuthConfigFile, writeAuthConfigFile } from "../utilities/configFiles.js"; +import { logger } from "../utilities/logger.js"; +import { whoAmI } from "./whoami.js"; export async function loginCommand(options: any) { const result = ApiUrlOptionsSchema.safeParse(options); @@ -35,7 +35,7 @@ export async function login(apiUrl: string): Promise { const existingAccessToken = readAuthConfigFile()?.accessToken; if (existingAccessToken) { - const whoAmiI = await whoAmI(apiUrl); + const whoAmiI = await whoAmI(); const continueOption = await select({ message: "You are already logged in.", @@ -98,7 +98,7 @@ export async function login(apiUrl: string): Promise { getPersonalAccessTokenSpinner.stop(`Logged in with token ${indexResult.obfuscatedToken}`); - writeAuthConfigFile({ accessToken: indexResult.token }); + writeAuthConfigFile({ accessToken: indexResult.token, apiUrl }); outro("Logged in successfully"); diff --git a/packages/cli-v3/src/commands/logout.ts b/packages/cli-v3/src/commands/logout.ts new file mode 100644 index 000000000..3ccb136d2 --- /dev/null +++ b/packages/cli-v3/src/commands/logout.ts @@ -0,0 +1,15 @@ +import { readAuthConfigFile, writeAuthConfigFile } from "../utilities/configFiles.js"; +import { logger } from "../utilities/logger.js"; + +export async function logoutCommand(options: any) { + const config = readAuthConfigFile(); + + if (!config?.accessToken) { + logger.info("You are already logged out"); + return; + } + + writeAuthConfigFile({ ...config, accessToken: undefined, apiUrl: undefined }); + + logger.info("Logged out"); +} diff --git a/packages/cli-v3/src/commands/update.ts b/packages/cli-v3/src/commands/update.ts index 9d142b6a9..dc6b5016b 100644 --- a/packages/cli-v3/src/commands/update.ts +++ b/packages/cli-v3/src/commands/update.ts @@ -1,11 +1,10 @@ -import { spinner, confirm } from "@clack/prompts"; +import { confirm, spinner } from "@clack/prompts"; +import { RunOptions, run } from "npm-check-updates"; import path from "path"; -import { run, RunOptions } from "npm-check-updates"; -import { installDependencies } from "../utilities/installDependencies"; -import { readJSONFileSync, writeJSONFile } from "../utilities/fileSystem.js"; -import { logger } from "../utilities/logger.js"; import { z } from "zod"; -import { chalkError, chalkSuccess } from "../utilities/colors"; +import { chalkError, chalkSuccess } from "../utilities/colors.js"; +import { readJSONFileSync, writeJSONFile } from "../utilities/fileSystem.js"; +import { installDependencies } from "../utilities/installDependencies.js"; export const UpdateCommandOptionsSchema = z.object({ to: z.string().optional(), diff --git a/packages/cli-v3/src/commands/whoami.ts b/packages/cli-v3/src/commands/whoami.ts index a853e97df..223a52e0f 100644 --- a/packages/cli-v3/src/commands/whoami.ts +++ b/packages/cli-v3/src/commands/whoami.ts @@ -1,10 +1,12 @@ import { note, spinner } from "@clack/prompts"; -import { ApiUrlOptionsSchema } from "../cli"; -import { logger } from "../utilities/logger"; -import { resolvePath } from "../utilities/parseNameAndPath"; -import { readAuthConfigFile } from "../utilities/configFiles"; -import { login } from "./login"; -import { ApiClient } from "../apiClient"; +import { ApiClient } from "../apiClient.js"; +import { chalkLink } from "../utilities/colors.js"; +import { logger } from "../utilities/logger.js"; +import { isLoggedIn } from "../utilities/session.js"; +import { Command } from "commander"; +import { printInitialBanner } from "../utilities/initialBanner.js"; +import { CommonCommandOptions } from "../cli/common.js"; +import { z } from "zod"; type WhoAmIResult = | { @@ -19,46 +21,50 @@ type WhoAmIResult = error: string; }; -export async function whoamiCommand(options: any): Promise { - const result = ApiUrlOptionsSchema.safeParse(options); - if (!result.success) { - logger.error(result.error.message); - return { - success: false, - error: result.error.message, - }; - } +const WhoamiCommandOptions = CommonCommandOptions; - return whoAmI(result.data.apiUrl); +type WhoamiCommandOptions = z.infer; + +export function configureWhoamiCommand(program: Command) { + program + .command("whoami") + .description("display the current logged in user and project details") + .option( + "-l, --log-level ", + "The log level to use (debug, info, log, warn, error, none)", + "log" + ) + .action(async (options) => { + try { + await printInitialBanner(); + await whoAmI(WhoamiCommandOptions.parse(options)); + } catch (e) { + throw e; + } + }); } -export async function whoAmI(apiUrl: string): Promise { +export async function whoAmI(options?: WhoamiCommandOptions): Promise { + if (options?.logLevel) { + logger.loggerLevel = options?.logLevel; + } + const loadingSpinner = spinner(); loadingSpinner.start("Checking your account details"); - if (!readAuthConfigFile()?.accessToken) { - loadingSpinner.stop("You must login."); - const loginResult = await login(apiUrl); - if (!loginResult.success) { - logger.error(loginResult.error); - return { - success: false, - error: loginResult.error, - }; - } - } + const authentication = await isLoggedIn(); + + if (!authentication.ok) { + loadingSpinner.stop("You must login first. Use `trigger.dev login` to login."); - const accessToken = readAuthConfigFile()?.accessToken; - if (!accessToken) { - logger.error("No access token after login… this should never happen"); return { success: false, - error: "No access token after login… this should never happen", + error: authentication.error, }; } - const apiClient = new ApiClient(apiUrl); - const userData = await apiClient.whoAmI({ accessToken }); + const apiClient = new ApiClient(authentication.config.apiUrl, authentication.config.accessToken); + const userData = await apiClient.whoAmI(); if (!userData.success) { loadingSpinner.stop("Error getting your account details"); @@ -73,7 +79,9 @@ export async function whoAmI(apiUrl: string): Promise { note( `User ID: ${userData.data.userId} -Email: ${userData.data.email}`, +Email: ${userData.data.email} +URL: ${chalkLink(authentication.config.apiUrl)} +`, "Account details" ); diff --git a/packages/cli-v3/src/dev/backgroundWorker.ts b/packages/cli-v3/src/dev/backgroundWorker.ts new file mode 100644 index 000000000..e7b340cf2 --- /dev/null +++ b/packages/cli-v3/src/dev/backgroundWorker.ts @@ -0,0 +1,448 @@ +import { + BackgroundWorkerRecord, + BackgroundWorkerServerMessages, + CreateBackgroundWorkerResponse, + TaskMetadataWithFilePath, + TaskRunBuiltInError, + TaskRunError, + TaskRunExecution, + TaskRunExecutionPayload, + TaskRunExecutionResult, + ZodMessageHandler, + ZodMessageSender, + childToWorkerMessages, + workerToChildMessages, +} from "@trigger.dev/core/v3"; +import chalk from "chalk"; +import { Evt } from "evt"; +import { fork } from "node:child_process"; +import { readFileSync } from "node:fs"; +import nodePath from "node:path"; +import { SourceMapConsumer, type RawSourceMap } from "source-map"; +import terminalLink from "terminal-link"; +import { logger } from "../utilities/logger.js"; + +export type CurrentWorkers = BackgroundWorkerCoordinator["currentWorkers"]; +export class BackgroundWorkerCoordinator { + public onTaskCompleted: Evt<{ + backgroundWorkerId: string; + completion: TaskRunExecutionResult; + worker: BackgroundWorker; + execution: TaskRunExecution; + }> = new Evt(); + public onWorkerRegistered: Evt<{ + worker: BackgroundWorker; + id: string; + record: CreateBackgroundWorkerResponse; + }> = new Evt(); + public onWorkerDeprecated: Evt<{ worker: BackgroundWorker; id: string }> = new Evt(); + private _backgroundWorkers: Map = new Map(); + private _records: Map = new Map(); + + constructor(private baseURL: string) { + this.onTaskCompleted.attach(async ({ completion, execution }) => { + await this.#notifyWorkersOfTaskCompletion(completion, execution); + }); + } + + async #notifyWorkersOfTaskCompletion( + completion: TaskRunExecutionResult, + execution: TaskRunExecution + ) { + for (const worker of this._backgroundWorkers.values()) { + await worker.handleTaskRunCompletion(completion, execution); + } + } + + get currentWorkers() { + return Array.from(this._backgroundWorkers.entries()).map(([id, worker]) => ({ + id, + worker, + record: this._records.get(id)!, + })); + } + + async registerWorker(record: CreateBackgroundWorkerResponse, worker: BackgroundWorker) { + for (const [workerId, existingWorker] of this._backgroundWorkers.entries()) { + if (workerId === record.id) { + continue; + } + + this.onWorkerDeprecated.post({ worker: existingWorker, id: workerId }); + } + + this._backgroundWorkers.set(record.id, worker); + this._records.set(record.id, record); + this.onWorkerRegistered.post({ worker, id: record.id, record }); + } + + close() { + for (const worker of this._backgroundWorkers.values()) { + worker.close(); + } + + this._backgroundWorkers.clear(); + this._records.clear(); + } + + async handleMessage(id: string, message: BackgroundWorkerServerMessages) { + switch (message.type) { + case "EXECUTE_RUNS": { + await Promise.all(message.payloads.map((payload) => this.#executeTaskRun(id, payload))); + } + } + } + + async #executeTaskRun(id: string, payload: TaskRunExecutionPayload) { + const worker = this._backgroundWorkers.get(id); + + if (!worker) { + logger.error(`Could not find worker ${id}`); + return; + } + + const record = this._records.get(id); + + if (!record) { + logger.error(`Could not find worker record ${id}`); + return; + } + + const { execution } = payload; + + const link = chalk.bgBlueBright( + terminalLink("view logs", `${this.baseURL}/runs/${execution.run.id}`) + ); + const workerPrefix = chalk.green(`[worker:${record.version}]`); + const taskPrefix = chalk.yellow(`[task:${execution.task.id}]`); + const runId = chalk.blue(execution.run.id); + const attempt = chalk.blue(`.${execution.attempt.number}`); + + logger.log(`${workerPrefix}${taskPrefix} ${runId}${attempt} ${link}`); + + const now = performance.now(); + + const completion = await worker.executeTaskRun(payload); + + const elapsed = performance.now() - now; + + const resultText = !completion.ok ? chalk.red("error") : chalk.green("success"); + + const errorText = !completion.ok + ? `\n\n\t${chalk.bgRed("Error")} ${this.#formatErrorLog(completion.error)}` + : ""; + + const elapsedText = chalk.dim(`(${elapsed.toFixed(2)}ms)`); + + logger.log( + `${workerPrefix}${taskPrefix} ${runId}${attempt} ${resultText} ${elapsedText} ${link}${errorText}` + ); + + this.onTaskCompleted.post({ completion, execution, worker, backgroundWorkerId: id }); + } + + #formatErrorLog(error: TaskRunError) { + switch (error.type) { + case "INTERNAL_ERROR": { + return `Internal error: ${error.code}`; + } + case "STRING_ERROR": { + return error.raw; + } + case "CUSTOM_ERROR": { + return error.raw; + } + case "BUILT_IN_ERROR": { + return `${error.name === "Error" ? "" : `(${error.name})`} ${ + error.message + }\n${error.stackTrace + .split("\n") + .map((line) => `\t ${line}`) + .join("\n")}\n`; + } + } + } +} + +export type BackgroundWorkerParams = { + env: Record; + projectDir: string; +}; +export class BackgroundWorker { + private _rawSourceMap: RawSourceMap; + private _initialized: boolean = false; + private _handler = new ZodMessageHandler({ + schema: childToWorkerMessages, + }); + private _onTaskCompleted: Evt<{ + completion: TaskRunExecutionResult; + execution: TaskRunExecution; + }> = new Evt(); + private _onClose: Evt = new Evt(); + + public tasks: Array = []; + public metadata: BackgroundWorkerRecord | undefined; + + _taskExecutions: Map< + string, + { resolve: (value: TaskRunExecutionResult) => void; reject: (err?: any) => void } + > = new Map(); + + constructor( + public path: string, + private params: BackgroundWorkerParams + ) { + this._rawSourceMap = JSON.parse(readFileSync(`${path}.map`, "utf-8")); + } + + close() { + this._onClose.post(); + } + + async initialize() { + if (this._initialized) { + throw new Error("Worker already initialized"); + } + + let resolved = false; + + this.tasks = await new Promise>((resolve, reject) => { + const child = fork(this.path, { + stdio: [/*stdin*/ "ignore", /*stdout*/ "pipe", /*stderr*/ "pipe", "ipc"], + env: { + ...this.params.env, + }, + }); + + // Set a timeout to kill the child process if it doesn't respond + const timeout = setTimeout(() => { + if (resolved) { + return; + } + + resolved = true; + child.kill(); + reject(new Error("Worker timed out")); + }, 1000); + + child.on("message", async (msg: any) => { + const message = this._handler.parseMessage(msg); + + if (message.type === "TASKS_READY" && !resolved) { + clearTimeout(timeout); + resolved = true; + resolve(message.payload.tasks); + child.kill(); + } + }); + + child.stdout?.on("data", (data) => { + logger.log(data.toString()); + }); + + child.stderr?.on("data", (data) => { + logger.error(data.toString()); + }); + + child.on("exit", (code) => { + if (!resolved) { + clearTimeout(timeout); + resolved = true; + reject(new Error(`Worker exited with code ${code}`)); + } + }); + }); + + this._initialized = true; + } + + async handleTaskRunCompletion(completion: TaskRunExecutionResult, execution: TaskRunExecution) { + this._onTaskCompleted.post({ completion, execution }); + } + + // We need to fork the process before we can execute any tasks + async executeTaskRun(payload: TaskRunExecutionPayload): Promise { + const metadata = this.metadata; + + if (!metadata) { + throw new Error("Worker not registered"); + } + + const { execution, traceContext } = payload; + + const child = fork(this.path, { + stdio: [/*stdin*/ "ignore", /*stdout*/ "pipe", /*stderr*/ "pipe", "ipc"], + env: { + ...this.params.env, + }, + }); + + const sender = new ZodMessageSender({ + schema: workerToChildMessages, + sender: async (message) => { + if (!child.connected) { + return; + } + + child.send(message); + }, + }); + + const ctx = Evt.newCtx(); + + // This will notify this task of the completion of any other tasks + this._onTaskCompleted.attach(ctx, async (taskCompletion) => { + if (execution.attempt.id === taskCompletion.execution.attempt.id) { + return; + } + + await sender.send("TASK_RUN_COMPLETED", taskCompletion); + }); + + this._onClose.attachOnce(ctx, () => { + child.kill(); + }); + + let resolved = false; + let resolver: (value: TaskRunExecutionResult) => void; + let rejecter: (err?: any) => void; + + const promise = new Promise((resolve, reject) => { + resolver = resolve; + rejecter = reject; + }); + + child.on("message", async (msg: any) => { + const message = this._handler.parseMessage(msg); + + if (message.type === "TASK_RUN_COMPLETED") { + resolved = true; + resolver(message.payload.result); + this._onTaskCompleted.detach(ctx); + this._onClose.detach(ctx); + + await sender.send("CLEANUP", { flush: true }); + } else if (message.type === "READY_TO_DISPOSE") { + if (!child.killed) { + child.kill(); + } + } + }); + + child.on("exit", (code) => { + if (!resolved) { + resolved = true; + this._onTaskCompleted.detach(ctx); + this._onClose.detach(ctx); + rejecter(new Error(`Worker exited with code ${code}`)); + } + }); + + child.stdout?.on("data", (data) => { + logger.log( + `[${metadata.version}][${execution.run.id}.${execution.attempt.number}] ${data.toString()}` + ); + }); + + await sender.send("EXECUTE_TASK_RUN", { execution, traceContext, metadata }); + + const result = await promise; + + if (result.ok) { + return result; + } + + const error = result.error; + + if (error.type === "BUILT_IN_ERROR") { + const mappedError = await this.#correctError(error, execution); + + return { + ...result, + error: mappedError, + }; + } + + return result; + } + + async #correctError( + error: TaskRunBuiltInError, + execution: TaskRunExecution + ): Promise { + return { + ...error, + stackTrace: await this.#correctErrorStackTrace(error.stackTrace, execution), + }; + } + + async #correctErrorStackTrace(stackTrace: string, execution: TaskRunExecution): Promise { + // Split the stack trace into lines + const lines = stackTrace.split("\n"); + + // Remove the first line + lines.shift(); + + // Use SourceMapConsumer.with to handle the source map for the entire stack trace + return SourceMapConsumer.with(this._rawSourceMap, null, (consumer) => + lines + .map((line) => this.#correctStackTraceLine(line, consumer, execution)) + .filter(Boolean) + .join("\n") + ); + } + + #correctStackTraceLine( + line: string, + consumer: SourceMapConsumer, + execution: TaskRunExecution + ): string | undefined { + // Split the line into parts + const regex = /at (.*?) \(file:\/\/(\/.*?\.mjs):(\d+):(\d+)\)/; + + const match = regex.exec(line); + + if (!match) { + return line; + } + + const [_, identifier, path, lineNum, colNum] = match; + + const originalPosition = consumer.originalPositionFor({ + line: Number(lineNum), + column: Number(colNum), + }); + + if (!originalPosition.source) { + return line; + } + + const { source, line: originalLine, column: originalColumn } = originalPosition; + + if (this.#shouldFilterLine({ identifier, path: source })) { + return; + } + + const sourcePath = path + ? nodePath.relative(this.params.projectDir, nodePath.resolve(nodePath.dirname(path), source)) + : source; + + return `at ${ + identifier === "Object.run" ? `${execution.task.exportName}.run` : identifier + } (${sourcePath}:${originalLine}:${originalColumn})`; + } + + #shouldFilterLine(line: { identifier?: string; path?: string }): boolean { + const filename = nodePath.basename(line.path ?? ""); + + if (filename === "__entryPoint.ts") { + return true; + } + + if (line.identifier === "async ZodMessageHandler.handleMessage") { + return true; + } + + return false; + } +} diff --git a/packages/cli-v3/src/dev/ink-table.tsx b/packages/cli-v3/src/dev/ink-table.tsx new file mode 100644 index 000000000..afc63f82a --- /dev/null +++ b/packages/cli-v3/src/dev/ink-table.tsx @@ -0,0 +1,375 @@ +// via https://github.com/maticzav/ink-table +// inlined here because of https://github.com/maticzav/ink-table/issues/258 + +import React from "react"; +import { Box, Text } from "ink"; +import { sha1 } from "object-hash"; + +/* Table */ + +type Scalar = string | number | boolean | null | undefined; + +type ScalarDict = { + [key: string]: Scalar; +}; + +export type CellProps = React.PropsWithChildren<{ column: number }>; + +export type TableProps = { + /** + * List of values (rows). + */ + data: T[]; + /** + * Columns that we should display in the table. + */ + columns: (keyof T)[]; + /** + * Cell padding. + */ + padding: number; + /** + * Header component. + */ + header: (props: React.PropsWithChildren) => React.JSX.Element; + /** + * Component used to render a cell in the table. + */ + cell: (props: CellProps) => React.JSX.Element; + /** + * Component used to render the skeleton of the table. + */ + skeleton: (props: React.PropsWithChildren) => React.JSX.Element; +}; + +/* Table */ + +export default class Table extends React.Component< + Pick, "data"> & Partial> +> { + /* Config */ + + /** + * Merges provided configuration with defaults. + */ + getConfig(): TableProps { + return { + data: this.props.data, + columns: this.props.columns || this.getDataKeys(), + padding: this.props.padding || 1, + header: this.props.header || Header, + cell: this.props.cell || Cell, + skeleton: this.props.skeleton || Skeleton, + }; + } + + /** + * Gets all keyes used in data by traversing through the data. + */ + getDataKeys(): (keyof T)[] { + const keys = new Set(); + + // Collect all the keys. + for (const data of this.props.data) { + for (const key in data) { + keys.add(key); + } + } + + return Array.from(keys); + } + + /** + * Calculates the width of each column by finding + * the longest value in a cell of a particular column. + * + * Returns a list of column names and their widths. + */ + getColumns(): Column[] { + const { columns, padding } = this.getConfig(); + + const widths: Column[] = columns.map((key) => { + const header = String(key).length; + /* Get the width of each cell in the column */ + const data = this.props.data.map((data) => { + const value = data[key]; + + if (value == undefined || value == null) return 0; + return String(value).length; + }); + + const width = Math.max(...data, header) + padding * 2; + + /* Construct a cell */ + return { + column: key, + width: width, + key: String(key), + }; + }); + + return widths; + } + + /** + * Returns a (data) row representing the headings. + */ + getHeadings(): Partial { + const { columns } = this.getConfig(); + + const headings: Partial = columns.reduce( + (acc, column) => ({ ...acc, [column]: column }), + {} + ); + + return headings; + } + + /* Rendering utilities */ + + // The top most line in the table. + header = row({ + cell: this.getConfig().skeleton, + padding: this.getConfig().padding, + skeleton: { + component: this.getConfig().skeleton, + // chars + line: "─", + left: "┌", + right: "┐", + cross: "┬", + }, + }); + + // The line with column names. + heading = row({ + cell: this.getConfig().header, + padding: this.getConfig().padding, + skeleton: { + component: this.getConfig().skeleton, + // chars + line: " ", + left: "│", + right: "│", + cross: "│", + }, + }); + + // The line that separates rows. + separator = row({ + cell: this.getConfig().skeleton, + padding: this.getConfig().padding, + skeleton: { + component: this.getConfig().skeleton, + // chars + line: "─", + left: "├", + right: "┤", + cross: "┼", + }, + }); + + // The row with the data. + data = row({ + cell: this.getConfig().cell, + padding: this.getConfig().padding, + skeleton: { + component: this.getConfig().skeleton, + // chars + line: " ", + left: "│", + right: "│", + cross: "│", + }, + }); + + // The bottom most line of the table. + footer = row({ + cell: this.getConfig().skeleton, + padding: this.getConfig().padding, + skeleton: { + component: this.getConfig().skeleton, + // chars + line: "─", + left: "└", + right: "┘", + cross: "┴", + }, + }); + + /* Render */ + override render() { + /* Data */ + const columns = this.getColumns(); + const headings = this.getHeadings(); + + /** + * Render the table line by line. + */ + return ( + + {/* Header */} + {this.header({ key: "header", columns, data: {} })} + {this.heading({ key: "heading", columns, data: headings })} + {/* Data */} + {this.props.data.map((row, index) => { + // Calculate the hash of the row based on its value and position + const key = `row-${sha1(row)}-${index}`; + + // Construct a row. + return ( + + {this.separator({ key: `separator-${key}`, columns, data: {} })} + {this.data({ key: `data-${key}`, columns, data: row })} + + ); + })} + {/* Footer */} + {this.footer({ key: "footer", columns, data: {} })} + + ); + } +} + +/* Helper components */ + +type RowConfig = { + /** + * Component used to render cells. + */ + cell: (props: CellProps) => React.JSX.Element; + /** + * Tells the padding of each cell. + */ + padding: number; + /** + * Component used to render skeleton in the row. + */ + skeleton: { + component: (props: React.PropsWithChildren) => React.JSX.Element; + /** + * Characters used in skeleton. + * | | + * (left)-(line)-(cross)-(line)-(right) + * | | + */ + left: string; + right: string; + cross: string; + line: string; + }; +}; + +type RowProps = { + key: string; + data: Partial; + columns: Column[]; +}; + +type Column = { + key: string; + column: keyof T; + width: number; +}; + +/** + * Constructs a Row element from the configuration. + */ +function row(config: RowConfig): (props: RowProps) => React.JSX.Element { + /* This is a component builder. We return a function. */ + + const skeleton = config.skeleton; + + /* Row */ + return (props) => ( + + {/* Left */} + {skeleton.left} + {/* Data */} + {...intersperse( + (i) => { + const key = `${props.key}-hseparator-${i}`; + + // The horizontal separator. + return {skeleton.cross}; + }, + + // Values. + props.columns.map((column, colI) => { + // content + const value = props.data[column.column]; + + if (value == undefined || value == null) { + const key = `${props.key}-empty-${column.key}`; + + return ( + + {skeleton.line.repeat(column.width)} + + ); + } else { + const key = `${props.key}-cell-${column.key}`; + + // margins + const ml = config.padding; + const mr = column.width - String(value).length - config.padding; + + return ( + /* prettier-ignore */ + + {`${skeleton.line.repeat(ml)}${String(value)}${skeleton.line.repeat(mr)}`} + + ); + } + }) + )} + {/* Right */} + {skeleton.right} + + ); +} + +/** + * Renders the header of a table. + */ +export function Header(props: React.PropsWithChildren) { + return ( + + {props.children} + + ); +} + +/** + * Renders a cell in the table. + */ +export function Cell(props: CellProps) { + return {props.children}; +} + +/** + * Redners the scaffold of the table. + */ +export function Skeleton(props: React.PropsWithChildren) { + return {props.children}; +} + +/* Utility functions */ + +/** + * Intersperses a list of elements with another element. + */ +function intersperse(intersperser: (index: number) => I, elements: T[]): (T | I)[] { + // Intersparse by reducing from left. + const interspersed: (T | I)[] = elements.reduce( + (acc, element, index) => { + // Only add element if it's the first one. + if (acc.length === 0) return [element]; + // Add the intersparser as well otherwise. + return [...acc, intersperser(index), element]; + }, + [] as (T | I)[] + ); + + return interspersed; +} diff --git a/packages/cli-v3/src/index.ts b/packages/cli-v3/src/index.ts index c04a5f7d2..01f8666d8 100644 --- a/packages/cli-v3/src/index.ts +++ b/packages/cli-v3/src/index.ts @@ -1,7 +1,7 @@ #!/usr/bin/env node -import { program } from "./cli/index"; -import { logger } from "./utilities/logger"; +import { program } from "./cli/index.js"; +import { logger } from "./utilities/logger.js"; const main = async () => { await program.parseAsync(); diff --git a/packages/cli-v3/src/telemetry/telemetry.ts b/packages/cli-v3/src/telemetry/telemetry.ts index 6026c8d3f..b1b12470b 100644 --- a/packages/cli-v3/src/telemetry/telemetry.ts +++ b/packages/cli-v3/src/telemetry/telemetry.ts @@ -1,6 +1,6 @@ import { PostHog } from "posthog-node"; import { nanoid } from "nanoid"; -import { getVersion } from "../utilities/getVersion"; +import { getVersion } from "../utilities/getVersion.js"; const postHogApiKey = "phc_9aSDbJCaDUMdZdHxxMPTvcj7A9fsl3mCgM1RBPmPsl7"; diff --git a/packages/cli-v3/src/types.ts b/packages/cli-v3/src/types.ts new file mode 100644 index 000000000..2176422e2 --- /dev/null +++ b/packages/cli-v3/src/types.ts @@ -0,0 +1,5 @@ +import { TaskMetadataWithFilePath } from "@trigger.dev/core/v3"; + +export type TaskMetadataWithRun = TaskMetadataWithFilePath & { + run: (params: any) => Promise; +}; diff --git a/packages/cli-v3/src/utilities/configFiles.ts b/packages/cli-v3/src/utilities/configFiles.ts index 3e2216f34..eac5d34ac 100644 --- a/packages/cli-v3/src/utilities/configFiles.ts +++ b/packages/cli-v3/src/utilities/configFiles.ts @@ -1,26 +1,22 @@ -import fs, { mkdirSync, readFileSync, writeFileSync } from "node:fs"; -import os from "node:os"; +import { mkdirSync, writeFileSync } from "node:fs"; import path from "node:path"; import xdgAppPaths from "xdg-app-paths"; import { z } from "zod"; -import { isDirectory, pathExists, readJSONFileSync } from "./fileSystem"; +import { readJSONFileSync } from "./fileSystem.js"; +import { logger } from "./logger.js"; function getGlobalConfigFolderPath() { const configDir = xdgAppPaths(".trigger").config(); - const legacyConfigDir = path.join(os.homedir(), ".trigger"); // Legacy config in user's home directory - // Check for the .trigger directory in root, if it is not there then use the XDG compliant path. - if (isDirectory(legacyConfigDir)) { - return legacyConfigDir; - } else { - return configDir; - } + return configDir; } //auth config file export const UserAuthConfigSchema = z.object({ accessToken: z.string().optional(), + apiUrl: z.string().optional(), }); + export type UserAuthConfig = z.infer; function getAuthConfigFilePath() { @@ -38,12 +34,14 @@ export function writeAuthConfigFile(config: UserAuthConfig) { } export function readAuthConfigFile(): UserAuthConfig | undefined { - const authConfigFilePath = getAuthConfigFilePath(); - if (!pathExists(authConfigFilePath)) { - return; - } + try { + const authConfigFilePath = getAuthConfigFilePath(); - const json = readJSONFileSync(authConfigFilePath); - const parsed = UserAuthConfigSchema.parse(json); - return parsed; + const json = readJSONFileSync(authConfigFilePath); + const parsed = UserAuthConfigSchema.parse(json); + return parsed; + } catch (error) { + logger.debug(`Error reading auth config file: ${error}`); + return undefined; + } } diff --git a/packages/cli-v3/src/utilities/fileSystem.ts b/packages/cli-v3/src/utilities/fileSystem.ts index b7b3bbafb..e4f390f26 100644 --- a/packages/cli-v3/src/utilities/fileSystem.ts +++ b/packages/cli-v3/src/utilities/fileSystem.ts @@ -21,13 +21,7 @@ export function isDirectory(configPath: string) { } export async function pathExists(path: string): Promise { - try { - await fsModule.access(path); - - return true; - } catch (err) { - return false; - } + return fsSync.existsSync(path); } export async function someFileExists(directory: string, filenames: string[]): Promise { diff --git a/packages/cli-v3/src/utilities/getApiKeyType.test.ts b/packages/cli-v3/src/utilities/getApiKeyType.test.ts index ba81b5c42..e8be117e5 100644 --- a/packages/cli-v3/src/utilities/getApiKeyType.test.ts +++ b/packages/cli-v3/src/utilities/getApiKeyType.test.ts @@ -1,4 +1,4 @@ -import { checkApiKeyIsDevServer } from "./getApiKeyType"; +import { checkApiKeyIsDevServer } from "./getApiKeyType.js"; describe("Test API keys", () => { test("dev server succeeds", async () => { diff --git a/packages/cli-v3/src/utilities/getEnvironmentVariableFactory.ts b/packages/cli-v3/src/utilities/getEnvironmentVariableFactory.ts new file mode 100644 index 000000000..e8c104f27 --- /dev/null +++ b/packages/cli-v3/src/utilities/getEnvironmentVariableFactory.ts @@ -0,0 +1,69 @@ +import { logger } from "./logger.js"; + +type VariableNames = "TRIGGER_API_URL" | "TRIGGER_API_KEY" | "TRIGGER_LOG_LEVEL"; + +type DeprecatedNames = ""; + +/** + * Create a function used to access an environment variable. + * + * This is not memoized to allow us to change the value at runtime, such as in testing. + * A warning is shown if the client is using a deprecated version - but only once. + */ +export function getEnvironmentVariableFactory({ + variableName, + deprecatedName, +}: { + variableName: VariableNames; + deprecatedName?: DeprecatedNames; +}): () => string | undefined; + +/** + * Create a function used to access an environment variable, with a default value. + * + * This is not memoized to allow us to change the value at runtime, such as in testing. + * A warning is shown if the client is using a deprecated version - but only once. + */ +export function getEnvironmentVariableFactory({ + variableName, + deprecatedName, + defaultValue, +}: { + variableName: VariableNames; + deprecatedName?: DeprecatedNames; + defaultValue: () => string; +}): () => string; + +/** + * Create a function used to access an environment variable. + * + * This is not memoized to allow us to change the value at runtime, such as in testing. + * A warning is shown if the client is using a deprecated version - but only once. + */ +export function getEnvironmentVariableFactory({ + variableName, + deprecatedName, + defaultValue, +}: { + variableName: VariableNames; + deprecatedName?: DeprecatedNames; + defaultValue?: () => string; +}): () => string | undefined { + let hasWarned = false; + return () => { + if (process.env[variableName]) { + return process.env[variableName]; + } else if (deprecatedName && process.env[deprecatedName]) { + if (!hasWarned) { + // Only show the warning once. + hasWarned = true; + logger.warn( + `Using "${deprecatedName}" environment variable. This is deprecated. Please use "${variableName}", instead.` + ); + } + return process.env[deprecatedName]; + } else { + return defaultValue?.(); + } + }; +} diff --git a/packages/cli-v3/src/utilities/getUserPackageManager.spec.ts b/packages/cli-v3/src/utilities/getUserPackageManager.spec.ts index 577810006..48959cb55 100644 --- a/packages/cli-v3/src/utilities/getUserPackageManager.spec.ts +++ b/packages/cli-v3/src/utilities/getUserPackageManager.spec.ts @@ -1,6 +1,6 @@ import { randomUUID } from "crypto"; -import { pathExists } from "./fileSystem"; -import { getUserPackageManager } from "./getUserPackageManager"; +import { pathExists } from "./fileSystem.js"; +import { getUserPackageManager } from "./getUserPackageManager.js"; import * as pathModule from "path"; import { Mock } from "vitest"; diff --git a/packages/cli-v3/src/utilities/getUserPackageManager.ts b/packages/cli-v3/src/utilities/getUserPackageManager.ts index 72879178b..27b9a9031 100644 --- a/packages/cli-v3/src/utilities/getUserPackageManager.ts +++ b/packages/cli-v3/src/utilities/getUserPackageManager.ts @@ -1,5 +1,5 @@ import pathModule from "path"; -import { pathExists } from "./fileSystem"; +import { pathExists } from "./fileSystem.js"; export type PackageManager = "npm" | "pnpm" | "yarn"; diff --git a/packages/cli-v3/src/utilities/getVersion.ts b/packages/cli-v3/src/utilities/getVersion.ts index 946689105..46d91f05a 100644 --- a/packages/cli-v3/src/utilities/getVersion.ts +++ b/packages/cli-v3/src/utilities/getVersion.ts @@ -1,7 +1,7 @@ import { type PackageJson } from "type-fest"; import path from "path"; -import { PKG_ROOT } from "../consts"; -import { readJSONFileSync } from "./fileSystem"; +import { PKG_ROOT } from "../consts.js"; +import { readJSONFileSync } from "./fileSystem.js"; export function getVersion() { const packageJsonPath = path.join(PKG_ROOT, "package.json"); diff --git a/packages/cli-v3/src/utilities/initialBanner.ts b/packages/cli-v3/src/utilities/initialBanner.ts index 0bd6f8dbe..68d347602 100644 --- a/packages/cli-v3/src/utilities/initialBanner.ts +++ b/packages/cli-v3/src/utilities/initialBanner.ts @@ -1,11 +1,12 @@ +import { spinner } from "@clack/prompts"; import chalk from "chalk"; +import supportsColor from "supports-color"; import type { Result } from "update-check"; import checkForUpdate from "update-check"; import pkg from "../../package.json"; -import { chalkGrey, logo } from "./colors"; -import { getVersion } from "./getVersion"; -import { logger } from "./logger"; -import { spinner, intro } from "@clack/prompts"; +import { chalkGrey, green, logo } from "./colors.js"; +import { getVersion } from "./getVersion.js"; +import { logger } from "./logger.js"; export async function printInitialBanner(performUpdateCheck = true) { const packageVersion = getVersion(); @@ -21,7 +22,7 @@ export async function printInitialBanner(performUpdateCheck = true) { // Log a slightly more noticeable message if this is a major bump if (maybeNewVersion !== undefined) { - loadingSpinner.stop(`Update available ${chalk.green(maybeNewVersion)})`); + loadingSpinner.stop(`Update available ${chalk.green(maybeNewVersion)}`); const currentMajor = parseInt(packageVersion.split(".")[0]!); const newMajor = parseInt(maybeNewVersion.split(".")[0]!); if (newMajor > currentMajor) { @@ -37,6 +38,25 @@ After installation, run Trigger.dev with \`npx trigger.dev\`.` } } +export async function printStandloneInitialBanner(performUpdateCheck = true) { + const packageVersion = getVersion(); + + let text = `\n${logo()} ${chalkGrey(`${packageVersion}`)}`; + + if (performUpdateCheck) { + const maybeNewVersion = await updateCheck(); + + // Log a slightly more noticeable message if this is a major bump + if (maybeNewVersion !== undefined) { + text = `${text} (update available ${chalk.green(maybeNewVersion)})`; + } + } + + logger.log( + text + "\n" + (supportsColor.stdout ? chalk.hex(green)("-".repeat(54)) : "-".repeat(54)) + ); +} + async function doUpdateCheck(): Promise { let update: Result | null = null; try { diff --git a/packages/cli-v3/src/utilities/installDependencies.ts b/packages/cli-v3/src/utilities/installDependencies.ts index 1a10eaab1..6245d44ea 100644 --- a/packages/cli-v3/src/utilities/installDependencies.ts +++ b/packages/cli-v3/src/utilities/installDependencies.ts @@ -1,8 +1,8 @@ -import { spinner, confirm } from "@clack/prompts"; -import { getUserPackageManager, type PackageManager } from "./getUserPackageManager"; -import { logger } from "./logger"; +import { spinner } from "@clack/prompts"; import chalk from "chalk"; import { execa } from "execa"; +import { getUserPackageManager, type PackageManager } from "./getUserPackageManager.js"; +import { logger } from "./logger.js"; export async function installDependencies(projectDir: string) { logger.info("Installing dependencies..."); diff --git a/packages/cli-v3/src/utilities/logger.ts b/packages/cli-v3/src/utilities/logger.ts index fe1656a57..07774b639 100644 --- a/packages/cli-v3/src/utilities/logger.ts +++ b/packages/cli-v3/src/utilities/logger.ts @@ -1,29 +1,69 @@ +// This is a copy of the logger utility from the wrangler repo: https://github.com/cloudflare/workers-sdk/blob/main/packages/wrangler/src/logger.ts + +import { format } from "node:util"; import chalk from "chalk"; import CLITable from "cli-table3"; +import { formatMessagesSync } from "esbuild"; +import type { Message } from "esbuild"; +import { getEnvironmentVariableFactory } from "./getEnvironmentVariableFactory.js"; +export const LOGGER_LEVELS = { + none: -1, + error: 0, + warn: 1, + info: 2, + log: 3, + debug: 4, +} as const; -export type Logger = typeof logger; +export type LoggerLevel = keyof typeof LOGGER_LEVELS; + +/** A map from LOGGER_LEVEL to the error `kind` needed by `formatMessagesSync()`. */ +const LOGGER_LEVEL_FORMAT_TYPE_MAP = { + error: "error", + warn: "warning", + info: undefined, + log: undefined, + debug: undefined, +} as const; + +const getLogLevelFromEnv = getEnvironmentVariableFactory({ + variableName: "TRIGGER_LOG_LEVEL", +}); + +function getLoggerLevel(): LoggerLevel { + const fromEnv = getLogLevelFromEnv()?.toLowerCase(); + if (fromEnv !== undefined) { + if (fromEnv in LOGGER_LEVELS) return fromEnv as LoggerLevel; + const expected = Object.keys(LOGGER_LEVELS) + .map((level) => `"${level}"`) + .join(" | "); + console.warn( + `Unrecognised WRANGLER_LOG value ${JSON.stringify( + fromEnv + )}, expected ${expected}, defaulting to "log"...` + ); + } + return "log"; +} export type TableRow = Record; -export const logger = { - log(...args: unknown[]) { - console.log(...args); - }, - error(...args: unknown[]) { - console.log(chalk.red(...args)); - }, - warn(...args: unknown[]) { - console.log(chalk.yellow(...args)); - }, - info(...args: unknown[]) { - console.log(chalk.cyan(...args)); - }, - success(...args: unknown[]) { - console.log(chalk.green(...args)); - }, +export class Logger { + constructor() {} + + loggerLevel = getLoggerLevel(); + columns = process.stdout.columns; + + debug = (...args: unknown[]) => this.doLog("debug", args); + debugWithSanitization = (label: string, ...args: unknown[]) => { + this.doLog("debug", [label, ...args]); + }; + info = (...args: unknown[]) => this.doLog("info", args); + log = (...args: unknown[]) => this.doLog("log", args); + warn = (...args: unknown[]) => this.doLog("warn", args); + error = (...args: unknown[]) => this.doLog("error", args); table(data: TableRow[]) { - if (data.length === 0) return console.log("No data"); - const keys: Keys[] = data.length === 0 ? [] : (Object.keys(data[0] as {}) as Keys[]); + const keys: Keys[] = data.length === 0 ? [] : (Object.keys(data[0]!) as Keys[]); const t = new CLITable({ head: keys, style: { @@ -32,6 +72,57 @@ export const logger = { }, }); t.push(...data.map((row) => keys.map((k) => row[k]))); - return this.log(t.toString()); - }, -}; + return this.doLog("log", [t.toString()]); + } + + private doLog(messageLevel: Exclude, args: unknown[]) { + const message = this.formatMessage(messageLevel, format(...args)); + + // only send logs to the terminal if their level is at least the configured log-level + if (LOGGER_LEVELS[this.loggerLevel] >= LOGGER_LEVELS[messageLevel]) { + console[messageLevel](message); + } + } + + private formatMessage(level: Exclude, message: string): string { + const kind = LOGGER_LEVEL_FORMAT_TYPE_MAP[level]; + if (kind) { + // Format the message using the esbuild formatter. + // The first line of the message is the main `text`, + // subsequent lines are put into the `notes`. + const [firstLine, ...otherLines] = message.split("\n"); + const notes = otherLines.length > 0 ? otherLines.map((text) => ({ text })) : undefined; + return formatMessagesSync([{ text: firstLine, notes }], { + color: true, + kind, + terminalWidth: this.columns, + })[0]!; + } else { + return message; + } + } +} + +/** + * A drop-in replacement for `console` for outputting logging messages. + * + * Errors and Warnings will get additional formatting to highlight them to the user. + * You can also set a `logger.loggerLevel` value to one of "debug", "log", "warn" or "error", + * to filter out logging messages. + */ +export const logger = new Logger(); + +export function logBuildWarnings(warnings: Message[]) { + const logs = formatMessagesSync(warnings, { kind: "warning", color: true }); + for (const log of logs) console.warn(log); +} + +/** + * Logs all errors/warnings associated with an esbuild BuildFailure in the same + * style esbuild would. + */ +export function logBuildFailure(errors: Message[], warnings: Message[]) { + const logs = formatMessagesSync(errors, { kind: "error", color: true }); + for (const log of logs) console.error(log); + logBuildWarnings(warnings); +} diff --git a/packages/cli-v3/src/utilities/session.ts b/packages/cli-v3/src/utilities/session.ts new file mode 100644 index 000000000..71ce8d036 --- /dev/null +++ b/packages/cli-v3/src/utilities/session.ts @@ -0,0 +1,28 @@ +import { ApiClient } from "../apiClient.js"; +import { readAuthConfigFile } from "./configFiles.js"; + +export async function isLoggedIn() { + const config = readAuthConfigFile(); + + if (!config?.accessToken || !config?.apiUrl) { + return { ok: false as const, error: "You must login first" }; + } + + const apiClient = new ApiClient(config.apiUrl, config.accessToken); + const userData = await apiClient.whoAmI(); + + if (!userData.success) { + return { + ok: false as const, + error: userData.error, + }; + } + + return { + ok: true as const, + config: { + apiUrl: config.apiUrl, + accessToken: config.accessToken, + }, + }; +} diff --git a/packages/cli-v3/src/worker-facade.ts b/packages/cli-v3/src/worker-facade.ts new file mode 100644 index 000000000..0e2aa0a90 --- /dev/null +++ b/packages/cli-v3/src/worker-facade.ts @@ -0,0 +1,234 @@ +import { TracingSDK, HttpInstrumentation, FetchInstrumentation } from "@trigger.dev/core/v3/otel"; + +// IMPORTANT: this needs to be the first import to work properly +const tracingSDK = new TracingSDK({ + url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://0.0.0.0:4318", + resource: new Resource({ + [SemanticInternalAttributes.CLI_VERSION]: packageJson.version, + }), + instrumentations: [new HttpInstrumentation(), new FetchInstrumentation()], +}); + +const otelTracer = tracingSDK.getTracer("trigger-dev-worker", packageJson.version); +const otelLogger = tracingSDK.getLogger("trigger-dev-worker", packageJson.version); + +import { SpanKind } from "@opentelemetry/api"; +import { + BackgroundWorkerRecord, + ConsoleInterceptor, + DevRuntimeManager, + OtelTaskLogger, + SemanticInternalAttributes, + TaskMetadataWithFilePath, + TaskRunContext, + TaskRunErrorCodes, + TaskRunExecution, + TriggerTracer, + ZodMessageHandler, + ZodMessageSender, + childToWorkerMessages, + logger, + parseError, + runtime, + taskContextManager, + workerToChildMessages, +} from "@trigger.dev/core/v3"; +import * as packageJson from "../package.json"; + +import { Resource } from "@opentelemetry/resources"; +import { flattenAttributes } from "@trigger.dev/core/v3"; +import { TaskMetadataWithRun } from "./types.js"; + +const tracer = new TriggerTracer({ tracer: otelTracer, logger: otelLogger }); +const consoleInterceptor = new ConsoleInterceptor(otelLogger); + +const devRuntimeManager = new DevRuntimeManager({ + tracer, +}); + +runtime.setGlobalRuntimeManager(devRuntimeManager); + +const otelTaskLogger = new OtelTaskLogger({ + logger: otelLogger, + level: "info", +}); + +logger.setGlobalTaskLogger(otelTaskLogger); + +type TaskFileImport = Record; + +const TaskFileImports: Record = {}; +const TaskFiles: Record = {}; + +__TASKS__; +declare const __TASKS__: Record; + +class TaskExecutor { + constructor(public task: TaskMetadataWithRun) {} + + async execute( + execution: TaskRunExecution, + worker: BackgroundWorkerRecord, + traceContext: Record + ) { + const parsedPayload = JSON.parse(execution.run.payload); + const ctx = TaskRunContext.parse(execution); + + const output = await taskContextManager.runWith( + { + ctx, + payload: parsedPayload, + worker, + }, + async () => { + tracingSDK.asyncResourceDetector.resolveWithAttributes({ + ...taskContextManager.attributes, + [SemanticInternalAttributes.SDK_VERSION]: this.task.packageVersion, + [SemanticInternalAttributes.SDK_LANGUAGE]: "typescript", + }); + + return await tracer.startActiveSpan( + `Attempt #${execution.attempt.number}`, + async (span) => { + return await consoleInterceptor.intercept(console, async () => { + const output = await this.task.run({ + payload: parsedPayload, + ctx: TaskRunContext.parse(execution), + }); + + span.setAttributes(flattenAttributes(output, SemanticInternalAttributes.OUTPUT)); + + return output; + }); + }, + { + kind: SpanKind.CONSUMER, + attributes: { + [SemanticInternalAttributes.STYLE_ICON]: "task", + }, + }, + tracer.extractContext(traceContext) + ); + } + ); + + return { output: JSON.stringify(output), outputType: "application/json" }; + } +} + +function getTasks(): Array { + const result: Array = []; + + for (const [importName, taskFile] of Object.entries(TaskFiles)) { + const fileImports = TaskFileImports[importName]; + + for (const [exportName, task] of Object.entries(fileImports ?? {})) { + if ((task as any).__trigger) { + result.push({ + id: (task as any).__trigger.id, + exportName, + packageVersion: (task as any).__trigger.packageVersion, + filePath: (taskFile as any).filePath, + run: (task as any).__trigger.run, + }); + } + } + } + + return result; +} + +function getTaskMetadata(): Array { + const result = getTasks(); + + // Remove the run function from the metadata + return result.map((task) => { + const { run, ...metadata } = task; + + return metadata; + }); +} + +const sender = new ZodMessageSender({ + schema: childToWorkerMessages, + sender: async (message) => { + process.send?.(message); + }, +}); + +const tasks = getTasks(); + +const taskExecutors: Map = new Map(); + +for (const task of tasks) { + taskExecutors.set(task.id, new TaskExecutor(task)); +} + +const handler = new ZodMessageHandler({ + schema: workerToChildMessages, + messages: { + EXECUTE_TASK_RUN: async ({ execution, traceContext, metadata }) => { + process.title = `trigger-dev-worker: ${execution.task.id} ${execution.attempt.id}`; + + const executor = taskExecutors.get(execution.task.id); + + if (!executor) { + console.error(`Could not find executor for task ${execution.task.id}`); + + await sender.send("TASK_RUN_COMPLETED", { + result: { + ok: false, + id: execution.attempt.id, + error: { + type: "INTERNAL_ERROR", + code: TaskRunErrorCodes.COULD_NOT_FIND_EXECUTOR, + }, + }, + }); + + return; + } + + try { + const result = await executor.execute(execution, metadata, traceContext); + + return sender.send("TASK_RUN_COMPLETED", { + result: { + id: execution.attempt.id, + ok: true, + ...result, + }, + }); + } catch (e) { + return sender.send("TASK_RUN_COMPLETED", { + result: { + id: execution.attempt.id, + ok: false, + error: parseError(e), + }, + }); + } + }, + TASK_RUN_COMPLETED: async ({ completion, execution }) => { + devRuntimeManager.resumeTask(completion, execution); + }, + CLEANUP: async ({ flush }) => { + if (flush) { + await tracingSDK.flushOtel(); + } + + // Now we need to exit the process + await sender.send("READY_TO_DISPOSE", undefined); + }, + }, +}); + +process.on("message", async (msg: any) => { + await handler.handleMessage(msg); +}); + +sender.send("TASKS_READY", { tasks: getTaskMetadata() }).catch((err) => { + console.error("Failed to send TASKS_READY message", err); +}); + +process.title = "trigger-dev-worker"; diff --git a/packages/cli-v3/tsconfig.json b/packages/cli-v3/tsconfig.json index e017b811e..b4976837f 100644 --- a/packages/cli-v3/tsconfig.json +++ b/packages/cli-v3/tsconfig.json @@ -1,55 +1,31 @@ +// See: https://www.totaltypescript.com/tsconfig-cheat-sheet { - "include": ["src/globals.d.ts", "./src/**/*.ts", "tsup.config.ts", "./test/**/*.ts"], + "include": ["./src/**/*.ts", "./src/**/*.tsx"], "compilerOptions": { - /* LANGUAGE COMPILATION OPTIONS */ - "target": "ES2020", - "lib": ["DOM", "DOM.Iterable", "ES2020"], - "module": "ESNext", - "moduleResolution": "node", - "resolveJsonModule": true, - "allowJs": true, - "checkJs": true, - /* EMIT RULES */ - "outDir": "./dist", - "noEmit": true, // TSUP takes care of emitting js for us, in a MUCH faster way - "declaration": true, - "declarationMap": true, - "sourceMap": true, - "removeComments": true, - - /* TYPE CHECKING RULES */ - "strict": true, - // "noImplicitAny": true, // Included in "Strict" - // "noImplicitThis": true, // Included in "Strict" - // "strictBindCallApply": true, // Included in "Strict" - // "strictFunctionTypes": true, // Included in "Strict" - // "strictNullChecks": true, // Included in "Strict" - // "strictPropertyInitialization": true, // Included in "Strict" - "noFallthroughCasesInSwitch": true, - "noImplicitOverride": true, - "noImplicitReturns": true, - "noUnusedLocals": false, - "noUnusedParameters": false, - "useUnknownInCatchVariables": true, - // "noUncheckedIndexedAccess": true, // TLDR - Checking an indexed value (array[0]) now forces type as there is no confirmation that index exists - // THE BELOW ARE EXTRA STRICT OPTIONS THAT SHOULD ONLY BY CONSIDERED IN VERY SAFE PROJECTS - // "exactOptionalPropertyTypes": true, // TLDR - Setting to undefined is not the same as a property not being defined at all - // "noPropertyAccessFromIndexSignature": true, // TLDR - Use dot notation for objects if youre sure it exists, use ['index'] notaion if unsure - - /* OTHER OPTIONS */ - "allowSyntheticDefaultImports": true, "esModuleInterop": true, - // "emitDecoratorMetadata": true, - // "experimentalDecorators": true, - "forceConsistentCasingInFileNames": true, "skipLibCheck": true, - "useDefineForClassFields": true, - "experimentalDecorators": true, - "emitDecoratorMetadata": true, - "types": ["vitest/globals"], + "target": "es2022", + "allowJs": true, + "resolveJsonModule": true, + "moduleDetection": "force", + "isolatedModules": true, + "strict": true, + "noUncheckedIndexedAccess": true, + /* Building for a monorepo */ + "declaration": true, + "composite": false, + "sourceMap": true, + "declarationMap": true, + /* We're building with tsup */ + "moduleResolution": "Bundler", + "module": "ESNext", + "noEmit": true, + "lib": ["es2022", "DOM"], + "types": ["node", "vitest/globals"], + "jsx": "react", "paths": { - "@trigger.dev/core/*": ["../core/src/*"], - "@trigger.dev/core": ["../core/src/index"] + "@trigger.dev/core/v3": ["../core/src/v3"], + "@trigger.dev/core/v3/*": ["../core/src/v3/*"] } }, "exclude": ["node_modules"] diff --git a/packages/cli-v3/tsup.config.ts b/packages/cli-v3/tsup.config.ts index 9122e86d8..57eec45dc 100644 --- a/packages/cli-v3/tsup.config.ts +++ b/packages/cli-v3/tsup.config.ts @@ -3,17 +3,18 @@ import { defineConfig } from "tsup"; const isDev = process.env.npm_lifecycle_event === "dev"; export default defineConfig({ - clean: true, + clean: false, + tsconfig: "tsconfig.json", dts: true, + splitting: false, entry: ["src/index.ts"], format: ["esm"], - minify: !isDev, - metafile: !isDev, + minify: false, + metafile: false, sourcemap: true, target: "esnext", outDir: "dist", onSuccess: isDev ? `node dist/index.js` : "", - //this is required because "xdg-app-paths" uses a dynamic import banner: { js: "import { createRequire } from 'module';const require = createRequire(import.meta.url);", }, diff --git a/packages/cli-v3/tsup.facade.config.ts b/packages/cli-v3/tsup.facade.config.ts new file mode 100644 index 000000000..2c960249f --- /dev/null +++ b/packages/cli-v3/tsup.facade.config.ts @@ -0,0 +1,16 @@ +import { defineConfig } from "tsup"; + +export default defineConfig({ + clean: false, + dts: true, + tsconfig: "tsconfig.json", + splitting: false, + entry: ["src/worker-facade.ts"], + format: ["esm"], + minify: false, + metafile: false, + sourcemap: true, + target: "esnext", + outDir: "dist", + noExternal: ["zod"], +}); diff --git a/packages/cli/package.json b/packages/cli/package.json index c847d2a3d..d1fcb7bc9 100644 --- a/packages/cli/package.json +++ b/packages/cli/package.json @@ -67,6 +67,7 @@ "console-table-printer": "^2.11.2", "degit": "^2.8.4", "dotenv": "^16.3.1", + "esbuild": "^0.19.11", "execa": "^7.0.0", "gradient-string": "^2.0.2", "inquirer": "^9.1.4", diff --git a/packages/cli/src/types.ts b/packages/cli/src/types.ts new file mode 100644 index 000000000..06fdea6a4 --- /dev/null +++ b/packages/cli/src/types.ts @@ -0,0 +1,4 @@ +export type TaskMetadata = { + id: string; + exportName: string; +}; diff --git a/packages/core/package.json b/packages/core/package.json index 4a64668d8..a7f3b5fd1 100644 --- a/packages/core/package.json +++ b/packages/core/package.json @@ -21,8 +21,34 @@ "require": "./dist/index.js", "types": "./dist/index.d.ts" }, + "./v3": { + "import": { + "types": "./dist/v3/index.d.mts", + "default": "./dist/v3/index.mjs" + }, + "require": "./dist/v3/index.js", + "types": "./dist/v3/index.d.ts" + }, + "./v3/otel": { + "import": { + "types": "./dist/v3/otel/index.d.mts", + "default": "./dist/v3/otel/index.mjs" + }, + "require": "./dist/v3/otel/index.js", + "types": "./dist/v3/otel/index.d.ts" + }, "./package.json": "./package.json" }, + "typesVersions": { + "*": { + "v3": [ + "./dist/v3/index.d.ts" + ], + "v3/otel": [ + "./dist/v3/otel/index.d.ts" + ] + } + }, "sideEffects": false, "scripts": { "clean": "rimraf dist", @@ -32,19 +58,34 @@ "test": "jest" }, "dependencies": { + "@opentelemetry/api": "^1.7.0", + "@opentelemetry/api-logs": "^0.48.0", + "@opentelemetry/auto-instrumentations-node": "^0.40.3", + "@opentelemetry/exporter-collector": "^0.25.0", + "@opentelemetry/exporter-logs-otlp-http": "^0.48.0", + "@opentelemetry/exporter-trace-otlp-http": "^0.48.0", + "@opentelemetry/instrumentation": "^0.48.0", + "@opentelemetry/instrumentation-fetch": "^0.48.0", + "@opentelemetry/instrumentation-http": "^0.48.0", + "@opentelemetry/resources": "^1.21.0", + "@opentelemetry/sdk-logs": "^0.48.0", + "@opentelemetry/sdk-node": "^0.48.0", + "@opentelemetry/sdk-trace-base": "^1.21.0", + "@opentelemetry/sdk-trace-node": "^1.21.0", + "@opentelemetry/semantic-conventions": "^1.21.0", "ulidx": "^2.2.1", "zod": "3.22.3", "zod-error": "1.5.0" }, "devDependencies": { "@trigger.dev/tsconfig": "workspace:*", + "@trigger.dev/tsup": "workspace:*", "@types/jest": "^29.5.3", "@types/node": "16", "jest": "^29.6.2", "rimraf": "^3.0.2", "ts-jest": "^29.1.1", "tsup": "^8.0.1", - "@trigger.dev/tsup": "workspace:*", "typescript": "^5.3.0" }, "engines": { diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts index 4ea0ca311..63ef65dc0 100644 --- a/packages/core/src/index.ts +++ b/packages/core/src/index.ts @@ -6,7 +6,6 @@ export * from "./replacements"; export * from "./searchParams"; export * from "./eventFilterMatches"; export * from "./requestFilterMatches"; -export * from "./v3"; export const API_VERSIONS = { LAZY_LOADED_CACHED_TASKS: "2023-09-29", diff --git a/packages/core/src/v3/apiClient/index.ts b/packages/core/src/v3/apiClient/index.ts new file mode 100644 index 000000000..5c71da47c --- /dev/null +++ b/packages/core/src/v3/apiClient/index.ts @@ -0,0 +1,36 @@ +import { context, propagation } from "@opentelemetry/api"; +import { zodfetch } from "../../zodfetch"; +import { TriggerTaskRequestBody, TriggerTaskResponse } from "../schemas/api"; +import { taskContextManager } from "../tasks/taskContextManager"; + +/** + * Trigger.dev v3 API client + */ +export class ApiClient { + constructor( + private readonly baseUrl: string, + private readonly accessToken: string + ) {} + + triggerTask(taskId: string, options: TriggerTaskRequestBody) { + return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/trigger`, { + method: "POST", + headers: this.#getHeaders(), + body: JSON.stringify(options), + }); + } + + #getHeaders() { + const headers = { + "Content-Type": "application/json", + Authorization: `Bearer ${this.accessToken}`, + }; + + // Only inject the context if we are inside a task + if (taskContextManager.isInsideTask) { + propagation.inject(context.active(), headers); + } + + return headers; + } +} diff --git a/packages/core/src/v3/consoleInterceptor.ts b/packages/core/src/v3/consoleInterceptor.ts new file mode 100644 index 000000000..6ff588bd2 --- /dev/null +++ b/packages/core/src/v3/consoleInterceptor.ts @@ -0,0 +1,118 @@ +import type * as logsAPI from "@opentelemetry/api-logs"; +import { SeverityNumber } from "@opentelemetry/api-logs"; +import util from "node:util"; +import { flattenAttributes } from "./utils/flattenAttributes"; + +export class ConsoleInterceptor { + constructor(private readonly logger: logsAPI.Logger) {} + + // Intercept the console and send logs to the OpenTelemetry logger + // during the execution of the callback + async intercept>(console: Console, callback: () => R): Promise { + // Save the original console methods + const originalConsole = { + log: console.log, + info: console.info, + warn: console.warn, + error: console.error, + }; + + // Override the console methods + console.log = this.log.bind(this); + console.info = this.info.bind(this); + console.warn = this.warn.bind(this); + console.error = this.error.bind(this); + + try { + return await callback(); + } finally { + // Restore the original console methods + console.log = originalConsole.log; + console.info = originalConsole.info; + console.warn = originalConsole.warn; + console.error = originalConsole.error; + } + } + + log(...args: unknown[]): void { + this.#handleLog(SeverityNumber.INFO, "Log", ...args); + } + + info(...args: unknown[]): void { + this.#handleLog(SeverityNumber.INFO, "Info", ...args); + } + + warn(...args: unknown[]): void { + this.#handleLog(SeverityNumber.WARN, "Warn", ...args); + } + + error(...args: unknown[]): void { + this.#handleLog(SeverityNumber.ERROR, "Error", ...args); + } + + #handleLog(severityNumber: SeverityNumber, severityText: string, ...args: unknown[]): void { + const body = util.format(...args); + + const parsed = tryParseJSON(body); + + if (parsed.ok) { + this.logger.emit({ + severityNumber, + severityText, + body: getLogMessage(parsed.value, severityText), + attributes: { ...this.#getAttributes(), ...flattenAttributes(parsed.value) }, + }); + + return; + } + + this.logger.emit({ + severityNumber, + severityText, + body, + attributes: this.#getAttributes(), + }); + } + + #getAttributes(): logsAPI.LogAttributes { + return { + "log.type": "console", + }; + } +} + +function getLogMessage(value: Record, fallback: string): string { + if (typeof value["message"] === "string") { + return value["message"]; + } + + if (typeof value["msg"] === "string") { + return value["msg"]; + } + + if (typeof value["body"] === "string") { + return value["body"]; + } + + if (typeof value["error"] === "string") { + return value["error"]; + } + + return fallback; +} + +function tryParseJSON( + value: string +): { ok: true; value: Record } | { ok: false; value: string } { + try { + const parsed = JSON.parse(value); + + if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) { + return { ok: true, value: parsed }; + } + + return { ok: false, value }; + } catch (e) { + return { ok: false, value }; + } +} diff --git a/packages/core/src/v3/errors.ts b/packages/core/src/v3/errors.ts new file mode 100644 index 000000000..9b12f7ffd --- /dev/null +++ b/packages/core/src/v3/errors.ts @@ -0,0 +1,53 @@ +import { TaskRunError } from "./schemas/common"; + +export function parseError(error: unknown): TaskRunError { + if (error instanceof Error) { + return { + type: "BUILT_IN_ERROR", + name: error.name, + message: error.message, + stackTrace: error.stack ?? "", + }; + } + + if (typeof error === "string") { + return { + type: "STRING_ERROR", + raw: error, + }; + } + + try { + return { + type: "CUSTOM_ERROR", + raw: JSON.stringify(error), + }; + } catch (e) { + return { + type: "CUSTOM_ERROR", + raw: String(error), + }; + } +} + +export function createErrorTaskError(error: TaskRunError): any { + switch (error.type) { + case "BUILT_IN_ERROR": { + const e = new Error(error.message); + + e.name = error.name; + e.stack = error.stackTrace; + + return e; + } + case "STRING_ERROR": { + return error.raw; + } + case "CUSTOM_ERROR": { + return JSON.parse(error.raw); + } + case "INTERNAL_ERROR": { + return new Error(`trigger.dev internal error (${error.code})`); + } + } +} diff --git a/packages/core/src/v3/index.ts b/packages/core/src/v3/index.ts index 292f6057c..698dc30d5 100644 --- a/packages/core/src/v3/index.ts +++ b/packages/core/src/v3/index.ts @@ -1 +1,23 @@ +import { TriggerTaskRequestBody } from "./schemas"; + export * from "./schemas"; +export * from "./apiClient"; +export * from "./zodMessageHandler"; +export * from "./errors"; +export * from "./runtime-api"; +export * from "./logger-api"; +export { SemanticInternalAttributes } from "./semanticInternalAttributes"; + +export function parseTriggerTaskRequestBody(body: unknown) { + return TriggerTaskRequestBody.safeParse(body); +} + +export { taskContextManager } from "./tasks/taskContextManager"; +export type { RuntimeManager } from "./runtime/manager"; +export { DevRuntimeManager } from "./runtime/devRuntimeManager"; +export { TriggerTracer } from "./tracer"; + +export type { TaskLogger } from "./logger/taskLogger"; +export { OtelTaskLogger } from "./logger/taskLogger"; +export { ConsoleInterceptor } from "./consoleInterceptor"; +export { flattenAttributes } from "./utils/flattenAttributes"; diff --git a/packages/core/src/v3/logger-api.ts b/packages/core/src/v3/logger-api.ts new file mode 100644 index 000000000..58fdd02fa --- /dev/null +++ b/packages/core/src/v3/logger-api.ts @@ -0,0 +1,5 @@ +// Split module-level variable definition into separate files to allow +// tree-shaking on each api instance. +import { LoggerAPI } from "./logger"; +/** Entrypoint for logger API */ +export const logger = LoggerAPI.getInstance(); diff --git a/packages/core/src/v3/logger/index.ts b/packages/core/src/v3/logger/index.ts new file mode 100644 index 000000000..dcbc3eb4f --- /dev/null +++ b/packages/core/src/v3/logger/index.ts @@ -0,0 +1,52 @@ +import { NoopTaskLogger, TaskLogger } from "./taskLogger"; +import { getGlobal, registerGlobal, unregisterGlobal } from "../utils/globals"; + +const API_NAME = "logger"; + +const NOOP_TASK_LOGGER = new NoopTaskLogger(); + +export class LoggerAPI implements TaskLogger { + private static _instance?: LoggerAPI; + + private constructor() {} + + public static getInstance(): LoggerAPI { + if (!this._instance) { + this._instance = new LoggerAPI(); + } + + return this._instance; + } + + public disable() { + unregisterGlobal(API_NAME); + } + + public setGlobalTaskLogger(taskLogger: TaskLogger): boolean { + return registerGlobal(API_NAME, taskLogger); + } + + public debug(message: string, metadata?: Record) { + this.#getTaskLogger().debug(message, metadata); + } + + public log(message: string, metadata?: Record) { + this.#getTaskLogger().log(message, metadata); + } + + public info(message: string, metadata?: Record) { + this.#getTaskLogger().info(message, metadata); + } + + public warn(message: string, metadata?: Record) { + this.#getTaskLogger().warn(message, metadata); + } + + public error(message: string, metadata?: Record) { + this.#getTaskLogger().error(message, metadata); + } + + #getTaskLogger(): TaskLogger { + return getGlobal(API_NAME) ?? NOOP_TASK_LOGGER; + } +} diff --git a/packages/core/src/v3/logger/taskLogger.ts b/packages/core/src/v3/logger/taskLogger.ts new file mode 100644 index 000000000..a91bf46b6 --- /dev/null +++ b/packages/core/src/v3/logger/taskLogger.ts @@ -0,0 +1,79 @@ +import { Logger, SeverityNumber } from "@opentelemetry/api-logs"; +import { flattenAttributes } from "../utils/flattenAttributes"; + +export type LogLevel = "log" | "error" | "warn" | "info" | "debug"; + +const logLevels: Array = ["error", "warn", "log", "info", "debug"]; + +export type TaskLoggerConfig = { + logger: Logger; + level: LogLevel; +}; + +export interface TaskLogger { + debug(message: string, properties?: Record): void; + log(message: string, properties?: Record): void; + info(message: string, properties?: Record): void; + warn(message: string, properties?: Record): void; + error(message: string, properties?: Record): void; +} + +export class OtelTaskLogger implements TaskLogger { + private readonly _level: number; + + constructor(private readonly _config: TaskLoggerConfig) { + this._level = logLevels.indexOf(_config.level); + } + + debug(message: string, properties?: Record) { + if (this._level < 4) return; + + this.#emitLog(message, "debug", SeverityNumber.DEBUG, properties); + } + + log(message: string, properties?: Record) { + if (this._level < 2) return; + + this.#emitLog(message, "log", SeverityNumber.INFO, properties); + } + + info(message: string, properties?: Record) { + if (this._level < 3) return; + + this.#emitLog(message, "info", SeverityNumber.INFO, properties); + } + + warn(message: string, properties?: Record) { + if (this._level < 1) return; + + this.#emitLog(message, "warn", SeverityNumber.WARN, properties); + } + + error(message: string, properties?: Record) { + if (this._level < 0) return; + + this.#emitLog(message, "error", SeverityNumber.ERROR, properties); + } + + #emitLog( + message: string, + severityText: string, + severityNumber: SeverityNumber, + properties?: Record + ) { + this._config.logger.emit({ + severityNumber, + severityText, + body: message, + attributes: { ...flattenAttributes(properties), "log.type": "logger" }, + }); + } +} + +export class NoopTaskLogger implements TaskLogger { + debug() {} + log() {} + info() {} + warn() {} + error() {} +} diff --git a/packages/core/src/v3/otel/index.ts b/packages/core/src/v3/otel/index.ts new file mode 100644 index 000000000..148482160 --- /dev/null +++ b/packages/core/src/v3/otel/index.ts @@ -0,0 +1,2 @@ +export { TracingSDK, type TracingSDKConfig } from "./tracingSDK"; +export { HttpInstrumentation, FetchInstrumentation } from "./instrumentations"; diff --git a/packages/core/src/v3/otel/instrumentations.ts b/packages/core/src/v3/otel/instrumentations.ts new file mode 100644 index 000000000..0df8eb222 --- /dev/null +++ b/packages/core/src/v3/otel/instrumentations.ts @@ -0,0 +1,2 @@ +export { HttpInstrumentation } from "@opentelemetry/instrumentation-http"; +export { FetchInstrumentation } from "@opentelemetry/instrumentation-fetch"; diff --git a/packages/core/src/v3/otel/tracingSDK.ts b/packages/core/src/v3/otel/tracingSDK.ts new file mode 100644 index 000000000..af4cb09ef --- /dev/null +++ b/packages/core/src/v3/otel/tracingSDK.ts @@ -0,0 +1,112 @@ +import { TracerProvider } from "@opentelemetry/api"; +import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http"; +import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http"; +import { + registerInstrumentations, + type InstrumentationOption, +} from "@opentelemetry/instrumentation"; +import { + IResource, + Resource, + ResourceAttributes, + detectResourcesSync, +} from "@opentelemetry/resources"; +import { LoggerProvider, SimpleLogRecordProcessor } from "@opentelemetry/sdk-logs"; +import { NodeTracerProvider, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-node"; +import { logs } from "@opentelemetry/api-logs"; +import { DetectorSync, ResourceDetectionConfig } from "@opentelemetry/resources"; +import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions"; +import { SemanticInternalAttributes } from "../semanticInternalAttributes"; + +class AsyncResourceDetector implements DetectorSync { + private _promise: Promise; + private _resolver?: (value: ResourceAttributes) => void; + + constructor() { + this._promise = new Promise((resolver) => { + this._resolver = resolver; + }); + } + + detect(_config?: ResourceDetectionConfig): Resource { + return new Resource({}, this._promise); + } + + resolveWithAttributes(attributes: ResourceAttributes) { + if (!this._resolver) { + throw new Error("Resolver not available"); + } + + this._resolver(attributes); + } +} + +export type TracingSDKConfig = { + url: string; + forceFlushTimeoutMillis?: number; + resource?: IResource; + instrumentations?: InstrumentationOption[]; +}; + +export class TracingSDK { + public readonly asyncResourceDetector = new AsyncResourceDetector(); + private readonly _logProvider: LoggerProvider; + private readonly _traceExporter: OTLPTraceExporter; + + public readonly getLogger: LoggerProvider["getLogger"]; + public readonly getTracer: TracerProvider["getTracer"]; + + constructor(private readonly config: TracingSDKConfig) { + const commonResources = detectResourcesSync({ + detectors: [this.asyncResourceDetector], + }) + .merge( + new Resource({ + [SemanticResourceAttributes.CLOUD_PROVIDER]: "trigger.dev", + [SemanticInternalAttributes.TRIGGER]: true, + }) + ) + .merge(config.resource ?? new Resource({})); + + const provider = new NodeTracerProvider({ + forceFlushTimeoutMillis: config.forceFlushTimeoutMillis ?? 500, + resource: commonResources, + }); + + const exporter = new OTLPTraceExporter({ + url: `${config.url}/v1/traces`, + timeoutMillis: config.forceFlushTimeoutMillis ?? 1000, + }); + + provider.addSpanProcessor(new SimpleSpanProcessor(exporter)); + provider.register(); + + registerInstrumentations({ + instrumentations: config.instrumentations ?? [], + }); + + const logExporter = new OTLPLogExporter({ + url: `${config.url}/v1/logs`, + }); + + // To start a logger, you first need to initialize the Logger provider. + const loggerProvider = new LoggerProvider({ + resource: commonResources, + }); + + loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(logExporter)); + + this._logProvider = loggerProvider; + this._traceExporter = exporter; + + logs.setGlobalLoggerProvider(loggerProvider); + + this.getLogger = loggerProvider.getLogger.bind(loggerProvider); + this.getTracer = provider.getTracer.bind(provider); + } + + public async flushOtel() { + await this._traceExporter.forceFlush(); + await this._logProvider.forceFlush(); + } +} diff --git a/packages/core/src/v3/runtime-api.ts b/packages/core/src/v3/runtime-api.ts new file mode 100644 index 000000000..f58de48e4 --- /dev/null +++ b/packages/core/src/v3/runtime-api.ts @@ -0,0 +1,5 @@ +// Split module-level variable definition into separate files to allow +// tree-shaking on each api instance. +import { RuntimeAPI } from "./runtime"; +/** Entrypoint for runtime API */ +export const runtime = RuntimeAPI.getInstance(); diff --git a/packages/core/src/v3/runtime/devRuntimeManager.ts b/packages/core/src/v3/runtime/devRuntimeManager.ts new file mode 100644 index 000000000..579a9dc4d --- /dev/null +++ b/packages/core/src/v3/runtime/devRuntimeManager.ts @@ -0,0 +1,55 @@ +import { TaskRunContext, TaskRunExecution, TaskRunExecutionResult } from "../schemas"; +import { TriggerTracer } from "../tracer"; +import { RuntimeManager } from "./manager"; + +export type DevRuntimeManagerOptions = { + tracer: TriggerTracer; +}; + +export class DevRuntimeManager implements RuntimeManager { + _taskWaits: Map< + string, + { resolve: (value: TaskRunExecutionResult) => void; reject: (err?: any) => void } + > = new Map(); + + constructor(private readonly options: DevRuntimeManagerOptions) {} + + disable(): void { + // do nothing + } + + async waitForDuration(ms: number): Promise { + return this.options.tracer.startActiveSpan("wait for duration", async (span) => { + return new Promise((resolve) => { + setTimeout(resolve, ms); + }); + }); + } + + async waitUntil(date: Date): Promise { + return new Promise((resolve) => { + setTimeout(resolve, date.getTime() - Date.now()); + }); + } + + async waitForTask(params: { id: string; ctx: TaskRunContext }): Promise { + return this.options.tracer.startActiveSpan("wait for task", async (span) => { + span.setAttribute("trigger.task.run.id", params.id); + + const promise = new Promise((resolve, reject) => { + this._taskWaits.set(params.id, { resolve, reject }); + }); + + return await promise; + }); + } + + resumeTask(completion: TaskRunExecutionResult, execution: TaskRunExecution): void { + const wait = this._taskWaits.get(execution.run.id); + + if (wait) { + wait.resolve(completion); + this._taskWaits.delete(execution.run.id); + } + } +} diff --git a/packages/core/src/v3/runtime/index.ts b/packages/core/src/v3/runtime/index.ts new file mode 100644 index 000000000..a3111585b --- /dev/null +++ b/packages/core/src/v3/runtime/index.ts @@ -0,0 +1,47 @@ +const API_NAME = "runtime"; + +import { TaskRunContext, TaskRunExecutionResult } from "../schemas"; +import { getGlobal, registerGlobal, unregisterGlobal } from "../utils/globals"; +import { type RuntimeManager } from "./manager"; +import { NoopRuntimeManager } from "./noopRuntimeManager"; + +const NOOP_RUNTIME_MANAGER = new NoopRuntimeManager(); + +export class RuntimeAPI { + private static _instance?: RuntimeAPI; + + private constructor() {} + + public static getInstance(): RuntimeAPI { + if (!this._instance) { + this._instance = new RuntimeAPI(); + } + + return this._instance; + } + + public waitForDuration(ms: number): Promise { + return this.#getRuntimeManager().waitForDuration(ms); + } + + public waitUntil(date: Date): Promise { + return this.#getRuntimeManager().waitUntil(date); + } + + public waitForTask(params: { id: string; ctx: TaskRunContext }): Promise { + return this.#getRuntimeManager().waitForTask(params); + } + + public setGlobalRuntimeManager(runtimeManager: RuntimeManager): boolean { + return registerGlobal(API_NAME, runtimeManager); + } + + public disable() { + this.#getRuntimeManager().disable(); + unregisterGlobal(API_NAME); + } + + #getRuntimeManager(): RuntimeManager { + return getGlobal(API_NAME) ?? NOOP_RUNTIME_MANAGER; + } +} diff --git a/packages/core/src/v3/runtime/manager.ts b/packages/core/src/v3/runtime/manager.ts new file mode 100644 index 000000000..7a4fbfe31 --- /dev/null +++ b/packages/core/src/v3/runtime/manager.ts @@ -0,0 +1,8 @@ +import { TaskRunContext, TaskRunExecutionResult } from "../schemas"; + +export interface RuntimeManager { + disable(): void; + waitUntil(date: Date): Promise; + waitForDuration(ms: number): Promise; + waitForTask(params: { id: string; ctx: TaskRunContext }): Promise; +} diff --git a/packages/core/src/v3/runtime/noopRuntimeManager.ts b/packages/core/src/v3/runtime/noopRuntimeManager.ts new file mode 100644 index 000000000..8472e4ada --- /dev/null +++ b/packages/core/src/v3/runtime/noopRuntimeManager.ts @@ -0,0 +1,20 @@ +import { TaskRunContext, TaskRunExecutionResult } from "../schemas"; +import { RuntimeManager } from "./manager"; + +export class NoopRuntimeManager implements RuntimeManager { + disable(): void { + // do nothing + } + + waitForDuration(ms: number): Promise { + return Promise.resolve(); + } + + waitUntil(date: Date): Promise { + return Promise.resolve(); + } + + waitForTask(params: { id: string; ctx: TaskRunContext }): Promise { + throw new Error("Method not implemented."); + } +} diff --git a/packages/core/src/v3/schemas/api.ts b/packages/core/src/v3/schemas/api.ts new file mode 100644 index 000000000..e03e57cb2 --- /dev/null +++ b/packages/core/src/v3/schemas/api.ts @@ -0,0 +1,53 @@ +import { z } from "zod"; +import { BackgroundWorkerMetadata } from "./resources"; + +export const WhoAmIResponseSchema = z.object({ + userId: z.string(), + email: z.string().email(), +}); + +export type WhoAmIResponse = z.infer; + +export const GetProjectDevResponse = z.object({ + apiKey: z.string(), + name: z.string(), +}); + +export type GetProjectDevResponse = z.infer; + +export const CreateBackgroundWorkerRequestBody = z.object({ + localOnly: z.boolean(), + metadata: BackgroundWorkerMetadata, +}); + +export type CreateBackgroundWorkerRequestBody = z.infer; + +export const CreateBackgroundWorkerResponse = z.object({ + id: z.string(), + version: z.string(), + contentHash: z.string(), +}); + +export type CreateBackgroundWorkerResponse = z.infer; + +export const BackgroundWorkerRecord = CreateBackgroundWorkerResponse; +export type BackgroundWorkerRecord = CreateBackgroundWorkerResponse; + +export const TriggerTaskRequestBody = z.object({ + payload: z.any(), + context: z.any(), + options: z + .object({ + parentAttempt: z.string().optional(), + lockToCurrentVersion: z.boolean().optional(), + }) + .optional(), +}); + +export type TriggerTaskRequestBody = z.infer; + +export const TriggerTaskResponse = z.object({ + id: z.string(), +}); + +export type TriggerTaskResponse = z.infer; diff --git a/packages/core/src/v3/schemas/common.ts b/packages/core/src/v3/schemas/common.ts new file mode 100644 index 000000000..27b433965 --- /dev/null +++ b/packages/core/src/v3/schemas/common.ts @@ -0,0 +1,145 @@ +import { z } from "zod"; + +export const TaskRunBuiltInError = z.object({ + type: z.literal("BUILT_IN_ERROR"), + name: z.string(), + message: z.string(), + stackTrace: z.string(), +}); + +export type TaskRunBuiltInError = z.infer; + +export const TaskRunCustomErrorObject = z.object({ + type: z.literal("CUSTOM_ERROR"), + raw: z.string(), +}); + +export type TaskRunCustomErrorObject = z.infer; + +export const TaskRunStringError = z.object({ + type: z.literal("STRING_ERROR"), + raw: z.string(), +}); + +export type TaskRunStringError = z.infer; + +export const TaskRunErrorCodes = { + COULD_NOT_FIND_EXECUTOR: "COULD_NOT_FIND_EXECUTOR", +} as const; + +export const TaskRunInternalError = z.object({ + type: z.literal("INTERNAL_ERROR"), + code: z.enum(["COULD_NOT_FIND_EXECUTOR"]), +}); + +export type TaskRunInternalError = z.infer; + +export const TaskRunError = z.discriminatedUnion("type", [ + TaskRunBuiltInError, + TaskRunCustomErrorObject, + TaskRunStringError, + TaskRunInternalError, +]); + +export type TaskRunError = z.infer; + +export const TaskRun = z.object({ + id: z.string(), + payload: z.string(), + payloadType: z.string(), + context: z.any(), + tags: z.array(z.string()), + createdAt: z.coerce.date(), +}); + +export type TaskRun = z.infer; + +export const TaskRunExecutionTask = z.object({ + id: z.string(), + filePath: z.string(), + exportName: z.string(), +}); + +export type TaskRunExecutionTask = z.infer; + +export const TaskRunExecutionAttempt = z.object({ + id: z.string(), + number: z.number(), + startedAt: z.coerce.date(), + backgroundWorkerId: z.string(), + backgroundWorkerTaskId: z.string(), + status: z.string(), +}); + +export type TaskRunExecutionAttempt = z.infer; + +export const TaskRunExecutionEnvironment = z.object({ + id: z.string(), + slug: z.string(), + type: z.enum(["PRODUCTION", "STAGING", "DEVELOPMENT", "PREVIEW"]), +}); + +export type TaskRunExecutionEnvironment = z.infer; + +export const TaskRunExecutionOrganization = z.object({ + id: z.string(), + slug: z.string(), + name: z.string(), +}); + +export type TaskRunExecutionOrganization = z.infer; + +export const TaskRunExecutionProject = z.object({ + id: z.string(), + ref: z.string(), + slug: z.string(), + name: z.string(), +}); + +export type TaskRunExecutionProject = z.infer; + +export const TaskRunExecution = z.object({ + task: TaskRunExecutionTask, + attempt: TaskRunExecutionAttempt, + run: TaskRun, + environment: TaskRunExecutionEnvironment, + organization: TaskRunExecutionOrganization, + project: TaskRunExecutionProject, +}); + +export type TaskRunExecution = z.infer; + +export const TaskRunContext = z.object({ + task: TaskRunExecutionTask, + attempt: TaskRunExecutionAttempt.omit({ backgroundWorkerId: true, backgroundWorkerTaskId: true }), + run: TaskRun.omit({ payload: true, payloadType: true }), + environment: TaskRunExecutionEnvironment, + organization: TaskRunExecutionOrganization, + project: TaskRunExecutionProject, +}); + +export type TaskRunContext = z.infer; + +export const TaskRunFailedExecutionResult = z.object({ + ok: z.literal(false), + id: z.string(), + error: TaskRunError, +}); + +export type TaskRunFailedExecutionResult = z.infer; + +export const TaskRunSuccessfulExecutionResult = z.object({ + ok: z.literal(true), + id: z.string(), + output: z.string(), + outputType: z.string(), +}); + +export type TaskRunSuccessfulExecutionResult = z.infer; + +export const TaskRunExecutionResult = z.discriminatedUnion("ok", [ + TaskRunSuccessfulExecutionResult, + TaskRunFailedExecutionResult, +]); + +export type TaskRunExecutionResult = z.infer; diff --git a/packages/core/src/v3/schemas/index.ts b/packages/core/src/v3/schemas/index.ts index ef200075b..e9fba6c46 100644 --- a/packages/core/src/v3/schemas/index.ts +++ b/packages/core/src/v3/schemas/index.ts @@ -1,2 +1,5 @@ export * from "./tokens"; -export * from "./whoami"; +export * from "./api"; +export * from "./resources"; +export * from "./common"; +export * from "./messages"; diff --git a/packages/core/src/v3/schemas/messages.ts b/packages/core/src/v3/schemas/messages.ts new file mode 100644 index 000000000..c078dda13 --- /dev/null +++ b/packages/core/src/v3/schemas/messages.ts @@ -0,0 +1,101 @@ +import { z } from "zod"; +import { TaskRunExecutionResult, TaskRunExecution } from "./common"; +import { BackgroundWorkerRecord } from "./api"; + +export const TaskRunExecutionPayload = z.object({ + execution: TaskRunExecution, + traceContext: z.record(z.unknown()), +}); + +export type TaskRunExecutionPayload = z.infer; + +export const BackgroundWorkerServerMessages = z.discriminatedUnion("type", [ + z.object({ + type: z.literal("EXECUTE_RUNS"), + payloads: z.array(TaskRunExecutionPayload), + }), +]); + +export type BackgroundWorkerServerMessages = z.infer; + +export const serverWebsocketMessages = { + SERVER_READY: z.object({ + version: z.literal("v1").default("v1"), + id: z.string(), + }), + BACKGROUND_WORKER_MESSAGE: z.object({ + version: z.literal("v1").default("v1"), + backgroundWorkerId: z.string(), + data: BackgroundWorkerServerMessages, + }), +}; + +export const BackgroundWorkerClientMessages = z.discriminatedUnion("type", [ + z.object({ + version: z.literal("v1").default("v1"), + type: z.literal("TASK_RUN_COMPLETED"), + completion: TaskRunExecutionResult, + }), +]); + +export type BackgroundWorkerClientMessages = z.infer; + +export const clientWebsocketMessages = { + READY_FOR_TASKS: z.object({ + version: z.literal("v1").default("v1"), + backgroundWorkerId: z.string(), + }), + WORKER_DEPRECATED: z.object({ + version: z.literal("v1").default("v1"), + backgroundWorkerId: z.string(), + }), + BACKGROUND_WORKER_MESSAGE: z.object({ + version: z.literal("v1").default("v1"), + backgroundWorkerId: z.string(), + data: BackgroundWorkerClientMessages, + }), +}; + +export const workerToChildMessages = { + EXECUTE_TASK_RUN: z.object({ + version: z.literal("v1").default("v1"), + execution: TaskRunExecution, + traceContext: z.record(z.unknown()), + metadata: BackgroundWorkerRecord, + }), + TASK_RUN_COMPLETED: z.object({ + version: z.literal("v1").default("v1"), + completion: TaskRunExecutionResult, + execution: TaskRunExecution, + }), + CLEANUP: z.object({ + version: z.literal("v1").default("v1"), + flush: z.boolean().default(false), + }), +}; + +export const TaskMetadata = z.object({ + id: z.string(), + exportName: z.string(), + packageVersion: z.string(), +}); + +export type TaskMetadata = z.infer; + +export const TaskMetadataWithFilePath = TaskMetadata.extend({ + filePath: z.string(), +}); + +export type TaskMetadataWithFilePath = z.infer; + +export const childToWorkerMessages = { + TASK_RUN_COMPLETED: z.object({ + version: z.literal("v1").default("v1"), + result: TaskRunExecutionResult, + }), + TASKS_READY: z.object({ + version: z.literal("v1").default("v1"), + tasks: TaskMetadataWithFilePath.array(), + }), + READY_TO_DISPOSE: z.undefined(), +}; diff --git a/packages/core/src/v3/schemas/resources.ts b/packages/core/src/v3/schemas/resources.ts new file mode 100644 index 000000000..78aa73e77 --- /dev/null +++ b/packages/core/src/v3/schemas/resources.ts @@ -0,0 +1,18 @@ +import { z } from "zod"; + +export const TaskResource = z.object({ + id: z.string(), + filePath: z.string(), + exportName: z.string(), +}); + +export type TaskResource = z.infer; + +export const BackgroundWorkerMetadata = z.object({ + packageVersion: z.string(), + contentHash: z.string(), + cliPackageVersion: z.string(), + tasks: z.array(TaskResource), +}); + +export type BackgroundWorkerMetadata = z.infer; diff --git a/packages/core/src/v3/schemas/whoami.ts b/packages/core/src/v3/schemas/whoami.ts deleted file mode 100644 index 13c2351d9..000000000 --- a/packages/core/src/v3/schemas/whoami.ts +++ /dev/null @@ -1,8 +0,0 @@ -import { z } from "zod"; - -export const WhoAmIResponseSchema = z.object({ - userId: z.string(), - email: z.string().email(), -}); - -export type WhoAmIResponse = z.infer; diff --git a/packages/core/src/v3/semanticInternalAttributes.ts b/packages/core/src/v3/semanticInternalAttributes.ts new file mode 100644 index 000000000..2c6e7a127 --- /dev/null +++ b/packages/core/src/v3/semanticInternalAttributes.ts @@ -0,0 +1,26 @@ +export const SemanticInternalAttributes = { + ENVIRONMENT_ID: "ctx.environment.id", + ENVIRONMENT_TYPE: "ctx.environment.type", + ORGANIZATION_ID: "ctx.organization.id", + PROJECT_ID: "ctx.project.id", + PROJECT_REF: "ctx.project.ref", + ATTEMPT_ID: "ctx.attempt.id", + ATTEMP_NUMBER: "ctx.attempt.number", + RUN_ID: "ctx.run.id", + TASK_SLUG: "ctx.task.id", + TASK_PATH: "ctx.task.filePath", + TASK_EXPORT_NAME: "ctx.task.exportName", + SPAN_PARTIAL: "$span.partial", + SPAN_ID: "$span.span_id", + OUTPUT: "$output", + STYLE: "$style", + STYLE_ICON: "$style.icon", + METADATA: "$metadata", + TRIGGER: "$trigger", + PAYLOAD: "$payload", + WORKER_ID: "worker.id", + WORKER_VERSION: "worker.version", + CLI_VERSION: "cli.version", + SDK_VERSION: "sdk.version", + SDK_LANGUAGE: "sdk.language", +}; diff --git a/packages/core/src/v3/tasks/taskContextManager.ts b/packages/core/src/v3/tasks/taskContextManager.ts new file mode 100644 index 000000000..21fb065fe --- /dev/null +++ b/packages/core/src/v3/tasks/taskContextManager.ts @@ -0,0 +1,59 @@ +import { Attributes } from "@opentelemetry/api"; +import { BackgroundWorkerRecord, TaskRunContext } from "../schemas"; +import { SafeAsyncLocalStorage } from "../utils/safeAsyncLocalStorage"; +import { flattenAttributes } from "../utils/flattenAttributes"; + +type TaskContext = { + ctx: TaskRunContext; + payload: any; + worker: BackgroundWorkerRecord; +}; + +export class TaskContextManager { + private _storage: SafeAsyncLocalStorage = new SafeAsyncLocalStorage(); + + get isInsideTask(): boolean { + return this.#getStore() !== undefined; + } + + get ctx(): TaskRunContext | undefined { + const store = this.#getStore(); + return store?.ctx; + } + + get payload(): any | undefined { + const store = this.#getStore(); + return store?.payload; + } + + get worker(): BackgroundWorkerRecord | undefined { + const store = this.#getStore(); + return store?.worker; + } + + get attributes(): Attributes { + if (this.ctx) { + return { + ...flattenAttributes(this.ctx, "ctx"), + ...flattenAttributes(this.payload, "payload"), + ...flattenAttributes(this.worker, "worker"), + "service.name": this.ctx.task.id, + }; + } + + return {}; + } + + runWith Promise>( + context: TaskContext, + fn: R + ): Promise> { + return this._storage.runWith(context, fn); + } + + #getStore(): TaskContext | undefined { + return this._storage.getStore(); + } +} + +export const taskContextManager = new TaskContextManager(); diff --git a/packages/core/src/v3/tracer.ts b/packages/core/src/v3/tracer.ts new file mode 100644 index 000000000..8b223d6cb --- /dev/null +++ b/packages/core/src/v3/tracer.ts @@ -0,0 +1,102 @@ +import { + Context, + SpanOptions, + SpanStatusCode, + context, + propagation, + trace, + type Span, + type Tracer, +} from "@opentelemetry/api"; +import { Logger, logs } from "@opentelemetry/api-logs"; +import { SemanticInternalAttributes } from "./semanticInternalAttributes"; + +export type TriggerTracerConfig = + | { + name: string; + version: string; + } + | { + tracer: Tracer; + logger: Logger; + }; + +export class TriggerTracer { + constructor(private readonly _config: TriggerTracerConfig) {} + + private _tracer: Tracer | undefined; + private get tracer(): Tracer { + if (!this._tracer) { + if ("tracer" in this._config) return this._config.tracer; + + this._tracer = trace.getTracer(this._config.name, this._config.version); + } + + return this._tracer; + } + + private _logger: Logger | undefined; + private get logger(): Logger { + if (!this._logger) { + if ("logger" in this._config) return this._config.logger; + + this._logger = logs.getLogger(this._config.name, this._config.version); + } + + return this._logger; + } + + extractContext(traceContext?: Record) { + return propagation.extract(context.active(), traceContext ?? {}); + } + + startActiveSpan( + name: string, + fn: (span: Span) => Promise, + options?: SpanOptions, + ctx?: Context + ): Promise { + const parentContext = ctx ?? context.active(); + + const attributes = options?.attributes ?? {}; + + return this.tracer.startActiveSpan( + name, + { + ...options, + attributes, + }, + parentContext, + async (span) => { + this.tracer + .startSpan( + name, + { + ...options, + attributes: { + ...attributes, + [SemanticInternalAttributes.SPAN_PARTIAL]: true, + [SemanticInternalAttributes.SPAN_ID]: span.spanContext().spanId, + }, + }, + parentContext + ) + .end(); + + try { + return await fn(span); + } catch (e) { + if (typeof e === "string" || e instanceof Error) { + span.recordException(e); + } + + span.setStatus({ code: SpanStatusCode.ERROR }); + + throw e; + } finally { + span.end(); + } + } + ); + } +} diff --git a/packages/core/src/v3/utils/flattenAttributes.ts b/packages/core/src/v3/utils/flattenAttributes.ts new file mode 100644 index 000000000..44e2eaeb4 --- /dev/null +++ b/packages/core/src/v3/utils/flattenAttributes.ts @@ -0,0 +1,40 @@ +import { Attributes } from "@opentelemetry/api"; + +export function flattenAttributes( + obj: Record | null | undefined, + prefix?: string +): Attributes { + const result: Attributes = {}; + + // Check if obj is null or undefined + if (obj == null) { + return result; + } + + for (const [key, value] of Object.entries(obj)) { + const newPrefix = `${prefix ? `${prefix}.` : ""}${key}`; + if (Array.isArray(value)) { + for (let i = 0; i < value.length; i++) { + if (typeof value[i] === "object" && value[i] !== null) { + // update null check here as well + Object.assign(result, flattenAttributes(value[i], `${newPrefix}.${i}`)); + } else { + result[`${newPrefix}.${i}`] = value[i]; + } + } + } else if (isRecord(value)) { + // update null check here + Object.assign(result, flattenAttributes(value, newPrefix)); + } else { + if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") { + result[newPrefix] = value; + } + } + } + + return result; +} + +function isRecord(value: unknown): value is Record { + return value !== null && typeof value === "object" && !Array.isArray(value); +} diff --git a/packages/core/src/v3/utils/globals.ts b/packages/core/src/v3/utils/globals.ts new file mode 100644 index 000000000..4e8fc0757 --- /dev/null +++ b/packages/core/src/v3/utils/globals.ts @@ -0,0 +1,47 @@ +import type { RuntimeManager } from "../runtime/manager"; +import { _globalThis } from "./platform"; + +const GLOBAL_TRIGGER_DOT_DEV_KEY = Symbol.for(`dev.trigger.ts.api`); + +const _global = _globalThis as TriggerDotDevGlobal; + +export function registerGlobal( + type: Type, + instance: TriggerDotDevGlobalAPI[Type], + allowOverride = false +): boolean { + const api = (_global[GLOBAL_TRIGGER_DOT_DEV_KEY] = _global[GLOBAL_TRIGGER_DOT_DEV_KEY] ?? {}); + + if (!allowOverride && api[type]) { + // already registered an API of this type + const err = new Error(`trigger.dev: Attempted duplicate registration of API: ${type}`); + return false; + } + + api[type] = instance; + + return true; +} + +export function getGlobal( + type: Type +): TriggerDotDevGlobalAPI[Type] | undefined { + return _global[GLOBAL_TRIGGER_DOT_DEV_KEY]?.[type]; +} + +export function unregisterGlobal(type: keyof TriggerDotDevGlobalAPI) { + const api = _global[GLOBAL_TRIGGER_DOT_DEV_KEY]; + + if (api) { + delete api[type]; + } +} + +type TriggerDotDevGlobal = { + [GLOBAL_TRIGGER_DOT_DEV_KEY]?: TriggerDotDevGlobalAPI; +}; + +type TriggerDotDevGlobalAPI = { + runtime?: RuntimeManager; + logger?: any; +}; diff --git a/packages/core/src/v3/utils/platform.ts b/packages/core/src/v3/utils/platform.ts new file mode 100644 index 000000000..794e313ef --- /dev/null +++ b/packages/core/src/v3/utils/platform.ts @@ -0,0 +1 @@ +export const _globalThis = typeof globalThis === "object" ? globalThis : global; diff --git a/packages/core/src/v3/utils/safeAsyncLocalStorage.ts b/packages/core/src/v3/utils/safeAsyncLocalStorage.ts new file mode 100644 index 000000000..1fba2e646 --- /dev/null +++ b/packages/core/src/v3/utils/safeAsyncLocalStorage.ts @@ -0,0 +1,17 @@ +import { AsyncLocalStorage } from "node:async_hooks"; + +export class SafeAsyncLocalStorage { + private storage: AsyncLocalStorage; + + constructor() { + this.storage = new AsyncLocalStorage(); + } + + runWith Promise>(context: T, fn: R): Promise> { + return this.storage.run(context, fn); + } + + getStore(): T | undefined { + return this.storage.getStore(); + } +} diff --git a/packages/core/src/v3/zodMessageHandler.ts b/packages/core/src/v3/zodMessageHandler.ts new file mode 100644 index 000000000..599f56ea1 --- /dev/null +++ b/packages/core/src/v3/zodMessageHandler.ts @@ -0,0 +1,123 @@ +import { z } from "zod"; + +export interface ZodMessageCatalogSchema { + [key: string]: z.ZodFirstPartySchemaTypes | z.ZodDiscriminatedUnion; +} + +export type ZodMessageHandlers = Partial<{ + [K in keyof TCatalogSchema]: (payload: z.infer) => Promise; +}>; + +export type ZodMessageHandlerOptions = { + schema: TMessageCatalog; + messages?: ZodMessageHandlers; +}; + +type MessageFromSchema< + K extends keyof TMessageCatalog, + TMessageCatalog extends ZodMessageCatalogSchema, +> = { + type: K; + payload: z.input; +}; + +type MessageFromCatalog = { + [K in keyof TMessageCatalog]: MessageFromSchema; +}[keyof TMessageCatalog]; + +const messageSchema = z.object({ + version: z.literal("v1").default("v1"), + type: z.string(), + payload: z.unknown(), +}); + +export class ZodMessageHandler { + #schema: TMessageCatalog; + #handlers: ZodMessageHandlers | undefined; + + constructor(options: ZodMessageHandlerOptions) { + this.#schema = options.schema; + this.#handlers = options.messages; + } + + public async handleMessage(message: unknown) { + const parsedMessage = this.parseMessage(message); + + if (!this.#handlers) { + throw new Error("No handlers provided"); + } + + const handler = this.#handlers[parsedMessage.type]; + + if (!handler) { + throw new Error(`Unknown message type: ${String(parsedMessage.type)}`); + } + + await handler(parsedMessage.payload); + } + + public parseMessage(message: unknown): MessageFromCatalog { + const parsedMessage = messageSchema.safeParse(message); + + if (!parsedMessage.success) { + throw new Error(`Failed to parse message: ${JSON.stringify(parsedMessage.error)}`); + } + + const schema = this.#schema[parsedMessage.data.type]; + + if (!schema) { + throw new Error(`Unknown message type: ${parsedMessage.data.type}`); + } + + const parsedPayload = schema.safeParse(parsedMessage.data.payload); + + if (!parsedPayload.success) { + throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`); + } + + return { + type: parsedMessage.data.type, + payload: parsedPayload.data, + }; + } +} + +type ZodMessageSenderCallback = (message: { + type: keyof TMessageCatalog; + payload: z.infer; + version: "v1"; +}) => Promise; + +export type ZodMessageSenderOptions = { + schema: TMessageCatalog; + sender: ZodMessageSenderCallback; +}; + +export class ZodMessageSender { + #schema: TMessageCatalog; + #sender: ZodMessageSenderCallback; + + constructor(options: ZodMessageSenderOptions) { + this.#schema = options.schema; + this.#sender = options.sender; + } + + public async send( + type: K, + payload: z.input + ) { + const schema = this.#schema[type]; + + if (!schema) { + throw new Error(`Unknown message type: ${type as string}`); + } + + const parsedPayload = schema.safeParse(payload); + + if (!parsedPayload.success) { + throw new Error(`Failed to parse message payload: ${JSON.stringify(parsedPayload.error)}`); + } + + await this.#sender({ type, payload, version: "v1" }); + } +} diff --git a/packages/core/src/zodfetch.ts b/packages/core/src/zodfetch.ts new file mode 100644 index 000000000..68feed413 --- /dev/null +++ b/packages/core/src/zodfetch.ts @@ -0,0 +1,63 @@ +import { z } from "zod"; +import { context, propagation } from "@opentelemetry/api"; + +type ApiResult = + | { ok: true; data: TSuccessResult } + | { + ok: false; + error: string; + }; + +export async function zodfetch( + schema: z.Schema, + url: string, + requestInit?: RequestInit +): Promise> { + try { + const response = await fetch(url, requestInit); + + if ((!requestInit || requestInit.method === "GET") && response.status === 404) { + return { + ok: false, + error: `404: ${response.statusText}`, + }; + } + + if (response.status >= 400 && response.status < 500) { + const body = await response.json(); + if (!body.error) { + return { ok: false, error: "Something went wrong" }; + } + + return { ok: false, error: body.error }; + } + + if (response.status !== 200) { + return { + ok: false, + error: `Failed to fetch ${url}, got status code ${response.status}`, + }; + } + + const jsonBody = await response.json(); + const parsedResult = schema.safeParse(jsonBody); + + if (parsedResult.success) { + return { ok: true, data: parsedResult.data }; + } + + if ("error" in jsonBody) { + return { + ok: false, + error: typeof jsonBody.error === "string" ? jsonBody.error : JSON.stringify(jsonBody.error), + }; + } + + return { ok: false, error: parsedResult.error.message }; + } catch (error) { + return { + ok: false, + error: error instanceof Error ? error.message : JSON.stringify(error), + }; + } +} diff --git a/packages/core/tsup.config.ts b/packages/core/tsup.config.ts index 1914192e5..794b1e585 100644 --- a/packages/core/tsup.config.ts +++ b/packages/core/tsup.config.ts @@ -3,4 +3,5 @@ import { packageOptions, defineConfig } from "@trigger.dev/tsup"; export default defineConfig({ ...packageOptions, config: "tsconfig.build.json", + entry: ["./src/index.ts", "./src/v3/index.ts", "./src/v3/otel/index.ts"], }); diff --git a/packages/database/package.json b/packages/database/package.json index 6c82f4588..0850dfd74 100644 --- a/packages/database/package.json +++ b/packages/database/package.json @@ -17,6 +17,7 @@ "db:migrate:dev:create": "prisma migrate dev --create-only", "db:migrate:deploy": "prisma migrate deploy", "db:studio": "prisma studio", + "db:reset": "prisma migrate reset", "typecheck": "tsc --noEmit" } -} +} \ No newline at end of file diff --git a/packages/database/prisma/migrations/20240115160657_add_external_ref_to_projects/migration.sql b/packages/database/prisma/migrations/20240115160657_add_external_ref_to_projects/migration.sql new file mode 100644 index 000000000..9abbb931c --- /dev/null +++ b/packages/database/prisma/migrations/20240115160657_add_external_ref_to_projects/migration.sql @@ -0,0 +1,21 @@ +ALTER TABLE + "Project" +ADD + COLUMN "externalRef" TEXT; + +-- Populate the externalRef column +UPDATE + "Project" +SET + "externalRef" = MD5(RANDOM() :: text); + +-- Make the externalRef column non-nullable +ALTER TABLE + "Project" +ALTER COLUMN + "externalRef" +SET + NOT NULL; + +-- CreateIndex +CREATE UNIQUE INDEX "Project_externalRef_key" ON "Project"("externalRef"); \ No newline at end of file diff --git a/packages/database/prisma/migrations/20240116115734_add_background_worker_models/migration.sql b/packages/database/prisma/migrations/20240116115734_add_background_worker_models/migration.sql new file mode 100644 index 000000000..d46eece02 --- /dev/null +++ b/packages/database/prisma/migrations/20240116115734_add_background_worker_models/migration.sql @@ -0,0 +1,48 @@ +-- CreateTable +CREATE TABLE "BackgroundWorker" ( + "id" TEXT NOT NULL, + "projectId" TEXT NOT NULL, + "runtimeEnvironmentId" TEXT NOT NULL, + "version" TEXT NOT NULL, + "metadata" JSONB NOT NULL, + "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + "updatedAt" TIMESTAMP(3) NOT NULL, + + CONSTRAINT "BackgroundWorker_pkey" PRIMARY KEY ("id") +); + +-- CreateTable +CREATE TABLE "BackgroundWorkerTask" ( + "id" TEXT NOT NULL, + "slug" TEXT NOT NULL, + "filePath" TEXT NOT NULL, + "exportName" TEXT NOT NULL, + "workerId" TEXT NOT NULL, + "projectId" TEXT NOT NULL, + "runtimeEnvironmentId" TEXT NOT NULL, + "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + "updatedAt" TIMESTAMP(3) NOT NULL, + + CONSTRAINT "BackgroundWorkerTask_pkey" PRIMARY KEY ("id") +); + +-- CreateIndex +CREATE UNIQUE INDEX "BackgroundWorker_projectId_runtimeEnvironmentId_version_key" ON "BackgroundWorker"("projectId", "runtimeEnvironmentId", "version"); + +-- CreateIndex +CREATE UNIQUE INDEX "BackgroundWorkerTask_workerId_slug_key" ON "BackgroundWorkerTask"("workerId", "slug"); + +-- AddForeignKey +ALTER TABLE "BackgroundWorker" ADD CONSTRAINT "BackgroundWorker_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "Project"("id") ON DELETE CASCADE ON UPDATE CASCADE; + +-- AddForeignKey +ALTER TABLE "BackgroundWorker" ADD CONSTRAINT "BackgroundWorker_runtimeEnvironmentId_fkey" FOREIGN KEY ("runtimeEnvironmentId") REFERENCES "RuntimeEnvironment"("id") ON DELETE CASCADE ON UPDATE CASCADE; + +-- AddForeignKey +ALTER TABLE "BackgroundWorkerTask" ADD CONSTRAINT "BackgroundWorkerTask_workerId_fkey" FOREIGN KEY ("workerId") REFERENCES "BackgroundWorker"("id") ON DELETE CASCADE ON UPDATE CASCADE; + +-- AddForeignKey +ALTER TABLE "BackgroundWorkerTask" ADD CONSTRAINT "BackgroundWorkerTask_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "Project"("id") ON DELETE CASCADE ON UPDATE CASCADE; + +-- AddForeignKey +ALTER TABLE "BackgroundWorkerTask" ADD CONSTRAINT "BackgroundWorkerTask_runtimeEnvironmentId_fkey" FOREIGN KEY ("runtimeEnvironmentId") REFERENCES "RuntimeEnvironment"("id") ON DELETE CASCADE ON UPDATE CASCADE; diff --git a/packages/database/prisma/migrations/20240116163753_add_task_run_model/migration.sql b/packages/database/prisma/migrations/20240116163753_add_task_run_model/migration.sql new file mode 100644 index 000000000..455224903 --- /dev/null +++ b/packages/database/prisma/migrations/20240116163753_add_task_run_model/migration.sql @@ -0,0 +1,40 @@ +-- CreateEnum +CREATE TYPE "TaskRunStatus" AS ENUM ('PENDING', 'EXECUTING', 'PAUSED', 'FAILED', 'CANCELED', 'COMPLETED'); + +-- CreateTable +CREATE TABLE "TaskRun" ( + "id" TEXT NOT NULL, + "externalRef" TEXT NOT NULL, + "idempotencyKey" TEXT NOT NULL, + "payload" TEXT NOT NULL, + "payloadType" TEXT NOT NULL DEFAULT 'JSON', + "context" JSONB, + "status" "TaskRunStatus" NOT NULL DEFAULT 'PENDING', + "runtimeEnvironmentId" TEXT NOT NULL, + "projectId" TEXT NOT NULL, + "backgroundWorkerId" TEXT, + "backgroundWorkerTaskId" TEXT, + "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + "updatedAt" TIMESTAMP(3) NOT NULL, + "startedAt" TIMESTAMP(3), + + CONSTRAINT "TaskRun_pkey" PRIMARY KEY ("id") +); + +-- CreateIndex +CREATE UNIQUE INDEX "TaskRun_externalRef_key" ON "TaskRun"("externalRef"); + +-- CreateIndex +CREATE UNIQUE INDEX "TaskRun_runtimeEnvironmentId_idempotencyKey_key" ON "TaskRun"("runtimeEnvironmentId", "idempotencyKey"); + +-- AddForeignKey +ALTER TABLE "TaskRun" ADD CONSTRAINT "TaskRun_runtimeEnvironmentId_fkey" FOREIGN KEY ("runtimeEnvironmentId") REFERENCES "RuntimeEnvironment"("id") ON DELETE CASCADE ON UPDATE CASCADE; + +-- AddForeignKey +ALTER TABLE "TaskRun" ADD CONSTRAINT "TaskRun_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "Project"("id") ON DELETE CASCADE ON UPDATE CASCADE; + +-- AddForeignKey +ALTER TABLE "TaskRun" ADD CONSTRAINT "TaskRun_backgroundWorkerId_fkey" FOREIGN KEY ("backgroundWorkerId") REFERENCES "BackgroundWorker"("id") ON DELETE CASCADE ON UPDATE CASCADE; + +-- AddForeignKey +ALTER TABLE "TaskRun" ADD CONSTRAINT "TaskRun_backgroundWorkerTaskId_fkey" FOREIGN KEY ("backgroundWorkerTaskId") REFERENCES "BackgroundWorkerTask"("id") ON DELETE CASCADE ON UPDATE CASCADE; diff --git a/packages/database/prisma/migrations/20240116165157_add_task_identifier_to_task_runs/migration.sql b/packages/database/prisma/migrations/20240116165157_add_task_identifier_to_task_runs/migration.sql new file mode 100644 index 000000000..1d25cfa1d --- /dev/null +++ b/packages/database/prisma/migrations/20240116165157_add_task_identifier_to_task_runs/migration.sql @@ -0,0 +1,8 @@ +/* + Warnings: + + - Added the required column `taskIdentifier` to the `TaskRun` table without a default value. This is not possible if the table is not empty. + +*/ +-- AlterTable +ALTER TABLE "TaskRun" ADD COLUMN "taskIdentifier" TEXT NOT NULL; diff --git a/packages/database/prisma/migrations/20240118155050_add_completion_columns_to_task_runs/migration.sql b/packages/database/prisma/migrations/20240118155050_add_completion_columns_to_task_runs/migration.sql new file mode 100644 index 000000000..a77c7bf15 --- /dev/null +++ b/packages/database/prisma/migrations/20240118155050_add_completion_columns_to_task_runs/migration.sql @@ -0,0 +1,11 @@ +/* + Warnings: + + - Added the required column `output` to the `TaskRun` table without a default value. This is not possible if the table is not empty. + +*/ +-- AlterTable +ALTER TABLE "TaskRun" ADD COLUMN "completedAt" TIMESTAMP(3), +ADD COLUMN "error" TEXT, +ADD COLUMN "output" TEXT NOT NULL, +ADD COLUMN "outputType" TEXT NOT NULL DEFAULT 'JSON'; diff --git a/packages/database/prisma/migrations/20240118155439_change_payload_output_type_defaults/migration.sql b/packages/database/prisma/migrations/20240118155439_change_payload_output_type_defaults/migration.sql new file mode 100644 index 000000000..80d77d591 --- /dev/null +++ b/packages/database/prisma/migrations/20240118155439_change_payload_output_type_defaults/migration.sql @@ -0,0 +1,3 @@ +-- AlterTable +ALTER TABLE "TaskRun" ALTER COLUMN "payloadType" SET DEFAULT 'application/json', +ALTER COLUMN "outputType" SET DEFAULT 'application/json'; diff --git a/packages/database/prisma/migrations/20240118160024_make_task_run_output_optional/migration.sql b/packages/database/prisma/migrations/20240118160024_make_task_run_output_optional/migration.sql new file mode 100644 index 000000000..98acc48a9 --- /dev/null +++ b/packages/database/prisma/migrations/20240118160024_make_task_run_output_optional/migration.sql @@ -0,0 +1,2 @@ +-- AlterTable +ALTER TABLE "TaskRun" ALTER COLUMN "output" DROP NOT NULL; diff --git a/packages/database/prisma/migrations/20240123093539_add_content_hash_to_background_worker/migration.sql b/packages/database/prisma/migrations/20240123093539_add_content_hash_to_background_worker/migration.sql new file mode 100644 index 000000000..3073e1bdf --- /dev/null +++ b/packages/database/prisma/migrations/20240123093539_add_content_hash_to_background_worker/migration.sql @@ -0,0 +1,8 @@ +/* + Warnings: + + - Added the required column `contentHash` to the `BackgroundWorker` table without a default value. This is not possible if the table is not empty. + +*/ +-- AlterTable +ALTER TABLE "BackgroundWorker" ADD COLUMN "contentHash" TEXT NOT NULL; diff --git a/packages/database/prisma/migrations/20240123193905_restructure_task_runs_with_attempts/migration.sql b/packages/database/prisma/migrations/20240123193905_restructure_task_runs_with_attempts/migration.sql new file mode 100644 index 000000000..8f89887ca --- /dev/null +++ b/packages/database/prisma/migrations/20240123193905_restructure_task_runs_with_attempts/migration.sql @@ -0,0 +1,109 @@ +/* + Warnings: + + - You are about to drop the column `backgroundWorkerId` on the `TaskRun` table. All the data in the column will be lost. + - You are about to drop the column `backgroundWorkerTaskId` on the `TaskRun` table. All the data in the column will be lost. + - You are about to drop the column `completedAt` on the `TaskRun` table. All the data in the column will be lost. + - You are about to drop the column `error` on the `TaskRun` table. All the data in the column will be lost. + - You are about to drop the column `externalRef` on the `TaskRun` table. All the data in the column will be lost. + - You are about to drop the column `output` on the `TaskRun` table. All the data in the column will be lost. + - You are about to drop the column `outputType` on the `TaskRun` table. All the data in the column will be lost. + - You are about to drop the column `startedAt` on the `TaskRun` table. All the data in the column will be lost. + - You are about to drop the column `status` on the `TaskRun` table. All the data in the column will be lost. + +*/ +-- CreateEnum +CREATE TYPE "TaskRunAttemptStatus" AS ENUM ('PENDING', 'EXECUTING', 'PAUSED', 'FAILED', 'CANCELED', 'COMPLETED'); + +-- DropForeignKey +ALTER TABLE "TaskRun" DROP CONSTRAINT "TaskRun_backgroundWorkerId_fkey"; + +-- DropForeignKey +ALTER TABLE "TaskRun" DROP CONSTRAINT "TaskRun_backgroundWorkerTaskId_fkey"; + +-- DropIndex +DROP INDEX "TaskRun_externalRef_key"; + +-- AlterTable +ALTER TABLE "TaskRun" DROP COLUMN "backgroundWorkerId", +DROP COLUMN "backgroundWorkerTaskId", +DROP COLUMN "completedAt", +DROP COLUMN "error", +DROP COLUMN "externalRef", +DROP COLUMN "output", +DROP COLUMN "outputType", +DROP COLUMN "startedAt", +DROP COLUMN "status", +ADD COLUMN "lockedAt" TIMESTAMP(3), +ADD COLUMN "lockedById" TEXT; + +-- DropEnum +DROP TYPE "TaskRunStatus"; + +-- CreateTable +CREATE TABLE "TaskTag" ( + "id" TEXT NOT NULL, + "name" TEXT NOT NULL, + "projectId" TEXT NOT NULL, + "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + + CONSTRAINT "TaskTag_pkey" PRIMARY KEY ("id") +); + +-- CreateTable +CREATE TABLE "TaskRunAttempt" ( + "id" TEXT NOT NULL, + "number" INTEGER NOT NULL DEFAULT 0, + "taskRunId" TEXT NOT NULL, + "backgroundWorkerId" TEXT NOT NULL, + "backgroundWorkerTaskId" TEXT NOT NULL, + "status" "TaskRunAttemptStatus" NOT NULL DEFAULT 'PENDING', + "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + "updatedAt" TIMESTAMP(3) NOT NULL, + "startedAt" TIMESTAMP(3), + "completedAt" TIMESTAMP(3), + "error" TEXT, + "output" TEXT, + "outputType" TEXT NOT NULL DEFAULT 'application/json', + + CONSTRAINT "TaskRunAttempt_pkey" PRIMARY KEY ("id") +); + +-- CreateTable +CREATE TABLE "_TaskRunToTaskTag" ( + "A" TEXT NOT NULL, + "B" TEXT NOT NULL +); + +-- CreateIndex +CREATE UNIQUE INDEX "TaskTag_projectId_name_key" ON "TaskTag"("projectId", "name"); + +-- CreateIndex +CREATE UNIQUE INDEX "TaskRunAttempt_taskRunId_number_key" ON "TaskRunAttempt"("taskRunId", "number"); + +-- CreateIndex +CREATE UNIQUE INDEX "_TaskRunToTaskTag_AB_unique" ON "_TaskRunToTaskTag"("A", "B"); + +-- CreateIndex +CREATE INDEX "_TaskRunToTaskTag_B_index" ON "_TaskRunToTaskTag"("B"); + +-- AddForeignKey +ALTER TABLE "TaskRun" ADD CONSTRAINT "TaskRun_lockedById_fkey" FOREIGN KEY ("lockedById") REFERENCES "BackgroundWorkerTask"("id") ON DELETE SET NULL ON UPDATE CASCADE; + +-- AddForeignKey +ALTER TABLE "TaskTag" ADD CONSTRAINT "TaskTag_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "Project"("id") ON DELETE CASCADE ON UPDATE CASCADE; + +-- AddForeignKey +ALTER TABLE "TaskRunAttempt" ADD CONSTRAINT "TaskRunAttempt_taskRunId_fkey" FOREIGN KEY ("taskRunId") REFERENCES "TaskRun"("id") ON DELETE CASCADE ON UPDATE CASCADE; + +-- AddForeignKey +ALTER TABLE "TaskRunAttempt" ADD CONSTRAINT "TaskRunAttempt_backgroundWorkerId_fkey" FOREIGN KEY ("backgroundWorkerId") REFERENCES "BackgroundWorker"("id") ON DELETE CASCADE ON UPDATE CASCADE; + +-- AddForeignKey +ALTER TABLE "TaskRunAttempt" ADD CONSTRAINT "TaskRunAttempt_backgroundWorkerTaskId_fkey" FOREIGN KEY ("backgroundWorkerTaskId") REFERENCES "BackgroundWorkerTask"("id") ON DELETE CASCADE ON UPDATE CASCADE; + +-- AddForeignKey +ALTER TABLE "_TaskRunToTaskTag" ADD CONSTRAINT "_TaskRunToTaskTag_A_fkey" FOREIGN KEY ("A") REFERENCES "TaskRun"("id") ON DELETE CASCADE ON UPDATE CASCADE; + +-- AddForeignKey +ALTER TABLE "_TaskRunToTaskTag" ADD CONSTRAINT "_TaskRunToTaskTag_B_fkey" FOREIGN KEY ("B") REFERENCES "TaskTag"("id") ON DELETE CASCADE ON UPDATE CASCADE; diff --git a/packages/database/prisma/migrations/20240124104013_add_friendly_id_to_v3_tables/migration.sql b/packages/database/prisma/migrations/20240124104013_add_friendly_id_to_v3_tables/migration.sql new file mode 100644 index 000000000..8417b5e9b --- /dev/null +++ b/packages/database/prisma/migrations/20240124104013_add_friendly_id_to_v3_tables/migration.sql @@ -0,0 +1,44 @@ +/* + Warnings: + + - A unique constraint covering the columns `[friendlyId]` on the table `BackgroundWorker` will be added. If there are existing duplicate values, this will fail. + - A unique constraint covering the columns `[friendlyId]` on the table `BackgroundWorkerTask` will be added. If there are existing duplicate values, this will fail. + - A unique constraint covering the columns `[friendlyId]` on the table `TaskRun` will be added. If there are existing duplicate values, this will fail. + - A unique constraint covering the columns `[friendlyId]` on the table `TaskRunAttempt` will be added. If there are existing duplicate values, this will fail. + - A unique constraint covering the columns `[friendlyId]` on the table `TaskTag` will be added. If there are existing duplicate values, this will fail. + - Added the required column `friendlyId` to the `BackgroundWorker` table without a default value. This is not possible if the table is not empty. + - Added the required column `friendlyId` to the `BackgroundWorkerTask` table without a default value. This is not possible if the table is not empty. + - Added the required column `friendlyId` to the `TaskRun` table without a default value. This is not possible if the table is not empty. + - Added the required column `friendlyId` to the `TaskRunAttempt` table without a default value. This is not possible if the table is not empty. + - Added the required column `friendlyId` to the `TaskTag` table without a default value. This is not possible if the table is not empty. + +*/ +-- AlterTable +ALTER TABLE "BackgroundWorker" ADD COLUMN "friendlyId" TEXT NOT NULL; + +-- AlterTable +ALTER TABLE "BackgroundWorkerTask" ADD COLUMN "friendlyId" TEXT NOT NULL; + +-- AlterTable +ALTER TABLE "TaskRun" ADD COLUMN "friendlyId" TEXT NOT NULL; + +-- AlterTable +ALTER TABLE "TaskRunAttempt" ADD COLUMN "friendlyId" TEXT NOT NULL; + +-- AlterTable +ALTER TABLE "TaskTag" ADD COLUMN "friendlyId" TEXT NOT NULL; + +-- CreateIndex +CREATE UNIQUE INDEX "BackgroundWorker_friendlyId_key" ON "BackgroundWorker"("friendlyId"); + +-- CreateIndex +CREATE UNIQUE INDEX "BackgroundWorkerTask_friendlyId_key" ON "BackgroundWorkerTask"("friendlyId"); + +-- CreateIndex +CREATE UNIQUE INDEX "TaskRun_friendlyId_key" ON "TaskRun"("friendlyId"); + +-- CreateIndex +CREATE UNIQUE INDEX "TaskRunAttempt_friendlyId_key" ON "TaskRunAttempt"("friendlyId"); + +-- CreateIndex +CREATE UNIQUE INDEX "TaskTag_friendlyId_key" ON "TaskTag"("friendlyId"); diff --git a/packages/database/prisma/migrations/20240124122331_convert_task_attempt_error_to_json/migration.sql b/packages/database/prisma/migrations/20240124122331_convert_task_attempt_error_to_json/migration.sql new file mode 100644 index 000000000..33969225f --- /dev/null +++ b/packages/database/prisma/migrations/20240124122331_convert_task_attempt_error_to_json/migration.sql @@ -0,0 +1,9 @@ +/* + Warnings: + + - The `error` column on the `TaskRunAttempt` table would be dropped and recreated. This will lead to data loss if there is data in the column. + +*/ +-- AlterTable +ALTER TABLE "TaskRunAttempt" DROP COLUMN "error", +ADD COLUMN "error" JSONB; diff --git a/packages/database/prisma/migrations/20240126130139_add_locked_to_version_to_task_runs/migration.sql b/packages/database/prisma/migrations/20240126130139_add_locked_to_version_to_task_runs/migration.sql new file mode 100644 index 000000000..9e4a7af70 --- /dev/null +++ b/packages/database/prisma/migrations/20240126130139_add_locked_to_version_to_task_runs/migration.sql @@ -0,0 +1,5 @@ +-- AlterTable +ALTER TABLE "TaskRun" ADD COLUMN "lockedToVersionId" TEXT; + +-- AddForeignKey +ALTER TABLE "TaskRun" ADD CONSTRAINT "TaskRun_lockedToVersionId_fkey" FOREIGN KEY ("lockedToVersionId") REFERENCES "BackgroundWorker"("id") ON DELETE SET NULL ON UPDATE CASCADE; diff --git a/packages/database/prisma/migrations/20240126204658_add_parent_attempt_to_task_runs/migration.sql b/packages/database/prisma/migrations/20240126204658_add_parent_attempt_to_task_runs/migration.sql new file mode 100644 index 000000000..7e1a216b5 --- /dev/null +++ b/packages/database/prisma/migrations/20240126204658_add_parent_attempt_to_task_runs/migration.sql @@ -0,0 +1,5 @@ +-- AlterTable +ALTER TABLE "TaskRun" ADD COLUMN "parentAttemptId" TEXT; + +-- AddForeignKey +ALTER TABLE "TaskRun" ADD CONSTRAINT "TaskRun_parentAttemptId_fkey" FOREIGN KEY ("parentAttemptId") REFERENCES "TaskRunAttempt"("id") ON DELETE SET NULL ON UPDATE CASCADE; diff --git a/packages/database/prisma/migrations/20240130205109_add_trace_context_to_task_run/migration.sql b/packages/database/prisma/migrations/20240130205109_add_trace_context_to_task_run/migration.sql new file mode 100644 index 000000000..ab270ea5a --- /dev/null +++ b/packages/database/prisma/migrations/20240130205109_add_trace_context_to_task_run/migration.sql @@ -0,0 +1,2 @@ +-- AlterTable +ALTER TABLE "TaskRun" ADD COLUMN "traceContext" JSONB; diff --git a/packages/database/prisma/migrations/20240207174021_add_unified_task_event_model/migration.sql b/packages/database/prisma/migrations/20240207174021_add_unified_task_event_model/migration.sql new file mode 100644 index 000000000..21dc269f0 --- /dev/null +++ b/packages/database/prisma/migrations/20240207174021_add_unified_task_event_model/migration.sql @@ -0,0 +1,51 @@ +-- CreateEnum +CREATE TYPE "TaskEventLevel" AS ENUM ('TRACE', 'DEBUG', 'LOG', 'INFO', 'WARN', 'ERROR'); + +-- CreateEnum +CREATE TYPE "TaskEventKind" AS ENUM ('UNSPECIFIED', 'INTERNAL', 'SERVER', 'CLIENT', 'PRODUCER', 'CONSUMER', 'UNRECOGNIZED', 'LOG'); + +-- CreateEnum +CREATE TYPE "TaskEventStatus" AS ENUM ('UNSET', 'OK', 'ERROR', 'UNRECOGNIZED'); + +-- CreateTable +CREATE TABLE "TaskEvent" ( + "id" TEXT NOT NULL, + "message" TEXT NOT NULL, + "traceId" TEXT NOT NULL, + "spanId" TEXT NOT NULL, + "parentId" TEXT, + "tracestate" TEXT, + "serviceName" TEXT NOT NULL, + "serviceNamespace" TEXT NOT NULL, + "level" "TaskEventLevel" NOT NULL DEFAULT 'TRACE', + "kind" "TaskEventKind" NOT NULL DEFAULT 'INTERNAL', + "status" "TaskEventStatus" NOT NULL DEFAULT 'UNSET', + "links" JSONB, + "events" JSONB, + "startTime" TIMESTAMP(3) NOT NULL, + "durationInMs" INTEGER NOT NULL DEFAULT 0, + "attemptId" TEXT NOT NULL, + "attemptNumber" INTEGER NOT NULL, + "environmentId" TEXT NOT NULL, + "environmentSlug" TEXT NOT NULL, + "environmentType" "RuntimeEnvironmentType" NOT NULL, + "organizationId" TEXT NOT NULL, + "organizationName" TEXT NOT NULL, + "organizationSlug" TEXT NOT NULL, + "projectId" TEXT NOT NULL, + "projectName" TEXT NOT NULL, + "projectRef" TEXT NOT NULL, + "runId" TEXT NOT NULL, + "taskId" TEXT NOT NULL, + "taskSlug" TEXT NOT NULL, + "taskPath" TEXT NOT NULL, + "taskExportName" TEXT NOT NULL, + "metadataStringKeys" TEXT[], + "metadataStringValues" TEXT[], + "metadataNumberKeys" TEXT[], + "metadataNumberValues" INTEGER[], + "metadataBooleanKeys" TEXT[], + "metadataBooleanValues" BOOLEAN[], + + CONSTRAINT "TaskEvent_pkey" PRIMARY KEY ("id") +); diff --git a/packages/database/prisma/migrations/20240207195749_move_event_data_to_json/migration.sql b/packages/database/prisma/migrations/20240207195749_move_event_data_to_json/migration.sql new file mode 100644 index 000000000..57718e707 --- /dev/null +++ b/packages/database/prisma/migrations/20240207195749_move_event_data_to_json/migration.sql @@ -0,0 +1,20 @@ +/* + Warnings: + + - You are about to drop the column `metadataBooleanKeys` on the `TaskEvent` table. All the data in the column will be lost. + - You are about to drop the column `metadataBooleanValues` on the `TaskEvent` table. All the data in the column will be lost. + - You are about to drop the column `metadataNumberKeys` on the `TaskEvent` table. All the data in the column will be lost. + - You are about to drop the column `metadataNumberValues` on the `TaskEvent` table. All the data in the column will be lost. + - You are about to drop the column `metadataStringKeys` on the `TaskEvent` table. All the data in the column will be lost. + - You are about to drop the column `metadataStringValues` on the `TaskEvent` table. All the data in the column will be lost. + - Added the required column `eventData` to the `TaskEvent` table without a default value. This is not possible if the table is not empty. + +*/ +-- AlterTable +ALTER TABLE "TaskEvent" DROP COLUMN "metadataBooleanKeys", +DROP COLUMN "metadataBooleanValues", +DROP COLUMN "metadataNumberKeys", +DROP COLUMN "metadataNumberValues", +DROP COLUMN "metadataStringKeys", +DROP COLUMN "metadataStringValues", +ADD COLUMN "eventData" JSONB NOT NULL; diff --git a/packages/database/prisma/migrations/20240208124114_changes_to_the_task_event_schema/migration.sql b/packages/database/prisma/migrations/20240208124114_changes_to_the_task_event_schema/migration.sql new file mode 100644 index 000000000..37ddf0847 --- /dev/null +++ b/packages/database/prisma/migrations/20240208124114_changes_to_the_task_event_schema/migration.sql @@ -0,0 +1,29 @@ +/* + Warnings: + + - You are about to drop the column `attemptNumber` on the `TaskEvent` table. All the data in the column will be lost. + - You are about to drop the column `environmentSlug` on the `TaskEvent` table. All the data in the column will be lost. + - You are about to drop the column `eventData` on the `TaskEvent` table. All the data in the column will be lost. + - You are about to drop the column `organizationName` on the `TaskEvent` table. All the data in the column will be lost. + - You are about to drop the column `organizationSlug` on the `TaskEvent` table. All the data in the column will be lost. + - You are about to drop the column `projectName` on the `TaskEvent` table. All the data in the column will be lost. + - You are about to drop the column `taskId` on the `TaskEvent` table. All the data in the column will be lost. + - Added the required column `properties` to the `TaskEvent` table without a default value. This is not possible if the table is not empty. + +*/ +-- AlterTable +ALTER TABLE "TaskEvent" DROP COLUMN "attemptNumber", +DROP COLUMN "environmentSlug", +DROP COLUMN "eventData", +DROP COLUMN "organizationName", +DROP COLUMN "organizationSlug", +DROP COLUMN "projectName", +DROP COLUMN "taskId", +ADD COLUMN "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, +ADD COLUMN "isError" BOOLEAN NOT NULL DEFAULT false, +ADD COLUMN "isPartial" BOOLEAN NOT NULL DEFAULT false, +ADD COLUMN "metadata" JSONB, +ADD COLUMN "output" JSONB, +ADD COLUMN "properties" JSONB NOT NULL, +ADD COLUMN "style" JSONB, +ALTER COLUMN "attemptId" DROP NOT NULL; diff --git a/packages/database/prisma/migrations/20240208133710_use_bigint_for_event_durations/migration.sql b/packages/database/prisma/migrations/20240208133710_use_bigint_for_event_durations/migration.sql new file mode 100644 index 000000000..4e5554e4f --- /dev/null +++ b/packages/database/prisma/migrations/20240208133710_use_bigint_for_event_durations/migration.sql @@ -0,0 +1,9 @@ +/* + Warnings: + + - You are about to drop the column `durationInMs` on the `TaskEvent` table. All the data in the column will be lost. + +*/ +-- AlterTable +ALTER TABLE "TaskEvent" DROP COLUMN "durationInMs", +ADD COLUMN "duration" BIGINT NOT NULL DEFAULT 0; diff --git a/packages/database/prisma/migrations/20240209110749_convert_task_fields_to_optional/migration.sql b/packages/database/prisma/migrations/20240209110749_convert_task_fields_to_optional/migration.sql new file mode 100644 index 000000000..8d8f8d6a7 --- /dev/null +++ b/packages/database/prisma/migrations/20240209110749_convert_task_fields_to_optional/migration.sql @@ -0,0 +1,3 @@ +-- AlterTable +ALTER TABLE "TaskEvent" ALTER COLUMN "taskPath" DROP NOT NULL, +ALTER COLUMN "taskExportName" DROP NOT NULL; diff --git a/packages/database/prisma/migrations/20240209121123_add_task_run_trace_columns/migration.sql b/packages/database/prisma/migrations/20240209121123_add_task_run_trace_columns/migration.sql new file mode 100644 index 000000000..caabbc232 --- /dev/null +++ b/packages/database/prisma/migrations/20240209121123_add_task_run_trace_columns/migration.sql @@ -0,0 +1,10 @@ +/* + Warnings: + + - Added the required column `spanId` to the `TaskRun` table without a default value. This is not possible if the table is not empty. + - Added the required column `traceId` to the `TaskRun` table without a default value. This is not possible if the table is not empty. + +*/ +-- AlterTable +ALTER TABLE "TaskRun" ADD COLUMN "spanId" TEXT NOT NULL, +ADD COLUMN "traceId" TEXT NOT NULL; diff --git a/packages/database/prisma/migrations/20240209153602_add_worker_columns_to_task_event/migration.sql b/packages/database/prisma/migrations/20240209153602_add_worker_columns_to_task_event/migration.sql new file mode 100644 index 000000000..64d05a4ce --- /dev/null +++ b/packages/database/prisma/migrations/20240209153602_add_worker_columns_to_task_event/migration.sql @@ -0,0 +1,3 @@ +-- AlterTable +ALTER TABLE "TaskEvent" ADD COLUMN "workerId" TEXT, +ADD COLUMN "workerVersion" TEXT; diff --git a/packages/database/prisma/schema.prisma b/packages/database/prisma/schema.prisma index 86bcd1737..181530235 100644 --- a/packages/database/prisma/schema.prisma +++ b/packages/database/prisma/schema.prisma @@ -382,6 +382,9 @@ model RuntimeEnvironment { keyValueItems KeyValueItem[] webhookEnvironments WebhookEnvironment[] webhookRequestDeliveries WebhookRequestDelivery[] + backgroundWorkers BackgroundWorker[] + backgroundWorkerTasks BackgroundWorkerTask[] + TaskRun TaskRun[] @@unique([projectId, slug, orgMemberId]) @@unique([projectId, shortcode]) @@ -399,6 +402,8 @@ model Project { slug String @unique name String + externalRef String @unique + organization Organization @relation(fields: [organizationId], references: [id], onDelete: Cascade, onUpdate: Cascade) organizationId String @@ -406,15 +411,19 @@ model Project { updatedAt DateTime @updatedAt deletedAt DateTime? - environments RuntimeEnvironment[] - endpoints Endpoint[] - jobs Job[] - jobVersion JobVersion[] - events EventRecord[] - runs JobRun[] - sources TriggerSource[] - httpEndpoints TriggerHttpEndpoint[] - webhooks Webhook[] + environments RuntimeEnvironment[] + endpoints Endpoint[] + jobs Job[] + jobVersion JobVersion[] + events EventRecord[] + runs JobRun[] + sources TriggerSource[] + httpEndpoints TriggerHttpEndpoint[] + webhooks Webhook[] + backgroundWorkers BackgroundWorker[] + backgroundWorkerTasks BackgroundWorkerTask[] + TaskRun TaskRun[] + TaskTag TaskTag[] } model Endpoint { @@ -1465,3 +1474,248 @@ model DataMigration { updatedAt DateTime @updatedAt completedAt DateTime? } + +// ==================================================== +// v3 Models +// ==================================================== +model BackgroundWorker { + id String @id @default(cuid()) + + friendlyId String @unique + + contentHash String + + project Project @relation(fields: [projectId], references: [id], onDelete: Cascade, onUpdate: Cascade) + projectId String + + runtimeEnvironment RuntimeEnvironment @relation(fields: [runtimeEnvironmentId], references: [id], onDelete: Cascade, onUpdate: Cascade) + runtimeEnvironmentId String + + version String + metadata Json + + createdAt DateTime @default(now()) + updatedAt DateTime @updatedAt + + tasks BackgroundWorkerTask[] + attempts TaskRunAttempt[] + lockedRuns TaskRun[] + + @@unique([projectId, runtimeEnvironmentId, version]) +} + +model BackgroundWorkerTask { + id String @id @default(cuid()) + slug String + + friendlyId String @unique + + filePath String + exportName String + + worker BackgroundWorker @relation(fields: [workerId], references: [id], onDelete: Cascade, onUpdate: Cascade) + workerId String + + project Project @relation(fields: [projectId], references: [id], onDelete: Cascade, onUpdate: Cascade) + projectId String + + runtimeEnvironment RuntimeEnvironment @relation(fields: [runtimeEnvironmentId], references: [id], onDelete: Cascade, onUpdate: Cascade) + runtimeEnvironmentId String + + createdAt DateTime @default(now()) + updatedAt DateTime @updatedAt + + attempts TaskRunAttempt[] + runs TaskRun[] + + @@unique([workerId, slug]) +} + +model TaskRun { + id String @id @default(cuid()) + + friendlyId String @unique + + idempotencyKey String + taskIdentifier String + + payload String + payloadType String @default("application/json") + context Json? + traceContext Json? + + traceId String + spanId String + + runtimeEnvironment RuntimeEnvironment @relation(fields: [runtimeEnvironmentId], references: [id], onDelete: Cascade, onUpdate: Cascade) + runtimeEnvironmentId String + + project Project @relation(fields: [projectId], references: [id], onDelete: Cascade, onUpdate: Cascade) + projectId String + + createdAt DateTime @default(now()) + updatedAt DateTime @updatedAt + + attempts TaskRunAttempt[] @relation("attempts") + tags TaskTag[] + + lockedAt DateTime? + lockedBy BackgroundWorkerTask? @relation(fields: [lockedById], references: [id]) + lockedById String? + + lockedToVersion BackgroundWorker? @relation(fields: [lockedToVersionId], references: [id]) + lockedToVersionId String? + + parentAttempt TaskRunAttempt? @relation("parentAttempt", fields: [parentAttemptId], references: [id]) + parentAttemptId String? + + @@unique([runtimeEnvironmentId, idempotencyKey]) +} + +model TaskTag { + id String @id @default(cuid()) + name String + + friendlyId String @unique + + runs TaskRun[] + + project Project @relation(fields: [projectId], references: [id], onDelete: Cascade, onUpdate: Cascade) + projectId String + + createdAt DateTime @default(now()) + + @@unique([projectId, name]) +} + +model TaskRunAttempt { + id String @id @default(cuid()) + number Int @default(0) + + friendlyId String @unique + + taskRun TaskRun @relation("attempts", fields: [taskRunId], references: [id], onDelete: Cascade, onUpdate: Cascade) + taskRunId String + + backgroundWorker BackgroundWorker @relation(fields: [backgroundWorkerId], references: [id], onDelete: Cascade, onUpdate: Cascade) + backgroundWorkerId String + + backgroundWorkerTask BackgroundWorkerTask @relation(fields: [backgroundWorkerTaskId], references: [id], onDelete: Cascade, onUpdate: Cascade) + backgroundWorkerTaskId String + + status TaskRunAttemptStatus @default(PENDING) + + createdAt DateTime @default(now()) + updatedAt DateTime @updatedAt + + startedAt DateTime? + completedAt DateTime? + + error Json? + output String? + outputType String @default("application/json") + + triggeredRuns TaskRun[] @relation("parentAttempt") + + @@unique([taskRunId, number]) +} + +enum TaskRunAttemptStatus { + PENDING + EXECUTING + PAUSED + FAILED + CANCELED + COMPLETED +} + +/// This is the unified otel span/log model that will eventually be replaced by clickhouse +model TaskEvent { + id String @id @default(cuid()) + + /// This matches the span name for a trace event, or the log body for a log event + message String + + traceId String + spanId String + parentId String? + tracestate String? + + isError Boolean @default(false) + isPartial Boolean @default(false) + + serviceName String + serviceNamespace String + + level TaskEventLevel @default(TRACE) + kind TaskEventKind @default(INTERNAL) + status TaskEventStatus @default(UNSET) + + links Json? + events Json? + + startTime DateTime + + /// This is the duration of the event in nanoseconds + duration BigInt @default(0) + + attemptId String? + + environmentId String + environmentType RuntimeEnvironmentType + + organizationId String + + projectId String + projectRef String + + runId String + + taskSlug String + taskPath String? + taskExportName String? + + workerId String? + workerVersion String? + + /// This represents all the span attributes available, like http.status_code, and special attributes like $style.icon, $output, $metadata.payload.userId, as it's used for searching and filtering + properties Json + + /// This represents all span attributes in the $metadata namespace, like $metadata.payload + metadata Json? + + /// This represents all span attributes in the $style namespace, like $style + style Json? + + /// This represents all span attributes in the $output namespace, like $output + output Json? + + createdAt DateTime @default(now()) +} + +enum TaskEventLevel { + TRACE + DEBUG + LOG + INFO + WARN + ERROR +} + +enum TaskEventKind { + UNSPECIFIED + INTERNAL + SERVER + CLIENT + PRODUCER + CONSUMER + UNRECOGNIZED + LOG +} + +enum TaskEventStatus { + UNSET + OK + ERROR + UNRECOGNIZED +} diff --git a/packages/otlp-importer/.gitignore b/packages/otlp-importer/.gitignore new file mode 100644 index 000000000..c82683cbd --- /dev/null +++ b/packages/otlp-importer/.gitignore @@ -0,0 +1,2 @@ +src/generated/* +!src/generated/.gitkeep diff --git a/packages/otlp-importer/CHANGELOG.md b/packages/otlp-importer/CHANGELOG.md new file mode 100644 index 000000000..e69de29bb diff --git a/packages/otlp-importer/LICENSE b/packages/otlp-importer/LICENSE new file mode 100644 index 000000000..e51e7b10a --- /dev/null +++ b/packages/otlp-importer/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 Trigger.dev + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packages/otlp-importer/README.md b/packages/otlp-importer/README.md new file mode 100644 index 000000000..0e5f7e507 --- /dev/null +++ b/packages/otlp-importer/README.md @@ -0,0 +1,54 @@ +## Getting started + +Install dependencies: + +```sh +brew install protobuf +``` + +# Submodules + +**Submodule is always pointing to certain revision number. So updating the submodule repo will not have impact on your code. +Knowing this if you want to change the submodule to point to a different version (when for example proto has changed) here is how to do it:** + +## Updating submodule to point to certain revision number + +1. Make sure you are in the same folder as this instruction + +2. Update your submodules by running this command + + ```shell script + git submodule sync --recursive + git submodule update --init --recursive + ``` + +3. Find the SHA which you want to update to and copy it (the long one) + the latest sha when this guide was written is `c451441d7b73f702d1647574c730daf7786f188c` + +4. Enter a submodule directory from this directory + + ```shell script + cd protos + ``` + +5. Updates files in the submodule tree to given commit: + + ```shell script + git checkout -q + ``` + +6. Return to the main directory: + + ```shell script + cd ../ + ``` + +7. Please run `git status` you should see something like `Head detached at`. This is correct, go to next step + +8. Now thing which is very important. You have to commit this to apply these changes + + ```shell script + git commit -am "chore: updating protos submodule for @trigger.dev/otlp-importer" + ``` + +9. If you look now at git log you will notice that the folder `protos` has been changed and it will show what was the previous sha and what is current one. diff --git a/packages/otlp-importer/jest.config.js b/packages/otlp-importer/jest.config.js new file mode 100644 index 000000000..e21cd117c --- /dev/null +++ b/packages/otlp-importer/jest.config.js @@ -0,0 +1,8 @@ +module.exports = { + moduleFileExtensions: ["ts", "tsx", "js"], + transform: { + "^.+\\.(ts|tsx)$": "ts-jest", + }, + testMatch: ["/test/**/*.ts?(x)", "/test/**/?(*.)+(spec|test).ts?(x)"], + testEnvironment: "node", +}; diff --git a/packages/otlp-importer/package.json b/packages/otlp-importer/package.json new file mode 100644 index 000000000..a5d13fc27 --- /dev/null +++ b/packages/otlp-importer/package.json @@ -0,0 +1,58 @@ +{ + "name": "@trigger.dev/otlp-importer", + "version": "2.3.11", + "description": "OpenTelemetry OTLP Importer for Node.js written in TypeScript", + "license": "MIT", + "main": "./dist/index.js", + "types": "./dist/index.d.ts", + "module": "./dist/index.mjs", + "publishConfig": { + "access": "public" + }, + "files": [ + "dist" + ], + "exports": { + ".": { + "import": { + "types": "./dist/index.d.mts", + "default": "./dist/index.mjs" + }, + "require": "./dist/index.js", + "types": "./dist/index.d.ts" + }, + "./package.json": "./package.json" + }, + "sideEffects": false, + "scripts": { + "prepublishOnly": "npm run build", + "clean": "rimraf dist", + "build": "npm run clean && npm run protos && npm run build:tsup", + "build:tsup": "tsup --dts-resolve", + "generate": "npm run protos", + "protos": "npm run submodule && npm run protos:generate", + "protos:generate": "./scripts/generate-protos.sh", + "submodule": "git submodule sync --recursive && git submodule update --init --recursive", + "typecheck": "tsc --noEmit", + "test": "jest" + }, + "devDependencies": { + "@trigger.dev/tsconfig": "workspace:*", + "@trigger.dev/tsup": "workspace:*", + "@types/jest": "^29.5.3", + "@types/node": "16", + "jest": "^29.6.2", + "rimraf": "^3.0.2", + "ts-jest": "^29.1.1", + "ts-proto": "^1.167.3", + "tsup": "^8.0.1", + "typescript": "^5.3.0" + }, + "engines": { + "node": ">=18.0.0" + }, + "dependencies": { + "long": "^5.2.3", + "protobufjs": "^7.2.6" + } +} \ No newline at end of file diff --git a/packages/otlp-importer/protos b/packages/otlp-importer/protos new file mode 160000 index 000000000..c451441d7 --- /dev/null +++ b/packages/otlp-importer/protos @@ -0,0 +1 @@ +Subproject commit c451441d7b73f702d1647574c730daf7786f188c diff --git a/packages/otlp-importer/scripts/generate-protos.sh b/packages/otlp-importer/scripts/generate-protos.sh new file mode 100755 index 000000000..6770a4966 --- /dev/null +++ b/packages/otlp-importer/scripts/generate-protos.sh @@ -0,0 +1,43 @@ +#!/bin/bash + +# Define the application root and directories for generated files and proto files +appRoot=$(pwd) +generatedPath="$appRoot/src/generated" +protosPath="$appRoot/protos" +pluginPath="$appRoot/node_modules/.bin/protoc-gen-ts_proto" + +# Ensure the generated directory exists +mkdir -p "$generatedPath" + +# Define proto files +protos=( + "opentelemetry/proto/common/v1/common.proto" + "opentelemetry/proto/resource/v1/resource.proto" + "opentelemetry/proto/trace/v1/trace.proto" + "opentelemetry/proto/collector/trace/v1/trace_service.proto" + "opentelemetry/proto/metrics/v1/metrics.proto" + "opentelemetry/proto/collector/metrics/v1/metrics_service.proto" + "opentelemetry/proto/logs/v1/logs.proto" + "opentelemetry/proto/collector/logs/v1/logs_service.proto" +) + +# Use protoc with ts-proto to generate TypeScript files from proto files +for proto in "${protos[@]}"; do + protoc --plugin=protoc-gen-ts_proto="$pluginPath" \ + --ts_proto_out="$generatedPath" \ + --proto_path="$protosPath" \ + --ts_proto_opt=forceLong=bigint \ + --ts_proto_opt=esModuleInterop=true \ + --ts_proto_opt=env=node \ + --ts_proto_opt=removeEnumPrefix=true \ + --ts_proto_opt=lowerCaseServiceMethods=true \ + --ts_proto_opt=oneof=unions \ + "$protosPath/$proto" +done + +# Check for errors +if [ $? -eq 0 ]; then + echo "TypeScript files generated successfully." +else + echo "An error occurred during generation." +fi diff --git a/packages/otlp-importer/src/generated/.gitkeep b/packages/otlp-importer/src/generated/.gitkeep new file mode 100644 index 000000000..e69de29bb diff --git a/packages/otlp-importer/src/index.ts b/packages/otlp-importer/src/index.ts new file mode 100644 index 000000000..7401431a8 --- /dev/null +++ b/packages/otlp-importer/src/index.ts @@ -0,0 +1,59 @@ +import { + ExportTracePartialSuccess, + ExportTraceServiceRequest, + ExportTraceServiceResponse, +} from "./generated/opentelemetry/proto/collector/trace/v1/trace_service"; + +import { + ExportLogsPartialSuccess, + ExportLogsServiceRequest, + ExportLogsServiceResponse, +} from "./generated/opentelemetry/proto/collector/logs/v1/logs_service"; + +import type { + AnyValue, + KeyValue, + KeyValueList, +} from "./generated/opentelemetry/proto/common/v1/common"; +import { + LogRecord, + ResourceLogs, + ScopeLogs, + SeverityNumber, +} from "./generated/opentelemetry/proto/logs/v1/logs"; +import { Resource } from "./generated/opentelemetry/proto/resource/v1/resource"; +import { + ResourceSpans, + ScopeSpans, + Span, + SpanFlags, + Span_Event, + Span_Link, + Span_SpanKind, + Status, + Status_StatusCode, +} from "./generated/opentelemetry/proto/trace/v1/trace"; + +export { + LogRecord, + Resource, + ResourceLogs, + ResourceSpans, + ScopeLogs, + ScopeSpans, + SeverityNumber, + Span, + SpanFlags, + Span_Event, + Span_Link, + Span_SpanKind, + Status, + Status_StatusCode, + type AnyValue, + type KeyValue, + type KeyValueList, +}; + +export { ExportTracePartialSuccess, ExportTraceServiceRequest, ExportTraceServiceResponse }; + +export { ExportLogsPartialSuccess, ExportLogsServiceRequest, ExportLogsServiceResponse }; diff --git a/packages/otlp-importer/test/index.test.ts b/packages/otlp-importer/test/index.test.ts new file mode 100644 index 000000000..1c54f6708 --- /dev/null +++ b/packages/otlp-importer/test/index.test.ts @@ -0,0 +1,5 @@ +describe("foo", () => { + it("Should work", () => { + expect(true).toBe(true); + }); +}); diff --git a/packages/otlp-importer/tsconfig.build.json b/packages/otlp-importer/tsconfig.build.json new file mode 100644 index 000000000..f444efc19 --- /dev/null +++ b/packages/otlp-importer/tsconfig.build.json @@ -0,0 +1,11 @@ +{ + "extends": "@trigger.dev/tsconfig/node18.json", + "include": ["src/globals.d.ts", "./src/**/*.ts", "tsup.config.ts"], + "compilerOptions": { + "experimentalDecorators": true, + "emitDecoratorMetadata": true, + "declaration": false, + "declarationMap": false + }, + "exclude": ["node_modules"] +} diff --git a/packages/otlp-importer/tsconfig.json b/packages/otlp-importer/tsconfig.json new file mode 100644 index 000000000..aa110b9ab --- /dev/null +++ b/packages/otlp-importer/tsconfig.json @@ -0,0 +1,17 @@ +{ + "extends": "@trigger.dev/tsconfig/node18.json", + "include": ["src/globals.d.ts", "./src/**/*.ts", "tsup.config.ts", "./test/**/*.ts"], + "compilerOptions": { + "experimentalDecorators": true, + "emitDecoratorMetadata": true, + "declaration": false, + "declarationMap": false, + "types": ["jest"], + "lib": ["DOM", "DOM.Iterable"], + "paths": { + "@trigger.dev/tsup/*": ["../../config-packages/tsup/src/*"], + "@trigger.dev/tsup": ["../../config-packages/tsup/src/index"] + } + }, + "exclude": ["node_modules"] +} diff --git a/packages/otlp-importer/tsup.config.ts b/packages/otlp-importer/tsup.config.ts new file mode 100644 index 000000000..54b9cf2ef --- /dev/null +++ b/packages/otlp-importer/tsup.config.ts @@ -0,0 +1,7 @@ +import { packageOptions, defineConfig } from "@trigger.dev/tsup"; + +export default defineConfig({ + ...packageOptions, + config: "tsconfig.build.json", + entry: ["./src/index.ts"], +}); diff --git a/packages/trigger-sdk/package.json b/packages/trigger-sdk/package.json index 4b65511af..c33b3d1c5 100644 --- a/packages/trigger-sdk/package.json +++ b/packages/trigger-sdk/package.json @@ -21,8 +21,23 @@ "require": "./dist/index.js", "types": "./dist/index.d.ts" }, + "./v3": { + "import": { + "types": "./dist/v3/index.d.mts", + "default": "./dist/v3/index.mjs" + }, + "require": "./dist/v3/index.js", + "types": "./dist/v3/index.d.ts" + }, "./package.json": "./package.json" }, + "typesVersions": { + "*": { + "v3": [ + "./dist/v3/index.d.ts" + ] + } + }, "scripts": { "clean": "rimraf dist", "build": "npm run clean && npm run build:tsup", @@ -32,6 +47,9 @@ "dependencies": { "@trigger.dev/core": "workspace:^2.3.18", "@trigger.dev/core-backend": "workspace:^2.3.18", + "@opentelemetry/api": "^1.7.0", + "@opentelemetry/api-logs": "^0.48.0", + "@opentelemetry/semantic-conventions": "^1.21.0", "chalk": "^5.2.0", "cronstrue": "^2.21.0", "debug": "^4.3.4", @@ -48,6 +66,7 @@ }, "devDependencies": { "@trigger.dev/tsconfig": "workspace:*", + "@trigger.dev/tsup": "workspace:*", "@types/debug": "^4.1.7", "@types/node": "18", "@types/slug": "^5.0.3", @@ -56,7 +75,6 @@ "encoding": "^0.1.13", "rimraf": "^3.0.2", "tsup": "^8.0.1", - "@trigger.dev/tsup": "workspace:*", "typed-emitter": "^2.1.0", "typescript": "^5.3.0" }, diff --git a/packages/trigger-sdk/src/v3/config.ts b/packages/trigger-sdk/src/v3/config.ts new file mode 100644 index 000000000..4145cbc87 --- /dev/null +++ b/packages/trigger-sdk/src/v3/config.ts @@ -0,0 +1,5 @@ +export interface Config { + project: string; + triggerDirectories?: string | string[]; + triggerUrl?: string; +} diff --git a/packages/trigger-sdk/src/v3/index.ts b/packages/trigger-sdk/src/v3/index.ts new file mode 100644 index 000000000..394b44946 --- /dev/null +++ b/packages/trigger-sdk/src/v3/index.ts @@ -0,0 +1,8 @@ +export * from "./tasks"; +export * from "./config"; +export * from "./wait"; + +import type { Context } from "./shared"; +export type { Context }; + +export { logger } from "@trigger.dev/core/v3"; diff --git a/packages/trigger-sdk/src/v3/shared.ts b/packages/trigger-sdk/src/v3/shared.ts new file mode 100644 index 000000000..dc695effe --- /dev/null +++ b/packages/trigger-sdk/src/v3/shared.ts @@ -0,0 +1,242 @@ +import { SpanKind } from "@opentelemetry/api"; +import { SemanticAttributes } from "@opentelemetry/semantic-conventions"; +import { + ApiClient, + TaskRunContext, + createErrorTaskError, + runtime, + taskContextManager, +} from "@trigger.dev/core/v3"; +import * as packageJson from "../../package.json"; +import { tracer } from "./tracer"; + +export type PreparedItems = Record; + +export type RunFnParams = Prettify<{ + payload: TPayload; + ctx: Context; + prepared: TPreparedItems; +}>; + +export type PrepareFnParams = Prettify<{ + payload: TPayload; + ctx: Context; +}>; + +export type Context = TaskRunContext; + +export type SuccessFnParams = RunFnParams< + TPayload, + TPreparedItems +> & + Prettify<{ + output: TOutput; + }>; + +export type ErrorFnParams = RunFnParams< + TPayload, + TPreparedItems +> & + Prettify<{ + error: unknown; + }>; + +type RateLimitOptions = + | { + hourly: number; + } + | { + daily: number; + } + | { + monthly: number; + }; + +type QueueOptions = { + concurrencyLimit?: number; + rateLimit?: RateLimitOptions; +}; + +export type Queue = { + name: string; +} & QueueOptions; + +export function queue(options: { name: string } & QueueOptions): Queue { + return options; +} + +export type RunOptions = { + id: string; + retry?: { + maxAttempts?: number; + }; + queue?: QueueOptions | Queue; + machine?: { + image?: "ffmpeg" | "puppeteer"; + cpu?: number; + memory?: number; + }; + run: (params: RunFnParams) => Promise; + before?: (params: PrepareFnParams) => Promise; + onSuccess?: (params: SuccessFnParams) => Promise; + onError?: (params: ErrorFnParams) => Promise; +}; + +type InvokeHandle = { + id: string; +}; + +type InvokeBatchHandle = { + batchId: string; + itemCount: number; +}; + +export type Task = { + trigger: (params: { payload: TInput; options?: TaskRunOptions }) => Promise; + batchTrigger: (params: { + items: { payload: TInput; options?: TaskRunOptions }[]; + batchOptions?: BatchRunOptions; + }) => Promise; + triggerAndWait: (params: { payload: TInput; options?: TaskRunOptions }) => Promise; + batchTriggerAndWait: (params: { + items: { payload: TInput; options?: TaskRunOptions }[]; + batchOptions?: BatchRunOptions; + }) => Promise; +}; + +type TaskRunOptions = { + idempotencyKey?: string; + maxAttempts?: number; + startAt?: Date; + startAfter?: number; + queue?: TaskRunConcurrencyOptions; + concurrencyKey?: string; +}; + +type TaskRunConcurrencyOptions = Queue; + +type BatchRunOptions = TaskRunOptions & { + maxConcurrency?: number; +}; + +export type Prettify = { + [K in keyof T]: T[K]; +} & {}; + +export type DynamicBaseOptions = { + id: string; +}; + +export function createTask( + params: RunOptions +): Task { + const task: Task = { + trigger: async ({ payload }) => { + const ctx = taskContextManager.ctx; + + const apiClient = initializeApiClient(); + + const handle = await tracer.startActiveSpan( + `${params.id} trigger`, + async (span) => { + const response = await apiClient.triggerTask(params.id, { + payload: payload, + options: { + parentAttempt: ctx?.attempt.id, + lockToCurrentVersion: false, // Don't lock to current version because we're not waiting for it to finish + }, + }); + + if (!response.ok) { + throw new Error(response.error); + } + + span.setAttribute("trigger.id", response.data.id); + + return response.data; + }, + { + kind: SpanKind.PRODUCER, + attributes: { [SemanticAttributes.MESSAGING_OPERATION]: "publish" }, + } + ); + + return handle; + }, + batchTrigger: async ({ items }) => { + const batchId = "batch_1234"; + //todo actually call the API to start the task group + return { + batchId, + itemCount: items.length, + }; + }, + triggerAndWait: async ({ payload, options }) => { + const ctx = taskContextManager.ctx; + + if (!ctx) { + throw new Error("triggerAndWait can only be used from inside a task.run()"); + } + + const apiClient = initializeApiClient(); + + return await tracer.startActiveSpan( + `${params.id} trigger`, + async (span) => { + span.setAttribute(SemanticAttributes.MESSAGING_OPERATION, "publish"); + + const response = await apiClient.triggerTask(params.id, { + payload: payload, + options: { + parentAttempt: ctx.attempt.id, + lockToCurrentVersion: true, // Lock to current version because we're waiting for it to finish + }, + }); + + if (!response.ok) { + throw new Error(response.error); + } + + const result = await runtime.waitForTask({ + id: response.data.id, + ctx, + }); + + if (!result.ok) { + throw createErrorTaskError(result.error); + } + + return JSON.parse(result.output); + }, + { kind: SpanKind.PRODUCER } + ); + }, + batchTriggerAndWait: async ({ items }) => { + //pseudo-code for throwing an error if not called from inside a Run + if (!process.env.IS_TRIGGER_ENV) { + throw new Error("batchTriggerAndWait can only be used from inside a run()"); + } + + //todo do an API call that creates a TaskGroup + //then waits for it to finish + //then return the result + throw new Error("not implemented"); + }, + }; + + Object.defineProperty(task, "__trigger", { + value: { + id: params.id, + run: params.run, + packageVersion: packageJson.version, + }, + enumerable: false, + }); + + return task; +} + +// TODO: make this cross-runtime compatible +function initializeApiClient() { + return new ApiClient(process.env.TRIGGER_API_URL!, process.env.TRIGGER_API_KEY!); +} diff --git a/packages/trigger-sdk/src/v3/tasks.ts b/packages/trigger-sdk/src/v3/tasks.ts new file mode 100644 index 000000000..099c43d58 --- /dev/null +++ b/packages/trigger-sdk/src/v3/tasks.ts @@ -0,0 +1,7 @@ +import { PreparedItems, RunOptions, Task, createTask } from "./shared"; + +export function task( + options: RunOptions +): Task { + return createTask(options); +} diff --git a/packages/trigger-sdk/src/v3/tracer.ts b/packages/trigger-sdk/src/v3/tracer.ts new file mode 100644 index 000000000..916127322 --- /dev/null +++ b/packages/trigger-sdk/src/v3/tracer.ts @@ -0,0 +1,4 @@ +import { TriggerTracer } from "@trigger.dev/core/v3"; +import * as packageJson from "../../package.json"; + +export const tracer = new TriggerTracer({ name: "@trigger.dev/sdk", version: packageJson.version }); diff --git a/packages/trigger-sdk/src/v3/wait.ts b/packages/trigger-sdk/src/v3/wait.ts new file mode 100644 index 000000000..3ac5952d3 --- /dev/null +++ b/packages/trigger-sdk/src/v3/wait.ts @@ -0,0 +1,73 @@ +import { runtime } from "@trigger.dev/core/v3"; + +export type WaitOptions = + | { + seconds: number; + } + | { + minutes: number; + } + | { + hours: number; + } + | { + days: number; + } + | { + weeks: number; + } + | { + months: number; + } + | { + years: number; + }; + +export const wait = { + for: async (options: WaitOptions) => { + const durationInMs = calculateDurationInMs(options); + + await runtime.waitForDuration(durationInMs); + }, + until: async (options: { date: Date; throwIfInThePast?: boolean }) => {}, + forRequest: async (params: RequestOptions): Promise => { + return {} as any; + }, +}; + +function calculateDurationInMs(options: WaitOptions): number { + if ("seconds" in options) { + return options.seconds * 1000; + } + + if ("minutes" in options) { + return options.minutes * 1000 * 60; + } + + if ("hours" in options) { + return options.hours * 1000 * 60 * 60; + } + + if ("days" in options) { + return options.days * 1000 * 60 * 60 * 24; + } + + if ("weeks" in options) { + return options.weeks * 1000 * 60 * 60 * 24 * 7; + } + + if ("months" in options) { + return options.months * 1000 * 60 * 60 * 24 * 30; + } + + if ("years" in options) { + return options.years * 1000 * 60 * 60 * 24 * 365; + } + + throw new Error("Invalid options"); +} + +type RequestOptions = { + to: (url: string) => Promise; + timeout: WaitOptions; +}; diff --git a/packages/trigger-sdk/tsup.config.ts b/packages/trigger-sdk/tsup.config.ts index 1d1b59a08..e21191453 100644 --- a/packages/trigger-sdk/tsup.config.ts +++ b/packages/trigger-sdk/tsup.config.ts @@ -1,3 +1,9 @@ -import { defineConfigPackage } from "@trigger.dev/tsup"; +import { Options, defineConfig as defineConfigTSUP } from "tsup"; +import { packageOptions } from "@trigger.dev/tsup"; -export default defineConfigPackage; +const options: Options = { + ...packageOptions, + entry: ["./src/index.ts", "./src/v3/index.ts"], +}; + +export default defineConfigTSUP(options); diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 2fbbfa8ea..00d79ed45 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -96,6 +96,15 @@ importers: '@highlight-run/react': ^3.2.0 '@internationalized/date': ^3.5.1 '@lezer/highlight': ^1.1.6 + '@opentelemetry/api': ^1.7.0 + '@opentelemetry/core': ^1.21.0 + '@opentelemetry/exporter-logs-otlp-http': ^0.48.0 + '@opentelemetry/exporter-trace-otlp-http': ^0.48.0 + '@opentelemetry/resources': ^1.21.0 + '@opentelemetry/sdk-logs': ^0.48.0 + '@opentelemetry/sdk-trace-base': ^1.21.0 + '@opentelemetry/sdk-trace-node': ^1.21.0 + '@opentelemetry/semantic-conventions': ^1.21.0 '@radix-ui/react-alert-dialog': ^1.0.4 '@radix-ui/react-dialog': ^1.0.3 '@radix-ui/react-label': ^2.0.1 @@ -142,6 +151,7 @@ importers: '@trigger.dev/core': workspace:* '@trigger.dev/core-backend': workspace:* '@trigger.dev/database': workspace:* + '@trigger.dev/otlp-importer': workspace:* '@trigger.dev/sdk': workspace:* '@trigger.dev/tailwind-config': workspace:* '@trigger.dev/yalt': workspace:* @@ -165,6 +175,7 @@ importers: '@types/simple-oauth2': ^5.0.4 '@types/slug': ^5.0.3 '@types/tar': ^6.1.4 + '@types/ws': ^8.5.3 '@typescript-eslint/eslint-plugin': ^5.59.6 '@typescript-eslint/parser': ^5.59.6 '@uiw/react-codemirror': ^4.19.5 @@ -181,6 +192,7 @@ importers: esbuild: ^0.15.10 eslint: ^8.24.0 eslint-config-prettier: ^8.5.0 + evt: ^2.4.13 express: ^4.18.1 framer-motion: ^10.12.11 graphile-worker: ^0.13.0 @@ -239,6 +251,8 @@ importers: tsconfig-paths: ^3.14.1 typescript: ^5.1.6 ulid: ^2.3.0 + ulidx: ^2.2.1 + ws: ^8.11.0 zod: 3.22.3 zod-error: 1.5.0 zod-validation-error: ^1.5.0 @@ -261,6 +275,15 @@ importers: '@highlight-run/react': 3.2.0_biqbaboplfbrettd7655fr4n2y '@internationalized/date': 3.5.1 '@lezer/highlight': 1.1.6 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-logs-otlp-http': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-http': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-logs': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-node': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 '@radix-ui/react-alert-dialog': 1.0.4_daadhm4ohxobgnrt365as5bhny '@radix-ui/react-dialog': 1.0.3_bwbutfx4xj25dewzmxso6o3wga '@radix-ui/react-label': 2.0.1_biqbaboplfbrettd7655fr4n2y @@ -288,6 +311,7 @@ importers: '@trigger.dev/core': link:../../packages/core '@trigger.dev/core-backend': link:../../packages/core-backend '@trigger.dev/database': link:../../packages/database + '@trigger.dev/otlp-importer': link:../../packages/otlp-importer '@trigger.dev/sdk': link:../../packages/trigger-sdk '@trigger.dev/yalt': link:../../packages/yalt '@types/pg': 8.6.6 @@ -300,6 +324,7 @@ importers: cross-env: 7.0.3 cuid: 2.1.8 emails: link:../../packages/emails + evt: 2.4.13 express: 4.18.2 framer-motion: 10.12.11_biqbaboplfbrettd7655fr4n2y graphile-worker: 0.13.0 @@ -344,6 +369,8 @@ importers: tailwindcss-animate: 1.0.5_tailwindcss@3.3.2 tiny-invariant: 1.3.1 ulid: 2.3.0 + ulidx: 2.2.1 + ws: 8.12.0 zod: 3.22.3 zod-error: 1.5.0 zod-validation-error: 1.5.0_zod@3.22.3 @@ -387,6 +414,7 @@ importers: '@types/simple-oauth2': 5.0.4 '@types/slug': 5.0.3 '@types/tar': 6.1.4 + '@types/ws': 8.5.4 '@typescript-eslint/eslint-plugin': 5.59.6_7rqy3acf7ittvjpliyki2mhtka '@typescript-eslint/parser': 5.59.6_a3vgt4pcadxos4gox5ryckz5rq autoprefixer: 10.4.13_postcss@8.4.21 @@ -443,11 +471,11 @@ importers: config-packages/tsup: specifiers: '@types/node': '18' - esbuild: ^0.19.2 + esbuild: ^0.19.11 tsup: ^8.0.1 typescript: ^5.3.0 dependencies: - esbuild: 0.19.2 + esbuild: 0.19.11 tsup: 8.0.1_a5ztaafw5l4qfghy2hjjuynb34_typescript@5.3.2 devDependencies: '@types/node': 18.17.1 @@ -829,6 +857,7 @@ importers: console-table-printer: ^2.11.2 degit: ^2.8.4 dotenv: ^16.3.1 + esbuild: ^0.19.11 execa: ^7.0.0 gradient-string: ^2.0.2 inquirer: ^9.1.4 @@ -867,6 +896,7 @@ importers: console-table-printer: 2.11.2 degit: 2.8.4 dotenv: 16.3.1 + esbuild: 0.19.11 execa: 7.0.0 gradient-string: 2.0.2 inquirer: 9.1.4 @@ -906,13 +936,29 @@ importers: packages/cli-v3: specifiers: '@clack/prompts': ^0.7.0 + '@opentelemetry/api': ^1.7.0 + '@opentelemetry/api-logs': ^0.48.0 + '@opentelemetry/auto-instrumentations-node': ^0.40.3 + '@opentelemetry/exporter-collector': ^0.25.0 + '@opentelemetry/exporter-logs-otlp-http': ^0.48.0 + '@opentelemetry/exporter-trace-otlp-http': ^0.48.0 + '@opentelemetry/instrumentation': ^0.48.0 + '@opentelemetry/instrumentation-fetch': ^0.48.0 + '@opentelemetry/instrumentation-http': ^0.48.0 + '@opentelemetry/resources': ^1.21.0 + '@opentelemetry/sdk-logs': ^0.48.0 + '@opentelemetry/sdk-node': ^0.48.0 + '@opentelemetry/sdk-trace-base': ^1.21.0 + '@opentelemetry/sdk-trace-node': ^1.21.0 + '@opentelemetry/semantic-conventions': ^1.21.0 '@trigger.dev/core': workspace:* '@trigger.dev/tsconfig': workspace:* '@types/degit': ^2.8.3 '@types/gradient-string': ^1.1.2 '@types/mock-fs': ^4.13.1 - '@types/node': '16' - '@types/node-fetch': ^2.6.2 + '@types/node': '18' + '@types/object-hash': ^3.0.6 + '@types/react': ^18.2.48 '@types/ws': ^8.5.3 chalk: ^5.2.0 chokidar: ^3.5.3 @@ -920,30 +966,59 @@ importers: commander: ^9.4.1 degit: ^2.8.4 dotenv: ^16.3.1 + esbuild: ^0.19.11 + evt: ^2.4.13 execa: ^7.0.0 + find-up: ^7.0.0 gradient-string: ^2.0.2 + import-meta-resolve: ^4.0.0 + ink: ^4.4.1 liquidjs: ^10.9.2 mock-fs: ^5.2.0 nanoid: ^4.0.2 node-fetch: ^3.3.0 npm-check-updates: ^16.12.2 + npm-run-all: ^4.1.5 + object-hash: ^3.0.0 open: ^10.0.3 p-retry: ^6.1.0 + p-throttle: ^6.1.0 + partysocket: ^0.0.17 posthog-node: ^3.1.1 proxy-agent: ^6.3.0 + react: ^18.2.0 + react-error-boundary: ^4.0.12 rimraf: ^3.0.2 simple-git: ^3.19.0 - tsup: ^6.5.0 + source-map: ^0.7.4 + supports-color: ^9.4.0 + terminal-link: ^3.0.0 + tsup: ^8.0.1 type-fest: ^3.6.0 - typescript: ^4.9.5 + typescript: ^5.3.3 update-check: ^1.5.4 url: ^0.11.1 vitest: ^0.34.4 - ws: ^8.11.0 + ws: ^8.12.0 xdg-app-paths: ^8.3.0 zod: 3.22.3 dependencies: '@clack/prompts': 0.7.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.48.0 + '@opentelemetry/auto-instrumentations-node': 0.40.3_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/exporter-collector': 0.25.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-logs-otlp-http': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-http': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.48.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-fetch': 0.48.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-http': 0.48.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-logs': 0.48.0_wj3rtarwgmsxddfed6zfae5bhe + '@opentelemetry/sdk-node': 0.48.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/sdk-trace-base': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-node': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 '@trigger.dev/core': link:../core '@types/degit': 2.8.3 chalk: 5.3.0 @@ -952,16 +1027,29 @@ importers: commander: 9.5.0 degit: 2.8.4 dotenv: 16.3.1 + esbuild: 0.19.11 + evt: 2.4.13 execa: 7.0.0 + find-up: 7.0.0 gradient-string: 2.0.2 + import-meta-resolve: 4.0.0 + ink: 4.4.1_7kh72gklg5qjlh5zc6s6v3p6v4 liquidjs: 10.9.3 mock-fs: 5.2.0 nanoid: 4.0.2 node-fetch: 3.3.0 - npm-check-updates: 16.12.3 + npm-check-updates: 16.12.3_supports-color@9.4.0 + object-hash: 3.0.0 + p-throttle: 6.1.0 + partysocket: 0.0.17 posthog-node: 3.1.3 - proxy-agent: 6.3.0 - simple-git: 3.19.0 + proxy-agent: 6.3.0_supports-color@9.4.0 + react: 18.2.0 + react-error-boundary: 4.0.12_react@18.2.0 + simple-git: 3.19.0_supports-color@9.4.0 + source-map: 0.7.4 + supports-color: 9.4.0 + terminal-link: 3.0.0 update-check: 1.5.4 url: 0.11.1 ws: 8.12.0 @@ -970,20 +1058,37 @@ importers: '@trigger.dev/tsconfig': link:../../config-packages/tsconfig '@types/gradient-string': 1.1.2 '@types/mock-fs': 4.13.1 - '@types/node': 16.18.11 - '@types/node-fetch': 2.6.4 + '@types/node': 18.17.1 + '@types/object-hash': 3.0.6 + '@types/react': 18.2.48 '@types/ws': 8.5.4 + npm-run-all: 4.1.5 open: 10.0.3 p-retry: 6.1.0 rimraf: 3.0.2 - tsup: 6.6.3_typescript@4.9.5 + tsup: 8.0.1_a5ztaafw5l4qfghy2hjjuynb34_7y24qjorrsjk6wdsbbcqvo2unm type-fest: 3.13.0 - typescript: 4.9.5 - vitest: 0.34.4 + typescript: 5.3.3 + vitest: 0.34.4_supports-color@9.4.0 xdg-app-paths: 8.3.0 packages/core: specifiers: + '@opentelemetry/api': ^1.7.0 + '@opentelemetry/api-logs': ^0.48.0 + '@opentelemetry/auto-instrumentations-node': ^0.40.3 + '@opentelemetry/exporter-collector': ^0.25.0 + '@opentelemetry/exporter-logs-otlp-http': ^0.48.0 + '@opentelemetry/exporter-trace-otlp-http': ^0.48.0 + '@opentelemetry/instrumentation': ^0.48.0 + '@opentelemetry/instrumentation-fetch': ^0.48.0 + '@opentelemetry/instrumentation-http': ^0.48.0 + '@opentelemetry/resources': ^1.21.0 + '@opentelemetry/sdk-logs': ^0.48.0 + '@opentelemetry/sdk-node': ^0.48.0 + '@opentelemetry/sdk-trace-base': ^1.21.0 + '@opentelemetry/sdk-trace-node': ^1.21.0 + '@opentelemetry/semantic-conventions': ^1.21.0 '@trigger.dev/tsconfig': workspace:* '@trigger.dev/tsup': workspace:* '@types/jest': ^29.5.3 @@ -997,6 +1102,21 @@ importers: zod: 3.22.3 zod-error: 1.5.0 dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.48.0 + '@opentelemetry/auto-instrumentations-node': 0.40.3_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-collector': 0.25.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-logs-otlp-http': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-http': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-fetch': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-http': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-logs': 0.48.0_wj3rtarwgmsxddfed6zfae5bhe + '@opentelemetry/sdk-node': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-node': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 ulidx: 2.2.1 zod: 3.22.3 zod-error: 1.5.0 @@ -1238,6 +1358,35 @@ importers: tsx: 3.12.2 typescript: 5.3.2 + packages/otlp-importer: + specifiers: + '@trigger.dev/tsconfig': workspace:* + '@trigger.dev/tsup': workspace:* + '@types/jest': ^29.5.3 + '@types/node': '16' + jest: ^29.6.2 + long: ^5.2.3 + protobufjs: ^7.2.6 + rimraf: ^3.0.2 + ts-jest: ^29.1.1 + ts-proto: ^1.167.3 + tsup: ^8.0.1 + typescript: ^5.3.0 + dependencies: + long: 5.2.3 + protobufjs: 7.2.6 + devDependencies: + '@trigger.dev/tsconfig': link:../../config-packages/tsconfig + '@trigger.dev/tsup': link:../../config-packages/tsup + '@types/jest': 29.5.3 + '@types/node': 16.18.11 + jest: 29.6.2_@types+node@16.18.11 + rimraf: 3.0.2 + ts-jest: 29.1.1_5rpxlvaikdwu64qu6f72wnb6nm + ts-proto: 1.167.3 + tsup: 8.0.1_a5ztaafw5l4qfghy2hjjuynb34_typescript@5.3.3 + typescript: 5.3.3 + packages/react: specifiers: '@tanstack/react-query': 5.0.0-beta.2 @@ -1344,6 +1493,9 @@ importers: packages/trigger-sdk: specifiers: + '@opentelemetry/api': ^1.7.0 + '@opentelemetry/api-logs': ^0.48.0 + '@opentelemetry/semantic-conventions': ^1.21.0 '@trigger.dev/core': workspace:^2.3.18 '@trigger.dev/core-backend': workspace:^2.3.18 '@trigger.dev/tsconfig': workspace:* @@ -1372,6 +1524,9 @@ importers: ws: ^8.11.0 zod: 3.22.3 dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.48.0 + '@opentelemetry/semantic-conventions': 1.21.0 '@trigger.dev/core': link:../core '@trigger.dev/core-backend': link:../core-backend chalk: 5.2.0 @@ -1871,6 +2026,63 @@ importers: vitest: 0.34.4 zod: 3.22.3 + references/v3-catalog: + specifiers: + '@opentelemetry/api': ^1.7.0 + '@opentelemetry/api-logs': ^0.48.0 + '@opentelemetry/auto-instrumentations-node': ^0.40.3 + '@opentelemetry/exporter-collector': ^0.25.0 + '@opentelemetry/exporter-logs-otlp-http': ^0.48.0 + '@opentelemetry/exporter-trace-otlp-http': ^0.48.0 + '@opentelemetry/instrumentation': ^0.48.0 + '@opentelemetry/instrumentation-fetch': ^0.48.0 + '@opentelemetry/instrumentation-http': ^0.48.0 + '@opentelemetry/propagator-b3': ^1.21.0 + '@opentelemetry/resources': ^1.21.0 + '@opentelemetry/sdk-logs': ^0.48.0 + '@opentelemetry/sdk-node': ^0.48.0 + '@opentelemetry/sdk-trace-base': ^1.21.0 + '@opentelemetry/sdk-trace-node': ^1.21.0 + '@opentelemetry/semantic-conventions': ^1.21.0 + '@trigger.dev/sdk': workspace:* + '@trigger.dev/tsconfig': workspace:* + '@types/node': 20.4.2 + concurrently: ^8.2.0 + dotenv: ^16.3.1 + nodemon: ^3.0.1 + trigger.dev: workspace:* + ts-node: ^10.9.1 + tsconfig-paths: ^3.14.1 + typescript: 5.1.6 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.48.0 + '@opentelemetry/auto-instrumentations-node': 0.40.3_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-collector': 0.25.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-logs-otlp-http': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-http': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-fetch': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-http': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/propagator-b3': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-logs': 0.48.0_wj3rtarwgmsxddfed6zfae5bhe + '@opentelemetry/sdk-node': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-node': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + '@trigger.dev/sdk': link:../../packages/trigger-sdk + devDependencies: + '@trigger.dev/tsconfig': link:../../config-packages/tsconfig + '@types/node': 20.4.2 + concurrently: 8.2.0 + dotenv: 16.3.1 + nodemon: 3.0.1 + trigger.dev: link:../../packages/cli-v3 + ts-node: 10.9.1_xj5cs2fmhcigm4w5bhhtewqeja + tsconfig-paths: 3.14.1 + typescript: 5.1.6 + runtime_tests: specifiers: '@cloudflare/workers-types': ^4.20221111.1 @@ -1906,6 +2118,14 @@ packages: resolution: {integrity: sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==} engines: {node: '>=0.10.0'} + /@alcalzone/ansi-tokenize/0.1.3: + resolution: {integrity: sha512-3yWxPTq3UQ/FY9p1ErPxIyfT64elWaMvM9lIHnaqpyft63tkxodF5aUElYHrdisWve5cETkh1+KBw1yJuW0aRw==} + engines: {node: '>=14.13.1'} + dependencies: + ansi-styles: 6.2.1 + is-fullwidth-code-point: 4.0.0 + dev: false + /@alloc/quick-lru/5.2.0: resolution: {integrity: sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==} engines: {node: '>=10'} @@ -5584,6 +5804,14 @@ packages: rollup-plugin-node-polyfills: 0.2.1 dev: true + /@esbuild/aix-ppc64/0.19.11: + resolution: {integrity: sha512-FnzU0LyE3ySQk7UntJO4+qIiQgI7KoODnZg5xzXIrFJlKd2P2gwHsHY4927xj9y5PJmJSzULiUCWmv7iWnNa7g==} + engines: {node: '>=12'} + cpu: [ppc64] + os: [aix] + requiresBuild: true + optional: true + /@esbuild/android-arm/0.15.18: resolution: {integrity: sha512-5GT+kcs2WVGjVs7+boataCkO5Fg0y4kCjzkB5bAip7H4jfnOS3dA6KPiww9W1OEKTKeAcUVhdZGvgI65OXmUnw==} engines: {node: '>=12'} @@ -5637,8 +5865,8 @@ packages: requiresBuild: true optional: true - /@esbuild/android-arm/0.19.2: - resolution: {integrity: sha512-tM8yLeYVe7pRyAu9VMi/Q7aunpLwD139EY1S99xbQkT4/q2qa6eA4ige/WJQYdJ8GBL1K33pPFhPfPdJ/WzT8Q==} + /@esbuild/android-arm/0.19.11: + resolution: {integrity: sha512-5OVapq0ClabvKvQ58Bws8+wkLCV+Rxg7tUVbo9xu034Nm536QTII4YzhaFriQ7rMrorfnFKUsArD2lqKbFY4vw==} engines: {node: '>=12'} cpu: [arm] os: [android] @@ -5689,8 +5917,8 @@ packages: requiresBuild: true optional: true - /@esbuild/android-arm64/0.19.2: - resolution: {integrity: sha512-lsB65vAbe90I/Qe10OjkmrdxSX4UJDjosDgb8sZUKcg3oefEuW2OT2Vozz8ef7wrJbMcmhvCC+hciF8jY/uAkw==} + /@esbuild/android-arm64/0.19.11: + resolution: {integrity: sha512-aiu7K/5JnLj//KOnOfEZ0D90obUkRzDMyqd/wNAUQ34m4YUPVhRZpnqKV9uqDGxT7cToSDnIHsGooyIczu9T+Q==} engines: {node: '>=12'} cpu: [arm64] os: [android] @@ -5741,8 +5969,8 @@ packages: requiresBuild: true optional: true - /@esbuild/android-x64/0.19.2: - resolution: {integrity: sha512-qK/TpmHt2M/Hg82WXHRc/W/2SGo/l1thtDHZWqFq7oi24AjZ4O/CpPSu6ZuYKFkEgmZlFoa7CooAyYmuvnaG8w==} + /@esbuild/android-x64/0.19.11: + resolution: {integrity: sha512-eccxjlfGw43WYoY9QgB82SgGgDbibcqyDTlk3l3C0jOVHKxrjdc9CTwDUQd0vkvYg5um0OH+GpxYvp39r+IPOg==} engines: {node: '>=12'} cpu: [x64] os: [android] @@ -5793,8 +6021,8 @@ packages: requiresBuild: true optional: true - /@esbuild/darwin-arm64/0.19.2: - resolution: {integrity: sha512-Ora8JokrvrzEPEpZO18ZYXkH4asCdc1DLdcVy8TGf5eWtPO1Ie4WroEJzwI52ZGtpODy3+m0a2yEX9l+KUn0tA==} + /@esbuild/darwin-arm64/0.19.11: + resolution: {integrity: sha512-ETp87DRWuSt9KdDVkqSoKoLFHYTrkyz2+65fj9nfXsaV3bMhTCjtQfw3y+um88vGRKRiF7erPrh/ZuIdLUIVxQ==} engines: {node: '>=12'} cpu: [arm64] os: [darwin] @@ -5845,8 +6073,8 @@ packages: requiresBuild: true optional: true - /@esbuild/darwin-x64/0.19.2: - resolution: {integrity: sha512-tP+B5UuIbbFMj2hQaUr6EALlHOIOmlLM2FK7jeFBobPy2ERdohI4Ka6ZFjZ1ZYsrHE/hZimGuU90jusRE0pwDw==} + /@esbuild/darwin-x64/0.19.11: + resolution: {integrity: sha512-fkFUiS6IUK9WYUO/+22omwetaSNl5/A8giXvQlcinLIjVkxwTLSktbF5f/kJMftM2MJp9+fXqZ5ezS7+SALp4g==} engines: {node: '>=12'} cpu: [x64] os: [darwin] @@ -5897,8 +6125,8 @@ packages: requiresBuild: true optional: true - /@esbuild/freebsd-arm64/0.19.2: - resolution: {integrity: sha512-YbPY2kc0acfzL1VPVK6EnAlig4f+l8xmq36OZkU0jzBVHcOTyQDhnKQaLzZudNJQyymd9OqQezeaBgkTGdTGeQ==} + /@esbuild/freebsd-arm64/0.19.11: + resolution: {integrity: sha512-lhoSp5K6bxKRNdXUtHoNc5HhbXVCS8V0iZmDvyWvYq9S5WSfTIHU2UGjcGt7UeS6iEYp9eeymIl5mJBn0yiuxA==} engines: {node: '>=12'} cpu: [arm64] os: [freebsd] @@ -5949,8 +6177,8 @@ packages: requiresBuild: true optional: true - /@esbuild/freebsd-x64/0.19.2: - resolution: {integrity: sha512-nSO5uZT2clM6hosjWHAsS15hLrwCvIWx+b2e3lZ3MwbYSaXwvfO528OF+dLjas1g3bZonciivI8qKR/Hm7IWGw==} + /@esbuild/freebsd-x64/0.19.11: + resolution: {integrity: sha512-JkUqn44AffGXitVI6/AbQdoYAq0TEullFdqcMY/PCUZ36xJ9ZJRtQabzMA+Vi7r78+25ZIBosLTOKnUXBSi1Kw==} engines: {node: '>=12'} cpu: [x64] os: [freebsd] @@ -6001,8 +6229,8 @@ packages: requiresBuild: true optional: true - /@esbuild/linux-arm/0.19.2: - resolution: {integrity: sha512-Odalh8hICg7SOD7XCj0YLpYCEc+6mkoq63UnExDCiRA2wXEmGlK5JVrW50vZR9Qz4qkvqnHcpH+OFEggO3PgTg==} + /@esbuild/linux-arm/0.19.11: + resolution: {integrity: sha512-3CRkr9+vCV2XJbjwgzjPtO8T0SZUmRZla+UL1jw+XqHZPkPgZiyWvbDvl9rqAN8Zl7qJF0O/9ycMtjU67HN9/Q==} engines: {node: '>=12'} cpu: [arm] os: [linux] @@ -6053,8 +6281,8 @@ packages: requiresBuild: true optional: true - /@esbuild/linux-arm64/0.19.2: - resolution: {integrity: sha512-ig2P7GeG//zWlU0AggA3pV1h5gdix0MA3wgB+NsnBXViwiGgY77fuN9Wr5uoCrs2YzaYfogXgsWZbm+HGr09xg==} + /@esbuild/linux-arm64/0.19.11: + resolution: {integrity: sha512-LneLg3ypEeveBSMuoa0kwMpCGmpu8XQUh+mL8XXwoYZ6Be2qBnVtcDI5azSvh7vioMDhoJFZzp9GWp9IWpYoUg==} engines: {node: '>=12'} cpu: [arm64] os: [linux] @@ -6105,8 +6333,8 @@ packages: requiresBuild: true optional: true - /@esbuild/linux-ia32/0.19.2: - resolution: {integrity: sha512-mLfp0ziRPOLSTek0Gd9T5B8AtzKAkoZE70fneiiyPlSnUKKI4lp+mGEnQXcQEHLJAcIYDPSyBvsUbKUG2ri/XQ==} + /@esbuild/linux-ia32/0.19.11: + resolution: {integrity: sha512-caHy++CsD8Bgq2V5CodbJjFPEiDPq8JJmBdeyZ8GWVQMjRD0sU548nNdwPNvKjVpamYYVL40AORekgfIubwHoA==} engines: {node: '>=12'} cpu: [ia32] os: [linux] @@ -6166,8 +6394,8 @@ packages: requiresBuild: true optional: true - /@esbuild/linux-loong64/0.19.2: - resolution: {integrity: sha512-hn28+JNDTxxCpnYjdDYVMNTR3SKavyLlCHHkufHV91fkewpIyQchS1d8wSbmXhs1fiYDpNww8KTFlJ1dHsxeSw==} + /@esbuild/linux-loong64/0.19.11: + resolution: {integrity: sha512-ppZSSLVpPrwHccvC6nQVZaSHlFsvCQyjnvirnVjbKSHuE5N24Yl8F3UwYUUR1UEPaFObGD2tSvVKbvR+uT1Nrg==} engines: {node: '>=12'} cpu: [loong64] os: [linux] @@ -6218,8 +6446,8 @@ packages: requiresBuild: true optional: true - /@esbuild/linux-mips64el/0.19.2: - resolution: {integrity: sha512-KbXaC0Sejt7vD2fEgPoIKb6nxkfYW9OmFUK9XQE4//PvGIxNIfPk1NmlHmMg6f25x57rpmEFrn1OotASYIAaTg==} + /@esbuild/linux-mips64el/0.19.11: + resolution: {integrity: sha512-B5x9j0OgjG+v1dF2DkH34lr+7Gmv0kzX6/V0afF41FkPMMqaQ77pH7CrhWeR22aEeHKaeZVtZ6yFwlxOKPVFyg==} engines: {node: '>=12'} cpu: [mips64el] os: [linux] @@ -6270,8 +6498,8 @@ packages: requiresBuild: true optional: true - /@esbuild/linux-ppc64/0.19.2: - resolution: {integrity: sha512-dJ0kE8KTqbiHtA3Fc/zn7lCd7pqVr4JcT0JqOnbj4LLzYnp+7h8Qi4yjfq42ZlHfhOCM42rBh0EwHYLL6LEzcw==} + /@esbuild/linux-ppc64/0.19.11: + resolution: {integrity: sha512-MHrZYLeCG8vXblMetWyttkdVRjQlQUb/oMgBNurVEnhj4YWOr4G5lmBfZjHYQHHN0g6yDmCAQRR8MUHldvvRDA==} engines: {node: '>=12'} cpu: [ppc64] os: [linux] @@ -6322,8 +6550,8 @@ packages: requiresBuild: true optional: true - /@esbuild/linux-riscv64/0.19.2: - resolution: {integrity: sha512-7Z/jKNFufZ/bbu4INqqCN6DDlrmOTmdw6D0gH+6Y7auok2r02Ur661qPuXidPOJ+FSgbEeQnnAGgsVynfLuOEw==} + /@esbuild/linux-riscv64/0.19.11: + resolution: {integrity: sha512-f3DY++t94uVg141dozDu4CCUkYW+09rWtaWfnb3bqe4w5NqmZd6nPVBm+qbz7WaHZCoqXqHz5p6CM6qv3qnSSQ==} engines: {node: '>=12'} cpu: [riscv64] os: [linux] @@ -6374,8 +6602,8 @@ packages: requiresBuild: true optional: true - /@esbuild/linux-s390x/0.19.2: - resolution: {integrity: sha512-U+RinR6aXXABFCcAY4gSlv4CL1oOVvSSCdseQmGO66H+XyuQGZIUdhG56SZaDJQcLmrSfRmx5XZOWyCJPRqS7g==} + /@esbuild/linux-s390x/0.19.11: + resolution: {integrity: sha512-A5xdUoyWJHMMlcSMcPGVLzYzpcY8QP1RtYzX5/bS4dvjBGVxdhuiYyFwp7z74ocV7WDc0n1harxmpq2ePOjI0Q==} engines: {node: '>=12'} cpu: [s390x] os: [linux] @@ -6426,8 +6654,8 @@ packages: requiresBuild: true optional: true - /@esbuild/linux-x64/0.19.2: - resolution: {integrity: sha512-oxzHTEv6VPm3XXNaHPyUTTte+3wGv7qVQtqaZCrgstI16gCuhNOtBXLEBkBREP57YTd68P0VgDgG73jSD8bwXQ==} + /@esbuild/linux-x64/0.19.11: + resolution: {integrity: sha512-grbyMlVCvJSfxFQUndw5mCtWs5LO1gUlwP4CDi4iJBbVpZcqLVT29FxgGuBJGSzyOxotFG4LoO5X+M1350zmPA==} engines: {node: '>=12'} cpu: [x64] os: [linux] @@ -6478,8 +6706,8 @@ packages: requiresBuild: true optional: true - /@esbuild/netbsd-x64/0.19.2: - resolution: {integrity: sha512-WNa5zZk1XpTTwMDompZmvQLHszDDDN7lYjEHCUmAGB83Bgs20EMs7ICD+oKeT6xt4phV4NDdSi/8OfjPbSbZfQ==} + /@esbuild/netbsd-x64/0.19.11: + resolution: {integrity: sha512-13jvrQZJc3P230OhU8xgwUnDeuC/9egsjTkXN49b3GcS5BKvJqZn86aGM8W9pd14Kd+u7HuFBMVtrNGhh6fHEQ==} engines: {node: '>=12'} cpu: [x64] os: [netbsd] @@ -6530,8 +6758,8 @@ packages: requiresBuild: true optional: true - /@esbuild/openbsd-x64/0.19.2: - resolution: {integrity: sha512-S6kI1aT3S++Dedb7vxIuUOb3oAxqxk2Rh5rOXOTYnzN8JzW1VzBd+IqPiSpgitu45042SYD3HCoEyhLKQcDFDw==} + /@esbuild/openbsd-x64/0.19.11: + resolution: {integrity: sha512-ysyOGZuTp6SNKPE11INDUeFVVQFrhcNDVUgSQVDzqsqX38DjhPEPATpid04LCoUr2WXhQTEZ8ct/EgJCUDpyNw==} engines: {node: '>=12'} cpu: [x64] os: [openbsd] @@ -6582,8 +6810,8 @@ packages: requiresBuild: true optional: true - /@esbuild/sunos-x64/0.19.2: - resolution: {integrity: sha512-VXSSMsmb+Z8LbsQGcBMiM+fYObDNRm8p7tkUDMPG/g4fhFX5DEFmjxIEa3N8Zr96SjsJ1woAhF0DUnS3MF3ARw==} + /@esbuild/sunos-x64/0.19.11: + resolution: {integrity: sha512-Hf+Sad9nVwvtxy4DXCZQqLpgmRTQqyFyhT3bZ4F2XlJCjxGmRFF0Shwn9rzhOYRB61w9VMXUkxlBy56dk9JJiQ==} engines: {node: '>=12'} cpu: [x64] os: [sunos] @@ -6634,8 +6862,8 @@ packages: requiresBuild: true optional: true - /@esbuild/win32-arm64/0.19.2: - resolution: {integrity: sha512-5NayUlSAyb5PQYFAU9x3bHdsqB88RC3aM9lKDAz4X1mo/EchMIT1Q+pSeBXNgkfNmRecLXA0O8xP+x8V+g/LKg==} + /@esbuild/win32-arm64/0.19.11: + resolution: {integrity: sha512-0P58Sbi0LctOMOQbpEOvOL44Ne0sqbS0XWHMvvrg6NE5jQ1xguCSSw9jQeUk2lfrXYsKDdOe6K+oZiwKPilYPQ==} engines: {node: '>=12'} cpu: [arm64] os: [win32] @@ -6686,8 +6914,8 @@ packages: requiresBuild: true optional: true - /@esbuild/win32-ia32/0.19.2: - resolution: {integrity: sha512-47gL/ek1v36iN0wL9L4Q2MFdujR0poLZMJwhO2/N3gA89jgHp4MR8DKCmwYtGNksbfJb9JoTtbkoe6sDhg2QTA==} + /@esbuild/win32-ia32/0.19.11: + resolution: {integrity: sha512-6YOrWS+sDJDmshdBIQU+Uoyh7pQKrdykdefC1avn76ss5c+RN6gut3LZA4E2cH5xUEp5/cA0+YxRaVtRAb0xBg==} engines: {node: '>=12'} cpu: [ia32] os: [win32] @@ -6738,8 +6966,8 @@ packages: requiresBuild: true optional: true - /@esbuild/win32-x64/0.19.2: - resolution: {integrity: sha512-tcuhV7ncXBqbt/Ybf0IyrMcwVOAPDckMK9rXNHtF17UTK18OKLpg08glminN06pt2WCoALhXdLfSPbVvK/6fxw==} + /@esbuild/win32-x64/0.19.11: + resolution: {integrity: sha512-vfkhltrjCAb603XaFhqhAF4LGDi2M4OrCRrFusyQ+iTLQ/o60QQXxc9cZC/FFpihBI9N1Grn6SMKVJ4KP7Fuiw==} engines: {node: '>=12'} cpu: [x64] os: [win32] @@ -6965,7 +7193,7 @@ packages: '@types/long': 4.0.2 lodash.camelcase: 4.3.0 long: 4.0.0 - protobufjs: 7.2.4 + protobufjs: 7.2.6 yargs: 17.7.2 dev: false @@ -7079,12 +7307,12 @@ packages: /@highlight-run/node/3.1.0: resolution: {integrity: sha512-HawGRA7K5IvAevw+4hKO/9+OfGukpdid36zTEgaALIlYC0lOiYeu7rb7wjxDdq1vnlWgGJm7VMY0so9SZKEVmA==} dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/auto-instrumentations-node': 0.36.5_@opentelemetry+api@1.4.1 - '@opentelemetry/exporter-trace-otlp-http': 0.38.0_@opentelemetry+api@1.4.1 - '@opentelemetry/resources': 1.15.0_@opentelemetry+api@1.4.1 - '@opentelemetry/sdk-node': 0.38.0_@opentelemetry+api@1.4.1 - '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/auto-instrumentations-node': 0.36.5_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-http': 0.38.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-node': 0.38.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.7.0 error-stack-parser: 2.0.7 highlight.run: 7.2.0 lru-cache: 7.18.3 @@ -7501,6 +7729,14 @@ packages: - supports-color dev: false + /@kwsites/file-exists/1.1.1_supports-color@9.4.0: + resolution: {integrity: sha512-m9/5YGR18lIwxSFDwfE3oA7bWuq9kdau6ugN4H2rJeyhFQZcG9AgSHkQtSD15a8WvTgfz9aikZMrKPHvbpqFiw==} + dependencies: + debug: 4.3.4_supports-color@9.4.0 + transitivePeerDependencies: + - supports-color + dev: false + /@kwsites/promise-deferred/1.1.1: resolution: {integrity: sha512-GaHYm+c0O9MjZRu0ongGBRbinu8gVAMd2UZjji6jVmqKtZluZnptXGWhz1E8j8D2HJ3f/yMxKAUC0b+57wncIw==} dev: false @@ -8252,6 +8488,19 @@ packages: - supports-color dev: false + /@npmcli/run-script/6.0.2_supports-color@9.4.0: + resolution: {integrity: sha512-NCcr1uQo1k5U+SYlnIrbAh3cxy+OQT1VtqiAbxdymSlptbzBb62AjH2xXgjNCoP073hoa1CfCAcwoZ8k96C4nA==} + engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + dependencies: + '@npmcli/node-gyp': 3.0.0 + '@npmcli/promise-spawn': 6.0.2 + node-gyp: 9.4.0_supports-color@9.4.0 + read-package-json-fast: 3.0.2 + which: 3.0.1 + transitivePeerDependencies: + - supports-color + dev: false + /@nuxtjs/opencollective/0.3.2: resolution: {integrity: sha512-um0xL3fO7Mf4fDxcqx9KryrB7zgRM5JSlvGN5AGkP6JLM5XEKyjeAiPbNxdXVXQ16isuAhYpvP88NgL2BGd6aA==} engines: {node: '>=8.0.0', npm: '>=5.0.0'} @@ -8505,672 +8754,2071 @@ packages: resolution: {integrity: sha512-Aq58f5HiWdyDlFffbbSjAlv596h/cOnt2DO1w3DOC7OJ5EHs0hd/nycJfiu9RJbT6Yk6F1knnRRXNSpxoIVZ9Q==} dev: true - /@opentelemetry/api/1.4.1: - resolution: {integrity: sha512-O2yRJce1GOc6PAy3QxFM4NzFiWzvScDC1/5ihYBL6BUEVdq0XMWN01sppE+H6bBXbaFYipjwFLEWLg5PaSOThA==} + /@opentelemetry/api-logs/0.46.0: + resolution: {integrity: sha512-+9BcqfiEDGPXEIo+o3tso/aqGM5dGbGwAkGVp3FPpZ8GlkK1YlaKRd9gMVyPaeRATwvO5wYGGnCsAc/sMMM9Qw==} + engines: {node: '>=14'} + dependencies: + '@opentelemetry/api': 1.7.0 + dev: false + + /@opentelemetry/api-logs/0.48.0: + resolution: {integrity: sha512-1/aMiU4Eqo3Zzpfwu51uXssp5pzvHFObk8S9pKAiXb1ne8pvg1qxBQitYL1XUiAMEXFzgjaidYG2V6624DRhhw==} + engines: {node: '>=14'} + dependencies: + '@opentelemetry/api': 1.7.0 + dev: false + + /@opentelemetry/api-metrics/0.25.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-9T0c9NQAEGRujUC7HzPa2/qZ5px/UvB2sfSU5CAKFRrAlDl2gn25B0oUbDqSRHW/IG1X2rnQ3z2bBQkJyJvE4g==} + engines: {node: '>=8.0.0'} + deprecated: Please use @opentelemetry/api >= 1.3.0 + peerDependencies: + '@opentelemetry/api': ^1.0.2 + dependencies: + '@opentelemetry/api': 1.7.0 + dev: false + + /@opentelemetry/api/1.7.0: + resolution: {integrity: sha512-AdY5wvN0P2vXBi3b29hxZgSFvdhdxPB9+f0B6s//P9Q8nibRWeA3cHm8UmLpio9ABigkVHJ5NMPk+Mz8VCCyrw==} engines: {node: '>=8.0.0'} dev: false - /@opentelemetry/auto-instrumentations-node/0.36.5_@opentelemetry+api@1.4.1: + /@opentelemetry/auto-instrumentations-node/0.36.5_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-tps0UDvV9H9Cz+XlycvLHo/3t5zYwXVUq5mW2WLubfWUheZiRYKpo4F7va7oFt7r1RKRo19YJVuJVHOFkgJZdw==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.35.1_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-amqplib': 0.32.5_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-aws-lambda': 0.35.3_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-aws-sdk': 0.34.3_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-bunyan': 0.31.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-cassandra-driver': 0.32.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-connect': 0.31.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-dataloader': 0.4.3_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-dns': 0.31.5_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-express': 0.32.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-fastify': 0.31.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-fs': 0.7.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-generic-pool': 0.31.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-graphql': 0.34.3_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-grpc': 0.35.1_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-hapi': 0.31.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-http': 0.35.1_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-ioredis': 0.34.3_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-knex': 0.31.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-koa': 0.34.6_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-lru-memoizer': 0.32.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-memcached': 0.31.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-mongodb': 0.34.3_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-mongoose': 0.32.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-mysql': 0.33.3_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-mysql2': 0.33.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-nestjs-core': 0.32.5_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-net': 0.31.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-pg': 0.35.3_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-pino': 0.33.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-redis': 0.34.7_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-redis-4': 0.34.6_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-restify': 0.32.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-router': 0.32.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-socket.io': 0.33.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-tedious': 0.5.4_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation-winston': 0.31.4_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.35.1_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-amqplib': 0.32.5_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-aws-lambda': 0.35.3_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-aws-sdk': 0.34.3_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-bunyan': 0.31.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-cassandra-driver': 0.32.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-connect': 0.31.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-dataloader': 0.4.3_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-dns': 0.31.5_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-express': 0.32.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-fastify': 0.31.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-fs': 0.7.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-generic-pool': 0.31.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-graphql': 0.34.3_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-grpc': 0.35.1_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-hapi': 0.31.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-http': 0.35.1_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-ioredis': 0.34.3_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-knex': 0.31.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-koa': 0.34.6_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-lru-memoizer': 0.32.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-memcached': 0.31.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-mongodb': 0.34.3_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-mongoose': 0.32.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-mysql': 0.33.3_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-mysql2': 0.33.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-nestjs-core': 0.32.5_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-net': 0.31.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-pg': 0.35.3_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-pino': 0.33.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-redis': 0.34.7_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-redis-4': 0.34.6_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-restify': 0.32.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-router': 0.32.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-socket.io': 0.33.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-tedious': 0.5.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-winston': 0.31.4_@opentelemetry+api@1.7.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/context-async-hooks/1.12.0_@opentelemetry+api@1.4.1: + /@opentelemetry/auto-instrumentations-node/0.40.3_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-MgBCzpFU4FBQEsXPgt5driYzxErf2JGntQ8Amtc94sqrnvq+FKdEBa6vxOpZlPM+c4Xr6tPpAT1ecTBV8U87hw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.4.1 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-amqplib': 0.33.5_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-aws-lambda': 0.37.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-aws-sdk': 0.37.2_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-bunyan': 0.34.1_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-cassandra-driver': 0.34.2_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-connect': 0.32.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-cucumber': 0.2.1_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-dataloader': 0.5.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-dns': 0.32.5_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-express': 0.34.1_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-fastify': 0.32.6_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-fs': 0.8.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-generic-pool': 0.32.5_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-graphql': 0.36.1_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-grpc': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-hapi': 0.33.3_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-http': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-ioredis': 0.36.1_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-knex': 0.32.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-koa': 0.36.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-lru-memoizer': 0.33.5_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-memcached': 0.32.5_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-mongodb': 0.38.1_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-mongoose': 0.34.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-mysql': 0.34.5_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-mysql2': 0.34.5_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-nestjs-core': 0.33.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-net': 0.32.5_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-pg': 0.37.2_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-pino': 0.34.5_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-redis': 0.35.5_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-redis-4': 0.35.6_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-restify': 0.34.3_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-router': 0.33.4_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-socket.io': 0.35.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-tedious': 0.6.5_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation-winston': 0.33.1_@opentelemetry+api@1.7.0 + '@opentelemetry/resource-detector-alibaba-cloud': 0.28.6_@opentelemetry+api@1.7.0 + '@opentelemetry/resource-detector-aws': 1.3.6_@opentelemetry+api@1.7.0 + '@opentelemetry/resource-detector-container': 0.3.6_@opentelemetry+api@1.7.0 + '@opentelemetry/resource-detector-gcp': 0.29.6_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-node': 0.46.0_@opentelemetry+api@1.7.0 + transitivePeerDependencies: + - encoding + - supports-color + dev: false + + /@opentelemetry/auto-instrumentations-node/0.40.3_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-MgBCzpFU4FBQEsXPgt5driYzxErf2JGntQ8Amtc94sqrnvq+FKdEBa6vxOpZlPM+c4Xr6tPpAT1ecTBV8U87hw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.4.1 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-amqplib': 0.33.5_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-aws-lambda': 0.37.4_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-aws-sdk': 0.37.2_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-bunyan': 0.34.1_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-cassandra-driver': 0.34.2_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-connect': 0.32.4_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-cucumber': 0.2.1_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-dataloader': 0.5.4_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-dns': 0.32.5_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-express': 0.34.1_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-fastify': 0.32.6_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-fs': 0.8.4_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-generic-pool': 0.32.5_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-graphql': 0.36.1_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-grpc': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-hapi': 0.33.3_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-http': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-ioredis': 0.36.1_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-knex': 0.32.4_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-koa': 0.36.4_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-lru-memoizer': 0.33.5_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-memcached': 0.32.5_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-mongodb': 0.38.1_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-mongoose': 0.34.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-mysql': 0.34.5_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-mysql2': 0.34.5_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-nestjs-core': 0.33.4_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-net': 0.32.5_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-pg': 0.37.2_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-pino': 0.34.5_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-redis': 0.35.5_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-redis-4': 0.35.6_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-restify': 0.34.3_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-router': 0.33.4_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-socket.io': 0.35.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-tedious': 0.6.5_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/instrumentation-winston': 0.33.1_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/resource-detector-alibaba-cloud': 0.28.6_@opentelemetry+api@1.7.0 + '@opentelemetry/resource-detector-aws': 1.3.6_@opentelemetry+api@1.7.0 + '@opentelemetry/resource-detector-container': 0.3.6_@opentelemetry+api@1.7.0 + '@opentelemetry/resource-detector-gcp': 0.29.6_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-node': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + transitivePeerDependencies: + - encoding + - supports-color + dev: false + + /@opentelemetry/context-async-hooks/1.12.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-PmwAanPNWCyS9JYFzhzVzHgviLhc0UHjOwdth+hp3HgQQ9XZZNE635P8JhAUHZmbghW9/qQFafRWOS4VN9VVnQ==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': '>=1.0.0 <1.5.0' dependencies: - '@opentelemetry/api': 1.4.1 + '@opentelemetry/api': 1.7.0 dev: false - /@opentelemetry/core/1.12.0_@opentelemetry+api@1.4.1: + /@opentelemetry/context-async-hooks/1.19.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-0i1ECOc9daKK3rjUgDDXf0GDD5XfCou5lXnt2DALIc2qKoruPPcesobNKE54laSVUWnC3jX26RzuOa31g0V32A==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + dev: false + + /@opentelemetry/context-async-hooks/1.21.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-t0iulGPiMjG/NrSjinPQoIf8ST/o9V0dGOJthfrFporJlNdlKIQPfC7lkrV+5s2dyBThfmSbJlp/4hO1eOcDXA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + dev: false + + /@opentelemetry/core/0.25.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-8OTWF4vfCENU112XB5ElLqf0eq/FhsY0SBvvY65vB3+fbZ2Oi+CPsRASrUZWGtC9MJ5rK2lBlY+/jI4a/NPPBg==} + engines: {node: '>=8.5.0'} + peerDependencies: + '@opentelemetry/api': ^1.0.2 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/semantic-conventions': 0.25.0 + semver: 7.5.4 + dev: false + + /@opentelemetry/core/1.12.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-4DWYNb3dLs2mSCGl65jY3aEgbvPWSHVQV/dmDWiYeWUrMakZQFcymqZOSUNZO0uDrEJoxMu8O5tZktX6UKFwag==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': '>=1.0.0 <1.5.0' dependencies: - '@opentelemetry/api': 1.4.1 + '@opentelemetry/api': 1.7.0 '@opentelemetry/semantic-conventions': 1.12.0 dev: false - /@opentelemetry/core/1.15.0_@opentelemetry+api@1.4.1: - resolution: {integrity: sha512-GGTS6BytfaN8OgbCUOnxg/a9WVsVUj0484zXHZuBzvIXx7V4Tmkb0IHnnhS7Q0cBLNLgjNuvrCpQaP8fIvO4bg==} + /@opentelemetry/core/1.19.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-w42AukJh3TP8R0IZZOVJVM/kMWu8g+lm4LzT70WtuKqhwq7KVhcDzZZuZinWZa6TtQCl7Smt2wolEYzpHabOgw==} engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.0.0 <1.5.0' + '@opentelemetry/api': '>=1.0.0 <1.8.0' dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 - tslib: 2.6.2 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/semantic-conventions': 1.19.0 dev: false - /@opentelemetry/core/1.9.1_@opentelemetry+api@1.4.1: + /@opentelemetry/core/1.21.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-KP+OIweb3wYoP7qTYL/j5IpOlu52uxBv5M4+QhSmmUfLyTgu1OIS71msK3chFo1D6Y61BIH3wMiMYRCxJCQctA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + dev: false + + /@opentelemetry/core/1.9.1_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-6/qon6tw2I8ZaJnHAQUUn4BqhTbTNRS0WP8/bA0ynaX+Uzp/DDbd0NS0Cq6TMlh8+mrlsyqDE7mO50nmv2Yvlg==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': '>=1.0.0 <1.5.0' dependencies: - '@opentelemetry/api': 1.4.1 + '@opentelemetry/api': 1.7.0 '@opentelemetry/semantic-conventions': 1.9.1 dev: false - /@opentelemetry/exporter-jaeger/1.12.0_@opentelemetry+api@1.4.1: + /@opentelemetry/exporter-collector/0.25.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-xZYstLt4hz1aTloJaepWdjMMf9305MqwqbUWjcU/X9pOxvgFWRlchO6x/HQTw7ow0i/S+ShzC+greKnb+1WvLA==} + engines: {node: '>=8.0.0'} + deprecated: Please use trace and metric specific exporters @opentelemetry/exporter-trace-otlp-http and @opentelemetry/exporter-metrics-otlp-http + peerDependencies: + '@opentelemetry/api': ^1.0.2 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-metrics': 0.25.0_@opentelemetry+api@1.7.0 + '@opentelemetry/core': 0.25.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 0.25.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-metrics-base': 0.25.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 0.25.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/exporter-jaeger/1.12.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-MGWslvok6tlNCHexHGnfXrSyobBqUDh4YOLENt2MeQ/F974SyVG4e73TD/CDM+227/rRM587hJ8dQBzvwUac/g==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.0.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.7.0 '@opentelemetry/semantic-conventions': 1.12.0 jaeger-client: 3.19.0 dev: false - /@opentelemetry/exporter-trace-otlp-grpc/0.38.0_@opentelemetry+api@1.4.1: + /@opentelemetry/exporter-logs-otlp-http/0.48.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-Glxl0ZmyHqykGjcv5T4HMvw4fQVZoiCV0oMolPgXBBnuTuOHS/dEdoGX6hNp4Xqw55YALM/CJocHwkRqBQnPgw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.48.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-exporter-base': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-transformer': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-logs': 0.48.0_wj3rtarwgmsxddfed6zfae5bhe + dev: false + + /@opentelemetry/exporter-trace-otlp-grpc/0.38.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-9pwDRnBr7qDeAZ81WHbM+aA1GSu9p8nh2ARmKgA4YrCo1E9IY94goaSBV03pbGe7gh/frOp18FQMvXmiRITGUg==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.0.0 dependencies: '@grpc/grpc-js': 1.8.17 - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/otlp-grpc-exporter-base': 0.38.0_@opentelemetry+api@1.4.1 - '@opentelemetry/otlp-transformer': 0.38.0_@opentelemetry+api@1.4.1 - '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-grpc-exporter-base': 0.38.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-transformer': 0.38.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.7.0 dev: false - /@opentelemetry/exporter-trace-otlp-http/0.38.0_@opentelemetry+api@1.4.1: + /@opentelemetry/exporter-trace-otlp-grpc/0.46.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-kR4kehnfIhv7v/2MuNYfrlh9A/ZtQofwCzurTIplornUjdzhKDGgjui1NkNTqTfM1QkqfCiavGsf5hwocx29bA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@grpc/grpc-js': 1.8.17 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-grpc-exporter-base': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-transformer': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.19.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/exporter-trace-otlp-grpc/0.48.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-+qRQXUbdRW6aNRT5yWOG3G6My1VxxKeqgUyLkkdIjkT20lvymjiN2RpBfGMtAf/oqnuRknf9snFl9VSIO2gniw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@grpc/grpc-js': 1.8.17 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-grpc-exporter-base': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-transformer': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.21.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/exporter-trace-otlp-http/0.38.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-AWpTCyijC7kt2DbLj8FmdlRquA6/rTXZ+3U4MVl4P2YNI7KLUnx/FEhn2BMTB0+rOy7UxSAocqz2tJ/5Ss/6Ng==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.0.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/otlp-exporter-base': 0.38.0_@opentelemetry+api@1.4.1 - '@opentelemetry/otlp-transformer': 0.38.0_@opentelemetry+api@1.4.1 - '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-exporter-base': 0.38.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-transformer': 0.38.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.7.0 dev: false - /@opentelemetry/exporter-trace-otlp-proto/0.38.0_@opentelemetry+api@1.4.1: + /@opentelemetry/exporter-trace-otlp-http/0.46.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-vZ2pYOB+qrQ+jnKPY6Gnd58y1k/Ti//Ny6/XsSX7/jED0X77crtSVgC6N5UA0JiGJOh6QB2KE9gaH99010XHzg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-exporter-base': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-transformer': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.19.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/exporter-trace-otlp-http/0.48.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-QEZKbfWqXrbKVpr2PHd4KyKI0XVOhUYC+p2RPV8s+2K5QzZBE3+F9WlxxrXDfkrvGmpQAZytBoHQQYA3AGOtpw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-exporter-base': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-transformer': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.21.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/exporter-trace-otlp-proto/0.38.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-M1YctP+T6485noDAJPsnpsx85xsfqyCr06CadTQBJHIgjStgsKTDA86iVpv7XEqW5lwdIThn/boDou2vyi0bQA==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.0.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/otlp-exporter-base': 0.38.0_@opentelemetry+api@1.4.1 - '@opentelemetry/otlp-proto-exporter-base': 0.38.0_@opentelemetry+api@1.4.1 - '@opentelemetry/otlp-transformer': 0.38.0_@opentelemetry+api@1.4.1 - '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-exporter-base': 0.38.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-proto-exporter-base': 0.38.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-transformer': 0.38.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.7.0 dev: false - /@opentelemetry/exporter-zipkin/1.12.0_@opentelemetry+api@1.4.1: + /@opentelemetry/exporter-trace-otlp-proto/0.46.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-A7PftDM57w1TLiirrhi8ceAnCpYkpUBObELdn239IyYF67zwngImGfBLf5Yo3TTAOA2Oj1TL76L8zWVL8W+Suw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-exporter-base': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-proto-exporter-base': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-transformer': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.19.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/exporter-trace-otlp-proto/0.48.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-hVXr/8DYlAKAzQYMsCf3ZsGweS6NTK3IHIEqmLokJZYcvJQBEEazeAdISfrL/utWnapg1Qnpw8u+W6SpxNzmTw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-exporter-base': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-proto-exporter-base': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-transformer': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.21.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/exporter-zipkin/1.12.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-HJ4ww7OjVIV4x5ZGgY+h+D1JS0GsCtnHuqZUVHl7EFFQxMGpbQcf5eISRtwqgQwlQKh2iqrEbiHdDyzbgA/7XQ==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.0.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.7.0 '@opentelemetry/semantic-conventions': 1.12.0 dev: false - /@opentelemetry/instrumentation-amqplib/0.32.5_@opentelemetry+api@1.4.1: + /@opentelemetry/exporter-zipkin/1.19.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-TY1fy4JiOBN5a8T9fknqTMcz0DXIeFBr6sklaLCgwtj+G699a5R4CekNwpeM7DHSwC44UMX7gljO2I6dYsTS3A==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.19.0 + dev: false + + /@opentelemetry/exporter-zipkin/1.21.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-J0ejrOx52s1PqvjNalIHvY/4v9ZxR2r7XS7WZbwK3qpVYZlGVq5V1+iCNweqsKnb/miUt/4TFvJBc9f5Q/kGcA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + dev: false + + /@opentelemetry/instrumentation-amqplib/0.32.5_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-D2hTvDfXQxj/9ydOcrz8Na7O3rLpNwSAKYHju37Mc15YLN2rmhnB/kW7YyW2+z1eC+cbLPg2iDIxzLd1FsJ15Q==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.15.0_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-aws-lambda/0.35.3_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-amqplib/0.33.5_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-WQ/XPzNLOHL3fpsmgoQUkiKCkJ09hvPN8wGrGzzOHMiJ5/3LqvfvxsJ4Rcd6aWkA4il3hEfpl+V0VF0t/DP65A==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-amqplib/0.33.5_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-WQ/XPzNLOHL3fpsmgoQUkiKCkJ09hvPN8wGrGzzOHMiJ5/3LqvfvxsJ4Rcd6aWkA4il3hEfpl+V0VF0t/DP65A==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-aws-lambda/0.35.3_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-GCG0MyKSOyRfRUcWNUA0xLZQ5gVS+GDHXX//IIc01n81sFoWhgEl0wYWIa/ziLu7qKAAsJF1klKlMo/HppfkLQ==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/propagator-aws-xray': 1.2.1_@opentelemetry+api@1.4.1 - '@opentelemetry/resources': 1.15.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/propagator-aws-xray': 1.2.1_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 '@types/aws-lambda': 8.10.81 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-aws-sdk/0.34.3_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-aws-lambda/0.37.4_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-/wdZwUalIWAbxeycvmE+25c1xCMhe5EUuj8bN0MWWN3L8N2SYvfv6DmiRgwrTIPXRgIyFugh2udNiF4MezZN4Q==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/propagator-aws-xray': 1.3.1_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/aws-lambda': 8.10.122 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-aws-lambda/0.37.4_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-/wdZwUalIWAbxeycvmE+25c1xCMhe5EUuj8bN0MWWN3L8N2SYvfv6DmiRgwrTIPXRgIyFugh2udNiF4MezZN4Q==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/propagator-aws-xray': 1.3.1_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/aws-lambda': 8.10.122 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-aws-sdk/0.34.3_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-esz3PUIKnRlzu9rXtSPfQkoR/amvrNDqFJK7RGAmcOxvXg+4TQGLF3BY74ZCv84iBjSgvObL8ELkVofYH6cDWg==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.15.0_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/propagation-utils': 0.29.5_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/propagation-utils': 0.29.5_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-bunyan/0.31.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-aws-sdk/0.37.2_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-eFHHOk0P9EFQ9Ho+2w7KH9R8cH7hut0/ePSsrk0nAM6Tiq2lBPeHn8ialCWESAA9jSjy+iuDelwmqAEXEe+jrg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/propagation-utils': 0.30.6_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-aws-sdk/0.37.2_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-eFHHOk0P9EFQ9Ho+2w7KH9R8cH7hut0/ePSsrk0nAM6Tiq2lBPeHn8ialCWESAA9jSjy+iuDelwmqAEXEe+jrg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/propagation-utils': 0.30.6_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-bunyan/0.31.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-uwQPzNXq+f2/7odtYPsBlozm2bjDHLOB/r3pSO02BEnHG5L7RyzV7aPLH1xYTHrLnZAd8ew8Am5dGM4uRiO4sA==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 '@types/bunyan': 1.8.7 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-cassandra-driver/0.32.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-bunyan/0.34.1_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-+eshbCFr2dkUYO2jCpbYGFC5hs94UCOsQRK1XqNOjeiNvQRtqvKYqk8ARwJBYBX+aW4J02jOliAHQUh/d7gYPg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.46.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@types/bunyan': 1.8.9 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-bunyan/0.34.1_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-+eshbCFr2dkUYO2jCpbYGFC5hs94UCOsQRK1XqNOjeiNvQRtqvKYqk8ARwJBYBX+aW4J02jOliAHQUh/d7gYPg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.46.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@types/bunyan': 1.8.9 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-cassandra-driver/0.32.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-xBWXyg585E/8PFoIgEyUdvVo4y/9rO/plkH9h1LF7aE4xXpAiYKVKNVFh4BsOTcylJkFSEZEvbHnFM8z8zb4jA==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-connect/0.31.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-cassandra-driver/0.34.2_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-wuzq7QQ9o7PJnzseblNfBcURtM+9AwO6e1m644QYtAb/6YRR6qg6gAmAipVeQu01H5BuHBFC/92svaAkdIV2WQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-cassandra-driver/0.34.2_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-wuzq7QQ9o7PJnzseblNfBcURtM+9AwO6e1m644QYtAb/6YRR6qg6gAmAipVeQu01H5BuHBFC/92svaAkdIV2WQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-connect/0.31.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-cce1AVRfWyQUOvJHMARaT+0KK5gN5qvKfmiiecmNSlj4NVC6w2DzknMuoHy3WkHQEQKPgF0pJG034UaU6bLKFA==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.15.0_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 '@types/connect': 3.4.35 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-dataloader/0.4.3_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-connect/0.32.4_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-oUGph9idncdnHlQMwdIs6m6mii7Kdp9PpHkM9roOZy71h+2vvf6+cVn45bs2unBbE2Vxho2i/049QQbaYKDYlw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/connect': 3.4.36 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-connect/0.32.4_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-oUGph9idncdnHlQMwdIs6m6mii7Kdp9PpHkM9roOZy71h+2vvf6+cVn45bs2unBbE2Vxho2i/049QQbaYKDYlw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/connect': 3.4.36 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-cucumber/0.2.1_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-ydF0DpmE0D6wccAbxx1F+6kokzcSSRy3X78Bvgok/3fHUSSshGLErqNiQL1HV44OIcV6392P3tu/jtXtUq3UDQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-cucumber/0.2.1_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-ydF0DpmE0D6wccAbxx1F+6kokzcSSRy3X78Bvgok/3fHUSSshGLErqNiQL1HV44OIcV6392P3tu/jtXtUq3UDQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-dataloader/0.4.3_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-iV1noFh7rOjDJ5WXg3o5mQIaEnxTCIpFGWPxqwK2kta3p78wU0KpYIz9x4MvdEVjFyTXxfB7iVz1kQ2g2b6Kpw==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-dns/0.31.5_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-dataloader/0.5.4_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-l1qQvvygxZJw+S+4hgYgzvT4GArqBrar42wzB5LVsOy04+gmbDw/4y7IqxZYepFyXKuBownGS8pR4huRL/Tj/A==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-dataloader/0.5.4_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-l1qQvvygxZJw+S+4hgYgzvT4GArqBrar42wzB5LVsOy04+gmbDw/4y7IqxZYepFyXKuBownGS8pR4huRL/Tj/A==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-dns/0.31.5_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-jGMpUzUlPT0mPum2N931Q918cuAfrEJOTHM35O1+YpCfjBnpbj+Vx77pIX0dSdWPxrigiPNZqdxQ2GadfdwBCA==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 semver: 7.5.4 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-express/0.32.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-dns/0.32.5_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-fHJqrbezpZSipo4O9nF9yGq6R8oyr1W2gSlyk1foJNXBaqdCODTlzIa7BP50vGtLBN/m+qO8pMOWCJmYSBX35g==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + semver: 7.5.4 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-dns/0.32.5_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-fHJqrbezpZSipo4O9nF9yGq6R8oyr1W2gSlyk1foJNXBaqdCODTlzIa7BP50vGtLBN/m+qO8pMOWCJmYSBX35g==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + semver: 7.5.4 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-express/0.32.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-67o/pc2GYRxNpgC5nw6xrPvxlpGKjr43dsukR23IJom45gtsZjt0V7YjEGw40MAvtdsrG0PMkthjXNBvr34Y6A==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.15.0_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 '@types/express': 4.17.13 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-fastify/0.31.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-express/0.34.1_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-pQBQxXpkH6imvzwCdPcw2FKjB1cphoRpmWTiGi6vtBdKXCP0hpne613ycpwhGG7C17S+mbarVmukbJKR4rmh6Q==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-express/0.34.1_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-pQBQxXpkH6imvzwCdPcw2FKjB1cphoRpmWTiGi6vtBdKXCP0hpne613ycpwhGG7C17S+mbarVmukbJKR4rmh6Q==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-fastify/0.31.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-3qYJySc+Eo0cpQVpE/MGbMi+WKU7n9OxQIEj/CswTcn3W1H7ot9dreV8IchNdM6WrRhUjFmAMCtrDS7Ewdvkpg==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.15.0_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-fs/0.7.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-fastify/0.32.6_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-UkBu8rAqeVC034jsRMiEAmYhFQ03pvmE/MnoPKE9gAbgVtPILdekHYqAKM0MdqnEjW7pO45t4wWsbtIcN0eiBw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-fastify/0.32.6_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-UkBu8rAqeVC034jsRMiEAmYhFQ03pvmE/MnoPKE9gAbgVtPILdekHYqAKM0MdqnEjW7pO45t4wWsbtIcN0eiBw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-fetch/0.48.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-y4Zw9VeUUMaowg3aXYZXcaUJQ7IKfpR6sjClrAQOJwWG8LYFpM6NIRSoAeJv/ShfxWWCPWC0P4zgXcKRqpURFQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-web': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-fetch/0.48.0_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-y4Zw9VeUUMaowg3aXYZXcaUJQ7IKfpR6sjClrAQOJwWG8LYFpM6NIRSoAeJv/ShfxWWCPWC0P4zgXcKRqpURFQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.48.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/sdk-trace-web': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-fs/0.7.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-JN+X7nfBeEbl2dvyd/6IBqVujjqE5/fY0oJdju2kW6X/fsKyIBTlEoKW1nlI+VLO6JVwTMTkvREFTvTOlGZqsA==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.15.0_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-generic-pool/0.31.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-fs/0.8.4_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-g99963nK8TuisUM3KH+ee5hOCHdCHSKiAdmy0RMdiKT7ITh3rXUct7fghQibViQA7FVPkdwM9+uRKkigJSFS9w==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-fs/0.8.4_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-g99963nK8TuisUM3KH+ee5hOCHdCHSKiAdmy0RMdiKT7ITh3rXUct7fghQibViQA7FVPkdwM9+uRKkigJSFS9w==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-generic-pool/0.31.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-S9LpOtGhk7COsC6GmkF5i/BB+XQD8qBbMgLHR0/fccsrzxTw7wd2IMo2hZOLPBYDvaSrywmOy8etJGT34eOEQA==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 '@types/generic-pool': 3.8.1 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-graphql/0.34.3_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-generic-pool/0.32.5_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-MNFloXa3SDg/rHh397JnWADr7iYQ6HHRwT7ZId5Vt0L1Xx+Qp3XSIILsXk5qTXVUIytEIVgn8iMT+kZILHzSqg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-generic-pool/0.32.5_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-MNFloXa3SDg/rHh397JnWADr7iYQ6HHRwT7ZId5Vt0L1Xx+Qp3XSIILsXk5qTXVUIytEIVgn8iMT+kZILHzSqg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-graphql/0.34.3_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-5NTOZWpIr0/E6FbftUHpoR6MxdySjcnNbHA3XAVqqAgLg5w5cmsaJepeKPxrbbNI91CShXqwcrNcaHueUGGCBw==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-grpc/0.35.1_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-graphql/0.36.1_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-EOvaS+d2909TOJJjNTsb0vHaLg8WdTLoQS8bRKdy3lMgdd7I4OL9/LSC7dp4M8CvJKz9B464Ix9PnARvhMkNOw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-graphql/0.36.1_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-EOvaS+d2909TOJJjNTsb0vHaLg8WdTLoQS8bRKdy3lMgdd7I4OL9/LSC7dp4M8CvJKz9B464Ix9PnARvhMkNOw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-grpc/0.35.1_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-EBmpCD+5QfUXPmupynjwxt3tUG5bgTrGZT12B0/+By9ZMLboDAryHjpiermanbPh5mTOq0q73YzruGQWU9TExg==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.35.1_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.35.1_@opentelemetry+api@1.7.0 '@opentelemetry/semantic-conventions': 1.9.1 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-hapi/0.31.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-grpc/0.46.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-KemIpB4jmywQv/+MbVoUIMVp3vr+rzra37TYbN7kTsbrn213YlzdXVamf6nq/yChI6q+9JlUnCdSZf86D6NO6g==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.19.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-grpc/0.46.0_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-KemIpB4jmywQv/+MbVoUIMVp3vr+rzra37TYbN7kTsbrn213YlzdXVamf6nq/yChI6q+9JlUnCdSZf86D6NO6g==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.19.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-hapi/0.31.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-6A8jxzeHow6RwrlM2PRfV10C2sVAeqy3L8EBa8FvNoUQiZbmmHhJssu0lxgeRabI3VS/1vDrac1zASN3aMqecQ==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.15.0_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 '@types/hapi__hapi': 20.0.9 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-http/0.35.1_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-hapi/0.33.3_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-l14u1TFPXMUjfHqnrHtzuMyLq6V8BikwhYJO/hIgkbaPCxS38TloCtDLJvcs8S8AZlcQfkUqE/NFgXYETZRo+Q==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/hapi__hapi': 20.0.13 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-hapi/0.33.3_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-l14u1TFPXMUjfHqnrHtzuMyLq6V8BikwhYJO/hIgkbaPCxS38TloCtDLJvcs8S8AZlcQfkUqE/NFgXYETZRo+Q==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/hapi__hapi': 20.0.13 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-http/0.35.1_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-tH92LznX5pcxpuTSb6A662IdldlMk8QTtneDN66h4nIT9ch98Gtu68GSSKjMoTR25GzH3opvPC9mX2xJamxMJw==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.9.1_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation': 0.35.1_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.9.1_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.35.1_@opentelemetry+api@1.7.0 '@opentelemetry/semantic-conventions': 1.9.1 semver: 7.5.4 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-ioredis/0.34.3_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-http/0.46.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-t5cxgqfV9AcxVP00/OL1ggkOSZM57VXDpvlWaOidYyyfLKcUJ9e2fGbNwoVsGFboRDeH0iFo7gLA3EEvX13wCA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.19.0 + semver: 7.5.4 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-http/0.46.0_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-t5cxgqfV9AcxVP00/OL1ggkOSZM57VXDpvlWaOidYyyfLKcUJ9e2fGbNwoVsGFboRDeH0iFo7gLA3EEvX13wCA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.19.0 + semver: 7.5.4 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-http/0.48.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-uXqOsLhW9WC3ZlGm6+PSX0xjSDTCfy4CMjfYj6TPWusOO8dtdx040trOriF24y+sZmS3M+5UQc6/3/ZxBJh4Mw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + semver: 7.5.4 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-http/0.48.0_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-uXqOsLhW9WC3ZlGm6+PSX0xjSDTCfy4CMjfYj6TPWusOO8dtdx040trOriF24y+sZmS3M+5UQc6/3/ZxBJh4Mw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.48.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + semver: 7.5.4 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-ioredis/0.34.3_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-k/4zPfdZSkdRYbx6CEjwgqi/UZlTUKk+8ZsthOzYsvmpCwPb1a1PomOa+1gk+5OvF83HanSy4mO06FhMx/NUgQ==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 '@opentelemetry/redis-common': 0.35.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/semantic-conventions': 1.21.0 '@types/ioredis4': /@types/ioredis/4.28.10 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-knex/0.31.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-ioredis/0.36.1_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-xxab7n4TD5igCFR5N0j5PJFYVeOXm54ZtCARVS32xavwGyGf+Sb6VtuVCLdl0re4JENCg18FO97Dyb1ql2EBUA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/redis-common': 0.36.1 + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/ioredis4': /@types/ioredis/4.28.10 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-ioredis/0.36.1_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-xxab7n4TD5igCFR5N0j5PJFYVeOXm54ZtCARVS32xavwGyGf+Sb6VtuVCLdl0re4JENCg18FO97Dyb1ql2EBUA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/redis-common': 0.36.1 + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/ioredis4': /@types/ioredis/4.28.10 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-knex/0.31.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-1Q0I5mn/pF5d42sZa9RWEayBft8c5XqQupC/MSaK6nuSZowQKcOPs5q8wMuPCB8Ma04xLmiH3N4MErjS3GIaSA==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-koa/0.34.6_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-knex/0.32.4_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-vqxK1wqhktQnBA7nGr6nqfhV5irSXK9v0R29hqlyTr/cB/86Hn3Z98zH58QvHo131FcE+d70QdiXu3P9S5vq4g==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-knex/0.32.4_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-vqxK1wqhktQnBA7nGr6nqfhV5irSXK9v0R29hqlyTr/cB/86Hn3Z98zH58QvHo131FcE+d70QdiXu3P9S5vq4g==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-koa/0.34.6_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-Rohp13k6t8XkbIKWjblW+qOovqSl3+OmgWHoyM8lf12cN0DAdCklwCKiittvht4ecVU/uRLh3MBIPIMCnkQa6g==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.15.0_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 '@types/koa': 2.13.6 '@types/koa__router': 8.0.7 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-lru-memoizer/0.32.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-koa/0.36.4_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-Qt6IF0mo3FZZ+x4NQhv/pViDtPSw/h/QYDvyIqMCuqUibqta619WLUCwAcanKnZWvzMuYh6lT0TnZ8ktjXo6jQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/koa': 2.13.9 + '@types/koa__router': 12.0.3 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-koa/0.36.4_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-Qt6IF0mo3FZZ+x4NQhv/pViDtPSw/h/QYDvyIqMCuqUibqta619WLUCwAcanKnZWvzMuYh6lT0TnZ8ktjXo6jQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/koa': 2.13.9 + '@types/koa__router': 12.0.3 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-lru-memoizer/0.32.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-5IxH+cW/2CsPR3owASTaO+RAlfs+oSZtHpCx/2LhjXms49yuLHB6YDFJcWyOW4QN6P2A3uLbxWYCxMt2XKy39Q==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-memcached/0.31.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-lru-memoizer/0.33.5_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-vbm9QPEYD3FZNGSa+7xQ7uOkgbJtskIwp1KnsCpmdBBiulhBaqqgeNLFo7gd8UxMrI2Vu3LTlZil2D0dVt8g/A==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-lru-memoizer/0.33.5_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-vbm9QPEYD3FZNGSa+7xQ7uOkgbJtskIwp1KnsCpmdBBiulhBaqqgeNLFo7gd8UxMrI2Vu3LTlZil2D0dVt8g/A==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-memcached/0.31.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-IDGys1d3aG7CGqgvZZ0dkmZCEFn1eQ3HPJCap+gUhjt7RRxLFYasa4h/GWviUHM3BNwJaA7VSmhEfbwxUCHxXw==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 '@types/memcached': 2.2.7 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-mongodb/0.34.3_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-memcached/0.32.5_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-1MS9LfgZruAsWOHVDTI+/Wy9mFFivUlpGUwYC4D+ho1I4NUyE33XHwL1BKcjMupkuRnE0JmbhdBfTG9Ai1vFkw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/memcached': 2.2.7 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-memcached/0.32.5_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-1MS9LfgZruAsWOHVDTI+/Wy9mFFivUlpGUwYC4D+ho1I4NUyE33XHwL1BKcjMupkuRnE0JmbhdBfTG9Ai1vFkw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/memcached': 2.2.7 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-mongodb/0.34.3_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-QCsX5vGjmmUnqLOlT+eThfBQ35JbQ3bdZSOCFvYu24+vqDEzMf+sWmgQVZuSlEGooXJ9lhlyFszPyUrTk2jS3g==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.39.1_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.39.1_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-mongoose/0.32.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-mongodb/0.38.1_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-X6YjE8dOCf8lG8FGmoAvczZq7LtgYaRzZcLGthZSUJQ2rfp1JJRlJixc+COvhrn1HJj5ab+AsSdUQgTpfQgEHQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-metrics': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-mongodb/0.38.1_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-X6YjE8dOCf8lG8FGmoAvczZq7LtgYaRzZcLGthZSUJQ2rfp1JJRlJixc+COvhrn1HJj5ab+AsSdUQgTpfQgEHQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/sdk-metrics': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-mongoose/0.32.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-JylmvZnH1ScQGc9tbV/6PIzk/rTNVgOtZDh9kJCYU0fbmX9a4lAsKav4kfnOK177IE+/jLsEECSUuytjqumGnQ==} engines: {node: '>=14.0'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.15.0_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-mysql/0.33.3_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-mongoose/0.34.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-/wGNK7qR/QXpcidXntKsnfACHETp8G/f2o/k8FPvJ2lukvdM9r7cHLys8QwkJkTN8Kt3qG1VIwarGKYtE/zOSw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-mongoose/0.34.0_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-/wGNK7qR/QXpcidXntKsnfACHETp8G/f2o/k8FPvJ2lukvdM9r7cHLys8QwkJkTN8Kt3qG1VIwarGKYtE/zOSw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-mysql/0.33.3_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-nzKW1mtEHu0YlUD+dRq+oPAMMQHMML5hLNDGKDwK/mcGqrXKHzaQKukVIKHv3AS3tMVBoayQi4Rz2LdZ/kylwA==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 '@types/mysql': 2.15.19 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-mysql2/0.33.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-mysql/0.34.5_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-cE8z1uJTeLcMj+R31t1pLkLqt3ryGMl1HApxsqqf8YCSHetrkVwGZOcyQ3phfgGSaNlC4/pdf3CQqfjhXbLWlA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/mysql': 2.15.22 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-mysql/0.34.5_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-cE8z1uJTeLcMj+R31t1pLkLqt3ryGMl1HApxsqqf8YCSHetrkVwGZOcyQ3phfgGSaNlC4/pdf3CQqfjhXbLWlA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/mysql': 2.15.22 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-mysql2/0.33.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-niaBa79lmgXTvMJXDpucPdiyTv+gUejkAiweAqgpigTTQM4T4qtfxNcw+dlP3vWAkHfu44+INy+96BHGlROxYw==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-nestjs-core/0.32.5_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-mysql2/0.34.5_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-Ai3+cJ83b11kLypIVEPLHuYCiIQjf828hHJPpllr78EhmHiq4S1yTW34aP3BzCBY+5Adr5PS5Nnv7NLBI/YfaQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + '@opentelemetry/sql-common': 0.40.0_@opentelemetry+api@1.7.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-mysql2/0.34.5_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-Ai3+cJ83b11kLypIVEPLHuYCiIQjf828hHJPpllr78EhmHiq4S1yTW34aP3BzCBY+5Adr5PS5Nnv7NLBI/YfaQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + '@opentelemetry/sql-common': 0.40.0_@opentelemetry+api@1.7.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-nestjs-core/0.32.5_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-fqPLahEiAW21aO60R+O+j5PJyfLHBczF+Ol7dodXpbzxd+9JWmiB2jeEgAAoOePDTJQC98WBuzfSZ8wRct06sQ==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-net/0.31.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-nestjs-core/0.33.4_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-AynD6TesE0bZg9UzS4ZLG//6TmU8GkRrjubhxs7jYZ3JRAlJAq1In0zSwM082JOIs7wr286nhs1FmqK91cG1cg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-nestjs-core/0.33.4_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-AynD6TesE0bZg9UzS4ZLG//6TmU8GkRrjubhxs7jYZ3JRAlJAq1In0zSwM082JOIs7wr286nhs1FmqK91cG1cg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-net/0.31.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-KbQg0Qwhu98+kgo2jIWw0/WqSxHA/Old6yFj8MoNOo/OF+SWQwaPHK1+oV9dZGV6v3aaikb//YnoaubWucUOiQ==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-pg/0.35.3_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-net/0.32.5_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-omBLTXyJeCtBy1MzVi+IzUcpXiup90k0z3AGhNKbzro4RhpsdMpN9O+3zZCXCIHMuyifhy7z8w99wmvvFO/FCQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-net/0.32.5_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-omBLTXyJeCtBy1MzVi+IzUcpXiup90k0z3AGhNKbzro4RhpsdMpN9O+3zZCXCIHMuyifhy7z8w99wmvvFO/FCQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-pg/0.35.3_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-Q37HiZJ1KsHH/gdzRHI8ixgiR1v7/+bFL+E/f6bi4BpPdJGJzer+sYYhdPyzpvGMFwlzRcGJpv9jYaQvCwJp9Q==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.15.0_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 '@types/pg': 8.6.1 '@types/pg-pool': 2.0.3 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-pino/0.33.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-pg/0.37.2_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-MAiKqdtGItYjvD6rOCyGS27CdMaDnh2JuImIHXhrPjq/sb2JlBNm6m1e4BH4uik1VfcKt/I3pI3UkydSWIscCg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + '@opentelemetry/sql-common': 0.40.0_@opentelemetry+api@1.7.0 + '@types/pg': 8.6.1 + '@types/pg-pool': 2.0.4 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-pg/0.37.2_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-MAiKqdtGItYjvD6rOCyGS27CdMaDnh2JuImIHXhrPjq/sb2JlBNm6m1e4BH4uik1VfcKt/I3pI3UkydSWIscCg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + '@opentelemetry/sql-common': 0.40.0_@opentelemetry+api@1.7.0 + '@types/pg': 8.6.1 + '@types/pg-pool': 2.0.4 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-pino/0.33.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-9jRkfICHBkwcP/O363Ft3cA2t7cuYgOyiW1L+hJ4rmnCmfAVOM+uNQ1dTezftkodgTvurlQbDjOBSKhvh2r2Pw==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-redis-4/0.34.6_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-pino/0.34.5_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-auYDSeFhkPFXayT/060mQRL7O88Bt5NKcV0qOfquNa9J5/qs5dlJYdTOraxPrjiGPM3tHaAJ+AvAhR0CPYgZew==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-pino/0.34.5_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-auYDSeFhkPFXayT/060mQRL7O88Bt5NKcV0qOfquNa9J5/qs5dlJYdTOraxPrjiGPM3tHaAJ+AvAhR0CPYgZew==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-redis-4/0.34.6_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-owBvjxm5QjSLaJJT23yX0Wx6DzBEE0m+yq3wue4k3yGToGgYienS5ThfrWNtkoTKhECJNajR0LyqZCtC+CGHsw==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 '@opentelemetry/redis-common': 0.35.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-redis/0.34.7_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-redis-4/0.35.6_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-OVSUJZAuy6OX18X2TKPdPlpwM5t4FooJU9QXiUxezhdMvfIAu00Agchw+gRbszkM7nvQ9dkXFOZO3nTmJNcLcA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/redis-common': 0.36.1 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-redis-4/0.35.6_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-OVSUJZAuy6OX18X2TKPdPlpwM5t4FooJU9QXiUxezhdMvfIAu00Agchw+gRbszkM7nvQ9dkXFOZO3nTmJNcLcA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/redis-common': 0.36.1 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-redis/0.34.7_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-mDfoMi73SXC5TRn/Xt1LRrQKYcz7w7TVekM8QlbPpx3KI7xKAjwa9+38psO1snhbX/nXdXgtcrtbXhz8nUJ+Sg==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 '@opentelemetry/redis-common': 0.35.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-restify/0.32.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-redis/0.35.5_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-UPYUncDlLqDPtyU11UhyZOUxAyPQS6yQGT0b96KjpqMhmuRb3b0WxzZh3SoIaAyprL5f9fxyeV2HfSulR0aWFQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/redis-common': 0.36.1 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-redis/0.35.5_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-UPYUncDlLqDPtyU11UhyZOUxAyPQS6yQGT0b96KjpqMhmuRb3b0WxzZh3SoIaAyprL5f9fxyeV2HfSulR0aWFQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/redis-common': 0.36.1 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-restify/0.32.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-puF9DaSKgC8NvqrUUt/5XA9iua+qOdtm8HhUvBmUlEfo8aNc//wfSd1znGAhg8jXaf5lRdYbOmBbT7SMM8gxiA==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.15.0_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-router/0.32.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-restify/0.34.3_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-nUqf4RTcQyc/YTWMT0e/ZqvuQqhRH04MOoSwaH6ocmyrEhKdPDq9AbvSMerQ/AxNC9yju/PytgzFFWH45hh3KA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-restify/0.34.3_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-nUqf4RTcQyc/YTWMT0e/ZqvuQqhRH04MOoSwaH6ocmyrEhKdPDq9AbvSMerQ/AxNC9yju/PytgzFFWH45hh3KA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-router/0.32.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-TbiufieBpP78UvVnECmhxuHtVWR0tfkZW53TwqsYShlNPeQjNYX377fLUw+S8Lnvnctqn47Wjt4SbCOBhNnZEg==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-socket.io/0.33.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-router/0.33.4_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-4140BgILsL0H8tA0BBN2tjzajgjxlDqd4xPatk2i5q9ofy8wlB0BlDJ4m36U7G1z0v+a+LshQSNqPP2VHZ9ORw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-router/0.33.4_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-4140BgILsL0H8tA0BBN2tjzajgjxlDqd4xPatk2i5q9ofy8wlB0BlDJ4m36U7G1z0v+a+LshQSNqPP2VHZ9ORw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-socket.io/0.33.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-6Rbg1d1q/OECrodA+ESFw30KA9zb0atrX+bk2rhLxhJMSO8s3MW9/rtdgkytLFS+nsEyPVMljmmOOPKwiki2Xg==} engines: {node: '>=14.0'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-tedious/0.5.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-socket.io/0.35.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-ED1/Wco05H9fepKqX7n2kONq9EXxkBZTKS29nUH9vVL7wSIT8sBIDqpHz94CnQ8xuicaQQ7c5h9TVuhjtzV43Q==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-socket.io/0.35.0_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-ED1/Wco05H9fepKqX7n2kONq9EXxkBZTKS29nUH9vVL7wSIT8sBIDqpHz94CnQ8xuicaQQ7c5h9TVuhjtzV43Q==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-tedious/0.5.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-i3P+/9+i8yWoMhrw9vCKClpiWB4lp9CGRF/riaRGTrPNF14IO2B0E+DpNMlOjCWydnOLnjZ/m0vIkbVLAdP9aw==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 - '@types/tedious': 4.0.9 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/tedious': 4.0.14 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation-winston/0.31.4_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-tedious/0.6.5_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-jjdrDegLUodz9np0yKCAa7sLxlAGTsxM7wU7l1mQ2NM6PHAGv4X3eSFClUk3fOipLx4+r5jTLnlsgu7g9CW+Qw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/tedious': 4.0.14 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-tedious/0.6.5_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-jjdrDegLUodz9np0yKCAa7sLxlAGTsxM7wU7l1mQ2NM6PHAGv4X3eSFClUk3fOipLx4+r5jTLnlsgu7g9CW+Qw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/semantic-conventions': 1.21.0 + '@types/tedious': 4.0.14 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-winston/0.31.4_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-AmUq5Do7FUoPLrehsDh45sK34qlPNg1i9HUieop3F+d1+gk+YPv2Z29WGi7KEnhM4/GJu2OsWq/pwzgemeNHuQ==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.40.0_@opentelemetry+api@1.7.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/instrumentation/0.35.1_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation-winston/0.33.1_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-4tSORoAY9f+yzqNVGcGr/3GydPMfgSiKK1OESc+qBwVTz0bmz4cOrhCruCngGzoqDCmPYpwqwR/8j4wRKgcUpw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation-winston/0.33.1_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-4tSORoAY9f+yzqNVGcGr/3GydPMfgSiKK1OESc+qBwVTz0bmz4cOrhCruCngGzoqDCmPYpwqwR/8j4wRKgcUpw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation/0.35.1_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-EZsvXqxenbRTSNsft6LDcrT4pjAiyZOx3rkDNeqKpwZZe6GmZtsXaZZKuDkJtz9fTjOGjDHjZj9/h80Ya9iIJw==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 + '@opentelemetry/api': 1.7.0 require-in-the-middle: 5.2.0 semver: 7.5.4 shimmer: 1.2.1 @@ -9178,13 +10826,13 @@ packages: - supports-color dev: false - /@opentelemetry/instrumentation/0.38.0_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation/0.38.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-wr1WkIbzHGV+oz6SCme88D2c+zNG23COkCjcida8b3jIzX2lJafOpEHPDcbBF38F8ChkRSj/tVnx1wnYAXZvbA==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 + '@opentelemetry/api': 1.7.0 require-in-the-middle: 6.0.0 semver: 7.5.4 shimmer: 1.2.1 @@ -9192,13 +10840,13 @@ packages: - supports-color dev: false - /@opentelemetry/instrumentation/0.39.1_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation/0.39.1_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-s7/9tPmM0l5KCd07VQizC4AO2/5UJdkXq5gMSHPdCeiMKSeBEdyDyQX7A+Cq+RYZM452qzFmrJ4ut628J5bnSg==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 + '@opentelemetry/api': 1.7.0 require-in-the-middle: 7.1.1 semver: 7.5.4 shimmer: 1.2.1 @@ -9206,13 +10854,13 @@ packages: - supports-color dev: false - /@opentelemetry/instrumentation/0.40.0_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation/0.40.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-23TzBKPflUS1uEq5SXymnQKQDSda35KvHjnvxdcDQGE+wg6hwDHgScUCWiBmZW4sxAaPcANfs+Wc9B7yDuyT6Q==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.3.0 dependencies: - '@opentelemetry/api': 1.4.1 + '@opentelemetry/api': 1.7.0 '@types/shimmer': 1.0.2 import-in-the-middle: 1.3.5 require-in-the-middle: 7.1.1 @@ -9222,17 +10870,101 @@ packages: - supports-color dev: false - /@opentelemetry/otlp-exporter-base/0.38.0_@opentelemetry+api@1.4.1: + /@opentelemetry/instrumentation/0.46.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-a9TijXZZbk0vI5TGLZl+0kxyFfrXHhX6Svtz7Pp2/VBlCSKrazuULEyoJQrOknJyFWNMEmbbJgOciHCCpQcisw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@types/shimmer': 1.0.2 + import-in-the-middle: 1.7.1 + require-in-the-middle: 7.1.1 + semver: 7.5.4 + shimmer: 1.2.1 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation/0.46.0_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-a9TijXZZbk0vI5TGLZl+0kxyFfrXHhX6Svtz7Pp2/VBlCSKrazuULEyoJQrOknJyFWNMEmbbJgOciHCCpQcisw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@types/shimmer': 1.0.2 + import-in-the-middle: 1.7.1 + require-in-the-middle: 7.1.1_supports-color@9.4.0 + semver: 7.5.4 + shimmer: 1.2.1 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation/0.48.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-sjtZQB5PStIdCw5ovVTDGwnmQC+GGYArJNgIcydrDSqUTdYBnMrN9P4pwQZgS3vTGIp+TU1L8vMXGe51NVmIKQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@types/shimmer': 1.0.2 + import-in-the-middle: 1.7.1 + require-in-the-middle: 7.1.1 + semver: 7.5.4 + shimmer: 1.2.1 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/instrumentation/0.48.0_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-sjtZQB5PStIdCw5ovVTDGwnmQC+GGYArJNgIcydrDSqUTdYBnMrN9P4pwQZgS3vTGIp+TU1L8vMXGe51NVmIKQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.3.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@types/shimmer': 1.0.2 + import-in-the-middle: 1.7.1 + require-in-the-middle: 7.1.1_supports-color@9.4.0 + semver: 7.5.4 + shimmer: 1.2.1 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/otlp-exporter-base/0.38.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-VWQo7vUDyW/7/FT8RErAtM/29i/fllCc9xMtnK7kDuheAjJU68zrZ88bQOsLamHvOCU3KVpozjfTZVxZKQRYXw==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.0.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 dev: false - /@opentelemetry/otlp-grpc-exporter-base/0.38.0_@opentelemetry+api@1.4.1: + /@opentelemetry/otlp-exporter-base/0.46.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-hfkh7cG17l77ZSLRAogz19SIJzr0KeC7xv5PDyTFbHFpwwoxV/bEViO49CqUFH6ckXB63NrltASP9R7po+ahTQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/otlp-exporter-base/0.48.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-T4LJND+Ugl87GUONoyoQzuV9qCn4BFIPOnCH1biYqdGhc2JahjuLqVD9aefwLzGBW638iLAo88Lh68h2F1FLiA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/otlp-grpc-exporter-base/0.38.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-wwGxeJt80w+mIA0aE+K9OshkyEoYQrXuwXl1TNZBs9K7qE4AAiEuxU9cbd3VX3BTsp+xzNcDRWIb9WWkiU9+kA==} engines: {node: '>=14'} peerDependencies: @@ -9240,73 +10972,212 @@ packages: dependencies: '@grpc/grpc-js': 1.8.17 '@grpc/proto-loader': 0.7.7 - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/otlp-exporter-base': 0.38.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-exporter-base': 0.38.0_@opentelemetry+api@1.7.0 dev: false - /@opentelemetry/otlp-proto-exporter-base/0.38.0_@opentelemetry+api@1.4.1: + /@opentelemetry/otlp-grpc-exporter-base/0.46.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-/KB/xfZZiWIY2JknvCoT/e9paIzQO3QCBN5gR6RyxpXM/AGx3YTAOKvB/Ts9Va19jo5aE74gB7emhFaCNy4Rmw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@grpc/grpc-js': 1.8.17 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-exporter-base': 0.46.0_@opentelemetry+api@1.7.0 + protobufjs: 7.2.6 + dev: false + + /@opentelemetry/otlp-grpc-exporter-base/0.48.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-Vdp56RK9OU+Oeoy3YQC/UMOWglKQ9qvgGr49FgF4r8vk5DlcTUgVS0m3KG8pykmRPA+5ZKaDuqwPw5aTvWmHFw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@grpc/grpc-js': 1.8.17 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-exporter-base': 0.48.0_@opentelemetry+api@1.7.0 + protobufjs: 7.2.6 + dev: false + + /@opentelemetry/otlp-proto-exporter-base/0.38.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-/Z68pIgFv+IwQQfJOJQ9ga7KZ5ET2cFAnpWO9JsxrHjW9glmX+T9RgcF7rfSAFl2JSM9A+kQ11WYRjE2tNKxqg==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.0.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/otlp-exporter-base': 0.38.0_@opentelemetry+api@1.4.1 - protobufjs: 7.2.4 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-exporter-base': 0.38.0_@opentelemetry+api@1.7.0 + protobufjs: 7.2.6 dev: false - /@opentelemetry/otlp-transformer/0.38.0_@opentelemetry+api@1.4.1: + /@opentelemetry/otlp-proto-exporter-base/0.46.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-rEJBA8U2AxfEzrdIUcyyjOweyVFkO6V1XAxwP161JkxpvNuVDdULHAfRVnGtoZhiVA1XsJKcpIIq2MEKAqq4cg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-exporter-base': 0.46.0_@opentelemetry+api@1.7.0 + protobufjs: 7.2.6 + dev: false + + /@opentelemetry/otlp-proto-exporter-base/0.48.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-14GSTvPZPfrWsB54fYMGb8v+Uge5xGXyz0r2rf4SzcRnO2hXCPHEuL3yyL50emaKPAY+fj29Dm0bweawe8UA6A==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/otlp-exporter-base': 0.48.0_@opentelemetry+api@1.7.0 + protobufjs: 7.2.6 + dev: false + + /@opentelemetry/otlp-transformer/0.38.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-ykQEipby0NVSi2ih5E8J2GNJ6y9zYDPSef0nD8j33XPKxfyVG5184rUrCsh6TIk1d/GlYl8gB9Wy4TdRvwl6kA==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': '>=1.3.0 <1.5.0' dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/sdk-metrics': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-metrics': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.7.0 dev: false - /@opentelemetry/propagation-utils/0.29.5_@opentelemetry+api@1.4.1: + /@opentelemetry/otlp-transformer/0.46.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-Fj9hZwr6xuqgsaERn667Uf6kuDG884puWhyrai2Jen2Fq+bGf4/5BzEJp/8xvty0VSU4EfXOto/ys3KpSz2UHg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.46.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-logs': 0.46.0_b4ttzq43gtblpycwykjioqjhcq + '@opentelemetry/sdk-metrics': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.19.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/otlp-transformer/0.48.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-yuoS4cUumaTK/hhxW3JUy3wl2U4keMo01cFDrUOmjloAdSSXvv1zyQ920IIH4lymp5Xd21Dj2/jq2LOro56TJg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.48.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-logs': 0.48.0_wj3rtarwgmsxddfed6zfae5bhe + '@opentelemetry/sdk-metrics': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.21.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/propagation-utils/0.29.5_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-TRVQAZZfXmatJ8ZrjtQadxv+3n1DbQl42aK2/UOeZ0THdz9EqQ2+IBbvPD484c8H7pjUVUwqDOsk+1BOSPwXEw==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.0.0 dependencies: - '@opentelemetry/api': 1.4.1 + '@opentelemetry/api': 1.7.0 dev: false - /@opentelemetry/propagator-aws-xray/1.2.1_@opentelemetry+api@1.4.1: + /@opentelemetry/propagation-utils/0.30.6_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-qvnYee5I/xrBY5XClUlOASIOdoTbnFGNI6+ViKqdoErF2xKmhysXcmxlJNzQFNDK0muTfjvJMZcFyEielARk7g==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + dev: false + + /@opentelemetry/propagator-aws-xray/1.2.1_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-xGPBHXwMvrFuRUfyWj6HEUuQX/QSblN3pcGila/wX01/9KYO5TgFvwKOqR9uxLqvS1s/NaF8J1afsieYCGp7Tg==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': ^1.0.0 dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.15.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 dev: false - /@opentelemetry/propagator-b3/1.12.0_@opentelemetry+api@1.4.1: + /@opentelemetry/propagator-aws-xray/1.3.1_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-6fDMzFlt5r6VWv7MUd0eOpglXPFqykW8CnOuUxJ1VZyLy6mV1bzBlzpsqEmhx1bjvZYvH93vhGkQZqrm95mlrQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/propagator-b3/1.12.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-WFcn98075QPc2zE1obhKydJHUehI5/HuLoelPEVwATj+487hjCwjHj9r2fgmQkWpvuNSB7CJaA0ys6qqq1N6lg==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': '>=1.0.0 <1.5.0' dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 dev: false - /@opentelemetry/propagator-jaeger/1.12.0_@opentelemetry+api@1.4.1: + /@opentelemetry/propagator-b3/1.19.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-v7y5IBOKBm0vP3yf0DHzlw4L2gL6tZ0KeeMTaxfO5IuomMffDbrGWcvYFp0Dt4LdZctTSK523rVLBB9FBHBciQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/propagator-b3/1.21.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-3ZTobj2VDIOzLsIvvYCdpw6tunxUVElPxDvog9lS49YX4hohHeD84A8u9Ns/6UYUcaN5GSoEf891lzhcBFiOLA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/propagator-jaeger/1.12.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-ugtWF7GC6X5RIJ0+iMwW2iVAGNs206CAeq8XQ8OkJRg+v0lp4H0/i+gJ4hubTT8NIL5a3IxtIrAENPLIGdLucQ==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': '>=1.0.0 <1.5.0' dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/propagator-jaeger/1.19.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-dedkOoTzKg+nYoLWCMp0Im+wo+XkTRW6aXhi8VQRtMW/9SNJGOllCJSu8llToLxMDF0+6zu7OCrKkevAof2tew==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/propagator-jaeger/1.21.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-8TQSwXjBmaDx7JkxRD7hdmBmRK2RGRgzHX1ArJfJhIc5trzlVweyorzqQrXOvqVEdEg+zxUMHkL5qbGH/HDTPA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 dev: false /@opentelemetry/redis-common/0.35.1: @@ -9314,101 +11185,452 @@ packages: engines: {node: '>=14'} dev: false - /@opentelemetry/resources/1.12.0_@opentelemetry+api@1.4.1: + /@opentelemetry/redis-common/0.36.1: + resolution: {integrity: sha512-YjfNEr7DK1Ymc5H0bzhmqVvMcCs+PUEUerzrpTFdHfZxj3HpnnjZTIFKx/gxiL/sajQ8dxycjlreoYTVYKBXlw==} + engines: {node: '>=14'} + dev: false + + /@opentelemetry/resource-detector-alibaba-cloud/0.28.6_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-VuJXc+oDQ/SYRHBCQbEshl0WJtEMvgfSkTDBq+WSxj6y9sKe0HCt55Sxeb5nLmBdtCYWMQFniHe2K4GLSjDZVw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + dev: false + + /@opentelemetry/resource-detector-aws/1.3.6_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-hFJ19yFwChqGCv1uMkXtjZU9BG8GcChe8cRCAkGWg1RZADse5S2ausf3D8pYw1cR3ktJtuAmRrGZniT6TDUPDw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + dev: false + + /@opentelemetry/resource-detector-container/0.3.6_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-psxtzQakVuZKFl/ukn+nPW4Ixn+KPHGsWJMYKndmXrsgdFri78X+MHR0wLOO41Zn79sc35DiSk+GdJ24cCylbg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + dev: false + + /@opentelemetry/resource-detector-gcp/0.29.6_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-cx03fXPknmiVW0hpWAJr0Nr8xwkwRB8VNWPvNrmP7UzJ8eEztY9lHnVke4ZVFaVGvm/4EFxk2y5hPNggbIezoA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + gcp-metadata: 6.1.0 + transitivePeerDependencies: + - encoding + - supports-color + dev: false + + /@opentelemetry/resource-detector-gcp/0.29.6_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-cx03fXPknmiVW0hpWAJr0Nr8xwkwRB8VNWPvNrmP7UzJ8eEztY9lHnVke4ZVFaVGvm/4EFxk2y5hPNggbIezoA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.0.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + gcp-metadata: 6.1.0_supports-color@9.4.0 + transitivePeerDependencies: + - encoding + - supports-color + dev: false + + /@opentelemetry/resources/0.25.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-O46u53vDBlxCML8O9dIjsRcCC2VT5ri1upwhp02ITobgJ16aVD/iScCo1lPl/x2E7yq9uwzMINENiiYZRFb6XA==} + engines: {node: '>=8.0.0'} + peerDependencies: + '@opentelemetry/api': ^1.0.2 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 0.25.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 0.25.0 + dev: false + + /@opentelemetry/resources/1.12.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-gunMKXG0hJrR0LXrqh7BVbziA/+iJBL3ZbXCXO64uY+SrExkwoyJkpiq9l5ismkGF/A20mDEV7tGwh+KyPw00Q==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': '>=1.0.0 <1.5.0' dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 '@opentelemetry/semantic-conventions': 1.12.0 dev: false - /@opentelemetry/resources/1.15.0_@opentelemetry+api@1.4.1: - resolution: {integrity: sha512-Sb8A6ZXHXDlgHv32UNRE3y8McWE3vkb5dsSttYArYa5ZpwjiF5ge0vnnKUUnG7bY0AgF9VBIOORZE8gsrnD2WA==} + /@opentelemetry/resources/1.19.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-RgxvKuuMOf7nctOeOvpDjt2BpZvZGr9Y0vf7eGtY5XYZPkh2p7e2qub1S2IArdBMf9kEbz0SfycqCviOu9isqg==} engines: {node: '>=14'} peerDependencies: - '@opentelemetry/api': '>=1.0.0 <1.5.0' + '@opentelemetry/api': '>=1.0.0 <1.8.0' dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.15.0_@opentelemetry+api@1.4.1 - '@opentelemetry/semantic-conventions': 1.15.0 - tslib: 2.6.2 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.19.0 dev: false - /@opentelemetry/sdk-metrics/1.12.0_@opentelemetry+api@1.4.1: + /@opentelemetry/resources/1.21.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-1Z86FUxPKL6zWVy2LdhueEGl9AHDJcx+bvHStxomruz6Whd02mE3lNUMjVJ+FGRoktx/xYQcxccYb03DiUP6Yw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + dev: false + + /@opentelemetry/sdk-logs/0.46.0_b4ttzq43gtblpycwykjioqjhcq: + resolution: {integrity: sha512-Knlyk4+G72uEzNh6GRN1Fhmrj+/rkATI5/lOrevN7zRDLgp4kfyZBGGoWk7w+qQjlYvwhIIdPVxlIcipivdZIg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.4.0 <1.8.0' + '@opentelemetry/api-logs': '>=0.39.1' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.46.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.19.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/sdk-logs/0.48.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-lRcA5/qkSJuSh4ItWCddhdn/nNbVvnzM+cm9Fg1xpZUeTeozjJDBcHnmeKoOaWRnrGYBdz6UTY6bynZR9aBeAA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.4.0 <1.8.0' + '@opentelemetry/api-logs': '>=0.39.1' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/sdk-logs/0.48.0_wj3rtarwgmsxddfed6zfae5bhe: + resolution: {integrity: sha512-lRcA5/qkSJuSh4ItWCddhdn/nNbVvnzM+cm9Fg1xpZUeTeozjJDBcHnmeKoOaWRnrGYBdz6UTY6bynZR9aBeAA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.4.0 <1.8.0' + '@opentelemetry/api-logs': '>=0.39.1' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.48.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + dev: false + + /@opentelemetry/sdk-metrics-base/0.25.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-7fwPlAFB5Xw8mnVQfq0wqKNw3RXiAMad9T1bk5Sza9LK/L6hz8RTuHWCsFMsj+1OOSAaiPFuUMYrK1J75+2IAg==} + engines: {node: '>=8.0.0'} + deprecated: Please use @opentelemetry/sdk-metrics + peerDependencies: + '@opentelemetry/api': ^1.0.2 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-metrics': 0.25.0_@opentelemetry+api@1.7.0 + '@opentelemetry/core': 0.25.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 0.25.0_@opentelemetry+api@1.7.0 + lodash.merge: 4.6.2 + dev: false + + /@opentelemetry/sdk-metrics/1.12.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-zOy88Jfk88eTxqu+9ypHLs184dGydJocSWtvWMY10QKVVaxhC3SLKa0uxI/zBtD9S+x0LP65wxrTSfSoUNtCOA==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': '>=1.3.0 <1.5.0' dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.7.0 lodash.merge: 4.6.2 dev: false - /@opentelemetry/sdk-node/0.38.0_@opentelemetry+api@1.4.1: + /@opentelemetry/sdk-metrics/1.19.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-FiMii40zr0Fmys4F1i8gmuCvbinBnBsDeGBr4FQemOf0iPCLytYQm5AZJ/nn4xSc71IgKBQwTFQRAGJI7JvZ4Q==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.19.0_@opentelemetry+api@1.7.0 + lodash.merge: 4.6.2 + dev: false + + /@opentelemetry/sdk-metrics/1.21.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-on1jTzIHc5DyWhRP+xpf+zrgrREXcHBH4EDAfaB5mIG7TWpKxNXooQ1JCylaPsswZUv4wGnVTinr4HrBdGARAQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + lodash.merge: 4.6.2 + dev: false + + /@opentelemetry/sdk-node/0.38.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-L91SSwq5Et9348ONtQGEimSAEKaqgJxoScRgh7OB/7OlIG0Q6l/pyIGULXtZkAlMMkiWdQOiYFkLV+0LLZr+JA==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': '>=1.3.0 <1.5.0' dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/exporter-jaeger': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/exporter-trace-otlp-grpc': 0.38.0_@opentelemetry+api@1.4.1 - '@opentelemetry/exporter-trace-otlp-http': 0.38.0_@opentelemetry+api@1.4.1 - '@opentelemetry/exporter-trace-otlp-proto': 0.38.0_@opentelemetry+api@1.4.1 - '@opentelemetry/exporter-zipkin': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/instrumentation': 0.38.0_@opentelemetry+api@1.4.1 - '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/sdk-metrics': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/sdk-trace-node': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-jaeger': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-grpc': 0.38.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-http': 0.38.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-proto': 0.38.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-zipkin': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.38.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-metrics': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-node': 1.12.0_@opentelemetry+api@1.7.0 '@opentelemetry/semantic-conventions': 1.12.0 transitivePeerDependencies: - supports-color dev: false - /@opentelemetry/sdk-trace-base/1.12.0_@opentelemetry+api@1.4.1: + /@opentelemetry/sdk-node/0.46.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-BQhzdCRZXchhKjZaFkgxlgoowjOt/QXekJ1CZgfvFO9Yg5GV15LyJFUEyQkDyD8XbshGo3Cnj0WZMBnDWtWY1A==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.46.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-grpc': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-http': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-proto': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-zipkin': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-logs': 0.46.0_b4ttzq43gtblpycwykjioqjhcq + '@opentelemetry/sdk-metrics': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-node': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.19.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/sdk-node/0.46.0_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-BQhzdCRZXchhKjZaFkgxlgoowjOt/QXekJ1CZgfvFO9Yg5GV15LyJFUEyQkDyD8XbshGo3Cnj0WZMBnDWtWY1A==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.46.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-grpc': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-http': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-proto': 0.46.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-zipkin': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.46.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/resources': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-logs': 0.46.0_b4ttzq43gtblpycwykjioqjhcq + '@opentelemetry/sdk-metrics': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-node': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.19.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/sdk-node/0.48.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-3o3GS6t+VLGVFCV5bqfGOcWIgOdkR/UE6Qz7hHksP5PXrVBeYsPqts7cPma5YXweaI3r3h26mydg9PqQIcqksg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.48.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-grpc': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-http': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-proto': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-zipkin': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-logs': 0.48.0_wj3rtarwgmsxddfed6zfae5bhe + '@opentelemetry/sdk-metrics': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-node': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/sdk-node/0.48.0_rr4fxqkzz7nhz3auplkqn4p6em: + resolution: {integrity: sha512-3o3GS6t+VLGVFCV5bqfGOcWIgOdkR/UE6Qz7hHksP5PXrVBeYsPqts7cPma5YXweaI3r3h26mydg9PqQIcqksg==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.3.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/api-logs': 0.48.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-grpc': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-http': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-trace-otlp-proto': 0.48.0_@opentelemetry+api@1.7.0 + '@opentelemetry/exporter-zipkin': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/instrumentation': 0.48.0_rr4fxqkzz7nhz3auplkqn4p6em + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-logs': 0.48.0_wj3rtarwgmsxddfed6zfae5bhe + '@opentelemetry/sdk-metrics': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-node': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + transitivePeerDependencies: + - supports-color + dev: false + + /@opentelemetry/sdk-trace-base/0.25.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-TInkLSF/ThM3GNVM+9tgnCVjyNLnRxvAkG585Fhu0HNwaEtCTUwI0r7AvMRIREOreeRWttBG6kvT0LOKdo8yjw==} + engines: {node: '>=8.0.0'} + peerDependencies: + '@opentelemetry/api': ^1.0.2 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 0.25.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 0.25.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 0.25.0 + lodash.merge: 4.6.2 + dev: false + + /@opentelemetry/sdk-trace-base/1.12.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-pfCOB3tNDlYVoWuz4D7Ji+Jmy9MHnATWHVpkERdCEiwUGEZ+4IvNPXUcPc37wJVmMpjGLeaWgPPrie0KIpWf1A==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': '>=1.0.0 <1.5.0' dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.12.0_@opentelemetry+api@1.7.0 '@opentelemetry/semantic-conventions': 1.12.0 dev: false - /@opentelemetry/sdk-trace-node/1.12.0_@opentelemetry+api@1.4.1: + /@opentelemetry/sdk-trace-base/1.19.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-+IRvUm+huJn2KqfFW3yW/cjvRwJ8Q7FzYHoUNx5Fr0Lws0LxjMJG1uVB8HDpLwm7mg5XXH2M5MF+0jj5cM8BpQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.19.0 + dev: false + + /@opentelemetry/sdk-trace-base/1.21.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-yrElGX5Fv0umzp8Nxpta/XqU71+jCAyaLk34GmBzNcrW43nqbrqvdPs4gj4MVy/HcTjr6hifCDCYA3rMkajxxA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/resources': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + dev: false + + /@opentelemetry/sdk-trace-node/1.12.0_@opentelemetry+api@1.7.0: resolution: {integrity: sha512-PxpDemnNZLLeFNLAu95/K3QubjlaScXVjVQPlwPui65VRxIvxGVysnN7DFfsref+qoh1hI6nlrYSij43vxdm2w==} engines: {node: '>=14'} peerDependencies: '@opentelemetry/api': '>=1.0.0 <1.5.0' dependencies: - '@opentelemetry/api': 1.4.1 - '@opentelemetry/context-async-hooks': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/propagator-b3': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/propagator-jaeger': 1.12.0_@opentelemetry+api@1.4.1 - '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.4.1 + '@opentelemetry/api': 1.7.0 + '@opentelemetry/context-async-hooks': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/core': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/propagator-b3': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/propagator-jaeger': 1.12.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.12.0_@opentelemetry+api@1.7.0 semver: 7.5.4 dev: false + /@opentelemetry/sdk-trace-node/1.19.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-TCiEq/cUjM15RFqBRwWomTVbOqzndWL4ILa7ZCu0zbjU1/XY6AgHkgrgAc7vGP6TjRqH4Xryuglol8tcIfbBUQ==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/context-async-hooks': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/core': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/propagator-b3': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/propagator-jaeger': 1.19.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.19.0_@opentelemetry+api@1.7.0 + semver: 7.5.4 + dev: false + + /@opentelemetry/sdk-trace-node/1.21.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-1pdm8jnqs+LuJ0Bvx6sNL28EhC8Rv7NYV8rnoXq3GIQo7uOHBDAFSj7makAfbakrla7ecO1FRfI8emnR4WvhYA==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/context-async-hooks': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/propagator-b3': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/propagator-jaeger': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.21.0_@opentelemetry+api@1.7.0 + semver: 7.5.4 + dev: false + + /@opentelemetry/sdk-trace-web/1.21.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-MxkmY/UNXkDiZj7JUu5T7wWt8Ai4NJEwSjGoQQ9YLvgLUIivvaIo9Mne+Q+KLOUG2v/uhivz3qzxbCODVa0c1A==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': '>=1.0.0 <1.8.0' + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/sdk-trace-base': 1.21.0_@opentelemetry+api@1.7.0 + '@opentelemetry/semantic-conventions': 1.21.0 + dev: false + + /@opentelemetry/semantic-conventions/0.25.0: + resolution: {integrity: sha512-V3N+MDBiv0TUlorbgiSqk6CvcP876CYUk/41Tg6s8OIyvniTwprE6vPvFQayuABiVkGlHOxv1Mlvp0w4qNdnVg==} + engines: {node: '>=8.0.0'} + dev: false + /@opentelemetry/semantic-conventions/1.12.0: resolution: {integrity: sha512-hO+bdeGOlJwqowUBoZF5LyP3ORUFOP1G0GRv8N45W/cztXbT2ZEXaAzfokRS9Xc9FWmYrDj32mF6SzH6wuoIyA==} engines: {node: '>=14'} dev: false - /@opentelemetry/semantic-conventions/1.15.0: - resolution: {integrity: sha512-f3wwFrFyCpGrFBrFs7lCUJSCSCGyeKG52c+EKeobs3Dd29M75yO6GYkt6PkYPfDawxSlV5p+4yJPPk8tPObzTQ==} + /@opentelemetry/semantic-conventions/1.19.0: + resolution: {integrity: sha512-14jRpC8f5c0gPSwoZ7SbEJni1PqI+AhAE8m1bMz6v+RPM4OlP1PT2UHBJj5Qh/ALLPjhVU/aZUK3YyjTUqqQVg==} + engines: {node: '>=14'} + dev: false + + /@opentelemetry/semantic-conventions/1.21.0: + resolution: {integrity: sha512-lkC8kZYntxVKr7b8xmjCVUgE0a8xgDakPyDo9uSWavXPyYqLgYYGdEd2j8NxihRyb6UwpX3G/hFUF4/9q2V+/g==} engines: {node: '>=14'} - dependencies: - tslib: 2.6.2 dev: false /@opentelemetry/semantic-conventions/1.9.1: @@ -9416,6 +11638,16 @@ packages: engines: {node: '>=14'} dev: false + /@opentelemetry/sql-common/0.40.0_@opentelemetry+api@1.7.0: + resolution: {integrity: sha512-vSqRJYUPJVjMFQpYkQS3ruexCPSZJ8esne3LazLwtCPaPRvzZ7WG3tX44RouAn7w4wMp8orKguBqtt+ng2UTnw==} + engines: {node: '>=14'} + peerDependencies: + '@opentelemetry/api': ^1.1.0 + dependencies: + '@opentelemetry/api': 1.7.0 + '@opentelemetry/core': 1.21.0_@opentelemetry+api@1.7.0 + dev: false + /@peculiar/asn1-schema/2.3.6: resolution: {integrity: sha512-izNRxPoaeJeg/AyH8hER6s+H7p4itk+03QCa4sbxI3lNdseQYCuxzgsuNK8bTXChtLTjpJz6NmXKA73qLa3rCA==} dependencies: @@ -9558,46 +11790,36 @@ packages: /@protobufjs/aspromise/1.1.2: resolution: {integrity: sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==} - dev: false /@protobufjs/base64/1.1.2: resolution: {integrity: sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==} - dev: false /@protobufjs/codegen/2.0.4: resolution: {integrity: sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==} - dev: false /@protobufjs/eventemitter/1.1.0: resolution: {integrity: sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==} - dev: false /@protobufjs/fetch/1.1.0: resolution: {integrity: sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==} dependencies: '@protobufjs/aspromise': 1.1.2 '@protobufjs/inquire': 1.1.0 - dev: false /@protobufjs/float/1.0.2: resolution: {integrity: sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==} - dev: false /@protobufjs/inquire/1.1.0: resolution: {integrity: sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==} - dev: false /@protobufjs/path/1.1.2: resolution: {integrity: sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==} - dev: false /@protobufjs/pool/1.1.0: resolution: {integrity: sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==} - dev: false /@protobufjs/utf8/1.1.0: resolution: {integrity: sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==} - dev: false /@radix-ui/number/1.0.0: resolution: {integrity: sha512-Ofwh/1HX69ZfJRiRBMTy7rgjAzHmwe4kW9C9Y99HTRUcYLUuVT0KESFj15rPjRgKJs20GPq8Bm5aEDJ8DuA3vA==} @@ -12576,6 +14798,17 @@ packages: - supports-color dev: false + /@sigstore/sign/1.0.0_supports-color@9.4.0: + resolution: {integrity: sha512-INxFVNQteLtcfGmcoldzV6Je0sbbfh9I16DM4yJPw3j5+TFP8X6uIiA18mvpEa9yyeycAKgPmOA3X9hVdVTPUA==} + engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + dependencies: + '@sigstore/bundle': 1.1.0 + '@sigstore/protobuf-specs': 0.2.1 + make-fetch-happen: 11.1.1_supports-color@9.4.0 + transitivePeerDependencies: + - supports-color + dev: false + /@sigstore/tuf/1.0.3: resolution: {integrity: sha512-2bRovzs0nJZFlCN3rXirE4gwxCn97JNjMmwpecqlbgV9WcxX7WRuIrgzx/X7Ib7MYRbyUTpBYE0s2x6AmZXnlg==} engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} @@ -12586,6 +14819,16 @@ packages: - supports-color dev: false + /@sigstore/tuf/1.0.3_supports-color@9.4.0: + resolution: {integrity: sha512-2bRovzs0nJZFlCN3rXirE4gwxCn97JNjMmwpecqlbgV9WcxX7WRuIrgzx/X7Ib7MYRbyUTpBYE0s2x6AmZXnlg==} + engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + dependencies: + '@sigstore/protobuf-specs': 0.2.1 + tuf-js: 1.1.7_supports-color@9.4.0 + transitivePeerDependencies: + - supports-color + dev: false + /@sinclair/typebox/0.27.8: resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==} @@ -14936,6 +17179,10 @@ packages: resolution: {integrity: sha512-M8WpEGfC9iQ6V2Ccq6nGIXoQgeVc6z0Ngk8yCOL5V/TYIxshvb0MWQYLFFTZDesL0zmsoBc4OBjG9DB/4rei6w==} dev: false + /@types/aws-lambda/8.10.122: + resolution: {integrity: sha512-vBkIh9AY22kVOCEKo5CJlyCgmSWvasC+SWUxL/x/vOwRobMpI/HG1xp/Ae3AqmSiZeLUbOhW0FCD3ZjqqUxmXw==} + dev: false + /@types/aws-lambda/8.10.81: resolution: {integrity: sha512-C1rFKGVZ8KwqhwBOYlpoybTSRtxu2433ea6JaO3amc6ubEe08yQoFsPa9aU9YqvX7ppeZ25CnCtC4AH9mhtxsQ==} dev: false @@ -14995,6 +17242,12 @@ packages: '@types/node': 20.6.0 dev: false + /@types/bunyan/1.8.9: + resolution: {integrity: sha512-ZqS9JGpBxVOvsawzmVt30sP++gSQMTejCkIAQ3VdadOcRE8izTyW66hufvwLeH+YEGP6Js2AW7Gz+RMyvrEbmw==} + dependencies: + '@types/node': 20.6.0 + dev: false + /@types/cacheable-request/6.0.3: resolution: {integrity: sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==} dependencies: @@ -15026,6 +17279,12 @@ packages: dependencies: '@types/node': 20.6.0 + /@types/connect/3.4.36: + resolution: {integrity: sha512-P63Zd/JUGq+PdrM1lv0Wv5SBYeA2+CORvbrXbngriYY0jzLUWfQMQQxOhjONEz/wlHOAxOdY7CY65rgQdTjq2w==} + dependencies: + '@types/node': 20.6.0 + dev: false + /@types/content-disposition/0.5.5: resolution: {integrity: sha512-v6LCdKfK6BwcqMo+wYW05rLS12S0ZO0Fl4w1h4aaZMD7bqT3gVUns6FvLJKGZHQmYn3SX55JWGpziwJRwVgutA==} dev: false @@ -15044,7 +17303,7 @@ packages: /@types/cookies/0.7.7: resolution: {integrity: sha512-h7BcvPUogWbKCzBR2lY4oqaZbO3jXZksexYJVFvkrFeLgbZjQkU4x8pRq6eg2MHXQhY0McQdqmmsxRWlVAHooA==} dependencies: - '@types/connect': 3.4.35 + '@types/connect': 3.4.36 '@types/express': 4.17.18 '@types/keygrip': 1.0.2 '@types/node': 20.6.0 @@ -15236,6 +17495,19 @@ packages: resolution: {integrity: sha512-A6ivRrXD5glmnJna1UAGw87QNZRp/vdFO9U4GS+WhOMWzHnw+oTGkMvg0g6y1930CbeheGOCm7A1qHsqH7AXqg==} dev: false + /@types/hapi__hapi/20.0.13: + resolution: {integrity: sha512-LP4IPfhIO5ZPVOrJo7H8c8Slc0WYTFAUNQX1U0LBPKyXioXhH5H2TawIgxKujIyOhbwoBbpvOsBf6o5+ToJIrQ==} + dependencies: + '@hapi/boom': 9.1.4 + '@hapi/iron': 6.0.0 + '@hapi/podium': 4.1.3 + '@types/hapi__catbox': 10.2.4 + '@types/hapi__mimos': 4.1.4 + '@types/hapi__shot': 4.1.2 + '@types/node': 20.6.0 + joi: 17.7.0 + dev: false + /@types/hapi__hapi/20.0.9: resolution: {integrity: sha512-fGpKScknCKZityRXdZgpCLGbm41R1ppFgnKHerfZlqOOlCX/jI129S6ghgBqkqCE8m9A0CIu1h7Ch04lD9KOoA==} dependencies: @@ -15377,7 +17649,7 @@ packages: /@types/koa-compose/3.2.5: resolution: {integrity: sha512-B8nG/OoE1ORZqCkBVsup/AKcvjdgoHnfi4pZMn5UwAPCbhk/96xyv284eBYW8JlQbQ7zDmnpFr68I/40mFoIBQ==} dependencies: - '@types/koa': 2.13.6 + '@types/koa': 2.13.9 dev: false /@types/koa/2.13.6: @@ -15393,10 +17665,29 @@ packages: '@types/node': 20.6.0 dev: false + /@types/koa/2.13.9: + resolution: {integrity: sha512-tPX3cN1dGrMn+sjCDEiQqXH2AqlPoPd594S/8zxwUm/ZbPsQXKqHPUypr2gjCPhHUc+nDJLduhh5lXI/1olnGQ==} + dependencies: + '@types/accepts': 1.3.5 + '@types/content-disposition': 0.5.5 + '@types/cookies': 0.7.7 + '@types/http-assert': 1.5.3 + '@types/http-errors': 2.0.1 + '@types/keygrip': 1.0.2 + '@types/koa-compose': 3.2.5 + '@types/node': 20.6.0 + dev: false + + /@types/koa__router/12.0.3: + resolution: {integrity: sha512-5YUJVv6NwM1z7m6FuYpKfNLTZ932Z6EF6xy2BbtpJSyn13DKNQEkXVffFVSnJHxvwwWh2SAeumpjAYUELqgjyw==} + dependencies: + '@types/koa': 2.13.9 + dev: false + /@types/koa__router/8.0.7: resolution: {integrity: sha512-OB3Ax75nmTP+WR9AgdzA42DI7YmBtiNKN2g1Wxl+d5Dyek9SWt740t+ukwXSmv/jMBCUPyV3YEI93vZHgdP7UQ==} dependencies: - '@types/koa': 2.13.6 + '@types/koa': 2.13.9 dev: false /@types/lodash.omit/4.5.7: @@ -15478,6 +17769,12 @@ packages: '@types/node': 20.6.0 dev: false + /@types/mysql/2.15.22: + resolution: {integrity: sha512-wK1pzsJVVAjYCSZWQoWHziQZbNggXFDUEIGf54g4ZM/ERuP86uGdWeKZWMYlqTPMZfHJJvLPyogXGvCOg87yLQ==} + dependencies: + '@types/node': 20.6.0 + dev: false + /@types/nlcst/1.0.1: resolution: {integrity: sha512-aVIyXt6pZiiMOtVByE4Y0gf+BLm1Cxc4ZLSK8VRHn1CgkO+kXbQwN/EBhQmhPdBMjFJCMBKtmNW2zWQuFywz8Q==} dependencies: @@ -15551,6 +17848,10 @@ packages: resolution: {integrity: sha512-WKG4gTr8przEZBiJ5r3s8ZIAoMXNbOgQ+j/d5O4X3x6kZJRLNvyUJuUK/KoG3+8BaOHPhp2m7WC6JKKeovDSzQ==} dev: true + /@types/object-hash/3.0.6: + resolution: {integrity: sha512-fOBV8C1FIu2ELinoILQ+ApxcUKz4ngq+IWUYrxSGjXzzjUALijilampwkMgEtJ+h2njAW3pi853QpzNVCHB73w==} + dev: true + /@types/parse-json/4.0.0: resolution: {integrity: sha512-//oorEZjL6sbPcKUaCdIGlIUeH26mgzimjBB77G6XRgnDl/L5wOnpyBGRe/Mmf5CVW3PwEBE1NjiMZ/ssFh4wA==} @@ -15563,6 +17864,12 @@ packages: '@types/pg': 8.6.6 dev: false + /@types/pg-pool/2.0.4: + resolution: {integrity: sha512-qZAvkv1K3QbmHHFYSNRYPkRjOWRLBYrL4B9c+wG0GSVGBw0NtJwPcgx/DSddeDJvRGMHCEQ4VMEVfuJ/0gZ3XQ==} + dependencies: + '@types/pg': 8.6.6 + dev: false + /@types/pg/8.6.1: resolution: {integrity: sha512-1Kc4oAGzAl7uqUStZCDvaLFqZrW9qWSjXOmBfdgyBP5La7Us6Mg4GBvRlSoaZMhQF/zSj1C8CtKMBkoiT8eL8w==} dependencies: @@ -15616,6 +17923,13 @@ packages: '@types/scheduler': 0.16.2 csstype: 3.1.1 + /@types/react/18.2.48: + resolution: {integrity: sha512-qboRCl6Ie70DQQG9hhNREz81jqC1cs9EVNcjQ1AU+jH6NFfSAhVVbrrY/+nSF+Bsk4AOwm9Qa61InvMCyV+H3w==} + dependencies: + '@types/prop-types': 15.7.5 + '@types/scheduler': 0.16.2 + csstype: 3.1.1 + /@types/resolve/1.20.2: resolution: {integrity: sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==} @@ -15699,8 +18013,8 @@ packages: minipass: 4.0.0 dev: true - /@types/tedious/4.0.9: - resolution: {integrity: sha512-ipwFvfy9b2m0gjHsIX0D6NAAwGCKokzf5zJqUZHUGt+7uWVlBIy6n2eyMgiKQ8ChLFVxic/zwQUhjLYNzbHDRA==} + /@types/tedious/4.0.14: + resolution: {integrity: sha512-KHPsfX/FoVbUGbyYvk1q9MMQHLPeRZhRJZdO45Q4YjvFkv4hMNghCWTvy7rdKessBsmtz4euWCWAB6/tVpI1Iw==} dependencies: '@types/node': 20.6.0 dev: false @@ -16741,7 +19055,6 @@ packages: acorn: ^8 dependencies: acorn: 8.10.0 - dev: true /acorn-jsx/5.3.2_acorn@7.4.1: resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==} @@ -16818,6 +19131,15 @@ packages: transitivePeerDependencies: - supports-color + /agent-base/6.0.2_supports-color@9.4.0: + resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==} + engines: {node: '>= 6.0.0'} + dependencies: + debug: 4.3.4_supports-color@9.4.0 + transitivePeerDependencies: + - supports-color + dev: false + /agent-base/7.1.0: resolution: {integrity: sha512-o/zjMZRhJxny7OyEF+Op8X+efiELC7k7yOjMzgfzVqOzXqkBkWI79YoTdOtsuWd5BWhAGAuOY/Xa6xpiaWXiNg==} engines: {node: '>= 14'} @@ -16826,6 +19148,15 @@ packages: transitivePeerDependencies: - supports-color + /agent-base/7.1.0_supports-color@9.4.0: + resolution: {integrity: sha512-o/zjMZRhJxny7OyEF+Op8X+efiELC7k7yOjMzgfzVqOzXqkBkWI79YoTdOtsuWd5BWhAGAuOY/Xa6xpiaWXiNg==} + engines: {node: '>= 14'} + dependencies: + debug: 4.3.4_supports-color@9.4.0 + transitivePeerDependencies: + - supports-color + dev: false + /agentkeepalive/4.5.0: resolution: {integrity: sha512-5GG/5IbQQpC9FpkRGsSvZI5QYeSCzlJHdpBQntCsuTOxhKD8lqKhrleg2Yi7yvMIf82Ycmmqln9U8V9qwEiJew==} engines: {node: '>= 8.0.0'} @@ -17286,7 +19617,7 @@ packages: devalue: 4.3.2 diff: 5.1.0 es-module-lexer: 1.3.1 - esbuild: 0.19.2 + esbuild: 0.19.11 estree-walker: 3.0.3 execa: 8.0.1 fast-glob: 3.3.1 @@ -17353,6 +19684,11 @@ packages: engines: {node: '>=8.0.0'} dev: true + /auto-bind/5.0.1: + resolution: {integrity: sha512-ooviqdwwgfIfNmDwo94wlshcdzfO64XV0Cg6oDsDYBJfITDz1EngD2z7DkbvCWn+XIMsIqW27sEVF6qcpJrRcg==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + dev: false + /autoprefixer/10.4.13_postcss@8.4.21: resolution: {integrity: sha512-49vKpMqcZYsJjwotvt4+h/BCjJVnhGwcLpDt5xkcaOG3eLrG/HUYLagrihYsQ+qrIBgIzX1Rw7a6L8I/ZA1Atg==} engines: {node: ^10 || ^12 || >=14} @@ -17709,6 +20045,10 @@ packages: resolution: {integrity: sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==} dev: true + /bignumber.js/9.1.2: + resolution: {integrity: sha512-2/mKyZH9K85bzOEfhXDBFZTGd1CTs+5IHpeFQo9luiBG7hghdC851Pj2WAhb6E3R6b9tZj/XKhbg4fum+Kepug==} + dev: false + /binary-extensions/2.2.0: resolution: {integrity: sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==} engines: {node: '>=8'} @@ -18038,13 +20378,13 @@ packages: load-tsconfig: 0.2.3 dev: true - /bundle-require/4.0.1_esbuild@0.19.2: + /bundle-require/4.0.1_esbuild@0.19.11: resolution: {integrity: sha512-9NQkRHlNdNpDBGmLpngF3EFDcwodhMUuLz9PaWYciVcQF9SE4LFjM2DB/xV1Li5JiuDMv7ZUWuC3rGbqR0MAXQ==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} peerDependencies: esbuild: '>=0.17' dependencies: - esbuild: 0.19.2 + esbuild: 0.19.11 load-tsconfig: 0.2.3 /busboy/1.6.0: @@ -18258,6 +20598,11 @@ packages: xtend: 4.0.2 dev: true + /case-anything/2.1.13: + resolution: {integrity: sha512-zlOQ80VrQ2Ue+ymH5OuM/DlDq64mEm+B9UTdHULv5osUMD6HalNTblf2b1u/m6QecjsnOkBpqVZ+XPwIVsy7Ng==} + engines: {node: '>=12.13'} + dev: true + /case-sensitive-paths-webpack-plugin/2.4.0: resolution: {integrity: sha512-roIFONhcxog0JSSWbvVAh3OocukmSgpqOH6YpMkCvav/ySIV3JKg4Dc8vYtQjYi/UxpNE36r/9v+VqTQqgkYmw==} engines: {node: '>=4'} @@ -18384,7 +20729,6 @@ packages: /cjs-module-lexer/1.2.3: resolution: {integrity: sha512-0TNiGstbQmCFwt4akjjBg5pLRTSyj/PkWQ1ZoO2zntmg9yLqSRxwEa4iCfQLGjqhiqBfOJa7W/E8wfGrTDmlZQ==} - dev: true /class-utils/0.3.6: resolution: {integrity: sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==} @@ -18461,7 +20805,6 @@ packages: dependencies: slice-ansi: 5.0.0 string-width: 5.1.2 - dev: true /cli-width/3.0.0: resolution: {integrity: sha512-FxqpkPPwu1HjuN93Omfm4h8uIanXofW0RxVEW3k5RKx+mJJYSthzNhp32Kzxxy3YAEZ/Dc/EWN1vZRY0+kOhbw==} @@ -18536,6 +20879,13 @@ packages: engines: {iojs: '>= 1.0.0', node: '>= 0.12.0'} dev: true + /code-excerpt/4.0.0: + resolution: {integrity: sha512-xxodCmBen3iy2i0WtAK8FlFNrRzjUqjRsMfho58xT/wvZU1YTM3fCnRjcy1gJPMepaRlgm/0e6w8SpWHpn3/cA==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + dependencies: + convert-to-spaces: 2.0.1 + dev: false + /code-red/1.0.4: resolution: {integrity: sha512-7qJWqItLA8/VPVlKJlFXU+NBlo/qyfs39aJcuMT/2ere32ZqvF5OSxgdM5xOfJJ7O429gg2HM47y8v9P+9wrNw==} dependencies: @@ -18792,6 +21142,11 @@ packages: resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} dev: true + /convert-to-spaces/2.0.1: + resolution: {integrity: sha512-rcQ1bsQO9799wq24uE5AM2tAILy4gXGIK/njFWcVQkGNZ96edlpY+A7bjwvzjYvLDyzmG1MmMLZhpcsb+klNMQ==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + dev: false + /cookie-signature/1.0.6: resolution: {integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==} @@ -19270,6 +21625,18 @@ packages: supports-color: 8.1.1 dev: true + /debug/4.3.4_supports-color@9.4.0: + resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + dependencies: + ms: 2.1.2 + supports-color: 9.4.0 + /decamelize-keys/1.1.1: resolution: {integrity: sha512-WiPxgEirIV0/eIOMcnFBA3/IJZAZqKnwAwWyvvdi4lsr1WCN22nhdf/3db3DoZcUjTV2SqfzIwNyp6y2xs3nmg==} engines: {node: '>=0.10.0'} @@ -19515,6 +21882,12 @@ packages: resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==} engines: {node: '>=8'} + /detect-libc/1.0.3: + resolution: {integrity: sha512-pGjwhsmsp4kL2RTz08wcOlGN83otlqHeD/Z5T8GXZB+/YcpQ/dgo+lbU8ZsGxV0HIvqqxo9l7mqYwyYMD9bKDg==} + engines: {node: '>=0.10'} + hasBin: true + dev: true + /detect-libc/2.0.2: resolution: {integrity: sha512-UX6sGumvvqSaXgdKGUsgZWqcUyIXZ/vZTrlRT/iobiKhGL0zL4d3osHj3uqllWJK+i+sixDS/3COVEOFbupFyw==} engines: {node: '>=8'} @@ -19727,6 +22100,12 @@ packages: engines: {node: '>=10'} dev: false + /dprint-node/1.0.8: + resolution: {integrity: sha512-iVKnUtYfGrYcW1ZAlfR/F59cUVL8QIhWoBJoSjkkdua/dkWIgjZfiLMeTjiB06X0ZLkQ0M2C1VbUj/CxkIf1zg==} + dependencies: + detect-libc: 1.0.3 + dev: true + /dset/3.1.2: resolution: {integrity: sha512-g/M9sqy3oHe477Ar4voQxWtaPIFw1jTdKZuomOjhCcBx9nHUNn0pu6NopuFFrTh/TRZIKEj+76vLWFu9BNKk+Q==} engines: {node: '>=4'} @@ -20408,34 +22787,35 @@ packages: '@esbuild/win32-ia32': 0.18.11 '@esbuild/win32-x64': 0.18.11 - /esbuild/0.19.2: - resolution: {integrity: sha512-G6hPax8UbFakEj3hWO0Vs52LQ8k3lnBhxZWomUJDxfz3rZTLqF5k/FCzuNdLx2RbpBiQQF9H9onlDDH1lZsnjg==} + /esbuild/0.19.11: + resolution: {integrity: sha512-HJ96Hev2hX/6i5cDVwcqiJBBtuo9+FeIJOtZ9W1kA5M6AMJRHUZlpYZ1/SbEwtO0ioNAW8rUooVpC/WehY2SfA==} engines: {node: '>=12'} hasBin: true requiresBuild: true optionalDependencies: - '@esbuild/android-arm': 0.19.2 - '@esbuild/android-arm64': 0.19.2 - '@esbuild/android-x64': 0.19.2 - '@esbuild/darwin-arm64': 0.19.2 - '@esbuild/darwin-x64': 0.19.2 - '@esbuild/freebsd-arm64': 0.19.2 - '@esbuild/freebsd-x64': 0.19.2 - '@esbuild/linux-arm': 0.19.2 - '@esbuild/linux-arm64': 0.19.2 - '@esbuild/linux-ia32': 0.19.2 - '@esbuild/linux-loong64': 0.19.2 - '@esbuild/linux-mips64el': 0.19.2 - '@esbuild/linux-ppc64': 0.19.2 - '@esbuild/linux-riscv64': 0.19.2 - '@esbuild/linux-s390x': 0.19.2 - '@esbuild/linux-x64': 0.19.2 - '@esbuild/netbsd-x64': 0.19.2 - '@esbuild/openbsd-x64': 0.19.2 - '@esbuild/sunos-x64': 0.19.2 - '@esbuild/win32-arm64': 0.19.2 - '@esbuild/win32-ia32': 0.19.2 - '@esbuild/win32-x64': 0.19.2 + '@esbuild/aix-ppc64': 0.19.11 + '@esbuild/android-arm': 0.19.11 + '@esbuild/android-arm64': 0.19.11 + '@esbuild/android-x64': 0.19.11 + '@esbuild/darwin-arm64': 0.19.11 + '@esbuild/darwin-x64': 0.19.11 + '@esbuild/freebsd-arm64': 0.19.11 + '@esbuild/freebsd-x64': 0.19.11 + '@esbuild/linux-arm': 0.19.11 + '@esbuild/linux-arm64': 0.19.11 + '@esbuild/linux-ia32': 0.19.11 + '@esbuild/linux-loong64': 0.19.11 + '@esbuild/linux-mips64el': 0.19.11 + '@esbuild/linux-ppc64': 0.19.11 + '@esbuild/linux-riscv64': 0.19.11 + '@esbuild/linux-s390x': 0.19.11 + '@esbuild/linux-x64': 0.19.11 + '@esbuild/netbsd-x64': 0.19.11 + '@esbuild/openbsd-x64': 0.19.11 + '@esbuild/sunos-x64': 0.19.11 + '@esbuild/win32-arm64': 0.19.11 + '@esbuild/win32-ia32': 0.19.11 + '@esbuild/win32-x64': 0.19.11 /escalade/3.1.1: resolution: {integrity: sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==} @@ -20456,7 +22836,6 @@ packages: /escape-string-regexp/2.0.0: resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==} engines: {node: '>=8'} - dev: true /escape-string-regexp/4.0.0: resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} @@ -22233,6 +24612,15 @@ packages: locate-path: 6.0.0 path-exists: 4.0.0 + /find-up/7.0.0: + resolution: {integrity: sha512-YyZM99iHrqLKjmt4LJDj58KI+fYyufRLBSYcqycxf//KpBk9FoewoGX0450m9nB44qrZnovzC2oeP5hUibxc/g==} + engines: {node: '>=18'} + dependencies: + locate-path: 7.2.0 + path-exists: 5.0.0 + unicorn-magic: 0.1.0 + dev: false + /find-yarn-workspace-root2/1.2.16: resolution: {integrity: sha512-hr6hb1w8ePMpPVUK39S4RlwJzi+xPLuVuG8XlwXU3KD5Yn3qgBWVfy3AzNlDhWvE1EORCE65/Qm26rFQt3VLVA==} dependencies: @@ -22597,6 +24985,54 @@ packages: wide-align: 1.1.5 dev: false + /gaxios/6.2.0: + resolution: {integrity: sha512-H6+bHeoEAU5D6XNc6mPKeN5dLZqEDs9Gpk6I+SZBEzK5So58JVrHPmevNi35fRl1J9Y5TaeLW0kYx3pCJ1U2mQ==} + engines: {node: '>=14'} + dependencies: + extend: 3.0.2 + https-proxy-agent: 7.0.1 + is-stream: 2.0.1 + node-fetch: 2.6.12 + transitivePeerDependencies: + - encoding + - supports-color + dev: false + + /gaxios/6.2.0_supports-color@9.4.0: + resolution: {integrity: sha512-H6+bHeoEAU5D6XNc6mPKeN5dLZqEDs9Gpk6I+SZBEzK5So58JVrHPmevNi35fRl1J9Y5TaeLW0kYx3pCJ1U2mQ==} + engines: {node: '>=14'} + dependencies: + extend: 3.0.2 + https-proxy-agent: 7.0.1_supports-color@9.4.0 + is-stream: 2.0.1 + node-fetch: 2.6.12 + transitivePeerDependencies: + - encoding + - supports-color + dev: false + + /gcp-metadata/6.1.0: + resolution: {integrity: sha512-Jh/AIwwgaxan+7ZUUmRLCjtchyDiqh4KjBJ5tW3plBZb5iL/BPcso8A5DlzeD9qlw0duCamnNdpFjxwaT0KyKg==} + engines: {node: '>=14'} + dependencies: + gaxios: 6.2.0 + json-bigint: 1.0.0 + transitivePeerDependencies: + - encoding + - supports-color + dev: false + + /gcp-metadata/6.1.0_supports-color@9.4.0: + resolution: {integrity: sha512-Jh/AIwwgaxan+7ZUUmRLCjtchyDiqh4KjBJ5tW3plBZb5iL/BPcso8A5DlzeD9qlw0duCamnNdpFjxwaT0KyKg==} + engines: {node: '>=14'} + dependencies: + gaxios: 6.2.0_supports-color@9.4.0 + json-bigint: 1.0.0 + transitivePeerDependencies: + - encoding + - supports-color + dev: false + /generic-names/4.0.0: resolution: {integrity: sha512-ySFolZQfw9FoDb3ed9d80Cm9f0+r7qj+HJkWjeD9RBfpxEVTlVhol+gvaQB/78WbwYfbnNh8nWHHBSlg072y6A==} dependencies: @@ -22699,6 +25135,18 @@ packages: transitivePeerDependencies: - supports-color + /get-uri/6.0.1_supports-color@9.4.0: + resolution: {integrity: sha512-7ZqONUVqaabogsYNWlYj0t3YZaL6dhuEueZXGF+/YVmf6dHmaFg8/6psJKqhx9QykIDKzpGcy2cn4oV4YC7V/Q==} + engines: {node: '>= 14'} + dependencies: + basic-ftp: 5.0.3 + data-uri-to-buffer: 5.0.1 + debug: 4.3.4_supports-color@9.4.0 + fs-extra: 8.1.0 + transitivePeerDependencies: + - supports-color + dev: false + /get-value/2.0.6: resolution: {integrity: sha512-Ln0UQDlxH1BapMu3GPtf7CuYNwRZf2gwCuPqbyG6pB8WfmFpzqcy4xtAaAMUhnNqjMKTiCPZG2oMT3YSx8U2NA==} engines: {node: '>=0.10.0'} @@ -23438,6 +25886,17 @@ packages: - supports-color dev: false + /http-proxy-agent/5.0.0_supports-color@9.4.0: + resolution: {integrity: sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w==} + engines: {node: '>= 6'} + dependencies: + '@tootallnate/once': 2.0.0 + agent-base: 6.0.2_supports-color@9.4.0 + debug: 4.3.4_supports-color@9.4.0 + transitivePeerDependencies: + - supports-color + dev: false + /http-proxy-agent/7.0.0: resolution: {integrity: sha512-+ZT+iBxVUQ1asugqnD6oWoRiS25AkjNfG085dKJGtGxkdwLQrMKU5wJr2bOOFAXzKcTuqq+7fZlTMgG3SRfIYQ==} engines: {node: '>= 14'} @@ -23447,6 +25906,16 @@ packages: transitivePeerDependencies: - supports-color + /http-proxy-agent/7.0.0_supports-color@9.4.0: + resolution: {integrity: sha512-+ZT+iBxVUQ1asugqnD6oWoRiS25AkjNfG085dKJGtGxkdwLQrMKU5wJr2bOOFAXzKcTuqq+7fZlTMgG3SRfIYQ==} + engines: {node: '>= 14'} + dependencies: + agent-base: 7.1.0_supports-color@9.4.0 + debug: 4.3.4_supports-color@9.4.0 + transitivePeerDependencies: + - supports-color + dev: false + /http2-wrapper/1.0.3: resolution: {integrity: sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==} engines: {node: '>=10.19.0'} @@ -23481,6 +25950,16 @@ packages: transitivePeerDependencies: - supports-color + /https-proxy-agent/5.0.1_supports-color@9.4.0: + resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==} + engines: {node: '>= 6'} + dependencies: + agent-base: 6.0.2_supports-color@9.4.0 + debug: 4.3.4_supports-color@9.4.0 + transitivePeerDependencies: + - supports-color + dev: false + /https-proxy-agent/7.0.1: resolution: {integrity: sha512-Eun8zV0kcYS1g19r78osiQLEFIRspRUDd9tIfBCTBPBeMieF/EsJNL8VI3xOIdYRDEkjQnqOYPsZ2DsWsVsFwQ==} engines: {node: '>= 14'} @@ -23490,6 +25969,16 @@ packages: transitivePeerDependencies: - supports-color + /https-proxy-agent/7.0.1_supports-color@9.4.0: + resolution: {integrity: sha512-Eun8zV0kcYS1g19r78osiQLEFIRspRUDd9tIfBCTBPBeMieF/EsJNL8VI3xOIdYRDEkjQnqOYPsZ2DsWsVsFwQ==} + engines: {node: '>= 14'} + dependencies: + agent-base: 7.1.0_supports-color@9.4.0 + debug: 4.3.4_supports-color@9.4.0 + transitivePeerDependencies: + - supports-color + dev: false + /https/1.0.0: resolution: {integrity: sha512-4EC57ddXrkaF0x83Oj8sM6SLQHAWXw90Skqu2M4AEWENZ3F02dFJE/GARA8igO79tcgYqGrD7ae4f5L3um2lgg==} dev: false @@ -23587,6 +26076,15 @@ packages: module-details-from-path: 1.0.3 dev: false + /import-in-the-middle/1.7.1: + resolution: {integrity: sha512-1LrZPDtW+atAxH42S6288qyDFNQ2YCty+2mxEPRtfazH6Z5QwkaBSTS2ods7hnVJioF6rkRfNoA6A/MstpFXLg==} + dependencies: + acorn: 8.10.0 + acorn-import-assertions: 1.9.0_acorn@8.10.0 + cjs-module-lexer: 1.2.3 + module-details-from-path: 1.0.3 + dev: false + /import-lazy/4.0.0: resolution: {integrity: sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw==} engines: {node: '>=8'} @@ -23604,6 +26102,10 @@ packages: /import-meta-resolve/3.0.0: resolution: {integrity: sha512-4IwhLhNNA8yy445rPjD/lWh++7hMDOml2eHtd58eG7h+qK3EryMuuRbsHGPikCoAgIkkDnckKfWSk2iDla/ejg==} + /import-meta-resolve/4.0.0: + resolution: {integrity: sha512-okYUR7ZQPH+efeuMJGlq4f8ubUgO50kByRPyt/Cy1Io4PSRsPjxME+YlVaCOx+NIToW7hCsZNFJyTPFFKepRSA==} + dev: false + /imurmurhash/0.1.4: resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} engines: {node: '>=0.8.19'} @@ -23612,6 +26114,11 @@ packages: resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==} engines: {node: '>=8'} + /indent-string/5.0.0: + resolution: {integrity: sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==} + engines: {node: '>=12'} + dev: false + /infer-owner/1.0.4: resolution: {integrity: sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==} dev: true @@ -23638,6 +26145,51 @@ packages: engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} dev: false + /ink/4.4.1_7kh72gklg5qjlh5zc6s6v3p6v4: + resolution: {integrity: sha512-rXckvqPBB0Krifk5rn/5LvQGmyXwCUpBfmTwbkQNBY9JY8RSl3b8OftBNEYxg4+SWUhEKcPifgope28uL9inlA==} + engines: {node: '>=14.16'} + peerDependencies: + '@types/react': '>=18.0.0' + react: '>=18.0.0' + react-devtools-core: ^4.19.1 + peerDependenciesMeta: + '@types/react': + optional: true + react-devtools-core: + optional: true + dependencies: + '@alcalzone/ansi-tokenize': 0.1.3 + '@types/react': 18.2.48 + ansi-escapes: 6.0.0 + auto-bind: 5.0.1 + chalk: 5.3.0 + cli-boxes: 3.0.0 + cli-cursor: 4.0.0 + cli-truncate: 3.1.0 + code-excerpt: 4.0.0 + indent-string: 5.0.0 + is-ci: 3.0.1 + is-lower-case: 2.0.2 + is-upper-case: 2.0.2 + lodash: 4.17.21 + patch-console: 2.0.0 + react: 18.2.0 + react-reconciler: 0.29.0_react@18.2.0 + scheduler: 0.23.0 + signal-exit: 3.0.7 + slice-ansi: 6.0.0 + stack-utils: 2.0.6 + string-width: 5.1.2 + type-fest: 0.12.0 + widest-line: 4.0.1 + wrap-ansi: 8.1.0 + ws: 8.12.0 + yoga-wasm-web: 0.3.3 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + dev: false + /inline-style-parser/0.1.1: resolution: {integrity: sha512-7NXolsK4CAS5+xvdj5OMMbI962hU/wvwoxk+LWR9Ek9bVtyuuYScDN6eS0rUm6TxApFpw7CX1o4uJzcd4AyD3Q==} dev: true @@ -23977,7 +26529,6 @@ packages: /is-fullwidth-code-point/4.0.0: resolution: {integrity: sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==} engines: {node: '>=12'} - dev: true /is-generator-fn/2.1.0: resolution: {integrity: sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==} @@ -24040,6 +26591,12 @@ packages: resolution: {integrity: sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==} dev: false + /is-lower-case/2.0.2: + resolution: {integrity: sha512-bVcMJy4X5Og6VZfdOZstSexlEy20Sr0k/p/b2IlQJlfdKAQuMpiv5w2Ccxb8sKdRUNAG1PnHVHjFSdRDVS6NlQ==} + dependencies: + tslib: 2.6.2 + dev: false + /is-map/2.0.2: resolution: {integrity: sha512-cOZFQQozTha1f4MxLFzlgKYPTyj26picdZTx82hbc/Xf4K/tZOOXSCkMvU4pKioRXGDLJRn0GM7Upe7kR721yg==} dev: true @@ -24213,6 +26770,12 @@ packages: resolution: {integrity: sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==} engines: {node: '>=12'} + /is-upper-case/2.0.2: + resolution: {integrity: sha512-44pxmxAvnnAOwBg4tHPnkfvgjPwbc5QIsSstNU+YcJ1ovxVzCWpSGosPJOZh/a1tdl81fbgnLc9LLv+x2ywbPQ==} + dependencies: + tslib: 2.6.2 + dev: false + /is-weakmap/2.0.1: resolution: {integrity: sha512-NSBR4kH5oVj1Uwvv970ruUkCV7O1mzgVFO4/rev2cLRda9Tm9HrL70ZPut4rOHgY0FNrUu9BCbXA2sdQ+x0chA==} dev: true @@ -25153,6 +27716,12 @@ packages: hasBin: true dev: true + /json-bigint/1.0.0: + resolution: {integrity: sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==} + dependencies: + bignumber.js: 9.1.2 + dev: false + /json-buffer/3.0.0: resolution: {integrity: sha512-CuUqjv0FUZIdXkHPI8MezCnFCdaTAacej1TZYulLoAg1h/PhwkdXFN4V/gzY4g+fMBCOV2xF+rp7t2XD2ns/NQ==} dev: true @@ -25536,6 +28105,13 @@ packages: dependencies: p-locate: 5.0.0 + /locate-path/7.2.0: + resolution: {integrity: sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + dependencies: + p-locate: 6.0.0 + dev: false + /lodash.camelcase/4.3.0: resolution: {integrity: sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==} @@ -25609,7 +28185,6 @@ packages: /long/5.2.3: resolution: {integrity: sha512-lcHwpNoggQTObv5apGNCTdJrO69eHOZMi4BNC+rTLER8iHAqGrUVeLh/irVIM7zTw2bOXA8T6uNPeujwOLg/2Q==} - dev: false /longest-streak/3.1.0: resolution: {integrity: sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==} @@ -25771,6 +28346,29 @@ packages: - supports-color dev: false + /make-fetch-happen/11.1.1_supports-color@9.4.0: + resolution: {integrity: sha512-rLWS7GCSTcEujjVBs2YqG7Y4643u8ucvCJeSRqiLYhesrDuzeuFIk37xREzAsfQaqzl8b9rNCE4m6J8tvX4Q8w==} + engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + dependencies: + agentkeepalive: 4.5.0 + cacache: 17.1.4 + http-cache-semantics: 4.1.1 + http-proxy-agent: 5.0.0_supports-color@9.4.0 + https-proxy-agent: 5.0.1_supports-color@9.4.0 + is-lambda: 1.0.1 + lru-cache: 7.18.3 + minipass: 5.0.0 + minipass-fetch: 3.0.4 + minipass-flush: 1.0.5 + minipass-pipeline: 1.2.4 + negotiator: 0.6.3 + promise-retry: 2.0.1 + socks-proxy-agent: 7.0.0_supports-color@9.4.0 + ssri: 10.0.5 + transitivePeerDependencies: + - supports-color + dev: false + /make-iterator/0.1.1: resolution: {integrity: sha512-s8tbTxYqrfcXYHAPxUecPxgBnWod7yFShdSOWiV17WRM87bBH2mzr24A4tpUDv9SqebaV6JsPApwKXnisMmMBA==} engines: {node: '>=0.10.0'} @@ -27286,6 +29884,26 @@ packages: - supports-color dev: false + /node-gyp/9.4.0_supports-color@9.4.0: + resolution: {integrity: sha512-dMXsYP6gc9rRbejLXmTbVRYjAHw7ppswsKyMxuxJxxOHzluIO1rGp9TOQgjFJ+2MCqcOcQTOPB/8Xwhr+7s4Eg==} + engines: {node: ^12.13 || ^14.13 || >=16} + hasBin: true + dependencies: + env-paths: 2.2.1 + exponential-backoff: 3.1.1 + glob: 7.2.3 + graceful-fs: 4.2.10 + make-fetch-happen: 11.1.1_supports-color@9.4.0 + nopt: 6.0.0 + npmlog: 6.0.2 + rimraf: 3.0.2 + semver: 7.5.4 + tar: 6.1.13 + which: 2.0.2 + transitivePeerDependencies: + - supports-color + dev: false + /node-int64/0.4.0: resolution: {integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==} @@ -27415,6 +30033,47 @@ packages: - supports-color dev: false + /npm-check-updates/16.12.3_supports-color@9.4.0: + resolution: {integrity: sha512-oF6kwb5d0HzMpDA5Xt8Ah8LyEkYPI40tBwv1hPs43BMGHqh2Abah+KBp1RJLnIsb8Hjy0DY4yzQrm/qLjL2UCA==} + engines: {node: '>=14.14'} + hasBin: true + dependencies: + chalk: 5.3.0 + cli-table3: 0.6.3 + commander: 10.0.1 + fast-memoize: 2.5.2 + find-up: 5.0.0 + fp-and-or: 0.1.3 + get-stdin: 8.0.0 + globby: 11.1.0 + hosted-git-info: 5.2.1 + ini: 4.1.1 + js-yaml: 4.1.0 + json-parse-helpfulerror: 1.0.3 + jsonlines: 0.1.1 + lodash: 4.17.21 + make-fetch-happen: 11.1.1_supports-color@9.4.0 + minimatch: 9.0.3 + p-map: 4.0.0 + pacote: 15.2.0_supports-color@9.4.0 + parse-github-url: 1.0.2 + progress: 2.0.3 + prompts-ncu: 3.0.0 + rc-config-loader: 4.1.3_supports-color@9.4.0 + remote-git-tags: 3.0.0 + rimraf: 5.0.1 + semver: 7.5.4 + semver-utils: 1.1.4 + source-map-support: 0.5.21 + spawn-please: 2.0.2 + strip-json-comments: 5.0.1 + untildify: 4.0.0 + update-notifier: 6.0.2 + transitivePeerDependencies: + - bluebird + - supports-color + dev: false + /npm-install-checks/6.2.0: resolution: {integrity: sha512-744wat5wAAHsxa4590mWO0tJ8PKxR8ORZsH9wGpQc3nWTzozMAgBN/XyqYw7mg3yqLM8dLwEnwSfKMmXAjF69g==} engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} @@ -27465,6 +30124,21 @@ packages: - supports-color dev: false + /npm-registry-fetch/14.0.5_supports-color@9.4.0: + resolution: {integrity: sha512-kIDMIo4aBm6xg7jOttupWZamsZRkAqMqwqqbVXnUqstY5+tapvv6bkH/qMR76jdgV+YljEUCyWx3hRYMrJiAgA==} + engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + dependencies: + make-fetch-happen: 11.1.1_supports-color@9.4.0 + minipass: 5.0.0 + minipass-fetch: 3.0.4 + minipass-json-stream: 1.0.1 + minizlib: 2.1.2 + npm-package-arg: 10.1.0 + proc-log: 3.0.0 + transitivePeerDependencies: + - supports-color + dev: false + /npm-run-all/4.1.5: resolution: {integrity: sha512-Oo82gJDAVcaMdi3nuoKFavkIHBRVqQ1qvMb+9LHk/cF4P6B2m8aP04hGf7oL6wZ9BuGwX1onlLhpuoofSyoQDQ==} engines: {node: '>= 4'} @@ -27477,7 +30151,7 @@ packages: minimatch: 3.1.2 pidtree: 0.3.1 read-pkg: 3.0.0 - shell-quote: 1.7.4 + shell-quote: 1.8.1 string.prototype.padend: 3.1.4 /npm-run-path/4.0.1: @@ -27959,6 +30633,13 @@ packages: dependencies: p-limit: 3.1.0 + /p-locate/6.0.0: + resolution: {integrity: sha512-wPrq66Llhl7/4AGC6I+cqxT07LhXvWL08LNXz1fENOw0Ap4sRZZ/gZpTTJ5jpurzzzfS2W/Ge9BY3LgLjCShcw==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + dependencies: + p-limit: 4.0.0 + dev: false + /p-map/2.1.0: resolution: {integrity: sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==} engines: {node: '>=6'} @@ -28001,6 +30682,11 @@ packages: is-network-error: 1.0.0 retry: 0.13.1 + /p-throttle/6.1.0: + resolution: {integrity: sha512-eQMdGTxk2+047La67wefUtt0tEHh7D+C8Jl7QXoFCuIiNYeQ9zWs2AZiJdIAs72rSXZ06t11me2bgalRNdy3SQ==} + engines: {node: '>=18'} + dev: false + /p-timeout/3.2.0: resolution: {integrity: sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==} engines: {node: '>=8'} @@ -28027,6 +30713,22 @@ packages: transitivePeerDependencies: - supports-color + /pac-proxy-agent/7.0.0_supports-color@9.4.0: + resolution: {integrity: sha512-t4tRAMx0uphnZrio0S0Jw9zg3oDbz1zVhQ/Vy18FjLfP1XOLNUEjaVxYCYRI6NS+BsMBXKIzV6cTLOkO9AtywA==} + engines: {node: '>= 14'} + dependencies: + '@tootallnate/quickjs-emscripten': 0.23.0 + agent-base: 7.1.0_supports-color@9.4.0 + debug: 4.3.4_supports-color@9.4.0 + get-uri: 6.0.1_supports-color@9.4.0 + http-proxy-agent: 7.0.0_supports-color@9.4.0 + https-proxy-agent: 7.0.1_supports-color@9.4.0 + pac-resolver: 7.0.0 + socks-proxy-agent: 8.0.1_supports-color@9.4.0 + transitivePeerDependencies: + - supports-color + dev: false + /pac-resolver/7.0.0: resolution: {integrity: sha512-Fd9lT9vJbHYRACT8OhCbZBbxr6KRSawSovFpy8nDGshaK99S/EBhVIHp9+crhxrsZOuvLpgL1n23iyPg6Rl2hg==} engines: {node: '>= 14'} @@ -28087,6 +30789,34 @@ packages: - supports-color dev: false + /pacote/15.2.0_supports-color@9.4.0: + resolution: {integrity: sha512-rJVZeIwHTUta23sIZgEIM62WYwbmGbThdbnkt81ravBplQv+HjyroqnLRNH2+sLJHcGZmLRmhPwACqhfTcOmnA==} + engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + hasBin: true + dependencies: + '@npmcli/git': 4.1.0 + '@npmcli/installed-package-contents': 2.0.2 + '@npmcli/promise-spawn': 6.0.2 + '@npmcli/run-script': 6.0.2_supports-color@9.4.0 + cacache: 17.1.4 + fs-minipass: 3.0.3 + minipass: 5.0.0 + npm-package-arg: 10.1.0 + npm-packlist: 7.0.4 + npm-pick-manifest: 8.0.2 + npm-registry-fetch: 14.0.5_supports-color@9.4.0 + proc-log: 3.0.0 + promise-retry: 2.0.1 + read-package-json: 6.0.4 + read-package-json-fast: 3.0.2 + sigstore: 1.9.0_supports-color@9.4.0 + ssri: 10.0.5 + tar: 6.1.13 + transitivePeerDependencies: + - bluebird + - supports-color + dev: false + /pako/0.2.9: resolution: {integrity: sha512-NUcwaKxUxWrZLpDG+z/xZaCgQITkA/Dv4V/T6bw7VON6l1Xz/VnrBqrYjZQ12TamKHzITTfOEIYUj48y2KXImA==} dev: true @@ -28187,6 +30917,11 @@ packages: engines: {node: '>=0.10.0'} dev: false + /patch-console/2.0.0: + resolution: {integrity: sha512-0YNdUceMdaQwoKce1gatDScmMo5pu/tfABfnzEqeG0gtTmd7mh/WcwgUjtAeOU7N8nFFlbQBnFK2gXW5fGvmMA==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + dev: false + /path-browserify/1.0.1: resolution: {integrity: sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==} dev: true @@ -28204,6 +30939,11 @@ packages: resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} engines: {node: '>=8'} + /path-exists/5.0.0: + resolution: {integrity: sha512-RjhtfwJOxzcFmNOi6ltcbcu4Iu+FL3zEj83dk4kAS+fVpTxXLO1b38RvJgT/0QwvV/L3aY9TAnyv0EOqW4GoMQ==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + dev: false + /path-is-absolute/1.0.1: resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==} engines: {node: '>=0.10.0'} @@ -29159,8 +31899,8 @@ packages: resolution: {integrity: sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==} dev: false - /protobufjs/7.2.4: - resolution: {integrity: sha512-AT+RJgD2sH8phPmCf7OUZR8xGdcJRga4+1cOaXJ64hvcSkVhNcRHOwIxUatPH15+nj59WAGTDv3LSGZPEQbJaQ==} + /protobufjs/7.2.6: + resolution: {integrity: sha512-dgJaEDDL6x8ASUZ1YqWciTRrdOuYNzoOf27oHNfdyvKqHr5i0FV7FSLU+aIeFjyFgVxrpTOtQUi0BLLBymZaBw==} engines: {node: '>=12.0.0'} requiresBuild: true dependencies: @@ -29176,7 +31916,6 @@ packages: '@protobufjs/utf8': 1.1.0 '@types/node': 20.6.0 long: 5.2.3 - dev: false /proxy-addr/2.0.7: resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==} @@ -29200,6 +31939,22 @@ packages: transitivePeerDependencies: - supports-color + /proxy-agent/6.3.0_supports-color@9.4.0: + resolution: {integrity: sha512-0LdR757eTj/JfuU7TL2YCuAZnxWXu3tkJbg4Oq3geW/qFNT/32T0sp2HnZ9O0lMR4q3vwAt0+xCA8SR0WAD0og==} + engines: {node: '>= 14'} + dependencies: + agent-base: 7.1.0_supports-color@9.4.0 + debug: 4.3.4_supports-color@9.4.0 + http-proxy-agent: 7.0.0_supports-color@9.4.0 + https-proxy-agent: 7.0.1_supports-color@9.4.0 + lru-cache: 7.18.3 + pac-proxy-agent: 7.0.0_supports-color@9.4.0 + proxy-from-env: 1.1.0 + socks-proxy-agent: 8.0.1_supports-color@9.4.0 + transitivePeerDependencies: + - supports-color + dev: false + /proxy-from-env/1.1.0: resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==} @@ -29356,6 +32111,17 @@ packages: - supports-color dev: false + /rc-config-loader/4.1.3_supports-color@9.4.0: + resolution: {integrity: sha512-kD7FqML7l800i6pS6pvLyIE2ncbk9Du8Q0gp/4hMPhJU6ZxApkoLcGD8ZeqgiAlfwZ6BlETq6qqe+12DUL207w==} + dependencies: + debug: 4.3.4_supports-color@9.4.0 + js-yaml: 4.1.0 + json5: 2.2.3 + require-from-string: 2.0.2 + transitivePeerDependencies: + - supports-color + dev: false + /rc/1.2.8: resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==} hasBin: true @@ -29495,6 +32261,15 @@ packages: - supports-color dev: false + /react-error-boundary/4.0.12_react@18.2.0: + resolution: {integrity: sha512-kJdxdEYlb7CPC1A0SeUY38cHpjuu6UkvzKiAmqmOFL21VRfMhOcWxTCBgLVCO0VEMh9JhFNcVaXlV4/BTpiwOA==} + peerDependencies: + react: '>=16.13.1' + dependencies: + '@babel/runtime': 7.22.5 + react: 18.2.0 + dev: false + /react-hotkeys-hook/4.4.1_biqbaboplfbrettd7655fr4n2y: resolution: {integrity: sha512-sClBMBioFEgFGYLTWWRKvhxcCx1DRznd+wkFHwQZspnRBkHTgruKIHptlK/U/2DPX8BhHoRGzpMVWUXMmdZlmw==} peerDependencies: @@ -29546,6 +32321,17 @@ packages: react-dom: 18.2.0_react@18.2.0 dev: false + /react-reconciler/0.29.0_react@18.2.0: + resolution: {integrity: sha512-wa0fGj7Zht1EYMRhKWwoo1H9GApxYLBuhoAuXN0TlltESAjDssB+Apf0T/DngVqaMyPypDmabL37vw/2aRM98Q==} + engines: {node: '>=0.10.0'} + peerDependencies: + react: ^18.2.0 + dependencies: + loose-envify: 1.4.0 + react: 18.2.0 + scheduler: 0.23.0 + dev: false + /react-refresh/0.11.0: resolution: {integrity: sha512-F27qZr8uUqwhWZboondsPx8tnC3Ct3SxZA3V5WyEvujRyyNv0VYPhoBg1gZ8/MV5tubQp76Trw8lTv9hzRBa+A==} engines: {node: '>=0.10.0'} @@ -30358,6 +33144,17 @@ packages: - supports-color dev: false + /require-in-the-middle/7.1.1_supports-color@9.4.0: + resolution: {integrity: sha512-OScOjQjrrjhAdFpQmnkE/qbIBGCRFhQB/YaJhcC3CPOlmhe7llnW46Ac1J5+EjcNXOTnDdpF96Erw/yedsGksQ==} + engines: {node: '>=8.6.0'} + dependencies: + debug: 4.3.4_supports-color@9.4.0 + module-details-from-path: 1.0.3 + resolve: 1.22.4 + transitivePeerDependencies: + - supports-color + dev: false + /require-like/0.1.2: resolution: {integrity: sha512-oyrU88skkMtDdauHDuKVrgR+zuItqr6/c//FXzvmxRGMexSDc6hNvJInGW3LL46n+8b50RykrvwSUIIQH2LQ5A==} dev: true @@ -31016,12 +33813,8 @@ packages: resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} engines: {node: '>=8'} - /shell-quote/1.7.4: - resolution: {integrity: sha512-8o/QEhSSRb1a5i7TFR0iM4G16Z0vYB2OQVs4G3aAFXjn3T6yEx8AZxy1PgDF7I00LZHYA3WxaSYIf5e5sAX8Rw==} - /shell-quote/1.8.1: resolution: {integrity: sha512-6j1W9l1iAs/4xYBI1SYOVZyFcCis9b4KCLQ8fgAGG07QvzaRLVVRQvAy85yNmmZSjYjg4MWh4gNvlPujU/5LpA==} - dev: true /shelljs/0.8.5: resolution: {integrity: sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==} @@ -31079,6 +33872,20 @@ packages: - supports-color dev: false + /sigstore/1.9.0_supports-color@9.4.0: + resolution: {integrity: sha512-0Zjz0oe37d08VeOtBIuB6cRriqXse2e8w+7yIy2XSXjshRKxbc2KkhXjL229jXSxEm7UbcjS76wcJDGQddVI9A==} + engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + hasBin: true + dependencies: + '@sigstore/bundle': 1.1.0 + '@sigstore/protobuf-specs': 0.2.1 + '@sigstore/sign': 1.0.0_supports-color@9.4.0 + '@sigstore/tuf': 1.0.3_supports-color@9.4.0 + make-fetch-happen: 11.1.1_supports-color@9.4.0 + transitivePeerDependencies: + - supports-color + dev: false + /simple-concat/1.0.1: resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==} optional: true @@ -31101,6 +33908,16 @@ packages: - supports-color dev: false + /simple-git/3.19.0_supports-color@9.4.0: + resolution: {integrity: sha512-hyH2p9Ptxjf/xPuL7HfXbpYt9gKhC1yWDh3KYIAYJJePAKV7AEjLN4xhp7lozOdNiaJ9jlVvAbBymVlcS2jRiA==} + dependencies: + '@kwsites/file-exists': 1.1.1_supports-color@9.4.0 + '@kwsites/promise-deferred': 1.1.1 + debug: 4.3.4_supports-color@9.4.0 + transitivePeerDependencies: + - supports-color + dev: false + /simple-oauth2/5.0.0: resolution: {integrity: sha512-8291lo/z5ZdpmiOFzOs1kF3cxn22bMj5FFH+DNUppLJrpoIlM1QnFiE7KpshHu3J3i21TVcx4yW+gXYjdCKDLQ==} dependencies: @@ -31171,7 +33988,14 @@ packages: dependencies: ansi-styles: 6.2.1 is-fullwidth-code-point: 4.0.0 - dev: true + + /slice-ansi/6.0.0: + resolution: {integrity: sha512-6bn4hRfkTvDfUoEQYkERg0BVF1D0vrX9HEkMl08uDiNWvVvjylLHvZFZWkDo6wjT8tUctbYl1nCOuE66ZTaUtA==} + engines: {node: '>=14.16'} + dependencies: + ansi-styles: 6.2.1 + is-fullwidth-code-point: 4.0.0 + dev: false /slug/6.1.0: resolution: {integrity: sha512-x6vLHCMasg4DR2LPiyFGI0gJJhywY6DTiGhCrOMzb3SOk/0JVLIaL4UhyFSHu04SD3uAavrKY/K3zZ3i6iRcgA==} @@ -31253,6 +34077,17 @@ packages: - supports-color dev: false + /socks-proxy-agent/7.0.0_supports-color@9.4.0: + resolution: {integrity: sha512-Fgl0YPZ902wEsAyiQ+idGd1A7rSFx/ayC1CQVMw5P+EQx2V0SgpGtf6OKFhVjPflPUl9YMmEOnmfjCdMUsygww==} + engines: {node: '>= 10'} + dependencies: + agent-base: 6.0.2_supports-color@9.4.0 + debug: 4.3.4_supports-color@9.4.0 + socks: 2.7.1 + transitivePeerDependencies: + - supports-color + dev: false + /socks-proxy-agent/8.0.1: resolution: {integrity: sha512-59EjPbbgg8U3x62hhKOFVAmySQUcfRQ4C7Q/D5sEHnZTQRrQlNKINks44DMR1gwXp0p4LaVIeccX2KHTTcHVqQ==} engines: {node: '>= 14'} @@ -31263,6 +34098,17 @@ packages: transitivePeerDependencies: - supports-color + /socks-proxy-agent/8.0.1_supports-color@9.4.0: + resolution: {integrity: sha512-59EjPbbgg8U3x62hhKOFVAmySQUcfRQ4C7Q/D5sEHnZTQRrQlNKINks44DMR1gwXp0p4LaVIeccX2KHTTcHVqQ==} + engines: {node: '>= 14'} + dependencies: + agent-base: 7.1.0_supports-color@9.4.0 + debug: 4.3.4_supports-color@9.4.0 + socks: 2.7.1 + transitivePeerDependencies: + - supports-color + dev: false + /socks/2.7.1: resolution: {integrity: sha512-7maUZy1N7uo6+WVEX6psASxtNlKaNVMlGQKkG/63nEDdLOWNbiUMoLK7X4uYoLhQstau72mLgfEWcXcwsaHbYQ==} engines: {node: '>= 10.13.0', npm: '>= 3.0.0'} @@ -31465,7 +34311,6 @@ packages: engines: {node: '>=10'} dependencies: escape-string-regexp: 2.0.0 - dev: true /stackback/0.0.2: resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==} @@ -31907,6 +34752,10 @@ packages: has-flag: 4.0.0 dev: true + /supports-color/9.4.0: + resolution: {integrity: sha512-VL+lNrEoIXww1coLPOmiEmK/0sGigko5COxI09KzHc2VJXJsQ37UaQ+8quuxjDeA7+KnLGTWRyOXSLLR2Wb4jw==} + engines: {node: '>=12'} + /supports-hyperlinks/2.3.0: resolution: {integrity: sha512-RpsAZlpWcDwOPQA22aCH4J0t7L8JmAvsCxfOSEwm7cQs3LshN36QaTkwd70DnBOXDWGssw2eUoc8CaRWT0XunA==} engines: {node: '>=8'} @@ -32602,6 +35451,39 @@ packages: yargs-parser: 21.1.1 dev: true + /ts-jest/29.1.1_5rpxlvaikdwu64qu6f72wnb6nm: + resolution: {integrity: sha512-D6xjnnbP17cC85nliwGiL+tpoKN0StpgE0TeOjXQTU6MVCfsB4v7aW05CgQ/1OywGb0x/oy9hHFnN+sczTiRaA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + hasBin: true + peerDependencies: + '@babel/core': '>=7.0.0-beta.0 <8' + '@jest/types': ^29.0.0 + babel-jest: ^29.0.0 + esbuild: '*' + jest: ^29.0.0 + typescript: '>=4.3 <6' + peerDependenciesMeta: + '@babel/core': + optional: true + '@jest/types': + optional: true + babel-jest: + optional: true + esbuild: + optional: true + dependencies: + bs-logger: 0.2.6 + fast-json-stable-stringify: 2.1.0 + jest: 29.6.2_@types+node@16.18.11 + jest-util: 29.6.2 + json5: 2.2.3 + lodash.memoize: 4.1.2 + make-error: 1.3.6 + semver: 7.5.4 + typescript: 5.3.3 + yargs-parser: 21.1.1 + dev: true + /ts-loader/9.4.2_typescript@5.0.4: resolution: {integrity: sha512-OmlC4WVmFv5I0PpaxYb+qGeGOdm5giHU7HwDDUjw59emP2UYMHy9fFSDcYgSNoH8sXcj4hGCSEhlDZ9ULeDraA==} engines: {node: '>=12.0.0'} @@ -32754,6 +35636,29 @@ packages: yn: 3.1.1 dev: true + /ts-poet/6.6.0: + resolution: {integrity: sha512-4vEH/wkhcjRPFOdBwIh9ItO6jOoumVLRF4aABDX5JSNEubSqwOulihxQPqai+OkuygJm3WYMInxXQX4QwVNMuw==} + dependencies: + dprint-node: 1.0.8 + dev: true + + /ts-proto-descriptors/1.15.0: + resolution: {integrity: sha512-TYyJ7+H+7Jsqawdv+mfsEpZPTIj9siDHS6EMCzG/z3b/PZiphsX+mWtqFfFVe5/N0Th6V3elK9lQqjnrgTOfrg==} + dependencies: + long: 5.2.3 + protobufjs: 7.2.6 + dev: true + + /ts-proto/1.167.3: + resolution: {integrity: sha512-quBKTeIgqhTGKXl5JN7HHZjLwrdMaNIoQ0+X11PqNLVRqTlnEzfiCUXM6HOW4pZa6PD5+qSyKOEGaTa3kS7Glg==} + hasBin: true + dependencies: + case-anything: 2.1.13 + protobufjs: 7.2.6 + ts-poet: 6.6.0 + ts-proto-descriptors: 1.15.0 + dev: true + /tsafe/1.4.1: resolution: {integrity: sha512-3IDBalvf6SyvHFS14UiwCWzqdSdo+Q0k2J7DZyJYaHW/iraW9DJpaBKDJpry3yQs3o/t/A+oGaRW3iVt2lKxzA==} dev: false @@ -32903,6 +35808,46 @@ packages: - ts-node dev: true + /tsup/8.0.1_a5ztaafw5l4qfghy2hjjuynb34_7y24qjorrsjk6wdsbbcqvo2unm: + resolution: {integrity: sha512-hvW7gUSG96j53ZTSlT4j/KL0q1Q2l6TqGBFc6/mu/L46IoNWqLLUzLRLP1R8Q7xrJTmkDxxDoojV5uCVs1sVOg==} + engines: {node: '>=18'} + hasBin: true + peerDependencies: + '@microsoft/api-extractor': ^7.36.0 + '@swc/core': ^1 + postcss: ^8.4.12 + typescript: '>=4.5.0' + peerDependenciesMeta: + '@microsoft/api-extractor': + optional: true + '@swc/core': + optional: true + postcss: + optional: true + typescript: + optional: true + dependencies: + bundle-require: 4.0.1_esbuild@0.19.11 + cac: 6.7.14 + chokidar: 3.5.3 + debug: 4.3.4_supports-color@9.4.0 + esbuild: 0.19.11 + execa: 5.1.1 + globby: 11.1.0 + joycon: 3.1.1 + postcss-load-config: 4.0.1 + resolve-from: 5.0.0 + rollup: 4.6.1 + source-map: 0.8.0-beta.0 + sucrase: 3.32.0 + tree-kill: 1.2.2 + typescript: 5.3.3 + transitivePeerDependencies: + - supports-color + - ts-node + dev: true + patched: true + /tsup/8.0.1_a5ztaafw5l4qfghy2hjjuynb34_typescript@5.3.2: resolution: {integrity: sha512-hvW7gUSG96j53ZTSlT4j/KL0q1Q2l6TqGBFc6/mu/L46IoNWqLLUzLRLP1R8Q7xrJTmkDxxDoojV5uCVs1sVOg==} engines: {node: '>=18'} @@ -32922,11 +35867,11 @@ packages: typescript: optional: true dependencies: - bundle-require: 4.0.1_esbuild@0.19.2 + bundle-require: 4.0.1_esbuild@0.19.11 cac: 6.7.14 chokidar: 3.5.3 debug: 4.3.4 - esbuild: 0.19.2 + esbuild: 0.19.11 execa: 5.1.1 globby: 11.1.0 joycon: 3.1.1 @@ -32942,6 +35887,46 @@ packages: - ts-node patched: true + /tsup/8.0.1_a5ztaafw5l4qfghy2hjjuynb34_typescript@5.3.3: + resolution: {integrity: sha512-hvW7gUSG96j53ZTSlT4j/KL0q1Q2l6TqGBFc6/mu/L46IoNWqLLUzLRLP1R8Q7xrJTmkDxxDoojV5uCVs1sVOg==} + engines: {node: '>=18'} + hasBin: true + peerDependencies: + '@microsoft/api-extractor': ^7.36.0 + '@swc/core': ^1 + postcss: ^8.4.12 + typescript: '>=4.5.0' + peerDependenciesMeta: + '@microsoft/api-extractor': + optional: true + '@swc/core': + optional: true + postcss: + optional: true + typescript: + optional: true + dependencies: + bundle-require: 4.0.1_esbuild@0.19.11 + cac: 6.7.14 + chokidar: 3.5.3 + debug: 4.3.4 + esbuild: 0.19.11 + execa: 5.1.1 + globby: 11.1.0 + joycon: 3.1.1 + postcss-load-config: 4.0.1 + resolve-from: 5.0.0 + rollup: 4.6.1 + source-map: 0.8.0-beta.0 + sucrase: 3.32.0 + tree-kill: 1.2.2 + typescript: 5.3.3 + transitivePeerDependencies: + - supports-color + - ts-node + dev: true + patched: true + /tsutils/3.21.0: resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==} engines: {node: '>= 6'} @@ -33026,6 +36011,17 @@ packages: - supports-color dev: false + /tuf-js/1.1.7_supports-color@9.4.0: + resolution: {integrity: sha512-i3P9Kgw3ytjELUfpuKVDNBJvk4u5bXL6gskv572mcevPbSKCV3zt3djhmlEQ65yERjIbOSncy7U4cQJaB1CBCg==} + engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + dependencies: + '@tufjs/models': 1.0.4 + debug: 4.3.4_supports-color@9.4.0 + make-fetch-happen: 11.1.1_supports-color@9.4.0 + transitivePeerDependencies: + - supports-color + dev: false + /tunnel-agent/0.6.0: resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==} dependencies: @@ -33110,6 +36106,11 @@ packages: resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==} engines: {node: '>=4'} + /type-fest/0.12.0: + resolution: {integrity: sha512-53RyidyjvkGpnWPMF9bQgFtWp+Sl8O2Rp13VavmJgfAP9WWG6q6TkrKU8iyJdnwnfgHI6k2hTlgqH4aSdjoTbg==} + engines: {node: '>=10'} + dev: false + /type-fest/0.13.1: resolution: {integrity: sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==} engines: {node: '>=10'} @@ -33320,6 +36321,11 @@ packages: engines: {node: '>=4'} dev: true + /unicorn-magic/0.1.0: + resolution: {integrity: sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==} + engines: {node: '>=18'} + dev: false + /unified/10.1.2: resolution: {integrity: sha512-pUSWAi/RAnVy1Pif2kAoeWNBa3JVrx0MId2LASj8G+7AiHWoKZNTomq6LG326T68U7/e263X6fTdcXIy7XnF7Q==} dependencies: @@ -33905,6 +36911,28 @@ packages: - supports-color - terser + /vite-node/0.34.4_ebva6qbjyqsykukpg7etpnxeem: + resolution: {integrity: sha512-ho8HtiLc+nsmbwZMw8SlghESEE3KxJNp04F/jPUCLVvaURwt0d+r9LxEqCX5hvrrOQ0GSyxbYr5ZfRYhQ0yVKQ==} + engines: {node: '>=v14.18.0'} + hasBin: true + dependencies: + cac: 6.7.14 + debug: 4.3.4_supports-color@9.4.0 + mlly: 1.4.2 + pathe: 1.1.1 + picocolors: 1.0.0 + vite: 4.4.9_@types+node@20.6.0 + transitivePeerDependencies: + - '@types/node' + - less + - lightningcss + - sass + - stylus + - sugarss + - supports-color + - terser + dev: true + /vite-tsconfig-paths/4.0.5: resolution: {integrity: sha512-/L/eHwySFYjwxoYt1WRJniuK/jPv+WGwgRGBYx3leciR5wBeqntQpUE6Js6+TJemChc+ter7fDBKieyEWDx4yQ==} dependencies: @@ -34228,6 +37256,71 @@ packages: - supports-color - terser + /vitest/0.34.4_supports-color@9.4.0: + resolution: {integrity: sha512-SE/laOsB6995QlbSE6BtkpXDeVNLJc1u2LHRG/OpnN4RsRzM3GQm4nm3PQCK5OBtrsUqnhzLdnT7se3aeNGdlw==} + engines: {node: '>=v14.18.0'} + hasBin: true + peerDependencies: + '@edge-runtime/vm': '*' + '@vitest/browser': '*' + '@vitest/ui': '*' + happy-dom: '*' + jsdom: '*' + playwright: '*' + safaridriver: '*' + webdriverio: '*' + peerDependenciesMeta: + '@edge-runtime/vm': + optional: true + '@vitest/browser': + optional: true + '@vitest/ui': + optional: true + happy-dom: + optional: true + jsdom: + optional: true + playwright: + optional: true + safaridriver: + optional: true + webdriverio: + optional: true + dependencies: + '@types/chai': 4.3.6 + '@types/chai-subset': 1.3.3 + '@types/node': 20.6.0 + '@vitest/expect': 0.34.4 + '@vitest/runner': 0.34.4 + '@vitest/snapshot': 0.34.4 + '@vitest/spy': 0.34.4 + '@vitest/utils': 0.34.4 + acorn: 8.10.0 + acorn-walk: 8.2.0 + cac: 6.7.14 + chai: 4.3.7 + debug: 4.3.4_supports-color@9.4.0 + local-pkg: 0.4.3 + magic-string: 0.30.3 + pathe: 1.1.1 + picocolors: 1.0.0 + std-env: 3.4.3 + strip-literal: 1.0.1 + tinybench: 2.5.0 + tinypool: 0.7.0 + vite: 4.4.9_@types+node@20.6.0 + vite-node: 0.34.4_ebva6qbjyqsykukpg7etpnxeem + why-is-node-running: 2.2.2 + transitivePeerDependencies: + - less + - lightningcss + - sass + - stylus + - sugarss + - supports-color + - terser + dev: true + /vscode-oniguruma/1.7.0: resolution: {integrity: sha512-L9WMGRfrjOhgHSdOYgCt/yRMsXzLDJSL7BPrOZt73gU0iWO4mpqzqQzOz5srxqTvMBaR0XZTSrVWo4j55Rc6cA==} @@ -34947,6 +38040,10 @@ packages: resolution: {integrity: sha512-9bnSc/HEW2uRy67wc+T8UwauLuPJVn28jb+GtJY16iiKWyvmYJRXVT4UamsAEGQfPohgr2q4Tq0sQbQlxTfi1g==} engines: {node: '>=12.20'} + /yoga-wasm-web/0.3.3: + resolution: {integrity: sha512-N+d4UJSJbt/R3wqY7Coqs5pcV0aUj2j9IaQ3rNj9bVCLld8tTGKRa2USARjnvZJWVx1NDmQev8EknoczaOQDOA==} + dev: false + /youch/3.3.3: resolution: {integrity: sha512-qSFXUk3UZBLfggAW3dJKg0BMblG5biqSF8M34E06o5CSsZtH92u9Hqmj2RzGiHDi64fhe83+4tENFP2DB6t6ZA==} dependencies: diff --git a/references/v3-catalog/package.json b/references/v3-catalog/package.json new file mode 100644 index 000000000..1d74a9dbf --- /dev/null +++ b/references/v3-catalog/package.json @@ -0,0 +1,39 @@ +{ + "name": "@references/v3-catalog", + "version": "0.1.0", + "private": true, + "scripts": { + "dev:trigger": "trigger.dev dev --log-level debug", + "start": "ts-node -r tsconfig-paths/register -r dotenv/config src/index.ts" + }, + "dependencies": { + "@opentelemetry/api": "^1.7.0", + "@opentelemetry/api-logs": "^0.48.0", + "@opentelemetry/auto-instrumentations-node": "^0.40.3", + "@opentelemetry/exporter-collector": "^0.25.0", + "@opentelemetry/exporter-logs-otlp-http": "^0.48.0", + "@opentelemetry/exporter-trace-otlp-http": "^0.48.0", + "@opentelemetry/instrumentation": "^0.48.0", + "@opentelemetry/instrumentation-fetch": "^0.48.0", + "@opentelemetry/instrumentation-http": "^0.48.0", + "@opentelemetry/propagator-b3": "^1.21.0", + "@opentelemetry/resources": "^1.21.0", + "@opentelemetry/sdk-logs": "^0.48.0", + "@opentelemetry/sdk-node": "^0.48.0", + "@opentelemetry/sdk-trace-base": "^1.21.0", + "@opentelemetry/sdk-trace-node": "^1.21.0", + "@opentelemetry/semantic-conventions": "^1.21.0", + "@trigger.dev/sdk": "workspace:*" + }, + "devDependencies": { + "@trigger.dev/tsconfig": "workspace:*", + "@types/node": "20.4.2", + "concurrently": "^8.2.0", + "dotenv": "^16.3.1", + "nodemon": "^3.0.1", + "trigger.dev": "workspace:*", + "ts-node": "^10.9.1", + "tsconfig-paths": "^3.14.1", + "typescript": "5.1.6" + } +} \ No newline at end of file diff --git a/references/v3-catalog/src/index.ts b/references/v3-catalog/src/index.ts new file mode 100644 index 000000000..b6046ffd9 --- /dev/null +++ b/references/v3-catalog/src/index.ts @@ -0,0 +1,11 @@ +import { parentTask } from "./trigger/simple"; + +export async function main() { + const handle = await parentTask.trigger({ + payload: { message: "This is a message from the trigger-dev CLI" }, + }); + + return handle; +} + +main().then(console.log).catch(console.error); diff --git a/references/v3-catalog/src/trigger/logging.ts b/references/v3-catalog/src/trigger/logging.ts new file mode 100644 index 000000000..5466c2f64 --- /dev/null +++ b/references/v3-catalog/src/trigger/logging.ts @@ -0,0 +1,8 @@ +import { task } from "@trigger.dev/sdk/v3"; + +export const loggingTask = task({ + id: "logging-task", + run: async ({ payload }: { payload: { url: string } }) => { + console.log("Hello world"); + }, +}); diff --git a/references/v3-catalog/src/trigger/other.ts b/references/v3-catalog/src/trigger/other.ts new file mode 100644 index 000000000..56a290ae0 --- /dev/null +++ b/references/v3-catalog/src/trigger/other.ts @@ -0,0 +1,8 @@ +import { task } from "@trigger.dev/sdk/v3"; + +export const loggingTask = task({ + id: "logging-task-2", + run: async ({ payload }: { payload: { url: string } }) => { + console.log("Hello world"); + }, +}); diff --git a/references/v3-catalog/src/trigger/simple.ts b/references/v3-catalog/src/trigger/simple.ts new file mode 100644 index 000000000..979746f0d --- /dev/null +++ b/references/v3-catalog/src/trigger/simple.ts @@ -0,0 +1,133 @@ +import { task, wait, type Context, logger } from "@trigger.dev/sdk/v3"; + +export const simplestTask = task({ + id: "fetch-post-task", + run: async ({ payload }: { payload: { url: string } }) => { + const response = await fetch(payload.url, { + method: "POST", + body: JSON.stringify({ + hello: "world", + taskId: "fetch-post-task", + foo: "barrrrrrrrrrrrrrrrrr", + }), + }); + + return response.json(); + }, +}); + +export const createJsonHeroDoc = task({ + id: "create-jsonhero-doc", + run: async ({ payload, ctx }: { payload: { title: string; content: any }; ctx: Context }) => { + // Sleep for 5 seconds + await wait.for({ seconds: 5 }); + + const response = await fetch("https://jsonhero.io/api/create.json", { + method: "POST", + headers: { + "Content-Type": "application/json", + }, + body: JSON.stringify({ + title: `${payload.title} v2`, + content: { + payload: payload.content, + __triggerContext: ctx, + }, + readOnly: true, + }), + }); + + const json: any = await response.json(); + + return json; + }, +}); + +export const simulateError = task({ + id: "simulateError", + run: async ({ payload, ctx }: { payload: { message: string }; ctx: Context }) => { + // Sleep for 1 second + await new Promise((resolve) => setTimeout(resolve, 1000)); + + thisFunctionWillThrow(); + }, +}); + +function thisFunctionWillThrow() { + throw new Error("This function will throw"); +} + +export const parentTask = task({ + id: "parent-task", + run: async ({ payload, ctx }: { payload: { message: string }; ctx: Context }) => { + logger.info("Parent task payload", { payload }); + + console.log(JSON.stringify({ ctx, message: "This is the parent task context" })); + + await wait.for({ seconds: 5 }); + + const childTaskResponse = await childTask.triggerAndWait({ + payload: { + message: payload.message, + forceError: false, + }, + }); + + logger.info("Child task response", { childTaskResponse }); + + await childTask.trigger({ + payload: { + message: `${payload.message} - 2.a`, + forceError: true, + }, + }); + + return { + message: payload.message, + childTaskResponse, + }; + }, +}); + +export const childTask = task({ + id: "child-task", + run: async ({ + payload, + ctx, + }: { + payload: { message: string; forceError: boolean }; + ctx: Context; + }) => { + logger.info("Child task payload", { payload }); + + await wait.for({ seconds: 10 }); + + const response = await fetch("https://jsonhero.io/api/create.json", { + method: "POST", + headers: { + "Content-Type": "application/json", + }, + body: JSON.stringify({ + title: "childTask payload and ctx", + content: { + payload, + ctx, + }, + readOnly: true, + }), + }); + + const json: any = await response.json(); + + logger.info("JSONHero response", { json }); + + if (payload.forceError) { + throw new Error(`Forced error: ${payload.message}`); + } + + return { + message: "This is the child task", + parentMessage: payload.message, + }; + }, +}); diff --git a/references/v3-catalog/trigger.config.mjs b/references/v3-catalog/trigger.config.mjs new file mode 100644 index 000000000..11888a2d8 --- /dev/null +++ b/references/v3-catalog/trigger.config.mjs @@ -0,0 +1,5 @@ +/** @type {import('@trigger.dev/sdk/v3').Config} */ + +export default { + project: "yubjwjsfkxnylobaqvqz", +}; diff --git a/references/v3-catalog/tsconfig.json b/references/v3-catalog/tsconfig.json new file mode 100644 index 000000000..509f66c9c --- /dev/null +++ b/references/v3-catalog/tsconfig.json @@ -0,0 +1,15 @@ +{ + "extends": "@trigger.dev/tsconfig/node18.json", + "include": ["./src/**/*.ts", "trigger.config.mjs"], + "compilerOptions": { + "baseUrl": ".", + "lib": ["DOM", "DOM.Iterable"], + "paths": { + "@/*": ["./src/*"], + "@trigger.dev/sdk": ["../../packages/trigger-sdk/src/index"], + "@trigger.dev/sdk/*": ["../../packages/trigger-sdk/src/*"], + "@trigger.dev/core": ["../../packages/core/src/index"], + "@trigger.dev/core/*": ["../../packages/core/src/*"] + } + } +} diff --git a/tests/global.setup.ts b/tests/global.setup.ts index e89d40063..dfc04c671 100644 --- a/tests/global.setup.ts +++ b/tests/global.setup.ts @@ -39,6 +39,7 @@ const setup = async () => { slug: organization.slug, }, }, + externalRef: "test-project-123", }, include: { organization: {