Struct Inspector 

pub struct Inspector { /* private fields */ }

Main inspector for tracking async execution

Implementations

impl Inspector

pub fn new() -> Self

Create a new inspector

pub fn global() -> &'static Self

Get the global inspector instance

pub fn is_enabled(&self) -> bool

Check if the inspector is enabled

pub fn enable(&self)

Enable the inspector

pub fn disable(&self)

Disable the inspector

pub fn register_task(&self, name: String) -> TaskId

Register a new task

pub fn register_child_task(&self, name: String, parent_id: TaskId) -> TaskId

Register a child task with a parent

pub fn register_task_with_info(&self, task: TaskInfo) -> TaskId

Register a task with additional metadata

pub fn update_task_state(&self, task_id: TaskId, new_state: TaskState)

Update task state

pub fn poll_started(&self, task_id: TaskId)

Record a poll start

pub fn poll_ended(&self, task_id: TaskId, duration: Duration)

Record a poll end

pub fn await_started( &self, task_id: TaskId, await_point: String, location: Option<String>, )

Record an await start

pub fn await_ended( &self, task_id: TaskId, await_point: String, duration: Duration, )

Record an await end

pub fn task_completed(&self, task_id: TaskId)

Mark task as completed

pub fn task_failed(&self, task_id: TaskId, error: Option<String>)

Mark task as failed

pub fn inspection_point( &self, task_id: TaskId, label: String, message: Option<String>, )

Record an inspection point

pub fn add_event(&self, task_id: TaskId, kind: EventKind)

Add an event to the timeline

pub fn get_task(&self, task_id: TaskId) -> Option<TaskInfo>

Get a task by ID

pub fn get_all_tasks(&self) -> Vec<TaskInfo>

Get all tasks

pub fn get_tasks_filtered(&self, filter: &TaskFilter) -> Vec<TaskInfo>

Get tasks matching a filter

Example

use async_inspect::{Inspector, task::{TaskFilter, TaskState}};
use std::time::Duration;

let inspector = Inspector::new();

// Find all running tasks with "fetch" in the name
let filter = TaskFilter::new()
    .with_state(TaskState::Running)
    .with_name_pattern("fetch");

let tasks = inspector.get_tasks_filtered(&filter);

pub fn get_tasks_sorted( &self, filter: &TaskFilter, sort_by: TaskSortBy, direction: SortDirection, ) -> Vec<TaskInfo>

Get tasks matching a filter, sorted by the given criteria

Example

use async_inspect::{Inspector, task::{TaskFilter, TaskState, TaskSortBy, SortDirection}};

let inspector = Inspector::new();

// Get blocked tasks sorted by age (oldest first)
let filter = TaskFilter::new().with_state(TaskState::Blocked { await_point: String::new() });
let tasks = inspector.get_tasks_sorted(&filter, TaskSortBy::Age, SortDirection::Descending);

pub fn get_running_tasks(&self) -> Vec<TaskInfo>

Get running tasks

pub fn get_blocked_tasks(&self) -> Vec<TaskInfo>

Get blocked tasks

pub fn get_long_running_tasks(&self, min_duration: Duration) -> Vec<TaskInfo>

Get long-running tasks (older than the specified duration)

pub fn get_root_tasks(&self) -> Vec<TaskInfo>

Get root tasks (tasks without a parent)

pub fn get_child_tasks(&self, parent_id: TaskId) -> Vec<TaskInfo>

Get child tasks of a specific parent

pub fn get_events(&self) -> Vec<Event>

Get all events

pub fn get_task_events(&self, task_id: TaskId) -> Vec<Event>

Get events for a specific task

pub fn build_profiler(&self) -> Profiler

Build a performance profiler from collected data

pub fn stats(&self) -> InspectorStats

Get statistics

pub fn clear(&self)

Clear all data

pub fn reset(&self)

Reset the inspector

pub fn deadlock_detector(&self) -> &DeadlockDetector

Get the deadlock detector

Returns a reference to the integrated deadlock detector for resource tracking and deadlock analysis.

Trait Implementations

impl Clone for Inspector

fn clone(&self) -> Inspector

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for Inspector

fn default() -> Self

Returns the “default value” for a type.