Live request-log tail

GET /api/v1/logs/tail opens a Server-Sent Events (SSE) connection that streams every API request handled for your tenant, sub-second after each response completes. It is the data source behind the Live tail toggle on the developer Request Logs page, and you can consume it directly from your own tooling. The stream excludes health, readiness, and metrics probes, as well as the tail endpoint itself. Base path: /api/v1/logs/tail Authentication: API key (X-API-Key) or session JWT. The caller must hold the owner, admin, or developer role.

Using the SDKs

Prefer the typed client, but this page’s endpoint has no helper yet — the generic request() keeps auth/retries and the { data, meta } envelope identical:

import { Orbit } from "@devotel-orbit/node";

const orbit = new Orbit({ apiKey: process.env.ORBIT_API_KEY! });

const { data } = await orbit.request<unknown>(
  "GET",
  "/logs/tail"
);

Raw curl in the body of this page works identically. Full SDK index at SDK quickstart.

Connect

curl -N "https://api.orbit.devotel.io/api/v1/logs/tail?token=dv_live_sk_your_key_here"

Browsers use EventSource, which cannot set request headers, so pass your credential as the token query parameter instead. A dv_-prefixed value is promoted to X-API-Key; any other value is treated as a bearer JWT. When you call from a server you can send the X-API-Key or Authorization header directly and omit token.

const source = new EventSource(
  `https://api.orbit.devotel.io/api/v1/logs/tail?token=${jwt}`,
  { withCredentials: true },
);

source.addEventListener("log", (event) => {
  const row = JSON.parse(event.data);
  console.log(row.method, row.path_pattern, row.status_code, row.duration_ms);
});

Frames

After connecting, the server sends, in order:

An event: connected handshake frame with data: {"type":"connected", ...}.
A backfill of up to the most recent ~100 request rows.
New rows live, as each request completes.

Comment lines (: heartbeat) are sent every 30 seconds to keep the connection open. Each request row arrives as a named log frame — listen with addEventListener("log", …), not onmessage, because EventSource only routes named frames to a matching listener. Each log frame’s data: line is one JSON object:

{
  "type": "log",
  "ts": 1718971200123,
  "request_id": "req_7f3c2a",
  "method": "POST",
  "path_pattern": "/api/v1/messages",
  "status_code": 202,
  "duration_ms": 41,
  "user_id": "user_abc",
  "api_key_id": null,
  "error_code": null,
  "error_message": null,
  "user_agent": "MyApp/1.4"
}

Field	Type	Notes
`type`	string	Always `log`.
`ts`	integer	Unix epoch milliseconds when the response completed.
`request_id`	string	Per-request id, also returned as the `X-Request-Id` header.
`method`	string	HTTP method.
`path_pattern`	string	Normalized route with ids collapsed to `:id`, e.g. `/api/v1/messages/:id`.
`status_code`	integer	HTTP status code.
`duration_ms`	integer	Server-side handling time in milliseconds.
`user_id`	string \| null	Authenticated user, or `null` for API-key requests.
`api_key_id`	string \| null	API key that authenticated the request, or `null`.
`error_code`	string \| null	Machine-readable error code for `>= 400` responses, otherwise `null`.
`error_message`	string \| null	Error message for `>= 400` responses (truncated), otherwise `null`.
`user_agent`	string \| null	Request `User-Agent` (truncated), or `null`.

Adding fields is backwards-compatible — ignore keys you don’t recognize, and drop any row missing a required field.

Resume after a disconnect

Every frame carries an id (a stream cursor). To resume without losing rows, reconnect with the Last-Event-ID request header set to the last id you received — browser EventSource does this automatically. From a client that can’t set the header, pass the same value as the lastEventId query parameter:

curl -N "https://api.orbit.devotel.io/api/v1/logs/tail?token=dv_live_sk_your_key_here&lastEventId=1718971200123-0"

On resume the server replays the rows newer than that cursor before continuing the live tail.

Consume from Node.js

Server-side consumers — log forwarders, ETL jobs, on-call bots — authenticate with the X-API-Key header (or an Authorization bearer header). Never send token as a query parameter from server code: a URL ends up in access logs and proxy history, and a credential in it is exposed. If your server library parses named SSE events, use the named event (addEventListener("log", …)), not a generic message handler — the rows arrive as event: log frames, so an onmessage-style handler never sees them.

eventsource
Manual parse (fetch)

// npm install eventsource
import { EventSource } from "eventsource";

let cursor = loadCursor(); // persist the last id across restarts

function connect() {
  const source = new EventSource("https://api.orbit.devotel.io/api/v1/logs/tail", {
    headers: { "X-API-Key": process.env.ORBIT_API_KEY },
  });

  // Named listener — the log rows arrive as `event: log` frames.
  source.addEventListener("log", (event) => {
    cursor = event.id;
    saveCursor(cursor); // persist for resume after a disconnect
    forward(JSON.parse(event.data)); // your sink: Kafka, BigQuery, SIEM…
  });

  source.onerror = () => {
    source.close();
    setTimeout(connect, backoff()); // then reconnect with Last-Event-ID
  };
}

