@fedify/fedify 2.3.0-dev.994 → 2.3.0-pr.809.37

package/dist/federation/send.test.mjs

@@ -1,19 +1,21 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as esm_default } from "../esm-DVILvP5e.mjs";
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import "../std__assert-CRDpx_HF.mjs";
-import { n as assertFalse, t as assertRejects } from "../assert_rejects-B-qJtC9Z.mjs";
-import { t as assertInstanceOf } from "../assert_instance_of-C4Ri6VuN.mjs";
-import { t as assertNotEquals } from "../assert_not_equals--wG9hV7u.mjs";
-import { t as assert } from "../assert-DikXweDx.mjs";
-import { l as verifyRequest } from "../http-CSlLA54v.mjs";
+import { t as esm_default } from "../esm-vrlUxr60.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import "../std__assert-BBjXFNOb.mjs";
+import { n as assertGreaterOrEqual, r as assertFalse, t as assertRejects } from "../assert_rejects-DN60FHPX.mjs";
+import { t as assertInstanceOf } from "../assert_instance_of-DBC5X09g.mjs";
+import { t as assertNotEquals } from "../assert_not_equals-DkVK8oqV.mjs";
+import { t as assert } from "../assert-OguE97r2.mjs";
+import { l as verifyRequest } from "../http-CO59u1Yk.mjs";
 import { i as rsaPrivateKey2, n as ed25519PrivateKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DGu1NFwu.mjs";
-import { t as doesActorOwnKey } from "../owner-C-tqfvxn.mjs";
-import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "../send-05pJLcb6.mjs";
-import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
+import { t as doesActorOwnKey } from "../owner-B4LgOmzV.mjs";
+import { n as extractInboxes, r as sendActivity, t as SendActivityError } from "../send-ByK1Q7DK.mjs";
 import { Activity, Application, Endpoints, Group, Person, Service } from "@fedify/vocab";
+import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
+import { FetchError } from "@fedify/vocab-runtime";
+import { AggregationTemporality, InMemoryMetricExporter, MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
 //#region src/federation/send.test.ts
 test("extractInboxes()", () => {
 	const recipients = [
@@ -185,6 +187,7 @@ test("sendActivity()", async (t) => {
 	});
 	esm_default.post("https://example.com/inbox2", {
 		status: 500,
+		headers: { "Retry-After": "120" },
 		body: "something went wrong"
 	});
 	await t.step("failure", async () => {
@@ -227,8 +230,39 @@ test("sendActivity()", async (t) => {
 			assertEquals(e.statusCode, 500);
 			assertEquals(e.inbox, new URL("https://example.com/inbox2"));
 			assertEquals(e.responseBody, "something went wrong");
+			assertEquals(e.responseHeaders.get("Retry-After"), "120");
 		}
 	});
+	await t.step("signed challenge retry transport errors throw FetchError", async () => {
+		const activity = {
+			"@context": "https://www.w3.org/ns/activitystreams",
+			"type": "Create",
+			"id": "https://example.com/activity",
+			"actor": "https://example.com/person"
+		};
+		const failure = /* @__PURE__ */ new TypeError("challenge retry connection reset");
+		let requestCount = 0;
+		esm_default.post("https://example.com/inbox-challenge-reset", () => {
+			requestCount++;
+			if (requestCount === 1) return new Response("Unauthorized", {
+				status: 401,
+				headers: { "Accept-Signature": "sig1=(\"@method\" \"@target-uri\" \"@authority\" \"content-digest\");created;nonce=\"retry-nonce\"" }
+			});
+			throw failure;
+		});
+		const error = await assertRejects(() => sendActivity({
+			activity,
+			activityId: "https://example.com/activity",
+			keys: [{
+				privateKey: rsaPrivateKey2,
+				keyId: rsaPublicKey2.id
+			}],
+			inbox: new URL("https://example.com/inbox-challenge-reset")
+		}), FetchError, "challenge retry connection reset");
+		assertEquals(error.url.href, "https://example.com/inbox-challenge-reset");
+		assertEquals(error.cause, failure);
+		assertEquals(requestCount, 2);
+	});
 	esm_default.post("https://example.com/inbox-gone", {
 		status: 410,
 		body: "Gone"
@@ -407,13 +441,117 @@ test("sendActivity() records OpenTelemetry span events", async (t) => {
 		assert(event.attributes != null);
 		assertEquals(event.attributes["activitypub.inbox.url"], "https://example.com/inbox");
 		assertEquals(event.attributes["activitypub.activity.id"], "https://example.com/activity");
-		assert(typeof event.attributes["activitypub.activity.json"] === "string");
-		const recordedActivity = JSON.parse(event.attributes["activitypub.activity.json"]);
-		assertEquals(recordedActivity.id, "https://example.com/activity");
-		assertEquals(recordedActivity.type, "Create");
+		assertEquals(event.attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+		assertEquals(event.attributes["activitypub.actor.id"], "https://example.com/person");
+		assertEquals(event.attributes["activitypub.activity.json"], void 0);
 		exporter.clear();
 		esm_default.hardReset();
 	});
 });
+test("sendActivity() records OpenTelemetry delivery metrics", async (t) => {
+	const [meterProvider, recorder] = createTestMeterProvider();
+	esm_default.spyGlobal();
+	await t.step("successful send", async () => {
+		esm_default.post("https://metrics.example:8443/inbox/path?x=1", { status: 202 });
+		await sendActivity({
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				id: "https://example.com/activity",
+				actor: "https://example.com/person"
+			},
+			activityId: "https://example.com/activity",
+			activityType: "https://www.w3.org/ns/activitystreams#Create",
+			keys: [],
+			inbox: new URL("https://metrics.example:8443/inbox/path?x=1"),
+			meterProvider
+		});
+		const sent = recorder.getMeasurements("activitypub.delivery.sent");
+		assertEquals(sent.length, 1);
+		assertEquals(sent[0].type, "counter");
+		assertEquals(sent[0].value, 1);
+		assertEquals(sent[0].attributes["activitypub.remote.host"], "metrics.example:8443");
+		assertEquals(sent[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+		assertEquals(sent[0].attributes["activitypub.delivery.success"], true);
+		const durations = recorder.getMeasurements("activitypub.delivery.duration");
+		assertEquals(durations.length, 1);
+		assertEquals(durations[0].type, "histogram");
+		assertGreaterOrEqual(durations[0].value, 0);
+		assertEquals(durations[0].attributes["activitypub.remote.host"], "metrics.example:8443");
+		assertEquals(durations[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
+		assertEquals(durations[0].attributes["activitypub.delivery.success"], true);
+		recorder.clear();
+		esm_default.hardReset();
+	});
+	await t.step("failed HTTP response", async () => {
+		esm_default.spyGlobal();
+		esm_default.post("https://metrics.example/inbox", {
+			status: 500,
+			body: "failed"
+		});
+		const activity = {
+			"@context": "https://www.w3.org/ns/activitystreams",
+			type: "Follow",
+			id: "https://example.com/follow",
+			actor: "https://example.com/person"
+		};
+		await assertRejects(() => sendActivity({
+			activity,
+			activityId: "https://example.com/follow",
+			activityType: "https://www.w3.org/ns/activitystreams#Follow",
+			keys: [],
+			inbox: new URL("https://metrics.example/inbox"),
+			meterProvider
+		}), SendActivityError);
+		const sent = recorder.getMeasurements("activitypub.delivery.sent");
+		assertEquals(sent.length, 1);
+		assertEquals(sent[0].attributes["activitypub.delivery.success"], false);
+		assertEquals(sent[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Follow");
+		assertEquals(sent[0].attributes["activitypub.remote.host"], "metrics.example");
+		const durations = recorder.getMeasurements("activitypub.delivery.duration");
+		assertEquals(durations.length, 1);
+		assertGreaterOrEqual(durations[0].value, 0);
+		assertEquals(durations[0].attributes["activitypub.remote.host"], "metrics.example");
+		assertEquals(durations[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Follow");
+		assertEquals(durations[0].attributes["activitypub.delivery.success"], false);
+		recorder.clear();
+		esm_default.hardReset();
+	});
+});
+test("sendActivity() exports delivery metrics through OpenTelemetry SDK", async () => {
+	const exporter = new InMemoryMetricExporter(AggregationTemporality.CUMULATIVE);
+	const meterProvider = new MeterProvider({ readers: [new PeriodicExportingMetricReader({
+		exporter,
+		exportIntervalMillis: 6e4
+	})] });
+	esm_default.spyGlobal();
+	esm_default.post("https://sdk-metrics.example/inbox", { status: 202 });
+	try {
+		await sendActivity({
+			activity: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				id: "https://example.com/activity",
+				actor: "https://example.com/person"
+			},
+			activityId: "https://example.com/activity",
+			activityType: "https://www.w3.org/ns/activitystreams#Create",
+			keys: [],
+			inbox: new URL("https://sdk-metrics.example/inbox"),
+			meterProvider
+		});
+		await meterProvider.forceFlush();
+		const sent = exporter.getMetrics().flatMap((resourceMetrics) => resourceMetrics.scopeMetrics).flatMap((scopeMetrics) => scopeMetrics.metrics).find((metric) => metric.descriptor.name === "activitypub.delivery.sent");
+		assert(sent != null);
+		assertEquals(sent.dataPoints.length, 1);
+		assertEquals(sent.dataPoints[0].attributes["activitypub.remote.host"], "sdk-metrics.example");
+	} finally {
+		try {
+			await meterProvider.shutdown();
+		} finally {
+			esm_default.hardReset();
+		}
+	}
+});
 //#endregion
 export {};

package/dist/federation/temporal.test.d.mts

@@ -0,0 +1,2 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";

package/dist/federation/temporal.test.mjs

@@ -0,0 +1,71 @@
+import "@js-temporal/polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import "../std__assert-BBjXFNOb.mjs";
+import { r as assertFalse } from "../assert_rejects-DN60FHPX.mjs";
+import { t as assert } from "../assert-OguE97r2.mjs";
+import { t as hasMalformedKnownTemporalLiteral } from "../temporal-LpjyAjKb.mjs";
+import { test } from "@fedify/fixture";
+//#region src/federation/temporal.test.ts
+test("hasMalformedKnownTemporalLiteral() detects expanded proof timestamps", async () => {
+	assert(await hasMalformedKnownTemporalLiteral({
+		"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"],
+		id: "https://example.com/activities/invalid-proof-created",
+		type: "Create",
+		actor: "https://example.com/person2",
+		object: {
+			id: "https://example.com/notes/invalid-proof-created",
+			type: "Note",
+			attributedTo: "https://example.com/person2",
+			content: "Hello, world!"
+		},
+		proof: {
+			type: "DataIntegrityProof",
+			cryptosuite: "eddsa-jcs-2022",
+			verificationMethod: "https://example.com/person2#main-key",
+			proofPurpose: "assertionMethod",
+			created: { "@value": "not-a-date" },
+			proofValue: "zLaewdp4H9kqtwyrLatK4cjY5oRHwVcw4gibPSUDYDMhi4M49v8pcYk3ZB6D69dNpAPbUmY8ocuJ3m9KhKJEEg7z"
+		}
+	}, void 0));
+});
+test("hasMalformedKnownTemporalLiteral() follows aliases in nested objects", async () => {
+	assert(await hasMalformedKnownTemporalLiteral({
+		"@context": ["https://www.w3.org/ns/activitystreams", { publishedAt: "as:published" }],
+		id: "https://example.com/activities/invalid-nested-published",
+		type: "Create",
+		actor: "https://example.com/person2",
+		object: {
+			id: "https://example.com/notes/invalid-nested-published",
+			type: "Note",
+			attributedTo: "https://example.com/person2",
+			content: "Hello, world!"
+		},
+		audience: {
+			type: "Note",
+			publishedAt: { "@value": "not-a-date" }
+		}
+	}, void 0));
+});
+test("hasMalformedKnownTemporalLiteral() does not over-classify ignored as:closed values", async () => {
+	assertFalse(await hasMalformedKnownTemporalLiteral({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Question",
+		closed: "not-a-date"
+	}, void 0));
+});
+test("hasMalformedKnownTemporalLiteral() detects date-like invalid as:closed values", async () => {
+	assert(await hasMalformedKnownTemporalLiteral({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Question",
+		closed: "2024-02-31T00:00:00Z"
+	}, void 0));
+});
+test("hasMalformedKnownTemporalLiteral() ignores custom-typed as:closed values", async () => {
+	assertFalse(await hasMalformedKnownTemporalLiteral({ "https://www.w3.org/ns/activitystreams#closed": [{
+		"@value": "2024-02-31T00:00:00Z",
+		"@type": "https://example.com/ns#customDateTime"
+	}] }, void 0));
+});
+//#endregion
+export {};

package/dist/federation/webfinger.test.mjs

@@ -1,13 +1,14 @@
 import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { r as createRequestContext } from "../context-Dk_tacqz.mjs";
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import "../std__assert-CRDpx_HF.mjs";
+import { r as createRequestContext } from "../context-DVoTs_wM.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import "../std__assert-BBjXFNOb.mjs";
+import { t as assertNotEquals } from "../assert_not_equals-DkVK8oqV.mjs";
 import { t as MemoryKvStore } from "../kv-rV3vodCc.mjs";
-import { o as createFederation, s as handleWebFinger } from "../middleware-K1g6bEkV.mjs";
-import { test } from "@fedify/fixture";
+import { o as createFederation, s as handleWebFinger } from "../middleware-Cg4EyWsq.mjs";
 import { Image, Link, Person, Tombstone } from "@fedify/vocab";
+import { createTestMeterProvider, test } from "@fedify/fixture";
 //#region src/federation/webfinger.test.ts
 test("handleWebFinger()", async (t) => {
 	const url = new URL("https://example.com/.well-known/webfinger");
@@ -532,5 +533,149 @@ test("handleWebFinger()", async (t) => {
 		});
 	});
 });
+test("handleWebFinger() records webfinger.handle counter and duration", async (t) => {
+	const url = new URL("https://example.com/.well-known/webfinger");
+	const actorDispatcher = (ctx, identifier) => {
+		if (identifier === "gone") return new Tombstone({ id: ctx.getActorUri(identifier) });
+		if (identifier !== "someone") return null;
+		return new Person({
+			id: ctx.getActorUri(identifier),
+			preferredUsername: "someone"
+		});
+	};
+	const onNotFound = () => new Response("Not found", { status: 404 });
+	function createContext(u) {
+		return createRequestContext({
+			federation: createFederation({ kv: new MemoryKvStore() }),
+			url: u,
+			data: void 0,
+			getActorUri(identifier) {
+				return new URL(`${u.origin}/users/${identifier}`);
+			},
+			async getActor(handle) {
+				const actor = await actorDispatcher(this, handle);
+				return actor instanceof Tombstone ? null : actor;
+			},
+			parseUri(uri) {
+				if (uri == null) return null;
+				if (uri.protocol === "acct:") return null;
+				if (!uri.pathname.startsWith("/users/")) return null;
+				return {
+					type: "actor",
+					identifier: uri.pathname.split("/").pop()
+				};
+			}
+		});
+	}
+	await t.step("records result=resolved for a 200 response", async () => {
+		const u = new URL(url);
+		u.searchParams.set("resource", "acct:someone@example.com");
+		const context = createContext(u);
+		const [meterProvider, recorder] = createTestMeterProvider();
+		assertEquals((await handleWebFinger(context.request, {
+			context,
+			actorDispatcher,
+			onNotFound,
+			meterProvider
+		})).status, 200);
+		const counter = recorder.getMeasurement("webfinger.handle");
+		assertNotEquals(counter, void 0);
+		assertEquals(counter?.type, "counter");
+		assertEquals(counter?.value, 1);
+		assertEquals(counter?.attributes["webfinger.handle.result"], "resolved");
+		assertEquals(counter?.attributes["webfinger.resource.scheme"], "acct");
+		assertEquals(counter?.attributes["http.response.status_code"], 200);
+		const duration = recorder.getMeasurement("webfinger.handle.duration");
+		assertNotEquals(duration, void 0);
+		assertEquals(duration?.type, "histogram");
+		assertEquals(duration?.attributes["webfinger.handle.result"], "resolved");
+	});
+	await t.step("records result=invalid for a 400 response", async () => {
+		const context = createContext(new URL(url));
+		const [meterProvider, recorder] = createTestMeterProvider();
+		assertEquals((await handleWebFinger(context.request, {
+			context,
+			actorDispatcher,
+			onNotFound,
+			meterProvider
+		})).status, 400);
+		const counter = recorder.getMeasurement("webfinger.handle");
+		assertEquals(counter?.attributes["webfinger.handle.result"], "invalid");
+		assertEquals(counter?.attributes["http.response.status_code"], 400);
+		assertEquals("webfinger.resource.scheme" in (counter?.attributes ?? {}), false, "missing resource has no scheme attribute");
+	});
+	await t.step("records result=not_found for a 404 response", async () => {
+		const u = new URL(url);
+		u.searchParams.set("resource", "acct:absent@example.com");
+		const context = createContext(u);
+		const [meterProvider, recorder] = createTestMeterProvider();
+		assertEquals((await handleWebFinger(context.request, {
+			context,
+			actorDispatcher,
+			onNotFound,
+			meterProvider
+		})).status, 404);
+		const counter = recorder.getMeasurement("webfinger.handle");
+		assertEquals(counter?.attributes["webfinger.handle.result"], "not_found");
+		assertEquals(counter?.attributes["http.response.status_code"], 404);
+		assertEquals(counter?.attributes["webfinger.resource.scheme"], "acct");
+	});
+	await t.step("records result=tombstoned for a 410 response", async () => {
+		const u = new URL(url);
+		u.searchParams.set("resource", "acct:gone@example.com");
+		const context = createContext(u);
+		const [meterProvider, recorder] = createTestMeterProvider();
+		assertEquals((await handleWebFinger(context.request, {
+			context,
+			actorDispatcher,
+			onNotFound,
+			meterProvider
+		})).status, 410);
+		const counter = recorder.getMeasurement("webfinger.handle");
+		assertEquals(counter?.attributes["webfinger.handle.result"], "tombstoned");
+		assertEquals(counter?.attributes["http.response.status_code"], 410);
+	});
+	await t.step("records result=not_found when onNotFound returns 200", async () => {
+		const u = new URL(url);
+		u.searchParams.set("resource", "acct:absent@example.com");
+		const context = createContext(u);
+		const [meterProvider, recorder] = createTestMeterProvider();
+		assertEquals((await handleWebFinger(context.request, {
+			context,
+			actorDispatcher,
+			onNotFound: () => new Response("custom fallback", { status: 200 }),
+			meterProvider
+		})).status, 200);
+		const counter = recorder.getMeasurement("webfinger.handle");
+		assertEquals(counter?.attributes["webfinger.handle.result"], "not_found");
+		assertEquals(counter?.attributes["http.response.status_code"], 200);
+	});
+	await t.step("buckets unknown resource schemes as 'other' to keep metric cardinality bounded", async () => {
+		const u = new URL(url);
+		u.searchParams.set("resource", "ssh:nobody@example.com");
+		const context = createContext(u);
+		const [meterProvider, recorder] = createTestMeterProvider();
+		await handleWebFinger(context.request, {
+			context,
+			actorDispatcher,
+			onNotFound,
+			meterProvider
+		});
+		assertEquals(recorder.getMeasurement("webfinger.handle")?.attributes["webfinger.resource.scheme"], "other");
+	});
+	await t.step("omits measurements when no meterProvider is provided", async () => {
+		const u = new URL(url);
+		u.searchParams.set("resource", "acct:someone@example.com");
+		const context = createContext(u);
+		const [_unused, recorder] = createTestMeterProvider();
+		await handleWebFinger(context.request, {
+			context,
+			actorDispatcher,
+			onNotFound
+		});
+		assertEquals(recorder.getMeasurements("webfinger.handle").length, 0);
+		assertEquals(recorder.getMeasurements("webfinger.handle.duration").length, 0);
+	});
+});
 //#endregion
 export {};