lgwks_std 0.6.5

Everyday Rust primitives with no async runtime required: hex, base64, timestamps, UUIDs, hashing, glob matching, regex, JSON, RON, binary wire, blocking HTTP, and structured logging. One audited dependency stack per feature.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

//! Structured, levelled logging (feature `trace`, default-on).
//!
//! This module exists because the estate's PRINTS rule names a facility the
//! estate did not have. `AGENTS.md` forbids `println!`/`eprintln!` in library
//! code and says to *"use `tracing`"* — but `tracing` was absent from every
//! crate, so a library author following the rule had nothing to use, and one
//! ignoring it had `println!`. The rule was enforceable against the wrong
//! practice and unenforceable in favour of the right one.
//!
//! It is a re-export, like [`json`](crate::json): the estate names the
//! capability, not the crate, so replacing the implementation is one change
//! here rather than one per consumer.
//!
//! # What is here, and what is not
//!
//! The **macros and core types** are here, which is what calling code needs.
//! The `attributes` feature is deliberately not enabled — see the note in
//! `Cargo.toml` — so `#[instrument]` is unavailable from this path; it would
//! pull `syn` into the foundation crate.
//!
//! There is also **no subscriber**. `tracing` records; a separate crate
//! decides where records go. Bundling one would choose an output format, a
//! writer, and a filter syntax on behalf of every consumer, which is a
//! different decision from "the macros are available". A binary installs its
//! own subscriber; a library must only emit.
//!
//! # Levels
//!
//! `ERROR` — a broken contract. `WARN` — degraded but serving. `INFO` —
//! lifecycle. `DEBUG` — developer diagnostics. `TRACE` — wire-level.
//!
//! # Example
//!
//! ```
//! use lgwks_std::trace::{info, warn};
//!
//! // A library emits. With no subscriber installed these are near-free no-ops;
//! // the binary that links this installs the subscriber that decides where
//! // records go.
//! info!(bytes = 512, "read a record");
//! warn!(remaining = 3, "retry budget is nearly spent");
//! ```
//!
//! Structured fields, not interpolated strings: a subscriber can filter on
//! `bytes` without parsing the message, which is the property `println!` cannot
//! provide and the reason the estate bans it in library code.

pub use tracing::{self, Level};

pub use tracing::{debug, error, info, trace, warn};
pub use tracing::{debug_span, error_span, info_span, span, trace_span};
pub use tracing::{event, event_enabled};

pub use tracing::{Event, Span, Value};
// `Instrument` (the future combinator) is core; `#[instrument]` (the attribute)
// is not, because it lives behind the `attributes` feature this crate declines.
pub use tracing::Instrument;

/// Structured fields attached to an event or span.
///
/// Module rather than a re-export: call sites spell `field::Empty` and
/// `field::display`, so the path has to survive verbatim.
pub use tracing::field;