nsproxy-hickory-server 0.25.4

Hickory DNS is a safe and secure DNS server with DNSSEC support. The DNSSEC support allows for live signing of all records, but it does not currently support records signed offline. The server supports dynamic DNS with SIG(0) or TSIG authenticated requests. Hickory DNS is based on the Tokio and Futures libraries, which means it should be easy to integrate into other software that also uses those libraries. 
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use crate::authority::{LookupControlFlow, LookupObject};
use metrics::{Counter, Gauge, Unit, counter, describe_counter, describe_gauge, gauge};

pub(super) struct StoreMetrics {
    pub(crate) query: QueryStoreMetrics,
    pub(crate) persistent: PersistentStoreMetrics,
}

impl StoreMetrics {
    pub(super) fn new(store: &'static str) -> Self {
        Self {
            query: QueryStoreMetrics::new(store),
            persistent: PersistentStoreMetrics::new(store),
        }
    }
}

pub(super) struct PersistentStoreMetrics {
    pub(super) zone_records: Gauge,
    #[cfg(feature = "__dnssec")]
    pub(super) zone_records_added: Counter,
    #[cfg(feature = "__dnssec")]
    pub(super) zone_records_deleted: Counter,
    #[cfg(feature = "__dnssec")]
    pub(super) zone_records_updated: Counter,
}

impl PersistentStoreMetrics {
    pub(super) fn new(store: &'static str) -> Self {
        let store_key = "store";

        let zone_records_name = "hickory_zone_records_total";
        let zone_records = gauge!(zone_records_name, store_key => store);
        describe_gauge!(
            zone_records_name,
            Unit::Count,
            "number of dns zone records in persisted storages"
        );

        #[cfg(feature = "__dnssec")]
        let (zone_records_added, zone_records_deleted, zone_records_updated) = {
            let zone_records_modified_name = "hickory_zone_records_modified_total";

            let operation_key = "operation";

            let records_added =
                counter!(zone_records_modified_name, store_key => store, operation_key => "added");
            let records_deleted = counter!(zone_records_modified_name, store_key => store, operation_key => "deleted");
            let records_updated = counter!(zone_records_modified_name, store_key => store, operation_key => "updated");

            describe_counter!(
                zone_records_modified_name,
                Unit::Count,
                "number of dns zone records that had been modified"
            );

            (records_added, records_deleted, records_updated)
        };

        Self {
            zone_records,
            #[cfg(feature = "__dnssec")]
            zone_records_added,
            #[cfg(feature = "__dnssec")]
            zone_records_deleted,
            #[cfg(feature = "__dnssec")]
            zone_records_updated,
        }
    }

    #[cfg(feature = "__dnssec")]
    pub(super) fn added(&self) {
        self.zone_records_added.increment(1);
        self.zone_records.increment(1);
    }

    #[cfg(feature = "__dnssec")]
    pub(super) fn deleted(&self) {
        self.zone_records_deleted.increment(1);
        self.zone_records.decrement(1)
    }
    #[cfg(feature = "__dnssec")]
    pub(super) fn updated(&self) {
        self.zone_records_updated.increment(1);
    }
}

pub(super) struct QueryStoreMetrics {
    pub(super) zone_record_lookups_success: Counter,
    pub(super) zone_record_lookups_error: Counter,
}

impl QueryStoreMetrics {
    pub(crate) fn new(store: &'static str) -> Self {
        let zone_record_lookups_name = "hickory_zone_record_lookups_total";
        let store_key = "store";
        let success_key = "success";

        let zone_record_lookups_success =
            counter!(zone_record_lookups_name, store_key => store, success_key => "true");
        let zone_record_lookups_error =
            counter!(zone_record_lookups_name, store_key => store, success_key => "false");

        describe_counter!(
            zone_record_lookups_name,
            Unit::Count,
            "number of occurred dns zone record lookups"
        );

        Self {
            zone_record_lookups_success,
            zone_record_lookups_error,
        }
    }

    pub(super) fn increment_lookup<T: LookupObject>(
        &self,
        lookup_control_flow: &LookupControlFlow<T>,
    ) {
        let is_success = match lookup_control_flow {
            LookupControlFlow::Continue(res) => res.is_ok(),
            LookupControlFlow::Break(res) => res.is_ok(),
            LookupControlFlow::Skip => false,
        };

        if is_success {
            self.zone_record_lookups_success.increment(1)
        } else {
            self.zone_record_lookups_error.increment(1)
        }
    }
}