datadog_api_client/datadogV2/model/
model_observability_pipeline_dedupe_processor.rs

1// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
2// This product includes software developed at Datadog (https://www.datadoghq.com/).
3// Copyright 2019-Present Datadog, Inc.
4use serde::de::{Error, MapAccess, Visitor};
5use serde::{Deserialize, Deserializer, Serialize};
6use serde_with::skip_serializing_none;
7use std::fmt::{self, Formatter};
8
9/// The `dedupe` processor removes duplicate fields in log events.
10#[non_exhaustive]
11#[skip_serializing_none]
12#[derive(Clone, Debug, PartialEq, Serialize)]
13pub struct ObservabilityPipelineDedupeProcessor {
14    /// A list of log field paths to check for duplicates.
15    #[serde(rename = "fields")]
16    pub fields: Vec<String>,
17    /// The unique identifier for this processor.
18    #[serde(rename = "id")]
19    pub id: String,
20    /// A Datadog search query used to determine which logs this processor targets.
21    #[serde(rename = "include")]
22    pub include: String,
23    /// A list of component IDs whose output is used as the input for this processor.
24    #[serde(rename = "inputs")]
25    pub inputs: Vec<String>,
26    /// The deduplication mode to apply to the fields.
27    #[serde(rename = "mode")]
28    pub mode: crate::datadogV2::model::ObservabilityPipelineDedupeProcessorMode,
29    /// The processor type. The value should always be `dedupe`.
30    #[serde(rename = "type")]
31    pub type_: crate::datadogV2::model::ObservabilityPipelineDedupeProcessorType,
32    #[serde(flatten)]
33    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
34    #[serde(skip)]
35    #[serde(default)]
36    pub(crate) _unparsed: bool,
37}
38
39impl ObservabilityPipelineDedupeProcessor {
40    pub fn new(
41        fields: Vec<String>,
42        id: String,
43        include: String,
44        inputs: Vec<String>,
45        mode: crate::datadogV2::model::ObservabilityPipelineDedupeProcessorMode,
46        type_: crate::datadogV2::model::ObservabilityPipelineDedupeProcessorType,
47    ) -> ObservabilityPipelineDedupeProcessor {
48        ObservabilityPipelineDedupeProcessor {
49            fields,
50            id,
51            include,
52            inputs,
53            mode,
54            type_,
55            additional_properties: std::collections::BTreeMap::new(),
56            _unparsed: false,
57        }
58    }
59
60    pub fn additional_properties(
61        mut self,
62        value: std::collections::BTreeMap<String, serde_json::Value>,
63    ) -> Self {
64        self.additional_properties = value;
65        self
66    }
67}
68
69impl<'de> Deserialize<'de> for ObservabilityPipelineDedupeProcessor {
70    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
71    where
72        D: Deserializer<'de>,
73    {
74        struct ObservabilityPipelineDedupeProcessorVisitor;
75        impl<'a> Visitor<'a> for ObservabilityPipelineDedupeProcessorVisitor {
76            type Value = ObservabilityPipelineDedupeProcessor;
77
78            fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
79                f.write_str("a mapping")
80            }
81
82            fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
83            where
84                M: MapAccess<'a>,
85            {
86                let mut fields: Option<Vec<String>> = None;
87                let mut id: Option<String> = None;
88                let mut include: Option<String> = None;
89                let mut inputs: Option<Vec<String>> = None;
90                let mut mode: Option<
91                    crate::datadogV2::model::ObservabilityPipelineDedupeProcessorMode,
92                > = None;
93                let mut type_: Option<
94                    crate::datadogV2::model::ObservabilityPipelineDedupeProcessorType,
95                > = None;
96                let mut additional_properties: std::collections::BTreeMap<
97                    String,
98                    serde_json::Value,
99                > = std::collections::BTreeMap::new();
100                let mut _unparsed = false;
101
102                while let Some((k, v)) = map.next_entry::<String, serde_json::Value>()? {
103                    match k.as_str() {
104                        "fields" => {
105                            fields = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
106                        }
107                        "id" => {
108                            id = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
109                        }
110                        "include" => {
111                            include = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
112                        }
113                        "inputs" => {
114                            inputs = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
115                        }
116                        "mode" => {
117                            mode = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
118                            if let Some(ref _mode) = mode {
119                                match _mode {
120                                    crate::datadogV2::model::ObservabilityPipelineDedupeProcessorMode::UnparsedObject(_mode) => {
121                                        _unparsed = true;
122                                    },
123                                    _ => {}
124                                }
125                            }
126                        }
127                        "type" => {
128                            type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
129                            if let Some(ref _type_) = type_ {
130                                match _type_ {
131                                    crate::datadogV2::model::ObservabilityPipelineDedupeProcessorType::UnparsedObject(_type_) => {
132                                        _unparsed = true;
133                                    },
134                                    _ => {}
135                                }
136                            }
137                        }
138                        &_ => {
139                            if let Ok(value) = serde_json::from_value(v.clone()) {
140                                additional_properties.insert(k, value);
141                            }
142                        }
143                    }
144                }
145                let fields = fields.ok_or_else(|| M::Error::missing_field("fields"))?;
146                let id = id.ok_or_else(|| M::Error::missing_field("id"))?;
147                let include = include.ok_or_else(|| M::Error::missing_field("include"))?;
148                let inputs = inputs.ok_or_else(|| M::Error::missing_field("inputs"))?;
149                let mode = mode.ok_or_else(|| M::Error::missing_field("mode"))?;
150                let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?;
151
152                let content = ObservabilityPipelineDedupeProcessor {
153                    fields,
154                    id,
155                    include,
156                    inputs,
157                    mode,
158                    type_,
159                    additional_properties,
160                    _unparsed,
161                };
162
163                Ok(content)
164            }
165        }
166
167        deserializer.deserialize_any(ObservabilityPipelineDedupeProcessorVisitor)
168    }
169}
datadog_api_client/datadogV2/model/model_observability_pipeline_dedupe_processor.rs

datadog_api_client/datadogV2/model/
model_observability_pipeline_dedupe_processor.rs
