You're building something that touches three languages. A Python data pipeline feeds a Node.js API that talks to a Swift backend. Each has its own logging story. Python has the logging module. Node has winston or pino. Swift has OSLog. None of them talk to each other. When something breaks across the boundary, you're grepping three separate outputs in three separate terminals, correlating timestamps by eye, and hoping the clocks agree.

This is the normal state of cross-language development on a Mac. It shouldn't be.

Why Is Cross-Language Logging Still This Hard?

The standard answer to centralized logging is infrastructure. Elasticsearch with Kibana. Grafana with Loki. Fluentd or Logstash with agents in each process. These tools work well for production systems at scale. They are absurd for local development.

You're not running a cluster. You're running three processes on one machine. You want to see errors from all of them in one place. You don't want to write a docker-compose.yml for that. You don't want to install a logging agent into your Python virtualenv, a different one into your Node project, and a third into your Swift package dependencies. You definitely don't want to maintain configuration files that map each agent to a central collector.

The overhead scales with the number of languages in your stack. Two languages means two agents, two configs, two sets of dependencies to keep updated. Four languages means four. Every language has its own idiomatic logging library, its own format, its own opinions about structured data. Getting them to agree on a schema and ship to the same destination is a project in itself.

For production, that project is worth doing. For development, you need something that works in five minutes and doesn't touch your dependency tree.

What If Logging Was an HTTP POST?

LogPiper is a logging bus built into ToolPiper. It exposes a write endpoint, a read endpoint with filters, and a live stream. Any process on your Mac that can make an HTTP request can write structured log entries and read them back. There's nothing to install per-language, nothing to configure, and no dependency to add to any project.

The write interface is a JSON POST:

POST http://127.0.0.1:9998/v1/logs
Content-Type: application/json

{
  "source": "my-app",
  "level": "error",
  "event": "db.connection",
  "message": "Connection pool exhausted",
  "data": {"activeConnections": 50, "maxPool": 50},
  "correlationId": "job_20260404_001"
}

The read interface is a filtered GET:

GET http://127.0.0.1:9998/v1/logs?level=error&limit=20

That's the entire integration surface. Every field is optional (a missing source becomes unknown, a missing event becomes custom). The source field is how you identify which process logged the entry. The level field (debug, info, warn, error) controls filtering; any other value, such as warning, fails the whole POST with a 400. The event field is a free-form string for categorization. The data field carries any JSON object you want, nested as deep as you like. The correlationId is a string you choose that ties related entries together across processes.

If ToolPiper is running, the logging bus is running. If ToolPiper isn't running, the POST fails silently. Your app doesn't slow down, doesn't crash, doesn't wait.

Five Languages, One Destination

The best way to show this is with code. Each example below is a complete, copy-pasteable logging function. None of them import a logging library. None of them require configuration.

Python

import json
import urllib.request

def log(level, event, message, data=None):
    body = json.dumps({
        "source": "data-pipeline",
        "level": level,
        "event": event,
        "message": message,
        "data": data or {}
    }).encode()
    req = urllib.request.Request("http://127.0.0.1:9998/v1/logs", data=body,
                                 headers={"Content-Type": "application/json"})
    try:
        urllib.request.urlopen(req, timeout=2).close()
    except Exception:
        pass

log("info", "pipeline.start", "Processing batch", {"rows": 50000})
log("error", "pipeline.fail", "CSV parse error", {"line": 3847, "raw": "malformed..."})

The timeout=2 and the empty except are the safety net. If ToolPiper is down, the call fails within 2 seconds, the error is swallowed, and your pipeline keeps running. In normal operation, a localhost POST takes under a millisecond.

JavaScript (Node.js)

async function log(level, event, message, data = {}) {
  fetch('http://127.0.0.1:9998/v1/logs', {
    method: 'POST',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({ source: 'api-server', level, event, message, data }),
    signal: AbortSignal.timeout(2000)
  }).catch(() => {})
}

await log('info', 'server.start', 'Listening on port 3001')
await log('error', 'auth.fail', 'Token expired', { userId: 'u_42', expiredAt: '2026-04-03T23:59:00Z' })

