CLI

+ import type { DrainContext } from 'evlog'
+ import { createFsDrain } from 'evlog/fs'
+ import { createDrainPipeline } from 'evlog/pipeline'
+
+ const pipeline = createDrainPipeline<DrainContext>({ batch: { size: 20 } })
+
+ export function createCliDrain() {
+   return pipeline(createFsDrain({ dir: '.evlog/logs' }))
+ }

+ import { setupEvlog } from '@evlog/cli'
+ import { createCliDrain } from './drain'
+
+ export const setup = setupEvlog({
+   service: 'my-cli',
+   version: '1.0.0',
+   drain: createCliDrain(),
+ })

+ import { runMain } from '@evlog/cli/citty'
+ import { setup } from './evlog'
- runMain(main)
+ runMain(main, setup)
+   .then(() => setup.flush())
+   .catch(err => exitWithError(err))

+ import { useLogger } from '@evlog/cli'

  async run() {
+   const log = useLogger()
+   log.set({ checks: results })
    p.intro('my-cli doctor')   // Clack unchanged
    // …
  }

import type { DrainContext } from 'evlog'
import { createAxiomDrain } from 'evlog/axiom'
import { createDatadogDrain } from 'evlog/datadog'
import { createFsDrain } from 'evlog/fs'
import { createOtlpDrain } from 'evlog/otlp'
import { createDrainPipeline } from 'evlog/pipeline'

const pipeline = createDrainPipeline<DrainContext>({ batch: { size: 20 } })

export function createCliDrain() {
  switch (process.env.EVLOG_DRAIN ?? 'fs') {
    case 'axiom':
      // Reads AXIOM_API_KEY / AXIOM_DATASET (or AXIOM_TOKEN) from the environment
      return pipeline(createAxiomDrain())
    case 'datadog':
      return pipeline(createDatadogDrain())
    case 'otlp':
      return pipeline(createOtlpDrain())
    default:
      return pipeline(createFsDrain({
        dir: process.env.EVLOG_LOG_DIR ?? '.evlog/logs',
      }))
  }
}

import { setupEvlog } from '@evlog/cli'
import { createCliDrain } from './drain'

export const setup = setupEvlog({
  service: 'my-cli',
  version: '1.0.0',
  redact: true,
  drain: createCliDrain(),
})

my-cli/
├── package.json
├── tsconfig.json
└── src/
    ├── index.ts              # runMain, flush, exitWithError
    ├── drain.ts              # createCliDrain() — fs default, axiom via env
    ├── evlog.ts              # setupEvlog()
    ├── catalogs/             # optional — advanced commands only
    │   ├── actor.ts          # resolveCliActor() for audit.actor
    │   ├── errors.ts
    │   └── audit.ts
    └── commands/
        ├── index.ts          # main + subCommands
        ├── doctor.ts
        └── pull.ts

import type { DrainContext } from 'evlog'
import { createAxiomDrain } from 'evlog/axiom'
import { createFsDrain } from 'evlog/fs'
import { createDrainPipeline } from 'evlog/pipeline'

const pipeline = createDrainPipeline<DrainContext>({ batch: { size: 20 } })

export function createCliDrain() {
  if (process.env.EVLOG_DRAIN === 'axiom') {
    return pipeline(createAxiomDrain())
  }
  return pipeline(createFsDrain({
    dir: process.env.EVLOG_LOG_DIR ?? '.evlog/logs',
  }))
}

import { setupEvlog } from '@evlog/cli'
import { createCliDrain } from './drain'

export const setup = setupEvlog({
  service: 'my-cli',
  version: '1.0.0',
  redact: true,
  drain: createCliDrain(),
})

import { defineCommand } from 'citty'
import * as p from '@clack/prompts'
import { useLogger } from '@evlog/cli'

export const doctor = defineCommand({
  meta: { name: 'doctor', description: 'Health checks' },
  async run() {
    const log = useLogger()
    p.intro('my-cli doctor')
    const checks = [{ name: 'config', ok: true }, { name: 'api', ok: true }]
    log.set({ checks })
    p.outro(`All ${checks.length} checks passed`)
  },
})

import { defineErrorCatalog } from 'evlog'

export const errorCatalog = defineErrorCatalog('myapp', {
  CONFIG_MISSING: {
    status: 1,
    message: 'No config file found',
    fix: 'Run myapp init or set MYAPP_CONFIG.',
  },
})

declare module 'evlog' {
  interface RegisteredErrorCatalogs {
    myapp: typeof errorCatalog
  }
}

import { defineAuditCatalog } from 'evlog'

export const auditCatalog = defineAuditCatalog('myapp', {
  SECRET_PULL: {
    target: 'secret_store',
    severity: 'high',
    description: 'Read secrets from a remote store',
    redactPaths: ['token', 'password'],
  },
  DEPLOY: {
    target: 'deployment',
    severity: 'critical',
    requiresChanges: true,
    description: 'Promote a build to a region',
  },
})

declare module 'evlog' {
  interface RegisteredAuditCatalogs {
    myapp: typeof auditCatalog
  }
}

import type { AuditActor } from 'evlog'

export function resolveCliActor(): AuditActor {
  const id = process.env.USER ?? 'unknown'
  return { type: 'user', id, displayName: id }
}

import { exitWithError } from '@evlog/cli'
import { runMain } from '@evlog/cli/citty'
import { setup } from './evlog'
import { main } from './commands'

runMain(main, setup)
  .then(() => setup.flush())
  .catch(error => exitWithError(error))