@fedify/fedify 2.3.0-dev.1114 → 2.3.0-dev.1131

package/dist/{metrics-ek3ilf6c.mjs → metrics-BTOMkW8C.mjs}

@@ -1,8 +1,9 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-CF3jMgip.mjs";
+import { n as version, t as name } from "./deno--CS-SBS9.mjs";
 import { metrics } from "@opentelemetry/api";
+import { FetchError } from "@fedify/vocab-runtime";
 //#region src/federation/metrics.ts
 var FederationMetrics = class {
 	deliverySent;
@@ -20,6 +21,14 @@ var FederationMetrics = class {
 	queueTaskFailed;
 	queueTaskDuration;
 	queueTaskInFlight;
+	fanoutRecipients;
+	inboxActivity;
+	outboxActivity;
+	keyLookup;
+	keyLookupDuration;
+	documentFetch;
+	documentFetchDuration;
+	documentCache;
 	constructor(meterProvider) {
 		const meter = meterProvider.getMeter(name, version);
 		this.deliverySent = meter.createCounter("activitypub.delivery.sent", {
@@ -114,6 +123,70 @@ var FederationMetrics = class {
 			description: "Queue tasks currently being processed in this Fedify process.",
 			unit: "{task}"
 		});
+		this.fanoutRecipients = meter.createHistogram("activitypub.fanout.recipients", {
+			description: "Number of recipient inboxes produced by an ActivityPub fanout task.",
+			unit: "{recipient}"
+		});
+		this.inboxActivity = meter.createCounter("activitypub.inbox.activity", {
+			description: "ActivityPub activities observed at the inbox lifecycle level: queued, processed, retried, rejected, or abandoned.",
+			unit: "{activity}"
+		});
+		this.outboxActivity = meter.createCounter("activitypub.outbox.activity", {
+			description: "ActivityPub activities observed at the outbox lifecycle level: queued, retried, or abandoned.  Per-recipient delivery counters live on `activitypub.delivery.*`.",
+			unit: "{activity}"
+		});
+		this.keyLookup = meter.createCounter("activitypub.key.lookup", {
+			description: "Public-key lookup attempts performed by Fedify, including both cache hits and remote fetches.",
+			unit: "{lookup}"
+		});
+		this.keyLookupDuration = meter.createHistogram("activitypub.key.lookup.duration", {
+			description: "Duration of public-key lookups performed by Fedify, including any remote fetch.",
+			unit: "ms",
+			advice: { explicitBucketBoundaries: [
+				5,
+				10,
+				25,
+				50,
+				75,
+				100,
+				250,
+				500,
+				750,
+				1e3,
+				2500,
+				5e3,
+				7500,
+				1e4
+			] }
+		});
+		this.documentFetch = meter.createCounter("activitypub.document.fetch", {
+			description: "Remote JSON-LD document loader invocations made by Fedify-wrapped loaders.",
+			unit: "{fetch}"
+		});
+		this.documentFetchDuration = meter.createHistogram("activitypub.document.fetch.duration", {
+			description: "Duration of remote JSON-LD document loader invocations made by Fedify-wrapped loaders.",
+			unit: "ms",
+			advice: { explicitBucketBoundaries: [
+				5,
+				10,
+				25,
+				50,
+				75,
+				100,
+				250,
+				500,
+				750,
+				1e3,
+				2500,
+				5e3,
+				7500,
+				1e4
+			] }
+		});
+		this.documentCache = meter.createCounter("activitypub.document.cache", {
+			description: "KV-backed document loader cache lookups, with `hit` or `miss` classification.",
+			unit: "{lookup}"
+		});
 	}
 	recordDelivery(inbox, durationMs, success, activityType) {
 		const deliveryAttributes = {
@@ -186,7 +259,53 @@ var FederationMetrics = class {
 		else if (result === "failed") this.queueTaskFailed.add(1, attributes);
 		this.queueTaskDuration.record(durationMs, attributes);
 	}
+	recordFanoutRecipients(recipientCount, activityType) {
+		const attributes = {};
+		if (activityType != null) attributes["activitypub.activity.type"] = activityType;
+		this.fanoutRecipients.record(recipientCount, attributes);
+	}
+	recordInboxActivity(result, activityType) {
+		this.inboxActivity.add(1, buildActivityLifecycleAttributes(result, activityType));
+	}
+	recordOutboxActivity(result, activityType) {
+		this.outboxActivity.add(1, buildActivityLifecycleAttributes(result, activityType));
+	}
+	recordKeyLookup(attrs) {
+		const attributes = {
+			"activitypub.lookup.kind": "public_key",
+			"activitypub.lookup.result": attrs.result,
+			"activitypub.cache.enabled": attrs.cacheEnabled
+		};
+		if (attrs.remoteUrl != null) attributes["activitypub.remote.host"] = getRemoteHost(attrs.remoteUrl);
+		if (attrs.statusCode != null) attributes["http.response.status_code"] = attrs.statusCode;
+		this.keyLookup.add(1, attributes);
+		this.keyLookupDuration.record(attrs.durationMs, attributes);
+	}
+	recordDocumentFetch(attrs) {
+		const attributes = {
+			"activitypub.lookup.kind": attrs.kind,
+			"activitypub.lookup.result": attrs.result
+		};
+		if (attrs.remoteUrl != null) attributes["activitypub.remote.host"] = getRemoteHost(attrs.remoteUrl);
+		if (attrs.cacheEnabled != null) attributes["activitypub.cache.enabled"] = attrs.cacheEnabled;
+		if (attrs.statusCode != null) attributes["http.response.status_code"] = attrs.statusCode;
+		this.documentFetch.add(1, attributes);
+		this.documentFetchDuration.record(attrs.durationMs, attributes);
+	}
+	recordDocumentCache(attrs) {
+		const attributes = {
+			"activitypub.lookup.kind": attrs.kind,
+			"activitypub.lookup.result": attrs.result
+		};
+		if (attrs.remoteUrl != null) attributes["activitypub.remote.host"] = getRemoteHost(attrs.remoteUrl);
+		this.documentCache.add(1, attributes);
+	}
 };
+function buildActivityLifecycleAttributes(result, activityType) {
+	const attributes = { "activitypub.processing.result": result };
+	if (activityType != null) attributes["activitypub.activity.type"] = activityType;
+	return attributes;
+}
 function buildQueueTaskAttributes(common) {
 	const attributes = { "fedify.queue.role": common.role };
 	const backend = getQueueBackend(common.queue);
@@ -216,20 +335,176 @@ function getQueueBackend(queue) {
 	return name;
 }
 /**
-* Records `fedify.queue.task.enqueued` for an outgoing outbox enqueue.
+* Records `fedify.queue.task.enqueued` for an outgoing outbox enqueue and,
+* for the initial attempt, also records
+* `activitypub.outbox.activity{queued}`.
 *
 * Both `Context.sendActivity()` and `OutboxContext.forwardActivity()` enqueue
 * outbox messages with the same metric attributes (role, queue, activity
 * type, attempt), so they share this helper rather than each defining a local
-* closure.
+* closure.  Retry enqueues (attempt > 0) intentionally do not record a
+* second `activitypub.outbox.activity{queued}`; retries are reported as
+* `result=retried` from the retry-scheduling site, which has the failure
+* context.
 * @since 2.3.0
 */
 function recordOutboxEnqueue(meterProvider, outboxQueue, message) {
-	getFederationMetrics(meterProvider).recordQueueTaskEnqueued({
+	const metrics = getFederationMetrics(meterProvider);
+	metrics.recordQueueTaskEnqueued({
 		role: "outbox",
 		queue: outboxQueue,
 		activityType: message.activityType
 	}, message.attempt);
+	if (message.attempt === 0) metrics.recordOutboxActivity("queued", message.activityType);
+}
+/**
+* Records `activitypub.fanout.recipients` with the number of recipient
+* inboxes a single fanout produced.  The histogram is unitless count
+* (one measurement per fanout enqueue).  Recipient URLs are deliberately
+* not recorded; only the activity type, when known.
+* @since 2.3.0
+*/
+function recordFanoutRecipients(meterProvider, recipientCount, activityType) {
+	getFederationMetrics(meterProvider).recordFanoutRecipients(recipientCount, activityType);
+}
+/**
+* Records one `activitypub.inbox.activity` measurement.  The
+* `activitypub.processing.result` attribute is always present;
+* `activitypub.activity.type` is recorded only when Fedify already knows
+* the activity type.
+* @since 2.3.0
+*/
+function recordInboxActivity(meterProvider, result, activityType) {
+	getFederationMetrics(meterProvider).recordInboxActivity(result, activityType);
+}
+/**
+* Records one `activitypub.outbox.activity` measurement.  The
+* `activitypub.processing.result` attribute is always present;
+* `activitypub.activity.type` is recorded only when Fedify already knows
+* the activity type (it is always known for outbox lifecycle events).
+* @since 2.3.0
+*/
+function recordOutboxActivity(meterProvider, result, activityType) {
+	getFederationMetrics(meterProvider).recordOutboxActivity(result, activityType);
+}
+/**
+* Records one measurement on `activitypub.key.lookup` (counter) and
+* `activitypub.key.lookup.duration` (histogram) for a public-key lookup.
+*
+* `activitypub.lookup.kind` is always recorded as `public_key`; the result
+* classification, remote host, HTTP status code (when an HTTP response was
+* received), and `activitypub.cache.enabled` are recorded as attributes on
+* both measurements.  Full key URLs and key IDs are deliberately omitted to
+* keep cardinality bounded.
+* @since 2.3.0
+*/
+function recordKeyLookup(meterProvider, attrs) {
+	getFederationMetrics(meterProvider).recordKeyLookup(attrs);
+}
+/**
+* Records one measurement each on `activitypub.document.fetch` (counter)
+* and `activitypub.document.fetch.duration` (histogram) for one remote
+* JSON-LD document loader invocation, with bounded
+* `activitypub.lookup.kind` and `activitypub.lookup.result` attributes
+* plus the optional remote-host, cache-enabled, and HTTP status-code
+* attributes.  Counter and histogram are always recorded together so
+* aggregate rate and latency views stay in sync.
+* @since 2.3.0
+*/
+function recordDocumentFetch(meterProvider, attrs) {
+	getFederationMetrics(meterProvider).recordDocumentFetch(attrs);
+}
+/**
+* Records one `activitypub.document.cache` measurement, classifying the
+* lookup as `hit` (the cache returned an entry) or `miss` (the cache was
+* consulted and returned nothing, prompting a delegate fetch).
+* @since 2.3.0
+*/
+function recordDocumentCache(meterProvider, attrs) {
+	getFederationMetrics(meterProvider).recordDocumentCache(attrs);
+}
+/**
+* Classifies a thrown value from a key or document fetch into the bounded
+* {@link LookupResult} taxonomy and, when an HTTP response was received,
+* surfaces its status code.
+*
+*  -  `FetchError` with a `Response` whose status is `404` or `410`:
+*     `result=not_found` and the response status code.
+*  -  `FetchError` with any other `Response`: `result=error` and the
+*     response status code.
+*  -  `FetchError` without a `Response`: `result=network_error`.
+*  -  An `AbortError` (typically from a cancelled fetch): `result=network_error`.
+*  -  A bare `TypeError` (the shape native `fetch()` raises on DNS, connect,
+*     and TLS failures before any response is observed):
+*     `result=network_error`.
+*  -  Any other value: `result=error`.
+* @since 2.3.0
+*/
+function classifyFetchError(error) {
+	if (error instanceof FetchError) {
+		if (error.response != null) {
+			const status = error.response.status;
+			return {
+				result: status === 404 || status === 410 ? "not_found" : "error",
+				statusCode: status
+			};
+		}
+		return { result: "network_error" };
+	}
+	if (isAbortError(error)) return { result: "network_error" };
+	if (error instanceof TypeError) return { result: "network_error" };
+	return { result: "error" };
+}
+/**
+* Wraps a {@link DocumentLoader} so each invocation records one
+* measurement on `activitypub.document.fetch` (counter) and one on
+* `activitypub.document.fetch.duration` (histogram), classifying the
+* outcome via {@link classifyFetchError} when the wrapped loader throws
+* and as `fetched` on success.  The wrapper rethrows whatever the
+* wrapped loader throws so caller behavior is unchanged.
+*
+* The wrapper records the hostname of the requested URL on
+* `activitypub.remote.host` when the URL parses; full URLs, paths, and
+* query strings are deliberately excluded to keep cardinality bounded.
+* HTTP status codes are recorded only when the failure carries a
+* `Response` (currently, when the wrapped loader throws a
+* {@link FetchError} with a non-`null` `response`).
+* @since 2.3.0
+*/
+function instrumentDocumentLoader(loader, options) {
+	const meterProvider = options.meterProvider;
+	if (meterProvider == null) return loader;
+	return async (url, opts) => {
+		const start = performance.now();
+		let remoteUrl;
+		try {
+			remoteUrl = new URL(url);
+		} catch {
+			remoteUrl = void 0;
+		}
+		try {
+			const result = await loader(url, opts);
+			recordDocumentFetch(meterProvider, {
+				durationMs: getDurationMs(start),
+				kind: options.kind,
+				result: "fetched",
+				remoteUrl,
+				cacheEnabled: options.cacheEnabled
+			});
+			return result;
+		} catch (error) {
+			const classified = classifyFetchError(error);
+			recordDocumentFetch(meterProvider, {
+				durationMs: getDurationMs(start),
+				kind: options.kind,
+				result: classified.result,
+				remoteUrl,
+				cacheEnabled: options.cacheEnabled,
+				statusCode: classified.statusCode
+			});
+			throw error;
+		}
+	};
 }
 /**
 * Times an awaited public key fetch and records exactly one
@@ -311,4 +586,4 @@ function getDurationMs(start) {
 	return Math.max(0, performance.now() - start);
 }
 //#endregion
-export { measureSignatureKeyFetch as a, isAbortError as i, getFederationMetrics as n, recordOutboxEnqueue as o, getRemoteHost as r, getDurationMs as t };
+export { instrumentDocumentLoader as a, recordDocumentCache as c, recordInboxActivity as d, recordKeyLookup as f, getRemoteHost as i, recordDocumentFetch as l, recordOutboxEnqueue as m, getDurationMs as n, isAbortError as o, recordOutboxActivity as p, getFederationMetrics as r, measureSignatureKeyFetch as s, classifyFetchError as t, recordFanoutRecipients as u };

package/dist/{middleware-EqTYPG4F.cjs → middleware-B2rtdpFV.cjs}

@@ -2,10 +2,10 @@ const { Temporal } = require("@js-temporal/polyfill");
 const { URLPattern } = require("urlpattern-polyfill");
 const require_chunk = require("./chunk-DDcVe30Y.cjs");
 const require_transformers = require("./transformers-NeAONrAq.cjs");
-const require_http = require("./http-CKCgOPkX.cjs");
-const require_proof = require("./proof-DIoqrKnX.cjs");
+const require_http = require("./http-CJfvRL7D.cjs");
+const require_proof = require("./proof-B1_u25UV.cjs");
 const require_types = require("./types-KC4QAoxe.cjs");
-const require_kv_cache = require("./kv-cache-DY-XWOqM.cjs");
+const require_kv_cache = require("./kv-cache-L0SMQkcd.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_vocab = require("@fedify/vocab");
 let _opentelemetry_api = require("@opentelemetry/api");
@@ -817,6 +817,7 @@ async function routeActivity({ context: ctx, json, activity, recipient, inboxLis
 				code: _opentelemetry_api.SpanStatusCode.UNSET,
 				message: `Activity ${activity.id?.href} has already been processed.`
 			});
+			require_http.recordInboxActivity(meterProvider, "rejected", (0, _fedify_vocab.getTypeId)(activity).href);
 			return "alreadyProcessed";
 		}
 	}
@@ -826,6 +827,7 @@ async function routeActivity({ context: ctx, json, activity, recipient, inboxLis
 			code: _opentelemetry_api.SpanStatusCode.ERROR,
 			message: "Missing actor."
 		});
+		require_http.recordInboxActivity(meterProvider, "rejected", (0, _fedify_vocab.getTypeId)(activity).href);
 		return "missingActor";
 	}
 	span.setAttribute("activitypub.actor.id", activity.actorId.href);
@@ -861,6 +863,7 @@ async function routeActivity({ context: ctx, json, activity, recipient, inboxLis
 			queue,
 			activityType: (0, _fedify_vocab.getTypeId)(activity).href
 		}, 0);
+		require_http.recordInboxActivity(meterProvider, "queued", (0, _fedify_vocab.getTypeId)(activity).href);
 		logger.info("Activity {activityId} is enqueued.", {
 			activityId: activity.id?.href,
 			activity: json,
@@ -880,6 +883,7 @@ async function routeActivity({ context: ctx, json, activity, recipient, inboxLis
 				code: _opentelemetry_api.SpanStatusCode.UNSET,
 				message: `Unsupported activity type: ${(0, _fedify_vocab.getTypeId)(activity).href}`
 			});
+			require_http.recordInboxActivity(meterProvider, "rejected", (0, _fedify_vocab.getTypeId)(activity).href);
 			span.end();
 			return "unsupportedActivity";
 		}
@@ -889,7 +893,7 @@ async function routeActivity({ context: ctx, json, activity, recipient, inboxLis
 			const activityType = (0, _fedify_vocab.getTypeId)(activity).href;
 			const started = performance.now();
 			try {
-				await listener(inboxContextFactory(recipient, json, activity?.id?.href, activityType), activity);
+				await listener(inboxContextFactory(recipient, json, activity.id?.href, activityType), activity);
 			} finally {
 				require_http.getFederationMetrics(meterProvider).recordInboxProcessingDuration(activityType, require_http.getDurationMs(started));
 			}
@@ -914,9 +918,11 @@ async function routeActivity({ context: ctx, json, activity, recipient, inboxLis
 				code: _opentelemetry_api.SpanStatusCode.ERROR,
 				message: String(error)
 			});
+			require_http.recordInboxActivity(meterProvider, "rejected", (0, _fedify_vocab.getTypeId)(activity).href);
 			span.end();
 			return "error";
 		}
+		require_http.recordInboxActivity(meterProvider, "processed", (0, _fedify_vocab.getTypeId)(activity).href);
 		if (cacheKey != null) await kv.set(cacheKey, true, { ttl: Temporal.Duration.from({ days: 1 }) });
 		logger.info("Activity {activityId} has been processed.", {
 			activityId: activity.id?.href,
@@ -2907,23 +2913,50 @@ var FederationImpl = class extends FederationBuilderImpl {
 		}
 		const { allowPrivateAddress, userAgent } = options;
 		this.allowPrivateAddress = allowPrivateAddress ?? false;
-		this.documentLoaderFactory = options.documentLoaderFactory ?? ((opts) => {
-			return require_kv_cache.kvCache({
-				loader: (0, _fedify_vocab_runtime.getDocumentLoader)({
-					allowPrivateAddress: opts?.allowPrivateAddress ?? allowPrivateAddress,
-					userAgent: opts?.userAgent ?? userAgent
-				}),
-				kv: options.kv,
-				prefix: this.kvPrefixes.remoteDocument
-			});
+		const userDocumentLoaderFactory = options.documentLoaderFactory;
+		const userContextLoaderFactory = options.contextLoaderFactory;
+		const userAuthFactory = options.authenticatedDocumentLoaderFactory;
+		const builtinDocumentLoaderFactory = (opts) => require_kv_cache.kvCache({
+			loader: (0, _fedify_vocab_runtime.getDocumentLoader)({
+				allowPrivateAddress: opts?.allowPrivateAddress ?? allowPrivateAddress,
+				userAgent: opts?.userAgent ?? userAgent
+			}),
+			kv: options.kv,
+			prefix: this.kvPrefixes.remoteDocument,
+			meterProvider: this._meterProvider,
+			kind: "object"
+		});
+		const builtinContextLoaderFactory = (opts) => require_kv_cache.kvCache({
+			loader: (0, _fedify_vocab_runtime.getDocumentLoader)({
+				allowPrivateAddress: opts?.allowPrivateAddress ?? allowPrivateAddress,
+				userAgent: opts?.userAgent ?? userAgent
+			}),
+			kv: options.kv,
+			prefix: this.kvPrefixes.remoteDocument,
+			meterProvider: this._meterProvider,
+			kind: "context"
+		});
+		this.documentLoaderFactory = (opts) => require_http.instrumentDocumentLoader((userDocumentLoaderFactory ?? builtinDocumentLoaderFactory)(opts), {
+			meterProvider: this._meterProvider,
+			kind: "object",
+			cacheEnabled: userDocumentLoaderFactory == null ? true : void 0
+		});
+		const resolvedContextLoaderFactory = userContextLoaderFactory ?? userDocumentLoaderFactory ?? builtinContextLoaderFactory;
+		this.contextLoaderFactory = (opts) => require_http.instrumentDocumentLoader(resolvedContextLoaderFactory(opts), {
+			meterProvider: this._meterProvider,
+			kind: "context",
+			cacheEnabled: userContextLoaderFactory == null && userDocumentLoaderFactory == null ? true : void 0
 		});
-		this.contextLoaderFactory = options.contextLoaderFactory ?? this.documentLoaderFactory;
-		this.authenticatedDocumentLoaderFactory = options.authenticatedDocumentLoaderFactory ?? ((identity) => require_kv_cache.getAuthenticatedDocumentLoader(identity, {
-			allowPrivateAddress,
-			userAgent,
+		this.authenticatedDocumentLoaderFactory = (identity, factoryOpts) => require_http.instrumentDocumentLoader(userAuthFactory != null ? userAuthFactory(identity, factoryOpts) : require_kv_cache.getAuthenticatedDocumentLoader(identity, {
+			allowPrivateAddress: factoryOpts?.allowPrivateAddress ?? allowPrivateAddress,
+			userAgent: factoryOpts?.userAgent ?? userAgent,
 			specDeterminer: new KvSpecDeterminer(this.kv, this.kvPrefixes.httpMessageSignaturesSpec, options.firstKnock),
 			tracerProvider: this.tracerProvider
-		}));
+		}), {
+			meterProvider: this._meterProvider,
+			kind: "object",
+			cacheEnabled: userAuthFactory == null ? false : void 0
+		});
 		this.userAgent = userAgent;
 		this.onOutboxError = options.onOutboxError;
 		this.permanentFailureStatusCodes = options.permanentFailureStatusCodes ?? [404, 410];
@@ -3233,6 +3266,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 						});
 					}
 				}
+				require_http.recordOutboxActivity(this.meterProvider, "abandoned", message.activityType);
 				return;
 			}
 			if (this.outboxQueue?.nativeRetrial) {
@@ -3263,11 +3297,15 @@ var FederationImpl = class extends FederationBuilderImpl {
 						queue: outboxQueue,
 						activityType: retryMessage.activityType
 					}, retryMessage.attempt);
+					require_http.recordOutboxActivity(this.meterProvider, "retried", retryMessage.activityType);
 				}
-			} else logger.error("Failed to send activity {activityId} to {inbox} after {attempt} attempts; giving up:\n{error}", {
-				...logData,
-				error
-			});
+			} else {
+				logger.error("Failed to send activity {activityId} to {inbox} after {attempt} attempts; giving up:\n{error}", {
+					...logData,
+					error
+				});
+				require_http.recordOutboxActivity(this.meterProvider, "abandoned", message.activityType);
+			}
 			return;
 		}
 		logger.info("Successfully sent activity {activityId} to {inbox}.", { ...logData });
@@ -3302,6 +3340,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 					activity: message.activity,
 					recipient: message.identifier
 				});
+				require_http.recordInboxActivity(this.meterProvider, "rejected", activityType);
 				return;
 			}
 		}
@@ -3318,6 +3357,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 					code: _opentelemetry_api.SpanStatusCode.ERROR,
 					message: `Unsupported activity type: ${activityType}`
 				});
+				require_http.recordInboxActivity(this.meterProvider, "rejected", activityType);
 				span.end();
 				return;
 			}
@@ -3330,6 +3370,7 @@ var FederationImpl = class extends FederationBuilderImpl {
 				} finally {
 					require_http.getFederationMetrics(this.meterProvider).recordInboxProcessingDuration(activityType, require_http.getDurationMs(started));
 				}
+				require_http.recordInboxActivity(this.meterProvider, "processed", activityType);
 			} catch (error) {
 				try {
 					await this.inboxErrorHandler?.(context, error);
@@ -3380,13 +3421,17 @@ var FederationImpl = class extends FederationBuilderImpl {
 							queue: inboxQueue,
 							activityType
 						}, retryMessage.attempt);
+						require_http.recordInboxActivity(this.meterProvider, "retried", activityType);
 					}
-				} else logger.error("Failed to process the incoming activity {activityId} after {trial} attempts; giving up:\n{error}", {
-					error,
-					activityId: activity.id?.href,
-					activity: message.activity,
-					recipient: message.identifier
-				});
+				} else {
+					logger.error("Failed to process the incoming activity {activityId} after {trial} attempts; giving up:\n{error}", {
+						error,
+						activityId: activity.id?.href,
+						activity: message.activity,
+						recipient: message.identifier
+					});
+					require_http.recordInboxActivity(this.meterProvider, "abandoned", activityType);
+				}
 				span.setStatus({
 					code: _opentelemetry_api.SpanStatusCode.ERROR,
 					message: String(error)
@@ -4226,6 +4271,7 @@ var ContextImpl = class ContextImpl {
 			contextLoader: options.contextLoader ?? this.contextLoader,
 			userAgent: options.userAgent ?? this.federation.userAgent,
 			tracerProvider: options.tracerProvider ?? this.tracerProvider,
+			meterProvider: options.meterProvider ?? this.meterProvider,
 			allowPrivateAddress: this.federation.allowPrivateAddress
 		});
 	}
@@ -4413,6 +4459,7 @@ var ContextImpl = class ContextImpl {
 			queue: this.federation.fanoutQueue,
 			activityType: message.activityType
 		}, 0);
+		require_http.recordFanoutRecipients(this.federation.meterProvider, globalThis.Object.keys(message.inboxes).length, message.activityType);
 		return true;
 	}
 	async *getFollowers(identifier) {