hotpath 0.19.1

//! hotpath-rs is a simple async Rust profiler. It instruments functions, channels, futures, and streams to quickly find bottlenecks and focus optimizations where they matter most.
//! It can provide actionable insights into time, memory, and data flow with minimal setup.
//! ## Setup & Usage
//! For a complete setup guide, examples, and advanced configuration, visit
//! [hotpath.rs](https://hotpath.rs).

#[cfg(all(
    feature = "hotpath-cpu",
    not(any(target_os = "macos", target_os = "linux"))
))]
compile_error!("the `hotpath-cpu` feature is only supported on macOS and Linux");

#[cfg(feature = "hotpath")]
#[doc(inline)]
pub use lib_on::*;
#[cfg(feature = "hotpath")]
mod lib_on;

#[cfg(feature = "hotpath")]
pub use lib_on::channels;
#[cfg(feature = "hotpath")]
pub use lib_on::futures;
#[cfg(feature = "hotpath")]
pub use lib_on::mutexes;
#[cfg(feature = "hotpath")]
pub use lib_on::sql;
#[cfg(feature = "hotpath")]
pub use lib_on::streams;
#[cfg(all(feature = "hotpath", feature = "threads"))]
pub use lib_on::threads;
#[cfg(all(feature = "hotpath", feature = "tokio"))]
pub use lib_on::tokio_runtime;

#[cfg(any(feature = "hotpath", feature = "utils", feature = "tui"))]
pub(crate) mod output;
#[cfg(feature = "hotpath")]
pub use output::format_debug_truncated;
#[cfg(any(feature = "hotpath", feature = "utils", feature = "tui"))]
pub use output::{
    ceil_char_boundary, floor_char_boundary, format_bytes, format_count, format_duration,
    format_percentile_header, format_percentile_key, format_rate, parse_bytes, parse_count,
    parse_duration, shorten_function_name, OutputDestination, ProfilingMode, MAX_LOG_LEN,
};

#[cfg(feature = "hotpath")]
pub(crate) mod output_on;

#[cfg(feature = "hotpath")]
pub(crate) mod metrics_server;

#[cfg(feature = "hotpath-mcp")]
pub(crate) mod mcp_server;

#[allow(dead_code)]
#[cfg(any(feature = "hotpath", feature = "utils", feature = "tui"))]
pub mod json;
#[cfg(any(feature = "hotpath", feature = "utils", feature = "tui"))]
pub use json::Route;

#[cfg(feature = "hotpath")]
#[doc(hidden)]
pub mod instant;
#[cfg(feature = "hotpath")]
pub(crate) mod tid;

#[cfg(not(feature = "hotpath"))]
#[doc(inline)]
pub use lib_off::*;
#[cfg(not(feature = "hotpath"))]
mod lib_off;

#[cfg(not(feature = "hotpath"))]
pub use lib_off::channels;
#[cfg(not(feature = "hotpath"))]
pub use lib_off::futures;
#[cfg(not(feature = "hotpath"))]
pub use lib_off::streams;
#[cfg(not(feature = "hotpath"))]
pub use lib_off::threads;

/// Mirror of `std` paths so instrumented types can be used as drop-in
/// replacements by prefixing imports with `hotpath::wrap::` (e.g.
/// `hotpath::wrap::std::sync::RwLock`).
///
/// These types expose `new(value)` (capturing the caller location as the
/// registered source) so existing `Type::new(..)` call sites keep compiling,
/// but it is deprecated: prefer the [`mutex!`](crate::mutex) /
/// [`rw_lock!`](crate::rw_lock) macros, which also accept a `label`.
pub mod wrap {
    pub mod std {
        pub mod sync {
            #[cfg(not(feature = "hotpath"))]
            pub use crate::lib_off::mutexes::{Mutex, MutexGuard};
            #[cfg(not(feature = "hotpath"))]
            pub use crate::lib_off::rw_locks::{RwLock, RwLockReadGuard, RwLockWriteGuard};
            #[cfg(feature = "hotpath")]
            pub use crate::lib_on::mutexes::wrapper::std::{Mutex, MutexGuard};
            #[cfg(feature = "hotpath")]
            pub use crate::lib_on::rw_locks::wrapper::std::{
                RwLock, RwLockReadGuard, RwLockWriteGuard,
            };

