@fedify/fedify 1.3.0-dev.570 → 1.3.0-dev.575

package/CHANGES.md

@@ -59,6 +59,9 @@ To be released.
 
  -  Added `getTypeId()` function.
 
+ -  `Context.sendActivity()` and `InboxContext.forwardActivity()` methods now
+    reject when they fail to enqueue the task.  [[#192]]
+
  -  Fedify now supports OpenTelemetry for tracing.  [[#170]]
 
      -  Added `Context.tracerProvider` property.
@@ -103,6 +106,7 @@ To be released.
 [#173]: https://github.com/dahlia/fedify/issues/173
 [#183]: https://github.com/dahlia/fedify/pull/183
 [#186]: https://github.com/dahlia/fedify/pull/186
+[#192]: https://github.com/dahlia/fedify/issues/192
 
 
 Version 1.2.8

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "@fedify/fedify",
-    "version": "1.3.0-dev.570+61d94afc",
+    "version": "1.3.0-dev.575+9cfc4531",
     "license": "MIT",
     "exports": {
         ".": "./mod.ts",

package/esm/federation/handler.js

@@ -71,28 +71,12 @@ export async function handleObject(request, { values, context, objectDispatcher,
         },
     });
 }
-export function handleCollection(request, params) {
-    const name = params.name.trim().replace(/\s+/g, "_");
-    const tracerProvider = params.tracerProvider ?? trace.getTracerProvider();
+export async function handleCollection(request, { name, identifier, uriGetter, filter, filterPredicate, context, collectionCallbacks, tracerProvider, onUnauthorized, onNotFound, onNotAcceptable, }) {
+    const spanName = name.trim().replace(/\s+/g, "_");
+    tracerProvider = tracerProvider ?? trace.getTracerProvider();
     const tracer = tracerProvider.getTracer(metadata.name, metadata.version);
     const url = new URL(request.url);
     const cursor = url.searchParams.get("cursor");
-    return tracer.startActiveSpan(cursor == null
-        ? `activitypub.dispatch_collection ${name}`
-        : `activitypub.dispatch_collection_page ${name}`, { kind: SpanKind.SERVER }, async (span) => {
-        try {
-            return await handleCollectionInternal(request, cursor, params, span);
-        }
-        catch (e) {
-            span.setStatus({ code: SpanStatusCode.ERROR, message: String(e) });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
-    });
-}
-async function handleCollectionInternal(request, cursor, { name, identifier, uriGetter, filter, filterPredicate, context, collectionCallbacks, onUnauthorized, onNotFound, onNotAcceptable, }, span) {
     if (collectionCallbacks == null)
         return await onNotFound(request);
     let collection;
@@ -100,21 +84,41 @@ async function handleCollectionInternal(request, cursor, { name, identifier, uri
     if (cursor == null) {
         const firstCursor = await collectionCallbacks.firstCursor?.(context, identifier);
         const totalItems = await collectionCallbacks.counter?.(context, identifier);
-        if (totalItems != null) {
-            span.setAttribute("activitypub.collection.total_items", Number(totalItems));
-        }
         if (firstCursor == null) {
-            const page = await collectionCallbacks.dispatcher(context, identifier, null, filter);
-            if (page == null) {
-                span.setStatus({ code: SpanStatusCode.ERROR });
-                return await onNotFound(request);
-            }
-            const { items } = page;
-            span.setAttribute("fedify.collection.items", items.length);
+            const itemsOrResponse = await tracer.startActiveSpan(`activitypub.dispatch_collection ${spanName}`, {
+                kind: SpanKind.SERVER,
+                attributes: {
+                    "activitypub.collection.id": baseUri.href,
+                    "activitypub.collection.type": OrderedCollection.typeId.href,
+                },
+            }, async (span) => {
+                if (totalItems != null) {
+                    span.setAttribute("activitypub.collection.total_items", Number(totalItems));
+                }
+                try {
+                    const page = await collectionCallbacks.dispatcher(context, identifier, null, filter);
+                    if (page == null) {
+                        span.setStatus({ code: SpanStatusCode.ERROR });
+                        return await onNotFound(request);
+                    }
+                    const { items } = page;
+                    span.setAttribute("fedify.collection.items", items.length);
+                    return items;
+                }
+                catch (e) {
+                    span.setStatus({ code: SpanStatusCode.ERROR, message: String(e) });
+                    throw e;
+                }
+                finally {
+                    span.end();
+                }
+            });
+            if (itemsOrResponse instanceof Response)
+                return itemsOrResponse;
             collection = new OrderedCollection({
                 id: baseUri,
                 totalItems: totalItems == null ? null : Number(totalItems),
-                items: filterCollectionItems(items, name, filterPredicate),
+                items: filterCollectionItems(itemsOrResponse, name, filterPredicate),
             });
         }
         else {
@@ -135,16 +139,36 @@ async function handleCollectionInternal(request, cursor, { name, identifier, uri
         }
     }
     else {
-        span.setAttribute("fedify.collection.cursor", cursor);
         const uri = new URL(baseUri);
         uri.searchParams.set("cursor", cursor);
-        const page = await collectionCallbacks.dispatcher(context, identifier, cursor, filter);
-        if (page == null) {
-            span.setStatus({ code: SpanStatusCode.ERROR });
-            return await onNotFound(request);
-        }
-        const { items, prevCursor, nextCursor } = page;
-        span.setAttribute("fedify.collection.items", items.length);
+        const pageOrResponse = await tracer.startActiveSpan(`activitypub.dispatch_collection_page ${name}`, {
+            kind: SpanKind.SERVER,
+            attributes: {
+                "activitypub.collection.id": uri.href,
+                "activitypub.collection.type": OrderedCollectionPage.typeId.href,
+                "fedify.collection.cursor": cursor,
+            },
+        }, async (span) => {
+            try {
+                const page = await collectionCallbacks.dispatcher(context, identifier, cursor, filter);
+                if (page == null) {
+                    span.setStatus({ code: SpanStatusCode.ERROR });
+                    return await onNotFound(request);
+                }
+                span.setAttribute("fedify.collection.items", page.items.length);
+                return page;
+            }
+            catch (e) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: String(e) });
+                throw e;
+            }
+            finally {
+                span.end();
+            }
+        });
+        if (pageOrResponse instanceof Response)
+            return pageOrResponse;
+        const { items, prevCursor, nextCursor } = pageOrResponse;
         let prev = null;
         if (prevCursor != null) {
             prev = new URL(context.url);
@@ -174,10 +198,6 @@ async function handleCollectionInternal(request, cursor, { name, identifier, uri
             return await onUnauthorized(request);
         }
     }
-    if (collection.id != null) {
-        span.setAttribute("activitypub.collection.id", collection.id.href);
-    }
-    span.setAttribute("activitypub.collection.type", getTypeId(collection).href);
     const jsonLd = await collection.toJsonLd(context);
     return new Response(JSON.stringify(jsonLd), {
         headers: {
@@ -425,7 +445,7 @@ export async function handleInbox(request, { recipient, context, inboxContextFac
         });
     }
     try {
-        await listener(inboxContextFactory(recipient, json), activity);
+        await listener(inboxContextFactory(recipient, json, activity.id?.href, getTypeId(activity).href), activity);
     }
     catch (error) {
         try {

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,9 +157,31 @@ export class FederationImpl {
         await Promise.all(promises);
     }
     #listenQueue(ctxData, message) {
+        const tracer = this.#getTracer();
         return withContext({ messageId: message.id }, async () => {
             if (message.type === "outbox") {
-                await this.#listenOutboxMessage(ctxData, message);
+                const extractedContext = propagation.extract(context.active(), message.traceContext);
+                await tracer.startActiveSpan("activitypub.outbox", {
+                    kind: SpanKind.CONSUMER,
+                    attributes: { "activitypub.activity.type": message.activityType },
+                }, extractedContext, async (span) => {
+                    if (message.activityId != null) {
+                        span.setAttribute("activitypub.activity.id", message.activityId);
+                    }
+                    try {
+                        await this.#listenOutboxMessage(ctxData, message);
+                    }
+                    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);
@@ -194,7 +216,9 @@ 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,
             });
@@ -220,7 +244,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,
                 }, {
@@ -286,7 +310,7 @@ export class FederationImpl {
             return;
         }
         try {
-            await listener(context.toInboxContext(message.identifier, message.activity), activity);
+            await listener(context.toInboxContext(message.identifier, message.activity, activity.id?.href, getTypeId(activity).href), activity);
         }
         catch (error) {
             try {
@@ -314,7 +338,7 @@ export class FederationImpl {
                     activity: message.activity,
                     recipient: message.identifier,
                 });
-                this.inboxQueue?.enqueue({
+                await this.inboxQueue?.enqueue({
                     ...message,
                     attempt: message.attempt + 1,
                 }, {
@@ -960,7 +984,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 +998,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 +1085,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 +1105,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 +1115,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 +1411,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 +1781,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 +1838,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 +1878,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 +1986,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;
     }
-    async forwardActivity(forwarder, recipients, options) {
+    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 forwardActivityInternal(forwarder, recipients, options) {
         const logger = getLogger(["fedify", "federation", "inbox"]);
         let keys;
         let identifier = null;
@@ -1961,12 +2062,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 +2079,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 +2097,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 +2114,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");