@ossy/observability 1.1.0

package/README.md

@@ -0,0 +1,192 @@
+# @ossy/observability
+
+Structured logger with pluggable backends for the Ossy platform.
+
+## `createLogger(namespace)`
+
+Returns a logger bound to a namespace string. All log methods accept an optional `context` object that is merged into the output.
+
+```js
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('my-service')
+
+log.info('Server started', { port: 3000 })
+log.warn('Deprecated config key', { key: 'FOO' })
+log.error('Request failed', { url: '/api/foo' }, error)
+log.debug('Processing item', { id: '123' })
+```
+
+### Methods
+
+| Method | Signature |
+|--------|-----------|
+| `log.info` | `(message: string, context?: object) => void` |
+| `log.warn` | `(message: string, context?: object) => void` |
+| `log.error` | `(message: string, context?: object, error?: Error) => void` |
+| `log.debug` | `(message: string, context?: object) => void` |
+
+## Output format
+
+- **Development** (`NODE_ENV !== 'production'`): pretty-printed lines with a `[namespace]` prefix.
+- **Production** (`NODE_ENV === 'production'`): newline-delimited JSON:
+  ```json
+  { "level": "info", "namespace": "my-service", "message": "Server started", "port": 3000, "timestamp": "2026-01-01T00:00:00.000Z" }
+  ```
+
+## Adding a custom backend
+
+A backend is an object with four functions. Register it with `registerBackend`:
+
+```js
+import { registerBackend } from '@ossy/observability'
+
+registerBackend({
+  info(namespace, message, context) { /* ... */ },
+  warn(namespace, message, context) { /* ... */ },
+  error(namespace, message, context, error) { /* ... */ },
+  debug(namespace, message, context) { /* ... */ },
+})
+```
+
+All registered backends receive every log call (fan-out). The built-in console backend is always active unless you call `clearBackends()` first.
+
+## Built-in integrations
+
+### `console.integration.js`
+
+| Field | Value |
+|-------|-------|
+| `id` | `logger-console` |
+| `credentials` | *(none)* |
+
+Provides the same pretty/JSON output as the default backend, but as a discoverable `*.integration.js` primitive. Use it when you want the platform's integration loader to manage the console backend explicitly:
+
+```js
+import { consoleIntegration } from '@ossy/observability'
+import { registerBackend, clearBackends } from '@ossy/observability'
+
+clearBackends()
+registerBackend(await consoleIntegration.connect({ env: process.env }))
+```
+
+### `sentry.integration.js`
+
+| Field | Value |
+|-------|-------|
+| `id` | `logger-sentry` |
+| `credentials` | `SENTRY_DSN` |
+
+Forwards `error`-level calls to Sentry via `captureException`. `info`, `warn`, and `debug` are no-ops in this backend.
+
+Add the integration file to your app's manifest (or import it directly) and ensure `SENTRY_DSN` is set in the environment:
+
+```js
+import { sentryIntegration } from '@ossy/observability'
+import { registerBackend } from '@ossy/observability'
+
+registerBackend(await sentryIntegration.connect({ env: process.env }))
+```
+
+### `grafana-loki.integration.js`
+
+| Field | Value |
+|-------|-------|
+| `id` | `logger-grafana-loki` |
+| `credentials` | `GRAFANA_LOKI_URL`, `GRAFANA_LOKI_USER`, `GRAFANA_LOKI_API_KEY` |
+
+Forwards every log call to a Grafana Loki instance as a structured JSON stream.  Calls are fire-and-forget — Loki outages never block application code.
+
+Each log entry is pushed as a Loki stream labelled with `level` and `namespace`, making it queryable in Grafana Explore:
+
+```logql
+{namespace="my-service"} | json
+{level="error"}
+```
+
+**Setup:**
+
+```js
+import { grafanaLokiIntegration, registerBackend } from '@ossy/observability'
+
+registerBackend(await grafanaLokiIntegration.connect({ env: process.env }))
+```
+
+**Required environment variables:**
+
+| Variable | Description |
+|----------|-------------|
+| `GRAFANA_LOKI_URL` | Full Loki push endpoint, e.g. `https://logs-prod-eu-west-0.grafana.net/loki/api/v1/push` |
+| `GRAFANA_LOKI_USER` | Numeric user ID from the Grafana Cloud Loki data source page |
+| `GRAFANA_LOKI_API_KEY` | Grafana Cloud API key with the **MetricsPublisher** role |
+
+---
+
+### `grafana-metrics.integration.js`
+
+| Field | Value |
+|-------|-------|
+| `id` | `metrics-grafana` |
+| `credentials` | `GRAFANA_METRICS_URL`, `GRAFANA_METRICS_USER`, `GRAFANA_METRICS_API_KEY` |
+
+Batches counter, gauge, and histogram observations in memory and flushes them every 10 seconds as a Prometheus text-format body to the configured push endpoint.  No extra npm dependencies — uses native `fetch` only.
+
+**Setup:**
+
+```js
+import { grafanaMetricsIntegration } from '@ossy/observability'
+
+await grafanaMetricsIntegration.connect({ env: process.env })
+```
+
+Call `connect()` once at startup.  This wires up the `metrics` singleton exported from the package and starts the flush interval.
+
+**Using the metrics client:**
+
+```js
+import { metrics } from '@ossy/observability'
+
+metrics.increment('task.run', { task: 'resize-image' })   // counter
+metrics.gauge('queue.depth', 42, { queue: 'images' })      // gauge
+metrics.timing('task.duration', 1234, { task: 'resize-image' }) // histogram (ms)
+```
+
+Metric names use dots in application code (`task.run`) and are normalised to underscores (`task_run`) in the Prometheus output.
+
+**Required environment variables:**
+
+| Variable | Description |
+|----------|-------------|
+| `GRAFANA_METRICS_URL` | Prometheus-compatible push endpoint, e.g. `https://prometheus-prod-13-prod-us-east-0.grafana.net/api/prom/push` |
+| `GRAFANA_METRICS_USER` | Numeric user ID from the Grafana Cloud Prometheus data source page |
+| `GRAFANA_METRICS_API_KEY` | Grafana Cloud API key with the **MetricsPublisher** role |
+
+**What appears in Grafana:**
+
+| Prometheus metric | Type | Labels |
+|-------------------|------|--------|
+| `task_run` | counter | `task` |
+| `task_duration_bucket` / `_sum` / `_count` | histogram | `task` |
+
+Histogram buckets are pre-defined at 10 ms, 50 ms, 100 ms, 250 ms, 500 ms, 1 s, 2.5 s, 5 s, 10 s, and +Inf.  Use a PromQL query like the following to graph p95 task duration:
+
+```promql
+histogram_quantile(0.95, sum by (le, task) (rate(task_duration_bucket[5m])))
+```
+
+---
+
+## How tasks receive `log` automatically
+
+`@ossy/platform`'s `TaskService` injects a `log` instance into every task's `run()` call, scoped to the task's `metadata.id`:
+
+```js
+// your-task.js
+export const metadata = { id: 'my-task', triggers: [...] }
+
+export async function run({ event, sdk, integrations, log }) {
+  log.info('Task started', { eventType: event.type })
+}
+```
+
+No extra setup needed — the logger is created automatically by the platform before dispatching the task.

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@ossy/observability",
+  "version": "1.1.0",
+  "description": "Structured logger with pluggable backends for the Ossy platform",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ossy-se/packages.git"
+  },
+  "type": "module",
+  "ossy": {
+    "src": "./src"
+  },
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [],
+  "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
+  "license": "MIT",
+  "dependencies": {
+    "@sentry/node": "^8"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "gitHead": "9a8a1bb0466d35001425d241d77c2c9ab31e11d3"
+}

