hermes-logger 0.1.0

Implementation of an IBC Relayer in Rust, as a library
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use cgp::prelude::*;
use hermes_logging_components::impls::delegate::DelegateLogger;
use hermes_logging_components::impls::global::GetGlobalLogger;
use hermes_logging_components::traits::has_logger::{
    GlobalLoggerGetter, HasLoggerType, LoggerGetterComponent, ProvideLoggerType,
};
use hermes_logging_components::traits::logger::LoggerComponent;
use hermes_logging_components::types::level::{
    LevelDebug, LevelError, LevelInfo, LevelTrace, LevelWarn,
};
use hermes_relayer_components::chain::traits::types::message::HasMessageType;
use hermes_relayer_components::relay::impls::packet_clearers::receive_packet::LogClearPacketError;
use hermes_relayer_components::relay::impls::packet_relayers::general::full_relay::LogRelayPacketAction;
use hermes_relayer_components::relay::impls::packet_relayers::general::lock::LogSkipRelayLockedPacket;
use hermes_relayer_components::relay::impls::packet_relayers::general::log::LogRelayPacketStatus;
use hermes_relayer_components::relay::impls::update_client::skip::LogSkipBuildUpdateClientMessage;
use hermes_relayer_components::relay::impls::update_client::wait::LogWaitUpdateClientHeightStatus;
use hermes_relayer_components::relay::traits::chains::HasRelayChains;
use hermes_relayer_components::relay::traits::target::ChainTarget;
use hermes_relayer_components::transaction::impls::estimate_fees_and_send_tx::LogSendMessagesWithSignerAndNonce;
use hermes_relayer_components::transaction::impls::poll_tx_response::{
    LogRetryQueryTxResponse, TxNoResponseError,
};
use hermes_relayer_components::transaction::traits::types::nonce::HasNonceType;
use hermes_relayer_components::transaction::traits::types::signer::HasSignerType;
use hermes_relayer_components::transaction::traits::types::tx_hash::HasTransactionHashType;
use hermes_relayer_components_extra::batch::worker::LogBatchWorker;
use hermes_tracing_logging_components::contexts::logger::TracingLogger;

pub struct HermesLogger;

pub struct HermesLoggerComponents;

pub struct HermesLogHandlers;

impl HasComponents for HermesLogger {
    type Components = HermesLoggerComponents;
}

delegate_components! {
    HermesLoggerComponents {
        LoggerComponent: DelegateLogger<HermesLogHandlers>,
    }
}

delegate_components! {
    HermesLogHandlers {
        [
            (),
            LevelTrace,
            LevelDebug,
            LevelInfo,
            LevelWarn,
            LevelError,
            <'a, Chain: HasSignerType + HasNonceType + HasMessageType,>
                LogSendMessagesWithSignerAndNonce<'a, Chain>,
            <'a, Chain: HasTransactionHashType>
                TxNoResponseError<'a, Chain>,
            <'a, Chain: HasTransactionHashType + HasErrorType>
                LogRetryQueryTxResponse<'a, Chain>,
            <'a, Relay: HasRelayChains>
                LogSkipRelayLockedPacket<'a, Relay>,
            <'a, Relay: HasRelayChains>
                LogRelayPacketAction<'a, Relay>,
            <'a, Relay: HasRelayChains>
                LogClearPacketError<'a, Relay>,
            <'a, Relay: HasRelayChains>
                LogRelayPacketStatus<'a, Relay>,
            <'a, Relay: HasRelayChains, Target: ChainTarget<Relay>>
                LogSkipBuildUpdateClientMessage<'a, Relay, Target>,
            <'a, Relay: HasRelayChains, Target: ChainTarget<Relay>>
                LogWaitUpdateClientHeightStatus<'a, Relay, Target>,
            <'a, Relay: HasRelayChains, Target: ChainTarget<Relay>>
                LogBatchWorker<'a, Relay, Target>,
        ]: TracingLogger,
    }
}

pub struct ProvideHermesLogger;

delegate_components! {
    ProvideHermesLogger {
        LoggerGetterComponent: GetGlobalLogger,
    }
}

impl<Context> ProvideLoggerType<Context> for ProvideHermesLogger
where
    Context: Async,
{
    type Logger = HermesLogger;
}

impl<Context> GlobalLoggerGetter<Context> for ProvideHermesLogger
where
    Context: HasLoggerType<Logger = HermesLogger>,
{
    fn global_logger() -> &'static HermesLogger {
        &HermesLogger
    }
}