            /// Instrumented `std::sync::mpsc` channel endpoints for
            /// `channel!(..., wrap = true)`. With `hotpath` enabled these are the
            /// instrumented wrappers; otherwise `channel!` is a no-op and the endpoints
            /// are the raw std types, so the alias resolves the same way regardless of
            /// feature configuration.
            pub mod mpsc {
                #[cfg(feature = "hotpath")]
                pub use crate::lib_on::channels::wrapper::std_wrap::{
                    Receiver, Sender, SyncSender,
                };
                #[cfg(not(feature = "hotpath"))]
                pub use std::sync::mpsc::{Receiver, Sender, SyncSender};
            }
        }
    }

    #[cfg(feature = "parking_lot")]
    pub mod parking_lot {
        #[cfg(not(feature = "hotpath"))]
        pub use crate::lib_off::parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
        #[cfg(feature = "hotpath")]
        pub use crate::lib_on::rw_locks::wrapper::parking_lot::{
            RwLock, RwLockReadGuard, RwLockWriteGuard,
        };
    }

    #[cfg(feature = "async-lock")]
    pub mod async_lock {
        #[cfg(not(feature = "hotpath"))]
        pub use crate::lib_off::async_lock::{
            Mutex, MutexGuard, RwLock, RwLockReadGuard, RwLockWriteGuard,
        };
        #[cfg(feature = "hotpath")]
        pub use crate::lib_on::mutexes::wrapper::async_lock::{Mutex, MutexGuard};
        #[cfg(feature = "hotpath")]
        pub use crate::lib_on::rw_locks::wrapper::async_lock::{
            RwLock, RwLockReadGuard, RwLockWriteGuard,
        };
    }

    #[cfg(feature = "tokio")]
    pub mod tokio {
        pub mod sync {
            #[cfg(not(feature = "hotpath"))]
            pub use crate::lib_off::tokio::sync::{
                Mutex, MutexGuard, RwLock, RwLockReadGuard, RwLockWriteGuard,
            };
            #[cfg(feature = "hotpath")]
            pub use crate::lib_on::mutexes::wrapper::tokio::{Mutex, MutexGuard};
            #[cfg(feature = "hotpath")]
            pub use crate::lib_on::rw_locks::wrapper::tokio::{
                RwLock, RwLockReadGuard, RwLockWriteGuard,
            };

            /// Instrumented `tokio::sync::mpsc` channel endpoints for
            /// `channel!(..., wrap = true)`. With `hotpath` enabled these are the
            /// instrumented wrappers; otherwise `channel!` is a no-op and the endpoints
            /// are the raw tokio types, so the alias resolves the same way regardless of
            /// feature configuration.
            pub mod mpsc {
                #[cfg(feature = "hotpath")]
                pub use crate::lib_on::channels::wrapper::tokio_wrap::{
                    Receiver, Sender, UnboundedReceiver, UnboundedSender,
                };
                #[cfg(not(feature = "hotpath"))]
                pub use tokio::sync::mpsc::{Receiver, Sender, UnboundedReceiver, UnboundedSender};
            }
        }
    }

    /// Instrumented crossbeam channel endpoints for `channel!(..., wrap = true)`.
    /// With `hotpath` enabled these are the instrumented wrappers; otherwise
    /// `channel!` is a no-op and the endpoints are the raw crossbeam types, so the
    /// alias resolves the same way regardless of feature configuration.
    #[cfg(feature = "crossbeam")]
    pub mod crossbeam_channel {
        #[cfg(feature = "hotpath")]
        pub use crate::lib_on::channels::wrapper::crossbeam_wrap::{Receiver, Sender};
        #[cfg(not(feature = "hotpath"))]
        pub use crossbeam_channel::{Receiver, Sender};
    }

    /// Instrumented flume channel endpoints for `channel!(..., wrap = true)`.
    /// With `hotpath` enabled these are the instrumented wrappers; otherwise
    /// `channel!` is a no-op and the endpoints are the raw flume types, so the
    /// alias resolves the same way regardless of feature configuration.
    #[cfg(feature = "flume")]
    pub mod flume {
        #[cfg(feature = "hotpath")]
        pub use crate::lib_on::channels::wrapper::flume_wrap::{Receiver, Sender};
        #[cfg(not(feature = "hotpath"))]
        pub use flume::{Receiver, Sender};
    }
}

mod shared;
pub use shared::{env_flag, Format, IntoF64, Section};

#[doc(hidden)]
pub mod dev_logging;