Documentación de Estiaje

El SDK oficial: Instalar, tu primer evento y, para el hilo entre servicios, Contexto y linaje.

Copia estiaje.py a tu proyecto. Python 3.8 o superior.

# estiaje.py: copia este archivo a tu proyecto. Sin dependencias.
import contextvars, json, os, re, secrets, threading, urllib.request

URL = (os.environ.get("ESTIAJE_URL") or "https://estiaje.mx") + "/v1/events"
SERVICIO = "mi-api"
_hilo = contextvars.ContextVar("estiaje_hilo", default=None)
_envios = []
_TP = re.compile(r"^[0-9a-f]{2}-([0-9a-f]{32})-[0-9a-f]{16}-[0-9a-f]{2}$")


def empezar_hilo(traceparent=None):
    """Al entrar una petición: toma el hilo de la cabecera o crea uno nuevo."""
    m = _TP.match((traceparent or "").strip().lower())
    hilo = m.group(1) if m and m.group(1) != "0" * 32 else secrets.token_hex(16)
    _hilo.set(hilo)
    return hilo


def traceparent():
    """Para las llamadas que salen a otro servicio: el mismo hilo, un paso nuevo."""
    return "00-%s-%s-01" % (_hilo.get() or secrets.token_hex(16), secrets.token_hex(8))


def evento(name, attrs=None, kind="event"):
    """Manda el evento en segundo plano: nunca frena ni rompe tu app."""
    if not os.environ.get("ESTIAJE_TOKEN"):
        return  # sin llave no sale nada por la red
    ev = {"service": SERVICIO, "kind": kind, "name": name, "attrs": attrs or {}}
    if _hilo.get():
        ev["trace_id"] = _hilo.get()
    envio = threading.Thread(target=_mandar, args=([ev],))
    envio.start()
    _envios[:] = [e for e in _envios if e.is_alive()] + [envio]


def esperar():
    """En una lambda, antes de devolver: que salga lo pendiente (2 s como máximo)."""
    for e in list(_envios):
        e.join()


def _mandar(lote):
    try:
        req = urllib.request.Request(URL, data=json.dumps(lote).encode(), headers={
            "content-type": "application/json",
            "authorization": "Bearer " + os.environ["ESTIAJE_TOKEN"]})
        urllib.request.urlopen(req, timeout=2).close()
    except Exception:
        pass  # si Estiaje no contesta, tu app sigue

Donde pase algo:

import estiaje

estiaje.evento("pedido.creado", {"order_id": pedido.id, "monto": pedido.total})

Django: el hilo, en un middleware.

# miapp/middleware.py  (y en settings.MIDDLEWARE: "miapp.middleware.hilo_estiaje")
import estiaje

def hilo_estiaje(get_response):
    def middleware(request):
        estiaje.empezar_hilo(request.headers.get("traceparent"))
        return get_response(request)
    return middleware

Flask:

@app.before_request
def hilo_estiaje():
    estiaje.empezar_hilo(request.headers.get("traceparent"))

FastAPI: el hilo en un middleware, y el evento con BackgroundTasks para que salga después de responder.

from fastapi import BackgroundTasks, FastAPI, Request
import estiaje

app = FastAPI()

@app.middleware("http")
async def hilo_estiaje(request: Request, call_next):
    estiaje.empezar_hilo(request.headers.get("traceparent"))
    return await call_next(request)

@app.post("/pedidos")
async def crear(p: Pedido, tareas: BackgroundTasks):
    ...
    tareas.add_task(estiaje.evento, "pedido.creado", {"order_id": p.id, "monto": p.total})

Al llamar a otro de tus servicios, pasa el hilo:

requests.get(url, headers={"traceparent": estiaje.traceparent()}, timeout=5)

En un script o un cron no hace falta nada más: Python espera el envío antes de salir.

Copia estiaje.php a tu proyecto. PHP 7.4 o superior, con la extensión curl. Los eventos se juntan y se mandan al final, cuando tu usuario ya tiene su respuesta (con PHP-FPM).

<?php
// estiaje.php: cópialo a tu proyecto (en Laravel, app/Estiaje.php). Sin dependencias.
final class Estiaje
{
    const SERVICIO = 'mi-api';
    private static ?string $hilo = null;
    private static array $lote = [];

