diff --git a/.generated-info b/.generated-info index 95edbc79c..e9311c509 100644 --- a/.generated-info +++ b/.generated-info @@ -1,4 +1,4 @@ { - "spec_repo_commit": "2ffdc3f", - "generated": "2025-07-16 19:19:08.488" + "spec_repo_commit": "827a324", + "generated": "2025-07-17 11:22:53.407" } diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 2ee20dab0..bd6dcdb99 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -25145,6 +25145,7 @@ components: - $ref: '#/components/schemas/ObservabilityPipelineSentinelOneDestination' - $ref: '#/components/schemas/ObservabilityPipelineOpenSearchDestination' - $ref: '#/components/schemas/ObservabilityPipelineAmazonOpenSearchDestination' + - $ref: '#/components/schemas/ObservabilityPipelineSocketDestination' ObservabilityPipelineConfigProcessorItem: description: A processor for the pipeline. oneOf: @@ -25164,6 +25165,7 @@ components: - $ref: '#/components/schemas/ObservabilityPipelineEnrichmentTableProcessor' - $ref: '#/components/schemas/ObservabilityPipelineReduceProcessor' - $ref: '#/components/schemas/ObservabilityPipelineThrottleProcessor' + - $ref: '#/components/schemas/ObservabilityPipelineCustomProcessorProcessor' ObservabilityPipelineConfigSourceItem: description: A data source for the pipeline. oneOf: @@ -25182,6 +25184,87 @@ components: - $ref: '#/components/schemas/ObservabilityPipelineGooglePubSubSource' - $ref: '#/components/schemas/ObservabilityPipelineHttpClientSource' - $ref: '#/components/schemas/ObservabilityPipelineLogstashSource' + - $ref: '#/components/schemas/ObservabilityPipelineSocketSource' + ObservabilityPipelineCustomProcessorProcessor: + description: The `custom_processor` processor transforms events using [Vector + Remap Language (VRL)](https://vector.dev/docs/reference/vrl/) scripts with + advanced filtering capabilities. + properties: + id: + description: The unique identifier for this processor. + example: remap-vrl-processor + type: string + include: + default: '*' + description: A Datadog search query used to determine which logs this processor + targets. This field should always be set to `*` for the custom_processor + processor. + example: '*' + type: string + inputs: + description: A list of component IDs whose output is used as the input for + this processor. + example: + - datadog-agent-source + items: + type: string + type: array + remaps: + description: Array of VRL remap rules. + items: + $ref: '#/components/schemas/ObservabilityPipelineCustomProcessorProcessorRemap' + minItems: 1 + type: array + type: + $ref: '#/components/schemas/ObservabilityPipelineCustomProcessorProcessorType' + required: + - id + - type + - include + - remaps + - inputs + type: object + ObservabilityPipelineCustomProcessorProcessorRemap: + description: Defines a single VRL remap rule with its own filtering and transformation + logic. + properties: + drop_on_error: + default: false + description: Whether to drop events that caused errors during processing. + example: false + type: boolean + enabled: + default: true + description: Whether this remap rule is enabled. + example: true + type: boolean + include: + description: A Datadog search query used to filter events for this specific + remap rule. + example: service:web + type: string + name: + description: A descriptive name for this remap rule. + example: Parse JSON from message field + type: string + source: + description: The VRL script source code that defines the processing logic. + example: . = parse_json!(.message) + type: string + required: + - include + - name + - source + type: object + ObservabilityPipelineCustomProcessorProcessorType: + default: custom_processor + description: The processor type. The value should always be `custom_processor`. + enum: + - custom_processor + example: custom_processor + type: string + x-enum-varnames: + - CUSTOM_PROCESSOR ObservabilityPipelineData: description: "Contains the pipeline\u2019s ID, type, and configuration attributes." properties: @@ -27465,6 +27548,278 @@ components: type: string x-enum-varnames: - SENTINEL_ONE + ObservabilityPipelineSocketDestination: + description: 'The `socket` destination sends logs over TCP or UDP to a remote + server. + + ' + properties: + encoding: + $ref: '#/components/schemas/ObservabilityPipelineSocketDestinationEncoding' + framing: + $ref: '#/components/schemas/ObservabilityPipelineSocketDestinationFraming' + id: + description: The unique identifier for this component. + example: socket-destination + type: string + inputs: + description: A list of component IDs whose output is used as the `input` + for this component. + example: + - filter-processor + items: + type: string + type: array + mode: + $ref: '#/components/schemas/ObservabilityPipelineSocketDestinationMode' + tls: + $ref: '#/components/schemas/ObservabilityPipelineTls' + description: TLS configuration. Relevant only when `mode` is `tcp`. + type: + $ref: '#/components/schemas/ObservabilityPipelineSocketDestinationType' + required: + - id + - type + - inputs + - encoding + - framing + - mode + type: object + ObservabilityPipelineSocketDestinationEncoding: + description: Encoding format for log events. + enum: + - json + - raw_message + example: json + type: string + x-enum-varnames: + - JSON + - RAW_MESSAGE + ObservabilityPipelineSocketDestinationFraming: + description: Framing method configuration. + oneOf: + - $ref: '#/components/schemas/ObservabilityPipelineSocketDestinationFramingNewlineDelimited' + - $ref: '#/components/schemas/ObservabilityPipelineSocketDestinationFramingBytes' + - $ref: '#/components/schemas/ObservabilityPipelineSocketDestinationFramingCharacterDelimited' + ObservabilityPipelineSocketDestinationFramingBytes: + description: Event data is not delimited at all. + properties: + method: + $ref: '#/components/schemas/ObservabilityPipelineSocketDestinationFramingBytesMethod' + required: + - method + type: object + ObservabilityPipelineSocketDestinationFramingBytesMethod: + description: The definition of `ObservabilityPipelineSocketDestinationFramingBytesMethod` + object. + enum: + - bytes + example: bytes + type: string + x-enum-varnames: + - BYTES + ObservabilityPipelineSocketDestinationFramingCharacterDelimited: + description: Each log event is separated using the specified delimiter character. + properties: + delimiter: + description: A single ASCII character used as a delimiter. + example: '|' + maxLength: 1 + minLength: 1 + type: string + method: + $ref: '#/components/schemas/ObservabilityPipelineSocketDestinationFramingCharacterDelimitedMethod' + required: + - method + - delimiter + type: object + ObservabilityPipelineSocketDestinationFramingCharacterDelimitedMethod: + description: The definition of `ObservabilityPipelineSocketDestinationFramingCharacterDelimitedMethod` + object. + enum: + - character_delimited + example: character_delimited + type: string + x-enum-varnames: + - CHARACTER_DELIMITED + ObservabilityPipelineSocketDestinationFramingNewlineDelimited: + description: Each log event is delimited by a newline character. + properties: + method: + $ref: '#/components/schemas/ObservabilityPipelineSocketDestinationFramingNewlineDelimitedMethod' + required: + - method + type: object + ObservabilityPipelineSocketDestinationFramingNewlineDelimitedMethod: + description: The definition of `ObservabilityPipelineSocketDestinationFramingNewlineDelimitedMethod` + object. + enum: + - newline_delimited + example: newline_delimited + type: string + x-enum-varnames: + - NEWLINE_DELIMITED + ObservabilityPipelineSocketDestinationMode: + description: Protocol used to send logs. + enum: + - tcp + - udp + example: tcp + type: string + x-enum-varnames: + - TCP + - UDP + ObservabilityPipelineSocketDestinationType: + default: socket + description: The destination type. The value should always be `socket`. + enum: + - socket + example: socket + type: string + x-enum-varnames: + - SOCKET + ObservabilityPipelineSocketSource: + description: 'The `socket` source ingests logs over TCP or UDP. + + ' + properties: + framing: + $ref: '#/components/schemas/ObservabilityPipelineSocketSourceFraming' + id: + description: The unique identifier for this component. Used to reference + this component in other parts of the pipeline (e.g., as input to downstream + components). + example: socket-source + type: string + mode: + $ref: '#/components/schemas/ObservabilityPipelineSocketSourceMode' + tls: + $ref: '#/components/schemas/ObservabilityPipelineTls' + description: TLS configuration. Relevant only when `mode` is `tcp`. + type: + $ref: '#/components/schemas/ObservabilityPipelineSocketSourceType' + required: + - id + - type + - mode + - framing + type: object + ObservabilityPipelineSocketSourceFraming: + description: Framing method configuration for the socket source. + oneOf: + - $ref: '#/components/schemas/ObservabilityPipelineSocketSourceFramingNewlineDelimited' + - $ref: '#/components/schemas/ObservabilityPipelineSocketSourceFramingBytes' + - $ref: '#/components/schemas/ObservabilityPipelineSocketSourceFramingCharacterDelimited' + - $ref: '#/components/schemas/ObservabilityPipelineSocketSourceFramingOctetCounting' + - $ref: '#/components/schemas/ObservabilityPipelineSocketSourceFramingChunkedGelf' + ObservabilityPipelineSocketSourceFramingBytes: + description: Byte frames are passed through as-is according to the underlying + I/O boundaries (for example, split between messages or stream segments). + properties: + method: + $ref: '#/components/schemas/ObservabilityPipelineSocketSourceFramingBytesMethod' + required: + - method + type: object + ObservabilityPipelineSocketSourceFramingBytesMethod: + description: Byte frames are passed through as-is according to the underlying + I/O boundaries (for example, split between messages or stream segments). + enum: + - bytes + example: bytes + type: string + x-enum-varnames: + - BYTES + ObservabilityPipelineSocketSourceFramingCharacterDelimited: + description: Byte frames which are delimited by a chosen character. + properties: + delimiter: + description: A single ASCII character used to delimit events. + example: '|' + maxLength: 1 + minLength: 1 + type: string + method: + $ref: '#/components/schemas/ObservabilityPipelineSocketSourceFramingCharacterDelimitedMethod' + required: + - method + - delimiter + type: object + ObservabilityPipelineSocketSourceFramingCharacterDelimitedMethod: + description: Byte frames which are delimited by a chosen character. + enum: + - character_delimited + example: character_delimited + type: string + x-enum-varnames: + - CHARACTER_DELIMITED + ObservabilityPipelineSocketSourceFramingChunkedGelf: + description: Byte frames which are chunked GELF messages. + properties: + method: + $ref: '#/components/schemas/ObservabilityPipelineSocketSourceFramingChunkedGelfMethod' + required: + - method + type: object + ObservabilityPipelineSocketSourceFramingChunkedGelfMethod: + description: Byte frames which are chunked GELF messages. + enum: + - chunked_gelf + example: chunked_gelf + type: string + x-enum-varnames: + - CHUNKED_GELF + ObservabilityPipelineSocketSourceFramingNewlineDelimited: + description: Byte frames which are delimited by a newline character. + properties: + method: + $ref: '#/components/schemas/ObservabilityPipelineSocketSourceFramingNewlineDelimitedMethod' + required: + - method + type: object + ObservabilityPipelineSocketSourceFramingNewlineDelimitedMethod: + description: Byte frames which are delimited by a newline character. + enum: + - newline_delimited + example: newline_delimited + type: string + x-enum-varnames: + - NEWLINE_DELIMITED + ObservabilityPipelineSocketSourceFramingOctetCounting: + description: Byte frames according to the octet counting format as per RFC6587. + properties: + method: + $ref: '#/components/schemas/ObservabilityPipelineSocketSourceFramingOctetCountingMethod' + required: + - method + type: object + ObservabilityPipelineSocketSourceFramingOctetCountingMethod: + description: Byte frames according to the octet counting format as per RFC6587. + enum: + - octet_counting + example: octet_counting + type: string + x-enum-varnames: + - OCTET_COUNTING + ObservabilityPipelineSocketSourceMode: + description: Protocol used to receive logs. + enum: + - tcp + - udp + example: tcp + type: string + x-enum-varnames: + - TCP + - UDP + ObservabilityPipelineSocketSourceType: + default: socket + description: The source type. The value should always be `socket`. + enum: + - socket + example: socket + type: string + x-enum-varnames: + - SOCKET ObservabilityPipelineSpec: description: Input schema representing an observability pipeline configuration. Used in create and validate requests. diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index 7828bf289..770096776 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -3468,6 +3468,28 @@ pub mod model_observability_pipeline_amazon_open_search_destination_auth_strateg pub use self::model_observability_pipeline_amazon_open_search_destination_auth_strategy::ObservabilityPipelineAmazonOpenSearchDestinationAuthStrategy; pub mod model_observability_pipeline_amazon_open_search_destination_type; pub use self::model_observability_pipeline_amazon_open_search_destination_type::ObservabilityPipelineAmazonOpenSearchDestinationType; +pub mod model_observability_pipeline_socket_destination; +pub use self::model_observability_pipeline_socket_destination::ObservabilityPipelineSocketDestination; +pub mod model_observability_pipeline_socket_destination_encoding; +pub use self::model_observability_pipeline_socket_destination_encoding::ObservabilityPipelineSocketDestinationEncoding; +pub mod model_observability_pipeline_socket_destination_framing_newline_delimited; +pub use self::model_observability_pipeline_socket_destination_framing_newline_delimited::ObservabilityPipelineSocketDestinationFramingNewlineDelimited; +pub mod model_observability_pipeline_socket_destination_framing_newline_delimited_method; +pub use self::model_observability_pipeline_socket_destination_framing_newline_delimited_method::ObservabilityPipelineSocketDestinationFramingNewlineDelimitedMethod; +pub mod model_observability_pipeline_socket_destination_framing_bytes; +pub use self::model_observability_pipeline_socket_destination_framing_bytes::ObservabilityPipelineSocketDestinationFramingBytes; +pub mod model_observability_pipeline_socket_destination_framing_bytes_method; +pub use self::model_observability_pipeline_socket_destination_framing_bytes_method::ObservabilityPipelineSocketDestinationFramingBytesMethod; +pub mod model_observability_pipeline_socket_destination_framing_character_delimited; +pub use self::model_observability_pipeline_socket_destination_framing_character_delimited::ObservabilityPipelineSocketDestinationFramingCharacterDelimited; +pub mod model_observability_pipeline_socket_destination_framing_character_delimited_method; +pub use self::model_observability_pipeline_socket_destination_framing_character_delimited_method::ObservabilityPipelineSocketDestinationFramingCharacterDelimitedMethod; +pub mod model_observability_pipeline_socket_destination_framing; +pub use self::model_observability_pipeline_socket_destination_framing::ObservabilityPipelineSocketDestinationFraming; +pub mod model_observability_pipeline_socket_destination_mode; +pub use self::model_observability_pipeline_socket_destination_mode::ObservabilityPipelineSocketDestinationMode; +pub mod model_observability_pipeline_socket_destination_type; +pub use self::model_observability_pipeline_socket_destination_type::ObservabilityPipelineSocketDestinationType; pub mod model_observability_pipeline_config_destination_item; pub use self::model_observability_pipeline_config_destination_item::ObservabilityPipelineConfigDestinationItem; pub mod model_observability_pipeline_filter_processor; @@ -3650,6 +3672,12 @@ pub mod model_observability_pipeline_throttle_processor; pub use self::model_observability_pipeline_throttle_processor::ObservabilityPipelineThrottleProcessor; pub mod model_observability_pipeline_throttle_processor_type; pub use self::model_observability_pipeline_throttle_processor_type::ObservabilityPipelineThrottleProcessorType; +pub mod model_observability_pipeline_custom_processor_processor; +pub use self::model_observability_pipeline_custom_processor_processor::ObservabilityPipelineCustomProcessorProcessor; +pub mod model_observability_pipeline_custom_processor_processor_remap; +pub use self::model_observability_pipeline_custom_processor_processor_remap::ObservabilityPipelineCustomProcessorProcessorRemap; +pub mod model_observability_pipeline_custom_processor_processor_type; +pub use self::model_observability_pipeline_custom_processor_processor_type::ObservabilityPipelineCustomProcessorProcessorType; pub mod model_observability_pipeline_config_processor_item; pub use self::model_observability_pipeline_config_processor_item::ObservabilityPipelineConfigProcessorItem; pub mod model_observability_pipeline_kafka_source; @@ -3726,6 +3754,34 @@ pub mod model_observability_pipeline_logstash_source; pub use self::model_observability_pipeline_logstash_source::ObservabilityPipelineLogstashSource; pub mod model_observability_pipeline_logstash_source_type; pub use self::model_observability_pipeline_logstash_source_type::ObservabilityPipelineLogstashSourceType; +pub mod model_observability_pipeline_socket_source; +pub use self::model_observability_pipeline_socket_source::ObservabilityPipelineSocketSource; +pub mod model_observability_pipeline_socket_source_framing_newline_delimited; +pub use self::model_observability_pipeline_socket_source_framing_newline_delimited::ObservabilityPipelineSocketSourceFramingNewlineDelimited; +pub mod model_observability_pipeline_socket_source_framing_newline_delimited_method; +pub use self::model_observability_pipeline_socket_source_framing_newline_delimited_method::ObservabilityPipelineSocketSourceFramingNewlineDelimitedMethod; +pub mod model_observability_pipeline_socket_source_framing_bytes; +pub use self::model_observability_pipeline_socket_source_framing_bytes::ObservabilityPipelineSocketSourceFramingBytes; +pub mod model_observability_pipeline_socket_source_framing_bytes_method; +pub use self::model_observability_pipeline_socket_source_framing_bytes_method::ObservabilityPipelineSocketSourceFramingBytesMethod; +pub mod model_observability_pipeline_socket_source_framing_character_delimited; +pub use self::model_observability_pipeline_socket_source_framing_character_delimited::ObservabilityPipelineSocketSourceFramingCharacterDelimited; +pub mod model_observability_pipeline_socket_source_framing_character_delimited_method; +pub use self::model_observability_pipeline_socket_source_framing_character_delimited_method::ObservabilityPipelineSocketSourceFramingCharacterDelimitedMethod; +pub mod model_observability_pipeline_socket_source_framing_octet_counting; +pub use self::model_observability_pipeline_socket_source_framing_octet_counting::ObservabilityPipelineSocketSourceFramingOctetCounting; +pub mod model_observability_pipeline_socket_source_framing_octet_counting_method; +pub use self::model_observability_pipeline_socket_source_framing_octet_counting_method::ObservabilityPipelineSocketSourceFramingOctetCountingMethod; +pub mod model_observability_pipeline_socket_source_framing_chunked_gelf; +pub use self::model_observability_pipeline_socket_source_framing_chunked_gelf::ObservabilityPipelineSocketSourceFramingChunkedGelf; +pub mod model_observability_pipeline_socket_source_framing_chunked_gelf_method; +pub use self::model_observability_pipeline_socket_source_framing_chunked_gelf_method::ObservabilityPipelineSocketSourceFramingChunkedGelfMethod; +pub mod model_observability_pipeline_socket_source_framing; +pub use self::model_observability_pipeline_socket_source_framing::ObservabilityPipelineSocketSourceFraming; +pub mod model_observability_pipeline_socket_source_mode; +pub use self::model_observability_pipeline_socket_source_mode::ObservabilityPipelineSocketSourceMode; +pub mod model_observability_pipeline_socket_source_type; +pub use self::model_observability_pipeline_socket_source_type::ObservabilityPipelineSocketSourceType; pub mod model_observability_pipeline_config_source_item; pub use self::model_observability_pipeline_config_source_item::ObservabilityPipelineConfigSourceItem; pub mod model_list_pipelines_response_meta; diff --git a/src/datadogV2/model/model_observability_pipeline_config_destination_item.rs b/src/datadogV2/model/model_observability_pipeline_config_destination_item.rs index 4df9ff335..871e15c48 100644 --- a/src/datadogV2/model/model_observability_pipeline_config_destination_item.rs +++ b/src/datadogV2/model/model_observability_pipeline_config_destination_item.rs @@ -49,6 +49,9 @@ pub enum ObservabilityPipelineConfigDestinationItem { ObservabilityPipelineAmazonOpenSearchDestination( Box, ), + ObservabilityPipelineSocketDestination( + Box, + ), UnparsedObject(crate::datadog::UnparsedObject), } @@ -180,6 +183,14 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineConfigDestinationItem { return Ok(ObservabilityPipelineConfigDestinationItem::ObservabilityPipelineAmazonOpenSearchDestination(_v)); } } + if let Ok(_v) = serde_json::from_value::< + Box, + >(value.clone()) + { + if !_v._unparsed { + return Ok(ObservabilityPipelineConfigDestinationItem::ObservabilityPipelineSocketDestination(_v)); + } + } return Ok(ObservabilityPipelineConfigDestinationItem::UnparsedObject( crate::datadog::UnparsedObject { value }, diff --git a/src/datadogV2/model/model_observability_pipeline_config_processor_item.rs b/src/datadogV2/model/model_observability_pipeline_config_processor_item.rs index 8bfae3f08..309e7a7f8 100644 --- a/src/datadogV2/model/model_observability_pipeline_config_processor_item.rs +++ b/src/datadogV2/model/model_observability_pipeline_config_processor_item.rs @@ -56,6 +56,9 @@ pub enum ObservabilityPipelineConfigProcessorItem { ObservabilityPipelineThrottleProcessor( Box, ), + ObservabilityPipelineCustomProcessorProcessor( + Box, + ), UnparsedObject(crate::datadog::UnparsedObject), } @@ -213,6 +216,14 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineConfigProcessorItem { return Ok(ObservabilityPipelineConfigProcessorItem::ObservabilityPipelineThrottleProcessor(_v)); } } + if let Ok(_v) = serde_json::from_value::< + Box, + >(value.clone()) + { + if !_v._unparsed { + return Ok(ObservabilityPipelineConfigProcessorItem::ObservabilityPipelineCustomProcessorProcessor(_v)); + } + } return Ok(ObservabilityPipelineConfigProcessorItem::UnparsedObject( crate::datadog::UnparsedObject { value }, diff --git a/src/datadogV2/model/model_observability_pipeline_config_source_item.rs b/src/datadogV2/model/model_observability_pipeline_config_source_item.rs index abb11ba4c..5ae53d3ce 100644 --- a/src/datadogV2/model/model_observability_pipeline_config_source_item.rs +++ b/src/datadogV2/model/model_observability_pipeline_config_source_item.rs @@ -53,6 +53,9 @@ pub enum ObservabilityPipelineConfigSourceItem { ObservabilityPipelineLogstashSource( Box, ), + ObservabilityPipelineSocketSource( + Box, + ), UnparsedObject(crate::datadog::UnparsedObject), } @@ -218,6 +221,16 @@ impl<'de> Deserialize<'de> for ObservabilityPipelineConfigSourceItem { ); } } + if let Ok(_v) = serde_json::from_value::< + Box, + >(value.clone()) + { + if !_v._unparsed { + return Ok( + ObservabilityPipelineConfigSourceItem::ObservabilityPipelineSocketSource(_v), + ); + } + } return Ok(ObservabilityPipelineConfigSourceItem::UnparsedObject( crate::datadog::UnparsedObject { value }, diff --git a/src/datadogV2/model/model_observability_pipeline_custom_processor_processor.rs b/src/datadogV2/model/model_observability_pipeline_custom_processor_processor.rs new file mode 100644 index 000000000..36a881d53 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_custom_processor_processor.rs @@ -0,0 +1,152 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// The `custom_processor` processor transforms events using [Vector Remap Language (VRL)]() scripts with advanced filtering capabilities. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineCustomProcessorProcessor { + /// The unique identifier for this processor. + #[serde(rename = "id")] + pub id: String, + /// A Datadog search query used to determine which logs this processor targets. This field should always be set to `*` for the custom_processor processor. + #[serde(rename = "include")] + pub include: String, + /// A list of component IDs whose output is used as the input for this processor. + #[serde(rename = "inputs")] + pub inputs: Vec, + /// Array of VRL remap rules. + #[serde(rename = "remaps")] + pub remaps: Vec, + /// The processor type. The value should always be `custom_processor`. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::ObservabilityPipelineCustomProcessorProcessorType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ObservabilityPipelineCustomProcessorProcessor { + pub fn new( + id: String, + include: String, + inputs: Vec, + remaps: Vec, + type_: crate::datadogV2::model::ObservabilityPipelineCustomProcessorProcessorType, + ) -> ObservabilityPipelineCustomProcessorProcessor { + ObservabilityPipelineCustomProcessorProcessor { + id, + include, + inputs, + remaps, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineCustomProcessorProcessor { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineCustomProcessorProcessorVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineCustomProcessorProcessorVisitor { + type Value = ObservabilityPipelineCustomProcessorProcessor; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut id: Option = None; + let mut include: Option = None; + let mut inputs: Option> = None; + let mut remaps: Option< + Vec< + crate::datadogV2::model::ObservabilityPipelineCustomProcessorProcessorRemap, + >, + > = None; + let mut type_: Option< + crate::datadogV2::model::ObservabilityPipelineCustomProcessorProcessorType, + > = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "id" => { + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "include" => { + include = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "inputs" => { + inputs = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "remaps" => { + remaps = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::ObservabilityPipelineCustomProcessorProcessorType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let id = id.ok_or_else(|| M::Error::missing_field("id"))?; + let include = include.ok_or_else(|| M::Error::missing_field("include"))?; + let inputs = inputs.ok_or_else(|| M::Error::missing_field("inputs"))?; + let remaps = remaps.ok_or_else(|| M::Error::missing_field("remaps"))?; + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = ObservabilityPipelineCustomProcessorProcessor { + id, + include, + inputs, + remaps, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ObservabilityPipelineCustomProcessorProcessorVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_custom_processor_processor_remap.rs b/src/datadogV2/model/model_observability_pipeline_custom_processor_processor_remap.rs new file mode 100644 index 000000000..187ee2ef6 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_custom_processor_processor_remap.rs @@ -0,0 +1,151 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Defines a single VRL remap rule with its own filtering and transformation logic. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineCustomProcessorProcessorRemap { + /// Whether to drop events that caused errors during processing. + #[serde(rename = "drop_on_error")] + pub drop_on_error: Option, + /// Whether this remap rule is enabled. + #[serde(rename = "enabled")] + pub enabled: Option, + /// A Datadog search query used to filter events for this specific remap rule. + #[serde(rename = "include")] + pub include: String, + /// A descriptive name for this remap rule. + #[serde(rename = "name")] + pub name: String, + /// The VRL script source code that defines the processing logic. + #[serde(rename = "source")] + pub source: String, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ObservabilityPipelineCustomProcessorProcessorRemap { + pub fn new( + include: String, + name: String, + source: String, + ) -> ObservabilityPipelineCustomProcessorProcessorRemap { + ObservabilityPipelineCustomProcessorProcessorRemap { + drop_on_error: None, + enabled: None, + include, + name, + source, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn drop_on_error(mut self, value: bool) -> Self { + self.drop_on_error = Some(value); + self + } + + pub fn enabled(mut self, value: bool) -> Self { + self.enabled = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineCustomProcessorProcessorRemap { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineCustomProcessorProcessorRemapVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineCustomProcessorProcessorRemapVisitor { + type Value = ObservabilityPipelineCustomProcessorProcessorRemap; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut drop_on_error: Option = None; + let mut enabled: Option = None; + let mut include: Option = None; + let mut name: Option = None; + let mut source: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "drop_on_error" => { + if v.is_null() { + continue; + } + drop_on_error = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "enabled" => { + if v.is_null() { + continue; + } + enabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "include" => { + include = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "name" => { + name = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "source" => { + source = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let include = include.ok_or_else(|| M::Error::missing_field("include"))?; + let name = name.ok_or_else(|| M::Error::missing_field("name"))?; + let source = source.ok_or_else(|| M::Error::missing_field("source"))?; + + let content = ObservabilityPipelineCustomProcessorProcessorRemap { + drop_on_error, + enabled, + include, + name, + source, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ObservabilityPipelineCustomProcessorProcessorRemapVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_custom_processor_processor_type.rs b/src/datadogV2/model/model_observability_pipeline_custom_processor_processor_type.rs new file mode 100644 index 000000000..faf03191d --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_custom_processor_processor_type.rs @@ -0,0 +1,48 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineCustomProcessorProcessorType { + CUSTOM_PROCESSOR, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineCustomProcessorProcessorType { + fn to_string(&self) -> String { + match self { + Self::CUSTOM_PROCESSOR => String::from("custom_processor"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineCustomProcessorProcessorType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineCustomProcessorProcessorType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "custom_processor" => Self::CUSTOM_PROCESSOR, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_destination.rs b/src/datadogV2/model/model_observability_pipeline_socket_destination.rs new file mode 100644 index 000000000..e5e683b9d --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_destination.rs @@ -0,0 +1,207 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// The `socket` destination sends logs over TCP or UDP to a remote server. +/// +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineSocketDestination { + /// Encoding format for log events. + #[serde(rename = "encoding")] + pub encoding: crate::datadogV2::model::ObservabilityPipelineSocketDestinationEncoding, + /// Framing method configuration. + #[serde(rename = "framing")] + pub framing: crate::datadogV2::model::ObservabilityPipelineSocketDestinationFraming, + /// The unique identifier for this component. + #[serde(rename = "id")] + pub id: String, + /// A list of component IDs whose output is used as the `input` for this component. + #[serde(rename = "inputs")] + pub inputs: Vec, + /// Protocol used to send logs. + #[serde(rename = "mode")] + pub mode: crate::datadogV2::model::ObservabilityPipelineSocketDestinationMode, + /// Configuration for enabling TLS encryption between the pipeline component and external services. + #[serde(rename = "tls")] + pub tls: Option, + /// The destination type. The value should always be `socket`. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::ObservabilityPipelineSocketDestinationType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ObservabilityPipelineSocketDestination { + pub fn new( + encoding: crate::datadogV2::model::ObservabilityPipelineSocketDestinationEncoding, + framing: crate::datadogV2::model::ObservabilityPipelineSocketDestinationFraming, + id: String, + inputs: Vec, + mode: crate::datadogV2::model::ObservabilityPipelineSocketDestinationMode, + type_: crate::datadogV2::model::ObservabilityPipelineSocketDestinationType, + ) -> ObservabilityPipelineSocketDestination { + ObservabilityPipelineSocketDestination { + encoding, + framing, + id, + inputs, + mode, + tls: None, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn tls(mut self, value: crate::datadogV2::model::ObservabilityPipelineTls) -> Self { + self.tls = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketDestination { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineSocketDestinationVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineSocketDestinationVisitor { + type Value = ObservabilityPipelineSocketDestination; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut encoding: Option< + crate::datadogV2::model::ObservabilityPipelineSocketDestinationEncoding, + > = None; + let mut framing: Option< + crate::datadogV2::model::ObservabilityPipelineSocketDestinationFraming, + > = None; + let mut id: Option = None; + let mut inputs: Option> = None; + let mut mode: Option< + crate::datadogV2::model::ObservabilityPipelineSocketDestinationMode, + > = None; + let mut tls: Option = None; + let mut type_: Option< + crate::datadogV2::model::ObservabilityPipelineSocketDestinationType, + > = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "encoding" => { + encoding = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _encoding) = encoding { + match _encoding { + crate::datadogV2::model::ObservabilityPipelineSocketDestinationEncoding::UnparsedObject(_encoding) => { + _unparsed = true; + }, + _ => {} + } + } + } + "framing" => { + framing = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _framing) = framing { + match _framing { + crate::datadogV2::model::ObservabilityPipelineSocketDestinationFraming::UnparsedObject(_framing) => { + _unparsed = true; + }, + _ => {} + } + } + } + "id" => { + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "inputs" => { + inputs = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "mode" => { + mode = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _mode) = mode { + match _mode { + crate::datadogV2::model::ObservabilityPipelineSocketDestinationMode::UnparsedObject(_mode) => { + _unparsed = true; + }, + _ => {} + } + } + } + "tls" => { + if v.is_null() { + continue; + } + tls = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::ObservabilityPipelineSocketDestinationType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let encoding = encoding.ok_or_else(|| M::Error::missing_field("encoding"))?; + let framing = framing.ok_or_else(|| M::Error::missing_field("framing"))?; + let id = id.ok_or_else(|| M::Error::missing_field("id"))?; + let inputs = inputs.ok_or_else(|| M::Error::missing_field("inputs"))?; + let mode = mode.ok_or_else(|| M::Error::missing_field("mode"))?; + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = ObservabilityPipelineSocketDestination { + encoding, + framing, + id, + inputs, + mode, + tls, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ObservabilityPipelineSocketDestinationVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_destination_encoding.rs b/src/datadogV2/model/model_observability_pipeline_socket_destination_encoding.rs new file mode 100644 index 000000000..142f64e99 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_destination_encoding.rs @@ -0,0 +1,51 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineSocketDestinationEncoding { + JSON, + RAW_MESSAGE, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineSocketDestinationEncoding { + fn to_string(&self) -> String { + match self { + Self::JSON => String::from("json"), + Self::RAW_MESSAGE => String::from("raw_message"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineSocketDestinationEncoding { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketDestinationEncoding { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "json" => Self::JSON, + "raw_message" => Self::RAW_MESSAGE, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_destination_framing.rs b/src/datadogV2/model/model_observability_pipeline_socket_destination_framing.rs new file mode 100644 index 000000000..a91e5e9fd --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_destination_framing.rs @@ -0,0 +1,48 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::{Deserialize, Deserializer, Serialize}; + +/// Framing method configuration. +#[non_exhaustive] +#[derive(Clone, Debug, PartialEq, Serialize)] +#[serde(untagged)] +pub enum ObservabilityPipelineSocketDestinationFraming { + ObservabilityPipelineSocketDestinationFramingNewlineDelimited(Box), + ObservabilityPipelineSocketDestinationFramingBytes(Box), + ObservabilityPipelineSocketDestinationFramingCharacterDelimited(Box), + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketDestinationFraming { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let value: serde_json::Value = Deserialize::deserialize(deserializer)?; + if let Ok(_v) = serde_json::from_value::>(value.clone()) { + if !_v._unparsed { + return Ok(ObservabilityPipelineSocketDestinationFraming::ObservabilityPipelineSocketDestinationFramingNewlineDelimited(_v)); + } + } + if let Ok(_v) = serde_json::from_value::< + Box, + >(value.clone()) + { + if !_v._unparsed { + return Ok(ObservabilityPipelineSocketDestinationFraming::ObservabilityPipelineSocketDestinationFramingBytes(_v)); + } + } + if let Ok(_v) = serde_json::from_value::>(value.clone()) { + if !_v._unparsed { + return Ok(ObservabilityPipelineSocketDestinationFraming::ObservabilityPipelineSocketDestinationFramingCharacterDelimited(_v)); + } + } + + return Ok( + ObservabilityPipelineSocketDestinationFraming::UnparsedObject( + crate::datadog::UnparsedObject { value }, + ), + ); + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_bytes.rs b/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_bytes.rs new file mode 100644 index 000000000..4a0ee1b71 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_bytes.rs @@ -0,0 +1,102 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Event data is not delimited at all. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineSocketDestinationFramingBytes { + /// The definition of `ObservabilityPipelineSocketDestinationFramingBytesMethod` object. + #[serde(rename = "method")] + pub method: crate::datadogV2::model::ObservabilityPipelineSocketDestinationFramingBytesMethod, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ObservabilityPipelineSocketDestinationFramingBytes { + pub fn new( + method: crate::datadogV2::model::ObservabilityPipelineSocketDestinationFramingBytesMethod, + ) -> ObservabilityPipelineSocketDestinationFramingBytes { + ObservabilityPipelineSocketDestinationFramingBytes { + method, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketDestinationFramingBytes { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineSocketDestinationFramingBytesVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineSocketDestinationFramingBytesVisitor { + type Value = ObservabilityPipelineSocketDestinationFramingBytes; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut method: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "method" => { + method = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _method) = method { + match _method { + crate::datadogV2::model::ObservabilityPipelineSocketDestinationFramingBytesMethod::UnparsedObject(_method) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let method = method.ok_or_else(|| M::Error::missing_field("method"))?; + + let content = ObservabilityPipelineSocketDestinationFramingBytes { + method, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ObservabilityPipelineSocketDestinationFramingBytesVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_bytes_method.rs b/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_bytes_method.rs new file mode 100644 index 000000000..93401110c --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_bytes_method.rs @@ -0,0 +1,48 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineSocketDestinationFramingBytesMethod { + BYTES, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineSocketDestinationFramingBytesMethod { + fn to_string(&self) -> String { + match self { + Self::BYTES => String::from("bytes"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineSocketDestinationFramingBytesMethod { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketDestinationFramingBytesMethod { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "bytes" => Self::BYTES, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_character_delimited.rs b/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_character_delimited.rs new file mode 100644 index 000000000..06a2c8a3e --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_character_delimited.rs @@ -0,0 +1,114 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Each log event is separated using the specified delimiter character. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineSocketDestinationFramingCharacterDelimited { + /// A single ASCII character used as a delimiter. + #[serde(rename = "delimiter")] + pub delimiter: String, + /// The definition of `ObservabilityPipelineSocketDestinationFramingCharacterDelimitedMethod` object. + #[serde(rename = "method")] + pub method: crate::datadogV2::model::ObservabilityPipelineSocketDestinationFramingCharacterDelimitedMethod, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool +} + +impl ObservabilityPipelineSocketDestinationFramingCharacterDelimited { + pub fn new( + delimiter: String, + method: crate::datadogV2::model::ObservabilityPipelineSocketDestinationFramingCharacterDelimitedMethod, + ) -> ObservabilityPipelineSocketDestinationFramingCharacterDelimited { + ObservabilityPipelineSocketDestinationFramingCharacterDelimited { + delimiter, + method, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketDestinationFramingCharacterDelimited { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineSocketDestinationFramingCharacterDelimitedVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineSocketDestinationFramingCharacterDelimitedVisitor { + type Value = ObservabilityPipelineSocketDestinationFramingCharacterDelimited; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut delimiter: Option = None; + let mut method: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "delimiter" => { + delimiter = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "method" => { + method = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _method) = method { + match _method { + crate::datadogV2::model::ObservabilityPipelineSocketDestinationFramingCharacterDelimitedMethod::UnparsedObject(_method) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let delimiter = delimiter.ok_or_else(|| M::Error::missing_field("delimiter"))?; + let method = method.ok_or_else(|| M::Error::missing_field("method"))?; + + let content = ObservabilityPipelineSocketDestinationFramingCharacterDelimited { + delimiter, + method, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer + .deserialize_any(ObservabilityPipelineSocketDestinationFramingCharacterDelimitedVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_character_delimited_method.rs b/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_character_delimited_method.rs new file mode 100644 index 000000000..958476d53 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_character_delimited_method.rs @@ -0,0 +1,50 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineSocketDestinationFramingCharacterDelimitedMethod { + CHARACTER_DELIMITED, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineSocketDestinationFramingCharacterDelimitedMethod { + fn to_string(&self) -> String { + match self { + Self::CHARACTER_DELIMITED => String::from("character_delimited"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineSocketDestinationFramingCharacterDelimitedMethod { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> + for ObservabilityPipelineSocketDestinationFramingCharacterDelimitedMethod +{ + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "character_delimited" => Self::CHARACTER_DELIMITED, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_newline_delimited.rs b/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_newline_delimited.rs new file mode 100644 index 000000000..1171c2d48 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_newline_delimited.rs @@ -0,0 +1,103 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Each log event is delimited by a newline character. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineSocketDestinationFramingNewlineDelimited { + /// The definition of `ObservabilityPipelineSocketDestinationFramingNewlineDelimitedMethod` object. + #[serde(rename = "method")] + pub method: crate::datadogV2::model::ObservabilityPipelineSocketDestinationFramingNewlineDelimitedMethod, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool +} + +impl ObservabilityPipelineSocketDestinationFramingNewlineDelimited { + pub fn new( + method: crate::datadogV2::model::ObservabilityPipelineSocketDestinationFramingNewlineDelimitedMethod, + ) -> ObservabilityPipelineSocketDestinationFramingNewlineDelimited { + ObservabilityPipelineSocketDestinationFramingNewlineDelimited { + method, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketDestinationFramingNewlineDelimited { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineSocketDestinationFramingNewlineDelimitedVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineSocketDestinationFramingNewlineDelimitedVisitor { + type Value = ObservabilityPipelineSocketDestinationFramingNewlineDelimited; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut method: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "method" => { + method = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _method) = method { + match _method { + crate::datadogV2::model::ObservabilityPipelineSocketDestinationFramingNewlineDelimitedMethod::UnparsedObject(_method) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let method = method.ok_or_else(|| M::Error::missing_field("method"))?; + + let content = ObservabilityPipelineSocketDestinationFramingNewlineDelimited { + method, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer + .deserialize_any(ObservabilityPipelineSocketDestinationFramingNewlineDelimitedVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_newline_delimited_method.rs b/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_newline_delimited_method.rs new file mode 100644 index 000000000..65d458173 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_destination_framing_newline_delimited_method.rs @@ -0,0 +1,48 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineSocketDestinationFramingNewlineDelimitedMethod { + NEWLINE_DELIMITED, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineSocketDestinationFramingNewlineDelimitedMethod { + fn to_string(&self) -> String { + match self { + Self::NEWLINE_DELIMITED => String::from("newline_delimited"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineSocketDestinationFramingNewlineDelimitedMethod { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketDestinationFramingNewlineDelimitedMethod { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "newline_delimited" => Self::NEWLINE_DELIMITED, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_destination_mode.rs b/src/datadogV2/model/model_observability_pipeline_socket_destination_mode.rs new file mode 100644 index 000000000..59b6cbfc5 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_destination_mode.rs @@ -0,0 +1,51 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineSocketDestinationMode { + TCP, + UDP, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineSocketDestinationMode { + fn to_string(&self) -> String { + match self { + Self::TCP => String::from("tcp"), + Self::UDP => String::from("udp"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineSocketDestinationMode { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketDestinationMode { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "tcp" => Self::TCP, + "udp" => Self::UDP, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_destination_type.rs b/src/datadogV2/model/model_observability_pipeline_socket_destination_type.rs new file mode 100644 index 000000000..ef71e629e --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_destination_type.rs @@ -0,0 +1,48 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineSocketDestinationType { + SOCKET, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineSocketDestinationType { + fn to_string(&self) -> String { + match self { + Self::SOCKET => String::from("socket"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineSocketDestinationType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketDestinationType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "socket" => Self::SOCKET, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_source.rs b/src/datadogV2/model/model_observability_pipeline_socket_source.rs new file mode 100644 index 000000000..092a3c744 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_source.rs @@ -0,0 +1,175 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// The `socket` source ingests logs over TCP or UDP. +/// +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineSocketSource { + /// Framing method configuration for the socket source. + #[serde(rename = "framing")] + pub framing: crate::datadogV2::model::ObservabilityPipelineSocketSourceFraming, + /// The unique identifier for this component. Used to reference this component in other parts of the pipeline (e.g., as input to downstream components). + #[serde(rename = "id")] + pub id: String, + /// Protocol used to receive logs. + #[serde(rename = "mode")] + pub mode: crate::datadogV2::model::ObservabilityPipelineSocketSourceMode, + /// Configuration for enabling TLS encryption between the pipeline component and external services. + #[serde(rename = "tls")] + pub tls: Option, + /// The source type. The value should always be `socket`. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::ObservabilityPipelineSocketSourceType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ObservabilityPipelineSocketSource { + pub fn new( + framing: crate::datadogV2::model::ObservabilityPipelineSocketSourceFraming, + id: String, + mode: crate::datadogV2::model::ObservabilityPipelineSocketSourceMode, + type_: crate::datadogV2::model::ObservabilityPipelineSocketSourceType, + ) -> ObservabilityPipelineSocketSource { + ObservabilityPipelineSocketSource { + framing, + id, + mode, + tls: None, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn tls(mut self, value: crate::datadogV2::model::ObservabilityPipelineTls) -> Self { + self.tls = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketSource { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineSocketSourceVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineSocketSourceVisitor { + type Value = ObservabilityPipelineSocketSource; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut framing: Option< + crate::datadogV2::model::ObservabilityPipelineSocketSourceFraming, + > = None; + let mut id: Option = None; + let mut mode: Option< + crate::datadogV2::model::ObservabilityPipelineSocketSourceMode, + > = None; + let mut tls: Option = None; + let mut type_: Option< + crate::datadogV2::model::ObservabilityPipelineSocketSourceType, + > = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "framing" => { + framing = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _framing) = framing { + match _framing { + crate::datadogV2::model::ObservabilityPipelineSocketSourceFraming::UnparsedObject(_framing) => { + _unparsed = true; + }, + _ => {} + } + } + } + "id" => { + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "mode" => { + mode = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _mode) = mode { + match _mode { + crate::datadogV2::model::ObservabilityPipelineSocketSourceMode::UnparsedObject(_mode) => { + _unparsed = true; + }, + _ => {} + } + } + } + "tls" => { + if v.is_null() { + continue; + } + tls = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::ObservabilityPipelineSocketSourceType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let framing = framing.ok_or_else(|| M::Error::missing_field("framing"))?; + let id = id.ok_or_else(|| M::Error::missing_field("id"))?; + let mode = mode.ok_or_else(|| M::Error::missing_field("mode"))?; + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = ObservabilityPipelineSocketSource { + framing, + id, + mode, + tls, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ObservabilityPipelineSocketSourceVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_source_framing.rs b/src/datadogV2/model/model_observability_pipeline_socket_source_framing.rs new file mode 100644 index 000000000..f7f2c5c47 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_source_framing.rs @@ -0,0 +1,82 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::{Deserialize, Deserializer, Serialize}; + +/// Framing method configuration for the socket source. +#[non_exhaustive] +#[derive(Clone, Debug, PartialEq, Serialize)] +#[serde(untagged)] +pub enum ObservabilityPipelineSocketSourceFraming { + ObservabilityPipelineSocketSourceFramingNewlineDelimited( + Box, + ), + ObservabilityPipelineSocketSourceFramingBytes( + Box, + ), + ObservabilityPipelineSocketSourceFramingCharacterDelimited( + Box, + ), + ObservabilityPipelineSocketSourceFramingOctetCounting( + Box, + ), + ObservabilityPipelineSocketSourceFramingChunkedGelf( + Box, + ), + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketSourceFraming { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let value: serde_json::Value = Deserialize::deserialize(deserializer)?; + if let Ok(_v) = serde_json::from_value::< + Box, + >(value.clone()) + { + if !_v._unparsed { + return Ok(ObservabilityPipelineSocketSourceFraming::ObservabilityPipelineSocketSourceFramingNewlineDelimited(_v)); + } + } + if let Ok(_v) = serde_json::from_value::< + Box, + >(value.clone()) + { + if !_v._unparsed { + return Ok(ObservabilityPipelineSocketSourceFraming::ObservabilityPipelineSocketSourceFramingBytes(_v)); + } + } + if let Ok(_v) = serde_json::from_value::< + Box< + crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingCharacterDelimited, + >, + >(value.clone()) + { + if !_v._unparsed { + return Ok(ObservabilityPipelineSocketSourceFraming::ObservabilityPipelineSocketSourceFramingCharacterDelimited(_v)); + } + } + if let Ok(_v) = serde_json::from_value::< + Box, + >(value.clone()) + { + if !_v._unparsed { + return Ok(ObservabilityPipelineSocketSourceFraming::ObservabilityPipelineSocketSourceFramingOctetCounting(_v)); + } + } + if let Ok(_v) = serde_json::from_value::< + Box, + >(value.clone()) + { + if !_v._unparsed { + return Ok(ObservabilityPipelineSocketSourceFraming::ObservabilityPipelineSocketSourceFramingChunkedGelf(_v)); + } + } + + return Ok(ObservabilityPipelineSocketSourceFraming::UnparsedObject( + crate::datadog::UnparsedObject { value }, + )); + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_source_framing_bytes.rs b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_bytes.rs new file mode 100644 index 000000000..613290900 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_bytes.rs @@ -0,0 +1,104 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Byte frames are passed through as-is according to the underlying I/O boundaries (for example, split between messages or stream segments). +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineSocketSourceFramingBytes { + /// Byte frames are passed through as-is according to the underlying I/O boundaries (for example, split between messages or stream segments). + #[serde(rename = "method")] + pub method: crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingBytesMethod, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ObservabilityPipelineSocketSourceFramingBytes { + pub fn new( + method: crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingBytesMethod, + ) -> ObservabilityPipelineSocketSourceFramingBytes { + ObservabilityPipelineSocketSourceFramingBytes { + method, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketSourceFramingBytes { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineSocketSourceFramingBytesVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineSocketSourceFramingBytesVisitor { + type Value = ObservabilityPipelineSocketSourceFramingBytes; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut method: Option< + crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingBytesMethod, + > = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "method" => { + method = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _method) = method { + match _method { + crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingBytesMethod::UnparsedObject(_method) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let method = method.ok_or_else(|| M::Error::missing_field("method"))?; + + let content = ObservabilityPipelineSocketSourceFramingBytes { + method, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ObservabilityPipelineSocketSourceFramingBytesVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_source_framing_bytes_method.rs b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_bytes_method.rs new file mode 100644 index 000000000..001437e41 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_bytes_method.rs @@ -0,0 +1,48 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineSocketSourceFramingBytesMethod { + BYTES, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineSocketSourceFramingBytesMethod { + fn to_string(&self) -> String { + match self { + Self::BYTES => String::from("bytes"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineSocketSourceFramingBytesMethod { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketSourceFramingBytesMethod { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "bytes" => Self::BYTES, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_source_framing_character_delimited.rs b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_character_delimited.rs new file mode 100644 index 000000000..4e46a6aa6 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_character_delimited.rs @@ -0,0 +1,115 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Byte frames which are delimited by a chosen character. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineSocketSourceFramingCharacterDelimited { + /// A single ASCII character used to delimit events. + #[serde(rename = "delimiter")] + pub delimiter: String, + /// Byte frames which are delimited by a chosen character. + #[serde(rename = "method")] + pub method: + crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingCharacterDelimitedMethod, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ObservabilityPipelineSocketSourceFramingCharacterDelimited { + pub fn new( + delimiter: String, + method: crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingCharacterDelimitedMethod, + ) -> ObservabilityPipelineSocketSourceFramingCharacterDelimited { + ObservabilityPipelineSocketSourceFramingCharacterDelimited { + delimiter, + method, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketSourceFramingCharacterDelimited { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineSocketSourceFramingCharacterDelimitedVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineSocketSourceFramingCharacterDelimitedVisitor { + type Value = ObservabilityPipelineSocketSourceFramingCharacterDelimited; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut delimiter: Option = None; + let mut method: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "delimiter" => { + delimiter = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "method" => { + method = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _method) = method { + match _method { + crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingCharacterDelimitedMethod::UnparsedObject(_method) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let delimiter = delimiter.ok_or_else(|| M::Error::missing_field("delimiter"))?; + let method = method.ok_or_else(|| M::Error::missing_field("method"))?; + + let content = ObservabilityPipelineSocketSourceFramingCharacterDelimited { + delimiter, + method, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer + .deserialize_any(ObservabilityPipelineSocketSourceFramingCharacterDelimitedVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_source_framing_character_delimited_method.rs b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_character_delimited_method.rs new file mode 100644 index 000000000..b1fd82580 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_character_delimited_method.rs @@ -0,0 +1,48 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineSocketSourceFramingCharacterDelimitedMethod { + CHARACTER_DELIMITED, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineSocketSourceFramingCharacterDelimitedMethod { + fn to_string(&self) -> String { + match self { + Self::CHARACTER_DELIMITED => String::from("character_delimited"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineSocketSourceFramingCharacterDelimitedMethod { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketSourceFramingCharacterDelimitedMethod { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "character_delimited" => Self::CHARACTER_DELIMITED, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_source_framing_chunked_gelf.rs b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_chunked_gelf.rs new file mode 100644 index 000000000..c4b5f7122 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_chunked_gelf.rs @@ -0,0 +1,102 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Byte frames which are chunked GELF messages. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineSocketSourceFramingChunkedGelf { + /// Byte frames which are chunked GELF messages. + #[serde(rename = "method")] + pub method: crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingChunkedGelfMethod, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ObservabilityPipelineSocketSourceFramingChunkedGelf { + pub fn new( + method: crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingChunkedGelfMethod, + ) -> ObservabilityPipelineSocketSourceFramingChunkedGelf { + ObservabilityPipelineSocketSourceFramingChunkedGelf { + method, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketSourceFramingChunkedGelf { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineSocketSourceFramingChunkedGelfVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineSocketSourceFramingChunkedGelfVisitor { + type Value = ObservabilityPipelineSocketSourceFramingChunkedGelf; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut method: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "method" => { + method = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _method) = method { + match _method { + crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingChunkedGelfMethod::UnparsedObject(_method) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let method = method.ok_or_else(|| M::Error::missing_field("method"))?; + + let content = ObservabilityPipelineSocketSourceFramingChunkedGelf { + method, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ObservabilityPipelineSocketSourceFramingChunkedGelfVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_source_framing_chunked_gelf_method.rs b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_chunked_gelf_method.rs new file mode 100644 index 000000000..df2d8030d --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_chunked_gelf_method.rs @@ -0,0 +1,48 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineSocketSourceFramingChunkedGelfMethod { + CHUNKED_GELF, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineSocketSourceFramingChunkedGelfMethod { + fn to_string(&self) -> String { + match self { + Self::CHUNKED_GELF => String::from("chunked_gelf"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineSocketSourceFramingChunkedGelfMethod { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketSourceFramingChunkedGelfMethod { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "chunked_gelf" => Self::CHUNKED_GELF, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_source_framing_newline_delimited.rs b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_newline_delimited.rs new file mode 100644 index 000000000..c507f4d82 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_newline_delimited.rs @@ -0,0 +1,104 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Byte frames which are delimited by a newline character. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineSocketSourceFramingNewlineDelimited { + /// Byte frames which are delimited by a newline character. + #[serde(rename = "method")] + pub method: + crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingNewlineDelimitedMethod, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ObservabilityPipelineSocketSourceFramingNewlineDelimited { + pub fn new( + method: crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingNewlineDelimitedMethod, + ) -> ObservabilityPipelineSocketSourceFramingNewlineDelimited { + ObservabilityPipelineSocketSourceFramingNewlineDelimited { + method, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketSourceFramingNewlineDelimited { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineSocketSourceFramingNewlineDelimitedVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineSocketSourceFramingNewlineDelimitedVisitor { + type Value = ObservabilityPipelineSocketSourceFramingNewlineDelimited; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut method: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "method" => { + method = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _method) = method { + match _method { + crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingNewlineDelimitedMethod::UnparsedObject(_method) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let method = method.ok_or_else(|| M::Error::missing_field("method"))?; + + let content = ObservabilityPipelineSocketSourceFramingNewlineDelimited { + method, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer + .deserialize_any(ObservabilityPipelineSocketSourceFramingNewlineDelimitedVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_source_framing_newline_delimited_method.rs b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_newline_delimited_method.rs new file mode 100644 index 000000000..b6fc173e9 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_newline_delimited_method.rs @@ -0,0 +1,48 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineSocketSourceFramingNewlineDelimitedMethod { + NEWLINE_DELIMITED, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineSocketSourceFramingNewlineDelimitedMethod { + fn to_string(&self) -> String { + match self { + Self::NEWLINE_DELIMITED => String::from("newline_delimited"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineSocketSourceFramingNewlineDelimitedMethod { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketSourceFramingNewlineDelimitedMethod { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "newline_delimited" => Self::NEWLINE_DELIMITED, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_source_framing_octet_counting.rs b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_octet_counting.rs new file mode 100644 index 000000000..73483e103 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_octet_counting.rs @@ -0,0 +1,103 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Byte frames according to the octet counting format as per RFC6587. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ObservabilityPipelineSocketSourceFramingOctetCounting { + /// Byte frames according to the octet counting format as per RFC6587. + #[serde(rename = "method")] + pub method: + crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingOctetCountingMethod, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ObservabilityPipelineSocketSourceFramingOctetCounting { + pub fn new( + method: crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingOctetCountingMethod, + ) -> ObservabilityPipelineSocketSourceFramingOctetCounting { + ObservabilityPipelineSocketSourceFramingOctetCounting { + method, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketSourceFramingOctetCounting { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ObservabilityPipelineSocketSourceFramingOctetCountingVisitor; + impl<'a> Visitor<'a> for ObservabilityPipelineSocketSourceFramingOctetCountingVisitor { + type Value = ObservabilityPipelineSocketSourceFramingOctetCounting; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut method: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "method" => { + method = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _method) = method { + match _method { + crate::datadogV2::model::ObservabilityPipelineSocketSourceFramingOctetCountingMethod::UnparsedObject(_method) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let method = method.ok_or_else(|| M::Error::missing_field("method"))?; + + let content = ObservabilityPipelineSocketSourceFramingOctetCounting { + method, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ObservabilityPipelineSocketSourceFramingOctetCountingVisitor) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_source_framing_octet_counting_method.rs b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_octet_counting_method.rs new file mode 100644 index 000000000..8addace24 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_source_framing_octet_counting_method.rs @@ -0,0 +1,48 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineSocketSourceFramingOctetCountingMethod { + OCTET_COUNTING, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineSocketSourceFramingOctetCountingMethod { + fn to_string(&self) -> String { + match self { + Self::OCTET_COUNTING => String::from("octet_counting"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineSocketSourceFramingOctetCountingMethod { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketSourceFramingOctetCountingMethod { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "octet_counting" => Self::OCTET_COUNTING, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_source_mode.rs b/src/datadogV2/model/model_observability_pipeline_socket_source_mode.rs new file mode 100644 index 000000000..902df5303 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_source_mode.rs @@ -0,0 +1,51 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineSocketSourceMode { + TCP, + UDP, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineSocketSourceMode { + fn to_string(&self) -> String { + match self { + Self::TCP => String::from("tcp"), + Self::UDP => String::from("udp"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineSocketSourceMode { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketSourceMode { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "tcp" => Self::TCP, + "udp" => Self::UDP, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_observability_pipeline_socket_source_type.rs b/src/datadogV2/model/model_observability_pipeline_socket_source_type.rs new file mode 100644 index 000000000..aa02d11d4 --- /dev/null +++ b/src/datadogV2/model/model_observability_pipeline_socket_source_type.rs @@ -0,0 +1,48 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum ObservabilityPipelineSocketSourceType { + SOCKET, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ObservabilityPipelineSocketSourceType { + fn to_string(&self) -> String { + match self { + Self::SOCKET => String::from("socket"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ObservabilityPipelineSocketSourceType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for ObservabilityPipelineSocketSourceType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "socket" => Self::SOCKET, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +}