Annotate relay error spans with schema fields (pingdotgg#2976)

Author: juliusmarminge

infra/relay/src/agentActivity/AgentActivityRows.ts

@@ -1,7 +1,6 @@
 import type { RelayAgentActivityState } from "@t3tools/contracts/relay";
 import { RelayAgentActivityState as RelayAgentActivityStateSchema } from "@t3tools/contracts/relay";
 import * as Context from "effect/Context";
-import * as Data from "effect/Data";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import { cast } from "effect/Function";
@@ -13,23 +12,32 @@ import { and, desc, eq, isNull } from "drizzle-orm";
 import { RelayDb } from "../db.ts";
 import { relayAgentActivityRows, relayEnvironmentLinks } from "../persistence/schema.ts";
 
-export class AgentActivityRowUpsertPersistenceError extends Data.TaggedError(
+export class AgentActivityRowUpsertPersistenceError extends Schema.TaggedErrorClass<AgentActivityRowUpsertPersistenceError>()(
   "AgentActivityRowUpsertPersistenceError",
-)<{
-  readonly cause: unknown;
-}> {}
+  { cause: Schema.Defect() },
+) {
+  override get message(): string {
+    return "Failed to persist agent activity state";
+  }
+}
 
-export class AgentActivityRowDeletePersistenceError extends Data.TaggedError(
+export class AgentActivityRowDeletePersistenceError extends Schema.TaggedErrorClass<AgentActivityRowDeletePersistenceError>()(
   "AgentActivityRowDeletePersistenceError",
-)<{
-  readonly cause: unknown;
-}> {}
+  { cause: Schema.Defect() },
+) {
+  override get message(): string {
+    return "Failed to delete agent activity state";
+  }
+}
 
-export class AgentActivityRowListPersistenceError extends Data.TaggedError(
+export class AgentActivityRowListPersistenceError extends Schema.TaggedErrorClass<AgentActivityRowListPersistenceError>()(
   "AgentActivityRowListPersistenceError",
-)<{
-  readonly cause: unknown;
-}> {}
+  { cause: Schema.Defect() },
+) {
+  override get message(): string {
+    return "Failed to list agent activity state";
+  }
+}
 
 export interface AgentActivityRowsShape {
   readonly upsert: (input: {

infra/relay/src/agentActivity/ApnsClient.ts

@@ -2,20 +2,13 @@ import * as NodeCrypto from "node:crypto";
 
 import type { RelayAgentActivityAggregateState } from "@t3tools/contracts/relay";
 import * as Context from "effect/Context";
-import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Encoding from "effect/Encoding";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
 import * as Schema from "effect/Schema";
-import {
-  Headers,
-  HttpClient,
-  HttpClientRequest,
-  type HttpBody,
-  type HttpClientError,
-} from "effect/unstable/http";
+import { Headers, HttpClient, HttpClientRequest } from "effect/unstable/http";
 import type { ApnsCredentials } from "../Config.ts";
 import type { ApnsNotificationPayload } from "./apnsDeliveryJobs.ts";
 
@@ -45,18 +38,39 @@ export interface ApnsDeliveryResult {
   readonly apnsId: string | null;
 }
 
-export class ApnsSigningError extends Data.TaggedError("ApnsSigningError")<{
-  readonly phase: "encoding" | "signing";
-  readonly cause: unknown;
-}> {}
+export class ApnsSigningError extends Schema.TaggedErrorClass<ApnsSigningError>()(
+  "ApnsSigningError",
+  {
+    phase: Schema.Literals(["encoding", "signing"]),
+    cause: Schema.Defect(),
+  },
+) {
+  override get message(): string {
+    return `Failed during APNs JWT ${this.phase}`;
+  }
+}
 
-export class ApnsHttpRequestError extends Data.TaggedError("ApnsHttpRequestError")<{
-  readonly cause: HttpClientError.HttpClientError | HttpBody.HttpBodyError;
-}> {}
+export class ApnsHttpRequestError extends Schema.TaggedErrorClass<ApnsHttpRequestError>()(
+  "ApnsHttpRequestError",
+  {
+    cause: Schema.Defect(),
+  },
+) {
+  override get message(): string {
+    return "APNs HTTP request failed";
+  }
+}
 
-export class ApnsInvalidResponseError extends Data.TaggedError("ApnsInvalidResponseError")<{
-  readonly cause: unknown;
-}> {}
+export class ApnsInvalidResponseError extends Schema.TaggedErrorClass<ApnsInvalidResponseError>()(
+  "ApnsInvalidResponseError",
+  {
+    cause: Schema.Defect(),
+  },
+) {
+  override get message(): string {
+    return "APNs returned an invalid response";
+  }
+}
 
 export type ApnsError = ApnsSigningError | ApnsHttpRequestError | ApnsInvalidResponseError;
 

infra/relay/src/agentActivity/ApnsDeliveries.ts

@@ -9,7 +9,6 @@ import {
   RelayAgentAwarenessPreferences as RelayAgentAwarenessPreferencesSchema,
 } from "@t3tools/contracts/relay";
 import * as Context from "effect/Context";
-import * as Data from "effect/Data";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -74,9 +73,16 @@ export type ApnsDeliveryError =
   | LiveActivities.LiveActivityTargetListPersistenceError
   | LiveActivities.LiveActivityDeliveryMarkPersistenceError;
 
-export class ApnsDeliveryJobClaimInFlight extends Data.TaggedError("ApnsDeliveryJobClaimInFlight")<{
-  readonly sourceJobId: string;
-}> {}
+export class ApnsDeliveryJobClaimInFlight extends Schema.TaggedErrorClass<ApnsDeliveryJobClaimInFlight>()(
+  "ApnsDeliveryJobClaimInFlight",
+  {
+    sourceJobId: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `APNs delivery job '${this.sourceJobId}' is already in flight`;
+  }
+}
 
 const decodeRelayAgentActivityAggregateStateJson = Schema.decodeUnknownOption(
   Schema.fromJsonString(RelayAgentActivityAggregateStateSchema),

infra/relay/src/agentActivity/ApnsDeliveryQueue.ts

@@ -2,10 +2,10 @@ import * as Alchemy from "alchemy";
 import * as Cloudflare from "alchemy/Cloudflare";
 import * as Crypto from "effect/Crypto";
 import * as Context from "effect/Context";
-import * as Data from "effect/Data";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
 
 import type { RelayDeliveryResult } from "@t3tools/contracts/relay";
 
@@ -22,9 +22,14 @@ import {
 } from "./apnsDeliveryJobs.ts";
 import * as RelayConfiguration from "../Config.ts";
 
-export class ApnsDeliveryQueueSendError extends Data.TaggedError("ApnsDeliveryQueueSendError")<{
-  readonly cause: unknown;
-}> {}
+export class ApnsDeliveryQueueSendError extends Schema.TaggedErrorClass<ApnsDeliveryQueueSendError>()(
+  "ApnsDeliveryQueueSendError",
+  { cause: Schema.Defect() },
+) {
+  override get message(): string {
+    return "Failed to enqueue APNs delivery";
+  }
+}
 
 export type ApnsDeliveryQueueError = ApnsDeliveryQueueSendError;
 

infra/relay/src/agentActivity/DeliveryAttempts.ts

@@ -1,20 +1,23 @@
 import * as Context from "effect/Context";
-import * as Data from "effect/Data";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import { and, eq, isNull } from "drizzle-orm";
 import * as Crypto from "effect/Crypto";
+import * as Schema from "effect/Schema";
 
 import { RelayDb } from "../db.ts";
 import { relayDeliveryAttempts } from "../persistence/schema.ts";
 
-export class DeliveryAttemptRecordPersistenceError extends Data.TaggedError(
+export class DeliveryAttemptRecordPersistenceError extends Schema.TaggedErrorClass<DeliveryAttemptRecordPersistenceError>()(
   "DeliveryAttemptRecordPersistenceError",
-)<{
-  readonly cause: unknown;
-}> {}
+  { cause: Schema.Defect() },
+) {
+  override get message(): string {
+    return "Failed to persist APNs delivery attempt";
+  }
+}
 
 export interface DeliveryAttemptInput {
   readonly userId: string | null;

infra/relay/src/agentActivity/Devices.ts

@@ -3,31 +3,42 @@ import type {
   RelayDeviceRegistrationRequest,
 } from "@t3tools/contracts/relay";
 import * as Context from "effect/Context";
-import * as Data from "effect/Data";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
 import { and, eq } from "drizzle-orm";
 import { sql } from "drizzle-orm";
 
 import { RelayDb } from "../db.ts";
 import { relayLiveActivities, relayMobileDevices } from "../persistence/schema.ts";
 
-export class DeviceRegistrationPersistenceError extends Data.TaggedError(
+export class DeviceRegistrationPersistenceError extends Schema.TaggedErrorClass<DeviceRegistrationPersistenceError>()(
   "DeviceRegistrationPersistenceError",
-)<{
-  readonly cause: unknown;
-}> {}
+  { cause: Schema.Defect() },
+) {
+  override get message(): string {
+    return "Failed to persist mobile device registration";
+  }
+}
 
-export class DeviceUnregistrationPersistenceError extends Data.TaggedError(
+export class DeviceUnregistrationPersistenceError extends Schema.TaggedErrorClass<DeviceUnregistrationPersistenceError>()(
   "DeviceUnregistrationPersistenceError",
-)<{
-  readonly cause: unknown;
-}> {}
+  { cause: Schema.Defect() },
+) {
+  override get message(): string {
+    return "Failed to unregister mobile device";
+  }
+}
 
-export class DeviceListPersistenceError extends Data.TaggedError("DeviceListPersistenceError")<{
-  readonly cause: unknown;
-}> {}
+export class DeviceListPersistenceError extends Schema.TaggedErrorClass<DeviceListPersistenceError>()(
+  "DeviceListPersistenceError",
+  { cause: Schema.Defect() },
+) {
+  override get message(): string {
+    return "Failed to list mobile devices";
+  }
+}
 
 export interface DevicesShape {
   readonly register: (input: {

infra/relay/src/agentActivity/LiveActivities.ts

@@ -5,7 +5,6 @@ import type {
 } from "@t3tools/contracts/relay";
 import { RelayAgentActivityAggregateState as RelayAgentActivityAggregateStateSchema } from "@t3tools/contracts/relay";
 import * as Context from "effect/Context";
-import * as Data from "effect/Data";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import { cast } from "effect/Function";
@@ -16,23 +15,32 @@ import { and, eq, sql } from "drizzle-orm";
 import { RelayDb } from "../db.ts";
 import { relayLiveActivities, relayMobileDevices } from "../persistence/schema.ts";
 
-export class LiveActivityRegistrationPersistenceError extends Data.TaggedError(
+export class LiveActivityRegistrationPersistenceError extends Schema.TaggedErrorClass<LiveActivityRegistrationPersistenceError>()(
   "LiveActivityRegistrationPersistenceError",
-)<{
-  readonly cause: unknown;
-}> {}
+  { cause: Schema.Defect() },
+) {
+  override get message(): string {
+    return "Failed to persist Live Activity registration";
+  }
+}
 
-export class LiveActivityTargetListPersistenceError extends Data.TaggedError(
+export class LiveActivityTargetListPersistenceError extends Schema.TaggedErrorClass<LiveActivityTargetListPersistenceError>()(
   "LiveActivityTargetListPersistenceError",
-)<{
-  readonly cause: unknown;
-}> {}
+  { cause: Schema.Defect() },
+) {
+  override get message(): string {
+    return "Failed to list Live Activity delivery targets";
+  }
+}
 
-export class LiveActivityDeliveryMarkPersistenceError extends Data.TaggedError(
+export class LiveActivityDeliveryMarkPersistenceError extends Schema.TaggedErrorClass<LiveActivityDeliveryMarkPersistenceError>()(
   "LiveActivityDeliveryMarkPersistenceError",
-)<{
-  readonly cause: unknown;
-}> {}
+  { cause: Schema.Defect() },
+) {
+  override get message(): string {
+    return "Failed to persist Live Activity delivery state";
+  }
+}
 
 export interface DeviceRow {
   readonly user_id: string;

infra/relay/src/agentActivity/apnsDeliveryJobs.ts

@@ -2,7 +2,6 @@ import * as NodeCrypto from "node:crypto";
 
 import { RelayAgentActivityAggregateState, type RelayDeliveryKind } from "@t3tools/contracts/relay";
 import { stableStringify } from "@t3tools/shared/relaySigning";
-import * as Data from "effect/Data";
 import * as DateTime from "effect/DateTime";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
@@ -50,13 +49,23 @@ export const SignedApnsDeliveryJob = Schema.Struct({
 });
 export type SignedApnsDeliveryJob = typeof SignedApnsDeliveryJob.Type;
 
-export class ApnsDeliveryJobInvalid extends Data.TaggedError("ApnsDeliveryJobInvalid")<{
-  readonly message: string;
-}> {}
-
-export class ApnsDeliveryJobExpired extends Data.TaggedError("ApnsDeliveryJobExpired")<{
-  readonly expiresAt: string;
-}> {}
+export class ApnsDeliveryJobInvalid extends Schema.TaggedErrorClass<ApnsDeliveryJobInvalid>()(
+  "ApnsDeliveryJobInvalid",
+  {
+    message: Schema.String,
+  },
+) {}
+
+export class ApnsDeliveryJobExpired extends Schema.TaggedErrorClass<ApnsDeliveryJobExpired>()(
+  "ApnsDeliveryJobExpired",
+  {
+    expiresAt: Schema.String,
+  },
+) {
+  override get message(): string {
+    return `APNs delivery job expired at ${this.expiresAt}`;
+  }
+}
 
 export type ApnsDeliveryJobVerificationError = ApnsDeliveryJobInvalid | ApnsDeliveryJobExpired;
 

infra/relay/src/auth/DpopProofs.ts

@@ -1,20 +1,25 @@
 import * as Context from "effect/Context";
-import * as Data from "effect/Data";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
 import * as HttpApiError from "effect/unstable/httpapi/HttpApiError";
 import { lt } from "drizzle-orm";
 
 import { verifyDpopProof } from "@t3tools/shared/dpop";
 import { RelayDb } from "../db.ts";
 import { relayDpopProofs } from "../persistence/schema.ts";
 
-export class DpopProofReplayPersistenceError extends Data.TaggedError(
+export class DpopProofReplayPersistenceError extends Schema.TaggedErrorClass<DpopProofReplayPersistenceError>()(
   "DpopProofReplayPersistenceError",
-)<{
-  readonly cause: unknown;
-}> {}
+  {
+    cause: Schema.Defect(),
+  },
+) {
+  override get message(): string {
+    return "Failed to persist DPoP proof replay state";
+  }
+}
 
 export interface DpopProofReplayShape {
   readonly verifyAndConsume: (input: {