@beignet/core 0.0.32 → 0.0.34

package/src/application/index.ts

@@ -5,6 +5,8 @@ import {
 } from "../providers/instrumentation.js";
 import {
   createChildTraceContext,
+  resolveTracingPort,
+  runWithTracing,
   type TraceContextInput,
 } from "../tracing/index.js";
 
@@ -482,6 +484,7 @@ function getInstrumentationTrace(ctx: unknown): TraceContextInput | undefined {
     spanId: context.spanId,
     parentSpanId: context.parentSpanId,
     traceparent: context.traceparent,
+    tracestate: context.tracestate,
   };
 }
 
@@ -517,9 +520,9 @@ function startUseCaseRunInstrumentation(args: {
   if (!useCasesEnabled && !errorsEnabled) return undefined;
 
   const requestId = getInstrumentationRequestId(args.ctx);
-  const trace = createChildTraceContext(
-    getInstrumentationTrace(args.ctx) ?? {},
-  );
+  const trace =
+    resolveTracingPort(ports)?.current() ??
+    createChildTraceContext(getInstrumentationTrace(args.ctx) ?? {});
 
   const record = (event: ProviderInstrumentationEventInput) => {
     try {
@@ -542,6 +545,7 @@ function startUseCaseRunInstrumentation(args: {
         spanId: trace.spanId,
         parentSpanId: trace.parentSpanId,
         traceparent: trace.traceparent,
+        tracestate: trace.tracestate,
         name: args.name,
         kind: args.kind,
         phase,
@@ -558,6 +562,7 @@ function startUseCaseRunInstrumentation(args: {
         spanId: trace.spanId,
         parentSpanId: trace.parentSpanId,
         traceparent: trace.traceparent,
+        tracestate: trace.tracestate,
         message: getRunErrorMessage(error),
         stack: error instanceof Error ? error.stack : undefined,
         useCaseName: args.name,
@@ -725,61 +730,88 @@ class UseCaseBuilder<
         : never,
       parseInput: boolean,
     ) => {
-      const startedAt = Date.now();
-      const instrumentation = instrumented
-        ? startUseCaseRunInstrumentation({
-            ctx: args.ctx,
+      const traceAttributes = {
+        "beignet.use_case.name": useCaseName,
+        "beignet.use_case.kind": useCaseKind,
+      } as const;
+
+      return await runWithTracing(
+        args.ctx,
+        {
+          name: `beignet.use_case ${useCaseName}`,
+          type: "useCase",
+          kind: "internal",
+          attributes: traceAttributes,
+          metricAttributes: traceAttributes,
+        },
+        async () => {
+          const startedAt = Date.now();
+          const instrumentation = instrumented
+            ? startUseCaseRunInstrumentation({
+                ctx: args.ctx,
+                name: useCaseName,
+                kind: useCaseKind,
+              })
+            : undefined;
+          onRun?.({
             name: useCaseName,
             kind: useCaseKind,
-          })
-        : undefined;
-      onRun?.({
-        name: useCaseName,
-        kind: useCaseKind,
-        phase: "start",
-        ctx: args.ctx,
-      });
-
-      try {
-        const parsedInput =
-          parseInput && validation.input
-            ? await parseSchema(inputSchema, args.input, useCaseName, "input")
-            : (args.input as SchemaOutput<InputSchema>);
-
-        const rawResult = await fn({
-          ctx: args.ctx,
-          input: parsedInput,
-          events: eventHelpers,
-        });
-
-        const result = validation.output
-          ? await parseSchema(outputSchema, rawResult, useCaseName, "output")
-          : (rawResult as SchemaOutput<OutputSchema>);
-
-        const durationMs = Date.now() - startedAt;
-        instrumentation?.end(durationMs);
-        onRun?.({
-          name: useCaseName,
-          kind: useCaseKind,
-          phase: "end",
-          durationMs,
-          ctx: args.ctx,
-        });
-
-        return result;
-      } catch (err) {
-        const durationMs = Date.now() - startedAt;
-        instrumentation?.error(durationMs, err);
-        onRun?.({
-          name: useCaseName,
-          kind: useCaseKind,
-          phase: "error",
-          durationMs,
-          error: err,
-          ctx: args.ctx,
-        });
-        throw err;
-      }
+            phase: "start",
+            ctx: args.ctx,
+          });
+
+          try {
+            const parsedInput =
+              parseInput && validation.input
+                ? await parseSchema(
+                    inputSchema,
+                    args.input,
+                    useCaseName,
+                    "input",
+                  )
+                : (args.input as SchemaOutput<InputSchema>);
+
+            const rawResult = await fn({
+              ctx: args.ctx,
+              input: parsedInput,
+              events: eventHelpers,
+            });
+
+            const result = validation.output
+              ? await parseSchema(
+                  outputSchema,
+                  rawResult,
+                  useCaseName,
+                  "output",
+                )
+              : (rawResult as SchemaOutput<OutputSchema>);
+
+            const durationMs = Date.now() - startedAt;
+            instrumentation?.end(durationMs);
+            onRun?.({
+              name: useCaseName,
+              kind: useCaseKind,
+              phase: "end",
+              durationMs,
+              ctx: args.ctx,
+            });
+
+            return result;
+          } catch (err) {
+            const durationMs = Date.now() - startedAt;
+            instrumentation?.error(durationMs, err);
+            onRun?.({
+              name: useCaseName,
+              kind: useCaseKind,
+              phase: "error",
+              durationMs,
+              error: err,
+              ctx: args.ctx,
+            });
+            throw err;
+          }
+        },
+      );
     };
 
     type RunArgs = Parameters<typeof execute>[0];

package/src/contracts/contract-builder.ts

@@ -111,13 +111,6 @@ export class ContractBuilder<
   /**
    * URL path template for this contract.
    */
-  get pathTemplate(): TPath {
-    return this._path;
-  }
-
-  /**
-   * URL path template alias.
-   */
   get path(): TPath {
     return this._path;
   }

package/src/events/index.ts

@@ -1,4 +1,6 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
+import { runWithResolvedTracingContext } from "../tracing/execution.js";
+import type { TracingPort } from "../tracing/index.js";
 
 /**
  * Any Standard Schema compatible validator.
@@ -160,6 +162,11 @@ export interface RegisterListenersOptions<Ctx> {
    * Static listener context or factory evaluated for each delivered event.
    */
   ctx?: Ctx | (() => MaybePromise<Ctx>);
+  /**
+   * Runtime tracing port used to start the listener span before a lazy context
+   * factory runs.
+   */
+  tracing?: TracingPort;
   /**
    * Called when a listener fails. When omitted, listener errors are rethrown to
    * the event bus subscription callback.
@@ -243,16 +250,6 @@ async function parsePayload<Schema extends StandardSchemaV1>(
   throw new Error("Invalid Standard Schema result: missing value");
 }
 
-async function resolveCtx<Ctx>(
-  ctx: Ctx | (() => MaybePromise<Ctx>) | undefined,
-): Promise<Ctx> {
-  if (typeof ctx === "function") {
-    return (ctx as () => MaybePromise<Ctx>)();
-  }
-
-  return ctx as Ctx;
-}
-
 /**
  * Define a typed event.
  *
@@ -326,10 +323,26 @@ export function registerListeners<Ctx>(
     eventBus.subscribe(listener.event, async (rawPayload) => {
       try {
         const payload = await parseEventPayload(listener.event, rawPayload);
-        await listener.handle({
-          event: listener.event,
-          payload,
-          ctx: await resolveCtx(options.ctx),
+        const traceAttributes = {
+          "beignet.listener.name": listener.name,
+          "beignet.event.name": listener.event.name,
+        } as const;
+        await runWithResolvedTracingContext({
+          tracing: options.tracing,
+          ctx: options.ctx as Ctx | (() => MaybePromise<Ctx>),
+          operation: {
+            name: `beignet.listener ${listener.name}`,
+            type: "listener",
+            kind: "consumer",
+            attributes: traceAttributes,
+            metricAttributes: traceAttributes,
+          },
+          run: (ctx) =>
+            listener.handle({
+              event: listener.event,
+              payload,
+              ctx,
+            }),
         });
       } catch (error) {
         options.onError?.(error, listener);

package/src/flags/index.ts

@@ -406,11 +406,6 @@ export function defineFlags<const TRegistry extends FlagRegistry>(
   return registry;
 }
 
-/**
- * Alias for apps that prefer to name the collection explicitly.
- */
-export const defineFlagRegistry = defineFlags;
-
 /**
  * Evaluate a flag through any `FlagsPort`.
  */