[opensourcedex]

kubetail is a free, open source monitoring & observability project written in Go and released under Apache-2.0. It has 1,801 GitHub stars, 133 forks and 29 open issues, and was last pushed 12 days ago. On this registry it ranks #182 of 270 tracked projects in Monitoring & Observability, with 5 head-to-head comparisons available. It gained 32 stars over the last 30 tracked days.

What is kubetail?

Kubetail is an open-source, Apache-2.0 licensed real-time logging dashboard for Kubernetes that merges the logs of every container in a workload into a single chronological timeline and delivers them to a terminal or a browser, and it is built for developers, SREs, and platform teams who want live cluster logs without forwarding them to an external service.

What it is

Kubetail is a general-purpose logging tool for Kubernetes, written in Go and distributed as a kubetail CLI whose primary entry point can either launch a local web dashboard or stream raw logs straight to a terminal. It reads logs through the cluster's own Kubernetes API rather than through a sidecar, agent, or log shipper, so it works against a cluster out of the box. Behind the CLI it also watches container lifecycle events through the same API, which keeps the timeline in sync as containers start, stop, or get replaced, so log output stays continuous as requests move between ephemeral containers.

The concrete problem it solves is multi-container log tailing. Following a workload such as a Deployment or a DaemonSet normally means running kubectl logs against one container at a time and manually interleaving the output by timestamp. Kubetail replaces that manual stitching with one merged, chronological view per workload, and it replaces the alternative of shipping cluster logs into an external aggregation service, since the data is fetched directly from the cluster and never leaves the operator's possession. It runs anywhere, with desktop, cluster, and Docker as the supported deployment shapes.

Key capabilities

  • kubetail serve starts the web dashboard locally, while the same CLI can stream raw log messages directly to the terminal.
  • Logs from all containers in a workload are merged into one chronological timeline, with container lifecycle events tracked through the Kubernetes API.
  • Filtering by workload type (Deployment, CronJob, StatefulSet), by absolute or relative time range, by node properties such as availability zone, CPU architecture, and node ID, and by grep.
  • Log retrieval goes through the cluster's Kubernetes API, so log data never leaves the operator's possession.
  • Switching between multiple clusters is supported, though that capability is desktop-only.
  • Deployment targets are desktop, cluster, and Docker, so the same tool covers a single engineer's laptop and a shared cluster install.
  • Installation is broad: brew install kubetail, kubectl krew install kubetail, Snap, Winget, Chocolatey, Scoop, MacPorts, an Ubuntu PPA, a Fedora copr repository, zypper, apk, AUR, Gentoo GURU, Nix flake and classic, asdf, release binaries, and the install script at https://www.kubetail.com/install.sh.
  • Documentation is localized into Simplified Chinese, Japanese, Korean, German, Spanish, Portuguese, and French.

Who uses it and how

  • Engineers tailing a multi-container workload who need to follow a request as it moves from one ephemeral container to another across services.
  • Desktop users who run kubetail serve, open the browser dashboard, and switch between multiple clusters during the same session.
  • Terminal-first users who skip the browser entirely and stream merged logs from the CLI.
  • Teams running the tool in-cluster or under Docker when a shared, centrally reachable dashboard is preferable to every engineer running it locally.
  • Contributors and operators filing bugs or suggestions through GitHub Issues or hello@kubetail.com, with discussion in the project's Kubernetes Slack channel and contribution governed by the Contributor Covenant 2.1.

Getting started

Install the CLI with Homebrew using brew install kubetail, or pick one of the other fifteen supported package managers, the release binaries, or the install script. Then start the dashboard with kubetail serve or stream logs to the terminal from the same command.

How it compares

No comparable tools and no list of replaced paid products is provided in the material available for this page, so no licence, cost-model, or self-hosting comparison can be drawn. On the facts given, kubetail stands alone in this registry as a Kubernetes log-tailing dashboard.

When to use it — and when not to

A self-hoster needs working Kubernetes API access and a valid kubeconfig, but no external log store, message queue, or forwarding agent, which keeps the operational surface small. The material available is an excerpt that shows the cluster and Docker run modes without detailing their manifests or images, so anyone evaluating a shared in-cluster deployment should check the project site and repository for those specifics first. Teams that need long-term retention, historical search, analytics, or alerting over archived logs are outside the described scope, which is built around real-time tailing.

project readme (upstream, from github) — read inline

Kubetail

Kubetail is a real-time logging dashboard for Kubernetes

demo-thumbnail

Demo: https://www.kubetail.com/demo

Slack Contributor Covenant Contributor Resources

English | 简体中文 | 日本語 | 한국어 | Deutsch | Español | Português | Français

Introduction



