### Installation and Namespace Setup for Telemere

Source: https://context7.com/taoensso/telemere/llms.txt

Instructions for adding the Telemere dependency using Leiningen or deps.edn, followed by namespace setup for use in Clojure applications.

```clojure
;; Leiningen
[com.taoensso/telemere "1.2.1"]

;; deps.edn
com.taoensso/telemere {:mvn/version "1.2.1"}

;; Namespace setup
(ns my-app
  (:require [taoensso.telemere :as tel]))
```

--------------------------------

### Telemere Logging with Argument Preparation and Structured Data

Source: https://github.com/taoensso/telemere/wiki/6-FAQ

Illustrates logging a message after preparing arguments using `:let` bindings for transformation and including structured data in `:data`. The example shows how transformed data is used in the final message.

```clojure
;; With arg prep
(let [user-arg "Bob"
      usd-balance-str "22.4821"]

  (tel/log!
    {:let
     [username (clojure.string/upper-case user-arg)
      usd-balance (parse-double usd-balance-str)]

     :data
     {:username    username
      :usd-balance usd-balance}}

    ["User" username "has balance:" (str "$" (Math/round usd-balance))]))

;; %> {:msg "User BOB has balance: $22" ...}
```

--------------------------------

### Example of log! usage with let bindings

Source: https://github.com/taoensso/telemere/blob/master/wiki/6-FAQ.md

Illustrates the typical usage of `log!` where the options map, including let bindings, is passed first, followed by a message that may depend on those bindings. This highlights the left-to-right readability for complex arguments.

```clojure
(log! {:id ::my-id,
       :let […]} 
      <message depending on let bindings>)
```

--------------------------------

### Example of event! usage with data

Source: https://github.com/taoensso/telemere/blob/master/wiki/6-FAQ.md

Demonstrates the common usage pattern of `event!` where the options map, potentially containing multi-line data, is passed as the last argument, followed by the event ID.

```clojure
(event! {:data <multi-line>}
        ::dangling-id)
```

--------------------------------

### Switching Namespace Imports from Timbre to Telemere

Source: https://github.com/taoensso/telemere/wiki/5-Migrating

This example shows how to update namespace imports to use Telemere's shim for Timbre compatibility. This allows existing Timbre logging calls to be redirected to Telemere without immediate code rewrites.

```clojure
(ns my-ns
  (:require [taoensso.timbre          :as timbre :refer [...]]) ; Old
  (:require [taoensso.telemere.timbre :as timbre :refer [...]]) ; New
  )
```

--------------------------------

### Structured Logging Example in Clojure

Source: https://github.com/taoensso/telemere/blob/master/README.md

This snippet demonstrates how to perform structured logging using the Telemere library. It shows logging an informational message with an ID and associated data. This approach retains rich data types and structures throughout the logging pipeline.

```clojure
(tel/log! {:level :info, :id ::login, :data {:user-id 1234}, :msg "User logged in!"})
```

--------------------------------

### Log a Signal with Telemere

Source: https://github.com/taoensso/telemere/wiki/4-Handlers

Example of how to log a signal using the Telemere library's `log!` function. This demonstrates the typical input format for logging signals.

```clojure
(tel/log! {:id ::my-id, :data {:x1 :x2}} "My message") =>
```

--------------------------------

### Create a Customizable Handler Constructor in Clojure/Script

Source: https://github.com/taoensso/telemere/wiki/4-Handlers

Shows how to create a handler constructor function for reusable, customizable signal handlers. This pattern allows for options validation and setup before the actual handler function is created.

```clojure
(defn handler:my-fancy-handler ; Note constructor naming convention
  "Needs `some-lib`, Ref. <https://github.com/example/some-lib>.

  Returns a signal handler that:
    - Takes a Telemere signal (map).
    - Does something useful with the signal!

  Options:
    `:option1` - Option description
    `:option2` - Option description

  Tips:
    - Tip 1
    - Tip 2"

  ([] (handler:my-fancy-handler nil)) ; Use default opts (iff defaults viable)
  ([{:as constructor-opts}]

   ;; Do option validation and other prep here, i.e. try to keep
   ;; expensive work outside handler function when possible!

   (let [handler-fn ; Fn of exactly 2 arities (1 and 0)
         (fn a-handler:my-fancy-handler ; Note fn naming convention

           ([signal] ; Arity-1 called when handling a signal
            ;; Do something useful with the given signal (write to
            ;; console/file/queue/db, etc.). Return value is ignored.
            )

           ([] ; Arity-0 called when stopping the handler
            ;; Flush buffers, close files, etc. May just noop.
            ;; Return value is ignored.
            ))]

     ;; (Advanced, optional) You can use metadata to provide default
     ;; handler dispatch options (see `help:handler-dispatch-options`)

     (with-meta handler-fn
       {:dispatch-opts
        {:min-level :info
         :limit
         [[1   1000] ; Max 1  signal  per second
          [10 60000] ; Max 10 signals per minute
          ]}}))))
```