package/src/console.integration.js

@@ -0,0 +1,41 @@
+/**
+ * Console backend for @ossy/observability.
+ *
+ * In development: pretty-printed lines with a `[namespace]` prefix.
+ * In production: newline-delimited JSON: { level, namespace, message, ...context, timestamp }.
+ *
+ * Credentials: none — always available.
+ */
+
+export const id = 'logger-console'
+export const credentials = []
+
+/**
+ * @param {{ env: NodeJS.ProcessEnv }} opts
+ * @returns {Promise<import('./logger.js').Backend>}
+ */
+export async function connect ({ env }) {
+  const isProd = env.NODE_ENV === 'production'
+
+  function emit (level, ns, msg, ctx, err) {
+    if (isProd) {
+      const entry = { level, namespace: ns, message: msg, ...ctx, timestamp: new Date().toISOString() }
+      if (err) entry.error = err.stack ?? err.message
+      const stream = level === 'error' ? process.stderr : process.stdout
+      stream.write(JSON.stringify(entry) + '\n')
+    } else {
+      const prefix = `[${ns}]`
+      if (level === 'info') console.log(prefix, msg, ...(ctx ? [ctx] : []))
+      else if (level === 'warn') console.warn(prefix, msg, ...(ctx ? [ctx] : []))
+      else if (level === 'error') console.error(prefix, msg, ...(ctx ? [ctx] : []), ...(err ? [err] : []))
+      else if (level === 'debug') console.debug(prefix, msg, ...(ctx ? [ctx] : []))
+    }
+  }
+
+  return {
+    info: (ns, msg, ctx) => emit('info', ns, msg, ctx),
+    warn: (ns, msg, ctx) => emit('warn', ns, msg, ctx),
+    error: (ns, msg, ctx, err) => emit('error', ns, msg, ctx, err),
+    debug: (ns, msg, ctx) => emit('debug', ns, msg, ctx),
+  }
+}

