Lib.rs

tracing

Application-level tracing for Rust

env_logger

A logging implementation for log which is configured via an environment variable

log

A lightweight logging facade for Rust

console-subscriber

A tracing-subscriber::Layer for collecting Tokio console telemetry

prometheus

instrumentation library for Rust applications

iced-x86

blazing fast and correct x86/x64 disassembler, assembler and instruction decoder written in Rust

tracing-opentelemetry

OpenTelemetry integration for tracing

opentelemetry

API for Rust

metrics

A lightweight metrics facade

sentry

(sentry.io) client for Rust

addr2line

A cross-platform symbolication library written in Rust, using gimli

assert2

assert!(...) and check!(...) macros inspired by Catch2, now with diffs!

backtrace

acquire a stack trace (backtrace) at runtime in a Rust program

fern

efficient logging

symbolic-demangle

demangle symbols from various languages and compilers

flexi_logger

easy-to-configure and flexible logger that writes logs to stderr or stdout and/or to files. It allows custom logline formats, and it allows changing the log specification at runtime…

fastrace

A high-performance timeline tracing library for Rust

tokio-metrics

Runtime and task level metrics for Tokio applications

gdbstub

GDB Remote Serial Protocol in Rust

cpp_demangle

demangling C++ symbols

tui-logger

Logger with smart widget for the ratatui crate

sentry-core

Core Sentry library used for instrumentation and integration development

jj-cli

Jujutsu - an experimental version control system

extism

runtime and Rust SDK

cadence

An extensible Statsd client for Rust

tracing-tree

A Tracing Layer which prints a tree of spans and events

console_log

A logging facility that routes Rust log messages to the browser's console

tracing-forest

Preserving contextual coherence among trace data from concurrent tasks

pyo3-log

Logging bridge from pyo3 native extension to python

cargo-expand

Wrapper around rustc -Zunpretty=expanded. Shows the result of macro expansion and #[derive] expansion.

emit

Developer-first diagnostics for Rust applications

tracing-bunyan-formatter

A Bunyan formatter for the tracing crate

symbolic-common

Common types and utilities for symbolic, a library to symbolicate and process stack traces from native applications, minidumps or minified JavaScript

wasmtime-internal-jit-debug

INTERNAL: JIT debug interfaces support for Wasmtime

pdb-addr2line

Symbolicate addresses from PDBs, like addr2line

logforth

A versatile and extensible logging implementation

pretty-hex

Pretty hex dump of bytes slice in the common style

tracing-opentelemetry-instrumentation-sdk

A set of helpers to build OpenTelemetry instrumentation based on tracing crate

datafusion-tracing

DataFusion tracing of execution plans

metrics-prometheus

prometheus backend for metrics crate

logfire

Rust SDK for Pydantic Logfire

systemd-journal-logger

Systemd journal logger for the log facade

libcasr

Collect crash reports, triage, and estimate severity

bpfix

Userspace eBPF verifier failure diagnostic CLI

opentelemetry_sdk

The SDK for the OpenTelemetry metrics collection and distributed tracing framework

cf-rustracing-jaeger

Jaeger client library created on top of rustracing

minidump-writer

Rust rewrite of Breakpad's minidump_writer

mem_dbg

Traits and associated procedural macros to display recursively the layout and memory usage of a value

crash-context

portable types containing target specific contextual information at the time of a crash

assert_float_eq

Assertions for floating-point equality

env_filter

Filter log events using environment variables

metrics-exporter-prometheus

A metrics-compatible exporter for sending metrics to Prometheus

fast_log

Rust async log High-performance asynchronous logging

sofka

A Kubernetes TUI, reimagined in Rust

tracing-loki

A tracing layer for shipping logs to Grafana Loki

debug-helper

declarative macros to help you implement the Debug trait manually

spdlog-rs

Fast, highly configurable Rust logging crate, inspired by the C++ logging library spdlog

sentry-types

Common reusable types for implementing the sentry.io protocol

tracing-logfmt

A logfmt formatter for tracing events and spans

pdbtool

