Transport Adapters

import { LoggerTransportAdapter } from "@igniter-js/telemetry/adapters";

const logger = LoggerTransportAdapter.create({
  logger: console,
  format: "json",           // "json" | "pretty"
  minLevel: "info",         // Minimum level to log
  includeTimestamp: true,   // Include ISO timestamp
});

// JSON format output
const jsonLogger = LoggerTransportAdapter.create({
  logger: console,
  format: "json",
});

// Filter to errors only
const errorLogger = LoggerTransportAdapter.create({
  logger: console,
  format: "pretty",
  minLevel: "error",
});

import { HttpTransportAdapter } from "@igniter-js/telemetry/adapters";

const http = HttpTransportAdapter.create({
  url: "https://webhook.example.com/telemetry",
  headers: {
    Authorization: `Bearer ${process.env.TELEMETRY_TOKEN}`,
    "X-Service-Name": "billing-api",
  },
  timeout: 4000,    // Request timeout in ms
  retries: 2,       // Number of retries on failure
});

import { OtlpTransportAdapter } from "@igniter-js/telemetry/adapters";

const otlp = OtlpTransportAdapter.create({
  url: "http://localhost:4318/v1/logs",
  headers: {
    "x-api-key": process.env.OTEL_API_KEY ?? "",
  },
});

import * as Sentry from "@sentry/node";
import { SentryTransportAdapter } from "@igniter-js/telemetry/adapters";

Sentry.init({ dsn: process.env.SENTRY_DSN });

const sentry = SentryTransportAdapter.create({
  sentry: Sentry,
});

import { SlackTransportAdapter } from "@igniter-js/telemetry/adapters";

const slack = SlackTransportAdapter.create({
  webhookUrl: process.env.SLACK_WEBHOOK_URL ?? "",
  minLevel: "error",                    // Only error+ events
  username: "Igniter Bot",
  iconEmoji: ":rotating_light:",
});

import { DiscordTransportAdapter } from "@igniter-js/telemetry/adapters";

const discord = DiscordTransportAdapter.create({
  webhookUrl: process.env.DISCORD_WEBHOOK_URL ?? "",
  minLevel: "warn",
  username: "Igniter Bot",
  avatarUrl: "https://example.com/bot-avatar.png",
});

import { TelegramTransportAdapter } from "@igniter-js/telemetry/adapters";

const telegram = TelegramTransportAdapter.create({
  botToken: process.env.TELEGRAM_BOT_TOKEN ?? "",
  chatId: process.env.TELEGRAM_CHAT_ID ?? "",
  minLevel: "error",
});

import { InMemoryTransportAdapter } from "@igniter-js/telemetry/adapters";

const memory = InMemoryTransportAdapter.create();

const telemetry = IgniterTelemetry.create()
  .withService("test")
  .addTransport(memory)
  .build();

telemetry.emit("test.event.one", {
  attributes: { "ctx.value": 1 },
});
telemetry.emit("test.event.two", {
  attributes: { "ctx.value": 2 },
});

// Inspect captured events
const events = memory.getEvents();
console.log(events.length);       // 2
console.log(events[0].name);      // "test.event.one"
console.log(events[0].attributes); // { "ctx.value": 1 }

// Clear events
memory.clear();

import { MockTelemetryAdapter } from "@igniter-js/telemetry/adapters";

const mock = MockTelemetryAdapter.create();

const telemetry = IgniterTelemetry.create()
  .withService("test")
  .addTransport(mock)
  .build();

telemetry.emit("user.created", {
  attributes: { "ctx.user.id": "usr_001" },
});

// Assertions
expect(mock.getLastEvent()?.name).toBe("user.created");
expect(mock.getLastEvent()?.attributes).toEqual({
  "ctx.user.id": "usr_001",
});

import { IgniterStore } from "@igniter-js/store";
import { StoreStreamTransportAdapter } from "@igniter-js/telemetry/adapters";

const store = IgniterStore.create()
  .withAdapter(redisAdapter)
  .withNamespace("telemetry")
  .build();

const storeTransport = StoreStreamTransportAdapter.create({
  store,
  stream: "telemetry:events",
  maxLen: 10000,   // Max stream length (capped)
});

const telemetry = IgniterTelemetry.create()
  .withService("api")
  .addTransport(LoggerTransportAdapter.create({ logger: console }))
  .addTransport(HttpTransportAdapter.create({ url: "https://..." }))
  .addTransport(SentryTransportAdapter.create({ sentry: Sentry }))
  .addTransport(SlackTransportAdapter.create({ webhookUrl: "..." }))
  .build();

// All four transports receive every event
telemetry.emit("payment.failed", {
  level: "error",
  error: { name: "PaymentError", message: "..." },
});

import type {
  IgniterTelemetryTransportAdapter,
  IgniterTelemetryEnvelope,
  IgniterTelemetryTransportMeta,
} from "@igniter-js/telemetry";

class DatadogTransport implements IgniterTelemetryTransportAdapter {
  readonly type = "datadog" as const;

  async init(meta: IgniterTelemetryTransportMeta): Promise<void> {
    // Optional: validate API key, open connection
    console.log(`Datadog transport initialized for ${meta.service}`);
  }

  async handle(envelope: IgniterTelemetryEnvelope): Promise<void> {
    await fetch("https://http-intake.logs.datadoghq.com/api/v2/logs", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "DD-API-KEY": process.env.DD_API_KEY!,
      },
      body: JSON.stringify({
        ddsource: envelope.service,
        ddtags: `env:${envelope.environment}`,
        service: envelope.service,
        message: envelope.name,
        ...envelope,
      }),
    });
  }

  async flush(): Promise<void> {
    // Optional: flush any buffered events
  }

  async shutdown(): Promise<void> {
    // Optional: close connections, cleanup
  }
}

// Use it
const telemetry = IgniterTelemetry.create()
  .withService("api")
  .addTransport(new DatadogTransport())
  .build();