---
title: reqlog — Failure Diagnosis and Recovery
date: 2026-10-18
time: 12:00
model: admin
category: programs
author_type: human
summary: Server failure analysis tool that traces and filters request flows in distributed systems. Searches logs from multiple services in one place.
tags: program, Failure Diagnosis and Recovery, reqlog
---

A distributed request tracing and server failure analysis tool that tracks and filters requests across multiple systems.

## Basic Information

| Program name | reqlog (RequestLog) |
| --- | --- |
| One-line description | A distributed request tracing and server failure analysis tool that tracks and filters requests across multiple systems. |
| Development & Maintenance | reqlog contributors |
| Official homepage | https://reqlog.sh/ |
| Official documentation | https://reqlog.sh/docs/ |
| Official download | https://reqlog.sh/downloads |
| Supported operating systems | Linux, macOS (Go 1.22+) |
| License | Apache-2.0 |
| Stable version | 1.8.2 (released 2026-10-12) — verified on 2026-10-18 |
| GitHub repository | https://github.com/FirasLatrech/reqlog |
| Category | Failure diagnosis and recovery (tags: distributed tracing, logs, failure analysis, server, troubleshooting) |

## What is this program?

In a distributed system where a single request passes through multiple services, reqlog is a tool that tracks the full flow of that request and performs integrated searching of related logs. It connects logs from multiple services using HTTP request ID and trace ID, allowing you to quickly narrow down the cause of failures.

When a failure occurs in a microservices environment, you typically have to open each service's logs separately. reqlog merges multiple log sources into a single timeline and filters them. You can track access logs, application logs, and error logs on one screen.

## What problems does it solve?

- ('During incident response', 'when you need to identify which service a request failed in', 'you can link logs from multiple services by trace ID to pinpoint the failure point.')
- ('During performance analysis', 'when you want to see where latency occurs', 'you can compare per-service elapsed time on the timeline.')
- ('During log search', 'when you need to find a specific request in tens of GB of logs', 'you can search by request ID, path, and status code with real-time filters.')
## Key Features

### Distributed tracing

Connects logs from multiple services by request ID and trace ID

- **Use case**: microservices failure analysis
- **Result**: see the entire path a request took at a glance
- **Limitations**: trace ID must be recorded in logs for linking to work.
### Real-time filters

Real-time filtering by path, status code, latency, and request ID

- **Use case**: extracting only relevant entries from large volumes of logs
- **Result**: you can view only failure signals
- **Limitations**: very broad filters can affect performance.
### Timeline view

Merges logs from multiple services into one timeline

- **Use case**: tracing request flow in chronological order
- **Result**: visually identify bottlenecks and latency sections between services
- **Limitations**: logs with large clock skew can be difficult to sort.
### Adding log sources

Collects logs from files, syslog, stdin, and HTTP endpoints

- **Use case**: integrating with existing log infrastructure
- **Result**: collect logs into reqlog without moving them
- **Limitations**: firewall configuration is required for network log collection.
## Installation and Usage

### Linux (binary)

Download the official binary and add it to your PATH.

```
curl -fsSL https://reqlog.sh/install.sh | sh
reqlog --version
```

### Building from source

Build the source with Go 1.22+.

```
git clone https://github.com/reqlog-dev/reqlog
cd reqlog
make build
sudo make install
```

### macOS

Use Homebrew.

```
brew install reqlog
```

## Real-world usage examples

### Specifying log sources and real-time tracing

Specify multiple log files as sources and start real-time tracing.

```
$ reqlog tail --source /var/log/nginx/access.log --source /var/log/app/app.log

[reqlog] 2 sources attached, tailing...
[12:01:23] nginx  GET /api/orders  200  trace=abc123  45ms
[12:01:23] app    process_order id=4821  trace=abc123
[12:01:24] nginx  GET /api/users   500  trace=def456  1203ms
```

### Tracing requests by trace ID

Trace the full flow of a specific request by trace ID.

```
$ reqlog trace abc123 --source /var/log/nginx/access.log --source /var/log/app/app.log

[trace] abc123 — 3 spans
  nginx    GET /api/orders      45ms   200
  gateway  forward to app        3ms   OK
  app      process_order      412ms   OK
[summary] total 460ms · 3 services · OK
```

### Failure filtering

Filter only 5xx responses and slow requests.

```
$ reqlog tail --source /var/log/nginx/access.log --filter 'status>=500 OR latency>1000ms'

[12:03:11] nginx  GET /api/users   500  trace=aaa111  2301ms
[12:03:45] nginx  POST /api/pay    502  trace=bbb222  5012ms
[filter] 2 matching entries (of 847 total)
```

## Advantages and limitations

### Advantages

- Merges and tracks logs from multiple services in a single timeline
- Distributed tracing based on trace ID — quickly pinpoint the cause of failures
- Extracts only relevant entries from large logs with real-time filters
- Supports multiple log sources: file, syslog, stdin, HTTP
### Considerations before use

- trace ID and request ID must be recorded in logs to use distributed tracing.
- Very high-volume log streams (tens of GB/hour) can degrade filtering performance.
- No GUI dashboard is provided yet (terminal-focused).
## Comparison with similar programs

| Program | Characteristics | Suitable when |
| --- | --- | --- |
| grep + awk | Search and filter logs with a combination of shell commands | Simple single-file log search |
| Elastic Stack (ELK) | Log collection, indexing, and visualization platform | Professional log infrastructure requiring long-term retention, dashboards, and alerting |
| Jaeger / Zipkin | Dedicated distributed tracing platform | Precise tracing based on OpenTelemetry |

## Official resources and further learning

- [Official homepage](https://reqlog.sh/) — https://reqlog.sh/
- [Official documentation / knowledge base](https://reqlog.sh/docs/) — https://reqlog.sh/docs/
- [Official download](https://reqlog.sh/downloads) — https://reqlog.sh/downloads
- [Release notes](https://reqlog.sh/changelog) — https://reqlog.sh/changelog
- [Source / development resources](https://github.com/FirasLatrech/reqlog) — https://github.com/FirasLatrech/reqlog
Version and supported environment information was confirmed on the official site as of 2026-10-18. Installation commands may vary depending on your distribution and version, so also check the official installation documentation.

## Actual execution screen

Below is a synthetic example screen created to help understand the usage flow (not an actual execution result). The screen is a synthetic example and not an actual execution result.

![reqlog distributed tracing example: 3-service path for trace abc123 (460ms), 5xx filtering result](https://games.aidebatehub.com/assets/reqlog-demo.png)

Actual production server

---
Source (HTML): https://games.aidebatehub.com/programs/apps/troubleshooting/reqlog.html
This file is an auto-generated Markdown twin of the DevHub document.