package/src/grafana-loki.integration.js

@@ -0,0 +1,68 @@
+/**
+ * Grafana Loki backend for @ossy/observability.
+ *
+ * Pushes every log entry to a Loki instance via the HTTP push API
+ * (POST /loki/api/v1/push).  Each call is fire-and-forget — network
+ * errors are swallowed so a Loki outage never blocks application code.
+ *
+ * Required credentials:
+ *   GRAFANA_LOKI_URL     — e.g. https://logs-prod-eu-west-0.grafana.net/loki/api/v1/push
+ *   GRAFANA_LOKI_USER    — numeric user ID shown in Grafana Cloud
+ *   GRAFANA_LOKI_API_KEY — Grafana Cloud API key with MetricsPublisher role
+ */
+
+export const id = 'logger-grafana-loki'
+export const credentials = [
+  'GRAFANA_LOKI_URL',
+  'GRAFANA_LOKI_USER',
+  'GRAFANA_LOKI_API_KEY',
+]
+
+/**
+ * @param {{ env: NodeJS.ProcessEnv }} opts
+ * @returns {Promise<import('./logger.js').Backend>}
+ */
+export async function connect ({ env }) {
+  const url  = env.GRAFANA_LOKI_URL
+  const user = env.GRAFANA_LOKI_USER
+  const key  = env.GRAFANA_LOKI_API_KEY
+  const auth = 'Basic ' + Buffer.from(`${user}:${key}`).toString('base64')
+
+  function push (level, ns, msg, ctx, err) {
+    const entry = {
+      level,
+      namespace: ns,
+      message: msg,
+      ...ctx,
+      ...(err ? { error: err.stack ?? err.message } : {}),
+      timestamp: new Date().toISOString(),
+    }
+
+    // Loki expects nanosecond Unix timestamps as strings.
+    const unixNs = String(Date.now() * 1_000_000)
+
+    const body = JSON.stringify({
+      streams: [{
+        stream: { level, namespace: ns },
+        values: [[unixNs, JSON.stringify(entry)]],
+      }],
+    })
+
+    // fire-and-forget — never await, never rethrow
+    fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: auth,
+      },
+      body,
+    }).catch(() => {})
+  }
+
+  return {
+    info:  (ns, msg, ctx)      => push('info',  ns, msg, ctx),
+    warn:  (ns, msg, ctx)      => push('warn',  ns, msg, ctx),
+    error: (ns, msg, ctx, err) => push('error', ns, msg, ctx, err),
+    debug: (ns, msg, ctx)      => push('debug', ns, msg, ctx),
+  }
+}

package/src/grafana-metrics.integration.js

