· Standard
L
Community-Eintrag
llms.txt erreichbar
KI-Impact-Score 95/100 · A
Die Organisation LogLayer nutzt den llms.txt-Standard für eine bessere Auffindbarkeit durch KI-Systeme. Branche: Entwickler-Tools. Die Website loglayer.dev stellt ihre llms.txt unter https://loglayer.dev/llms.txt bereit. Der Eintrag besteht seit 19. March 2026.
Geschäftskategorie
Entwickler-Tools
Eingetragen seit
llms.txt-Adresse
Beschreibung
A structured logging library with a fluent API for Typescript / Javascript. It separates log data into context (persistent), metadata (per-message), and errors with support for 25+ transports and plugins. Die Dokumentation umfasst: Installation, Quick Start, Log Levels, Tagged Template Syntax u. a..
Gemäß DSGVO Art. 17 kannst du die Löschung deiner Daten beantragen.
llms.txt — Aktueller Inhalt
Öffnen ↗
# LogLayer
> A structured logging library with a fluent API for Typescript / Javascript. It separates log data into context (persistent), metadata (per-message), and errors with support for 25+ transports and plugins.
## Installation
```
npm install loglayer
```
## Quick Start
```typescript
import { LogLayer, ConsoleTransport } from 'loglayer'
import type { ILogLayer } from 'loglayer'
const log: ILogLayer = new LogLayer({
transport: new ConsoleTransport({
logger: console,
}),
})
log.info('Hello world!')
```
## Log Levels
```typescript
log.trace('Detailed debugging')
log.debug('Debug information')
log.info('Informational message')
log.warn('Warning message')
log.error('Error occurred')
log.fatal('Critical failure')
// Multiple parameters
log.info('User', 123, 'logged in')
// Tagged template syntax (use withMetadata for structured data)
log.info`User ${userId} logged in`
log.warn`Request ${requestId} took ${duration}ms`
```
## Tagged Template Syntax
Log methods accept tagged templates directly — no special setup required.
```typescript
const userId = '123'
const count = 42
// Simple interpolations work great
log.info`User ${userId} logged in`
// Multiple values
log.warn`Request ${requestId} completed in ${duration}ms with status ${status}`
// Fluent chains still work
log.withMetadata({ env: 'production' })
.withContext({ service: 'api' })
.info`Processing ${taskCount} items`
```
**Behavior:** Interpolations are converted using `String()`. For structured data, use `withMetadata()`:
```typescript
// ✅ Good: simple values in templates
log.info`User ${userId} connected from ${ip}`
// ✅ Good: structured data via withMetadata
log.withMetadata({ user: { id: userId, name: name } }).info('User logged in')
// ⚠️ Objects in templates become "[object Object]" (intentional)
log.info`Data: ${myObject}` // Output: "Data: [object Object]"
```
## Metadata (per-message data)
```typescript
// Attach structured data to a single log entry
log.withMetadata({ userId: '123', action: 'login' }).info('User logged in')
// Log metadata without a message
log.metadataOnly({ status: 'healthy', cpu: '45%' })
```
## Context (persistent data across all log entries)
```typescript
// Set context - persists across all subsequent logs
log.withContext({ requestId: 'abc-123', service: 'auth' })
log.info('Processing') // includes requestId and service
log.info('Done') // still includes requestId and service
// Read, clear, mute
log.getContext()
log.clearContext() // clear all
log.clearContext(['requestId']) // clear specific keys
log.muteContext() // temporarily disable
log.unMuteContext()
```
## Error Handling
```typescript
// Error with a message
log.withError(new Error('Connection failed')).error('DB error')
// Error only (no extra message)
log.errorOnly(new Error('Connection failed'))
// Combine error with metadata
log.withError(new Error('Timeout'))
.withMetadata({ query: 'SELECT *', duration: 1500 })
.error('Query failed')
```
## Error Serialization (recommended)
```typescript
import { serializeError } from 'serialize-error' // npm install serialize-error
const log: ILogLayer = new LogLayer({
errorSerializer: serializeError,
transport: new ConsoleTransport({ logger: console }),
})
```
## Lazy Evaluation
```typescript
import { LogLayer, lazy } from 'loglayer'
// Context: re-evaluated on every log call
log.withContext({
memoryUsage: lazy(() => process.memoryUsage().heapUsed),
})
// Metadata: evaluated once for that log entry
log.withMetadata({
data: lazy(() => JSON.stringify(largeObject)),
}).debug('Processing result')
// metadataOnly: same behavior
log.metadataOnly({
status: lazy(() => getHealthStatus()),
})
// Async lazy (metadata only) — must be awaited
await log.withMetadata({
result: lazy(async () => await fetchResult()),
}).info('Done')
await log.metadataOnly({
result: lazy(async () => await fetchResult()),
})
// Callbacks are NOT invoked when t
[…gekürzt]