The .catch(() => {}) swallows failures silently, and AbortSignal.timeout(2000) caps the wait at 2 seconds. Fire-and-forget. The API server never blocks on logging.

Shell (Bash/Zsh)

log_event() {
  curl -s -X POST http://127.0.0.1:9998/v1/logs \
    -H "Content-Type: application/json" \
    -d "{\"source\":\"deploy\",\"level\":\"$1\",\"event\":\"$2\",\"message\":\"$3\"}" \
    --max-time 2 > /dev/null 2>&1 &
}

log_event info deploy.start "Deploying v2.1.0 to staging"
rsync -az ./dist/ staging:/var/www/
log_event info deploy.complete "Deploy finished"

The trailing & sends the curl to the background. Your deploy script doesn't wait for the log call to finish. The --max-time 2 kills the request if ToolPiper isn't reachable.

Swift

func log(_ level: String, event: String, message: String) {
    var request = URLRequest(url: URL(string: "http://127.0.0.1:9998/v1/logs")!)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    request.httpBody = try? JSONSerialization.data(withJSONObject: [
        "source": "backend", "level": level, "event": event, "message": message
    ])
    request.timeoutInterval = 2
    URLSession.shared.dataTask(with: request) { _, _, _ in }.resume()
}

log("info", event: "model.load", message: "Loading llama-3.2-3b")
log("error", event: "model.crash", message: "llama-server exited with code 137")

The dataTask callback is empty. The Swift app fires the request and moves on. No delegate, no response handling, no retry logic.

Go

func logEntry(level, event, message string) {
    body, _ := json.Marshal(map[string]string{
        "source": "worker", "level": level, "event": event, "message": message,
    })
    client := &http.Client{Timeout: 2 * time.Second}
    go client.Post("http://127.0.0.1:9998/v1/logs", "application/json", bytes.NewReader(body))
}

The go keyword sends it to a goroutine. The calling function doesn't block.

Every one of these follows the same pattern. Build a JSON body, POST it, don't wait for the response. The language is different. The logging interface is identical.

Querying Across All Sources

Once your processes log to a shared endpoint, the query side is where the value compounds. Every entry from every source lands in the same 5,000-entry circular buffer.

# All errors from any source
curl "http://127.0.0.1:9998/v1/logs?level=error&limit=20"

# Only the Python pipeline
curl "http://127.0.0.1:9998/v1/logs?source=data-pipeline&limit=50"

# Only events whose name starts with http
curl "http://127.0.0.1:9998/v1/logs?event=http&limit=100"

# Everything from one job execution
curl "http://127.0.0.1:9998/v1/logs?correlationId=batch_20260404"

The source filter isolates one process. The level filter shows only errors and above. The event filter matches by prefix, so event=pipeline catches pipeline.start, pipeline.fail, and pipeline.complete. The correlationId filter pulls every entry that's part of the same logical operation, regardless of which process logged it.

The query that matters most for cross-app debugging is the one that cuts across sources. Your Node API returned a 502. Was it because the Swift backend crashed? Was it because the Python pipeline fed it bad data? Query level=error&limit=20 and the answer is in chronological order, with entries from all three processes interleaved in the order they arrived. No terminal switching. No grep. One query.

Tracing a Request Across Process Boundaries

The correlationId field is how you trace a single logical operation through multiple processes. Assign a shared ID at the start of a job, pass it through your systems, and include it in every log entry. It goes at the top level of the entry, next to source and event, not inside data: the filter reads only the top-level field. Add a correlationId parameter to the helpers above and each process sends an entry like these:

# Python pipeline starts the job
{"source": "data-pipeline", "event": "pipeline.start", "correlationId": "batch_20260404",
 "message": "Processing batch", "data": {"rows": 50000}}

# Node API receives the result
{"source": "api-server", "event": "api.ingest", "correlationId": "batch_20260404",
 "message": "Received pipeline output", "data": {"recordCount": 49823}}

# Swift backend stores it
{"source": "backend", "event": "store.write", "correlationId": "batch_20260404",
 "message": "Wrote 49823 records to index"}

Later, when something went wrong:

curl "http://127.0.0.1:9998/v1/logs?correlationId=batch_20260404"