@@ -0,0 +1,223 @@
+/**
+ * Grafana Cloud metrics backend for @ossy/observability.
+ *
+ * Batches counter / gauge / histogram observations in memory and flushes them
+ * every 10 s as a Prometheus text-format body (no protobuf required) to the
+ * configured push endpoint (Prometheus Pushgateway or Grafana Cloud Mimir
+ * compatible push URL).
+ *
+ * Required credentials:
+ *   GRAFANA_METRICS_URL      — remote_write / pushgateway endpoint
+ *   GRAFANA_METRICS_USER     — numeric user ID shown in Grafana Cloud
+ *   GRAFANA_METRICS_API_KEY  — Grafana Cloud API key with MetricsPublisher role
+ *
+ * The exported `metrics` singleton starts as a no-op object.  Call connect()
+ * once at startup to wire up the real implementation.
+ */
+
+export const id = 'metrics-grafana'
+export const credentials = [
+  'GRAFANA_METRICS_URL',
+  'GRAFANA_METRICS_USER',
+  'GRAFANA_METRICS_API_KEY',
+]
+
+/**
+ * Singleton metrics client.  No-ops until connect() is called.
+ *
+ * @type {{
+ *   increment(name: string, labels?: Record<string, string>): void,
+ *   gauge(name: string, value: number, labels?: Record<string, string>): void,
+ *   timing(name: string, ms: number, labels?: Record<string, string>): void,
+ * }}
+ */
+export const metrics = {
+  increment (_name, _labels) {},
+  gauge     (_name, _value, _labels) {},
+  timing    (_name, _ms, _labels) {},
+}
+
+// Predefined histogram bucket boundaries (milliseconds).
+const HISTOGRAM_BUCKETS_MS = [10, 50, 100, 250, 500, 1000, 2500, 5000, 10000, Infinity]
+
+/**
+ * Normalise a metric name: dots → underscores (Prometheus convention).
+ * @param {string} name
+ */
+function safeName (name) {
+  return name.replace(/\./g, '_')
+}
+
+/**
+ * Render a label set as a Prometheus selector string, e.g. `{task="foo"}`.
+ * Returns an empty string when there are no labels.
+ * @param {Record<string, string> | undefined} labels
+ */
+function labelsStr (labels) {
+  if (!labels || !Object.keys(labels).length) return ''
+  return '{' + Object.entries(labels)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([k, v]) => `${k}="${v}"`)
+    .join(',') + '}'
+}
+
+/**
+ * Like labelsStr but appends the `le` label used in histogram buckets.
+ * @param {Record<string, string> | undefined} labels
+ * @param {string} leStr
+ */
+function labelsWithLe (labels, leStr) {
+  const sorted = labels
+    ? Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}="${v}"`)
+    : []
+  return '{' + [...sorted, `le="${leStr}"`].join(',') + '}'
+}
+
+/**
+ * Build a stable Map key from metric name + label set.
+ * @param {string} name
+ * @param {Record<string, string> | undefined} labels
+ */
+function makeKey (name, labels) {
+  return name + labelsStr(labels)
+}
+
+/**
+ * @param {{ env: NodeJS.ProcessEnv }} opts
+ * @returns {Promise<typeof metrics>}
+ */
+export async function connect ({ env }) {
+  const url  = env.GRAFANA_METRICS_URL
+  const user = env.GRAFANA_METRICS_USER
+  const key  = env.GRAFANA_METRICS_API_KEY
+  const auth = 'Basic ' + Buffer.from(`${user}:${key}`).toString('base64')
+
+  // In-memory accumulators — all values are cumulative (Prometheus semantics).
+  /** @type {Map<string, { name: string, labels: Record<string,string>|undefined, value: number }>} */
+  const counters = new Map()
+  /** @type {Map<string, { name: string, labels: Record<string,string>|undefined, value: number }>} */
+  const gauges = new Map()
+  /**
+   * @type {Map<string, {
+   *   name: string,
+   *   labels: Record<string,string>|undefined,
+   *   sum: number,
+   *   count: number,
+   *   buckets: Map<number, number>
+   * }>}
+   */
+  const histograms = new Map()
+
+  function buildTextBody () {
+    const lines = []
+
+    // Counters grouped by name (one TYPE declaration per metric name).
+    const countersByName = new Map()
+    for (const entry of counters.values()) {
+      const n = safeName(entry.name)
+      if (!countersByName.has(n)) countersByName.set(n, [])
+      countersByName.get(n).push(entry)
+    }
+    for (const [n, entries] of countersByName) {
+      lines.push(`# TYPE ${n} counter`)
+      for (const { labels, value } of entries) {
+        lines.push(`${n}${labelsStr(labels)} ${value}`)
+      }
+    }
+
+    // Gauges.
+    const gaugesByName = new Map()
+    for (const entry of gauges.values()) {
+      const n = safeName(entry.name)
+      if (!gaugesByName.has(n)) gaugesByName.set(n, [])
+      gaugesByName.get(n).push(entry)
+    }
+    for (const [n, entries] of gaugesByName) {
+      lines.push(`# TYPE ${n} gauge`)
+      for (const { labels, value } of entries) {
+        lines.push(`${n}${labelsStr(labels)} ${value}`)
+      }
+    }
+
+    // Histograms.
+    const histsByName = new Map()
+    for (const entry of histograms.values()) {
+      const n = safeName(entry.name)
+      if (!histsByName.has(n)) histsByName.set(n, [])
+      histsByName.get(n).push(entry)
+    }
+    for (const [n, entries] of histsByName) {
+      lines.push(`# TYPE ${n} histogram`)
+      for (const { labels, sum, count, buckets } of entries) {
+        for (const [le, n2] of buckets) {
+          const leStr = le === Infinity ? '+Inf' : String(le)
+          lines.push(`${n}_bucket${labelsWithLe(labels, leStr)} ${n2}`)
+        }
+        lines.push(`${n}_sum${labelsStr(labels)} ${sum}`)
+        lines.push(`${n}_count${labelsStr(labels)} ${count}`)
+      }
+    }
+
+    return lines.join('\n') + '\n'
+  }
+
+  async function flush () {
+    if (!counters.size && !gauges.size && !histograms.size) return
+
+    const body = buildTextBody()
+
+    try {
+      await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'text/plain',
+          Authorization: auth,
+        },
+        body,
+      })
+    } catch {
+      // swallow — a metrics outage must never crash the application
+    }
+  }
+
+  const interval = setInterval(flush, 10_000)
+  // Allow the process to exit cleanly without waiting for the flush interval.
+  if (interval.unref) interval.unref()
+
+  // Replace the singleton no-op methods with real implementations.
+  metrics.increment = function (name, labels) {
+    const key = makeKey(name, labels)
+    const existing = counters.get(key)
+    if (existing) {
+      existing.value += 1
+    } else {
+      counters.set(key, { name, labels, value: 1 })
+    }
+  }
+
+  metrics.gauge = function (name, value, labels) {
+    gauges.set(makeKey(name, labels), { name, labels, value })
+  }
+
+  metrics.timing = function (name, ms, labels) {
+    const key = makeKey(name, labels)
+    let h = histograms.get(key)
+    if (!h) {
+      h = {
+        name,
+        labels,
+        sum: 0,
+        count: 0,
+        buckets: new Map(HISTOGRAM_BUCKETS_MS.map(le => [le, 0])),
+      }
+      histograms.set(key, h)
+    }
+    h.sum += ms
+    h.count += 1
+    for (const le of h.buckets.keys()) {
+      if (ms <= le) h.buckets.set(le, h.buckets.get(le) + 1)
+    }
+  }
+
+  return metrics
+}

