copybook-codec 0.5.0

Deterministic COBOL copybook codec for EBCDIC/ASCII fixed and RDW records.
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115

// SPDX-License-Identifier: AGPL-3.0-or-later
//! Metrics integration for record processing.

#[cfg(feature = "metrics")]
mod imp {
    use crate::options::{Codepage, DecodeOptions, RecordFormat, ZonedEncodingFormat};
    use metrics::{counter, gauge, histogram};

    #[inline]
    pub fn record_read(bytes: usize, options: &DecodeOptions) {
        let format_label = format_label(options.format);
        let codepage_label = codepage_label(options.codepage);
        let zero_policy_label = zero_policy_label(options);

        counter!(
            "copybook_records_total",
            "format" => format_label,
            "codepage" => codepage_label,
            "zero_policy" => zero_policy_label
        )
        .increment(1);
        counter!(
            "copybook_bytes_total",
            "format" => format_label,
            "codepage" => codepage_label,
            "zero_policy" => zero_policy_label
        )
        .increment(bytes as u64);
    }

    #[inline]
    pub fn record_error(family: &'static str) {
        counter!("copybook_decode_errors_total", "family" => family).increment(1);
    }

    #[inline]
    pub fn record_completion(
        duration_seconds: f64,
        throughput_mibps: f64,
        options: &DecodeOptions,
    ) {
        let format_label = format_label(options.format);
        let codepage_label = codepage_label(options.codepage);

        if duration_seconds.is_finite() && duration_seconds >= 0.0 {
            histogram!(
                "copybook_decode_seconds",
                "format" => format_label,
                "codepage" => codepage_label
            )
            .record(duration_seconds);
        }

        if throughput_mibps.is_finite() {
            gauge!(
                "copybook_throughput_mibps",
                "format" => format_label,
                "codepage" => codepage_label
            )
            .set(throughput_mibps);
        }
    }

    #[inline]
    fn zero_policy_label(options: &DecodeOptions) -> &'static str {
        if options.preserve_zoned_encoding {
            "preserved"
        } else if options.preferred_zoned_encoding != ZonedEncodingFormat::Auto {
            "override"
        } else {
            "preferred"
        }
    }

    #[inline]
    fn format_label(format: RecordFormat) -> &'static str {
        match format {
            RecordFormat::Fixed => "fixed",
            RecordFormat::RDW => "rdw",
        }
    }

    #[inline]
    fn codepage_label(codepage: Codepage) -> &'static str {
        match codepage {
            Codepage::ASCII => "ascii",
            Codepage::CP037 => "cp037",
            Codepage::CP273 => "cp273",
            Codepage::CP500 => "cp500",
            Codepage::CP1047 => "cp1047",
            Codepage::CP1140 => "cp1140",
        }
    }
}

#[cfg(not(feature = "metrics"))]
mod imp {
    use crate::options::DecodeOptions;

    #[inline]
    pub fn record_read(_bytes: usize, _options: &DecodeOptions) {}

    #[inline]
    pub fn record_error(_family: &'static str) {}

    #[inline]
    pub fn record_completion(
        _duration_seconds: f64,
        _throughput_mibps: f64,
        _options: &DecodeOptions,
    ) {
    }
}

pub use imp::{record_completion, record_error, record_read};