test(log): add coverage for custom attributes, detail fetching, and getSpanDetails

Covers the three uncovered areas:

- formatLogDetails: custom attributes rendering, REDUNDANT_LOG_DETAIL_ATTRS
  filtering, --fields filter, fallback path (extraFields without allAttributes),
  and empty allAttributes
- view.func: getLogItemDetail called for traced logs, skipped for traceless
  logs, graceful degradation on failure, custom attributes appear in output
- traces: getSpanDetails delegates to trace-items endpoint with item_type=spans

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

Author: betegon

test/commands/log/view.func.test.ts

@@ -372,4 +372,72 @@ describe("viewCommand.func", () => {
       }
     });
   });
+
+  describe("detail attribute fetching", () => {
+    test("calls getLogItemDetail for logs that have a trace", async () => {
+      const log = makeSampleLog(ID1); // makeSampleLog sets trace: "abc123..."
+      getLogsSpy.mockResolvedValue([log]);
+
+      const { context } = createMockContext();
+      const func = await viewCommand.loader();
+      await func.call(context, { json: false, web: false }, "my-org/proj", ID1);
+
+      expect(getLogItemDetailSpy).toHaveBeenCalledWith(
+        "my-org",
+        "proj",
+        ID1,
+        log.trace
+      );
+    });
+
+    test("does not call getLogItemDetail for logs without a trace", async () => {
+      const log = makeSampleLog(ID1, "no trace log");
+      log.trace = null;
+      getLogsSpy.mockResolvedValue([log]);
+
+      const { context } = createMockContext();
+      const func = await viewCommand.loader();
+      await func.call(context, { json: false, web: false }, "my-org/proj", ID1);
+
+      expect(getLogItemDetailSpy).not.toHaveBeenCalled();
+    });
+
+    test("still renders output when getLogItemDetail fails", async () => {
+      const log = makeSampleLog(ID1);
+      getLogsSpy.mockResolvedValue([log]);
+      getLogItemDetailSpy.mockRejectedValue(new Error("network error"));
+
+      const { context, stdoutWrite } = createMockContext();
+      const func = await viewCommand.loader();
+      await func.call(context, { json: false, web: false }, "my-org/proj", ID1);
+
+      // Should still render the log with standard fields despite detail failure
+      const output = stdoutWrite.mock.calls.map((c) => c[0]).join("");
+      expect(output).toContain(ID1);
+    });
+
+    test("renders custom attributes in human output when detail available", async () => {
+      const log = makeSampleLog(ID1);
+      getLogsSpy.mockResolvedValue([log]);
+      getLogItemDetailSpy.mockResolvedValue({
+        itemId: ID1,
+        timestamp: log.timestamp,
+        attributes: [
+          { name: "user.id", type: "str", value: "u_42" },
+          { name: "order.status", type: "str", value: "shipped" },
+        ],
+      });
+
+      const { context, stdoutWrite } = createMockContext();
+      const func = await viewCommand.loader();
+      await func.call(context, { json: false, web: false }, "my-org/proj", ID1);
+
+      const output = stdoutWrite.mock.calls.map((c) => c[0]).join("");
+      expect(output).toContain("Custom Attributes");
+      expect(output).toContain("user.id");
+      expect(output).toContain("u_42");
+      expect(output).toContain("order.status");
+      expect(output).toContain("shipped");
+    });
+  });
 });

test/lib/api/traces.test.ts

@@ -6,7 +6,11 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { listSpans, listTransactions } from "../../../src/lib/api/traces.js";
+import {
+  getSpanDetails,
+  listSpans,
+  listTransactions,
+} from "../../../src/lib/api/traces.js";
 import { mockFetch, useTestConfigDir } from "../../helpers.js";
 
 // ---------------------------------------------------------------------------
@@ -634,3 +638,80 @@ describe("listSpans", () => {
     expect(result.nextCursor).toBeUndefined();
   });
 });
