tower-resilience-bulkhead 0.4.3

Bulkhead pattern for Tower services - resource isolation and concurrency limiting
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! Tower layer implementation for bulkhead.

use crate::config::BulkheadConfig;
use crate::service::Bulkhead;
use tower::Layer;

#[cfg(feature = "metrics")]
use metrics::{describe_counter, describe_gauge, describe_histogram};
#[cfg(feature = "metrics")]
use std::sync::Once;

#[cfg(feature = "metrics")]
static METRICS_INIT: Once = Once::new();

/// Layer that applies bulkhead concurrency limiting.
#[derive(Clone)]
pub struct BulkheadLayer {
    config: BulkheadConfig,
}

impl BulkheadLayer {
    /// Creates a new bulkhead layer with the given configuration.
    pub fn new(config: BulkheadConfig) -> Self {
        Self { config }
    }

    /// Creates a new builder for configuring a bulkhead layer.
    ///
    /// # Examples
    ///
    /// ```
    /// use tower_resilience_bulkhead::BulkheadLayer;
    /// use std::time::Duration;
    ///
    /// let layer = BulkheadLayer::builder()
    ///     .max_concurrent_calls(10)
    ///     .max_wait_duration(Some(Duration::from_secs(5)))
    ///     .build();
    /// ```
    pub fn builder() -> crate::BulkheadConfigBuilder {
        #[cfg(feature = "metrics")]
        {
            METRICS_INIT.call_once(|| {
                describe_counter!(
                    "bulkhead_calls_permitted_total",
                    "Total number of calls permitted through the bulkhead"
                );
                describe_counter!(
                    "bulkhead_calls_rejected_total",
                    "Total number of calls rejected by the bulkhead"
                );
                describe_counter!(
                    "bulkhead_calls_finished_total",
                    "Total number of calls that finished successfully"
                );
                describe_counter!(
                    "bulkhead_calls_failed_total",
                    "Total number of calls that failed"
                );
                describe_gauge!(
                    "bulkhead_concurrent_calls",
                    "Current number of concurrent calls"
                );
                describe_histogram!(
                    "bulkhead_wait_duration_seconds",
                    "Time spent waiting to acquire a permit"
                );
                describe_histogram!(
                    "bulkhead_call_duration_seconds",
                    "Duration of calls through the bulkhead"
                );
            });
        }
        crate::BulkheadConfigBuilder::new()
    }
}

impl<S> Layer<S> for BulkheadLayer {
    type Service = Bulkhead<S>;

    fn layer(&self, service: S) -> Self::Service {
        Bulkhead::new(service, self.config.clone())
    }
}