Kubetail is a general-purpose logging dashboard for Kubernetes, optimized for tailing logs across multi-container workloads in real-time. With Kubetail, you can view logs from all the containers in a workload (e.g. Deployment or DaemonSet) merged into a single, chronological timeline, delivered to your browser or terminal.

The primary entry point for Kubetail is the kubetail CLI tool, which can launch a local web dashboard on your desktop or stream raw logs directly to your terminal. Behind the scenes, Kubetail uses your cluster's Kubernetes API to fetch logs directly from your cluster, so it works out of the box without needing to forward your logs to an external service. Kubetail also uses your Kubernetes API to track container lifecycle events in order to keep your log timeline in sync as containers start, stop or get replaced. This makes it easy to follow logs seamlessly as user requests move from one ephemeral container to another across services.

Our goal is to build the most powerful, user-friendly logging platform for Kubernetes and we'd love your help. If you notice a bug or have a suggestion please create a GitHub Issue or send us an email (hello@kubetail.com)!

Features

  • Clean, easy-to-use interface
  • View log messages in real-time
  • Filter logs by:
    • Workload (e.g. Deployment, CronJob, StatefulSet)
    • Absolute or relative time range
    • Node properties (e.g. availability zone, CPU architecture, node ID)
    • Grep
  • Uses your Kubernetes API to retrieve log messages so data never leaves your possession (private by default)
  • Switch between multiple clusters (Desktop-only)
  • Run anywhere: Desktop, Cluster, Docker

Quickstart

Installation

To install kubetail you can use Homebrew:

brew install kubetail
See 15 other options (e.g. Krew, Snap, Winget, Ubuntu, Fedora, SUSE, Alpine, Arch, Gentoo, Nix, asdf, Chocolatey, Scoop, MacPorts)
# Krew
kubectl krew install kubetail

# Snap
sudo snap install kubetail

# Winget
winget install kubetail

# Chocolatey
choco install kubetail

# Scoop
scoop install kubetail

# MacPorts
sudo port install kubetail

# Ubuntu/Mint (apt)
sudo add-apt-repository ppa:kubetail/kubetail
sudo apt update && sudo apt install kubetail-cli

# Fedora/CentOS/RHEL/Amazonlinux/Mageia (copr)
dnf copr enable kubetail/kubetail
dnf install kubetail

# SUSE (zypper)
zypper addrepo 'https://download.opensuse.org/repositories/home:/kubetail/$releasever/' kubetail
zypper refresh && zypper install kubetail-cli

# Alpine (apk)
apk add kubetail --repository=https://dl-cdn.alpinelinux.org/alpine/edge/testing

# Arch Linux (AUR)
yay -S --noconfirm kubetail-cli

# Gentoo (GURU)
ACCEPT_KEYWORDS="~$(portageq envvar ARCH)" emerge dev-util/kubetail

# Nix (Flake)
nix profile add github:kubetail-org/kubetail-nix

# Nix (Classic)
nix-env -i -f https://github.com/kubetail-org/kubetail-nix/archive/refs/heads/main.tar.gz

# asdf
asdf plugin add kubetail https://github.com/kubetail-org/asdf-kubetail.git
asdf install kubetail latest

If you prefer, you can also download it from the release binaries or use our install script:

curl -sS https://www.kubetail.com/install.sh | bash

Usage

Here are some ways to use kubetail:

1. Start the web dashboard (GUI)

kubetail serve

2. View logs in your terminal

kubetail logs -f deployments/my-app

3. Enable advanced features (by installing Kubetail API)

kubetail cluster install

4. Initialize a local config file

kubetail config init

See the documentation for a full list of commands. Have fun tailing your logs!

Run Anywhere

In addition to running Kubetail on your desktop you can also run it in these environments:

Documentation

Visit our full documentation at https://www.kubetail.com

Roadmap and Status

This is our high-level plan for the Kubetail project, in order:

Step Status
1 Real-time container logs ✅
2 Real-time search and polished user experience 🛠️
3 Real-time system logs (e.g. systemd, k8s events) 🔲
4 Basic customizability (e.g. colors, time formats) 🔲
5 Message parsing and metrics 🔲
6 Historic data (e.g. log archives, metrics timeseries) 🔲
7 Kubetail API and developer-facing client libraries 🔲
N World Peace 🔲

And here are some additional details:

Real-time container logs

Users can view the container logs from the pods currently running inside their clusters quickly and easily using a web dashboard. Users can view container logs organized by workloads and follow log messages as ephemeral containers get created and deleted. They can also narrow their viewing window by timestamp and filter logs by source properties such as region, zone and node.

Real-time search and polished user experience

