@m1212e/rumble 0.23.17 → 0.23.19

package/out/index.mjs

@@ -3,15 +3,16 @@ import { t as generateFromSchema } from "./generate-0QFVc3Sg.mjs";
 import { GraphQLError, GraphQLSchema, execute as defaultExecute, getOperationAST, print, subscribe as defaultSubscribe } from "graphql";
 import { EnvelopArmorPlugin } from "@escape.tech/graphql-armor";
 import { useDisableIntrospection } from "@graphql-yoga/plugin-disable-introspection";
-import { SpanStatusCode, trace } from "@opentelemetry/api";
+import { SpanStatusCode, isSpanContextValid, trace } from "@opentelemetry/api";
 import { capitalize, cloneDeep, debounce, merge, toMerged } from "es-toolkit";
 import { createPubSub, createYoga } from "graphql-yoga";
 import { One, count, getTableColumns, getTableName, is, isTable, relationsFilterToSQL, sql } from "drizzle-orm";
+import { ATTR_GRAPHQL_DOCUMENT, ATTR_GRAPHQL_OPERATION_NAME, ATTR_GRAPHQL_OPERATION_TYPE } from "@opentelemetry/semantic-conventions/incubating";
+import { AttributeNames, SpanNames, createOpenTelemetryWrapper } from "@pothos/tracing-opentelemetry";
 import { toCamelCase } from "drizzle-orm/casing";
 import { PgColumn, PgEnumColumn, PgEnumObjectColumn, PgTable, isPgEnum } from "drizzle-orm/pg-core";
 import { MySqlEnumColumn, MySqlEnumObjectColumn, MySqlTable } from "drizzle-orm/mysql-core";
 import pluralize from "pluralize";
-import { AttributeNames, SpanNames, createOpenTelemetryWrapper } from "@pothos/tracing-opentelemetry";
 import { SQLiteTable } from "drizzle-orm/sqlite-core";
 import SchemaBuilder, { BasePlugin } from "@pothos/core";
 import DrizzlePlugin from "@pothos/plugin-drizzle";
@@ -181,7 +182,39 @@ function mapNullFieldsToUndefined(obj) {
 }
 //#endregion
 //#region package.json
-var version = "0.23.17";
+var version = "0.23.19";
+//#endregion
+//#region lib/helpers/errorLogging.ts
+function hasMessage(error) {
+	return typeof error === "object" && error !== null && "message" in error;
+}
+function toLoggedException(error) {
+	if (hasMessage(error)) {
+		const gqlError = error;
+		return {
+			"exception.type": gqlError.constructor?.name ?? gqlError.name ?? "Error",
+			"exception.message": String(gqlError.message),
+			...gqlError.stack ? { "exception.stacktrace": gqlError.stack } : {},
+			...gqlError.path ? { path: gqlError.path } : {},
+			...gqlError.extensions && Object.keys(gqlError.extensions).length > 0 ? { extensions: gqlError.extensions } : {}
+		};
+	}
+	return {
+		"exception.type": "UnknownError",
+		"exception.message": String(error)
+	};
+}
+/**
+* Every erroneous rumble log carries the same `errors` array shape,
+* whether it originates from a thrown exception (single-element array)
+* or a GraphQL `ExecutionResult.errors` list (multi-element array).
+*/
+function errorsLogField(errors) {
+	return { errors: errors.map(toLoggedException) };
+}
+function errorLogField(error) {
+	return errorsLogField([error]);
+}
 //#endregion
 //#region lib/helpers/mergeFilters.ts
 const EmptyFilter$1 = Symbol.for("drizzle:EmptyFilter");
@@ -441,6 +474,182 @@ function tableHelper({ db, table }) {
 	};
 }
 //#endregion
