///|
/// Metadata-only filter expression used by `Dispatch`.
pub(all) enum Filter {
LevelFilter(Level)
TargetFilter(Map[String, Level])
AndFilter(Filter, Filter)
} derive(Debug)
///|
#deprecated
#doc(hidden)
pub extend Filter with Debug::{to_repr}
///|
priv struct Lane {
filter : Filter?
subscriber : &Subscriber
}
///|
fn filter_allows(filter : Filter, metadata : Metadata) -> Bool {
match filter {
LevelFilter(max_level) => max_level.allows(metadata.level)
TargetFilter(levels) =>
match levels.get(metadata.target) {
Some(max_level) => max_level.allows(metadata.level)
None => false
}
AndFilter(lhs, rhs) =>
filter_allows(lhs, metadata) && filter_allows(rhs, metadata)
}
}
///|
fn lane_allows(lane : Lane, metadata : Metadata) -> Bool {
match lane.filter {
Some(filter) => filter_allows(filter, metadata)
None => true
}
}
///|
fn derive_target(loc : SourceLoc) -> String {
let encoded = loc.to_string()
match encoded.rev_find("@") {
Some(index) if index + 1 < encoded.length() =>
encoded[index + 1:].to_owned()
_ => "unknown"
}
}
///|
fn normalize_target(target : String?, loc : SourceLoc) -> String {
match target {
Some(target) => target
None => derive_target(loc)
}
}
///|
/// `Dispatch` is the filtering and fanout authority for tracing records.
pub struct Dispatch {
priv lanes : Array[Lane]
}
///|
/// Create a dispatch that never enables any event or span.
pub fn Dispatch::noop() -> Dispatch {
{ lanes: [], }
}
///|
/// Create a dispatch with a single unfiltered subscriber lane.
pub fn Dispatch::from_subscriber(subscriber : &Subscriber) -> Dispatch {
{ lanes: [{ filter: None, subscriber, }], }
}
///|
/// Combine multiple dispatches into a single fanout dispatch.
pub fn Dispatch::fanout(dispatches : ArrayView[Dispatch]) -> Dispatch {
let lanes : Array[Lane] = []
for dispatch in dispatches {
for lane in dispatch.lanes {
lanes.push(lane)
}
}
{ lanes, }
}
///|
/// Return a dispatch that additionally applies `filter` to every existing lane.
pub fn Dispatch::filtered(self : Dispatch, filter : Filter) -> Dispatch {
let lanes : Array[Lane] = []
for lane in self.lanes {
let filter = match lane.filter {
Some(existing) => Some(AndFilter(existing, filter))
None => Some(filter)
}
lanes.push({ filter, subscriber: lane.subscriber, })
}
{ lanes, }
}
///|
fn Dispatch::select_lanes(self : Dispatch, metadata : Metadata) -> Array[Lane] {
let lanes : Array[Lane] = []
for lane in self.lanes {
if lane_allows(lane, metadata) {
lanes.push(lane)
}
}
lanes
}