feat(blog): wire instrumentation — repo spans + use-case/controller withSpan + logger capture

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

packages/blog/src/infrastructure/repositories/articles.repository.mock.ts

@@ -1,5 +1,11 @@
 import "reflect-metadata";
 import { injectable } from "inversify";
+import {
+  NoopTracer,
+  NoopLogger,
+  type ITracer,
+  type ILogger,
+} from "@repo/core-shared/instrumentation";
 
 import type { IArticlesRepository } from "../../application/repositories/articles.repository.interface";
 import type { Article } from "../../entities/models/article";
@@ -7,13 +13,38 @@ import type { Article } from "../../entities/models/article";
 @injectable()
 export class MockArticlesRepository implements IArticlesRepository {
   private _articles: Article[] = [];
+  private tracer: ITracer;
+  private logger: ILogger;
+
+  constructor(
+    tracer: ITracer = new NoopTracer(),
+    logger: ILogger = new NoopLogger(),
+  ) {
+    this.tracer = tracer;
+    this.logger = logger;
+    void this.logger; // currently unused; reserved for future mock-thrown captures
+  }
 
   async getArticle(id: string): Promise<Article | undefined> {
-    return this._articles.find((a) => a.id === id);
+    return this.tracer.startSpan(
+      { name: "articles.getArticle", op: "repository", attributes: { id } },
+      async (span) => {
+        const found = this._articles.find((a) => a.id === id);
+        span.setAttribute("found", Boolean(found));
+        return found;
+      },
+    );
   }
 
   async getArticleBySlug(slug: string): Promise<Article | undefined> {
-    return this._articles.find((a) => a.slug === slug);
+    return this.tracer.startSpan(
+      { name: "articles.getArticleBySlug", op: "repository", attributes: { slug } },
+      async (span) => {
+        const found = this._articles.find((a) => a.slug === slug);
+        span.setAttribute("found", Boolean(found));
+        return found;
+      },
+    );
   }
 
   async getArticles(options?: {
@@ -22,33 +53,62 @@ export class MockArticlesRepository implements IArticlesRepository {
     limit?: number;
     offset?: number;
   }): Promise<Article[]> {
-    let result = [...this._articles];
-    if (options?.status) {
-      result = result.filter((a) => a.status === options.status);
-    }
-    if (options?.authorId) {
-      result = result.filter((a) => a.authorId === options.authorId);
-    }
-    const offset = options?.offset ?? 0;
-    const limit = options?.limit ?? 50;
-    return result.slice(offset, offset + limit);
+    return this.tracer.startSpan(
+      {
+        name: "articles.getArticles",
+        op: "repository",
+        attributes: {
+          status: options?.status ?? null,
+          authorId: options?.authorId ?? null,
+          limit: options?.limit ?? null,
+          offset: options?.offset ?? null,
+        },
+      },
+      async (span) => {
+        let result = [...this._articles];
+        if (options?.status) {
+          result = result.filter((a) => a.status === options.status);
+        }
+        if (options?.authorId) {
+          result = result.filter((a) => a.authorId === options.authorId);
+        }
+        const offset = options?.offset ?? 0;
+        const limit = options?.limit ?? 50;
+        const sliced = result.slice(offset, offset + limit);
+        span.setAttribute("count", sliced.length);
+        return sliced;
+      },
+    );
   }
 
   async createArticle(input: Article): Promise<Article> {
-    this._articles.push(input);
-    return input;
+    return this.tracer.startSpan(
+      { name: "articles.createArticle", op: "repository", attributes: { slug: input.slug } },
+      async (span) => {
+        this._articles.push(input);
+        span.setAttribute("id", input.id);
+        return input;
+      },
+    );
   }
 
   async updateArticle(
     id: string,
     input: Partial<Article>,
   ): Promise<Article | undefined> {
-    const index = this._articles.findIndex((a) => a.id === id);
-    if (index === -1) return undefined;
-    const current = this._articles[index];
-    if (!current) return undefined;
-    const updated: Article = { ...current, ...input, id: current.id };
-    this._articles[index] = updated;
-    return updated;
+    return this.tracer.startSpan(
+      { name: "articles.updateArticle", op: "repository", attributes: { id } },
+      async (span) => {
+        const idx = this._articles.findIndex((a) => a.id === id);
+        if (idx === -1) {
+          span.setAttribute("found", false);
+          return undefined;
+        }
+        const merged = { ...this._articles[idx]!, ...input, id } as Article;
+        this._articles[idx] = merged;
+        span.setAttribute("found", true);
+        return merged;
+      },
+    );
   }
 }

packages/blog/src/infrastructure/repositories/articles.repository.span.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from "vitest";
+import { RecordingTracer, RecordingLogger } from "@repo/core-testing/instrumentation";
+import { MockArticlesRepository } from "@/infrastructure/repositories/articles.repository.mock";
+
+// Mock repo also wraps in spans (R42); easier to assert without booting Payload.
+describe("MockArticlesRepository emits spans (R42)", () => {
+  it("getArticles emits one span with op='repository'", async () => {
+    const tracer = new RecordingTracer();
+    const logger = new RecordingLogger();
+    const repo = new MockArticlesRepository(tracer, logger);
+    await repo.getArticles({ limit: 10 });
+    expect(tracer.spans).toHaveLength(1);
+    expect(tracer.spans[0]).toMatchObject({
+      name: "articles.getArticles",
+      op: "repository",
+    });
+    expect(tracer.spans[0]!.attributes).toMatchObject({ limit: 10 });
+  });
+
+  it("createArticle emits a span with slug attribute", async () => {
+    const tracer = new RecordingTracer();
+    const repo = new MockArticlesRepository(tracer);
+    await repo.createArticle({
+      id: "a1",
+      title: "T",
+      slug: "t",
+      content: null,
+      status: "draft",
+      authorId: "u1",
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+    expect(tracer.findSpan("articles.createArticle")).toBeDefined();
+    expect(tracer.findSpan("articles.createArticle")!.attributes.slug).toBe("t");
+  });
+
+  it("getArticle records found=false for missing id", async () => {
+    const tracer = new RecordingTracer();
+    const repo = new MockArticlesRepository(tracer);
+    await repo.getArticle("missing");
+    expect(tracer.spans[0]!.attributes.found).toBe(false);
+  });
+});

packages/blog/src/infrastructure/repositories/articles.repository.test.ts

@@ -62,7 +62,10 @@ function buildPayloadStub() {
     findByID: vi.fn(
       async ({ id }: { collection: string; id: string; overrideAccess?: boolean }) => {
         const doc = store.get(String(id));
-        if (!doc) throw new Error(`Not found: ${id}`);
+        if (!doc) {
+          const err = Object.assign(new Error(`Not found: ${id}`), { status: 404 });
+          throw err;
+        }
         return doc;
       },
     ),
@@ -77,7 +80,10 @@ function buildPayloadStub() {
         overrideAccess?: boolean;
       }) => {
         const existing = store.get(String(id));
-        if (!existing) throw new Error(`Not found: ${id}`);
+        if (!existing) {
+          const err = Object.assign(new Error(`Not found: ${id}`), { status: 404 });
+          throw err;
+        }
         const updated = { ...existing, ...data };
         store.set(String(id), updated);
         return updated;

packages/blog/src/infrastructure/repositories/articles.repository.ts

@@ -2,6 +2,12 @@ import "reflect-metadata";
 import { injectable } from "inversify";
 import { getPayload } from "payload";
 import type { SanitizedConfig } from "payload";
+import {
+  NoopTracer,
+  NoopLogger,
+  type ITracer,
+  type ILogger,
+} from "@repo/core-shared/instrumentation";
 
 import type { IArticlesRepository } from "../../application/repositories/articles.repository.interface";
 import type { Article } from "../../entities/models/article";
@@ -36,38 +42,83 @@ function mapDoc(doc: PayloadArticleDoc): Article {
   };
 }
 
+const FEATURE = "blog" as const;
+const REPO = "articles" as const;
+
 @injectable()
 export class ArticlesRepository implements IArticlesRepository {
   private config: SanitizedConfig;
+  private tracer: ITracer;
+  private logger: ILogger;
 
-  constructor(config: SanitizedConfig) {
+  constructor(
+    config: SanitizedConfig,
+    tracer: ITracer = new NoopTracer(),
+    logger: ILogger = new NoopLogger(),
+  ) {
     this.config = config;
+    this.tracer = tracer;
+    this.logger = logger;
   }
 
   async getArticle(id: string): Promise<Article | undefined> {
-    const payload = await getPayload({ config: this.config });
-    try {
-      const doc = await payload.findByID({
-        collection: "articles",
-        id,
-        overrideAccess: true,
-      });
-      return mapDoc(doc as PayloadArticleDoc);
-    } catch {
-      return undefined;
-    }
+    return this.tracer.startSpan(
+      { name: "articles.getArticle", op: "repository", attributes: { id } },
+      async (span) => {
+        try {
+          const payload = await getPayload({ config: this.config });
+          const doc = await payload.findByID({
+            collection: "articles",
+            id,
+            overrideAccess: true,
+          });
+          span.setAttribute("found", true);
+          return mapDoc(doc as PayloadArticleDoc);
+        } catch (err) {
+          // Payload throws on not-found; treat as undefined per existing semantics
+          if (
+            err &&
+            typeof err === "object" &&
+            "status" in err &&
+            (err as { status: unknown }).status === 404
+          ) {
+            span.setAttribute("found", false);
+            return undefined;
+          }
+          this.logger.captureException(err, {
+            tags: { feature: FEATURE, repo: REPO, method: "getArticle" },
+          });
+          span.setStatus("error", err instanceof Error ? err.message : String(err));
+          throw err;
+        }
+      },
+    );
   }
 
   async getArticleBySlug(slug: string): Promise<Article | undefined> {
-    const payload = await getPayload({ config: this.config });
-    const result = await payload.find({
-      collection: "articles",
-      where: { slug: { equals: slug } },
-      limit: 1,
-      overrideAccess: true,
-    });
-    const doc = result.docs[0] as PayloadArticleDoc | undefined;
-    return doc ? mapDoc(doc) : undefined;
+    return this.tracer.startSpan(
+      { name: "articles.getArticleBySlug", op: "repository", attributes: { slug } },
+      async (span) => {
+        try {
+          const payload = await getPayload({ config: this.config });
+          const result = await payload.find({
+            collection: "articles",
+            where: { slug: { equals: slug } },
+            limit: 1,
+            overrideAccess: true,
+          });
+          const doc = result.docs[0] as PayloadArticleDoc | undefined;
+          span.setAttribute("found", Boolean(doc));
+          return doc ? mapDoc(doc) : undefined;
+        } catch (err) {
+          this.logger.captureException(err, {
+            tags: { feature: FEATURE, repo: REPO, method: "getArticleBySlug" },
+          });
+          span.setStatus("error", err instanceof Error ? err.message : String(err));
+          throw err;
+        }
+      },
+    );
   }
 
   async getArticles(options?: {
@@ -76,60 +127,116 @@ export class ArticlesRepository implements IArticlesRepository {
     limit?: number;
     offset?: number;
   }): Promise<Article[]> {
-    const payload = await getPayload({ config: this.config });
-    const where: Record<string, { equals: string }> = {};
-    if (options?.status) where.status = { equals: options.status };
-    if (options?.authorId) where.author = { equals: options.authorId };
+    return this.tracer.startSpan(
+      {
+        name: "articles.getArticles",
+        op: "repository",
+        attributes: {
+          status: options?.status ?? null,
+          authorId: options?.authorId ?? null,
+          limit: options?.limit ?? null,
+          offset: options?.offset ?? null,
+        },
+      },
+      async (span) => {
+        try {
+          const payload = await getPayload({ config: this.config });
+          const where: Record<string, { equals: string }> = {};
+          if (options?.status) where.status = { equals: options.status };
+          if (options?.authorId) where.author = { equals: options.authorId };
 
-    const result = await payload.find({
-      collection: "articles",
-      where: where as never,
-      limit: options?.limit ?? 50,
-      page: options?.offset
-        ? Math.floor(options.offset / (options.limit ?? 50)) + 1
-        : 1,
-      overrideAccess: true,
-    });
-    return result.docs.map((d) => mapDoc(d as PayloadArticleDoc));
+          const result = await payload.find({
+            collection: "articles",
+            where: where as never,
+            limit: options?.limit ?? 50,
+            page: options?.offset
+              ? Math.floor(options.offset / (options.limit ?? 50)) + 1
+              : 1,
+            overrideAccess: true,
+          });
+          span.setAttribute("count", result.docs.length);
+          return result.docs.map((d) => mapDoc(d as PayloadArticleDoc));
+        } catch (err) {
+          this.logger.captureException(err, {
+            tags: { feature: FEATURE, repo: REPO, method: "getArticles" },
+          });
+          span.setStatus("error", err instanceof Error ? err.message : String(err));
+          throw err;
+        }
+      },
+    );
   }
 
   async createArticle(input: Article): Promise<Article> {
-    const payload = await getPayload({ config: this.config });
-    const created = await payload.create({
-      collection: "articles",
-      data: {
-        title: input.title,
-        slug: input.slug,
-        content: input.content,
-        status: input.status,
-        author: input.authorId,
-      } as never,
-      overrideAccess: true,
-    });
-    return mapDoc(created as PayloadArticleDoc);
+    return this.tracer.startSpan(
+      { name: "articles.createArticle", op: "repository", attributes: { slug: input.slug } },
+      async (span) => {
+        try {
+          const payload = await getPayload({ config: this.config });
+          const created = await payload.create({
+            collection: "articles",
+            data: {
+              title: input.title,
+              slug: input.slug,
+              content: input.content,
+              status: input.status,
+              author: input.authorId,
+            } as never,
+            overrideAccess: true,
+          });
+          span.setAttribute("id", String((created as PayloadArticleDoc).id));
+          return mapDoc(created as PayloadArticleDoc);
+        } catch (err) {
+          this.logger.captureException(err, {
+            tags: { feature: FEATURE, repo: REPO, method: "createArticle" },
+          });
+          span.setStatus("error", err instanceof Error ? err.message : String(err));
+          throw err;
+        }
+      },
+    );
   }
 
   async updateArticle(
     id: string,
     input: Partial<Article>,
   ): Promise<Article | undefined> {
-    const payload = await getPayload({ config: this.config });
-    try {
-      const updated = await payload.update({
-        collection: "articles",
-        id,
-        data: {
-          ...(input.title !== undefined && { title: input.title }),
-          ...(input.slug !== undefined && { slug: input.slug }),
-          ...(input.content !== undefined && { content: input.content }),
-          ...(input.status !== undefined && { status: input.status }),
-          ...(input.authorId !== undefined && { author: input.authorId }),
-        } as never,
-        overrideAccess: true,
-      });
-      return mapDoc(updated as PayloadArticleDoc);
-    } catch {
-      return undefined;
-    }
+    return this.tracer.startSpan(
+      { name: "articles.updateArticle", op: "repository", attributes: { id } },
+      async (span) => {
+        try {
+          const payload = await getPayload({ config: this.config });
+          const updated = await payload.update({
+            collection: "articles",
+            id,
+            data: {
+              ...(input.title !== undefined && { title: input.title }),
+              ...(input.slug !== undefined && { slug: input.slug }),
+              ...(input.content !== undefined && { content: input.content }),
+              ...(input.status !== undefined && { status: input.status }),
+              ...(input.authorId !== undefined && { author: input.authorId }),
+            } as never,
+            overrideAccess: true,
+          });
+          span.setAttribute("found", true);
+          return mapDoc(updated as PayloadArticleDoc);
+        } catch (err) {
+          if (
+            err &&
+            typeof err === "object" &&
+            "status" in err &&
+            (err as { status: unknown }).status === 404
+          ) {
+            span.setAttribute("found", false);
+            return undefined;
+          }
+          this.logger.captureException(err, {
+            tags: { feature: FEATURE, repo: REPO, method: "updateArticle" },
+          });
+          span.setStatus("error", err instanceof Error ? err.message : String(err));
+          throw err;
+        }
+      },
+    );
   }
 }