Effect TS

// TypeScript: scattered console.log, no structure
function processOrder(order: Order) {
  console.log("Processing order", order.id)
  try {
    const result = chargeCard(order)
    console.log("Order processed", order.id, result)
    return result
  } catch (err) {
    console.error("Order failed", order.id, err)
    throw err
  }
}

// Want structured JSON logs? Install winston/pino,
// create a logger instance, pass it everywhere,
// update every call site...

import { Effect, Logger, LogLevel } from "effect"

// ── Logging is an Effect — it composes naturally ──
const processOrder = (order: Order) =>
  Effect.gen(function* () {
    yield* Effect.log("Processing order")
    const result = yield* chargeCard(order)
    yield* Effect.log("Order processed")
    return result
  }).pipe(
    // annotations flow to ALL logs inside this scope
    Effect.annotateLogs("orderId", order.id),
    Effect.annotateLogs("customer", order.customerId),
    // timing span — logs show elapsed time
    Effect.withLogSpan("processOrder")
  )

// ── Swap the logger without touching application code ──
// Dev: default pretty logger
// Test: silence everything
const testProgram = processOrder(order).pipe(
  Effect.provide(Logger.none)
)
// Prod: set minimum level
const prodProgram = processOrder(order).pipe(
  Logger.withMinimumLogLevel(LogLevel.Warning)
)

// TypeScript: manual OpenTelemetry instrumentation
import { trace } from "@opentelemetry/api"

const tracer = trace.getTracer("my-service")

async function processOrder(order: Order) {
  // manual span creation — verbose and error-prone
  const span = tracer.startSpan("processOrder")
  span.setAttribute("orderId", order.id)
  try {
    const result = await chargeCard(order)
    span.setStatus({ code: SpanStatusCode.OK })
    return result
  } catch (err) {
    span.setStatus({ code: SpanStatusCode.ERROR })
    span.recordException(err)
    throw err
  } finally {
    span.end() // easy to forget!
  }
}

// Metrics: yet another library, separate API
import { metrics } from "@opentelemetry/api"
const counter = metrics.getMeter("my-service")
  .createCounter("orders_processed")
counter.add(1, { status: "success" })

import { Effect, Metric } from "effect"

// ── Tracing: just wrap with withSpan ──
// Attributes live OUTSIDE the business logic via withSpan options
const processOrder = (order: Order) =>
  Effect.gen(function* () {
    const result = yield* chargeCard(order)
    return result
  }).pipe(
    Effect.withSpan("processOrder", {
      attributes: { orderId: order.id, amount: order.amount }
    })
  )

// Use annotateCurrentSpan only when the value is computed INSIDE the generator
const processOrderDynamic = Effect.gen(function* () {
  const result = yield* chargeCard(order)
  // value only known after chargeCard — must annotate here
  yield* Effect.annotateCurrentSpan("transactionId", result.txId)
  return result
}).pipe(Effect.withSpan("processOrder"))

// Nested spans create parent-child traces automatically
const handleRequest = (req: Request) =>
  Effect.gen(function* () {
    const order = yield* parseOrder(req)  // no span
    const result = yield* processOrder(order) // child span
    yield* sendConfirmation(order)        // no span
    return result
  }).pipe(Effect.withSpan("handleRequest")) // parent span

// ── Metrics: declare once, use in pipelines ──
const orderCounter = Metric.counter("orders_processed")
const latencyHistogram = Metric.histogram("order_latency_ms", {
  boundaries: [10, 50, 100, 500, 1000]
})

// Increment counter on each order
const countedOrder = processOrder(order).pipe(
  Metric.increment(orderCounter)
)

// Track timing with histogram
const timedOrder = processOrder(order).pipe(
  Metric.trackDuration(latencyHistogram)
)