You get the complete timeline. Pipeline started at 14:02:03. API received partial data at 14:02:47 (177 records missing). Backend wrote what it received. The gap is visible because the entries are structured and ordered. The pipeline's data field shows 50,000 rows in. The API's shows 49,823 received. Something dropped 177 records between the pipeline and the API. Now you know where to look.

Real-Time Streaming

For live debugging, LogPiper supports Server-Sent Events. Open a connection and matching entries appear the moment they're ingested:

# Stream all errors as they happen
curl -N "http://127.0.0.1:9998/v1/logs/stream?level=error"

# Stream from one specific source
curl -N "http://127.0.0.1:9998/v1/logs/stream?source=api-server"

Run this in one terminal while your processes run in others. Errors from the Python pipeline, the Node API, and the Swift backend all appear in the same stream, labeled by source, the instant they're logged. No polling. No delay.

The SSE stream accepts the query endpoint's level, source and event filters (it has no correlationId filter). Watch only errors. Watch only one source. Watch only events with a specific prefix. The stream shows you what's happening right now across your entire stack.

What You Don't Need

This is the part worth emphasizing, because the absence of things is the feature.

No SDK or client library per language. Every language already has HTTP. You're not adding a dependency. You're not importing a package. You're not pinning a version.

No agent process to install and configure. There's no collector, no forwarder, no sidecar. LogPiper runs inside ToolPiper, which you already have if you're doing local AI work on a Mac.

No Docker, Elasticsearch, Kibana, Loki, or Grafana. None of that infrastructure makes sense for local development logging. LogPiper is an in-memory buffer with an HTTP interface.

No YAML configuration files. No log format negotiation. No schema registration. No output plugin configuration. No rotation policy. No alerting rules.

No account creation. From the same Mac, writing (POST /v1/logs), reading (GET /v1/logs) and streaming (GET /v1/logs/stream) need no token, so any local process can use them without credentials. The two management endpoints are the exception: clearing (POST /v1/logs/clear) and exporting (POST /v1/logs/export) take a ToolPiper bearer token (Authorization: Bearer tp_...) with the system:control scope, even from the same Mac. You create one under Security in ToolPiper's main window.

HTTP POST. JSON body. Done.

What LogPiper Is Not

LogPiper stores 5,000 entries in a circular buffer, in memory. When the buffer is full, the oldest entry gets evicted, and a ToolPiper restart empties it. There's no disk persistence. You can export the current buffer to a JSON file with POST /v1/logs/export (bearer token required; the file lands in ~/Library/Application Support/ToolPiper/exports/), but this is on-demand, not automatic.

It's localhost only. ToolPiper answers on 127.0.0.1, so your processes have to be on the same Mac, and Docker containers are not a supported path. This is a local development debugging tool, not a distributed tracing system.

It's not built for high-volume sustained logging. A build system that generates 10,000 log lines per second will fill and rotate the buffer in under a second. For development workflows where you're logging meaningful events at API boundaries and decision points, 5,000 entries covers hours of work.

It won't replace Datadog. It won't replace Sentry. It fills a gap those tools don't target: the local, multi-language, multi-process debugging session where you want one place to look and zero infrastructure to manage.

The Pattern

The pattern that makes this work is simple enough to memorize.

Every process POSTs to the same endpoint. The source field identifies who sent the entry. Use your app name, your script name, your service name. Pick something you'll recognize when you're scanning entries at 2 AM.

Every log call is fire-and-forget. 2-second timeout. Background thread or goroutine. Empty error handler. Your app never waits on logging. If ToolPiper is down, the call fails silently. You can leave these calls in your code permanently, in development and staging, with zero risk to performance or stability.

Query when something breaks. level=error for the quick scan. source=my-app to isolate one process. correlationId=job_123 to trace a full operation. event=http for API traffic. The query parameters compose, so source=api-server&level=error shows only errors from the API server.

The integration is one function per language. The function is 5-10 lines. It uses your language's standard HTTP library. It has no external dependencies. Copy it into your project once and it works forever.

ToolPiper is a free download from the modelpiper.com/download. LogPiper is included in every installation, free and Pro.

This is part of the vibe debugging series on AI development observability. For the full LogPiper technical reference, see LogPiper: A Universal Logging Bus That Ships Free Inside ToolPiper.