runmat-runtime 0.5.5

Core runtime for RunMat with builtins, BLAS/LAPACK integration, and execution APIs
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

use std::collections::BTreeMap;

use chrono::Utc;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct OperationContext {
    pub trace_id: Option<String>,
    pub request_id: Option<String>,
}

impl OperationContext {
    pub fn new(trace_id: Option<String>, request_id: Option<String>) -> Self {
        Self {
            trace_id,
            request_id,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OperationEnvelope<T> {
    pub operation: String,
    pub op_version: String,
    pub trace_id: Option<String>,
    pub request_id: Option<String>,
    pub data: T,
}

impl<T> OperationEnvelope<T> {
    pub fn new(operation: &str, op_version: &str, context: &OperationContext, data: T) -> Self {
        Self {
            operation: operation.to_string(),
            op_version: op_version.to_string(),
            trace_id: context.trace_id.clone(),
            request_id: context.request_id.clone(),
            data,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum OperationErrorType {
    Input,
    Validation,
    Capacity,
    Backend,
    Internal,
    Contract,
    Cancelled,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum OperationErrorSeverity {
    Warning,
    Error,
    Fatal,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct OperationErrorEnvelope {
    pub error_code: String,
    pub error_type: OperationErrorType,
    pub message: String,
    pub operation: String,
    pub op_version: String,
    pub retryable: bool,
    pub severity: OperationErrorSeverity,
    pub context: BTreeMap<String, String>,
    pub trace_id: Option<String>,
    pub request_id: Option<String>,
    pub timestamp: String,
}

pub struct OperationErrorSpec<'a> {
    pub error_code: &'a str,
    pub error_type: OperationErrorType,
    pub retryable: bool,
    pub severity: OperationErrorSeverity,
}

pub fn operation_error(
    operation: &str,
    op_version: &str,
    context: &OperationContext,
    spec: OperationErrorSpec<'_>,
    message: impl Into<String>,
    error_context: BTreeMap<String, String>,
) -> OperationErrorEnvelope {
    OperationErrorEnvelope {
        error_code: spec.error_code.to_string(),
        error_type: spec.error_type,
        message: message.into(),
        operation: operation.to_string(),
        op_version: op_version.to_string(),
        retryable: spec.retryable,
        severity: spec.severity,
        context: error_context,
        trace_id: context.trace_id.clone(),
        request_id: context.request_id.clone(),
        timestamp: Utc::now().to_rfc3339(),
    }
}