    /** Al entrar una petición: toma el hilo de la cabecera o crea uno nuevo. */
    public static function empezarHilo(?string $traceparent): string
    {
        $tp = strtolower(trim((string) $traceparent));
        $ok = preg_match('/^[0-9a-f]{2}-([0-9a-f]{32})-[0-9a-f]{16}-[0-9a-f]{2}$/', $tp, $m);
        self::$hilo = $ok && $m[1] !== str_repeat('0', 32) ? $m[1] : bin2hex(random_bytes(16));
        return self::$hilo;
    }

    /** Para las llamadas que salen a otro servicio: el mismo hilo, un paso nuevo. */
    public static function traceparent(): string
    {
        return '00-' . (self::$hilo ?? bin2hex(random_bytes(16))) . '-' . bin2hex(random_bytes(8)) . '-01';
    }

    /** Junta el evento; se manda al final, ya que tu usuario tiene su respuesta. */
    public static function evento(string $name, array $attrs = [], string $kind = 'event'): void
    {
        if (!getenv('ESTIAJE_TOKEN')) return; // sin llave no sale nada por la red
        $ev = ['service' => self::SERVICIO, 'kind' => $kind, 'name' => $name, 'attrs' => (object) $attrs];
        if (self::$hilo) $ev['trace_id'] = self::$hilo;
        if (!self::$lote) register_shutdown_function([self::class, 'mandar']);
        self::$lote[] = $ev;
    }

    public static function mandar(): void
    {
        if (function_exists('fastcgi_finish_request')) fastcgi_finish_request();
        $lote = self::$lote;
        self::$lote = [];
        if (!$lote) return;
        $ch = curl_init((getenv('ESTIAJE_URL') ?: 'https://estiaje.mx') . '/v1/events');
        curl_setopt_array($ch, [
            CURLOPT_POST => true,
            CURLOPT_HTTPHEADER => ['content-type: application/json',
                                   'authorization: Bearer ' . getenv('ESTIAJE_TOKEN')],
            CURLOPT_POSTFIELDS => json_encode($lote),
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_CONNECTTIMEOUT_MS => 1000,
            CURLOPT_TIMEOUT_MS => 2000,
        ]);
        curl_exec($ch); // si Estiaje no contesta, tu app sigue
    }
}

Donde pase algo:

Estiaje::evento('pedido.creado', ['order_id' => $pedido->id, 'monto' => $pedido->total]);

Laravel: el hilo, en un middleware.

// app/Http/Middleware/HiloEstiaje.php
namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class HiloEstiaje
{
    public function handle(Request $request, Closure $next)
    {
        \Estiaje::empezarHilo($request->header('traceparent'));
        return $next($request);
    }
}

// bootstrap/app.php (Laravel 11+; antes, en $middleware de app/Http/Kernel.php)
->withMiddleware(fn ($middleware) => $middleware->append(\App\Http\Middleware\HiloEstiaje::class))

Al llamar a otro de tus servicios con el cliente de Laravel, pasa el hilo:

Http::withHeaders(['traceparent' => \Estiaje::traceparent()])->get($url);

¿Prefieres mandar el evento con el cliente de Laravel? Que salga después de responder:

// en config/services.php: 'estiaje' => ['token' => env('ESTIAJE_TOKEN')]
dispatch(fn () => Http::timeout(2)->withToken(config('services.estiaje.token'))
    ->post('https://estiaje.mx/v1/events', [[
        'service' => 'mi-api', 'kind' => 'event', 'name' => 'pedido.creado',
        'attrs' => ['order_id' => $pedido->id, 'monto' => $pedido->total],
    ]]))->afterResponse();

estiaje.php lee la llave con getenv. Con php artisan config:cache, Laravel ya no carga el .env: pon ESTIAJE_TOKEN como variable del servidor.

WordPress, en tu plugin o en functions.php:

require_once __DIR__ . '/estiaje.php';
add_action('init', fn () => Estiaje::empezarHilo($_SERVER['HTTP_TRACEPARENT'] ?? null));

// al llamar a otro servicio
wp_remote_get($url, ['headers' => ['traceparent' => Estiaje::traceparent()]]);

Copia Estiaje.java a tu proyecto. Java 17 o superior.

