tower-resilience-fallback 0.9.1

Fallback middleware for Tower services
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

//! Events emitted by the fallback service.

use std::time::Instant;
use tower_resilience_core::ResilienceEvent;

/// Events emitted by the fallback service.
#[derive(Debug, Clone)]
pub enum FallbackEvent {
    /// The inner service succeeded; no fallback was needed.
    Success {
        /// Name of the fallback instance.
        pattern_name: String,
        /// When the event occurred.
        timestamp: Instant,
    },

    /// The inner service failed; fallback will be attempted.
    FailedAttempt {
        /// Name of the fallback instance.
        pattern_name: String,
        /// When the event occurred.
        timestamp: Instant,
    },

    /// The fallback was successfully applied.
    Applied {
        /// Name of the fallback instance.
        pattern_name: String,
        /// When the event occurred.
        timestamp: Instant,
        /// The strategy that was applied.
        strategy: &'static str,
    },

    /// The fallback itself failed (only possible with service fallback).
    Failed {
        /// Name of the fallback instance.
        pattern_name: String,
        /// When the event occurred.
        timestamp: Instant,
    },

    /// The error didn't match the predicate; propagated as-is.
    Skipped {
        /// Name of the fallback instance.
        pattern_name: String,
        /// When the event occurred.
        timestamp: Instant,
    },
}

impl ResilienceEvent for FallbackEvent {
    fn event_type(&self) -> &'static str {
        match self {
            Self::Success { .. } => "success",
            Self::FailedAttempt { .. } => "failed_attempt",
            Self::Applied { .. } => "applied",
            Self::Failed { .. } => "failed",
            Self::Skipped { .. } => "skipped",
        }
    }

    fn timestamp(&self) -> Instant {
        match self {
            Self::Success { timestamp, .. }
            | Self::FailedAttempt { timestamp, .. }
            | Self::Applied { timestamp, .. }
            | Self::Failed { timestamp, .. }
            | Self::Skipped { timestamp, .. } => *timestamp,
        }
    }

    fn pattern_name(&self) -> &str {
        match self {
            Self::Success { pattern_name, .. }
            | Self::FailedAttempt { pattern_name, .. }
            | Self::Applied { pattern_name, .. }
            | Self::Failed { pattern_name, .. }
            | Self::Skipped { pattern_name, .. } => pattern_name,
        }
    }
}