@fedify/fedify 1.3.0-dev.571 → 1.3.0-dev.576

package/esm/federation/middleware.js

@@ -1,6 +1,6 @@
 import * as dntShim from "../_dnt.shims.js";
 import { getLogger, withContext } from "@logtape/logtape";
-import { SpanKind, SpanStatusCode, trace, } from "@opentelemetry/api";
+import { context, propagation, SpanKind, SpanStatusCode, trace, } from "@opentelemetry/api";
 import { ATTR_HTTP_REQUEST_HEADER, ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_HEADER, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_URL_FULL, } from "@opentelemetry/semantic-conventions";
 import metadata from "../deno.js";
 import { handleNodeInfo, handleNodeInfoJrd } from "../nodeinfo/handler.js";
@@ -157,16 +157,60 @@ export class FederationImpl {
         await Promise.all(promises);
     }
     #listenQueue(ctxData, message) {
+        const tracer = this.#getTracer();
+        const extractedContext = propagation.extract(context.active(), message.traceContext);
         return withContext({ messageId: message.id }, async () => {
             if (message.type === "outbox") {
-                await this.#listenOutboxMessage(ctxData, message);
+                await tracer.startActiveSpan("activitypub.outbox", {
+                    kind: SpanKind.CONSUMER,
+                    attributes: {
+                        "activitypub.activity.type": message.activityType,
+                        "activitypub.activity.retries": message.attempt,
+                    },
+                }, extractedContext, async (span) => {
+                    if (message.activityId != null) {
+                        span.setAttribute("activitypub.activity.id", message.activityId);
+                    }
+                    try {
+                        await this.#listenOutboxMessage(ctxData, message, span);
+                    }
+                    catch (e) {
+                        span.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: String(e),
+                        });
+                        throw e;
+                    }
+                    finally {
+                        span.end();
+                    }
+                });
             }
             else if (message.type === "inbox") {
-                await this.#listenInboxMessage(ctxData, message);
+                await tracer.startActiveSpan("activitypub.inbox", {
+                    kind: SpanKind.CONSUMER,
+                    attributes: {
+                        "activitypub.shared_inbox": message.identifier == null,
+                    },
+                }, extractedContext, async (span) => {
+                    try {
+                        await this.#listenInboxMessage(ctxData, message, span);
+                    }
+                    catch (e) {
+                        span.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: String(e),
+                        });
+                        throw e;
+                    }
+                    finally {
+                        span.end();
+                    }
+                });
             }
         });
     }