Users can install Kubetail easily on their desktops and in their clusters. By default, Kubetail will use only the Kubernetes API to fetch basic data such as running workloads and container logs. If a user wants more advanced functionality they can install Kubetail custom services in their cluster (i.e. "Kubetail Cluster API" and "Kubetail Cluster Agent", collectively known as the "Kubetail API") and gain access to features such as log search, log file sizes and last event timestamps. The entire experience of installing, upgrading and uninstalling the Kubetail API is very polished and users are able to view their logs with equally powerful tools in the browser and the terminal using the Kubetail web dashboard and CLI tool.

Real-time system logs

Users who install the Kubetail API gain immediate access to their node-level logs (e.g. systemd) and cluster-level logs (e.g. kubernetes events) and view them in an integrated interface that shows their container logs in context with other system information such as CPU utilization, memory usage and disk space. System logs are viewable in real-time, in the same merged timeline with other logs. Users can filter system logs by timestamp and source properties.

Basic customizability

Users can fully customize their Kubetail experience when using the web dashboard and CLI tool by modifying their user settings. The user settings are modifiable by hand using a config file or via the dashboard UI. The experience is very polished and works seamlessly across upgrades that may add/remove/modify user settings. Users have the option to sync their settings across multiple devices.

Development

Repository Structure

This monorepo contains the following modules:

It also contains the source code for the Kubetail Dashboard's frontend:

Setting up the Development Environment

Dependencies
Next steps
  1. Create a Tilt-compatible Kubernetes Dev Cluster:
# minikube
ctlptl apply -f hack/ctlptl/minikube.yaml

# kind
ctlptl apply -f hack/ctlptl/kind.yaml

# docker-desktop
ctlptl apply -f hack/ctlptl/docker-desktop.yaml
  1. Start the dev environment:
tilt up
  1. Start the Dashboard server:
cd modules/dashboard
go run cmd/main.go -c hack/config.yaml
  1. Run the Dashboard UI locally:
cd dashboard-ui
pnpm install
pnpm dev

Now access the dashboard at http://localhost:5173.

Rust Development (Optional)

By default, the dev environment uses a pre-built image for the Rust-based cluster-agent. If you're working on the Rust code, you can use the KUBETAIL_RUST_DEV_MODE environment variable to enable a development mode that compiles the Rust code and syncs the binary into the cluster. There are two modes available:

Mode Description
docker Compiles the Rust code inside a Docker container. No local Rust toolchain required.
local Compiles the Rust code on your machine using cross-compilation. Faster rebuilds but requires local setup.

Docker mode

To use Docker mode, run Tilt with the KUBETAIL_RUST_DEV_MODE env variable set to docker:

KUBETAIL_RUST_DEV_MODE=docker tilt up

Local mode

Local mode requires additional dependencies and setup but offers faster rebuild times.

Dependencies
Setup

First, install the Rust target required for your architecture:

# x86_64
rustup target add x86_64-unknown-linux-musl

# aarch64
rustup target add aarch64-unknown-linux-musl

Next, install the tools required by Rust cross compiler:

# macOS (Homebrew)
brew install FiloSottile/musl-cross/musl-cross

# Linux (Ubuntu)
apt-get install musl-tools

On macOS, add this to your ~/.cargo/config.toml file:

[target.x86_64-unknown-linux-musl]
linker = "x86_64-linux-musl-gcc"

[target.aarch64-unknown-linux-musl]
linker = "aarch64-linux-musl-gcc"

Finally, run Tilt with the KUBETAIL_RUST_DEV_MODE env variable set to local:

KUBETAIL_RUST_DEV_MODE=local tilt up

Build

CLI Tool

To build the Kubetail CLI tool executable (kubetail), run the following command:

make

When the build process finishes you can find the executable in the local bin/ directory.

Dashboard

To build a docker image for a production deployment of the Kubetail Dashboard server, run the following command:

docker build -f build/package/Dockerfile.dashboard -t kubetail-dashboard:latest .

Cluster API

To build a docker image for a production deployment of the Kubetail Cluster API server, run the following command:

docker build -f build/package/Dockerfile.cluster-api -t kubetail-cluster-api:latest .

Cluster Agent

To build a docker image for a production deployment of the Kubetail Cluster Agent, run the following command:

docker build -f build/package/Dockerfile.cluster-agent -t kubetail-cluster-agent:latest .

Get Involved

We're building the most user-friendly, cost-effective, and secure logging platform for Kubernetes and we'd love your contributions! Here's how you can help:

  • UI/UX design
  • React frontend development
  • Reporting issues and suggesting features

Reach us at hello@kubetail.com, or join our Discord server or Slack channel.

Frequently asked questions

Is kubetail free to use?

kubetail is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does kubetail do?

Real-time logging dashboard for Kubernetes. View logs in a terminal or a browser. Run anywhere - desktop, cluster, docker.

What is kubetail written in?

kubetail is primarily written in Go. Its source is publicly available at https://github.com/kubetail-org/kubetail, and it has 1,801 GitHub stars.