--------------------------------

### Filter Signals with Telemere

Source: https://github.com/taoensso/telemere/blob/master/README.md

Explains how to filter signals based on level, ID, and namespace using Telemere's configuration functions. It also demonstrates using transformation functions (xfns) to arbitrarily modify or filter signals based on their content, with examples for disabling signals.

```clojure
;; Set minimum level
(tel/set-min-level!       :warn) ; For all    signals
(tel/set-min-level! :log :debug) ; For `log!` signals specifically

;; Set id and namespace filters
(tel/set-id-filter! {:allow #{::my-particular-id "my-app/*"}})
(tel/set-ns-filter! {:disallow "taoensso.*" :allow "taoensso.sente.*"})

;; SLF4J signals will have their `:ns` key set to the logger's name
;; (typically a source class)
(tel/set-ns-filter! {:disallow "com.noisy.java.package.*"})

;; Set minimum level for `log!` signals for particular ns pattern
(tel/set-min-level! :log "taoensso.sente.*" :warn)

;; Use transforms (xfns) to filter and/or arbitrarily modify signals
;; by signal data/content/etc.

(tel/set-xfn!
  (fn [signal]
    (if (-> signal :data :skip-me?)
      nil ; Filter signal (don't handle)
      (assoc signal :transformed? true))))

(tel/with-signal (tel/log! {... :data {:skip-me? true}}))  ; => nil
(tel/with-signal (tel/log! {... :data {:skip-me? false}})) ; => {...}

;; See `tel/help:filters` docstring for more filtering options

```

--------------------------------

### Log Creation with `log!` - Clojure

Source: https://github.com/taoensso/telemere/wiki/6-FAQ

Illustrates the argument order for the `log!` function, showing how it takes an options map (potentially including `:let` bindings) as the first argument, followed by a message that might depend on those bindings. This serves as a comparison to `event!`.

```clojure
(log! {:id ::my-id, :let […]} <message depending on let bindings>)
```

--------------------------------

### Minimal Telemere Signal Handler (Clojure)

Source: https://github.com/taoensso/telemere/wiki/4-Handlers

A basic signal handler function in Clojure that accepts a signal map and prints it to the console. This serves as a starting point for custom signal processing.

```clojure
(fn [signal] (println signal))
```

--------------------------------

### Clojure: Log Message with Argument Preparation

Source: https://github.com/taoensso/telemere/blob/master/wiki/6-FAQ.md

Illustrates how to prepare arguments before logging in Clojure using `:let` for transformations and `:data` for structured payload. The final message is constructed using these prepared arguments.

```clojure
(let [user-arg "Bob"
      usd-balance-str "22.4821"]

  (tel/log!
    {:let
     [username (clojure.string/upper-case user-arg)
      usd-balance (parse-double usd-balance-str)]

     :data
     {:username    username
      :usd-balance usd-balance}}

    ["User" username "has balance:" (str "$" (Math/round usd-balance))]))

;; %> {:msg "User BOB has balance: $22" ...}
```

--------------------------------

### Direct usage of signal! for flexible argument ordering

Source: https://github.com/taoensso/telemere/blob/master/wiki/6-FAQ.md

Shows how to use the `signal!` function directly, which accepts a single map argument, allowing for flexible specification of all arguments in any preferred order. This is recommended for users who prefer explicit control.

```clojure
(signal! {:event-id ::my-event,
          :data {:key "value"},
          :opts {:other-opt true}})
```

--------------------------------

### Stateful Telemere Signal Handler with Stop Arity (Clojure)

Source: https://github.com/taoensso/telemere/wiki/4-Handlers

An example of a stateful signal handler in Clojure that includes a second 0-argument arity for cleanup or stopping logic. This is useful for managing resources or state within a handler.

