diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index c554255f1..5ab64baff 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -72071,10 +72071,16 @@ components: packets_sent_by_server: 20 rtt_micro_seconds: 800 tcp_closed_connections: 30 + tcp_delivered_ce: 12 tcp_established_connections: 40 + tcp_probe0_count: 2 + tcp_rcv_ooo_pack: 15 + tcp_recovery_count: 8 tcp_refusals: 7 + tcp_reord_seen: 4 tcp_resets: 5 tcp_retransmits: 30 + tcp_rto_count: 3 tcp_timeouts: 6 id: client_team:networks, server_service:hucklebuck type: aggregated_connection @@ -72132,14 +72138,34 @@ components: description: The number of TCP connections in a closed state. Measured in connections per second from the client. format: int64 type: integer + tcp_delivered_ce: + description: The number of TCP segments acknowledged with the ECN Congestion Experienced (CE) mark, indicating that an upstream router marked packets as experiencing congestion. + format: int64 + type: integer tcp_established_connections: description: The number of TCP connections in an established state. Measured in connections per second from the client. format: int64 type: integer + tcp_probe0_count: + description: The number of TCP zero-window probes sent. These probes are sent when the receiver advertises a zero receive window, indicating it cannot accept more data. + format: int64 + type: integer + tcp_rcv_ooo_pack: + description: The number of TCP packets received out of order. This indicates network-level packet reordering, which can degrade TCP performance by triggering spurious retransmissions and reducing throughput. + format: int64 + type: integer + tcp_recovery_count: + description: The number of TCP fast recovery events. Fast recovery retransmits lost segments detected through duplicate ACKs or selective acknowledgment (SACK) without waiting for a retransmission timeout. + format: int64 + type: integer tcp_refusals: description: The number of TCP connections that were refused by the server. Typically this indicates an attempt to connect to an IP/port that is not receiving connections, or a firewall/security misconfiguration. format: int64 type: integer + tcp_reord_seen: + description: The number of times reordering of sent packets was detected. Reordering detection adjusts the duplicate ACK threshold, preventing spurious retransmissions caused by out-of-order delivery. + format: int64 + type: integer tcp_resets: description: The number of TCP connections that were reset by the server. format: int64 @@ -72148,6 +72174,10 @@ components: description: TCP Retransmits represent detected failures that are retransmitted to ensure delivery. Measured in count of retransmits from the client. format: int64 type: integer + tcp_rto_count: + description: The number of TCP retransmission timeouts (RTOs). An RTO occurs when an ACK is not received within the estimated round-trip time, forcing the sender to retransmit and halve its congestion window. + format: int64 + type: integer tcp_timeouts: description: The number of TCP connections that timed out from the perspective of the operating system. This can indicate general connectivity and latency issues. format: int64 diff --git a/src/datadogV2/model/model_single_aggregated_connection_response_data_attributes.rs b/src/datadogV2/model/model_single_aggregated_connection_response_data_attributes.rs index 4564bc30d..c45848657 100644 --- a/src/datadogV2/model/model_single_aggregated_connection_response_data_attributes.rs +++ b/src/datadogV2/model/model_single_aggregated_connection_response_data_attributes.rs @@ -32,18 +32,36 @@ pub struct SingleAggregatedConnectionResponseDataAttributes { /// The number of TCP connections in a closed state. Measured in connections per second from the client. #[serde(rename = "tcp_closed_connections")] pub tcp_closed_connections: Option, + /// The number of TCP segments acknowledged with the ECN Congestion Experienced (CE) mark, indicating that an upstream router marked packets as experiencing congestion. + #[serde(rename = "tcp_delivered_ce")] + pub tcp_delivered_ce: Option, /// The number of TCP connections in an established state. Measured in connections per second from the client. #[serde(rename = "tcp_established_connections")] pub tcp_established_connections: Option, + /// The number of TCP zero-window probes sent. These probes are sent when the receiver advertises a zero receive window, indicating it cannot accept more data. + #[serde(rename = "tcp_probe0_count")] + pub tcp_probe0_count: Option, + /// The number of TCP packets received out of order. This indicates network-level packet reordering, which can degrade TCP performance by triggering spurious retransmissions and reducing throughput. + #[serde(rename = "tcp_rcv_ooo_pack")] + pub tcp_rcv_ooo_pack: Option, + /// The number of TCP fast recovery events. Fast recovery retransmits lost segments detected through duplicate ACKs or selective acknowledgment (SACK) without waiting for a retransmission timeout. + #[serde(rename = "tcp_recovery_count")] + pub tcp_recovery_count: Option, /// The number of TCP connections that were refused by the server. Typically this indicates an attempt to connect to an IP/port that is not receiving connections, or a firewall/security misconfiguration. #[serde(rename = "tcp_refusals")] pub tcp_refusals: Option, + /// The number of times reordering of sent packets was detected. Reordering detection adjusts the duplicate ACK threshold, preventing spurious retransmissions caused by out-of-order delivery. + #[serde(rename = "tcp_reord_seen")] + pub tcp_reord_seen: Option, /// The number of TCP connections that were reset by the server. #[serde(rename = "tcp_resets")] pub tcp_resets: Option, /// TCP Retransmits represent detected failures that are retransmitted to ensure delivery. Measured in count of retransmits from the client. #[serde(rename = "tcp_retransmits")] pub tcp_retransmits: Option, + /// The number of TCP retransmission timeouts (RTOs). An RTO occurs when an ACK is not received within the estimated round-trip time, forcing the sender to retransmit and halve its congestion window. + #[serde(rename = "tcp_rto_count")] + pub tcp_rto_count: Option, /// The number of TCP connections that timed out from the perspective of the operating system. This can indicate general connectivity and latency issues. #[serde(rename = "tcp_timeouts")] pub tcp_timeouts: Option, @@ -64,10 +82,16 @@ impl SingleAggregatedConnectionResponseDataAttributes { packets_sent_by_server: None, rtt_micro_seconds: None, tcp_closed_connections: None, + tcp_delivered_ce: None, tcp_established_connections: None, + tcp_probe0_count: None, + tcp_rcv_ooo_pack: None, + tcp_recovery_count: None, tcp_refusals: None, + tcp_reord_seen: None, tcp_resets: None, tcp_retransmits: None, + tcp_rto_count: None, tcp_timeouts: None, additional_properties: std::collections::BTreeMap::new(), _unparsed: false, @@ -109,16 +133,41 @@ impl SingleAggregatedConnectionResponseDataAttributes { self } + pub fn tcp_delivered_ce(mut self, value: i64) -> Self { + self.tcp_delivered_ce = Some(value); + self + } + pub fn tcp_established_connections(mut self, value: i64) -> Self { self.tcp_established_connections = Some(value); self } + pub fn tcp_probe0_count(mut self, value: i64) -> Self { + self.tcp_probe0_count = Some(value); + self + } + + pub fn tcp_rcv_ooo_pack(mut self, value: i64) -> Self { + self.tcp_rcv_ooo_pack = Some(value); + self + } + + pub fn tcp_recovery_count(mut self, value: i64) -> Self { + self.tcp_recovery_count = Some(value); + self + } + pub fn tcp_refusals(mut self, value: i64) -> Self { self.tcp_refusals = Some(value); self } + pub fn tcp_reord_seen(mut self, value: i64) -> Self { + self.tcp_reord_seen = Some(value); + self + } + pub fn tcp_resets(mut self, value: i64) -> Self { self.tcp_resets = Some(value); self @@ -129,6 +178,11 @@ impl SingleAggregatedConnectionResponseDataAttributes { self } + pub fn tcp_rto_count(mut self, value: i64) -> Self { + self.tcp_rto_count = Some(value); + self + } + pub fn tcp_timeouts(mut self, value: i64) -> Self { self.tcp_timeouts = Some(value); self @@ -173,10 +227,16 @@ impl<'de> Deserialize<'de> for SingleAggregatedConnectionResponseDataAttributes let mut packets_sent_by_server: Option = None; let mut rtt_micro_seconds: Option = None; let mut tcp_closed_connections: Option = None; + let mut tcp_delivered_ce: Option = None; let mut tcp_established_connections: Option = None; + let mut tcp_probe0_count: Option = None; + let mut tcp_rcv_ooo_pack: Option = None; + let mut tcp_recovery_count: Option = None; let mut tcp_refusals: Option = None; + let mut tcp_reord_seen: Option = None; let mut tcp_resets: Option = None; let mut tcp_retransmits: Option = None; + let mut tcp_rto_count: Option = None; let mut tcp_timeouts: Option = None; let mut additional_properties: std::collections::BTreeMap< String, @@ -234,6 +294,13 @@ impl<'de> Deserialize<'de> for SingleAggregatedConnectionResponseDataAttributes tcp_closed_connections = Some(serde_json::from_value(v).map_err(M::Error::custom)?); } + "tcp_delivered_ce" => { + if v.is_null() { + continue; + } + tcp_delivered_ce = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } "tcp_established_connections" => { if v.is_null() { continue; @@ -241,6 +308,27 @@ impl<'de> Deserialize<'de> for SingleAggregatedConnectionResponseDataAttributes tcp_established_connections = Some(serde_json::from_value(v).map_err(M::Error::custom)?); } + "tcp_probe0_count" => { + if v.is_null() { + continue; + } + tcp_probe0_count = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "tcp_rcv_ooo_pack" => { + if v.is_null() { + continue; + } + tcp_rcv_ooo_pack = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "tcp_recovery_count" => { + if v.is_null() { + continue; + } + tcp_recovery_count = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } "tcp_refusals" => { if v.is_null() { continue; @@ -248,6 +336,13 @@ impl<'de> Deserialize<'de> for SingleAggregatedConnectionResponseDataAttributes tcp_refusals = Some(serde_json::from_value(v).map_err(M::Error::custom)?); } + "tcp_reord_seen" => { + if v.is_null() { + continue; + } + tcp_reord_seen = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } "tcp_resets" => { if v.is_null() { continue; @@ -261,6 +356,13 @@ impl<'de> Deserialize<'de> for SingleAggregatedConnectionResponseDataAttributes tcp_retransmits = Some(serde_json::from_value(v).map_err(M::Error::custom)?); } + "tcp_rto_count" => { + if v.is_null() { + continue; + } + tcp_rto_count = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } "tcp_timeouts" => { if v.is_null() { continue; @@ -284,10 +386,16 @@ impl<'de> Deserialize<'de> for SingleAggregatedConnectionResponseDataAttributes packets_sent_by_server, rtt_micro_seconds, tcp_closed_connections, + tcp_delivered_ce, tcp_established_connections, + tcp_probe0_count, + tcp_rcv_ooo_pack, + tcp_recovery_count, tcp_refusals, + tcp_reord_seen, tcp_resets, tcp_retransmits, + tcp_rto_count, tcp_timeouts, additional_properties, _unparsed,