+//#region lib/helpers/telemetry.ts
+const SPAN_EXECUTE = SpanNames.EXECUTE;
+/** @pothos/tracing-opentelemetry's SpanNames enum has no subscribe member. */
+const SPAN_SUBSCRIBE = "graphql.subscribe";
+const SPAN_SUBSCRIBE_EVENT = "graphql.subscribe.event";
+const SPAN_ABILITIES_PREPARE = "rumble.abilities.prepare";
+const SPAN_FILTERS_APPLY = "rumble.filters.apply";
+const SPAN_FILTERS_RESOLVE = "rumble.filters.resolve";
+const ATTR_OPERATION_NAME = ATTR_GRAPHQL_OPERATION_NAME;
+const ATTR_OPERATION_TYPE = ATTR_GRAPHQL_OPERATION_TYPE;
+const ATTR_DOCUMENT = ATTR_GRAPHQL_DOCUMENT;
+const ATTR_FIELD_NAME = AttributeNames.FIELD_NAME;
+/** Prefix for per-variable span attributes, e.g. `graphql.variables.userId`. */
+const ATTR_VARIABLES_PREFIX = AttributeNames.VARIABLES;
+/** Log field holding all variables as one object (logs keep nesting, spans flatten). */
+const FIELD_VARIABLES = "graphql.variables";
+const ATTR_PARENT_TYPE = "graphql.parent.type";
+const ATTR_TRANSPORT = "rumble.transport";
+const ATTR_TABLE = "rumble.table";
+const ATTR_ACTION = "rumble.action";
+const ATTR_ABILITIES_STATUS = "rumble.abilities.status";
+const ATTR_ABILITIES_STATIC = "rumble.abilities.static";
+const ATTR_ABILITIES_DYNAMIC = "rumble.abilities.dynamic";
+const ATTR_ABILITIES_TOTAL = "rumble.abilities.total";
+const ATTR_FILTERS_TOTAL = "rumble.filters.total";
+const ATTR_FILTERS_ALLOWED = "rumble.filters.allowed";
+const ATTR_SUBSCRIPTION_EVENT_INDEX = "rumble.subscription.event_index";
+const FIELD_DURATION_MS = "duration_ms";
+const FIELD_EVENT_COUNT = "event_count";
+function telemetryLogger(config) {
+	return config.logger?.enabled ? config.logger.logger : void 0;
+}
+function telemetryTracer(config) {
+	return config.otel?.enabled ? config.otel.tracer : void 0;
+}
+/**
+* Whether anything at all should be instrumented. When this is false, rumble
+* hands the untouched execute/subscribe functions back to the transports so a
+* user who wants neither traces nor logs pays no overhead.
+*/
+function telemetryEnabled(config) {
+	return Boolean(config.otel?.enabled || config.logger?.enabled);
+}
+/**
+* `trace_id`/`span_id`/`trace_flags` for the given span, or for the currently
+* active one when no span is passed. Field names and the two-hex-digit flags
+* format follow the OpenTelemetry log data model, which is what log backends
+* (Loki, Tempo, Elastic) expect when linking a log line to its trace.
+*
+* Reading the *active* span means every rumble log site gets correlation for
+* free, without threading a child logger through the whole library.
+*/
+function traceCorrelationFields(config, span) {
+	if (!config.otel?.enabled || config.logger?.injectTraceId === false) return {};
+	const target = span ?? trace.getActiveSpan();
+	if (!target) return {};
+	const spanContext = target.spanContext();
+	if (!isSpanContextValid(spanContext)) return {};
+	return {
+		trace_id: spanContext.traceId,
+		span_id: spanContext.spanId,
+		trace_flags: spanContext.traceFlags.toString(16).padStart(2, "0")
+	};
+}
+function toException(error) {
+	if (error instanceof Error) return error;
+	if (typeof error === "object" && error !== null && "message" in error) return error;
+	return String(error);
+}
+function exceptionMessage(error) {
+	if (typeof error === "object" && error !== null && "message" in error) return String(error.message);
+	return error === void 0 ? void 0 : String(error);
+}
+/**
+* Records every error as an exception event and flips the span to ERROR, per
+* OpenTelemetry's exception conventions. Used for rumble's own spans as well as
+* the GraphQL operation spans so a failure looks identical wherever it happens.
+*/
+function recordSpanErrors(span, errors) {
+	if (!span || errors.length === 0) return;
+	for (const error of errors) span.recordException(toException(error));
+	span.setStatus({
+		code: SpanStatusCode.ERROR,
+		message: exceptionMessage(errors[0])
+	});
+}
+function recordSpanError(span, error) {
+	recordSpanErrors(span, [error]);
+}
+/**
+* Errors the operation wrapper has already reported.
+*
+* A transport can see the same failure twice: sofa, for instance, hands
+* `result.errors` to its error handler *after* execute has returned, so without
+* this the very same error would produce two log lines and two exception events,
+* which quietly doubles error counts in dashboards. A WeakSet keeps this free of
+* bookkeeping — entries disappear with the errors themselves.
+*/
+const reportedErrors = /* @__PURE__ */ new WeakSet();
+function markErrorsReported(errors) {
+	for (const error of errors) if (typeof error === "object" && error !== null) reportedErrors.add(error);
+}
+/** True when every error was already reported by the operation wrapper. */
+function errorsAlreadyReported(errors) {
+	if (errors.length === 0) return false;
+	return errors.every((error) => typeof error === "object" && error !== null && reportedErrors.has(error));
+}
+function safeJsonStringify(value) {
+	try {
+		return JSON.stringify(value, (_key, inner) => typeof inner === "bigint" ? inner.toString() : inner) ?? "null";
+	} catch {
+		return String(value);
+	}
+}
+function isHomogeneousPrimitiveArray(value) {
+	let seen;
+	for (const entry of value) {
+		if (entry === null || entry === void 0) continue;
+		const type = typeof entry;
+		if (type !== "string" && type !== "number" && type !== "boolean") return false;
+		if (seen && seen !== type) return false;
+		seen = type;
+	}
+	return true;
+}
+/**
+* Coerces an arbitrary value into something the OpenTelemetry attribute type
+* allows: primitives pass through, homogeneous primitive arrays stay arrays
+* (mixed ones are invalid per spec) and everything else becomes JSON.
+*
+* Values are intentionally not truncated here — length limits belong to the SDK
+* (`OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT`) so they stay configurable per deployment.
+*/
+function attributeValue(value) {
+	switch (typeof value) {
+		case "string": return value;
+		case "number": return Number.isFinite(value) ? value : String(value);
+		case "boolean": return value;
+		case "bigint": return value.toString();
+		case "undefined": return "null";
+		default: break;
+	}
+	if (value === null) return "null";
+	if (Array.isArray(value) && isHomogeneousPrimitiveArray(value)) return value;
+	return safeJsonStringify(value);
+}
+function resolveVariables(variables, include) {
+	if (include === false || !variables) return void 0;
+	const resolved = typeof include === "function" ? include({ ...variables }) : variables;
+	if (!resolved || Object.keys(resolved).length === 0) return void 0;
+	return resolved;
+}
+/** Variables flattened into `graphql.variables.<name>` span attributes. */
+function variableAttributes(variables, include) {
+	const resolved = resolveVariables(variables, include);
+	if (!resolved) return {};
+	const attributes = {};
+	for (const [key, value] of Object.entries(resolved)) attributes[`${ATTR_VARIABLES_PREFIX}${key}`] = attributeValue(value);
+	return attributes;
+}
+/** Variables as a single nested `graphql.variables` log field. */
+function variableLogField(variables, include) {
+	const resolved = resolveVariables(variables, include);
+	return resolved ? { [FIELD_VARIABLES]: resolved } : {};
+}
+/**
+* Monotonic clock reading. `Date.now()` can jump backwards when the wall clock is
+* adjusted (NTP), which would produce negative or inflated durations.
+*/
+function startTimer() {
+	return performance.now();
+}
+function durationMs(start) {
+	return Math.round((performance.now() - start) * 100) / 100;
+}
+//#endregion
 //#region lib/abilityBuilder.ts
 function isDynamicQueryFilter(filter) {
 	return typeof filter === "function" && filter.constructor.name !== "AsyncFunction";
@@ -448,17 +657,22 @@ function isDynamicQueryFilter(filter) {
 function isStaticQueryFilter(filter) {
 	return typeof filter !== "function";
 }
-const makeNothingRegisteredWarner = (logger) => debounce((model, action) => {
+const makeNothingRegisteredWarner = (config, logger) => debounce((model, action) => {
 	const msg = `No abilities registered for ${model}/${action} — blocking everything. Register the ability or ignore this warning if intentional.`;
 	if (logger) logger.warn({
-		"rumble.table": model,
-		"rumble.action": action
+		[ATTR_TABLE]: model,
+		[ATTR_ACTION]: action,
+		...traceCorrelationFields(config)
 	}, msg);
 	else console.warn(msg);
 }, 1e3);
 const createAbilityBuilder = ({ db, actions, defaultLimit, otel, logger: loggerConfig }) => {
 	const log = loggerConfig?.enabled ? loggerConfig.logger : void 0;
-	const nothingRegisteredWarningLogger = makeNothingRegisteredWarner(log);
+	const telemetryConfig = {
+		otel,
+		logger: loggerConfig
+	};
+	const nothingRegisteredWarningLogger = makeNothingRegisteredWarner(telemetryConfig, log);
 	const tableRelationNames = Object.keys(db.query).filter((name) => tableHelper({
 		db,
 		table: name
@@ -718,14 +932,14 @@ by: (explicitFilter) => {
 					}
 					return { withContext: (userContext) => {
 						return { filter: (action) => {
-							const assembleAbilities = (span) => {
+							const assembleAbilities = (attributes) => {
 								const filters = queryFilters.get(action);
 								if (filters === "unrestricted") {
-									span?.setAttribute("abilities.status", "unrestricted");
+									attributes[ATTR_ABILITIES_STATUS] = "unrestricted";
 									return transformToResponse();
 								}
 								if (!filters) {
-									span?.setAttribute("abilities.status", "blocked_everything");
+									attributes[ATTR_ABILITIES_STATUS] = "blocked_everything";
 									nothingRegisteredWarningLogger(String(tableName), action);
 									return transformToResponse(blockEverythingFilter);
 								}
@@ -734,58 +948,60 @@ by: (explicitFilter) => {
 								for (let i = 0; i < dynamicQueryFilters[action].length; i++) {
 									const func = dynamicQueryFilters[action][i];
 									const result = func(userContext);
-									if (result === "allow") return transformToResponse();
+									if (result === "allow") {
+										attributes[ATTR_ABILITIES_STATUS] = "unrestricted";
+										return transformToResponse();
+									}
 									if (result === void 0) continue;
 									dynamicResults[filtersReturned++] = result;
 								}
 								dynamicResults.length = filtersReturned;
-								span?.setAttribute("abilities.dynamic", dynamicResults.length);
-								span?.setAttribute("abilities.static", simpleQueryFilters[action].length);
+								attributes[ATTR_ABILITIES_DYNAMIC] = dynamicResults.length;
+								attributes[ATTR_ABILITIES_STATIC] = simpleQueryFilters[action].length;
 								const allQueryFilters = [...simpleQueryFilters[action], ...dynamicResults];
-								span?.setAttribute("abilities.total", allQueryFilters.length);
+								attributes[ATTR_ABILITIES_TOTAL] = allQueryFilters.length;
 								if (allQueryFilters.length === 0) {
-									span?.setAttribute("abilities.status", "blocked_everything");
+									attributes[ATTR_ABILITIES_STATUS] = "blocked_everything";
 									return transformToResponse(blockEverythingFilter);
 								}
 								const mergedFilters = allQueryFilters.length === 1 ? allQueryFilters[0] : allQueryFilters.reduce((a, b) => {
 									return mergeFilters(a, b, "OR");
 								});
-								span?.setAttribute("abilities.status", "applied");
+								attributes[ATTR_ABILITIES_STATUS] = "applied";
 								return transformToResponse(mergedFilters);
 							};
-							if (otel?.enabled && otel.tracer) return otel.tracer.startActiveSpan(`rumble.abilities.prepare`, (span) => {
-								span.setAttribute("rumble.action", action);
-								span.setAttribute("rumble.table", String(tableName));
+							const run = (span) => {
+								const attributes = {
+									[ATTR_TABLE]: String(tableName),
+									[ATTR_ACTION]: action
+								};
 								try {
-									const attrs = {
-										"rumble.table": String(tableName),
-										"rumble.action": action
-									};
-									const proxy = new Proxy(span, { get(target, prop) {
-										if (prop === "setAttribute") return (k, v) => {
-											attrs[k] = v;
-											return target.setAttribute(k, v);
-										};
-										return target[prop];
-									} });
-									const result = assembleAbilities(proxy);
-									log?.debug(attrs, "abilities prepared");
+									const result = assembleAbilities(attributes);
+									log?.debug({
+										...attributes,
+										...traceCorrelationFields(telemetryConfig, span)
+									}, "abilities prepared");
 									return result;
+								} catch (error) {
+									recordSpanError(span, error);
+									log?.error({
+										...attributes,
+										...traceCorrelationFields(telemetryConfig, span),
+										...errorLogField(error)
+									}, "abilities failed");
+									throw error;
+								} finally {
+									span?.setAttributes(attributes);
+								}
+							};
+							if (otel?.enabled && otel.tracer) return otel.tracer.startActiveSpan(SPAN_ABILITIES_PREPARE, (span) => {
+								try {
+									return run(span);
 								} finally {
 									span.end();
 								}
 							});
-							else {
-								const attrs = {
-									"rumble.table": String(tableName),
-									"rumble.action": action
-								};
-								const result = assembleAbilities(log ? { setAttribute: (k, v) => {
-									attrs[k] = v;
-								} } : void 0);
-								log?.debug(attrs, "abilities prepared");
-								return result;
-							}
+							return run();
 						} };
 					} };
 				};
@@ -1312,207 +1528,192 @@ const sofaOpenAPIWebhookDocs = {
 	} }
 };
 //#endregion
-//#region lib/helpers/errorLogging.ts
-function hasMessage(error) {
-	return typeof error === "object" && error !== null && "message" in error;
+//#region lib/helpers/tracing.ts
+function isAsyncIterable(value) {
+	return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
 }
-function toLoggedException(error) {
-	if (hasMessage(error)) {
-		const gqlError = error;
-		return {
-			"exception.type": gqlError.constructor?.name ?? gqlError.name ?? "Error",
-			"exception.message": String(gqlError.message),
-			...gqlError.stack ? { "exception.stacktrace": gqlError.stack } : {},
-			...gqlError.path ? { path: gqlError.path } : {},
-			...gqlError.extensions && Object.keys(gqlError.extensions).length > 0 ? { extensions: gqlError.extensions } : {}
-		};
-	}
+function buildOperationTelemetry(config, transport, options) {
+	const operationAst = getOperationAST(options.document, options.operationName);
+	const operationName = options.operationName ?? operationAst?.name?.value ?? "anonymous";
+	const operationType = operationAst?.operation;
+	const logFields = {
+		[ATTR_OPERATION_NAME]: operationName,
+		...operationType ? { [ATTR_OPERATION_TYPE]: operationType } : {},
+		[ATTR_TRANSPORT]: transport
+	};
 	return {
-		"exception.type": "UnknownError",
-		"exception.message": String(error)
+		operationName,
+		operationType,
+		logFields,
+		variableLogFields: variableLogField(options.variableValues, config.logger?.includeVariables),
+		attributes: () => ({
+			...logFields,
+			...config.otel?.includeDocument === false ? {} : { [ATTR_DOCUMENT]: print(options.document) },
+			...variableAttributes(options.variableValues, config.otel?.includeVariables)
+		})
 	};
 }
 /**
-* Every erroneous rumble log carries the same `errors` array shape,
-* whether it originates from a thrown exception (single-element array)
-* or a GraphQL `ExecutionResult.errors` list (multi-element array).
+* Wraps a subscription's event stream so delivered events are observable no
+* matter which transport consumes them.
 */
-function errorsLogField(errors) {
-	return { errors: errors.map(toLoggedException) };
-}
-function errorLogField(error) {
-	return errorsLogField([error]);
-}
-//#endregion
-//#region lib/helpers/tracing.ts
-const SUBSCRIBE_SPAN_NAME = "graphql.subscribe";
-function getOperationType(options) {
-	return getOperationAST(options.document, options.operationName)?.operation;
-}
-function operationLogFields(operationName, operationType) {
-	return {
-		"graphql.operation.name": operationName,
-		...operationType ? { "graphql.operation.type": operationType } : {}
-	};
-}
-function traceIdLogFields(span) {
-	const { traceId, spanId, traceFlags } = span.spanContext();
-	return {
-		trace_id: traceId,
-		span_id: spanId,
-		trace_flags: traceFlags.toString(16).padStart(2, "0")
+async function* wrapSubscriptionIterator(iterator, telemetry) {
+	const { log, tracer, setupSpanContext, logFields, attributes } = telemetry;
+	const recordEventErrors = (eventCount, errors) => {
+		if (!tracer) return;
+		const span = tracer.startSpan(SPAN_SUBSCRIBE_EVENT, {
+			root: true,
+			links: setupSpanContext ? [{ context: setupSpanContext }] : void 0,
+			attributes: {
+				...attributes,
+				[ATTR_SUBSCRIPTION_EVENT_INDEX]: eventCount
+			}
+		});
+		recordSpanErrors(span, errors);
+		span.end();
 	};
-}
-function isAsyncIterable(value) {
-	return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
-}
-async function* wrapSubscriptionIterator(iterator, log, operationName, operationType) {
 	let eventCount = 0;
 	try {
 		for await (const event of iterator) {
 			eventCount++;
-			if (event.errors?.length) log.error({
-				...operationLogFields(operationName, operationType),
-				event_count: eventCount,
-				...errorsLogField(event.errors)
-			}, "graphql subscription event error");
+			if (event.errors?.length) {
+				log?.error({
+					...logFields,
+					[FIELD_EVENT_COUNT]: eventCount,
+					...errorsLogField(event.errors)
+				}, "graphql subscription event error");
+				recordEventErrors(eventCount, event.errors);
+			}
 			yield event;
 		}
-		log.info({
-			...operationLogFields(operationName, operationType),
-			event_count: eventCount
+		log?.info({
+			...logFields,
+			[FIELD_EVENT_COUNT]: eventCount
 		}, "graphql subscription completed");
 	} catch (error) {
-		log.error({
-			...operationLogFields(operationName, operationType),
-			event_count: eventCount,
+		log?.error({
+			...logFields,
+			[FIELD_EVENT_COUNT]: eventCount,
 			...errorLogField(error)
 		}, "graphql subscription threw");
+		recordEventErrors(eventCount, [error]);
 		throw error;
 	}
 }
-function buildTracedExecute(executeFn, rumbleInput) {
+function buildTracedExecute(executeFn, rumbleInput, transport) {
+	if (!telemetryEnabled(rumbleInput)) return executeFn;
 	return async (options) => {
-		let log = rumbleInput.logger?.enabled ? rumbleInput.logger.logger : void 0;
-		const operationName = options.operationName ?? "anonymous";
-		const operationType = getOperationType(options);
-		const start = Date.now();
-		log?.info(operationLogFields(operationName, operationType), "graphql execute start");
-		const run = async () => {
-			const result = await executeFn(options);
-			if (result && "errors" in result && result.errors?.length) log?.error({
-				...operationLogFields(operationName, operationType),
-				duration_ms: Date.now() - start,
-				...errorsLogField(result.errors)
-			}, "graphql execute completed with errors");
-			else log?.info({
-				...operationLogFields(operationName, operationType),
-				duration_ms: Date.now() - start
-			}, "graphql execute completed");
-			return result;
-		};
-		if (rumbleInput.otel?.enabled) return rumbleInput.otel.tracer.startActiveSpan(SpanNames.EXECUTE, { attributes: {
-			[AttributeNames.OPERATION_NAME]: operationName,
-			...operationType ? { [AttributeNames.OPERATION_TYPE]: operationType } : {},
-			"graphql.document": print(options.document)
-		} }, async (span) => {
-			if (log && rumbleInput.logger?.injectTraceId !== false) log = log.child(traceIdLogFields(span));
+		const tracer = telemetryTracer(rumbleInput);
+		let log = telemetryLogger(rumbleInput);
+		const telemetry = buildOperationTelemetry(rumbleInput, transport, options);
+		const start = startTimer();
+		const run = async (span) => {
+			log?.info({
+				...telemetry.logFields,
+				...telemetry.variableLogFields
+			}, "graphql execute start");
 			try {
-				const result = await run();
+				const result = await executeFn(options);
 				if (result && "errors" in result && result.errors?.length) {
-					for (const error of result.errors) span.recordException(error);
-					span.setStatus({ code: SpanStatusCode.ERROR });
-				}
+					log?.error({
+						...telemetry.logFields,
+						[FIELD_DURATION_MS]: durationMs(start),
+						...errorsLogField(result.errors)
+					}, "graphql execute completed with errors");
+					recordSpanErrors(span, result.errors);
+					markErrorsReported(result.errors);
+				} else log?.info({
+					...telemetry.logFields,
+					[FIELD_DURATION_MS]: durationMs(start)
+				}, "graphql execute completed");
 				return result;
 			} catch (error) {
-				if (error instanceof Error) span.recordException(error);
 				log?.error({
-					...operationLogFields(operationName, operationType),
-					duration_ms: Date.now() - start,
+					...telemetry.logFields,
+					[FIELD_DURATION_MS]: durationMs(start),
 					...errorLogField(error)
 				}, "graphql execute threw");
-				span.setStatus({ code: SpanStatusCode.ERROR });
+				recordSpanError(span, error);
+				markErrorsReported([error]);
 				throw error;
+			}
+		};
+		if (!tracer) return run();
+		return tracer.startActiveSpan(SPAN_EXECUTE, { attributes: telemetry.attributes() }, async (span) => {
+			if (log) {
+				const correlation = traceCorrelationFields(rumbleInput, span);
+				if (Object.keys(correlation).length > 0) log = log.child(correlation);
+			}
+			try {
+				return await run(span);
 			} finally {
 				span.end();
 			}
 		});
-		try {
-			return await run();
-		} catch (error) {
-			log?.error({
-				...operationLogFields(operationName, operationType),
-				duration_ms: Date.now() - start,
-				...errorLogField(error)
-			}, "graphql execute threw");
-			throw error;
-		}
 	};
 }
-function buildTracedSubscribe(subscribeFn, rumbleInput) {
+function buildTracedSubscribe(subscribeFn, rumbleInput, transport) {
+	if (!telemetryEnabled(rumbleInput)) return subscribeFn;
 	return async (options) => {
-		let log = rumbleInput.logger?.enabled ? rumbleInput.logger.logger : void 0;
-		const operationName = options.operationName ?? "anonymous";
-		const operationType = getOperationType(options);
-		const start = Date.now();
-		const doSubscribe = async () => {
-			log?.info(operationLogFields(operationName, operationType), "graphql subscribe start");
-			const result = await subscribeFn(options);
-			if (!isAsyncIterable(result)) {
-				const execResult = result;
-				if (execResult.errors?.length) log?.error({
-					...operationLogFields(operationName, operationType),
-					duration_ms: Date.now() - start,
-					...errorsLogField(execResult.errors)
-				}, "graphql subscribe completed with errors");
-				return execResult;
-			}
+		const tracer = telemetryTracer(rumbleInput);
+		let log = telemetryLogger(rumbleInput);
+		const telemetry = buildOperationTelemetry(rumbleInput, transport, options);
+		const start = startTimer();
+		const attributes = tracer ? telemetry.attributes() : {};
+		const doSubscribe = async (span) => {
 			log?.info({
-				...operationLogFields(operationName, operationType),
-				duration_ms: Date.now() - start
-			}, "graphql subscription established");
-			if (log) return wrapSubscriptionIterator(result, log, operationName, operationType);
-			return result;
-		};
-		if (rumbleInput.otel?.enabled) return rumbleInput.otel.tracer.startActiveSpan(SUBSCRIBE_SPAN_NAME, { attributes: {
-			[AttributeNames.OPERATION_NAME]: operationName,
-			...operationType ? { [AttributeNames.OPERATION_TYPE]: operationType } : {},
-			"graphql.document": print(options.document)
-		} }, async (span) => {
-			if (log && rumbleInput.logger?.injectTraceId !== false) log = log.child(traceIdLogFields(span));
+				...telemetry.logFields,
+				...telemetry.variableLogFields
+			}, "graphql subscribe start");
 			try {
-				const result = await doSubscribe();
+				const result = await subscribeFn(options);
 				if (!isAsyncIterable(result)) {
 					const execResult = result;
 					if (execResult.errors?.length) {
-						for (const error of execResult.errors) span.recordException(error);
-						span.setStatus({ code: SpanStatusCode.ERROR });
+						log?.error({
+							...telemetry.logFields,
+							[FIELD_DURATION_MS]: durationMs(start),
+							...errorsLogField(execResult.errors)
+						}, "graphql subscribe completed with errors");
+						recordSpanErrors(span, execResult.errors);
+						markErrorsReported(execResult.errors);
 					}
+					return execResult;
 				}
-				return result;
+				log?.info({
+					...telemetry.logFields,
+					[FIELD_DURATION_MS]: durationMs(start)
+				}, "graphql subscription established");
+				return wrapSubscriptionIterator(result, {
+					log,
+					tracer,
+					setupSpanContext: span?.spanContext(),
+					logFields: telemetry.logFields,
+					attributes
+				});
 			} catch (error) {
-				if (error instanceof Error) span.recordException(error);
 				log?.error({
-					...operationLogFields(operationName, operationType),
-					duration_ms: Date.now() - start,
+					...telemetry.logFields,
+					[FIELD_DURATION_MS]: durationMs(start),
 					...errorLogField(error)
 				}, "graphql subscribe threw");
-				span.setStatus({ code: SpanStatusCode.ERROR });
+				recordSpanError(span, error);
+				markErrorsReported([error]);
 				throw error;
+			}
+		};
+		if (!tracer) return doSubscribe();
+		return tracer.startActiveSpan(SPAN_SUBSCRIBE, { attributes }, async (span) => {
+			if (log) {
+				const correlation = traceCorrelationFields(rumbleInput, span);
+				if (Object.keys(correlation).length > 0) log = log.child(correlation);
+			}
+			try {
+				return await doSubscribe(span);
 			} finally {
 				span.end();
 			}
 		});
-		try {
-			return await doSubscribe();
-		} catch (error) {
-			log?.error({
-				...operationLogFields(operationName, operationType),
-				duration_ms: Date.now() - start,
-				...errorLogField(error)
-			}, "graphql subscribe threw");
-			throw error;
-		}
 	};
 }
 //#endregion
@@ -1661,17 +1862,30 @@ const isProbablyAConfigObject = (t) => {
 	].find((e) => e === k))) return true;
 	return false;
 };
-const createObjectImplementer = ({ db, search, logger: loggerConfig, schemaBuilder, makePubSubInstance, whereArgImplementer, orderArgImplementer, enumImplementer, abilityBuilder }) => {
+const createObjectImplementer = ({ db, search, otel, logger: loggerConfig, schemaBuilder, makePubSubInstance, whereArgImplementer, orderArgImplementer, enumImplementer, abilityBuilder }) => {
+	const telemetryConfig = {
+		otel,
+		logger: loggerConfig
+	};
+	/**
+	* Schema construction warnings go through the configured logger when there is
+	* one, so they end up in the same structured stream as everything else, and
+	* fall back to the console otherwise.
+	*/
+	const warn = (msg, fields = {}) => {
+		const log = loggerConfig?.enabled ? loggerConfig.logger : void 0;
+		if (log) log.warn({
+			...fields,
+			...traceCorrelationFields(telemetryConfig)
+		}, msg);
+		else console.warn(msg);
+	};
 	return ({ table, refName, readAction = "read", adjust }) => {
 		const tableSchema = tableHelper({
 			db,
 			table
 		});
-		if (Object.keys(tableSchema.primaryKey).length === 0) {
-			const log = loggerConfig?.enabled ? loggerConfig.logger : void 0;
-			const msg = `Could not find primary key for ${String(table)}. Cannot register subscriptions!`;
-			log ? log.warn({ "rumble.table": String(table) }, msg) : console.warn(msg);
-		}
+		if (Object.keys(tableSchema.primaryKey).length === 0) warn(`Could not find primary key for ${String(table)}. Cannot register subscriptions!`, { [ATTR_TABLE]: String(table) });
 		const primaryKey = Object.values(tableSchema.primaryKey)[0];
 		const { registerOnInstance } = makePubSubInstance({ table });
 		return schemaBuilder.drizzleObject(table, {
@@ -1680,9 +1894,7 @@ const createObjectImplementer = ({ db, search, logger: loggerConfig, schemaBuild
 				if (!primaryKey) return;
 				const primaryKeyValue = element[primaryKey.name];
 				if (!primaryKeyValue) {
-					const log = loggerConfig?.enabled ? loggerConfig.logger : void 0;
-					const msg = `Could not find primary key value for element on ${String(table)}. Cannot register subscription!`;
-					log ? log.warn({ "rumble.table": String(table) }, msg) : console.warn(msg);
+					warn(`Could not find primary key value for element on ${String(table)}. Cannot register subscription!`, { [ATTR_TABLE]: String(table) });
 					return;
 				}
 				registerOnInstance({
@@ -1714,7 +1926,7 @@ const createObjectImplementer = ({ db, search, logger: loggerConfig, schemaBuild
 				} })) ?? {};
 				const fields = Object.entries(columns).reduce((acc, [key, column]) => {
 					if (key.startsWith("__")) {
-						console.warn(`Skipping column "${key}" on table "${tableSchema.tsName}": names starting with "__" are reserved by GraphQL introspection. Use a custom adjust() call if you really need to expose this column.`);
+						warn(`Skipping column "${key}" on table "${tableSchema.tsName}": names starting with "__" are reserved by GraphQL introspection. Use a custom adjust() call if you really need to expose this column.`, { [ATTR_TABLE]: tableSchema.tsName });
 						return acc;
 					}
 					if (userAdjustments[key]) {
@@ -1917,8 +2129,12 @@ const createPubSubInstance = ({ subscriptions }) => {
 };
 //#endregion
 //#region lib/query.ts
-const createQueryImplementer = ({ db, schemaBuilder, search, logger: loggerConfig, whereArgImplementer, orderArgImplementer, makePubSubInstance }) => {
+const createQueryImplementer = ({ db, schemaBuilder, search, otel, logger: loggerConfig, whereArgImplementer, orderArgImplementer, makePubSubInstance }) => {
 	const registeredQueryFieldNames = /* @__PURE__ */ new Set();
+	const telemetryConfig = {
+		otel,
+		logger: loggerConfig
+	};
 	return ({ table, readAction = "read", listAction = "read", findFirst, findMany }) => {
 		const WhereArg = whereArgImplementer({ table });
 		const OrderArg = orderArgImplementer({ table });
@@ -1990,7 +2206,7 @@ const createQueryImplementer = ({ db, schemaBuilder, search, logger: loggerConfi
 							else {
 								const msg = "Database dialect is not postgresql, cannot set cpu_operator_cost.";
 								const log = loggerConfig?.enabled ? loggerConfig.logger : void 0;
-								log ? log.info({}, msg) : console.info(msg);
+								log ? log.info(traceCorrelationFields(telemetryConfig), msg) : console.info(msg);
 							}
 							return run(tx);
 						});
@@ -2282,6 +2498,7 @@ var RuntimeFiltersPlugin = class extends BasePlugin {
 	tracer;
 	tracerEnabled;
 	logger;
+	telemetryConfig = {};
 	filterLoaders = /* @__PURE__ */ new WeakMap();
 	getLoader(context, filter) {
 		let perContext = this.filterLoaders.get(context);
@@ -2310,6 +2527,10 @@ var RuntimeFiltersPlugin = class extends BasePlugin {
 		this.tracer = this.builder.options.otel?.tracer;
 		this.tracerEnabled = this.builder.options.otel?.enabled;
 		this.logger = this.builder.options.logger?.enabled ? this.builder.options.logger.logger : void 0;
+		this.telemetryConfig = {
+			otel: this.builder.options.otel,
+			logger: this.builder.options.logger
+		};
 		return typeConfig;
 	}
 	wrapResolve(resolver, fieldConfig) {
@@ -2321,13 +2542,16 @@ var RuntimeFiltersPlugin = class extends BasePlugin {
 			if (!filters || !Array.isArray(filters) || filters.length === 0) return resolver(parent, args, context, info);
 			const runFilters = async (span) => {
 				const allFilters = Array.isArray(filters) ? filters : [filters];
-				span?.setAttribute("filters.total", allFilters.length);
+				span?.setAttribute(ATTR_FILTERS_TOTAL, allFilters.length);
 				const loaders = allFilters.map((filter) => this.getLoader(context, filter));
 				let resolved;
-				if (this.tracer && this.tracerEnabled) resolved = await this.tracer.startActiveSpan(`rumble.filter.resolve`, async (span) => {
-					span.setAttribute("graphql.field.name", fieldConfig.name);
+				if (this.tracer && this.tracerEnabled) resolved = await this.tracer.startActiveSpan(SPAN_FILTERS_RESOLVE, async (span) => {
+					span.setAttribute(ATTR_FIELD_NAME, fieldConfig.name);
 					try {
 						return await resolver(parent, args, context, info);
+					} catch (error) {
+						recordSpanError(span, error);
+						throw error;
 					} finally {
 						span.end();
 					}
@@ -2336,24 +2560,30 @@ var RuntimeFiltersPlugin = class extends BasePlugin {
 				const entities = Array.isArray(resolved) ? resolved : [resolved];
 				const perFilterResults = await Promise.all(loaders.map((loader) => Promise.all(entities.map((entity) => loader.load(entity)))));
 				const allowed = entities.filter((_, index) => perFilterResults.some((results) => results[index] != null));
-				span?.setAttribute("filters.allowed", allowed.length);
+				span?.setAttribute(ATTR_FILTERS_ALLOWED, allowed.length);
 				this.logger?.debug({
-					"graphql.field.name": fieldConfig.name,
-					"filters.total": allFilters.length,
-					"filters.allowed": allowed.length
+					[ATTR_FIELD_NAME]: fieldConfig.name,
+					[ATTR_FILTERS_TOTAL]: allFilters.length,
+					[ATTR_FILTERS_ALLOWED]: allowed.length,
+					...traceCorrelationFields(this.telemetryConfig)
 				}, "runtime filters applied");
 				if (Array.isArray(resolved)) return allowed;
 				return allowed[0] ?? null;
 			};
-			if (this.tracer && this.tracerEnabled) return this.tracer.startActiveSpan(`rumble.filter.apply`, async (span) => {
-				span.setAttribute("graphql.field.name", fieldConfig.name);
+			const logFilterError = (error) => {
+				this.logger?.error({
+					[ATTR_FIELD_NAME]: fieldConfig.name,
+					...traceCorrelationFields(this.telemetryConfig),
+					...errorLogField(error)
+				}, "runtime filter threw");
+			};
+			if (this.tracer && this.tracerEnabled) return this.tracer.startActiveSpan(SPAN_FILTERS_APPLY, async (span) => {
+				span.setAttribute(ATTR_FIELD_NAME, fieldConfig.name);
 				try {
 					return await runFilters(span);
 				} catch (error) {
-					this.logger?.error({
-						"graphql.field.name": fieldConfig.name,
-						...errorLogField(error)
-					}, "runtime filter threw");
+					logFilterError(error);
+					recordSpanError(span, error);
 					throw error;
 				} finally {
 					span.end();
@@ -2362,10 +2592,7 @@ var RuntimeFiltersPlugin = class extends BasePlugin {
 			else try {
 				return await runFilters();
 			} catch (error) {
-				this.logger?.error({
-					"graphql.field.name": fieldConfig.name,
-					...errorLogField(error)
-				}, "runtime filter threw");
+				logFilterError(error);
 				throw error;
 			}
 		};
@@ -2413,18 +2640,22 @@ const createSchemaBuilder = ({ db, pubsub, pothosConfig, otel, logger }) => {
 				let r = createSpan ? createSpan(resolver, options) : resolver;
 				if (logger?.enabled) {
 					const log = logger.logger;
+					const telemetryConfig = {
+						otel,
+						logger
+					};
 					r = wrapResolver(r, (error, duration) => {
+						const fields = {
+							[ATTR_FIELD_NAME]: config.name,
+							[ATTR_PARENT_TYPE]: config.parentType,
+							[FIELD_DURATION_MS]: duration,
+							...traceCorrelationFields(telemetryConfig)
+						};
 						if (error) log.error({
-							"graphql.field.name": config.name,
-							"graphql.parent.type": config.parentType,
-							duration_ms: duration,
+							...fields,
 							...errorLogField(error)
 						}, "resolver failed");
-						else log.debug({
-							"graphql.field.name": config.name,
-							"graphql.parent.type": config.parentType,
-							duration_ms: duration
-						}, "resolver completed");
+						else log.debug(fields, "resolver completed");
 					});
 				}
 				return r;
@@ -2446,6 +2677,27 @@ const createSchemaBuilder = ({ db, pubsub, pothosConfig, otel, logger }) => {
 };
 //#endregion
 //#region lib/rumble.ts
+/**
+* Mirrors sofa's own default error handler: it derives the HTTP status from
+* `extensions.http` and returns the errors as JSON. rumble only adds telemetry
+* around error handling, so a request that fails must still answer with the
+* status and body a plain sofa setup would have produced.
+*/
+function sofaErrorResponse(errors) {
+	let status;
+	const headers = { "Content-Type": "application/json; charset=utf-8" };
+	for (const error of errors) {
+		const http = error?.extensions?.http;
+		if (!http) continue;
+		if (http.status && (!status || http.status > status)) status = http.status;
+		if (http.headers) Object.assign(headers, http.headers);
+		delete error.extensions.http;
+	}
+	return Response.json({ errors }, {
+		status: status ?? 500,
+		headers
+	});
+}
 const rumble = (rumbleInput) => {
 	if (!rumbleInput.db._.relations) throw new RumbleError(`
 rumble could not find any relations in the provided drizzle instance.
@@ -2551,6 +2803,33 @@ export const r = rumble({
 			types: filteredTypes
 		});
 	});
+	/**
+	* Adapts the configured rumble logger to the logger interface yoga expects,
+	* so yoga's own diagnostics end up in the same structured stream (with the
+	* same `rumble.transport` and trace correlation fields) as rumble's entries.
+	*/
+	const yogaLogging = () => {
+		const log = telemetryLogger(rumbleInput);
+		if (!log) return void 0;
+		const emit = (level) => (...args) => {
+			const messages = args.filter((arg) => typeof arg === "string");
+			const rest = args.filter((arg) => typeof arg !== "string");
+			const errors = rest.filter((entry) => entry instanceof Error);
+			const details = rest.filter((entry) => !(entry instanceof Error));
+			log[level]({
+				[ATTR_TRANSPORT]: "graphql",
+				...traceCorrelationFields(rumbleInput),
+				...errors.length > 0 ? errorsLogField(errors) : {},
+				...details.length > 0 ? { details } : {}
+			}, messages.join(" ") || "yoga diagnostic");
+		};
+		return {
+			debug: emit("debug"),
+			info: emit("info"),
+			warn: emit("warn"),
+			error: emit("error")
+		};
+	};
 	const createYoga$1 = (args) => {
 		const enableApiDocs = args?.enableApiDocs ?? process?.env?.NODE_ENV === "development";
 		return createYoga({
@@ -2558,38 +2837,41 @@ export const r = rumble({
 			graphiql: enableApiDocs,
 			schema: builtSchema(),
 			context,
+			logging: args?.logging ?? yogaLogging() ?? true,
 			plugins: [
 				...args?.plugins ?? [],
 				...enableApiDocs ? [] : [useDisableIntrospection(), EnvelopArmorPlugin(args?.armorConfig)],
-				rumbleInput.otel?.enabled || rumbleInput.logger?.enabled ? { onExecute: ({ setExecuteFn, executeFn }) => {
-					setExecuteFn(buildTracedExecute(executeFn, rumbleInput));
-				} } : false
+				telemetryEnabled(rumbleInput) ? {
+					onExecute: ({ setExecuteFn, executeFn }) => {
+						setExecuteFn(buildTracedExecute(executeFn, rumbleInput, "graphql"));
+					},
+					onSubscribe: ({ setSubscribeFn, subscribeFn }) => {
+						setSubscribeFn(buildTracedSubscribe(subscribeFn, rumbleInput, "graphql"));
+					}
+				} : false
 			].filter(Boolean)
 		});
 	};
 	const createSofa = async (args) => {
 		const { useSofa: useSofaFn } = await import("@m1212e/sofa-api");
 		if (args.openAPI) merge(args.openAPI, sofaOpenAPIWebhookDocs);
-		if (args.errorHandler) {
-			const originalHandler = args.errorHandler;
-			args.errorHandler = (errors) => {
-				const span = trace.getActiveSpan();
-				for (const error of errors) span?.recordException(error);
-				span?.setStatus({ code: SpanStatusCode.ERROR });
-				return originalHandler(errors);
-			};
-		}
+		const userErrorHandler = args.errorHandler;
 		return useSofaFn({
 			...args,
 			schema: builtSchema(),
 			context,
-			execute: buildTracedExecute(args.execute ?? defaultExecute, rumbleInput),
-			subscribe: buildTracedSubscribe(args.subscribe ?? defaultSubscribe, rumbleInput),
+			execute: buildTracedExecute(args.execute ?? defaultExecute, rumbleInput, "rest"),
+			subscribe: buildTracedSubscribe(args.subscribe ?? defaultSubscribe, rumbleInput, "rest"),
 			errorHandler(errors) {
-				const span = trace.getActiveSpan();
-				for (const error of errors) span?.recordException(error);
-				span?.setStatus({ code: SpanStatusCode.ERROR });
-				return new Response(errors[0].message, { status: 500 });
+				if (!errorsAlreadyReported(errors)) {
+					recordSpanErrors(trace.getActiveSpan(), errors);
+					telemetryLogger(rumbleInput)?.error({
+						[ATTR_TRANSPORT]: "rest",
+						...traceCorrelationFields(rumbleInput),
+						...errorsLogField(errors)
+					}, "rest request failed");
+				}
+				return userErrorHandler?.(errors) ?? sofaErrorResponse(errors);
 			}
 		});
 	};
@@ -2598,8 +2880,8 @@ export const r = rumble({
 			...args,
 			schema: builtSchema(),
 			context,
-			execute: buildTracedExecute(args.execute ?? defaultExecute, rumbleInput),
-			subscribe: buildTracedSubscribe(args.subscribe ?? defaultSubscribe, rumbleInput)
+			execute: buildTracedExecute(args.execute ?? defaultExecute, rumbleInput, "ws"),
+			subscribe: buildTracedSubscribe(args.subscribe ?? defaultSubscribe, rumbleInput, "ws")
 		}, ...rest);
 	};
 	return {