package/src/index.js

@@ -0,0 +1,6 @@
+export { createLogger, registerBackend, clearBackends } from './logger.js'
+export * as consoleIntegration from './console.integration.js'
+export * as sentryIntegration from './sentry.integration.js'
+export * as grafanaLokiIntegration from './grafana-loki.integration.js'
+export * as grafanaMetricsIntegration from './grafana-metrics.integration.js'
+export { metrics } from './grafana-metrics.integration.js'

package/src/logger.js

@@ -0,0 +1,92 @@
+/**
+ * @ossy/observability — structured logger with pluggable backends.
+ *
+ * Usage:
+ *   import { createLogger } from '@ossy/observability'
+ *   const log = createLogger('my-namespace')
+ *   log.info('Server started', { port: 3000 })
+ */
+
+/** @type {Array<Backend>} */
+const _backends = []
+
+/**
+ * @typedef {{ level: string, namespace: string, message: string, context?: object, error?: Error, timestamp: string }} LogEntry
+ * @typedef {{ info(ns: string, msg: string, ctx?: object): void, warn(ns: string, msg: string, ctx?: object): void, error(ns: string, msg: string, ctx?: object, err?: Error): void, debug(ns: string, msg: string, ctx?: object): void }} Backend
+ */
+
+function _isProduction () {
+  return process.env.NODE_ENV === 'production'
+}
+
+/** Built-in fallback backend — always active unless explicitly replaced. */
+const _defaultBackend = {
+  info (ns, msg, ctx) {
+    if (_isProduction()) {
+      process.stdout.write(JSON.stringify({ level: 'info', namespace: ns, message: msg, ...ctx, timestamp: new Date().toISOString() }) + '\n')
+    } else {
+      console.log(`[${ns}] ${msg}`, ctx ?? '')
+    }
+  },
+  warn (ns, msg, ctx) {
+    if (_isProduction()) {
+      process.stdout.write(JSON.stringify({ level: 'warn', namespace: ns, message: msg, ...ctx, timestamp: new Date().toISOString() }) + '\n')
+    } else {
+      console.warn(`[${ns}] ${msg}`, ctx ?? '')
+    }
+  },
+  error (ns, msg, ctx, err) {
+    if (_isProduction()) {
+      const entry = { level: 'error', namespace: ns, message: msg, ...ctx, timestamp: new Date().toISOString() }
+      if (err) entry.error = err.stack ?? err.message
+      process.stderr.write(JSON.stringify(entry) + '\n')
+    } else {
+      console.error(`[${ns}] ${msg}`, ctx ?? '', err ?? '')
+    }
+  },
+  debug (ns, msg, ctx) {
+    if (_isProduction()) return
+    console.debug(`[${ns}] ${msg}`, ctx ?? '')
+  },
+}
+
+_backends.push(_defaultBackend)
+
+/**
+ * Add a backend to the fan-out list.
+ * All registered backends receive every log call.
+ * @param {Backend} backend
+ */
+export function registerBackend (backend) {
+  _backends.push(backend)
+}
+
+/**
+ * Remove all currently registered backends.
+ * Useful when replacing the default with a custom console integration.
+ */
+export function clearBackends () {
+  _backends.length = 0
+}
+
+/**
+ * Create a logger bound to the given namespace.
+ * @param {string} namespace
+ * @returns {{ info(msg: string, ctx?: object): void, warn(msg: string, ctx?: object): void, error(msg: string, ctx?: object, err?: Error): void, debug(msg: string, ctx?: object): void }}
+ */
+export function createLogger (namespace) {
+  return {
+    info (message, context) {
+      for (const b of _backends) b.info(namespace, message, context)
+    },
+    warn (message, context) {
+      for (const b of _backends) b.warn(namespace, message, context)
+    },
+    error (message, context, error) {
+      for (const b of _backends) b.error(namespace, message, context, error)
+    },
+    debug (message, context) {
+      for (const b of _backends) b.debug(namespace, message, context)
+    },
+  }
+}