// Estiaje.java: cópialo a tu proyecto (con tu package). Sin dependencias, Java 17+.
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.security.SecureRandom;
import java.time.Duration;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public final class Estiaje {
    static final String SERVICIO = "mi-api";
    static final String TOKEN = System.getenv("ESTIAJE_TOKEN");
    static final String BASE = System.getenv("ESTIAJE_URL");
    static final String URL = (BASE == null || BASE.isEmpty() ? "https://estiaje.mx" : BASE) + "/v1/events";
    static final HttpClient HTTP = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(1)).build();
    static final ThreadLocal<String> HILO = new ThreadLocal<>();
    static final Pattern TP = Pattern.compile("^[0-9a-f]{2}-([0-9a-f]{32})-[0-9a-f]{16}-[0-9a-f]{2}$");
    static final SecureRandom AZAR = new SecureRandom();

    /** Al entrar una petición: toma el hilo de la cabecera o crea uno nuevo. */
    public static String empezarHilo(String traceparent) {
        Matcher m = TP.matcher(traceparent == null ? "" : traceparent.trim().toLowerCase());
        String hilo = m.matches() && !m.group(1).equals("0".repeat(32)) ? m.group(1) : hex(16);
        HILO.set(hilo);
        return hilo;
    }

    /** Al terminar la petición: el hilo de Java se reusa para la siguiente. */
    public static void terminarHilo() {
        HILO.remove();
    }

    /** Para las llamadas que salen a otro servicio: el mismo hilo, un paso nuevo. */
    public static String traceparent() {
        String hilo = HILO.get();
        return "00-" + (hilo != null ? hilo : hex(16)) + "-" + hex(8) + "-01";
    }

    /** Manda el evento en segundo plano: nunca frena ni rompe tu app. */
    public static CompletableFuture<Void> evento(String name, Map<String, ?> attrs) {
        try {
            if (TOKEN == null || TOKEN.isEmpty()) return CompletableFuture.completedFuture(null);
            StringBuilder j = new StringBuilder("[{\"service\":" + q(SERVICIO) + ",\"kind\":\"event\",\"name\":" + q(name));
            if (HILO.get() != null) j.append(",\"trace_id\":").append(q(HILO.get()));
            j.append(",\"attrs\":{");
            String coma = "";
            for (Map.Entry<String, ?> a : attrs.entrySet()) {
                Object v = a.getValue();
                j.append(coma).append(q(a.getKey())).append(':')
                 .append(v instanceof Number || v instanceof Boolean ? v.toString() : q(String.valueOf(v)));
                coma = ",";
            }
            j.append("}}]");
            HttpRequest req = HttpRequest.newBuilder(URI.create(URL)).timeout(Duration.ofSeconds(2))
                .header("content-type", "application/json")
                .header("authorization", "Bearer " + TOKEN)
                .POST(HttpRequest.BodyPublishers.ofString(j.toString())).build();
            return HTTP.sendAsync(req, HttpResponse.BodyHandlers.discarding()).handle((r, e) -> null);
        } catch (RuntimeException e) {
            return CompletableFuture.completedFuture(null); // si algo falla, tu app sigue
        }
    }

    static String q(String s) {
        StringBuilder b = new StringBuilder("\"");
        for (char c : s.toCharArray()) {
            if (c == '"' || c == '\\') b.append('\\').append(c);
            else if (c < 0x20) b.append(String.format("\\u%04x", (int) c));
            else b.append(c);
        }
        return b.append('"').toString();
    }

    static String hex(int bytes) {
        byte[] b = new byte[bytes];
        AZAR.nextBytes(b);
        StringBuilder s = new StringBuilder();
        for (byte x : b) s.append(String.format("%02x", x));
        return s.toString();
    }
}

Donde pase algo:

Estiaje.evento("pedido.creado", Map.of("order_id", pedido.getId(), "monto", pedido.getTotal()));

Spring Boot: el hilo, en un filtro.

@Component
public class HiloEstiaje extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain chain)
            throws ServletException, IOException {
        Estiaje.empezarHilo(req.getHeader("traceparent"));
        try {
            chain.doFilter(req, res);
        } finally {
            Estiaje.terminarHilo();
        }
    }
}

Al llamar a otro de tus servicios (con RestClient), pasa el hilo:

RestClient http = RestClient.builder()
    .requestInterceptor((req, cuerpo, sigue) -> {
        req.getHeaders().set("traceparent", Estiaje.traceparent());
        return sigue.execute(req, cuerpo);
    })
    .build();

En un programa que termina enseguida, espera el envío: Estiaje.evento(…).join().

Copia Estiaje.cs a tu proyecto. .NET 6 o superior.

// Estiaje.cs: cópialo a tu proyecto. Sin paquetes, .NET 6 o superior.
using System.Net.Http.Json;
using System.Security.Cryptography;
using System.Text.RegularExpressions;

public static class Estiaje
{
    const string Servicio = "mi-api";
    static readonly HttpClient Http = new() { Timeout = TimeSpan.FromSeconds(2) };
    static readonly string Base = Environment.GetEnvironmentVariable("ESTIAJE_URL") ?? "";
    static readonly string Url = (Base.Length > 0 ? Base : "https://estiaje.mx") + "/v1/events";
    static readonly AsyncLocal<string?> Hilo = new();
    static readonly Regex Formato = new("^[0-9a-f]{2}-([0-9a-f]{32})-[0-9a-f]{16}-[0-9a-f]{2}$");

    /// Al entrar una petición: toma el hilo de la cabecera o crea uno nuevo.
    public static string EmpezarHilo(string? traceparent)
    {
        var m = Formato.Match((traceparent ?? "").Trim().ToLowerInvariant());
        Hilo.Value = m.Success && m.Groups[1].Value != new string('0', 32) ? m.Groups[1].Value : Azar(16);
        return Hilo.Value;
    }

    /// Para las llamadas que salen a otro servicio: el mismo hilo, un paso nuevo.
    public static string Traceparent() => $"00-{Hilo.Value ?? Azar(16)}-{Azar(8)}-01";

    /// Manda el evento en segundo plano: nunca frena ni rompe tu app. No hace falta esperarlo.
    public static Task Evento(string name, object? attrs = null)
    {
        var token = Environment.GetEnvironmentVariable("ESTIAJE_TOKEN");
        if (string.IsNullOrEmpty(token)) return Task.CompletedTask; // sin llave no sale nada
        var ev = new Dictionary<string, object?>
        {
            ["service"] = Servicio, ["kind"] = "event", ["name"] = name, ["attrs"] = attrs ?? new { },
        };
        if (Hilo.Value is { } hilo) ev["trace_id"] = hilo;
        var req = new HttpRequestMessage(HttpMethod.Post, Url) { Content = JsonContent.Create(new[] { ev }) };
        req.Headers.TryAddWithoutValidation("authorization", "Bearer " + token);
        return Http.SendAsync(req).ContinueWith(t => // si Estiaje no contesta, tu app sigue
        {
            if (t.IsCompletedSuccessfully) t.Result.Dispose(); else _ = t.Exception;
        });
    }

    static string Azar(int bytes) => Convert.ToHexString(RandomNumberGenerator.GetBytes(bytes)).ToLowerInvariant();
}

/// Pone traceparent en lo que sale por un HttpClient hacia tus otros servicios.
public class EstiajeSaliente : DelegatingHandler
{
    protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage req, CancellationToken ct)
    {
        req.Headers.Remove("traceparent");
        req.Headers.TryAddWithoutValidation("traceparent", Estiaje.Traceparent());
        return base.SendAsync(req, ct);
    }
}

En Program.cs: el hilo en un middleware, y que tus HttpClient lo pasen a tus otros servicios.

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddTransient<EstiajeSaliente>();
builder.Services.AddHttpClient("inventario").AddHttpMessageHandler<EstiajeSaliente>();
var app = builder.Build();

app.Use(async (ctx, next) =>
{
    Estiaje.EmpezarHilo(ctx.Request.Headers["traceparent"]);
    await next();
});

Donde pase algo (no hace falta await):

Estiaje.Evento("pedido.creado", new { order_id = pedido.Id, monto = pedido.Total });

En una app de consola que termina enseguida, sí espéralo: await Estiaje.Evento(…).

Copia estiaje.go a tu proyecto, en su paquete estiaje. Go 1.18 o superior.

// estiaje.go: cópialo a tu proyecto (paquete estiaje). Sin dependencias.
package estiaje

import (
	"bytes"
	"context"
	"crypto/rand"
	"encoding/hex"
	"encoding/json"
	"net/http"
	"os"
	"regexp"
	"strings"
	"sync"
	"time"
)

const servicio = "mi-api"

var (
	cliente    = &http.Client{Timeout: 2 * time.Second}
	formato    = regexp.MustCompile(`^[0-9a-f]{2}-([0-9a-f]{32})-[0-9a-f]{16}-[0-9a-f]{2}$`)
	pendientes sync.WaitGroup
)

type claveHilo struct{}

// ConHilo: al entrar una petición, toma el hilo de la cabecera o crea uno nuevo.
func ConHilo(ctx context.Context, traceparent string) context.Context {
	hilo := azar(16)
	if m := formato.FindStringSubmatch(strings.ToLower(strings.TrimSpace(traceparent))); m != nil && m[1] != strings.Repeat("0", 32) {
		hilo = m[1]
	}
	return context.WithValue(ctx, claveHilo{}, hilo)
}