+
+// ---------------------------------------------------------------------------
+// getSpanDetails
+// ---------------------------------------------------------------------------
+
+describe("getSpanDetails", () => {
+  useTestConfigDir("traces-span-details-test-");
+
+  let originalFetch: typeof globalThis.fetch;
+  let capturedUrl = "";
+  let capturedParams: Record<string, string> = {};
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+    capturedUrl = "";
+    capturedParams = {};
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  function mockOk(body: unknown) {
+    globalThis.fetch = mockFetch(async (input, init) => {
+      const req = new Request(input!, init);
+      capturedUrl = req.url;
+      const url = new URL(capturedUrl);
+      url.searchParams.forEach((v, k) => {
+        capturedParams[k] = v;
+      });
+      return new Response(JSON.stringify(body), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    });
+  }
+
+  const DETAIL_RESPONSE = {
+    itemId: "abc123",
+    timestamp: "2026-01-01T00:00:00Z",
+    attributes: [
+      { name: "span.op", type: "str", value: "db.query" },
+      { name: "user.id", type: "str", value: "u_42" },
+    ],
+  };
+
+  test("calls trace-items endpoint with item_type=spans", async () => {
+    mockOk(DETAIL_RESPONSE);
+
+    await getSpanDetails("my-org", "my-project", "span-id-abc", "trace-id-xyz");
+
+    expect(capturedUrl).toContain(
+      "/projects/my-org/my-project/trace-items/span-id-abc/"
+    );
+    expect(capturedParams.item_type).toBe("spans");
+    expect(capturedParams.trace_id).toBe("trace-id-xyz");
+  });
+
+  test("returns parsed attributes", async () => {
+    mockOk(DETAIL_RESPONSE);
+
+    const result = await getSpanDetails(
+      "my-org",
+      "my-project",
+      "span-id-abc",
+      "trace-id-xyz"
+    );
+
+    expect(result.itemId).toBe("abc123");
+    expect(result.attributes).toHaveLength(2);
+    expect(result.attributes[0]).toEqual({
+      name: "span.op",
+      type: "str",
+      value: "db.query",
+    });
+  });
+});

test/lib/formatters/log.test.ts

@@ -12,7 +12,11 @@ import {
   formatLogTable,
   getLogId,
 } from "../../../src/lib/formatters/log.js";
-import type { DetailedSentryLog, SentryLog } from "../../../src/types/index.js";
+import type {
+  DetailedSentryLog,
+  SentryLog,
+  TraceItemAttribute,
+} from "../../../src/types/index.js";
 
 /** Force rendered (TTY) mode for a describe block */
 function useRenderedMode() {
@@ -441,6 +445,88 @@ describe("formatLogDetails", () => {
     expect(result).not.toContain("SDK");
     expect(result).not.toContain("Trace");
   });
+
+  describe("Custom Attributes section", () => {
+    const customAttrs: TraceItemAttribute[] = [
+      { name: "user.id", type: "str", value: "u_42" },
+      { name: "order.total", type: "float", value: 99.9 },
+      { name: "retry.count", type: "int", value: 3 },
+      { name: "is_premium", type: "bool", value: true },
+    ];
+
+    test("renders custom attributes when allAttributes provided", () => {
+      const log = createDetailedTestLog();
+      const result = stripAnsi(formatLogDetails(log, "test-org", customAttrs));
+
+      expect(result).toContain("Custom Attributes");
+      expect(result).toContain("user.id");
+      expect(result).toContain("u_42");
+      expect(result).toContain("order.total");
+      expect(result).toContain("99.9");
+      expect(result).toContain("retry.count");
+      expect(result).toContain("3");
+      expect(result).toContain("is_premium");
+      expect(result).toContain("true");
+    });
+
+    test("filters out REDUNDANT_LOG_DETAIL_ATTRS from custom attributes", () => {
+      const attrsWithRedundant: TraceItemAttribute[] = [
+        { name: "user.id", type: "str", value: "u_42" },
+        // these are in REDUNDANT_LOG_DETAIL_ATTRS and should be suppressed
+        { name: "severity_number", type: "int", value: 9 },
+        { name: "project.id", type: "str", value: "123" },
+      ];
+      const log = createDetailedTestLog();
+      const result = stripAnsi(
+        formatLogDetails(log, "test-org", attrsWithRedundant)
+      );
+
+      expect(result).toContain("user.id");
+      expect(result).not.toContain("severity_number");
+      expect(result).not.toContain("project.id");
+    });
+
+    test("extraFields limits which custom attributes are shown", () => {
+      const log = createDetailedTestLog();
+      const result = stripAnsi(
+        formatLogDetails(log, "test-org", customAttrs, ["user.id"])
+      );
+
+      expect(result).toContain("Custom Attributes");
+      expect(result).toContain("user.id");
+      expect(result).not.toContain("order.total");
+      expect(result).not.toContain("retry.count");
+    });
+
+    test("shows no Custom Attributes section when all are filtered by extraFields", () => {
+      const log = createDetailedTestLog();
+      const result = stripAnsi(
+        formatLogDetails(log, "test-org", customAttrs, ["nonexistent.field"])
+      );
+
+      expect(result).not.toContain("Custom Attributes");
+    });
+
+    test("fallback: shows extraFields from log when allAttributes absent", () => {
+      const log = createDetailedTestLog({
+        "user.id": "u_99",
+      } as DetailedSentryLog);
+      const result = stripAnsi(
+        formatLogDetails(log, "test-org", undefined, ["user.id"])
+      );
+
+      expect(result).toContain("Custom Attributes");
+      expect(result).toContain("user.id");
+      expect(result).toContain("u_99");
+    });
+
+    test("no Custom Attributes section when allAttributes is empty array", () => {
+      const log = createDetailedTestLog();
+      const result = stripAnsi(formatLogDetails(log, "test-org", []));
+
+      expect(result).not.toContain("Custom Attributes");
+    });
+  });
 });
 
 describe("getLogId", () => {