o3

A fast, native desktop client for OpenObserve.

Query logs, explore metrics, and manage connections from a purpose-built macOS app — no browser tab, no context switching.

Built with Wails v2 (Go backend) + React / TypeScript frontend.

Features · Screenshots · Download · Getting started · Architecture · Roadmap

OpenObserve ships a capable web UI, but a desktop client buys you things a browser tab can't: native window chrome, OS keychain-backed credential storage, instant startup, and a workflow tuned for the query-inspect-refine loop instead of general-purpose dashboards.

o3 shares its Go client with the openobserve-cli project, so the CLI and the GUI talk to OpenObserve through exactly the same code — they cannot drift apart.

• CodeMirror 6 SQL editor with grammar-based highlighting, real undo/redo, and Cmd+Enter to run — no hand-rolled textarea overlay.
• Context-aware autocomplete that suggests live stream fields, SQL keywords, and functions as you type, fully keyboard-navigable.
• Multi-tab queries with inline rename (double-click a tab) and per-tab result state.
• Event-volume histogram rendered with Apache ECharts, with hover tooltips over 30s buckets.
• Result inspector drawer — click any row to see the full record as formatted JSON, copy it, or drill in.
• Value actions — click any field value to filter for/exclude it, aggregate by it, or copy it; the SQL is rewritten for you.

• Native PromQL range queries (rate, p99, error-rate expressions, …) against OpenObserve's Prometheus-compatible endpoint.
• Multi-series line charts with legend toggles, a shared-axis tooltip, and a dataZoom brush, all built on the reusable ECharts wrapper.
• Segmented time-range control with an automatic Prometheus step ladder (~120 points/range).

• Multiple contexts — switch between staging, prod, and local instances from the title bar.
• Browser sign-in on every platform — log in through your instance's own web login (SSO included) and o3 captures the session. macOS uses a native WebView window; Windows and Linux drive your Chromium-family browser over the DevTools Protocol. The capture core is shared with openobserve-cli, so both clients agree on when a login has actually completed.
• OS keychain-backed secrets — passwords/tokens are stored via go-keyring, never in plaintext config.
• Setup wizard and a contexts manager with a delete guard (you can't remove your last context) and live connection testing.

• Dark, information-dense UI faithful to a single visual source of truth.
• Dynamic accent color — every chart, caret, and highlight reacts to the runtime accent set in Settings.

Screenshots coming soon. Run wails dev to see the app live.

Grab the latest installer for your OS from the Releases page:

Heads-up: the builds are currently unsigned. Until code signing is in place, your OS will warn on first launch:

• macOS — Gatekeeper says the app "cannot be opened". Try to open it once, then go to System Settings → Privacy & Security and click Open Anyway (macOS 15 Sequoia removed the old right-click → Open bypass for unsigned apps; on macOS 14 and earlier that shortcut still works too). Or clear the quarantine flag once: xattr -dr com.apple.quarantine /Applications/o3.app. The install window of the DMG carries the same hint.
• Windows — SmartScreen shows "Windows protected your PC". Click More info → Run anyway.

Once installed, o3 keeps itself up to date: macOS and Windows builds update in place through the platform's native mechanism (Sparkle / WinSparkle), with every update verified against the project's EdDSA signing key before it is installed. The Linux AppImage notifies about new releases and links to the download. Details in docs/auto-update.md.

o3 depends on the shared client from the sibling openobserve-cli repo via a Go workspace (go.work). Check both repos out side by side so the replace directive in go.mod resolves.

wails dev

Live-reloads both the Go backend and the React frontend.

wails build

Produces a native .app bundle under build/bin/.

The Makefile wraps wails build with the per-OS packaging steps — each target builds on its own platform (Windows cross-compiles from any host):

make dmg        # macOS  → build/bin/o3-<version>-universal.dmg (needs dmgbuild)
make installer  # Windows → build/bin/o3-<version>-windows-amd64-setup.exe (needs makensis)
make appimage   # Linux  → build/bin/o3-<version>-x86_64.AppImage

VERSION defaults to the current git tag; override with make dmg VERSION=1.2.3. Add NATIVE_UPDATER=1 to reproduce the release configuration with the native auto-updater compiled in (see docs/auto-update.md).

Releases are automated: pushing a v*.*.* tag runs .github/workflows/release.yml, which builds all three platforms in a matrix and attaches the installers to a draft GitHub Release for review. The workflow checks out the sibling openobserve-cli repo automatically to satisfy the go.work dependency.

# Go
go test ./...

# Frontend
cd frontend && npm test

┌─────────────────────────────────────────────┐
│  React + TypeScript (frontend/)              │
│  CodeMirror 6 editor · ECharts viz · views   │
└───────────────┬─────────────────────────────┘
                │ Wails-generated TS bindings
┌───────────────┴─────────────────────────────┐
│  Go app layer (app.go, internal/)            │
│  contexts · query · metrics · config · errs  │
└───────────────┬─────────────────────────────┘
                │ shared client (go.work)
┌───────────────┴─────────────────────────────┐
│  openobserve-cli/pkg/{apiclient,auth,config, │
│                       webauth}               │
│  the single source of truth for the O2 API   │
└──────────────────────────────────────────────┘

• app.go exposes a small, typed surface to the frontend: ListContexts, SwitchContext, SaveContext, RemoveContext, TestConnection, ListStreams, GetFields, RunQuery, and RunMetricsQuery.
• internal/query builds and runs log searches; internal/metrics maps PromQL matrix responses into chart-ready series; internal/config manages contexts and keychain secrets; internal/apperr normalizes backend errors for the UI.
• frontend/src/components/charts/ holds a reusable <EChart> wrapper plus pure option-builders (buildHistogramOption, buildMetricsOption) — the foundation every future visualization reuses.

o3 is under active development. The logs and metrics explorers are functional; the remaining navigation surfaces are scaffolded and being built out.

Legend: ✅ shipped · 🚧 in progress · 📋 planned

• Shell: Wails v2
• Backend: Go 1.24, go-keyring
• Frontend: React 18, TypeScript, Vite
• Editor: CodeMirror 6 (@codemirror/lang-sql, @codemirror/autocomplete)
• Charts: Apache ECharts
• Tests: Vitest, Go testing

MIT © AngelMsger