```clojure
(fn my-handler
  ([signal] (println signal))
  ([] (my-stop-code)))
```

--------------------------------

### Generic Signal Creation with `signal!` - Clojure

Source: https://github.com/taoensso/telemere/wiki/6-FAQ

Shows how to use the `signal!` function, which accepts a single map argument, allowing for flexible specification of all arguments in a preferred order. This is presented as an alternative for users who prefer explicit control over argument ordering.

```clojure
(signal! {:event ::my-event, :data {:key "value"}, :opts {:timeout 1000}})
```

--------------------------------

### Logging Fixed and Joined Messages with Telemere

Source: https://github.com/taoensso/telemere/wiki/6-FAQ

Demonstrates how to log a simple fixed string message and a message constructed by joining elements in a vector. The output shows the structured log format generated by Telemere.

```clojure
;; A fixed message (string arg)
(tel/log! "A fixed message") ; %> {:msg "A fixed message"}

;; A joined message (vector arg)
(let [user-arg "Bob"]
  (tel/log! ["User" (str "`" user-arg "`") "just logged in!"]))
;; %> {:msg_ "User `Bob` just logged in!` ...}
```

--------------------------------

### Measuring Lazy/Async Code Execution with Spy in Clojure

Source: https://github.com/taoensso/telemere/blob/master/main/resources/docs/spy!.txt

Explains the limitation of 'spy!' in measuring the runtime of lazy or asynchronous code directly. It demonstrates the correct approach by ensuring the code's cost is realized within the 'spy!' call, for example, by dereferencing a delay.

```clojure
(spy!  (delay (my-slow-code))) ; Doesn't measure slow code
(spy! @(delay (my-slow-code))) ; Does    measure slow code
```

--------------------------------

### Telemere Logging with `str` and `format` Functions

Source: https://github.com/taoensso/telemere/wiki/6-FAQ

Shows how to construct log messages using standard Clojure functions like `str` and `format`. This highlights Telemere's flexibility in allowing any code execution for message generation.

```clojure
(tel/log! (str "This message " "was built " "by `str`"))
;; %> {:msg "This message was built by `str`"}

(tel/log! (format "This message was built by `%s`" "format"))
;; %> {:msg "This message was built by `format`"}
```

--------------------------------

### Create Signals with Telemere

Source: https://github.com/taoensso/telemere/blob/master/README.md

Demonstrates how to create various types of signals using Telemere's log! and trace! functions. Supports traditional, modern, and mixed logging styles, as well as advanced features like sampling, rate limiting, and conditional execution. No explicit configuration is needed for basic console output.

```clojure
(require '[taoensso.telemere :as tel])

;; No config needed for typical use cases!!
;; Signals print to console by default for both Clj and Cljs

;; Traditional style logging (data formatted into message string):
(tel/log! {:level :info, :msg (str "User " 1234 " logged in!")})

;; Modern/structured style logging (explicit id and data)
(tel/log! {:level :info, :id :auth/login, :data {:user-id 1234}})

;; Mixed style (explicit id and data, with message string)
(tel/log! {:level :info, :id :auth/login, :data {:user-id 1234}, :msg "User logged in!"})

;; Trace (can interop with OpenTelemetry)
;; Tracks form runtime, return value, and (nested) parent tree
(tel/trace! {:id ::my-id :data {...}}
  (do-some-work))

;; Check resulting signal content for debug/tests
(tel/with-signal (tel/log! {...})) ; => {:keys [ns level id data msg_ ...]})

;; Getting fancy (all costs are conditional!)
(tel/log!
  {:level    :debug
   :sample   0.75 ; 75% sampling (noop 25% of the time)
   :when     (my-conditional)
   :limit    {"1 per sec" [1  1000]
              "5 per min" [5 60000]} ; Rate limit
   :limit-by my-user-ip-address      ; Rate limit scope

   :do (inc-my-metric!)
   :let
   [diagnostics (my-expensive-diagnostics)
    formatted   (my-expensive-format diagnostics)]

   :data
   {:diagnostics diagnostics
    :formatted   formatted
    :local-state *my-dynamic-context*}}

  ;; Message string or vector to join as string
  ["Something interesting happened!" formatted])

