Crate mytheclipse 

mytheclipse

Resource-aware abstractions for async I/O, heavy compute, background queue management, resiliency, traffic control, lifecycle, and observability — built on a single lazily-initialized global engine context plus a set of self-contained, constructible utilities.

Call init once at startup (or let the first call to any entry point trigger it lazily) and then use whichever feature-gated entry points your workload needs:

• spawn_io (feature io) — spawn an async I/O task, tracing-instrumented.
• compute() (feature compute) — run CPU-bound work on a sized Rayon pool, panic-isolated.
• spawn_bg (feature bg) — spawn a background task under bounded concurrency.
• retry() / CircuitBreaker / timeout() (feature resiliency) — fault tolerance.
• RateLimiter / BackpressureQueue / ConcurrencyLimiter (feature traffic) — load control.
• SemaphorePool (feature traffic) — shared bounded resource pool.
• ShutdownManager / CronSchedule (feature lifecycle) — lifecycle + scheduling.
• HealthRegistry / LeaderElection (feature lifecycle) — health checks + leader election.
• MetricsCollector / PanicTracker (feature observability) — runtime visibility.

Enable the full feature to pull in all of the above at once.

Re-exports

pub use aggregate_error::AggregateError;

pub use parallel_map::parallel_for_each;

pub use parallel_map::parallel_map;

pub use parallel_map::parallel_map_unordered;

pub use parallel_map::ParallelConcurrency;

pub use retry_ext::RetryExt;

pub use auto_metrics_service::AutoMetricsServiceBuilder;

pub use runtime_auto::available_parallelism;

pub use runtime_auto::RuntimeConfig;

pub use shutdown_guard::ShutdownGuard;

pub use context::context;

pub use context::EngineContext;

pub use error::MytheclipseError;

pub use bg::spawn_bg;

pub use compute::compute;

pub use compute::compute_join;

pub use compute::compute_map;

pub use compute::compute_par_for_each;

pub use compute::ComputeErrors;

pub use io::spawn_io;

pub use circuit_breaker::CircuitBreaker;

pub use circuit_breaker::CircuitBreakerConfig;

pub use circuit_breaker::CircuitError;

pub use circuit_breaker::CircuitState;

pub use retry::retry;

pub use retry::JitterKind;

pub use retry::RetryConfig;

pub use retry::RetryError;

pub use timeout::timeout;

pub use timeout::with_timeout;

pub use timeout::Timeout;

pub use timeout::TimeoutError;

pub use backpressure::BackpressureError;

pub use backpressure::BackpressureQueue;

pub use backpressure::OverflowPolicy;

pub use concurrency::ConcurrencyLimiter;

pub use concurrency::ConcurrencyPermit;

pub use pool::AutoReconnectPool;

pub use pool::Pool;

pub use pool::PoolError;

pub use pool::Pooled;

pub use pool::Reconnectable;

pub use pool::SemaphorePool;

pub use ratelimit::RateLimitError;

pub use ratelimit::RateLimiter;

pub use cron::schedule;

pub use cron::CronError;

pub use cron::CronJob;

pub use cron::CronParseError;

pub use cron::CronSchedule;

pub use health::HealthCheck;

pub use health::HealthRegistry;

pub use health::HealthStatus;

pub use leader::InProcLeaderElection;

pub use leader::LeaderElection;

pub use shutdown::ShutdownManager;

pub use shutdown::ShutdownSignal;

pub use service_builder::RunError;

pub use service_builder::ServiceBuilder;

pub use service_builder::ServiceConfig;

pub use dlock::DistributedLock;

pub use dlock::InProcLock;

pub use dlock::LockError;

pub use dlock::LockGuard;

pub use lifecycle::AsyncLifecycleManager;

pub use metrics::MetricsCollector;

pub use metrics::MetricsSnapshot;

pub use metrics_bridge::MetricsBridge;

pub use metrics_bridge::MetricsHealthCheck;

pub use metrics_bridge::CircuitBreakerHealthCheck;

pub use pool_health::HealthCheckedPool;

pub use bg_join::BgJoiner;

pub use middleware::mw;

pub use middleware::BoxMiddleware;

pub use middleware::MiddlewarePipeline;

pub use middleware::PipelineError;

pub use panic_tracker::PanicGuard;

pub use panic_tracker::PanicInfo;

pub use panic_tracker::PanicTracker;

Modules

aggregate_error

Error aggregation for parallel/fan-out work (feature resiliency).

auto_metrics_service

Auto-metrics service builder (feature observability).

backpressure

A bounded queue with configurable overflow handling (feature traffic).

bg

Bounded-concurrency background task execution.

bg_join

Graceful task-joiner for background tasks (feature lifecycle).

circuit_breaker

Circuit breaker for isolating failures in calls to external services (feature resiliency).

compute

Panic-isolated heavy compute on a sized rayon::ThreadPool.

concurrency

A synchronous concurrency limiter (feature traffic).

context

Global engine context providing resource-aware execution primitives.

cron

Minimal cron scheduling (feature lifecycle).

dlock

Distributed lock with lease-based expiration.

error

Shared error type for mytheclipse execution primitives.

health

Health check registry for reporting component status.

io

Async I/O task spawning, instrumented with tracing.

leader

Distributed leader election via Redis or in-process fallback.

lifecycle

Async lifecycle manager composing shutdown, health checks, and periodic tasks.

metrics

A centralized, thread-safe metrics collector (feature observability).

metrics_bridge

Bridges the metrics collector to health checks and tracing events.

middleware

Composable middleware pipeline (feature observability + resiliency).

panic_tracker

Span and panic isolation tracking (feature observability).

parallel_map

Bounded parallel map over collections (feature resiliency).

pool

Resource pool for sharing bounded resources across async tasks.

pool_health

Health-checked resource pool (feature observability + traffic).

ratelimit

A token-bucket rate limiter (feature traffic).

retry

Automatic retry with exponential backoff and jitter (feature resiliency).

retry_ext

Ergonomic retry extension trait (feature resiliency).

runtime_auto

Auto thread/core allocation (feature lifecycle).

service_builder

Service builder that composes resiliency primitives.

shutdown

Graceful shutdown coordination (feature lifecycle).

shutdown_guard

RAII shutdown guard (feature lifecycle).

timeout

Hard execution time bounds for async work (feature resiliency).

Functions

init

Bootstraps the global EngineContext.

Attribute Macros

async_trait

Re-export of async-trait so implementing pool::Reconnectable (and other async traits) doesn’t require users to add their own async-trait dependency.