// Middleware para net/http (sirve igual con chi o gorilla/mux).
func Middleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		next.ServeHTTP(w, r.WithContext(ConHilo(r.Context(), r.Header.Get("traceparent"))))
	})
}

func Hilo(ctx context.Context) string {
	h, _ := ctx.Value(claveHilo{}).(string)
	return h
}

// Traceparent: para las llamadas que salen a otro servicio. El mismo hilo, un paso nuevo.
func Traceparent(ctx context.Context) string {
	h := Hilo(ctx)
	if h == "" {
		h = azar(16)
	}
	return "00-" + h + "-" + azar(8) + "-01"
}

// Transporte pone traceparent en todo lo que sale por un http.Client:
// &http.Client{Transport: estiaje.Transporte{}}, y la petición con su ctx.
type Transporte struct{ Base http.RoundTripper }

func (t Transporte) RoundTrip(r *http.Request) (*http.Response, error) {
	r = r.Clone(r.Context())
	r.Header.Set("traceparent", Traceparent(r.Context()))
	if t.Base == nil {
		return http.DefaultTransport.RoundTrip(r)
	}
	return t.Base.RoundTrip(r)
}

// Evento lo manda en segundo plano: nunca frena ni rompe tu app.
func Evento(ctx context.Context, name string, attrs map[string]any) {
	token := os.Getenv("ESTIAJE_TOKEN")
	if token == "" {
		return // sin llave no sale nada por la red
	}
	if attrs == nil {
		attrs = map[string]any{}
	}
	ev := map[string]any{"service": servicio, "kind": "event", "name": name, "attrs": attrs}
	if h := Hilo(ctx); h != "" {
		ev["trace_id"] = h
	}
	cuerpo, err := json.Marshal([]any{ev})
	if err != nil {
		return
	}
	url := os.Getenv("ESTIAJE_URL")
	if url == "" {
		url = "https://estiaje.mx"
	}
	pendientes.Add(1)
	go func() {
		defer pendientes.Done()
		req, err := http.NewRequest("POST", url+"/v1/events", bytes.NewReader(cuerpo))
		if err != nil {
			return
		}
		req.Header.Set("content-type", "application/json")
		req.Header.Set("authorization", "Bearer "+token)
		if res, err := cliente.Do(req); err == nil {
			res.Body.Close()
		}
	}()
}

// Esperar: en un programa que termina enseguida (un cron), llámalo antes de salir.
func Esperar() { pendientes.Wait() }

func azar(n int) string {
	b := make([]byte, n)
	rand.Read(b)
	return hex.EncodeToString(b)
}

net/http (y chi, gorilla/mux): envuelve tu router, y usa el Transporte para lo que sale.

http.ListenAndServe(":8080", estiaje.Middleware(mux))

// donde pase algo, con el contexto de la petición
estiaje.Evento(r.Context(), "pedido.creado", map[string]any{"order_id": p.ID, "monto": p.Total})

// al llamar a otro de tus servicios
cliente := &http.Client{Transport: estiaje.Transporte{}}
req, _ := http.NewRequestWithContext(r.Context(), "GET", url, nil)
cliente.Do(req)

Gin:

r.Use(func(c *gin.Context) {
    c.Request = c.Request.WithContext(estiaje.ConHilo(c.Request.Context(), c.GetHeader("traceparent")))
    c.Next()
})

En un programa que termina enseguida (un cron), llama estiaje.Esperar() antes de salir.

Copia estiaje.rb a tu proyecto. Ruby 2.7 o superior, sin gemas.

# estiaje.rb: cópialo a tu proyecto (en Rails, lib/estiaje.rb). Sin gemas.
require "json"
require "net/http"
require "securerandom"