```

--------------------------------

### Create Telemere Signals with Wrapper Macros

Source: https://github.com/taoensso/telemere/wiki/1-Getting-started

Demonstrates creating signals using wrapper macros like log!, event!, trace!, spy!, error!, and catch->error!. These macros simplify signal creation by providing different :kind values and optimized arguments for specific use cases. They can also accept a single options map.

```clojure
;; Example using log!
(tel/log! :info "This is an informational message.")

;; Example using event!
(tel/event! :user-login "user123")

;; Example using trace!
(tel/trace! (some-computation))

;; Example using spy!
(tel/spy! :debug (complex-function arg1 arg2))

;; Example using error!
(tel/error! :database-error (get-db-connection))

;; Example using catch->error!
(tel/catch->error! :network-error (fetch-data url))

;; All macros can accept an options map
(tel/log! {:level :warn :data {:user "admin"}} "Admin action performed.")
```

--------------------------------

### Event Creation with `event!` - Clojure

Source: https://github.com/taoensso/telemere/wiki/6-FAQ

Demonstrates the typical usage of the `event!` function, highlighting its argument order where the event ID keyword precedes the options map containing data. This contrasts with other signal creators in the telemere library.

```clojure
(event! ::dangling-id {:data <multi-line>})
```

--------------------------------

### Signal Creation Macros

Source: https://github.com/taoensso/telemere/wiki/1-Getting-started

Telemere provides several wrapper macros for creating signals, each with a different `:kind` value and optimized arguments for specific use cases. The low-level `signal!` macro is also available.

```APIDOC
## Signal Creation Macros

Telemere's signals are all created using the low-level `signal!` macro. You can use that directly, or one of the wrapper macros like `log!`.

Several different wrapper macros are provided. The only difference between them:

  1. They create signals with a different `:kind` value (which can be handy for filtering, etc.).
  2. They have different positional arguments and/or return values optimised for concise calling in different use cases.