Manual parsing is one pattern: buffer the stream, split frames on a blank line, and read each frame’s event, data, and id fields:

let cursor = loadCursor();

async function connect() {
  const headers = { "X-API-Key": process.env.ORBIT_API_KEY, Accept: "text/event-stream" };
  if (cursor) headers["Last-Event-ID"] = cursor;

  const response = await fetch("https://api.orbit.devotel.io/api/v1/logs/tail", { headers });
  if (!response.ok) throw new Error(`tail ${response.status}`);

  let buffer = "";
  for await (const chunk of response.body) {
    buffer += chunk.toString("utf8");
    let frameEnd; // a blank line terminates each frame
    while ((frameEnd = buffer.indexOf("\n\n")) >= 0) {
      const frame = buffer.slice(0, frameEnd);
      buffer = buffer.slice(frameEnd + 2);
      let event = "message", data = "", id;
      for (const line of frame.split("\n")) {
        if (line.startsWith("event:")) event = line.slice(6).trim();
        else if (line.startsWith("data:")) data += line.slice(5).trim();
        else if (line.startsWith("id:")) id = line.slice(3).trim();
      }
      if (event === "log" && data) {
        cursor = id ?? cursor;
        saveCursor(cursor);
        forward(JSON.parse(data));
      }
    }
  }
}

Consume from Python

Same rules as Node: header auth, named log events, a persisted cursor. sseclient dispatches each frame’s event: field to callbacks you register per name — register log, not message. With requests you iterate lines and track the fields yourself:

sseclient
requests

# pip install sseclient requests
import os
import json
import requests
import sseclient

cursor = load_cursor()

response = requests.get(
    "https://api.orbit.devotel.io/api/v1/logs/tail",
    headers={
        # header auth — never put the credential in the URL
        "X-API-Key": os.environ["ORBIT_API_KEY"],
        "Accept": "text/event-stream",
        # resume token — re-send the last id you saved
        "Last-Event-ID": cursor,
    },
    stream=True,
)
client = sseclient.SSEClient(response)

@client.on_event("log")  # named listener — the rows are `event: log`
def handle_log(event):
    save_cursor(event.id)
    forward(json.loads(event.data))

for _event in client.events():
    pass

import os, json, requests

cursor = load_cursor()
headers = {"X-API-Key": os.environ["ORBIT_API_KEY"], "Accept": "text/event-stream"}
if cursor:
    headers["Last-Event-ID"] = cursor

with requests.get(
    "https://api.orbit.devotel.io/api/v1/logs/tail",
    headers=headers,
    stream=True,
) as response:
    event, data, event_id = "message", "", None
    for line in response.iter_lines(decode_unicode=True):
        if line == "":  # blank line terminates one frame
            if event == "log" and data:
                save_cursor(event_id)
                forward(json.loads(data))
            event, data, event_id = "message", "", None
        elif line.startswith("event:"):
            event = line[6:].strip()
        elif line.startswith("data:"):
            data += line[5:].strip()
        elif line.startswith("id:"):
            event_id = line[3:].strip()

Keep the saved cursor in durable storage (a file, Redis, a database row) and re-send it as Last-Event-ID on reconnect — the server replays the rows you missed.

Limits and errors

Status	Meaning
`403`	Caller lacks the `owner`/`admin`/`developer` role, or the request did not come from a trusted browser origin.
`429`	Tenant has reached the maximum of 10 concurrent tail connections. Close an existing connection and retry.
`503`	The real-time backing store is temporarily unavailable. Retry with backoff.

On 429 or 503 from a server-side consumer, back off before retrying instead of reconnecting in a tight loop:

Node.js
Python

function backoff(attempt) {
  // 1s, 2s, 4s … capped at 30s; jitter spreads retries
  return Math.min(30_000, 1_000 * 2 ** attempt) + Math.random() * 500;
}

import random, time

def backoff(attempt):
    # 1s, 2s, 4s … capped at 30s; jitter spreads retries
    time.sleep(min(30, 2 ** attempt) + random.uniform(0, 0.5))

This is a live tail, not durable history. It carries only recent rows and the live stream — use it for observability, not as a system of record.

API Reference

All Endpoints

Live request-log tail

Live request-log tail

Using the SDKs

Connect

Frames

Resume after a disconnect

Consume from Node.js

Consume from Python

Limits and errors

​Live request-log tail

​Using the SDKs

​Connect

​Frames

​Resume after a disconnect

​Consume from Node.js

​Consume from Python

​Limits and errors

Live request-log tail

Using the SDKs

Connect

Frames

Resume after a disconnect

Consume from Node.js

Consume from Python

Limits and errors