From 3f1645408d9c2b5d0e4f42e5bf4b9705386941b5 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Tue, 24 Jun 2025 13:28:03 +0000 Subject: [PATCH] Regenerate client from commit a11e9377 of spec repo --- .apigentools-info | 8 +- .generator/schemas/v2/openapi.yaml | 274 ++++++++++++++++++ src/datadogV2/model/mod.rs | 50 ++++ ...bility_pipeline_config_destination_item.rs | 11 + ...servability_pipeline_config_source_item.rs | 13 + ...servability_pipeline_socket_destination.rs | 207 +++++++++++++ ...ty_pipeline_socket_destination_encoding.rs | 51 ++++ ...ity_pipeline_socket_destination_framing.rs | 48 +++ ...peline_socket_destination_framing_bytes.rs | 102 +++++++ ...socket_destination_framing_bytes_method.rs | 48 +++ ...destination_framing_character_delimited.rs | 114 ++++++++ ...tion_framing_character_delimited_method.rs | 50 ++++ ...t_destination_framing_newline_delimited.rs | 103 +++++++ ...nation_framing_newline_delimited_method.rs | 48 +++ ...bility_pipeline_socket_destination_mode.rs | 51 ++++ ...bility_pipeline_socket_destination_type.rs | 48 +++ ...el_observability_pipeline_socket_source.rs | 175 +++++++++++ ...vability_pipeline_socket_source_framing.rs | 82 ++++++ ...ty_pipeline_socket_source_framing_bytes.rs | 104 +++++++ ...line_socket_source_framing_bytes_method.rs | 48 +++ ...cket_source_framing_character_delimited.rs | 115 ++++++++ ...urce_framing_character_delimited_method.rs | 48 +++ ...line_socket_source_framing_chunked_gelf.rs | 102 +++++++ ...cket_source_framing_chunked_gelf_method.rs | 48 +++ ...socket_source_framing_newline_delimited.rs | 104 +++++++ ...source_framing_newline_delimited_method.rs | 48 +++ ...ne_socket_source_framing_octet_counting.rs | 103 +++++++ ...et_source_framing_octet_counting_method.rs | 48 +++ ...servability_pipeline_socket_source_mode.rs | 51 ++++ ...servability_pipeline_socket_source_type.rs | 48 +++ 30 files changed, 2346 insertions(+), 4 deletions(-) create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_destination.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_destination_encoding.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_destination_framing.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_destination_framing_bytes.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_destination_framing_bytes_method.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_destination_framing_character_delimited.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_destination_framing_character_delimited_method.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_destination_framing_newline_delimited.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_destination_framing_newline_delimited_method.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_destination_mode.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_destination_type.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_source.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_source_framing.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_source_framing_bytes.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_source_framing_bytes_method.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_source_framing_character_delimited.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_source_framing_character_delimited_method.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_source_framing_chunked_gelf.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_source_framing_chunked_gelf_method.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_source_framing_newline_delimited.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_source_framing_newline_delimited_method.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_source_framing_octet_counting.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_source_framing_octet_counting_method.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_source_mode.rs create mode 100644 src/datadogV2/model/model_observability_pipeline_socket_source_type.rs diff --git a/.apigentools-info b/.apigentools-info index a4a173218..355f5870c 100644 --- a/.apigentools-info +++ b/.apigentools-info @@ -4,13 +4,13 @@ "spec_versions": { "v1": { "apigentools_version": "1.6.6", - "regenerated": "2025-06-23 20:34:45.000901", - "spec_repo_commit": "837c2656" + "regenerated": "2025-06-24 13:22:17.355211", + "spec_repo_commit": "a11e9377" }, "v2": { "apigentools_version": "1.6.6", - "regenerated": "2025-06-23 20:34:45.017074", - "spec_repo_commit": "837c2656" + "regenerated": "2025-06-24 13:22:17.373611", + "spec_repo_commit": "a11e9377" } } } \ No newline at end of file diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 115918b18..8de42f67b 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -24267,6 +24267,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: @@ -24304,6 +24305,7 @@ components: - $ref: '#/components/schemas/ObservabilityPipelineGooglePubSubSource' - $ref: '#/components/schemas/ObservabilityPipelineHttpClientSource' - $ref: '#/components/schemas/ObservabilityPipelineLogstashSource' + - $ref: '#/components/schemas/ObservabilityPipelineSocketSource' ObservabilityPipelineData: description: "Contains the pipeline\u2019s ID, type, and configuration attributes." properties: @@ -26587,6 +26589,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 37942f439..5a13a4e67 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -3366,6 +3366,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; @@ -3624,6 +3646,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_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_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()), + }), + }) + } +}