nodedb-columnar 0.6.1

Columnar segment format and memtable for NodeDB analytical storage
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

// SPDX-License-Identifier: Apache-2.0

//! Forensic payloads carried by columnar reports.
//!
//! Grouping keys carry no row index. The row identifies the occurrence, so a
//! scan over many bad rows of one column files one report with a count.

use faultbox::DomainContext;
use faultbox::serde_json::{Value, json};

/// A memtable cell whose bytes do not hold a value of its declared type.
pub(super) struct MemtableCellCorrupt<'a> {
    /// Collection whose memtable holds the cell.
    pub collection: &'a str,
    /// Column of the cell.
    pub column: &'a str,
    /// The error text: column, row, and why the bytes do not decode.
    pub detail: String,
}

/// A columnar WAL row whose bytes do not decode.
pub(super) struct WalRowCorrupt {
    /// The error text: the byte offset and why the bytes do not decode.
    pub detail: String,
}

impl DomainContext for WalRowCorrupt {
    fn domain_kind(&self) -> &'static str {
        "nodedb_columnar.wal_row_corrupt"
    }

    fn grouping_key(&self) -> String {
        "wal_row".to_string()
    }

    fn to_json(&self) -> Value {
        json!({
            "detail": self.detail,
            "why_fatal": "the row the record carries cannot be rebuilt, so its decode is \
                          refused",
            "operator_action": "restore the collection from a snapshot taken before the \
                                damaged record",
        })
    }
}

/// A string column cell whose bytes are not UTF-8 when a segment is written.
pub(super) struct StringCellNotUtf8<'a> {
    /// Column of the cell.
    pub column: &'a str,
    /// The error text: column and row.
    pub detail: String,
}

impl DomainContext for StringCellNotUtf8<'_> {
    fn domain_kind(&self) -> &'static str {
        "nodedb_columnar.string_cell_not_utf8"
    }

    fn grouping_key(&self) -> String {
        format!("column={}", self.column)
    }

    fn to_json(&self) -> Value {
        json!({
            "column": self.column,
            "detail": self.detail,
            "why_fatal": "the segment write is refused: block statistics built from these \
                          bytes would prune rows a predicate matches",
            "operator_action": "rewrite or delete the named row, then let the flush retry",
        })
    }
}

impl DomainContext for MemtableCellCorrupt<'_> {
    fn domain_kind(&self) -> &'static str {
        "nodedb_columnar.memtable_cell_corrupt"
    }

    fn grouping_key(&self) -> String {
        format!("collection={} column={}", self.collection, self.column)
    }

    fn to_json(&self) -> Value {
        json!({
            "collection": self.collection,
            "column": self.column,
            "detail": self.detail,
            "why_fatal": "every read of the row is refused until the row is rewritten or \
                          removed. A flush of the memtable would copy the bad bytes into a \
                          segment",
            "operator_action": "rewrite or delete the named row. If many rows fail, \
                                restore the collection from a snapshot",
        })
    }
}