1#![allow(clippy::all, dead_code, unused)]
4
5#![allow(missing_docs)]
7
8use std::collections::HashMap;
9
10pub mod error {
12 pub struct ConversionError(::std::borrow::Cow<'static, str>);
13 impl ::std::error::Error for ConversionError {}
14 impl ::std::fmt::Display for ConversionError {
15 fn fmt(
16 &self,
17 f: &mut ::std::fmt::Formatter<'_>,
18 ) -> Result<(), ::std::fmt::Error> {
19 ::std::fmt::Display::fmt(&self.0, f)
20 }
21 }
22 impl ::std::fmt::Debug for ConversionError {
23 fn fmt(
24 &self,
25 f: &mut ::std::fmt::Formatter<'_>,
26 ) -> Result<(), ::std::fmt::Error> {
27 ::std::fmt::Debug::fmt(&self.0, f)
28 }
29 }
30 impl From<&'static str> for ConversionError {
31 fn from(value: &'static str) -> Self {
32 Self(value.into())
33 }
34 }
35 impl From<String> for ConversionError {
36 fn from(value: String) -> Self {
37 Self(value.into())
38 }
39 }
40}
41
42#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
43pub struct DatadogConfiguration {
44 #[serde(default, skip_serializing_if = ":: std :: collections :: HashMap::is_empty")]
45 pub additional_endpoints: HashMap<String, Vec<String>>,
46
47 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
48 pub agent_ipc: Option<DatadogConfigurationAgentIpc>,
49
50 #[serde(default = "defaults::default_u64::<i64, 2>")]
51 pub aggregator_stop_timeout: i64,
52
53 #[serde(default)]
54 pub allow_arbitrary_tags: bool,
55
56 #[serde(default)]
57 pub api_key: String,
58
59 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
60 pub apm_config: Option<DatadogConfigurationApmConfig>,
61
62 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
63 pub autoscaling: Option<DatadogConfigurationAutoscaling>,
64
65 #[serde(default)]
66 pub bind_host: String,
67
68 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
69 pub cluster_agent: Option<DatadogConfigurationClusterAgent>,
70
71 #[serde(default = "defaults::default_u64::<i64, 5001>")]
72 pub cmd_port: i64,
73
74 #[serde(default = "defaults::default_u64::<i64, 1>")]
75 pub cri_connection_timeout: i64,
76
77 #[serde(default = "defaults::default_u64::<i64, 5>")]
78 pub cri_query_timeout: i64,
79
80 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
81 pub data_plane: Option<DatadogConfigurationDataPlane>,
82
83 #[serde(default = "defaults::datadog_configuration_dd_url")]
84 pub dd_url: String,
85
86 #[serde(default = "defaults::default_u64::<i64, 8192>")]
87 pub dogstatsd_buffer_size: i64,
88
89 #[serde(default)]
90 pub dogstatsd_capture_depth: i64,
91
92 #[serde(default)]
93 pub dogstatsd_capture_path: String,
94
95 #[serde(default = "defaults::default_u64::<i64, 20>")]
96 pub dogstatsd_context_expiry_seconds: i64,
97
98 #[serde(default)]
99 pub dogstatsd_disable_verbose_logs: bool,
100
101 #[serde(default)]
102 pub dogstatsd_entity_id_precedence: bool,
103
104 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
105 pub dogstatsd_eol_required: Vec<String>,
106
107 #[serde(default)]
108 #[serde(alias = "aggregate_flush_open_windows")]
110 pub dogstatsd_flush_incomplete_buckets: bool,
111
112 #[serde(default)]
113 pub dogstatsd_log_file: String,
114
115 #[serde(default = "defaults::default_u64::<i64, 3>")]
116 pub dogstatsd_log_file_max_rolls: i64,
117
118 #[serde(default = "defaults::datadog_configuration_dogstatsd_log_file_max_size")]
119 pub dogstatsd_log_file_max_size: String,
120
121 #[serde(default = "defaults::default_bool::<true>")]
122 pub dogstatsd_logging_enabled: bool,
123
124 #[serde(default = "defaults::default_u64::<i64, 1000>")]
125 pub dogstatsd_mapper_cache_size: i64,
126
127 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
128 pub dogstatsd_mapper_profiles: Vec<::serde_json::Value>,
129
130 #[serde(default)]
131 pub dogstatsd_metrics_stats_enable: bool,
132
133 #[serde(default = "defaults::default_bool::<true>")]
134 pub dogstatsd_no_aggregation_pipeline: bool,
135
136 #[serde(default)]
137 pub dogstatsd_non_local_traffic: bool,
138
139 #[serde(default)]
140 pub dogstatsd_origin_detection: bool,
141
142 #[serde(default)]
143 pub dogstatsd_origin_detection_client: bool,
144
145 #[serde(default = "defaults::default_bool::<true>")]
146 pub dogstatsd_origin_optout_enabled: bool,
147
148 #[serde(default)]
149 pub dogstatsd_pipe_name: String,
150
151 #[serde(default = "defaults::default_u64::<i64, 8125>")]
152 pub dogstatsd_port: i64,
153
154 #[serde(default)]
155 pub dogstatsd_so_rcvbuf: i64,
156
157 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
158 pub dogstatsd_socket: Option<String>,
159
160 #[serde(default)]
161 pub dogstatsd_stream_log_too_big: bool,
162
163 #[serde(default)]
164 pub dogstatsd_stream_socket: String,
165
166 #[serde(default = "defaults::default_u64::<i64, 4096>")]
167 pub dogstatsd_string_interner_size: i64,
168
169 #[serde(default = "defaults::datadog_configuration_dogstatsd_tag_cardinality")]
170 pub dogstatsd_tag_cardinality: String,
171
172 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
173 pub dogstatsd_tags: Vec<String>,
174
175 #[serde(
176 default = "defaults::datadog_configuration_dogstatsd_windows_pipe_security_descriptor"
177 )]
178 pub dogstatsd_windows_pipe_security_descriptor: String,
179
180 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
181 pub enable_payloads: Option<DatadogConfigurationEnablePayloads>,
182
183 #[serde(default)]
184 pub env: String,
185
186 #[serde(default = "defaults::default_u64::<i64, 60>")]
187 pub forwarder_apikey_validation_interval: i64,
188
189 #[serde(default = "defaults::default_u64::<i64, 2>")]
190 pub forwarder_backoff_base: i64,
191
192 #[serde(default = "defaults::default_u64::<i64, 2>")]
193 pub forwarder_backoff_factor: i64,
194
195 #[serde(default = "defaults::default_u64::<i64, 64>")]
196 pub forwarder_backoff_max: i64,
197
198 #[serde(default)]
199 pub forwarder_connection_reset_interval: i64,
200
201 #[serde(
202 default = "defaults::datadog_configuration_forwarder_flush_to_disk_mem_ratio"
203 )]
204 pub forwarder_flush_to_disk_mem_ratio: f64,
205
206 #[serde(default = "defaults::default_u64::<i64, 100>")]
207 pub forwarder_high_prio_buffer_size: i64,
208
209 #[serde(default = "defaults::datadog_configuration_forwarder_http_protocol")]
210 pub forwarder_http_protocol: String,
211
212 #[serde(default = "defaults::default_u64::<i64, 10>")]
213 pub forwarder_max_concurrent_requests: i64,
214
215 #[serde(default = "defaults::default_u64::<i64, 1>")]
216 pub forwarder_num_workers: i64,
217
218 #[serde(default = "defaults::default_u64::<i64, 10>")]
219 pub forwarder_outdated_file_in_days: i64,
220
221 #[serde(default = "defaults::default_u64::<i64, 2>")]
222 pub forwarder_recovery_interval: i64,
223
224 #[serde(default)]
225 pub forwarder_recovery_reset: bool,
226
227 #[serde(default = "defaults::default_u64::<i64, 900>")]
228 pub forwarder_retry_queue_capacity_time_interval_sec: i64,
229
230 #[serde(default)]
231 pub forwarder_retry_queue_max_size: i64,
232
233 #[serde(default = "defaults::default_u64::<i64, 15728640>")]
234 pub forwarder_retry_queue_payloads_max_size: i64,
235
236 #[serde(default = "defaults::default_u64::<i64, 2>")]
237 pub forwarder_stop_timeout: i64,
238
239 #[serde(
240 default = "defaults::datadog_configuration_forwarder_storage_max_disk_ratio"
241 )]
242 pub forwarder_storage_max_disk_ratio: f64,
243
244 #[serde(default)]
245 pub forwarder_storage_max_size_in_bytes: i64,
246
247 #[serde(default)]
248 pub forwarder_storage_path: String,
249
250 #[serde(default = "defaults::default_u64::<i64, 20>")]
251 pub forwarder_timeout: i64,
252
253 #[serde(default = "defaults::datadog_configuration_histogram_aggregates")]
254 pub histogram_aggregates: Vec<String>,
255
256 #[serde(default)]
257 pub histogram_copy_to_distribution: bool,
258
259 #[serde(default)]
260 pub histogram_copy_to_distribution_prefix: String,
261
262 #[serde(default)]
263 pub log_format_rfc3339: bool,
264
265 #[serde(default = "defaults::datadog_configuration_log_level")]
266 pub log_level: String,
267
268 #[serde(default)]
269 pub log_payloads: bool,
270
271 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
272 pub metric_filterlist: Vec<String>,
273
274 #[serde(default)]
275 pub metric_filterlist_match_prefix: bool,
276
277 #[serde(default = "defaults::datadog_configuration_min_tls_version")]
278 pub min_tls_version: String,
279
280 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
281 pub multi_region_failover: Option<DatadogConfigurationMultiRegionFailover>,
282
283 #[serde(default)]
284 pub no_proxy_nonexact_match: bool,
285
286 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
287 pub observability_pipelines_worker: Option<
288 DatadogConfigurationObservabilityPipelinesWorker,
289
290 >,
291
292 #[serde(default)]
293 pub origin_detection_unified: bool,
294
295 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
296 pub otlp_config: Option<DatadogConfigurationOtlpConfig>,
297
298 #[serde(default)]
299 pub provider_kind: String,
300
301 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
302 pub proxy: Option<DatadogConfigurationProxy>,
303
304 #[serde(default = "defaults::datadog_configuration_serializer_compressor_kind")]
305 pub serializer_compressor_kind: String,
306
307 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
308 pub serializer_experimental_use_v3_api: Option<
309 DatadogConfigurationSerializerExperimentalUseV3Api,
310
311 >,
312
313 #[serde(default = "defaults::default_u64::<i64, 2621440>")]
314 pub serializer_max_payload_size: i64,
315
316 #[serde(default = "defaults::default_u64::<i64, 512000>")]
317 pub serializer_max_series_payload_size: i64,
318
319 #[serde(default = "defaults::default_u64::<i64, 10000>")]
320 pub serializer_max_series_points_per_payload: i64,
321
322 #[serde(default = "defaults::default_u64::<i64, 5242880>")]
323 pub serializer_max_series_uncompressed_payload_size: i64,
324
325 #[serde(default = "defaults::default_u64::<i64, 4194304>")]
326 pub serializer_max_uncompressed_payload_size: i64,
327
328 #[serde(default = "defaults::default_u64::<i64, 1>")]
329 pub serializer_zstd_compressor_level: i64,
330
331 #[serde(default = "defaults::datadog_configuration_site")]
332 pub site: String,
333
334 #[serde(default)]
335 pub skip_ssl_validation: bool,
336
337 #[serde(default)]
338 pub sslkeylogfile: String,
339
340 #[serde(default)]
341 pub statsd_forward_host: String,
342
343 #[serde(default)]
344 pub statsd_forward_port: i64,
345
346 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
347 pub statsd_metric_blocklist: Vec<String>,
348
349 #[serde(default)]
350 pub statsd_metric_blocklist_match_prefix: bool,
351
352 #[serde(default)]
353 pub statsd_metric_namespace: String,
354
355 #[serde(
356 default = "defaults::datadog_configuration_statsd_metric_namespace_blacklist"
357 )]
358 #[serde(alias = "statsd_metric_namespace_blocklist")]
360 pub statsd_metric_namespace_blacklist: Vec<String>,
361
362 #[serde(default)]
363 pub syslog_rfc: bool,
364
365 #[serde(default)]
366 pub syslog_uri: String,
367
368 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
369 pub telemetry: Option<DatadogConfigurationTelemetry>,
370
371 #[serde(default)]
372 pub use_proxy_for_cloud_metadata: bool,
373
374 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
375 pub use_v2_api: Option<DatadogConfigurationUseV2Api>,
376
377 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
378 pub use_v3_api: Option<DatadogConfigurationUseV3Api>,
379
380 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
381 pub vector: Option<DatadogConfigurationVector>,
382
383 #[serde(default)]
384 pub vsock_addr: String,
385}
386
387impl Default for DatadogConfiguration {
388 fn default() -> Self {
389 Self {
390 additional_endpoints: Default::default(),
391 agent_ipc: Default::default(),
392 aggregator_stop_timeout: defaults::default_u64::<i64, 2>(),
393 allow_arbitrary_tags: Default::default(),
394 api_key: Default::default(),
395 apm_config: Default::default(),
396 autoscaling: Default::default(),
397 bind_host: Default::default(),
398 cluster_agent: Default::default(),
399 cmd_port: defaults::default_u64::<i64, 5001>(),
400 cri_connection_timeout: defaults::default_u64::<i64, 1>(),
401 cri_query_timeout: defaults::default_u64::<i64, 5>(),
402 data_plane: Default::default(),
403 dd_url: defaults::datadog_configuration_dd_url(),
404 dogstatsd_buffer_size: defaults::default_u64::<i64, 8192>(),
405 dogstatsd_capture_depth: Default::default(),
406 dogstatsd_capture_path: Default::default(),
407 dogstatsd_context_expiry_seconds: defaults::default_u64::<i64, 20>(),
408 dogstatsd_disable_verbose_logs: Default::default(),
409 dogstatsd_entity_id_precedence: Default::default(),
410 dogstatsd_eol_required: Default::default(),
411 dogstatsd_flush_incomplete_buckets: Default::default(),
412 dogstatsd_log_file: Default::default(),
413 dogstatsd_log_file_max_rolls: defaults::default_u64::<i64, 3>(),
414 dogstatsd_log_file_max_size: defaults::datadog_configuration_dogstatsd_log_file_max_size(),
415 dogstatsd_logging_enabled: defaults::default_bool::<true>(),
416 dogstatsd_mapper_cache_size: defaults::default_u64::<i64, 1000>(),
417 dogstatsd_mapper_profiles: Default::default(),
418 dogstatsd_metrics_stats_enable: Default::default(),
419 dogstatsd_no_aggregation_pipeline: defaults::default_bool::<true>(),
420 dogstatsd_non_local_traffic: Default::default(),
421 dogstatsd_origin_detection: Default::default(),
422 dogstatsd_origin_detection_client: Default::default(),
423 dogstatsd_origin_optout_enabled: defaults::default_bool::<true>(),
424 dogstatsd_pipe_name: Default::default(),
425 dogstatsd_port: defaults::default_u64::<i64, 8125>(),
426 dogstatsd_so_rcvbuf: Default::default(),
427 dogstatsd_socket: Default::default(),
428 dogstatsd_stream_log_too_big: Default::default(),
429 dogstatsd_stream_socket: Default::default(),
430 dogstatsd_string_interner_size: defaults::default_u64::<i64, 4096>(),
431 dogstatsd_tag_cardinality: defaults::datadog_configuration_dogstatsd_tag_cardinality(),
432 dogstatsd_tags: Default::default(),
433 dogstatsd_windows_pipe_security_descriptor: defaults::datadog_configuration_dogstatsd_windows_pipe_security_descriptor(),
434 enable_payloads: Default::default(),
435 env: Default::default(),
436 forwarder_apikey_validation_interval: defaults::default_u64::<i64, 60>(),
437 forwarder_backoff_base: defaults::default_u64::<i64, 2>(),
438 forwarder_backoff_factor: defaults::default_u64::<i64, 2>(),
439 forwarder_backoff_max: defaults::default_u64::<i64, 64>(),
440 forwarder_connection_reset_interval: Default::default(),
441 forwarder_flush_to_disk_mem_ratio: defaults::datadog_configuration_forwarder_flush_to_disk_mem_ratio(),
442 forwarder_high_prio_buffer_size: defaults::default_u64::<i64, 100>(),
443 forwarder_http_protocol: defaults::datadog_configuration_forwarder_http_protocol(),
444 forwarder_max_concurrent_requests: defaults::default_u64::<i64, 10>(),
445 forwarder_num_workers: defaults::default_u64::<i64, 1>(),
446 forwarder_outdated_file_in_days: defaults::default_u64::<i64, 10>(),
447 forwarder_recovery_interval: defaults::default_u64::<i64, 2>(),
448 forwarder_recovery_reset: Default::default(),
449 forwarder_retry_queue_capacity_time_interval_sec: defaults::default_u64::<
450 i64,
451 900,
452 >(),
453 forwarder_retry_queue_max_size: Default::default(),
454 forwarder_retry_queue_payloads_max_size: defaults::default_u64::<
455 i64,
456 15728640,
457 >(),
458 forwarder_stop_timeout: defaults::default_u64::<i64, 2>(),
459 forwarder_storage_max_disk_ratio: defaults::datadog_configuration_forwarder_storage_max_disk_ratio(),
460 forwarder_storage_max_size_in_bytes: Default::default(),
461 forwarder_storage_path: Default::default(),
462 forwarder_timeout: defaults::default_u64::<i64, 20>(),
463 histogram_aggregates: defaults::datadog_configuration_histogram_aggregates(),
464 histogram_copy_to_distribution: Default::default(),
465 histogram_copy_to_distribution_prefix: Default::default(),
466 log_format_rfc3339: Default::default(),
467 log_level: defaults::datadog_configuration_log_level(),
468 log_payloads: Default::default(),
469 metric_filterlist: Default::default(),
470 metric_filterlist_match_prefix: Default::default(),
471 min_tls_version: defaults::datadog_configuration_min_tls_version(),
472 multi_region_failover: Default::default(),
473 no_proxy_nonexact_match: Default::default(),
474 observability_pipelines_worker: Default::default(),
475 origin_detection_unified: Default::default(),
476 otlp_config: Default::default(),
477 provider_kind: Default::default(),
478 proxy: Default::default(),
479 serializer_compressor_kind: defaults::datadog_configuration_serializer_compressor_kind(),
480 serializer_experimental_use_v3_api: Default::default(),
481 serializer_max_payload_size: defaults::default_u64::<i64, 2621440>(),
482 serializer_max_series_payload_size: defaults::default_u64::<i64, 512000>(),
483 serializer_max_series_points_per_payload: defaults::default_u64::<
484 i64,
485 10000,
486 >(),
487 serializer_max_series_uncompressed_payload_size: defaults::default_u64::<
488 i64,
489 5242880,
490 >(),
491 serializer_max_uncompressed_payload_size: defaults::default_u64::<
492 i64,
493 4194304,
494 >(),
495 serializer_zstd_compressor_level: defaults::default_u64::<i64, 1>(),
496 site: defaults::datadog_configuration_site(),
497 skip_ssl_validation: Default::default(),
498 sslkeylogfile: Default::default(),
499 statsd_forward_host: Default::default(),
500 statsd_forward_port: Default::default(),
501 statsd_metric_blocklist: Default::default(),
502 statsd_metric_blocklist_match_prefix: Default::default(),
503 statsd_metric_namespace: Default::default(),
504 statsd_metric_namespace_blacklist: defaults::datadog_configuration_statsd_metric_namespace_blacklist(),
505 syslog_rfc: Default::default(),
506 syslog_uri: Default::default(),
507 telemetry: Default::default(),
508 use_proxy_for_cloud_metadata: Default::default(),
509 use_v2_api: Default::default(),
510 use_v3_api: Default::default(),
511 vector: Default::default(),
512 vsock_addr: Default::default(),
513 }
514 }
515}
516
517#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
518pub struct DatadogConfigurationAgentIpc {
519 #[serde(default = "defaults::default_u64::<i64, 134217728>")]
520 pub grpc_max_message_size: i64,
521}
522
523impl Default for DatadogConfigurationAgentIpc {
524 fn default() -> Self {
525 Self {
526 grpc_max_message_size: defaults::default_u64::<i64, 134217728>(),
527 }
528 }
529}
530
531#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
532pub struct DatadogConfigurationApmConfig {
533 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
534 pub obfuscation: Option<DatadogConfigurationApmConfigObfuscation>,
535}
536
537impl Default for DatadogConfigurationApmConfig {
538 fn default() -> Self {
539 Self {
540 obfuscation: Default::default(),
541 }
542 }
543}
544
545#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
546pub struct DatadogConfigurationApmConfigObfuscation {
547 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
548 pub credit_cards: Option<DatadogConfigurationApmConfigObfuscationCreditCards>,
549
550 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
551 pub elasticsearch: Option<DatadogConfigurationApmConfigObfuscationElasticsearch>,
552
553 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
554 pub http: Option<DatadogConfigurationApmConfigObfuscationHttp>,
555
556 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
557 pub memcached: Option<DatadogConfigurationApmConfigObfuscationMemcached>,
558
559 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
560 pub mongodb: Option<DatadogConfigurationApmConfigObfuscationMongodb>,
561
562 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
563 pub opensearch: Option<DatadogConfigurationApmConfigObfuscationOpensearch>,
564
565 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
566 pub redis: Option<DatadogConfigurationApmConfigObfuscationRedis>,
567
568 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
569 pub valkey: Option<DatadogConfigurationApmConfigObfuscationValkey>,
570}
571
572impl Default for DatadogConfigurationApmConfigObfuscation {
573 fn default() -> Self {
574 Self {
575 credit_cards: Default::default(),
576 elasticsearch: Default::default(),
577 http: Default::default(),
578 memcached: Default::default(),
579 mongodb: Default::default(),
580 opensearch: Default::default(),
581 redis: Default::default(),
582 valkey: Default::default(),
583 }
584 }
585}
586
587#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
588pub struct DatadogConfigurationApmConfigObfuscationCreditCards {
589 #[serde(default = "defaults::default_bool::<true>")]
590 pub enabled: bool,
591
592 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
593 pub keep_values: Vec<String>,
594
595 #[serde(default)]
596 pub luhn: bool,
597}
598
599impl Default for DatadogConfigurationApmConfigObfuscationCreditCards {
600 fn default() -> Self {
601 Self {
602 enabled: defaults::default_bool::<true>(),
603 keep_values: Default::default(),
604 luhn: Default::default(),
605 }
606 }
607}
608
609#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
610pub struct DatadogConfigurationApmConfigObfuscationElasticsearch {
611 #[serde(default = "defaults::default_bool::<true>")]
612 pub enabled: bool,
613
614 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
615 pub keep_values: Vec<String>,
616
617 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
618 pub obfuscate_sql_values: Vec<String>,
619}
620
621impl Default for DatadogConfigurationApmConfigObfuscationElasticsearch {
622 fn default() -> Self {
623 Self {
624 enabled: defaults::default_bool::<true>(),
625 keep_values: Default::default(),
626 obfuscate_sql_values: Default::default(),
627 }
628 }
629}
630
631#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
632pub struct DatadogConfigurationApmConfigObfuscationHttp {
633 #[serde(default)]
634 pub remove_paths_with_digits: bool,
635
636 #[serde(default)]
637 pub remove_query_string: bool,
638}
639
640impl Default for DatadogConfigurationApmConfigObfuscationHttp {
641 fn default() -> Self {
642 Self {
643 remove_paths_with_digits: Default::default(),
644 remove_query_string: Default::default(),
645 }
646 }
647}
648
649#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
650pub struct DatadogConfigurationApmConfigObfuscationMemcached {
651 #[serde(default = "defaults::default_bool::<true>")]
652 pub enabled: bool,
653
654 #[serde(default)]
655 pub keep_command: bool,
656}
657
658impl Default for DatadogConfigurationApmConfigObfuscationMemcached {
659 fn default() -> Self {
660 Self {
661 enabled: defaults::default_bool::<true>(),
662 keep_command: Default::default(),
663 }
664 }
665}
666
667#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
668pub struct DatadogConfigurationApmConfigObfuscationMongodb {
669 #[serde(default = "defaults::default_bool::<true>")]
670 pub enabled: bool,
671
672 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
673 pub keep_values: Vec<String>,
674
675 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
676 pub obfuscate_sql_values: Vec<String>,
677}
678
679impl Default for DatadogConfigurationApmConfigObfuscationMongodb {
680 fn default() -> Self {
681 Self {
682 enabled: defaults::default_bool::<true>(),
683 keep_values: Default::default(),
684 obfuscate_sql_values: Default::default(),
685 }
686 }
687}
688
689#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
690pub struct DatadogConfigurationApmConfigObfuscationOpensearch {
691 #[serde(default = "defaults::default_bool::<true>")]
692 pub enabled: bool,
693
694 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
695 pub keep_values: Vec<String>,
696
697 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
698 pub obfuscate_sql_values: Vec<String>,
699}
700
701impl Default for DatadogConfigurationApmConfigObfuscationOpensearch {
702 fn default() -> Self {
703 Self {
704 enabled: defaults::default_bool::<true>(),
705 keep_values: Default::default(),
706 obfuscate_sql_values: Default::default(),
707 }
708 }
709}
710
711#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
712pub struct DatadogConfigurationApmConfigObfuscationRedis {
713 #[serde(default = "defaults::default_bool::<true>")]
714 pub enabled: bool,
715
716 #[serde(default)]
717 pub remove_all_args: bool,
718}
719
720impl Default for DatadogConfigurationApmConfigObfuscationRedis {
721 fn default() -> Self {
722 Self {
723 enabled: defaults::default_bool::<true>(),
724 remove_all_args: Default::default(),
725 }
726 }
727}
728
729#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
730pub struct DatadogConfigurationApmConfigObfuscationValkey {
731 #[serde(default = "defaults::default_bool::<true>")]
732 pub enabled: bool,
733
734 #[serde(default)]
735 pub remove_all_args: bool,
736}
737
738impl Default for DatadogConfigurationApmConfigObfuscationValkey {
739 fn default() -> Self {
740 Self {
741 enabled: defaults::default_bool::<true>(),
742 remove_all_args: Default::default(),
743 }
744 }
745}
746
747#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
748pub struct DatadogConfigurationAutoscaling {
749 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
750 pub failover: Option<DatadogConfigurationAutoscalingFailover>,
751}
752
753impl Default for DatadogConfigurationAutoscaling {
754 fn default() -> Self {
755 Self {
756 failover: Default::default(),
757 }
758 }
759}
760
761#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
762pub struct DatadogConfigurationAutoscalingFailover {
763 #[serde(default)]
764 pub enabled: bool,
765
766 #[serde(default = "defaults::datadog_configuration_autoscaling_failover_metrics")]
767 pub metrics: Vec<String>,
768}
769
770impl Default for DatadogConfigurationAutoscalingFailover {
771 fn default() -> Self {
772 Self {
773 enabled: Default::default(),
774 metrics: defaults::datadog_configuration_autoscaling_failover_metrics(),
775 }
776 }
777}
778
779#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
780pub struct DatadogConfigurationClusterAgent {
781 #[serde(default)]
782 pub auth_token: String,
783
784 #[serde(default)]
785 pub enabled: bool,
786
787 #[serde(
788 default = "defaults::datadog_configuration_cluster_agent_kubernetes_service_name"
789 )]
790 pub kubernetes_service_name: String,
791
792 #[serde(default)]
793 pub url: String,
794}
795
796impl Default for DatadogConfigurationClusterAgent {
797 fn default() -> Self {
798 Self {
799 auth_token: Default::default(),
800 enabled: Default::default(),
801 kubernetes_service_name: defaults::datadog_configuration_cluster_agent_kubernetes_service_name(),
802 url: Default::default(),
803 }
804 }
805}
806
807#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
808pub struct DatadogConfigurationDataPlane {
809 #[serde(default = "defaults::datadog_configuration_data_plane_api_listen_address")]
810 pub api_listen_address: String,
811
812 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
813 pub dogstatsd: Option<DatadogConfigurationDataPlaneDogstatsd>,
814
815 #[serde(default = "defaults::datadog_configuration_data_plane_log_file")]
816 pub log_file: String,
817
818 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
819 pub otlp: Option<DatadogConfigurationDataPlaneOtlp>,
820
821 #[serde(default = "defaults::default_bool::<true>")]
822 pub remote_agent_enabled: bool,
823
824 #[serde(
825 default = "defaults::datadog_configuration_data_plane_secure_api_listen_address"
826 )]
827 pub secure_api_listen_address: String,
828
829 #[serde(default = "defaults::default_bool::<true>")]
830 pub use_new_config_stream_endpoint: bool,
831}
832
833impl Default for DatadogConfigurationDataPlane {
834 fn default() -> Self {
835 Self {
836 api_listen_address: defaults::datadog_configuration_data_plane_api_listen_address(),
837 dogstatsd: Default::default(),
838 log_file: defaults::datadog_configuration_data_plane_log_file(),
839 otlp: Default::default(),
840 remote_agent_enabled: defaults::default_bool::<true>(),
841 secure_api_listen_address: defaults::datadog_configuration_data_plane_secure_api_listen_address(),
842 use_new_config_stream_endpoint: defaults::default_bool::<true>(),
843 }
844 }
845}
846
847#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
848pub struct DatadogConfigurationDataPlaneDogstatsd {
849 #[serde(default = "defaults::default_u64::<i64, 100000>")]
850 pub aggregator_tag_filter_cache_capacity: i64,
851}
852
853impl Default for DatadogConfigurationDataPlaneDogstatsd {
854 fn default() -> Self {
855 Self {
856 aggregator_tag_filter_cache_capacity: defaults::default_u64::<i64, 100000>(),
857 }
858 }
859}
860
861#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
862pub struct DatadogConfigurationDataPlaneOtlp {
863 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
864 pub proxy: Option<DatadogConfigurationDataPlaneOtlpProxy>,
865}
866
867impl Default for DatadogConfigurationDataPlaneOtlp {
868 fn default() -> Self {
869 Self { proxy: Default::default() }
870 }
871}
872
873#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
874pub struct DatadogConfigurationDataPlaneOtlpProxy {
875 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
876 pub logs: Option<DatadogConfigurationDataPlaneOtlpProxyLogs>,
877
878 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
879 pub metrics: Option<DatadogConfigurationDataPlaneOtlpProxyMetrics>,
880
881 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
882 pub traces: Option<DatadogConfigurationDataPlaneOtlpProxyTraces>,
883}
884
885impl Default for DatadogConfigurationDataPlaneOtlpProxy {
886 fn default() -> Self {
887 Self {
888 logs: Default::default(),
889 metrics: Default::default(),
890 traces: Default::default(),
891 }
892 }
893}
894
895#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
896pub struct DatadogConfigurationDataPlaneOtlpProxyLogs {
897 #[serde(default = "defaults::default_bool::<true>")]
898 pub enabled: bool,
899}
900
901impl Default for DatadogConfigurationDataPlaneOtlpProxyLogs {
902 fn default() -> Self {
903 Self {
904 enabled: defaults::default_bool::<true>(),
905 }
906 }
907}
908
909#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
910pub struct DatadogConfigurationDataPlaneOtlpProxyMetrics {
911 #[serde(default = "defaults::default_bool::<true>")]
912 pub enabled: bool,
913}
914
915impl Default for DatadogConfigurationDataPlaneOtlpProxyMetrics {
916 fn default() -> Self {
917 Self {
918 enabled: defaults::default_bool::<true>(),
919 }
920 }
921}
922
923#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
924pub struct DatadogConfigurationDataPlaneOtlpProxyTraces {
925 #[serde(default = "defaults::default_bool::<true>")]
926 pub enabled: bool,
927}
928
929impl Default for DatadogConfigurationDataPlaneOtlpProxyTraces {
930 fn default() -> Self {
931 Self {
932 enabled: defaults::default_bool::<true>(),
933 }
934 }
935}
936
937#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
938pub struct DatadogConfigurationEnablePayloads {
939 #[serde(default = "defaults::default_bool::<true>")]
940 pub events: bool,
941
942 #[serde(default = "defaults::default_bool::<true>")]
943 pub series: bool,
944
945 #[serde(default = "defaults::default_bool::<true>")]
946 pub service_checks: bool,
947
948 #[serde(default = "defaults::default_bool::<true>")]
949 pub sketches: bool,
950}
951
952impl Default for DatadogConfigurationEnablePayloads {
953 fn default() -> Self {
954 Self {
955 events: defaults::default_bool::<true>(),
956 series: defaults::default_bool::<true>(),
957 service_checks: defaults::default_bool::<true>(),
958 sketches: defaults::default_bool::<true>(),
959 }
960 }
961}
962
963#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
964pub struct DatadogConfigurationMultiRegionFailover {
965 #[serde(default)]
966 pub api_key: String,
967
968 #[serde(default)]
969 pub dd_url: String,
970
971 #[serde(default)]
972 pub enabled: bool,
973
974 #[serde(default)]
975 pub failover_metrics: bool,
976
977 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
978 pub metric_allowlist: Vec<String>,
979
980 #[serde(default)]
981 pub site: String,
982}
983
984impl Default for DatadogConfigurationMultiRegionFailover {
985 fn default() -> Self {
986 Self {
987 api_key: Default::default(),
988 dd_url: Default::default(),
989 enabled: Default::default(),
990 failover_metrics: Default::default(),
991 metric_allowlist: Default::default(),
992 site: Default::default(),
993 }
994 }
995}
996
997#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
998pub struct DatadogConfigurationObservabilityPipelinesWorker {
999 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1000 pub metrics: Option<DatadogConfigurationObservabilityPipelinesWorkerMetrics>,
1001}
1002
1003impl Default for DatadogConfigurationObservabilityPipelinesWorker {
1004 fn default() -> Self {
1005 Self {
1006 metrics: Default::default(),
1007 }
1008 }
1009}
1010
1011#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1012pub struct DatadogConfigurationObservabilityPipelinesWorkerMetrics {
1013 #[serde(default)]
1014 pub enabled: bool,
1015
1016 #[serde(default)]
1017 pub url: String,
1018
1019 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1020 pub use_v3_api: Option<
1021 DatadogConfigurationObservabilityPipelinesWorkerMetricsUseV3Api,
1022
1023 >,
1024}
1025
1026impl Default for DatadogConfigurationObservabilityPipelinesWorkerMetrics {
1027 fn default() -> Self {
1028 Self {
1029 enabled: Default::default(),
1030 url: Default::default(),
1031 use_v3_api: Default::default(),
1032 }
1033 }
1034}
1035
1036#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1037pub struct DatadogConfigurationObservabilityPipelinesWorkerMetricsUseV3Api {
1038 #[serde(default)]
1039 pub series: bool,
1040}
1041
1042impl Default for DatadogConfigurationObservabilityPipelinesWorkerMetricsUseV3Api {
1043 fn default() -> Self {
1044 Self { series: Default::default() }
1045 }
1046}
1047
1048#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1049pub struct DatadogConfigurationOtlpConfig {
1050 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1051 pub logs: Option<DatadogConfigurationOtlpConfigLogs>,
1052
1053 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1054 pub metrics: Option<DatadogConfigurationOtlpConfigMetrics>,
1055
1056 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1057 pub receiver: Option<DatadogConfigurationOtlpConfigReceiver>,
1058
1059 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1060 pub traces: Option<DatadogConfigurationOtlpConfigTraces>,
1061}
1062
1063impl Default for DatadogConfigurationOtlpConfig {
1064 fn default() -> Self {
1065 Self {
1066 logs: Default::default(),
1067 metrics: Default::default(),
1068 receiver: Default::default(),
1069 traces: Default::default(),
1070 }
1071 }
1072}
1073
1074#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1075pub struct DatadogConfigurationOtlpConfigLogs {
1076 #[serde(default)]
1077 pub enabled: bool,
1078}
1079
1080impl Default for DatadogConfigurationOtlpConfigLogs {
1081 fn default() -> Self {
1082 Self {
1083 enabled: Default::default(),
1084 }
1085 }
1086}
1087
1088#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1089pub struct DatadogConfigurationOtlpConfigMetrics {
1090 #[serde(default = "defaults::default_bool::<true>")]
1091 pub enabled: bool,
1092}
1093
1094impl Default for DatadogConfigurationOtlpConfigMetrics {
1095 fn default() -> Self {
1096 Self {
1097 enabled: defaults::default_bool::<true>(),
1098 }
1099 }
1100}
1101
1102#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1103pub struct DatadogConfigurationOtlpConfigReceiver {
1104 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1105 pub protocols: Option<DatadogConfigurationOtlpConfigReceiverProtocols>,
1106}
1107
1108impl Default for DatadogConfigurationOtlpConfigReceiver {
1109 fn default() -> Self {
1110 Self {
1111 protocols: Default::default(),
1112 }
1113 }
1114}
1115
1116#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1117pub struct DatadogConfigurationOtlpConfigReceiverProtocols {
1118 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1119 pub grpc: Option<DatadogConfigurationOtlpConfigReceiverProtocolsGrpc>,
1120
1121 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1122 pub http: Option<DatadogConfigurationOtlpConfigReceiverProtocolsHttp>,
1123}
1124
1125impl Default for DatadogConfigurationOtlpConfigReceiverProtocols {
1126 fn default() -> Self {
1127 Self {
1128 grpc: Default::default(),
1129 http: Default::default(),
1130 }
1131 }
1132}
1133
1134#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1135pub struct DatadogConfigurationOtlpConfigReceiverProtocolsGrpc {
1136 #[serde(
1137 default = "defaults::datadog_configuration_otlp_config_receiver_protocols_grpc_endpoint"
1138 )]
1139 pub endpoint: String,
1140
1141 #[serde(default)]
1142 pub max_recv_msg_size_mib: i64,
1143
1144 #[serde(
1145 default = "defaults::datadog_configuration_otlp_config_receiver_protocols_grpc_transport"
1146 )]
1147 pub transport: String,
1148}
1149
1150impl Default for DatadogConfigurationOtlpConfigReceiverProtocolsGrpc {
1151 fn default() -> Self {
1152 Self {
1153 endpoint: defaults::datadog_configuration_otlp_config_receiver_protocols_grpc_endpoint(),
1154 max_recv_msg_size_mib: Default::default(),
1155 transport: defaults::datadog_configuration_otlp_config_receiver_protocols_grpc_transport(),
1156 }
1157 }
1158}
1159
1160#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1161pub struct DatadogConfigurationOtlpConfigReceiverProtocolsHttp {
1162 #[serde(
1163 default = "defaults::datadog_configuration_otlp_config_receiver_protocols_http_endpoint"
1164 )]
1165 pub endpoint: String,
1166}
1167
1168impl Default for DatadogConfigurationOtlpConfigReceiverProtocolsHttp {
1169 fn default() -> Self {
1170 Self {
1171 endpoint: defaults::datadog_configuration_otlp_config_receiver_protocols_http_endpoint(),
1172 }
1173 }
1174}
1175
1176#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1177pub struct DatadogConfigurationOtlpConfigTraces {
1178 #[serde(default = "defaults::default_bool::<true>")]
1179 pub enabled: bool,
1180
1181 #[serde(default = "defaults::default_u64::<i64, 5003>")]
1182 pub internal_port: i64,
1183
1184 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1185 pub probabilistic_sampler: Option<
1186 DatadogConfigurationOtlpConfigTracesProbabilisticSampler,
1187
1188 >,
1189}
1190
1191impl Default for DatadogConfigurationOtlpConfigTraces {
1192 fn default() -> Self {
1193 Self {
1194 enabled: defaults::default_bool::<true>(),
1195 internal_port: defaults::default_u64::<i64, 5003>(),
1196 probabilistic_sampler: Default::default(),
1197 }
1198 }
1199}
1200
1201#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1202pub struct DatadogConfigurationOtlpConfigTracesProbabilisticSampler {
1203 #[serde(
1204 default = "defaults::datadog_configuration_otlp_config_traces_probabilistic_sampler_sampling_percentage"
1205 )]
1206 pub sampling_percentage: f64,
1207}
1208
1209impl Default for DatadogConfigurationOtlpConfigTracesProbabilisticSampler {
1210 fn default() -> Self {
1211 Self {
1212 sampling_percentage: defaults::datadog_configuration_otlp_config_traces_probabilistic_sampler_sampling_percentage(),
1213 }
1214 }
1215}
1216
1217#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1218pub struct DatadogConfigurationProxy {
1219 #[serde(default)]
1220 pub http: String,
1221
1222 #[serde(default)]
1223 pub https: String,
1224
1225 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
1226 pub no_proxy: Vec<String>,
1227}
1228
1229impl Default for DatadogConfigurationProxy {
1230 fn default() -> Self {
1231 Self {
1232 http: Default::default(),
1233 https: Default::default(),
1234 no_proxy: Default::default(),
1235 }
1236 }
1237}
1238
1239#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1240pub struct DatadogConfigurationSerializerExperimentalUseV3Api {
1241 #[serde(default)]
1242 pub compression_level: i64,
1243
1244 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1245 pub series: Option<DatadogConfigurationSerializerExperimentalUseV3ApiSeries>,
1246
1247 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1248 pub sketches: Option<DatadogConfigurationSerializerExperimentalUseV3ApiSketches>,
1249}
1250
1251impl Default for DatadogConfigurationSerializerExperimentalUseV3Api {
1252 fn default() -> Self {
1253 Self {
1254 compression_level: Default::default(),
1255 series: Default::default(),
1256 sketches: Default::default(),
1257 }
1258 }
1259}
1260
1261#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1262pub struct DatadogConfigurationSerializerExperimentalUseV3ApiSeries {
1263 #[serde(
1264 default = "defaults::datadog_configuration_serializer_experimental_use_v3_api_series_beta_route"
1265 )]
1266 pub beta_route: String,
1267
1268 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
1269 pub endpoints: Vec<String>,
1270
1271 #[serde(
1272 default = "defaults::datadog_configuration_serializer_experimental_use_v3_api_series_shadow_sample_rate"
1273 )]
1274 pub shadow_sample_rate: f64,
1275
1276 #[serde(
1277 default = "defaults::datadog_configuration_serializer_experimental_use_v3_api_series_shadow_sites"
1278 )]
1279 pub shadow_sites: Vec<String>,
1280
1281 #[serde(default)]
1282 pub use_beta: bool,
1283
1284 #[serde(default)]
1285 pub validate: bool,
1286}
1287
1288impl Default for DatadogConfigurationSerializerExperimentalUseV3ApiSeries {
1289 fn default() -> Self {
1290 Self {
1291 beta_route: defaults::datadog_configuration_serializer_experimental_use_v3_api_series_beta_route(),
1292 endpoints: Default::default(),
1293 shadow_sample_rate: defaults::datadog_configuration_serializer_experimental_use_v3_api_series_shadow_sample_rate(),
1294 shadow_sites: defaults::datadog_configuration_serializer_experimental_use_v3_api_series_shadow_sites(),
1295 use_beta: Default::default(),
1296 validate: Default::default(),
1297 }
1298 }
1299}
1300
1301#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1302pub struct DatadogConfigurationSerializerExperimentalUseV3ApiSketches {
1303 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
1304 pub endpoints: Vec<String>,
1305
1306 #[serde(default)]
1307 pub validate: bool,
1308}
1309
1310impl Default for DatadogConfigurationSerializerExperimentalUseV3ApiSketches {
1311 fn default() -> Self {
1312 Self {
1313 endpoints: Default::default(),
1314 validate: Default::default(),
1315 }
1316 }
1317}
1318
1319#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1320pub struct DatadogConfigurationTelemetry {
1321 #[serde(default)]
1322 pub dogstatsd_origin: bool,
1323}
1324
1325impl Default for DatadogConfigurationTelemetry {
1326 fn default() -> Self {
1327 Self {
1328 dogstatsd_origin: Default::default(),
1329 }
1330 }
1331}
1332
1333#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1334pub struct DatadogConfigurationUseV2Api {
1335 #[serde(default = "defaults::default_bool::<true>")]
1336 pub series: bool,
1337}
1338
1339impl Default for DatadogConfigurationUseV2Api {
1340 fn default() -> Self {
1341 Self {
1342 series: defaults::default_bool::<true>(),
1343 }
1344 }
1345}
1346
1347#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1348pub struct DatadogConfigurationUseV3Api {
1349 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1350 pub series: Option<DatadogConfigurationUseV3ApiSeries>,
1351}
1352
1353impl Default for DatadogConfigurationUseV3Api {
1354 fn default() -> Self {
1355 Self { series: Default::default() }
1356 }
1357}
1358
1359#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1360pub struct DatadogConfigurationUseV3ApiSeries {
1361 #[serde(default = "defaults::datadog_configuration_use_v3_api_series_enabled")]
1362 pub enabled: String,
1363
1364 #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
1365 pub endpoints: ::serde_json::Map<String, ::serde_json::Value>,
1366}
1367
1368impl Default for DatadogConfigurationUseV3ApiSeries {
1369 fn default() -> Self {
1370 Self {
1371 enabled: defaults::datadog_configuration_use_v3_api_series_enabled(),
1372 endpoints: Default::default(),
1373 }
1374 }
1375}
1376
1377#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1378pub struct DatadogConfigurationVector {
1379 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1380 pub metrics: Option<DatadogConfigurationVectorMetrics>,
1381}
1382
1383impl Default for DatadogConfigurationVector {
1384 fn default() -> Self {
1385 Self {
1386 metrics: Default::default(),
1387 }
1388 }
1389}
1390
1391#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1392pub struct DatadogConfigurationVectorMetrics {
1393 #[serde(default)]
1394 pub enabled: bool,
1395
1396 #[serde(default)]
1397 pub url: String,
1398
1399 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1400 pub use_v3_api: Option<DatadogConfigurationVectorMetricsUseV3Api>,
1401}
1402
1403impl Default for DatadogConfigurationVectorMetrics {
1404 fn default() -> Self {
1405 Self {
1406 enabled: Default::default(),
1407 url: Default::default(),
1408 use_v3_api: Default::default(),
1409 }
1410 }
1411}
1412
1413#[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
1414pub struct DatadogConfigurationVectorMetricsUseV3Api {
1415 #[serde(default)]
1416 pub series: bool,
1417}
1418
1419impl Default for DatadogConfigurationVectorMetricsUseV3Api {
1420 fn default() -> Self {
1421 Self { series: Default::default() }
1422 }
1423}
1424
1425pub mod defaults {
1427 pub(super) fn default_bool<const V: bool>() -> bool {
1428 V
1429 }
1430 pub(super) fn default_i64<T, const V: i64>() -> T
1431 where
1432 T: TryFrom<i64>,
1433 <T as ::std::convert::TryFrom<i64>>::Error: ::std::fmt::Debug,
1434 {
1435 T::try_from(V).unwrap()
1436 }
1437 pub(super) fn default_u64<T, const V: u64>() -> T
1438 where
1439 T: TryFrom<u64>,
1440 <T as ::std::convert::TryFrom<u64>>::Error: ::std::fmt::Debug,
1441 {
1442 T::try_from(V).unwrap()
1443 }
1444 pub(super) fn datadog_configuration_dd_url() -> String {
1445 "https://app.datadoghq.com".to_string()
1446 }
1447 pub(super) fn datadog_configuration_dogstatsd_log_file_max_size() -> String {
1448 "10Mb".to_string()
1449 }
1450 pub(super) fn datadog_configuration_dogstatsd_tag_cardinality() -> String {
1451 "low".to_string()
1452 }
1453 pub(super) fn datadog_configuration_dogstatsd_windows_pipe_security_descriptor() -> String {
1454 "D:AI(A;;GA;;;WD)".to_string()
1455 }
1456 pub(super) fn datadog_configuration_forwarder_flush_to_disk_mem_ratio() -> f64 {
1457 0.5_f64
1458 }
1459 pub(super) fn datadog_configuration_forwarder_http_protocol() -> String {
1460 "auto".to_string()
1461 }
1462 pub(super) fn datadog_configuration_forwarder_storage_max_disk_ratio() -> f64 {
1463 0.8_f64
1464 }
1465 pub(super) fn datadog_configuration_histogram_aggregates() -> Vec<String> {
1466 vec![
1467 "max".to_string(),
1468 "median".to_string(),
1469 "avg".to_string(),
1470 "count".to_string(),
1471 ]
1472 }
1473 pub(super) fn datadog_configuration_log_level() -> String {
1474 "info".to_string()
1475 }
1476 pub(super) fn datadog_configuration_min_tls_version() -> String {
1477 "tlsv1.2".to_string()
1478 }
1479 pub(super) fn datadog_configuration_serializer_compressor_kind() -> String {
1480 "zstd".to_string()
1481 }
1482 pub(super) fn datadog_configuration_site() -> String {
1483 "datadoghq.com".to_string()
1484 }
1485 pub(super) fn datadog_configuration_statsd_metric_namespace_blacklist() -> Vec<
1486 String,
1487 > {
1488 vec![
1489 "datadog.agent".to_string(),
1490 "datadog.dogstatsd".to_string(),
1491 "datadog.process".to_string(),
1492 "datadog.trace_agent".to_string(),
1493 "datadog.tracer".to_string(),
1494 "activemq".to_string(),
1495 "activemq_58".to_string(),
1496 "airflow".to_string(),
1497 "cassandra".to_string(),
1498 "confluent".to_string(),
1499 "hazelcast".to_string(),
1500 "hive".to_string(),
1501 "ignite".to_string(),
1502 "jboss".to_string(),
1503 "jvm".to_string(),
1504 "kafka".to_string(),
1505 "presto".to_string(),
1506 "sidekiq".to_string(),
1507 "solr".to_string(),
1508 "tomcat".to_string(),
1509 "runtime".to_string(),
1510 ]
1511 }
1512 pub(super) fn datadog_configuration_autoscaling_failover_metrics() -> Vec<String> {
1513 vec!["container.memory.usage".to_string(), "container.cpu.usage".to_string()]
1514 }
1515 pub(super) fn datadog_configuration_cluster_agent_kubernetes_service_name() -> String {
1516 "datadog-cluster-agent".to_string()
1517 }
1518 pub(super) fn datadog_configuration_data_plane_api_listen_address() -> String {
1519 "tcp://0.0.0.0:5100".to_string()
1520 }
1521 pub(super) fn datadog_configuration_data_plane_log_file() -> String {
1522 "/var/log/datadog/agent-data-plane.log".to_string()
1523 }
1524 pub(super) fn datadog_configuration_data_plane_secure_api_listen_address() -> String {
1525 "tcp://0.0.0.0:5101".to_string()
1526 }
1527 pub(super) fn datadog_configuration_otlp_config_receiver_protocols_grpc_endpoint() -> String {
1528 "localhost:4317".to_string()
1529 }
1530 pub(super) fn datadog_configuration_otlp_config_receiver_protocols_grpc_transport() -> String {
1531 "tcp".to_string()
1532 }
1533 pub(super) fn datadog_configuration_otlp_config_receiver_protocols_http_endpoint() -> String {
1534 "localhost:4318".to_string()
1535 }
1536 pub(super) fn datadog_configuration_otlp_config_traces_probabilistic_sampler_sampling_percentage() -> f64 {
1537 100_f64
1538 }
1539 pub(super) fn datadog_configuration_serializer_experimental_use_v3_api_series_beta_route() -> String {
1540 "/api/intake/metrics/v3beta/series".to_string()
1541 }
1542 pub(super) fn datadog_configuration_serializer_experimental_use_v3_api_series_shadow_sample_rate() -> f64 {
1543 0_f64
1544 }
1545 pub(super) fn datadog_configuration_serializer_experimental_use_v3_api_series_shadow_sites() -> Vec<
1546 String,
1547 > {
1548 vec!["datadoghq.com".to_string()]
1549 }
1550 pub(super) fn datadog_configuration_use_v3_api_series_enabled() -> String {
1551 "true".to_string()
1552 }
1553}