# Log Entry

> Structured log entry with level, message, service, trace ID, and error details.

- Name: `log-entry`
- Categories: logging
- Detail page: https://open-types.dev/types/log-entry

## Install

```bash
# Types only
npx shadcn add @open-types/log-entry

# Types + Zod v4 validators
npx shadcn add @open-types/log-entry-zod

# Types + real-world examples
npx shadcn add @open-types/log-entry-examples
```

## Types

```typescript
export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";

export interface LogError {
  name: string;
  message: string;
  stack?: string;
}

export interface LogEntry {
  level: LogLevel;
  message: string;
  timestamp: string;
  service?: string;
  context?: Record<string, unknown>;
  error?: LogError;
  trace_id?: string;
  span_id?: string;
}
```

## Zod validator

```typescript
import * as z from "zod";
import type { LogEntry, LogError, LogLevel } from "../types/log-entry";

export const logLevelSchema = z.enum([
  "trace",
  "debug",
  "info",
  "warn",
  "error",
  "fatal",
]) satisfies z.ZodType<LogLevel>;

export const logErrorSchema = z.object({
  name: z.string().min(1, { error: "Error name is required" }),
  message: z.string().min(1, { error: "Error message is required" }),
  stack: z.string().optional(),
}) satisfies z.ZodType<LogError>;

export const logEntrySchema = z.object({
  level: logLevelSchema,
  message: z.string().min(1, { error: "Log message is required" }),
  timestamp: z.iso.datetime({ error: "Invalid timestamp" }),
  service: z.string().optional(),
  context: z.record(z.string(), z.unknown()).optional(),
  error: logErrorSchema.optional(),
  trace_id: z.string().optional(),
  span_id: z.string().optional(),
}) satisfies z.ZodType<LogEntry>;

export type { LogEntry, LogError, LogLevel } from "../types/log-entry";
```

## Examples

```typescript
// Source: hand-crafted; modeled after pino/winston JSON output and OpenTelemetry conventions
import type {
  LogLevel,
  LogError,
  LogEntry,
} from "../types/log-entry";

export const logLevelExamples = {
  trace: "trace",
  debug: "debug",
  info: "info",
  warn: "warn",
  error: "error",
  fatal: "fatal",
} as const satisfies Record<string, LogLevel>;

const validationError = {
  name: "ValidationError",
  message: "email is required",
  stack: "ValidationError: email is required\n    at validate (/app/src/validate.ts:42:11)",
} as const satisfies LogError;

export const logErrorExamples = {
  validation: validationError,
  noStack: { name: "TimeoutError", message: "Request timed out after 30s" } satisfies LogError,
  minimal: { name: "Error", message: "Something went wrong" } satisfies LogError,
} as const;

const infoEntry = {
  level: "info",
  message: "Request handled",
  timestamp: "2026-05-16T18:30:00.000Z",
  service: "api",
  context: { method: "GET", path: "/v1/users", status: 200, duration_ms: 12 },
  trace_id: "4bf92f3577b34da6a3ce929d0e0e4736",
  span_id: "00f067aa0ba902b7",
} as const satisfies LogEntry;

export const logEntryExamples = {
  info: infoEntry,
  warn: { ...infoEntry, level: "warn", message: "Slow query", context: { duration_ms: 1850 } } satisfies LogEntry,
  errorWithStack: {
    ...infoEntry,
    level: "error",
    message: "Failed to validate input",
    error: validationError,
    context: { request_id: "req_abc" },
  } satisfies LogEntry,
  fatal: {
    ...infoEntry,
    level: "fatal",
    message: "Out of memory",
    error: { name: "FatalError", message: "JavaScript heap out of memory" },
  } satisfies LogEntry,
  debug: { ...infoEntry, level: "debug", message: "cache miss" } satisfies LogEntry,
  minimal: {
    level: "info",
    message: "boot",
    timestamp: "2026-05-16T18:30:00.000Z",
  } satisfies LogEntry,
} as const;
```