package/src/sentry.integration.js

@@ -0,0 +1,41 @@
+/**
+ * Sentry backend for @ossy/observability.
+ *
+ * Forwards `error`-level log calls to Sentry via captureException.
+ * info / warn / debug are no-ops in this backend.
+ *
+ * Required credentials: SENTRY_DSN
+ */
+
+export const id = 'logger-sentry'
+export const credentials = ['SENTRY_DSN']
+
+/**
+ * @param {{ env: NodeJS.ProcessEnv }} opts
+ * @returns {Promise<import('./logger.js').Backend>}
+ */
+export async function connect ({ env }) {
+  const Sentry = await import('@sentry/node')
+
+  Sentry.init({
+    dsn: env.SENTRY_DSN,
+    environment: env.NODE_ENV ?? 'development',
+  })
+
+  return {
+    info: () => {},
+    warn: () => {},
+    error: (_ns, msg, ctx, err) => {
+      if (err instanceof Error) {
+        Sentry.withScope((scope) => {
+          if (ctx) scope.setContext('log', ctx)
+          scope.setExtra('message', msg)
+          Sentry.captureException(err)
+        })
+      } else {
+        Sentry.captureMessage(msg, { level: 'error', extra: ctx })
+      }
+    },
+    debug: () => {},
+  }
+}