reading Program Database (PDB) files and displaying information about them

structured-logger

A logging implementation for the log crate that logs structured values either synchronous or asynchronous, as JSON, CBOR, or any other format, into a file, stderr, stdout, or any other destination

rlg

near-lock-free structured logging library for Rust. Sub-microsecond ingestion via a 65k-slot ring buffer (LMAX Disruptor pattern), deferred formatting, and native OS sinks (os_log on macOS via `syslog(3)…

influxive

High-level Rust integration of opentelemetry metrics and InfluxDB

adb_client

Rust ADB (Android Debug Bridge) client library

uuinfo

debug unique identifiers (UUID, ULID, Snowflake, etc)

opentelemetry-prometheus-text-exporter

OpenTelemetry metrics exporter for Prometheus text exposition format

starbase

Framework for building performant command line applications and developer tools

minidump

A parser for the minidump format

kdash

A fast and simple dashboard for Kubernetes

tracing-web

A tracing compatible subscriber layer for web platforms

tracing-appender

file appenders and making non-blocking writers

tracing-throttle

High-performance log deduplication and rate limiting for the tracing ecosystem

mquire

Memory forensics and analysis tool for querying Linux kernel memory dumps using SQL

temporalio-common

Common functionality for the Temporal SDK Core, Client, and Rust SDK

intentrace

strace with intent, it goes all the way for you instead of half the way

ftlog

An asynchronous logging library for high performance

bevy_brp_extras

Extra BRP methods for Bevy apps including screenshot, shutdown, and keyboard input capabilities

minidumper

IPC impl for creating a minidump for a crashed process

duodiff

A fast, cross-platform terminal user interface (TUI) directory comparison tool

autometrics

Easily add metrics to your code that actually help you spot and debug issues in production. Built on Prometheus and OpenTelemetry.

hyperlight-guest-tracing

tracing functionality for the hyperlight guest

framehop

Stack frame unwinding support for various formats

metrics-util

Helper types/functions used by the metrics ecosystem

trackable

way to track objects manually as an alternative to mechanisms like backtracing

timely_logging

Common timely logging infrastructure

logwise

an opinionated logging library for Rust

custom_debug

Derive Debug with a custom format per field

tracelogging

TraceLogging for Rust

logroller

A feature-rich log rotation library with timezone support, flexible rotation strategies, and compression, integrating seamlessly with the tracing ecosystem

sentry-tracing

Sentry integration for the tracing and tracing-subscriber crates

cntr

A container debugging tool based on Linux mount API

traceviewer

Run a command and inspect its logs in a scrollable terminal viewer

datadog-opentelemetry

A Datadog layer of compatibility for the opentelemetry SDK

cbor-diag

parsing data encoded in Concise Binary Object Representation (CBOR) (in any of raw binary, hex encoded (with comments) or diagnostic notation) then printing it out in either annotated hex form or…

kamu-logging

Structured tracing setup for native services and Cloudflare Workers

symbolizer-rs

A fast execution trace symbolizer for Windows that runs on all major platforms and doesn't depend on any Microsoft libraries

win_etw_tracing

backend for the tracing crate that logs events to ETW (Event Tracing for Windows)

probe

Static instrumentation probes

mixtrics

One crate for all metrics

via-pcb-cli

Project-oriented CLI wrapper for via checks, snapshots, BOMs, and exports

veil

Rust derive macro for redacting sensitive data in std::fmt::Debug

adk-telemetry

OpenTelemetry integration for Rust Agent Development Kit (ADK-Rust) agent observability

opentelemetry-application-insights

OpenTelemetry exporter for Azure Application Insights

tracing-mutex

Ensure deadlock-free mutexes by allocating in order, or else

dlt-core

Parser and writer for autosar DLT Diagnostic Log and Trace

tracing-wasm

tracing subscriber for browser WASM

inqjet

Ultra-fast, low-latency logging for Rust applications

tokio-metrics-collector

collecting Prometheus-compatible metrics from Tokio runtime and tasks

cosmian_logger

Shared tracing and OTLP initialization for Rust services

connector-mcp-server

MCP server for tauri-plugin-connector (Rust)

lief

Official Rust bindings for LIEF

thorin-dwp

building DWARF packages from input DWARF objects and packages

gearbox

Excessive tooling for Rust, boosting productivity and operations

helios-fhirpath

HL7's FHIRPath Specification

ugdb

An alternative TUI for gdb

aws-sdk-applicationinsights

AWS SDK for Amazon CloudWatch Application Insights

watchlog

A command-line utility to help you see how a log is moving

symdis

Symbolic disassembler for Mozilla crash report analysis

kprobe

A no_std Rust probe infrastructure crate for kprobe, kretprobe, and uprobe on multiple architectures

chatdbg

Rust-specific support for ChatDBG

rudy-lldb

Rudy LLDB server for debugging Rust programs

eventlog

A log-compatible wrapper around the Windows Event Log API

symbolic

symbolicate and process stack traces from native applications, minidumps, Unreal Engine 4 or minified JavaScript

lurk-cli

lurk is a pretty (simple) alternative to strace

json-subscriber

Customizable layer and subscriber for tracing that emits logs in JSON

byedroid

TUI — Android build, install, and log workflows in the terminal

std-logger

A logging implementation for the log crate that logs messages to standard error and requests to standard out. It support a number of output formats including JSON, JSON for GCP (gcloud) and logfmt.

axum-conf

simplify the use of Axum, Tokio and Postgres together using configuration. It comes with batteries included and many features can be feature activated.

assertor

Fluent assertion library with readable failure messages

tracing-rolling-file

A rolling file appender with customizable rolling conditions

sadness-generator

various ways to make your program sad

auditaur-cli

Command-line interface and MCP server for inspecting Auditaur local telemetry

retour

A cross-platform detour library written in Rust

auspex-otel

Extremely opinionated, lean, high-performance OTEL tracing middleware for axum

devtools-wire-format

gRPC wire format for the CrabNebula devtools for Tauri

glean

SDK Rust language bindings

chrome-debug-mcp

Rust MCP Server for full Chrome CDP control and interactive JS debugging

dlt_log

Log crate adapter for integrating with the Diagnostic Log and Trace (DLT) system

zydis-rs

A pure Rust x86/x64 disassembler and encoder library (inspired by Zydis)

zench

Run benchmarks anywhere in your codebase and integrate performance checks directly into your cargo test pipeline

force-ansi

A command-line wrapper program that can force ANSI code to be enabled in the Windows console

xvc-logging

Logging crate for Xvc

mockforge-observability

Observability features for MockForge including Prometheus metrics, OpenTelemetry tracing, and recording

error-forge

Pragmatic Rust error-handling framework with stable error metadata, contextual diagnostics, optional async support, and synchronous recovery primitives (retry, circuit-breaker, backoff)…

log-fastly

log façade for Fastly Compute

printer_event_handler

A cross-platform printer status monitoring library for Windows and Linux

log-panics

A panic hook which logs panic messages rather than printing them

tracexec

Tracer for execve{,at} and pre-exec behavior, launcher for debuggers

captains-log

A minimalist customizable logger for rust, based on the log crate, but also adapted to tracing, for production and testing scenario

idax

Safe, idiomatic Rust bindings for the IDA SDK via idax

dump_syms

Dump debug symbols into Breakpad ones

nils-cli-template

CLI crate for nils-cli-template in the nils-cli workspace

flashlog

A fast logging library for Rust

mago-bytes

Shared byte-slice utilities for the Mago toolchain: lossy UTF-8 display wrapper, byte trimming helpers

splog

A TUI log viewer with automatic category filtering

datadog-apm-sync

Datadog APM-compatible tracer and logger for Rust

macho-unwind-info

A parser for Apple's Compact Unwinding Format, which is used in the __unwind_info section of mach-O binaries

eventline

Structured journaling and scoped logging for Rust applications

tracing-cloudwatch

tracing-subscriber layer that sends your application's tracing events(logs) to AWS CloudWatch Logs

diagnosticism

Miscellaneous discrete and simple diagnostics facilities (for Rust)

hermes_rs

A dependency-free disassembler and assembler for the Hermes bytecode

rand_dev

Reproducible randomness source for tests

omniscope-pass

Analysis passes for FFI safety, memory safety, and concurrency in OmniScope

secure_sum

Utilizes OSSF Scorecard to probe open source repositories for their security posture using a customizable metric

fastrace-tonic

A tonic instrument for propagating trace context for fastrace

debugid

Common reusable types for implementing the sentry.io protocol

ptools

inspecting Linux processes

firo_logger

A high-performance, feature-rich logger for Rust applications with colored output, structured logging, and advanced configuration

eventheader_dynamic

Rust API for runtime-specified eventheader-encoded Linux Tracepoints via user_events

tracing-opentelemetry-setup

provide proper setup of tracing with OTEL export

harn-dap

Debug Adapter Protocol implementation for Harn

kaish-glob

Glob matching and async file walking with gitignore support

winston

winston for rust

pyisheval

A Python-like expression evaluator in Rust

lldb

Rust-like bindings to the public LLDB API. LLDB is the debugger from the LLVM project and is the system debugger on macOS.

otel-bootstrap

One-call OpenTelemetry bootstrap — traces + metrics with OTLP export

phs

Runtime for Phlow Script, PHS

witchcraft-log

A structured logging facade for Witchcraft servers

tracing-tunnel

Tunnelling tracing information across API boundary

srcsrv

Interpret the contents of a srcsrv stream from a pdb file (Microsoft Source Server)

prima-tracing

Prima.it opentelemetry standard library

git-spawn

Async wrapper around the git CLI: builder commands, typed parsers, high-level workflow helpers

daemon8

Runtime awareness management for AI agents

jwtinfo

Command line tool to get information about JWTs (Json Web Tokens)

bare_err_tree

Display errors as a formatted tree

perl-dap

Debug Adapter Protocol server for Perl

timber_rust

A high-performance, asynchronous logging library with support for Grafana Loki and AWS CloudWatch

egui_logger

log implementation for egui

axbacktrace

Backtrace for ArceOS

protobug

Interactive terminal debugger for protobuf payloads

fluxdi

Semi-Automatic Dependency Injector

rasant

lightweight, high performance and flexible Rust library for structured logging

moosicbox_logging

MoosicBox logging package

diagweave

Core runtime and macros re-export for diagweave error algebra and report diagweaveing

dev-report

Structured JSON reports for Rust verification tooling. Stable, versioned wire format with optional terminal, markdown, SARIF, and JUnit XML rendering. Foundation of the dev-* collection.

crypsol_logger

Structured asynchronous logger for Rust services with CloudWatch, HTTP (Loki / Elasticsearch / custom), file, and console backends

r0-metal-doctor

Diagnose whether RISC Zero proving on Apple Silicon actually uses Metal — device caps, toolchain state, and observed prover lane. Reports, never assumes.

logging_timer

timers that log the elapsed time when dropped

fsqlite-observability

Conflict analytics and observability infrastructure for FrankenSQLite MVCC

zerus

Lightweight tool for creating project-specific and/or general offline crates.io mirrors

smda

Recursive x86/x64/AArch64 disassembler library for control-flow recovery from memory dumps. Iced-x86 + disarm64-backed; zero-copy.

win_etw_metadata

metadata definitions for the win_etw_provider and win_etw_macros crates

hooq

macro that inserts a method before ?. (? 前にメソッドを挿入するシンプルなマクロ)

tracing-oslog

A layer for tracing that outputs to the oslog on macOS/iOS

maw-workspaces

Multi-Agent Workflow coordinator for Manifold git workspaces

Htrace

tracing system

wasmtime-jit-debug

JIT debug interfaces support for Wasmtime

dioxus-logger

A logging utility to provide a standard interface whether you're targeting web desktop, fullstack, and more

tracing-subscriber

implementing and composing tracing subscribers

basalt-tui

Basalt TUI application for Obsidian notes

nnd

A fast handmade TUI-based debugger for Linux

unstrip

Recover symbols, types, and method signatures from stripped Go binaries. Ghidra/IDA/Binary Ninja exporters included.

unbug

programmatically invoke debugging breakpoints with helping macros

charon-error

Structured error and panic handling with rich reports and bug reporting functionality

alterable_logger

A thin wrapper for "log" allowing to replace the actual logger implementation at run time

smooai-logger

Context-aware structured logging utilities for Rust mirroring the @smooai/logger toolkit

gcp-log

A CLI tool for structured logging on GCP

dynamo-backend-common

Shared runtime glue for Rust LLM backends

maa-framework

Rust bindings for MaaFramework

zerodds-replay

Inspect/replay CLI for .zddsrec recordings: dump frames, replay at scaled wallclock, optional live re-injection into a DCPS domain

crabka-audit

Audit event model, OCSF serialization, and write pipeline for Crabka (FedRAMP 20x MLA)

rskit-logging

Structured logging setup using tracing — JSON in production, pretty in dev

vcs-runner

Subprocess runner for jj and git with retry, timeouts, repo detection, and structured output parsing

io-buffer

A buffer abstracted for disk and network IO, with static lifetime. Unify Vec and *libc::c_void into one type, with smallest mem footprint

ddbug

Display debugging information

pi_logger

qubit-command

Command-line process running utilities for Rust

async-backtrace

Efficient, logical 'backtraces' of async tasks

mdcr

Validate, execute and optionally rewrite code blocks in Markdown files based on arbitrary commands

microsandbox-utils

Shared constants and utilities for the microsandbox project

aprender-profile

Pure Rust system call tracer with source-aware correlation for Rust binaries

command-run

running a command in a subprocess

valuable

Object-safe value inspection, used to pass un-typed structured data across trait-object boundaries

axum-observability

Axum middleware for request IDs, trace correlation, and structured access logs

opentelemetry-otlp

Exporter for the OpenTelemetry Collector

skywalking

Apache SkyWalking Rust Agent

ltrace

A rolling file writer for tracing and log crates with rotation, compression, and dynamic log level support

assert_no_alloc

Custom Rust allocator allowing to temporarily disable memory (de)allocations for a thread. Aborts or prints a warning if allocating although forbidden.

lash-trace

Trace types and JSONL exporter for the lash agent runtime

logged-stream

Logging of all read/write operations, errors and drop of underlying IO object

styledlog

combining versatile logging features with styled output

always-assert

Recoverable assertions for long-running robust applications

extract-shellcode

Small Rust toolkit for pulling shellcode out of a Windows PE and (optionally) executing it in-memory

lloggs

Logging configuration for clap applications

tracing-gstreamer

Bridge between gstreamer and the tracing ecosystem

binstalk

The binstall toolkit (library interface)

policy-rs

Policy library for working with protobuf-defined policy objects

lambda-otel-lite

Lightweight OpenTelemetry instrumentation for AWS Lambda

wasm-tracing

Tracing subscriber for WebAssembly. Maintained fork of tracing-wasm.

slog

Structured, extensible, composable logging for Rust

atomr-agents-observability

Structured event taxonomy + tracing/metric exporters for atomr-agents

toolkit-rs

Rust toolkit library(logger, time, painc handle)

pyo3-pylogger

Enables log for pyo3 based Rust applications using the logging modules

grex-core

Core library for grex, the nested meta-repo manager: manifest, lockfile, scheduler, pack model, plugin traits

sentry-rust-minidump

Captures native crashes as minidumps and sends to Sentry

project-structure

Generate an ASCII Representation of a project youre working on

swift-demangler

Demangle Swift symbol names into structured types for analysis

healthchecks

notify healthchecks.io from inside applications

tracing-layer-slack

Send filtered tracing events to Slack

trace-weft

Rust-first, local-first observability and debugging toolkit for LLM agents

quantum-pulse

A lightweight, customizable profiling library for Rust with support for custom categories and percentile statistics

debugchrome-cdp-rs

A protocol‐handler for launching & controlling Chrome via CDP

better-panic

Pretty panic backtraces inspired by Python's tracebacks

rconsole

A WebSocket-based logging library for Rust - send structured logs to NConsole desktop app

nolog

Pretty (by default) and easy to use logger. Compile-time level filtering, zero deps.

tracing-subscriber-init

A trait and some functions to make tracing subscriber initialization a bit easier

langfuse-ergonomic

Ergonomic Rust client for Langfuse with builder patterns

cx-sdk

Coralogix Management SDK

mozdevice

Client library for the Android Debug Bridge (adb)

zydis

Bindings for Zydis

yaru

Util - A collection of utilities for timing, memory inspection and SQL result formatting

amberfork

command: diff two agent-run traces and render where they fork

datafusion-openlineage

OpenLineage integration for Apache DataFusion sessions

ferroscope

MCP server that enables AI assistants to debug Rust programs using LLDB and GDB

si_trace_print

stack indented trace printing; a rust library to print messages indented to stack depth optionally preceded by the function name

logform

logform for rust

enforce-script-lsp

Language Server Protocol implementation for Enforce Script

metrics-process

Cross-platform Prometheus style process metrics collector of metrics crate

context-logger

A small structured context propagation layer for the standard Rust log ecosystem

bp3d-debug

Tracing subscriber implementations for use with BP3D software. Supports traditional logging through bp3d-logger and supports remote profiling through TCP.

stderrlog

Logger that logs to stderr based on verbosity specified

ir-assert

in-test assertion over its compiled llvm-ir

rust_util

Hatter's Rust Util

osquery-rs-sdk

Rust SDK for building osquery extensions — tables, loggers, config providers, and distributed query handlers

cellos-projector

Projection layer for CellOS — consumes JetStream CloudEvents into in-memory cell/formation state. Used by cellos-server.

consola

🐨 Elegant Console Logger for Rust and Browser

owl-logger

A production-ready, ergonomic logging library for Rust — inspired by Python's xmi_logger, powered by tracing

tklog

Lightweight and efficient rust structured log library with support for log level, file shred, compressed archive

pocopine-observe

Shared observability event contract for pocopine logging, tracing, and analytics

dev-security

Dependency audit and license policy for Rust. Wraps cargo-audit + cargo-deny: known-CVE scanning, license enforcement, banned-crate policies. Part of the dev-* verification collection.

desed

Sed script debugger. Debug and demystify your sed scripts with TUI debugger.

lumelog

A lightweight, flexible, and configurable logging library for Rust, with support for runtime configuration and build-mode detection

azure_core_opentelemetry

OpenTelemetry integration for the Azure SDK for Rust

dbg-cli

A universal debugger CLI that lets AI agents observe runtime state instead of guessing from source code

libsla

Rust bindings to Ghidra Sleigh library libsla

quo-rust

Companion package for the Quo debugger

gitbundle-sdk

GitBundle API documentation

traccia

A zero-dependency, flexible logging framework for Rust applications

tracehash-rs

Cross-language call/input/output hash tracing for algorithm parity checks

dots

A cli for managing all your dot(file)s

logly

High-performance, structured logging library with async support, rotation, filtering, and GPU/CPU optimization

debugger-cli

LLM-friendly debugger CLI using the Debug Adapter Protocol

telemetry-batteries

Batteries included library to configure tracing, logs and metrics

dsi-progress-logger

A tunable time-based progress logger to log progress information about long-running activities

blazesym-c

C bindings for blazesym

rolling-file

A rolling file appender with customizable rolling conditions

atosl

A partial replacement for Apple's atos tool for converting binary addresses to symbols

cf-gears-toolkit

Core ToolKit library

secra-logger

一个生产级的 Rust 日志系统库，基于 tracing 生态系统构建，支持结构化 JSON 日志、文件滚动、UTC+8 时区等特性

tracelite

An alternative to the tracing crate which is specialized for OpenTelemetry traces

pcf-debug

Inspection and visualisation tool for Partitioned Container Format (PCF) files

obs-tracing-bridge

Bidirectional bridge between tracing and the obs SDK

rustlog

A small, dependency-light logging crate with a pragmatic API, color (optional), groups, and a scope timer

tell

Tell analytics SDK for Rust — events and structured logging

tracing-rfc-5424

A tracing layer that writes to syslog

slog-loggly

unofficial Loggly drain for the slog logging infrastructure in Rust

bimm-contracts

Runtime shape/geometry contracts for the burn framework

wp-error

Structured, domain-specific error types and robustness strategies extracted from WarpParse

bt_logger

lightweight Rust log library with support for log level. Can Generate Log meessage only. Log to a file. Fail silently with warn msg.

debug_tree

Build a tree one element at a time and output it as a pretty string

metrics-opentelemetry

Opentelemetry recorder for metrics crate

garbage-code-hunter

A humorous Rust code quality detector that roasts your garbage code

nih_assert_no_alloc

Custom Rust allocator allowing to temporarily disable memory (de)allocations for a thread. Aborts or prints a warning if allocating although forbidden.

deloxide

scrubs your threads clean by detecting deadlocks in real time—keeping your system smooth, safe, and corrosion-free. 🦀🧼🔒

e-log

log

await-tree

Generate accurate and informative tree dumps of asynchronous tasks

a3s-box-sdk

Rust SDK for a3s-box direct runtime-backed management APIs

agx-tui

Step-through debugger for your agent — terminal-native session timeline viewer for Claude Code, Codex, Gemini, LangChain, Vercel AI SDK, and OpenTelemetry GenAI traces

hx-telemetry

Telemetry and tracing for hx

glitchtip-cli

Open source CLI for GlitchTip

prologger

A production-grade, ergonomic Rust logging library with colored output, file rotation, and structured formatting

simple-log

log. It's really simple use

libdd-trace-normalization

A duplicate of trace normalization implemented in the agent in https://github.com/DataDog/datadog-agent/blob/main/pkg/trace/traceutil/normalize.go

indicio

framework for emitting clues that may be used for debugging

cirious_codex_logger

Structured logging library for the Cirious Codex ecosystem

gensense

High-performance semantic diagnostic engine for Rust, TypeScript, and Solidity

phlow-engine

Engine for Phlow, a fast, modular runtime for building backends with YAML flows, Rust modules, and native OpenTelemetry observability

cmsis-pack

managing CMSIS Packs

micromegas-tracing

instrumentation module, part of micromegas

nice-log

An opinionated yet flexible logger catering to the needs of the nice-plug plugin framework

nemo-relay

Core Rust SDK for NeMo Relay observability, scope management, and runtime instrumentation

tiny_bail

Small but flexible macros for bailing on failure

rust-telemetry

Observability helpers originally developed for internal use at Famedly

cargo-depsize

Rust cargo utility that calculates and displays the total size of each dependency in your Rust project

errsight

Rust client for ErrSight error tracking — captures panics, errors, and log/tracing events and ships them to the ErrSight API from a background thread

sideways-otel

Observability from the side - vendor-neutral OpenTelemetry tracing, metrics, and logs for Rust services

embeddenator-obs

Observability: metrics, logging, and tracing for Embeddenator

radio_datetime_analyzer

Analyzer for log files of time station decoders

livetrace

CLI tool for live tailing of OTLP traces and logs in the Serverless OTLP Forwarder architecture

droidrun-adb

Async ADB (Android Debug Bridge) client library — wire protocol + sync protocol over TCP

rig-tap

Backend-agnostic observability event schema and taps for Rig agents (prompt/tool lifecycle + context-size sampling)

nanologger

A minimal, colored logger for Rust CLI applications

metrics-sqlite

providing SQLite backend for metrics

zakat-cli

Interactive CLI tool for Zakat calculations and debugging

litcat

A CLI tool for viewing patches with colors

logana

Turn any log source — files, compressed archives, Docker, or OTel streams — into structured data. Filter by pattern, field, or date range; annotate lines; bookmark findings; and export to Markdown…

tonic-debug

A debugging and diagnostics middleware for tonic gRPC servers

grlog

A high-performance async logging library based on gorust GMP runtime

casr

Collect crash reports, triage, and estimate severity

novmforbroadcom

VM detection library – detect hypervisors, sandboxes, and virtual machines with syscall-spoofed Windows NT calls (Hell's Gate) to evade AV/EDR hooks

init-tracing-opentelemetry

A set of helpers to initialize (and more) tracing + opentelemetry (compose your own or use opinionated preset)

acta

Make Tracing Great Again

slogx

Real-time log streaming SDK for Rust

leaktracer

allocator to trace memory allocations in Rust programs, by intercepting the allocations

mpigdb

A wrapper arround mpiexec, gdbserver, and gdb that makes debugging MPI programs eaiser

lob-orderbook

High-performance limit order book with real-time market depth updates, NATS integration, and SQLite metrics

FreedomLogger

A professional, reusable logging library with pattern formatting, log rotation, and file management

detrix-rs

Detrix client library for debug-on-demand observability in Rust applications

bulletin-board-server

Object storage for ArrayObject for debugging and data taking purposes

debug_unsafe

Uses debug-assertions as a switch of safe/unsafe behaviour

tracing-systemd

A tracing-subscriber Layer that pretty-prints span chains to stdout and/or the systemd journal

provekit_noir_debugger

Debugger for Noir

platform_common

Common utilities and middleware for microservices: trace-id, structured logging, HTTP propagation, RabbitMQ with auto-reconnect

mlua-probe-core

Core debug engine for mlua — breakpoints, stepping, variable inspection

ax-log

Macros for multi-level formatted logging used by ArceOS

forensic-adb

Tokio based client library for the Android Debug Bridge (adb) based on mozdevice

tinylog

A logger for my personal projects

cyrs-ffi

Stable C ABI over the Cypher / GQL frontend (cyrs-lang-services + cyrs-db + cyrs-diag + cyrs-fmt). Produces a cdylib + staticlib + cbindgen-generated header; spec 0004 §5.

tracing-error

enriching errors with tracing

slog-scope

Logging scopes for slog-rs

syslog-tracing

syslog backend for tracing

jsonl_logger

Async queue-based structured logging with JSONL output

minidump-stackwalk

Analyzes minidumps and produces a report (either human-readable or JSON)

cuenv-events

Structured event system for cuenv - enables multiple UI frontends via unified event stream

lupa

Interactive object inspector for Rust — web UI + TUI + snapshot diffing

metrics-exporter-statsd

metrics-rs exporter that supports reporting metrics to StatsD

stepshots-cli

CLI for recording, bundling, and uploading Stepshots demos

waddling-errors

Structured, secure-by-default diagnostic codes for distributed systems with no_std and role-based documentation

dirty-debug

Quick and dirty debugging

turbohex

Interactive terminal hex-viewer with plugin-based decoders

iceyee_logger

Logger

call_logger

A logger that calls another application for every logged item

rolly

Lightweight Rust observability. Hand-rolled OTLP protobuf over HTTP, built on tracing.

defmt-decoder

Decodes defmt log frames

gitpilot

A Git assistant for daily developer workflow

sentry-panic

Sentry integration for capturing panics

openlatch-client

The open-source security layer for AI agents — client forwarder

seqknock-nftables

TCP Sequence number-based knocking; nftables based server protector

stracers

Command-line utility to trace system calls and signals

pylogging

A small, ergonomic logging library inspired by Python's logging module

symbolic-debuginfo

inspect and load DWARF debugging information from binaries, such as Mach-O or ELF

radius2

a fast symbolic execution framework using r2

mozilla/neqo-common

Neqo, an implementation of QUIC written in Rust

exfiltrate

An embeddable debug tool for Rust

piquel-log

Small, composable backend initialization for tracing

rgbobj

A command-line program to print out RGBDS object files

vasm

Visualize 8086 assembly execution in your terminal

kcr_kafka_stackable_tech

Kubernetes Custom Resource Bindings

spandoc

Procedural macro attribute for converting doc comments into tracing spans