module Estiaje
  SERVICIO = "mi-api"
  FORMATO = /\A[0-9a-f]{2}-([0-9a-f]{32})-[0-9a-f]{16}-[0-9a-f]{2}\z/
  @envios = []
  @candado = Mutex.new

  # Al entrar una petición: toma el hilo de la cabecera o crea uno nuevo.
  def self.empezar_hilo(traceparent)
    m = FORMATO.match(traceparent.to_s.strip.downcase)
    Thread.current[:estiaje_hilo] = m && m[1] != "0" * 32 ? m[1] : SecureRandom.hex(16)
  end

  def self.hilo
    Thread.current[:estiaje_hilo]
  end

  # Para las llamadas que salen a otro servicio: el mismo hilo, un paso nuevo.
  def self.traceparent
    "00-#{hilo || SecureRandom.hex(16)}-#{SecureRandom.hex(8)}-01"
  end

  # Manda el evento en segundo plano: nunca frena ni rompe tu app.
  def self.evento(name, attrs = {}, kind: "event")
    token = ENV["ESTIAJE_TOKEN"].to_s
    return if token.empty? # sin llave no sale nada por la red
    ev = { service: SERVICIO, kind: kind, name: name, attrs: attrs }
    ev[:trace_id] = hilo if hilo
    base = ENV["ESTIAJE_URL"].to_s.empty? ? "https://estiaje.mx" : ENV["ESTIAJE_URL"]
    envio = Thread.new do
      uri = URI("#{base}/v1/events")
      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
                      open_timeout: 1, read_timeout: 2, write_timeout: 2) do |http|
        http.post(uri.path, [ev].to_json,
                  "content-type" => "application/json", "authorization" => "Bearer #{token}")
      end
    rescue StandardError
      nil # si Estiaje no contesta, tu app sigue
    end
    @candado.synchronize { @envios.select!(&:alive?); @envios << envio }
  end

  # En un script que termina enseguida (un cron, un rake), llámalo antes de salir.
  def self.esperar
    @candado.synchronize { @envios.dup }.each(&:join)
  end

  # El middleware de Rack: Rails, Sinatra, Hanami.
  class Middleware
    def initialize(app)
      @app = app
    end

    def call(env)
      Estiaje.empezar_hilo(env["HTTP_TRACEPARENT"])
      @app.call(env)
    ensure
      Thread.current[:estiaje_hilo] = nil
    end
  end
end

Rails, en config/application.rb (en Sinatra: use Estiaje::Middleware):

require_relative "../lib/estiaje"
# …dentro de class Application:
config.middleware.use Estiaje::Middleware

Donde pase algo, y al llamar a otro de tus servicios:

Estiaje.evento("pedido.creado", { order_id: pedido.id, monto: pedido.total })

req = Net::HTTP::Get.new(uri)
req["traceparent"] = Estiaje.traceparent

En un script o una tarea de rake, llama Estiaje.esperar antes de salir.

Una función serverless se congela en cuanto devuelve su respuesta, y lo que estaba por salir se queda sin salir. Por eso, aquí sí se espera el envío al final.

• Vercel y Lambda con Node: await estiaje.flush() antes de devolver la respuesta.
• Lambda con las recetas de arriba: estiaje.esperar() en Python, estiaje.Esperar() en Go, Estiaje.esperar en Ruby, .join() en Java y await en C#.
• Cloudflare Workers: ctx.waitUntil deja que el envío termine después de responder, sin hacer esperar a tu usuario.

export default {
  async fetch(request, env, ctx) {
    // el hilo: el de la cabecera traceparent, o uno nuevo
    const m = /^[0-9a-f]{2}-([0-9a-f]{32})-/.exec(request.headers.get('traceparent') ?? '');
    const trace_id = m ? m[1] : crypto.randomUUID().replaceAll('-', '');

    ctx.waitUntil(fetch('https://estiaje.mx/v1/events', {
      method: 'POST',
      headers: { 'content-type': 'application/json', authorization: `Bearer ${env.ESTIAJE_TOKEN}` },
      body: JSON.stringify([{ service: 'mi-worker', kind: 'event', name: 'pedido.creado', trace_id }]),
    }).catch(() => {}));  // si Estiaje no contesta, tu worker sigue

    return new Response('ok');
  },
};

Un paso de petición HTTP al final de tu flujo: en n8n, el nodo HTTP Request; en Make, HTTP › Make a request; en Zapier, Webhooks by Zapier › Custom Request.

[{"service": "n8n", "kind": "event", "name": "pedido.creado",
  "attrs": {"order_id": "{{ $json.id }}", "monto": {{ $json.total }}}}]

La llave guárdala en las credenciales de la herramienta, no escrita en el paso. Marca el paso para que siga aunque falle: si Estiaje no contesta, tu flujo no se detiene.

Una línea al final de tu pipeline avisa de cada despliegue, con quién y qué: npx @estiaje/sdk desplegado. Funciona sin importar en qué lenguaje esté tu servicio. Los detalles, en Despliegues.