datadog_api_client/datadogV2/api/
api_service_definition.rs

1// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
2// This product includes software developed at Datadog (https://www.datadoghq.com/).
3// Copyright 2019-Present Datadog, Inc.
4use crate::datadog;
5use async_stream::try_stream;
6use flate2::{
7    write::{GzEncoder, ZlibEncoder},
8    Compression,
9};
10use futures_core::stream::Stream;
11use reqwest::header::{HeaderMap, HeaderValue};
12use serde::{Deserialize, Serialize};
13use std::io::Write;
14
15/// GetServiceDefinitionOptionalParams is a struct for passing parameters to the method [`ServiceDefinitionAPI::get_service_definition`]
16#[non_exhaustive]
17#[derive(Clone, Default, Debug)]
18pub struct GetServiceDefinitionOptionalParams {
19    /// The schema version desired in the response.
20    pub schema_version: Option<crate::datadogV2::model::ServiceDefinitionSchemaVersions>,
21}
22
23impl GetServiceDefinitionOptionalParams {
24    /// The schema version desired in the response.
25    pub fn schema_version(
26        mut self,
27        value: crate::datadogV2::model::ServiceDefinitionSchemaVersions,
28    ) -> Self {
29        self.schema_version = Some(value);
30        self
31    }
32}
33
34/// ListServiceDefinitionsOptionalParams is a struct for passing parameters to the method [`ServiceDefinitionAPI::list_service_definitions`]
35#[non_exhaustive]
36#[derive(Clone, Default, Debug)]
37pub struct ListServiceDefinitionsOptionalParams {
38    /// Size for a given page. The maximum allowed value is 100.
39    pub page_size: Option<i64>,
40    /// Specific page number to return.
41    pub page_number: Option<i64>,
42    /// The schema version desired in the response.
43    pub schema_version: Option<crate::datadogV2::model::ServiceDefinitionSchemaVersions>,
44}
45
46impl ListServiceDefinitionsOptionalParams {
47    /// Size for a given page. The maximum allowed value is 100.
48    pub fn page_size(mut self, value: i64) -> Self {
49        self.page_size = Some(value);
50        self
51    }
52    /// Specific page number to return.
53    pub fn page_number(mut self, value: i64) -> Self {
54        self.page_number = Some(value);
55        self
56    }
57    /// The schema version desired in the response.
58    pub fn schema_version(
59        mut self,
60        value: crate::datadogV2::model::ServiceDefinitionSchemaVersions,
61    ) -> Self {
62        self.schema_version = Some(value);
63        self
64    }
65}
66
67/// CreateOrUpdateServiceDefinitionsError is a struct for typed errors of method [`ServiceDefinitionAPI::create_or_update_service_definitions`]
68#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum CreateOrUpdateServiceDefinitionsError {
71    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
72    UnknownValue(serde_json::Value),
73}
74
75/// DeleteServiceDefinitionError is a struct for typed errors of method [`ServiceDefinitionAPI::delete_service_definition`]
76#[derive(Debug, Clone, Serialize, Deserialize)]
77#[serde(untagged)]
78pub enum DeleteServiceDefinitionError {
79    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
80    UnknownValue(serde_json::Value),
81}
82
83/// GetServiceDefinitionError is a struct for typed errors of method [`ServiceDefinitionAPI::get_service_definition`]
84#[derive(Debug, Clone, Serialize, Deserialize)]
85#[serde(untagged)]
86pub enum GetServiceDefinitionError {
87    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
88    UnknownValue(serde_json::Value),
89}
90
91/// ListServiceDefinitionsError is a struct for typed errors of method [`ServiceDefinitionAPI::list_service_definitions`]
92#[derive(Debug, Clone, Serialize, Deserialize)]
93#[serde(untagged)]
94pub enum ListServiceDefinitionsError {
95    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
96    UnknownValue(serde_json::Value),
97}
98
99/// API to create, update, retrieve and delete service definitions.
100/// Note: Service Catalog [v3.0 schema](<https://docs.datadoghq.com/service_catalog/service_definitions/v3-0/>) has new API endpoints documented under [Software Catalog](<https://docs.datadoghq.com/api/latest/software-catalog/>). Use the following Service Definition endpoints for v2.2 and earlier.
101#[derive(Debug, Clone)]
102pub struct ServiceDefinitionAPI {
103    config: datadog::Configuration,
104    client: reqwest_middleware::ClientWithMiddleware,
105}
106
107impl Default for ServiceDefinitionAPI {
108    fn default() -> Self {
109        Self::with_config(datadog::Configuration::default())
110    }
111}
112
113impl ServiceDefinitionAPI {
114    pub fn new() -> Self {
115        Self::default()
116    }
117    pub fn with_config(config: datadog::Configuration) -> Self {
118        let mut reqwest_client_builder = reqwest::Client::builder();
119
120        if let Some(proxy_url) = &config.proxy_url {
121            let proxy = reqwest::Proxy::all(proxy_url).expect("Failed to parse proxy URL");
122            reqwest_client_builder = reqwest_client_builder.proxy(proxy);
123        }
124
125        let mut middleware_client_builder =
126            reqwest_middleware::ClientBuilder::new(reqwest_client_builder.build().unwrap());
127
128        if config.enable_retry {
129            struct RetryableStatus;
130            impl reqwest_retry::RetryableStrategy for RetryableStatus {
131                fn handle(
132                    &self,
133                    res: &Result<reqwest::Response, reqwest_middleware::Error>,
134                ) -> Option<reqwest_retry::Retryable> {
135                    match res {
136                        Ok(success) => reqwest_retry::default_on_request_success(success),
137                        Err(_) => None,
138                    }
139                }
140            }
141            let backoff_policy = reqwest_retry::policies::ExponentialBackoff::builder()
142                .build_with_max_retries(config.max_retries);
143
144            let retry_middleware =
145                reqwest_retry::RetryTransientMiddleware::new_with_policy_and_strategy(
146                    backoff_policy,
147                    RetryableStatus,
148                );
149
150            middleware_client_builder = middleware_client_builder.with(retry_middleware);
151        }
152
153        let client = middleware_client_builder.build();
154
155        Self { config, client }
156    }
157
158    pub fn with_client_and_config(
159        config: datadog::Configuration,
160        client: reqwest_middleware::ClientWithMiddleware,
161    ) -> Self {
162        Self { config, client }
163    }
164
165    /// Create or update service definition in the Datadog Service Catalog.
166    pub async fn create_or_update_service_definitions(
167        &self,
168        body: crate::datadogV2::model::ServiceDefinitionsCreateRequest,
169    ) -> Result<
170        crate::datadogV2::model::ServiceDefinitionCreateResponse,
171        datadog::Error<CreateOrUpdateServiceDefinitionsError>,
172    > {
173        match self
174            .create_or_update_service_definitions_with_http_info(body)
175            .await
176        {
177            Ok(response_content) => {
178                if let Some(e) = response_content.entity {
179                    Ok(e)
180                } else {
181                    Err(datadog::Error::Serde(serde::de::Error::custom(
182                        "response content was None",
183                    )))
184                }
185            }
186            Err(err) => Err(err),
187        }
188    }
189
190    /// Create or update service definition in the Datadog Service Catalog.
191    pub async fn create_or_update_service_definitions_with_http_info(
192        &self,
193        body: crate::datadogV2::model::ServiceDefinitionsCreateRequest,
194    ) -> Result<
195        datadog::ResponseContent<crate::datadogV2::model::ServiceDefinitionCreateResponse>,
196        datadog::Error<CreateOrUpdateServiceDefinitionsError>,
197    > {
198        let local_configuration = &self.config;
199        let operation_id = "v2.create_or_update_service_definitions";
200
201        let local_client = &self.client;
202
203        let local_uri_str = format!(
204            "{}/api/v2/services/definitions",
205            local_configuration.get_operation_host(operation_id)
206        );
207        let mut local_req_builder =
208            local_client.request(reqwest::Method::POST, local_uri_str.as_str());
209
210        // build headers
211        let mut headers = HeaderMap::new();
212        headers.insert("Content-Type", HeaderValue::from_static("application/json"));
213        headers.insert("Accept", HeaderValue::from_static("application/json"));
214
215        // build user agent
216        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
217            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
218            Err(e) => {
219                log::warn!("Failed to parse user agent header: {e}, falling back to default");
220                headers.insert(
221                    reqwest::header::USER_AGENT,
222                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
223                )
224            }
225        };
226
227        // build auth
228        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
229            headers.insert(
230                "DD-API-KEY",
231                HeaderValue::from_str(local_key.key.as_str())
232                    .expect("failed to parse DD-API-KEY header"),
233            );
234        };
235        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
236            headers.insert(
237                "DD-APPLICATION-KEY",
238                HeaderValue::from_str(local_key.key.as_str())
239                    .expect("failed to parse DD-APPLICATION-KEY header"),
240            );
241        };
242
243        // build body parameters
244        let output = Vec::new();
245        let mut ser = serde_json::Serializer::with_formatter(output, datadog::DDFormatter);
246        if body.serialize(&mut ser).is_ok() {
247            if let Some(content_encoding) = headers.get("Content-Encoding") {
248                match content_encoding.to_str().unwrap_or_default() {
249                    "gzip" => {
250                        let mut enc = GzEncoder::new(Vec::new(), Compression::default());
251                        let _ = enc.write_all(ser.into_inner().as_slice());
252                        match enc.finish() {
253                            Ok(buf) => {
254                                local_req_builder = local_req_builder.body(buf);
255                            }
256                            Err(e) => return Err(datadog::Error::Io(e)),
257                        }
258                    }
259                    "deflate" => {
260                        let mut enc = ZlibEncoder::new(Vec::new(), Compression::default());
261                        let _ = enc.write_all(ser.into_inner().as_slice());
262                        match enc.finish() {
263                            Ok(buf) => {
264                                local_req_builder = local_req_builder.body(buf);
265                            }
266                            Err(e) => return Err(datadog::Error::Io(e)),
267                        }
268                    }
269                    "zstd1" => {
270                        let mut enc = zstd::stream::Encoder::new(Vec::new(), 0).unwrap();
271                        let _ = enc.write_all(ser.into_inner().as_slice());
272                        match enc.finish() {
273                            Ok(buf) => {
274                                local_req_builder = local_req_builder.body(buf);
275                            }
276                            Err(e) => return Err(datadog::Error::Io(e)),
277                        }
278                    }
279                    _ => {
280                        local_req_builder = local_req_builder.body(ser.into_inner());
281                    }
282                }
283            } else {
284                local_req_builder = local_req_builder.body(ser.into_inner());
285            }
286        }
287
288        local_req_builder = local_req_builder.headers(headers);
289        let local_req = local_req_builder.build()?;
290        log::debug!("request content: {:?}", local_req.body());
291        let local_resp = local_client.execute(local_req).await?;
292
293        let local_status = local_resp.status();
294        let local_content = local_resp.text().await?;
295        log::debug!("response content: {}", local_content);
296
297        if !local_status.is_client_error() && !local_status.is_server_error() {
298            match serde_json::from_str::<crate::datadogV2::model::ServiceDefinitionCreateResponse>(
299                &local_content,
300            ) {
301                Ok(e) => {
302                    return Ok(datadog::ResponseContent {
303                        status: local_status,
304                        content: local_content,
305                        entity: Some(e),
306                    })
307                }
308                Err(e) => return Err(datadog::Error::Serde(e)),
309            };
310        } else {
311            let local_entity: Option<CreateOrUpdateServiceDefinitionsError> =
312                serde_json::from_str(&local_content).ok();
313            let local_error = datadog::ResponseContent {
314                status: local_status,
315                content: local_content,
316                entity: local_entity,
317            };
318            Err(datadog::Error::ResponseError(local_error))
319        }
320    }
321
322    /// Delete a single service definition in the Datadog Service Catalog.
323    pub async fn delete_service_definition(
324        &self,
325        service_name: String,
326    ) -> Result<(), datadog::Error<DeleteServiceDefinitionError>> {
327        match self
328            .delete_service_definition_with_http_info(service_name)
329            .await
330        {
331            Ok(_) => Ok(()),
332            Err(err) => Err(err),
333        }
334    }
335
336    /// Delete a single service definition in the Datadog Service Catalog.
337    pub async fn delete_service_definition_with_http_info(
338        &self,
339        service_name: String,
340    ) -> Result<datadog::ResponseContent<()>, datadog::Error<DeleteServiceDefinitionError>> {
341        let local_configuration = &self.config;
342        let operation_id = "v2.delete_service_definition";
343
344        let local_client = &self.client;
345
346        let local_uri_str = format!(
347            "{}/api/v2/services/definitions/{service_name}",
348            local_configuration.get_operation_host(operation_id),
349            service_name = datadog::urlencode(service_name)
350        );
351        let mut local_req_builder =
352            local_client.request(reqwest::Method::DELETE, local_uri_str.as_str());
353
354        // build headers
355        let mut headers = HeaderMap::new();
356        headers.insert("Accept", HeaderValue::from_static("*/*"));
357
358        // build user agent
359        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
360            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
361            Err(e) => {
362                log::warn!("Failed to parse user agent header: {e}, falling back to default");
363                headers.insert(
364                    reqwest::header::USER_AGENT,
365                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
366                )
367            }
368        };
369
370        // build auth
371        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
372            headers.insert(
373                "DD-API-KEY",
374                HeaderValue::from_str(local_key.key.as_str())
375                    .expect("failed to parse DD-API-KEY header"),
376            );
377        };
378        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
379            headers.insert(
380                "DD-APPLICATION-KEY",
381                HeaderValue::from_str(local_key.key.as_str())
382                    .expect("failed to parse DD-APPLICATION-KEY header"),
383            );
384        };
385
386        local_req_builder = local_req_builder.headers(headers);
387        let local_req = local_req_builder.build()?;
388        log::debug!("request content: {:?}", local_req.body());
389        let local_resp = local_client.execute(local_req).await?;
390
391        let local_status = local_resp.status();
392        let local_content = local_resp.text().await?;
393        log::debug!("response content: {}", local_content);
394
395        if !local_status.is_client_error() && !local_status.is_server_error() {
396            Ok(datadog::ResponseContent {
397                status: local_status,
398                content: local_content,
399                entity: None,
400            })
401        } else {
402            let local_entity: Option<DeleteServiceDefinitionError> =
403                serde_json::from_str(&local_content).ok();
404            let local_error = datadog::ResponseContent {
405                status: local_status,
406                content: local_content,
407                entity: local_entity,
408            };
409            Err(datadog::Error::ResponseError(local_error))
410        }
411    }
412
413    /// Get a single service definition from the Datadog Service Catalog.
414    pub async fn get_service_definition(
415        &self,
416        service_name: String,
417        params: GetServiceDefinitionOptionalParams,
418    ) -> Result<
419        crate::datadogV2::model::ServiceDefinitionGetResponse,
420        datadog::Error<GetServiceDefinitionError>,
421    > {
422        match self
423            .get_service_definition_with_http_info(service_name, params)
424            .await
425        {
426            Ok(response_content) => {
427                if let Some(e) = response_content.entity {
428                    Ok(e)
429                } else {
430                    Err(datadog::Error::Serde(serde::de::Error::custom(
431                        "response content was None",
432                    )))
433                }
434            }
435            Err(err) => Err(err),
436        }
437    }
438
439    /// Get a single service definition from the Datadog Service Catalog.
440    pub async fn get_service_definition_with_http_info(
441        &self,
442        service_name: String,
443        params: GetServiceDefinitionOptionalParams,
444    ) -> Result<
445        datadog::ResponseContent<crate::datadogV2::model::ServiceDefinitionGetResponse>,
446        datadog::Error<GetServiceDefinitionError>,
447    > {
448        let local_configuration = &self.config;
449        let operation_id = "v2.get_service_definition";
450
451        // unbox and build optional parameters
452        let schema_version = params.schema_version;
453
454        let local_client = &self.client;
455
456        let local_uri_str = format!(
457            "{}/api/v2/services/definitions/{service_name}",
458            local_configuration.get_operation_host(operation_id),
459            service_name = datadog::urlencode(service_name)
460        );
461        let mut local_req_builder =
462            local_client.request(reqwest::Method::GET, local_uri_str.as_str());
463
464        if let Some(ref local_query_param) = schema_version {
465            local_req_builder =
466                local_req_builder.query(&[("schema_version", &local_query_param.to_string())]);
467        };
468
469        // build headers
470        let mut headers = HeaderMap::new();
471        headers.insert("Accept", HeaderValue::from_static("application/json"));
472
473        // build user agent
474        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
475            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
476            Err(e) => {
477                log::warn!("Failed to parse user agent header: {e}, falling back to default");
478                headers.insert(
479                    reqwest::header::USER_AGENT,
480                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
481                )
482            }
483        };
484
485        // build auth
486        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
487            headers.insert(
488                "DD-API-KEY",
489                HeaderValue::from_str(local_key.key.as_str())
490                    .expect("failed to parse DD-API-KEY header"),
491            );
492        };
493        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
494            headers.insert(
495                "DD-APPLICATION-KEY",
496                HeaderValue::from_str(local_key.key.as_str())
497                    .expect("failed to parse DD-APPLICATION-KEY header"),
498            );
499        };
500
501        local_req_builder = local_req_builder.headers(headers);
502        let local_req = local_req_builder.build()?;
503        log::debug!("request content: {:?}", local_req.body());
504        let local_resp = local_client.execute(local_req).await?;
505
506        let local_status = local_resp.status();
507        let local_content = local_resp.text().await?;
508        log::debug!("response content: {}", local_content);
509
510        if !local_status.is_client_error() && !local_status.is_server_error() {
511            match serde_json::from_str::<crate::datadogV2::model::ServiceDefinitionGetResponse>(
512                &local_content,
513            ) {
514                Ok(e) => {
515                    return Ok(datadog::ResponseContent {
516                        status: local_status,
517                        content: local_content,
518                        entity: Some(e),
519                    })
520                }
521                Err(e) => return Err(datadog::Error::Serde(e)),
522            };
523        } else {
524            let local_entity: Option<GetServiceDefinitionError> =
525                serde_json::from_str(&local_content).ok();
526            let local_error = datadog::ResponseContent {
527                status: local_status,
528                content: local_content,
529                entity: local_entity,
530            };
531            Err(datadog::Error::ResponseError(local_error))
532        }
533    }
534
535    /// Get a list of all service definitions from the Datadog Service Catalog.
536    pub async fn list_service_definitions(
537        &self,
538        params: ListServiceDefinitionsOptionalParams,
539    ) -> Result<
540        crate::datadogV2::model::ServiceDefinitionsListResponse,
541        datadog::Error<ListServiceDefinitionsError>,
542    > {
543        match self.list_service_definitions_with_http_info(params).await {
544            Ok(response_content) => {
545                if let Some(e) = response_content.entity {
546                    Ok(e)
547                } else {
548                    Err(datadog::Error::Serde(serde::de::Error::custom(
549                        "response content was None",
550                    )))
551                }
552            }
553            Err(err) => Err(err),
554        }
555    }
556
557    pub fn list_service_definitions_with_pagination(
558        &self,
559        mut params: ListServiceDefinitionsOptionalParams,
560    ) -> impl Stream<
561        Item = Result<
562            crate::datadogV2::model::ServiceDefinitionData,
563            datadog::Error<ListServiceDefinitionsError>,
564        >,
565    > + '_ {
566        try_stream! {
567            let mut page_size: i64 = 10;
568            if params.page_size.is_none() {
569                params.page_size = Some(page_size);
570            } else {
571                page_size = params.page_size.unwrap().clone();
572            }
573            if params.page_number.is_none() {
574                params.page_number = Some(0);
575            }
576            loop {
577                let resp = self.list_service_definitions(params.clone()).await?;
578                let Some(data) = resp.data else { break };
579
580                let r = data;
581                let count = r.len();
582                for team in r {
583                    yield team;
584                }
585
586                if count < page_size as usize {
587                    break;
588                }
589                params.page_number = Some(params.page_number.unwrap() + 1);
590            }
591        }
592    }
593
594    /// Get a list of all service definitions from the Datadog Service Catalog.
595    pub async fn list_service_definitions_with_http_info(
596        &self,
597        params: ListServiceDefinitionsOptionalParams,
598    ) -> Result<
599        datadog::ResponseContent<crate::datadogV2::model::ServiceDefinitionsListResponse>,
600        datadog::Error<ListServiceDefinitionsError>,
601    > {
602        let local_configuration = &self.config;
603        let operation_id = "v2.list_service_definitions";
604
605        // unbox and build optional parameters
606        let page_size = params.page_size;
607        let page_number = params.page_number;
608        let schema_version = params.schema_version;
609
610        let local_client = &self.client;
611
612        let local_uri_str = format!(
613            "{}/api/v2/services/definitions",
614            local_configuration.get_operation_host(operation_id)
615        );
616        let mut local_req_builder =
617            local_client.request(reqwest::Method::GET, local_uri_str.as_str());
618
619        if let Some(ref local_query_param) = page_size {
620            local_req_builder =
621                local_req_builder.query(&[("page[size]", &local_query_param.to_string())]);
622        };
623        if let Some(ref local_query_param) = page_number {
624            local_req_builder =
625                local_req_builder.query(&[("page[number]", &local_query_param.to_string())]);
626        };
627        if let Some(ref local_query_param) = schema_version {
628            local_req_builder =
629                local_req_builder.query(&[("schema_version", &local_query_param.to_string())]);
630        };
631
632        // build headers
633        let mut headers = HeaderMap::new();
634        headers.insert("Accept", HeaderValue::from_static("application/json"));
635
636        // build user agent
637        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
638            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
639            Err(e) => {
640                log::warn!("Failed to parse user agent header: {e}, falling back to default");
641                headers.insert(
642                    reqwest::header::USER_AGENT,
643                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
644                )
645            }
646        };
647
648        // build auth
649        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
650            headers.insert(
651                "DD-API-KEY",
652                HeaderValue::from_str(local_key.key.as_str())
653                    .expect("failed to parse DD-API-KEY header"),
654            );
655        };
656        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
657            headers.insert(
658                "DD-APPLICATION-KEY",
659                HeaderValue::from_str(local_key.key.as_str())
660                    .expect("failed to parse DD-APPLICATION-KEY header"),
661            );
662        };
663
664        local_req_builder = local_req_builder.headers(headers);
665        let local_req = local_req_builder.build()?;
666        log::debug!("request content: {:?}", local_req.body());
667        let local_resp = local_client.execute(local_req).await?;
668
669        let local_status = local_resp.status();
670        let local_content = local_resp.text().await?;
671        log::debug!("response content: {}", local_content);
672
673        if !local_status.is_client_error() && !local_status.is_server_error() {
674            match serde_json::from_str::<crate::datadogV2::model::ServiceDefinitionsListResponse>(
675                &local_content,
676            ) {
677                Ok(e) => {
678                    return Ok(datadog::ResponseContent {
679                        status: local_status,
680                        content: local_content,
681                        entity: Some(e),
682                    })
683                }
684                Err(e) => return Err(datadog::Error::Serde(e)),
685            };
686        } else {
687            let local_entity: Option<ListServiceDefinitionsError> =
688                serde_json::from_str(&local_content).ok();
689            let local_error = datadog::ResponseContent {
690                status: local_status,
691                content: local_content,
692                entity: local_entity,
693            };
694            Err(datadog::Error::ResponseError(local_error))
695        }
696    }
697}
datadog_api_client/datadogV2/api/api_service_definition.rs

datadog_api_client/datadogV2/api/
api_service_definition.rs
