telemere

Provide structured logging and telemetry for Clojure and ClojureScript applications.

3|Updated Nov 10, 2025
One-click install
npx skills add https://github.com/hugoduncan/library-skills --skill telemere
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: telemere
Source: https://github.com/hugoduncan/library-skills/tree/main/plugins/clojure-libraries/skills/telemere
Command: npx skills add https://github.com/hugoduncan/library-skills --skill telemere

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires com.taoensso/telemere, and includes scripts (resource) components.

What problem does it solve?

This Skill unifies logging, tracing, and performance monitoring, eliminating fragmented insights and reducing complexity in Clojure applications.

Core Features & Use Cases

  • Unified API for Observability: Log, trace, and monitor performance with a single, consistent API, simplifying your application's observability stack.
  • Structured Telemetry: Capture rich, structured data for every event, enabling powerful analysis without the need for string parsing.
  • Intelligent Filtering & Elision: Optimize performance with compile-time signal removal and runtime filtering based on level, namespace, ID, and sampling.
  • Use Case: Instrument your microservice architecture to automatically generate distributed traces for every incoming request, log structured events for user actions, and monitor the execution time of critical functions, providing a holistic view of system behavior and performance bottlenecks.

Quick Start

Use the telemere skill to log an 'info' level message with structured data including a 'user-id' of 123 and an 'action' of 'login'.

Frequently Asked Questions about telemere

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement structured logging and tracing in Clojure applications?

Structured logging in Clojure captures rich, typed data as maps rather than formatted strings, enabling powerful filtering and analysis. Telemere provides a unified API for logging, tracing, and performance monitoring with compile-time signal elision and runtime filtering by level, namespace, ID, and sampling, integrating with OpenTelemetry, SLF4J, and tools.logging.

Can I use a single observability API for logs, traces, and metrics in Clojure?

Yes. Telemere unifies logging, tracing, and performance monitoring into one consistent API, eliminating fragmented observability stacks. It supports synchronous and asynchronous handlers, structured telemetry capture, and interoperability with standard observability tools, reducing complexity across microservice architectures.

What's the best way to reduce observability overhead in Clojure without losing visibility?

Intelligent filtering and compile-time signal elision optimize performance by removing unnecessary instrumentation before runtime. Telemere applies two-stage filtering—compile-time removal and runtime level/namespace/sampling-based filtering—to minimize overhead while preserving critical observability data for analysis.

Does Clojure observability work with OpenTelemetry and existing logging frameworks?

Yes. Telemere interoperates with OpenTelemetry, SLF4J, and tools.logging, integrating into existing Clojure and ClojureScript observability stacks. This compatibility enables distributed tracing, structured event logging, and performance monitoring without replacing your current infrastructure.

How do I instrument microservices to automatically generate distributed traces?

Telemere automatically generates distributed traces for incoming requests by capturing structured events with a unified API. Map-based signals enable rich context propagation across service boundaries, providing a holistic view of system behavior and performance bottlenecks in microservice architectures.

Can I use structured observability with ClojureScript applications?

Yes. Telemere supports both Clojure and ClojureScript, providing unified structured logging, tracing, and telemetry across your full stack. Compile-time signal elision and runtime filtering work in both languages, enabling consistent observability patterns.