-    async #listenOutboxMessage(_, message) {
+    async #listenOutboxMessage(_, message, span) {
         const logger = getLogger(["fedify", "federation", "outbox"]);
         const logData = {
             keyIds: message.keys.map((pair) => pair.keyId),
@@ -194,12 +238,15 @@ export class FederationImpl {
                 keys,
                 activity: message.activity,
                 activityId: message.activityId,
+                activityType: message.activityType,
                 inbox: new URL(message.inbox),
+                sharedInbox: message.sharedInbox,
                 headers: new Headers(message.headers),
                 tracerProvider: this.tracerProvider,
             });
         }
         catch (error) {
+            span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
             const activity = await Activity.fromJsonLd(message.activity, {
                 contextLoader: this.contextLoader,
                 documentLoader: rsaKeyPair == null
@@ -220,7 +267,7 @@ export class FederationImpl {
             if (delay != null) {
                 logger.error("Failed to send activity {activityId} to {inbox} (attempt " +
                     "#{attempt}); retry...:\n{error}", { ...logData, error });
-                this.outboxQueue?.enqueue({
+                await this.outboxQueue?.enqueue({
                     ...message,
                     attempt: message.attempt + 1,
                 }, {
@@ -237,7 +284,7 @@ export class FederationImpl {
         }
         logger.info("Successfully sent activity {activityId} to {inbox}.", { ...logData });
     }
-    async #listenInboxMessage(ctxData, message) {
+    async #listenInboxMessage(ctxData, message, span) {
         const logger = getLogger(["fedify", "federation", "inbox"]);
         const baseUrl = new URL(message.baseUrl);
         let context = this.#createContext(baseUrl, ctxData);
@@ -260,6 +307,10 @@ export class FederationImpl {
             }
         }
         const activity = await Activity.fromJsonLd(message.activity, context);
+        span.setAttribute("activitypub.activity.type", getTypeId(activity).href);
+        if (activity.id != null) {
+            span.setAttribute("activitypub.activity.id", activity.id.href);
+        }
         const cacheKey = activity.id == null ? null : [
             ...this.kvPrefixes.activityIdempotence,
             activity.id.href,
@@ -275,74 +326,89 @@ export class FederationImpl {
                 return;
             }
         }
-        const listener = this.inboxListeners?.dispatch(activity);
-        if (listener == null) {
-            logger.error("Unsupported activity type:\n{activity}", {
-                activityId: activity.id?.href,
-                activity: message.activity,
-                recipient: message.identifier,
-                trial: message.attempt,
-            });
-            return;
-        }
-        try {
-            await listener(context.toInboxContext(message.identifier, message.activity), activity);
-        }
-        catch (error) {
-            try {
-                await this.inboxErrorHandler?.(context, error);
-            }
-            catch (error) {
-                logger.error("An unexpected error occurred in inbox error handler:\n{error}", {
-                    error,
-                    trial: message.attempt,
+        await this.#getTracer().startActiveSpan("activitypub.dispatch_inbox_listener", { kind: SpanKind.INTERNAL }, async (span) => {
+            const dispatched = this.inboxListeners?.dispatchWithClass(activity);
+            if (dispatched == null) {
+                logger.error("Unsupported activity type:\n{activity}", {
                     activityId: activity.id?.href,
                     activity: message.activity,
                     recipient: message.identifier,
+                    trial: message.attempt,
                 });
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: `Unsupported activity type: ${getTypeId(activity).href}`,
+                });
+                span.end();
+                return;
             }
-            const delay = this.inboxRetryPolicy({
-                elapsedTime: dntShim.Temporal.Instant.from(message.started).until(dntShim.Temporal.Now.instant()),
-                attempts: message.attempt,
-            });
-            if (delay != null) {
-                logger.error("Failed to process the incoming activity {activityId} (attempt " +
-                    "#{attempt}); retry...:\n{error}", {
-                    error,
-                    attempt: message.attempt,
-                    activityId: activity.id?.href,
-                    activity: message.activity,
-                    recipient: message.identifier,
+            const { class: cls, listener } = dispatched;
+            span.updateName(`activitypub.dispatch_inbox_listener ${cls.name}`);
+            try {
+                await listener(context.toInboxContext(message.identifier, message.activity, activity.id?.href, getTypeId(activity).href), activity);
+            }
+            catch (error) {
+                try {
+                    await this.inboxErrorHandler?.(context, error);
+                }
+                catch (error) {
+                    logger.error("An unexpected error occurred in inbox error handler:\n{error}", {
+                        error,
+                        trial: message.attempt,
+                        activityId: activity.id?.href,
+                        activity: message.activity,
+                        recipient: message.identifier,
+                    });
+                }
+                const delay = this.inboxRetryPolicy({
+                    elapsedTime: dntShim.Temporal.Instant.from(message.started).until(dntShim.Temporal.Now.instant()),
+                    attempts: message.attempt,
                 });
-                this.inboxQueue?.enqueue({
-                    ...message,
-                    attempt: message.attempt + 1,
-                }, {
-                    delay: dntShim.Temporal.Duration.compare(delay, { seconds: 0 }) < 0
-                        ? dntShim.Temporal.Duration.from({ seconds: 0 })
-                        : delay,
+                if (delay != null) {
+                    logger.error("Failed to process the incoming activity {activityId} (attempt " +
+                        "#{attempt}); retry...:\n{error}", {
+                        error,
+                        attempt: message.attempt,
+                        activityId: activity.id?.href,
+                        activity: message.activity,
+                        recipient: message.identifier,
+                    });
+                    await this.inboxQueue?.enqueue({
+                        ...message,
+                        attempt: message.attempt + 1,
+                    }, {
+                        delay: dntShim.Temporal.Duration.compare(delay, { seconds: 0 }) < 0
+                            ? dntShim.Temporal.Duration.from({ seconds: 0 })
+                            : delay,
+                    });
+                }
+                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,
+                    });
+                }
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: String(error),
                 });
+                span.end();
+                return;
             }
-            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,
+            if (cacheKey != null) {
+                await this.kv.set(cacheKey, true, {
+                    ttl: dntShim.Temporal.Duration.from({ days: 1 }),
                 });
             }
-            return;
-        }
-        if (cacheKey != null) {
-            await this.kv.set(cacheKey, true, {
-                ttl: dntShim.Temporal.Duration.from({ days: 1 }),
+            logger.info("Activity {activityId} has been processed.", {
+                activityId: activity.id?.href,
+                activity: message.activity,
+                recipient: message.identifier,
             });
-        }
-        logger.info("Activity {activityId} has been processed.", {
-            activityId: activity.id?.href,
-            activity: message.activity,
-            recipient: message.identifier,
+            span.end();
         });
     }
     startQueue(contextData, options = {}) {
@@ -960,7 +1026,7 @@ export class FederationImpl {
         };
         return setters;
     }
-    async sendActivity(keys, recipients, activity, options) {
+    async sendActivity(keys, recipients, activity, options, span) {
         const logger = getLogger(["fedify", "federation", "outbox"]);
         const { preferSharedInbox, immediate, excludeBaseUris, collectionSync, contextData, } = options;
         if (keys.length < 1) {
@@ -974,9 +1040,9 @@ export class FederationImpl {
             throw new TypeError("The activity to send must have at least one actor property.");
         }
         if (activity.id == null) {
-            activity = activity.clone({
-                id: new URL(`urn:uuid:${dntShim.crypto.randomUUID()}`),
-            });
+            const id = new URL(`urn:uuid:${dntShim.crypto.randomUUID()}`);
+            activity = activity.clone({ id });
+            span?.setAttribute("activitypub.activity.id", id.href);
         }
         const inboxes = extractInboxes({
             recipients: Array.isArray(recipients) ? recipients : [recipients],
@@ -1061,9 +1127,11 @@ export class FederationImpl {
                     keys,
                     activity: jsonLd,
                     activityId: activity.id?.href,
+                    activityType: getTypeId(activity).href,
                     inbox: new URL(inbox),
+                    sharedInbox: inboxes[inbox].sharedInbox,
                     headers: collectionSync == null ? undefined : new Headers({
-                        "Collection-Synchronization": await buildCollectionSynchronizationHeader(collectionSync, inboxes[inbox]),
+                        "Collection-Synchronization": await buildCollectionSynchronizationHeader(collectionSync, inboxes[inbox].actorIds),
                     }),
                     tracerProvider: this.tracerProvider,
                 }));
@@ -1079,6 +1147,9 @@ export class FederationImpl {
         }
         if (!this.manuallyStartQueue)
             this.#startQueue(contextData);
+        const carrier = {};
+        propagation.inject(context.active(), carrier);
+        const promises = [];
         for (const inbox in inboxes) {
             const message = {
                 type: "outbox",
@@ -1086,14 +1157,28 @@ export class FederationImpl {
                 keys: keyJwkPairs,
                 activity: jsonLd,
                 activityId: activity.id?.href,
+                activityType: getTypeId(activity).href,
                 inbox,
+                sharedInbox: inboxes[inbox].sharedInbox,
                 started: new Date().toISOString(),
                 attempt: 0,
                 headers: collectionSync == null ? {} : {
-                    "Collection-Synchronization": await buildCollectionSynchronizationHeader(collectionSync, inboxes[inbox]),
+                    "Collection-Synchronization": await buildCollectionSynchronizationHeader(collectionSync, inboxes[inbox].actorIds),
                 },
+                traceContext: carrier,
             };
-            this.outboxQueue.enqueue(message);
+            promises.push(this.outboxQueue.enqueue(message));
+        }
+        const results = await Promise.allSettled(promises);
+        const errors = results
+            .filter((r) => r.status === "rejected")
+            .map((r) => r.reason);
+        if (errors.length > 0) {
+            logger.error("Failed to enqueue activity {activityId} to send later: {errors}", { activityId: activity.id.href, errors });
+            if (errors.length > 1) {
+                throw new AggregateError(errors, `Failed to enqueue activity ${activityId} to send later.`);
+            }
+            throw errors[0];
         }
     }
     fetch(request, options) {
@@ -1368,8 +1453,8 @@ export class ContextImpl {
         this.invokedFromActorKeyPairsDispatcher =
             invokedFromActorKeyPairsDispatcher;
     }
-    toInboxContext(recipient, activity) {
-        return new InboxContextImpl(recipient, activity, {
+    toInboxContext(recipient, activity, activityId, activityType) {
+        return new InboxContextImpl(recipient, activity, activityId, activityType, {
             url: this.url,
             federation: this.federation,
             data: this.data,
@@ -1738,7 +1823,36 @@ export class ContextImpl {
             contextLoader: options.contextLoader ?? this.contextLoader,
         });
     }
-    async sendActivity(sender, recipients, activity, options = {}) {
+    sendActivity(sender, recipients, activity, options = {}) {
+        const tracer = this.tracerProvider.getTracer(metadata.name, metadata.version);
+        return tracer.startActiveSpan("activitypub.outbox", {
+            kind: this.federation.outboxQueue == null || options.immediate
+                ? SpanKind.CLIENT
+                : SpanKind.PRODUCER,
+            attributes: {
+                "activitypub.activity.type": getTypeId(activity).href,
+                "activitypub.activity.to": activity.toIds.map((to) => to.href),
+                "activitypub.activity.cc": activity.toIds.map((cc) => cc.href),
+                "activitypub.activity.bto": activity.btoIds.map((bto) => bto.href),
+                "activitypub.activity.bcc": activity.toIds.map((bcc) => bcc.href),
+            },
+        }, async (span) => {
+            try {
+                if (activity.id != null) {
+                    span.setAttribute("activitypub.activity.id", activity.id.href);
+                }
+                await this.sendActivityInternal(sender, recipients, activity, options, span);
+            }
+            catch (e) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: String(e) });
+                throw e;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    async sendActivityInternal(sender, recipients, activity, options = {}, span) {
         let keys;
         let identifier = null;
         if ("identifier" in sender || "username" in sender || "handle" in sender) {
@@ -1766,6 +1880,7 @@ export class ContextImpl {
                     identifier = mapped;
                 }
             }
+            span.setAttribute("fedify.actor.identifier", identifier);
             keys = await this.getKeyPairsFromIdentifier(identifier);
             if (keys.length < 1) {
                 throw new Error(`No key pair found for actor ${JSON.stringify(identifier)}.`);
@@ -1805,7 +1920,8 @@ export class ContextImpl {
         else {
             expandedRecipients = [recipients];
         }
-        return await this.federation.sendActivity(keys, expandedRecipients, activity, opts);
+        span.setAttribute("activitypub.inboxes", expandedRecipients.length);
+        return await this.federation.sendActivity(keys, expandedRecipients, activity, opts, span);
     }
     async *getFollowers(identifier) {
         if (this.federation.followersCallbacks == null) {
@@ -1912,12 +2028,39 @@ class RequestContextImpl extends ContextImpl {
 export class InboxContextImpl extends ContextImpl {
     recipient;
     activity;
-    constructor(recipient, activity, options) {
+    activityId;
+    activityType;
+    constructor(recipient, activity, activityId, activityType, options) {
         super(options);
         this.recipient = recipient;
         this.activity = activity;
+        this.activityId = activityId;
+        this.activityType = activityType;
+    }
+    forwardActivity(forwarder, recipients, options) {
+        const tracer = this.tracerProvider.getTracer(metadata.name, metadata.version);
+        return tracer.startActiveSpan("activitypub.outbox", {
+            kind: this.federation.outboxQueue == null || options?.immediate
+                ? SpanKind.CLIENT
+                : SpanKind.PRODUCER,
+            attributes: { "activitypub.activity.type": this.activityType },
+        }, async (span) => {
+            try {
+                if (this.activityId != null) {
+                    span.setAttribute("activitypub.activity.id", this.activityId);
+                }
+                await this.forwardActivityInternal(forwarder, recipients, options);
+            }
+            catch (e) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: String(e) });
+                throw e;
+            }
+            finally {
+                span.end();
+            }
+        });
     }
-    async forwardActivity(forwarder, recipients, options) {
+    async forwardActivityInternal(forwarder, recipients, options) {
         const logger = getLogger(["fedify", "federation", "inbox"]);
         let keys;
         let identifier = null;
@@ -1961,12 +2104,10 @@ export class InboxContextImpl extends ContextImpl {
         else {
             keys = [forwarder];
         }
-        let activityId = undefined;
         if (!hasSignature(this.activity)) {
             let hasProof;
             try {
                 const activity = await Activity.fromJsonLd(this.activity, this);
-                activityId = activity.id?.href;
                 hasProof = await activity.getProof() != null;
             }
             catch {
@@ -1980,15 +2121,6 @@ export class InboxContextImpl extends ContextImpl {
                     "them due to the lack of a signature/proof.");
             }
         }
-        if (activityId == null && typeof this.activity === "object" &&
-            this.activity != null) {
-            activityId =
-                "@id" in this.activity && typeof this.activity["@id"] === "string"
-                    ? this.activity["@id"]
-                    : "id" in this.activity && typeof this.activity.id === "string"
-                        ? this.activity.id
-                        : undefined;
-        }
         if (recipients === "followers") {
             if (identifier == null) {
                 throw new Error('If recipients is "followers", ' +
@@ -2007,7 +2139,7 @@ export class InboxContextImpl extends ContextImpl {
         });
         logger.debug("Forwarding activity {activityId} to inboxes:\n{inboxes}", {
             inboxes: globalThis.Object.keys(inboxes),
-            activityId,
+            activityId: this.activityId,
             activity: this.activity,
         });
         if (options?.immediate || this.federation.outboxQueue == null) {
@@ -2024,33 +2156,52 @@ export class InboxContextImpl extends ContextImpl {
                 promises.push(sendActivity({
                     keys,
                     activity: this.activity,
-                    activityId: activityId,
+                    activityId: this.activityId,
+                    activityType: this.activityType,
                     inbox: new URL(inbox),
+                    sharedInbox: inboxes[inbox].sharedInbox,
                     tracerProvider: this.tracerProvider,
                 }));
             }
             await Promise.all(promises);
             return;
         }
-        logger.debug("Enqueuing activity {activityId} to forward later.", { activityId, activity: this.activity });
+        logger.debug("Enqueuing activity {activityId} to forward later.", { activityId: this.activityId, activity: this.activity });
         const keyJwkPairs = [];
         for (const { keyId, privateKey } of keys) {
             const privateKeyJwk = await exportJwk(privateKey);
             keyJwkPairs.push({ keyId: keyId.href, privateKey: privateKeyJwk });
         }
+        const carrier = {};
+        propagation.inject(context.active(), carrier);
+        const promises = [];
         for (const inbox in inboxes) {
             const message = {
                 type: "outbox",
                 id: dntShim.crypto.randomUUID(),
                 keys: keyJwkPairs,
                 activity: this.activity,
-                activityId,
+                activityId: this.activityId,
+                activityType: this.activityType,
                 inbox,
+                sharedInbox: inboxes[inbox].sharedInbox,
                 started: new Date().toISOString(),
                 attempt: 0,
                 headers: {},
+                traceContext: carrier,
             };
-            this.federation.outboxQueue.enqueue(message);
+            promises.push(this.federation.outboxQueue.enqueue(message));
+        }
+        const results = await Promise.allSettled(promises);
+        const errors = results
+            .filter((r) => r.status === "rejected")
+            .map((r) => r.reason);
+        if (errors.length > 0) {
+            logger.error("Failed to enqueue activity {activityId} to forward later:\n{errors}", { activityId: this.activityId, errors });
+            if (errors.length > 1) {
+                throw new AggregateError(errors, `Failed to enqueue activity ${this.activityId} to forward later.`);
+            }
+            throw errors[0];
         }
     }
 }

package/esm/federation/send.js

@@ -1,4 +1,6 @@
 import { getLogger } from "@logtape/logtape";
+import { SpanKind, SpanStatusCode, trace, } from "@opentelemetry/api";
+import metadata from "../deno.js";
 import { signRequest } from "../sig/http.js";
 /**
  * Extracts the inbox URLs from recipients.
@@ -9,16 +11,22 @@ import { signRequest } from "../sig/http.js";
 export function extractInboxes({ recipients, preferSharedInbox, excludeBaseUris }) {
     const inboxes = {};
     for (const recipient of recipients) {
-        const inbox = preferSharedInbox
-            ? recipient.endpoints?.sharedInbox ?? recipient.inboxId
-            : recipient.inboxId;
+        let inbox;
+        let sharedInbox = false;
+        if (preferSharedInbox && recipient.endpoints?.sharedInbox != null) {
+            inbox = recipient.endpoints.sharedInbox;
+            sharedInbox = true;
+        }
+        else {
+            inbox = recipient.inboxId;
+        }
         if (inbox != null && recipient.id != null) {
             if (excludeBaseUris != null &&
-                excludeBaseUris.some((u) => u.origin == inbox.origin)) {
+                excludeBaseUris.some((u) => u.origin === inbox?.origin)) {
                 continue;
             }
-            inboxes[inbox.href] ??= new Set();
-            inboxes[inbox.href].add(recipient.id.href);
+            inboxes[inbox.href] ??= { actorIds: new Set(), sharedInbox };
+            inboxes[inbox.href].actorIds.add(recipient.id.href);
         }
     }
     return inboxes;
@@ -30,7 +38,34 @@ export function extractInboxes({ recipients, preferSharedInbox, excludeBaseUris
  *                   See also {@link SendActivityParameters}.
  * @throws {Error} If the activity fails to send.
  */
-export async function sendActivity({ activity, activityId, keys, inbox, headers, tracerProvider, }) {
+export function sendActivity(options) {
+    const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
+    const tracer = tracerProvider.getTracer(metadata.name, metadata.version);
+    return tracer.startActiveSpan("activitypub.send_activity", {
+        kind: SpanKind.CLIENT,
+        attributes: {
+            "activitypub.shared_inbox": options.sharedInbox ?? false,
+        },
+    }, async (span) => {
+        if (options.activityId != null) {
+            span.setAttribute("activitypub.activity.id", options.activityId);
+        }
+        if (options.activityType != null) {
+            span.setAttribute("activitypub.activity.type", options.activityType);
+        }
+        try {
+            await sendActivityInternal({ ...options, tracerProvider });
+        }
+        catch (e) {
+            span.setStatus({ code: SpanStatusCode.ERROR, message: String(e) });
+            throw e;
+        }
+        finally {
+            span.end();
+        }
+    });
+}
+async function sendActivityInternal({ activity, activityId, keys, inbox, headers, tracerProvider, }) {
     const logger = getLogger(["fedify", "federation", "outbox"]);
     headers = new Headers(headers);
     headers.set("Content-Type", "application/activity+json");