**NB:** ALL wrapper macros can also just be called with a single [opts](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#help:signal-options) map!

See the linked docstrings below for more info:

| Name                                                                                                        | Args                       | Returns                      |
| :---------------------------------------------------------------------------------------------------------- | :------------------------- | :--------------------------- |
| [`log!`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#log!)                     | `[opts]` or `[?level msg]` | nil                          |
| [`event!`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#event!)                 | `[opts]` or `[id ?level]`  | nil                          |
| [`trace!`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#trace!)                 | `[opts]` or `[?id run]`    | Form result                  |
| [`spy!`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#spy!)                     | `[opts]` or `[?level run]` | Form result                  |
| [`error!`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#error!)                 | `[opts]` or `[?id error]`  | Given error                  |
| [`catch->error!`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#catch-%3Eerror!) | `[opts]` or `[?id error]`  | Form value or given fallback |
| [`signal!`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#signal!)               | `[opts]`                   | Depends on opts              |
```

--------------------------------

### Clojure: Log Messages using `str` and `format`

Source: https://github.com/taoensso/telemere/blob/master/wiki/6-FAQ.md

Shows how to construct log messages in Clojure using the built-in `str` function for string concatenation and the `format` function for formatted strings. This highlights the flexibility in message building.

```clojure
(tel/log! (str "This message " "was built " "by `str`"))
;; %> {:msg "This message was built by `str`"}

(tel/log! (format "This message was built by `%s`" "format"))
;; %> {:msg "This message was built by `format"}
```

--------------------------------

### Integrate Tufte Performance Data with Telemere

Source: https://github.com/taoensso/telemere/wiki/3-Config

Demonstrates how to capture performance data using Tufte's profiling and then log this data as a Telemere signal. This allows for performance metrics to be included alongside other telemetry data.

```clojure
(let [[_ perf-data] (tufte/profiled <opts> <form>)]
  (tel/log! {:perf-data perf-data} "Performance data"))
```

--------------------------------

### Check All Telemere Signals with with-signals

Source: https://github.com/taoensso/telemere/wiki/1-Getting-started

Demonstrates the use of `with-signals` to capture all signals generated within a specific form. This utility is valuable for scenarios where multiple signals might be produced and need to be examined collectively.

```clojure
;; Assuming a form that generates multiple signals
(tel/with-signals
  (do
    (tel/log! "First signal")
    (tel/event! "Second signal")))

;; => (list of signal maps)
```

--------------------------------

### Add Handlers with Telemere

Source: https://github.com/taoensso/telemere/blob/master/README.md

Shows how to add custom signal handlers to Telemere, including options for asynchronous processing, priority, sampling, and filtering. It also demonstrates adding built-in console handlers for formatted output (text, edn, JSON) and how to integrate with external JSON libraries.

```clojure
;; Add your own signal handler
(tel/add-handler! :my-handler
  (fn
    ([signal] (println signal))
    ([] (println "Handler has shut down"))))

;; Use `add-handler!` to set handler-level filtering and back-pressure
(tel/add-handler! :my-handler
  (fn
    ([signal] (println signal))
    ([] (println "Handler has shut down")))

  {:async {:mode :dropping, :buffer-size 1024, :n-threads 1}
   :priority  100
   :sample    0.5
   :min-level :info
   :ns-filter {:disallow "taoensso.*"}
   :limit     {"1 per sec" [1 1000]}
   ;; See `tel/help:handler-dispatch-options` for more
   })

;; See current handlers
(tel/get-handlers) ; => {<handler-id> {:keys [handler-fn handler-stats_ dispatch-opts]}}

;; Add console handler to print signals as human-readable text
(tel/add-handler! :my-handler
  (tel/handler:console
    {:output-fn (tel/format-signal-fn {})}))

;; Add console handler to print signals as edn
(tel/add-handler! :my-handler
  (tel/handler:console
    {:output-fn (tel/pr-signal-fn {:pr-fn :edn})}))

;; Add console handler to print signals as JSON
;; Ref.  <https://github.com/metosin/jsonista> (or any alt JSON lib)
#?(:clj (require '[jsonista.core :as jsonista]))
(tel/add-handler! :my-handler
  (tel/handler:console
    {:output-fn
     #?(:cljs :json ; Use js/JSON.stringify
        :clj   jsonista/write-value-as-string)}))

```

--------------------------------

### Configure Global Minimum Signal Level

Source: https://github.com/taoensso/telemere/wiki/1-Getting-started

Shows how to set a global minimum level for signal processing using `set-min-level!`. Signals below this level will be filtered out by default. This provides a coarse-grained control over signal verbosity.

```clojure
(tel/set-min-level! :info) ; Set global minimum level to :info

(tel/with-signal (tel/log! {:level :info  ...})) ; => {:keys [inst id ...]} (Signal is allowed)
(tel/with-signal (tel/log! {:level :debug ...})) ; => nil (Signal is filtered out)
```

--------------------------------

### Adding Custom Data to Signals in Telemere

Source: https://github.com/taoensso/telemere/wiki/7-Tips

Demonstrates how to include arbitrary application-level data within Telemere signals. These custom keys are added to the signal and are also available under the ':kvs' key, useful for custom transforms or handlers.

```clojure
(tel/with-signal (tel/log! {:my-key "foo"} "My message"))
;; => {:my-key "foo", :kvs {:my-key "foo", ...}, ...}
```

--------------------------------

### Basic Spy Signal Creation in Clojure

Source: https://github.com/taoensso/telemere/blob/master/main/resources/docs/spy!.txt

Demonstrates the fundamental usage of the 'spy!' function to trace a simple arithmetic operation. The resulting signal includes the run form, its value, and execution time. It also shows how to specify a debug level.

```clojure
(spy! (+ 1 2))
; %> {:kind :trace, :level :info, :run-form '(+ 1 2),
;     :run-val 3, :run-nsecs <int>, :parent {:keys [id uid]}
;     :msg "(+ 1 2) => 3" ...}

(spy! :debug (+ 1 2))
; %> {... :level :debug ...}
```

--------------------------------

### Import Telemere Namespace in Clojure/Script

Source: https://github.com/taoensso/telemere/wiki/1-Getting-started

This code demonstrates how to import the Telemere library into your Clojure/Script namespace for use in your application. It uses a common alias 'tel' for brevity.

```clojure
(ns my-app (:require [taoensso.telemere :as tel]))
```

--------------------------------

### Signal Checking Utilities

Source: https://github.com/taoensso/telemere/wiki/1-Getting-started

The `with-signal` and `with-signals` utilities can be used to test and debug signal creation. `with-signal` returns the last signal created, while `with-signals` returns all signals.

```APIDOC
## Checking signals

Use the [`with-signal`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#with-signal) or (advanced) [`with-signals`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#with-signals) utils to help test/debug the signals that you're creating:

```clojure
(tel/with-signal
  (tel/log!
    {:let  [x "x"]
     :data {:x x}}
    ["My msg:" x]))

;; => {:keys [ns inst data msg_ ...]} ; The signal
```

- [`with-signal`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#with-signal) will return the **last** signal created by the given form.
- [`with-signals`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#with-signals) will return **all** signals created by the given form.

Both have several options, see their docstrings (links above) for details.
```

--------------------------------

### Checking and Debugging Signals

Source: https://github.com/taoensso/telemere/blob/master/wiki/1-Getting-started.md

The `with-signal` and `with-signals` utilities are provided to help test and debug signal creation. `with-signal` returns the last signal created by a form, while `with-signals` returns all signals created by a form. Both utilities accept options for further customization.

```APIDOC
## Checking Signals

Use the [`with-signal`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#with-signal) or (advanced) [`with-signals`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#with-signals) utils to help test/debug the signals that you're creating:

```clojure
(tel/with-signal
  (tel/log!
    {:let  [x "x"]
     :data {:x x}}
    ["My msg:" x]))

;; => {:keys [ns inst data msg_ ...]} ; The signal
```

- [`with-signal`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#with-signal) will return the **last** signal created by the given form.
- [`with-signals`](https://cljdoc.org/d/com.taoensso/telemere/CURRENT/api/taoensso.telemere#with-signals) will return **all** signals created by the given form.

Both have several options, see their docstrings (links above) for details.
```

--------------------------------

### Redirect Timbre Output to Telemere using Appender

Source: https://github.com/taoensso/telemere/wiki/5-Migrating

This code snippet demonstrates how to redirect Timbre's logging output to Telemere by configuring a specific Timbre appender. It suggests disabling other Timbre appenders and filtering for a cleaner transition.

```clojure
(ns my-ns
  (:require [taoensso.timbre :as timbre :refer [timbre->telemere-appender ...]])) ; Add timbre->telemere-appender to refer
```

--------------------------------

### Check Telemere Signals with with-signal

Source: https://github.com/taoensso/telemere/wiki/1-Getting-started

Illustrates how to use the `with-signal` utility to capture and inspect the last signal created within a given form. This is useful for testing and debugging signal generation.

```clojure
(tel/with-signal
  (tel/log!
    {:let  [x "x"]
     :data {:x x}}
    ["My msg:" x]))

;; => {:keys [ns inst data msg_ ...]} ; The signal
```

--------------------------------

### Create and Check Telemere Signals

Source: https://github.com/taoensso/telemere/blob/master/wiki/1-Getting-started.md

Demonstrates the creation of a log signal with custom data and checking its output using `with-signal`. This function is useful for debugging and verifying signal generation.

```clojure
(tel/with-signal
  (tel/log!
    {:let  [x "x"]
     :data {:x x}}
    ["My msg:" x]))

;; => {:keys [ns inst data msg_ ...] ; The signal
```

--------------------------------

### Migrate from Timbre to Telemere (Clojure)

Source: https://context7.com/taoensso/telemere/llms.txt

Facilitate migration from Timbre to Telemere using a compatibility shim. This can be done by changing the namespace import for new code or by redirecting Timbre's output to Telemere via a custom appender. Both methods allow existing Timbre API calls to function seamlessly.

```clojure
;; Option 1: Change namespace import (recommended for new code)
(ns my-app
  ;; Old: (:require [taoensso.timbre :as timbre])
  (:require [taoensso.telemere.timbre :as timbre]))

;; Timbre API works as before
(timbre/info "This works!")
(timbre/warn {:user-id 123} "Warning with data")

;; Option 2: Redirect Timbre output to Telemere
(require '[taoensso.telemere.timbre :as tel-timbre])
(require '[taoensso.timbre :as timbre])

;; Add Telemere appender to Timbre
(timbre/merge-config!
  {:appenders
   {:telemere (tel-timbre/timbre->telemere-appender)}})
```

--------------------------------

### Filter Signals by Namespace

Source: https://github.com/taoensso/telemere/wiki/1-Getting-started

Demonstrates how to filter signals based on their originating namespace using `set-ns-filter!`. This allows for disabling signals from specific namespaces entirely, aiding in managing signal noise.

```clojure
;; Disallow all signals in namespaces starting with "some.nosy.namespace."
(tel/set-ns-filter! {:disallow "some.nosy.namespace.*"})
```