Fix WidgetNewFixedSpan - timestamps are milliseconds not seconds

.generator/schemas/v1/openapi.yaml

@@ -25943,17 +25943,17 @@ components:
       description: Used for fixed span times, such as 'March 1 to March 7'.
       properties:
         from:
-          description: Start time in seconds since epoch.
-          example: 1712080128
+          description: Start time in milliseconds since epoch.
+          example: 1712080128000
           format: int64
           minimum: 0
           type: integer
         hide_incomplete_cost_data:
           description: Whether to hide incomplete cost data in the widget.
           type: boolean
         to:
-          description: End time in seconds since epoch.
-          example: 1712083128
+          description: End time in milliseconds since epoch.
+          example: 1712083128000
           format: int64
           minimum: 0
           type: integer

.generator/schemas/v2/openapi.yaml

@@ -32179,6 +32179,53 @@ components:
             type: string
           type: array
       type: object
+    Integration:
+      description: Integration resource object.
+      properties:
+        attributes:
+          $ref: '#/components/schemas/IntegrationAttributes'
+        id:
+          description: The unique identifier of the integration.
+          example: calico
+          type: string
+        links:
+          $ref: '#/components/schemas/IntegrationLinks'
+        type:
+          $ref: '#/components/schemas/IntegrationType'
+      required:
+      - type
+      - id
+      - attributes
+      type: object
+    IntegrationAttributes:
+      description: Attributes for an integration.
+      properties:
+        categories:
+          description: List of categories associated with the integration.
+          example:
+          - Category::Kubernetes
+          - Category::Log Collection
+          items:
+            type: string
+          type: array
+        description:
+          description: A description of the integration.
+          example: Calico is a networking and network security solution for containers.
+          type: string
+        installed:
+          description: Whether the integration is installed.
+          example: true
+          type: boolean
+        title:
+          description: The name of the integration.
+          example: calico
+          type: string
+      required:
+      - title
+      - description
+      - categories
+      - installed
+      type: object
     IntegrationIncident:
       description: Incident integration settings
       properties:
@@ -32284,6 +32331,14 @@ components:
         value:
           $ref: '#/components/schemas/AnyValue'
       type: object
+    IntegrationLinks:
+      description: Links for the integration resource.
+      properties:
+        self:
+          description: Link to the integration resource.
+          example: /integrations?integrationId=calico
+          type: string
+      type: object
     IntegrationMonitor:
       description: Monitor integration settings
       properties:
@@ -32385,6 +32440,15 @@ components:
             type: string
           type: object
       type: object
+    IntegrationType:
+      default: integration
+      description: Integration resource type.
+      enum:
+      - integration
+      example: integration
+      type: string
+      x-enum-varnames:
+      - INTEGRATION
     InterfaceAttributes:
       description: The interface attributes
       properties:
@@ -34776,6 +34840,17 @@ components:
       - data
       - meta
       type: object
+    ListIntegrationsResponse:
+      description: Response containing information about multiple integrations.
+      properties:
+        data:
+          description: Array of integration objects.
+          items:
+            $ref: '#/components/schemas/Integration'
+          type: array
+      required:
+      - data
+      type: object
     ListInterfaceTagsResponse:
       description: Response for listing interface tags.
       properties:
@@ -84205,6 +84280,24 @@ paths:
       x-unstable: '**Note**: This endpoint is in public beta and is subject to change.
 
         If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/).'
+  /api/v2/integrations:
+    get:
+      operationId: ListIntegrations
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ListIntegrationsResponse'
+          description: Successful Response.
+        '429':
+          $ref: '#/components/responses/TooManyRequestsResponse'
+      security:
+      - apiKeyAuth: []
+        appKeyAuth: []
+      summary: List Integrations
+      tags:
+      - Integrations
   /api/v2/integrations/cloudflare/accounts:
     get:
       description: List Cloudflare accounts.
@@ -106291,6 +106384,10 @@ tags:
     and todos. See the [Incident Management page](https://docs.datadoghq.com/service_management/incident_management/)
     for more information.
   name: Incidents
+- description: 'The Integrations API is used to list available integrations
+
+    and retrieve information about their installation status.'
+  name: Integrations
 - description: Manage your Jira Integration. Atlassian Jira is a project management
     and issue tracking tool for teams to coordinate work and handle tasks efficiently.
   name: Jira Integration

examples/v2_integrations_ListIntegrations.rs

@@ -0,0 +1,15 @@
+// List Integrations returns "Successful Response." response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_integrations::IntegrationsAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = IntegrationsAPI::with_config(configuration);
+    let resp = api.list_integrations().await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

src/datadogV1/model/model_widget_new_fixed_span.rs

@@ -11,13 +11,13 @@ use std::fmt::{self, Formatter};
 #[skip_serializing_none]
 #[derive(Clone, Debug, PartialEq, Serialize)]
 pub struct WidgetNewFixedSpan {
-    /// Start time in seconds since epoch.
+    /// Start time in milliseconds since epoch.
     #[serde(rename = "from")]
     pub from: i64,
     /// Whether to hide incomplete cost data in the widget.
     #[serde(rename = "hide_incomplete_cost_data")]
     pub hide_incomplete_cost_data: Option<bool>,
-    /// End time in seconds since epoch.
+    /// End time in milliseconds since epoch.
     #[serde(rename = "to")]
     pub to: i64,
     /// Type "fixed" denotes a fixed span.

src/datadogV2/api/api_integrations.rs

@@ -0,0 +1,185 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+use crate::datadog;
+use reqwest::header::{HeaderMap, HeaderValue};
+use serde::{Deserialize, Serialize};
+
+/// ListIntegrationsError is a struct for typed errors of method [`IntegrationsAPI::list_integrations`]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum ListIntegrationsError {
+    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
+    UnknownValue(serde_json::Value),
+}
+
+/// The Integrations API is used to list available integrations
+/// and retrieve information about their installation status.
+#[derive(Debug, Clone)]
+pub struct IntegrationsAPI {
+    config: datadog::Configuration,
+    client: reqwest_middleware::ClientWithMiddleware,
+}
+
+impl Default for IntegrationsAPI {
+    fn default() -> Self {
+        Self::with_config(datadog::Configuration::default())
+    }
+}
+
+impl IntegrationsAPI {
+    pub fn new() -> Self {
+        Self::default()
+    }
+    pub fn with_config(config: datadog::Configuration) -> Self {
+        let mut reqwest_client_builder = reqwest::Client::builder();
+
+        if let Some(proxy_url) = &config.proxy_url {
+            let proxy = reqwest::Proxy::all(proxy_url).expect("Failed to parse proxy URL");
+            reqwest_client_builder = reqwest_client_builder.proxy(proxy);
+        }
+
+        let mut middleware_client_builder =
+            reqwest_middleware::ClientBuilder::new(reqwest_client_builder.build().unwrap());
+
+        if config.enable_retry {
+            struct RetryableStatus;
+            impl reqwest_retry::RetryableStrategy for RetryableStatus {
+                fn handle(
+                    &self,
+                    res: &Result<reqwest::Response, reqwest_middleware::Error>,
+                ) -> Option<reqwest_retry::Retryable> {
+                    match res {
+                        Ok(success) => reqwest_retry::default_on_request_success(success),
+                        Err(_) => None,
+                    }
+                }
+            }
+            let backoff_policy = reqwest_retry::policies::ExponentialBackoff::builder()
+                .build_with_max_retries(config.max_retries);
+
+            let retry_middleware =
+                reqwest_retry::RetryTransientMiddleware::new_with_policy_and_strategy(
+                    backoff_policy,
+                    RetryableStatus,
+                );
+
+            middleware_client_builder = middleware_client_builder.with(retry_middleware);
+        }
+
+        let client = middleware_client_builder.build();
+
+        Self { config, client }
+    }
+
+    pub fn with_client_and_config(
+        config: datadog::Configuration,
+        client: reqwest_middleware::ClientWithMiddleware,
+    ) -> Self {
+        Self { config, client }
+    }
+
+    pub async fn list_integrations(
+        &self,
+    ) -> Result<
+        crate::datadogV2::model::ListIntegrationsResponse,
+        datadog::Error<ListIntegrationsError>,
+    > {
+        match self.list_integrations_with_http_info().await {
+            Ok(response_content) => {
+                if let Some(e) = response_content.entity {
+                    Ok(e)
+                } else {
+                    Err(datadog::Error::Serde(serde::de::Error::custom(
+                        "response content was None",
+                    )))
+                }
+            }
+            Err(err) => Err(err),
+        }
+    }
+
+    pub async fn list_integrations_with_http_info(
+        &self,
+    ) -> Result<
+        datadog::ResponseContent<crate::datadogV2::model::ListIntegrationsResponse>,
+        datadog::Error<ListIntegrationsError>,
+    > {
+        let local_configuration = &self.config;
+        let operation_id = "v2.list_integrations";
+
+        let local_client = &self.client;
+
+        let local_uri_str = format!(
+            "{}/api/v2/integrations",
+            local_configuration.get_operation_host(operation_id)
+        );
+        let mut local_req_builder =
+            local_client.request(reqwest::Method::GET, local_uri_str.as_str());
+
+        // build headers
+        let mut headers = HeaderMap::new();
+        headers.insert("Accept", HeaderValue::from_static("application/json"));
+
+        // build user agent
+        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
+            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
+            Err(e) => {
+                log::warn!("Failed to parse user agent header: {e}, falling back to default");
+                headers.insert(
+                    reqwest::header::USER_AGENT,
+                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
+                )
+            }
+        };
+
+        // build auth
+        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
+            headers.insert(
+                "DD-API-KEY",
+                HeaderValue::from_str(local_key.key.as_str())
+                    .expect("failed to parse DD-API-KEY header"),
+            );
+        };
+        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
+            headers.insert(
+                "DD-APPLICATION-KEY",
+                HeaderValue::from_str(local_key.key.as_str())
+                    .expect("failed to parse DD-APPLICATION-KEY header"),
+            );
+        };
+
+        local_req_builder = local_req_builder.headers(headers);
+        let local_req = local_req_builder.build()?;
+        log::debug!("request content: {:?}", local_req.body());
+        let local_resp = local_client.execute(local_req).await?;
+
+        let local_status = local_resp.status();
+        let local_content = local_resp.text().await?;
+        log::debug!("response content: {}", local_content);
+
+        if !local_status.is_client_error() && !local_status.is_server_error() {
+            match serde_json::from_str::<crate::datadogV2::model::ListIntegrationsResponse>(
+                &local_content,
+            ) {
+                Ok(e) => {
+                    return Ok(datadog::ResponseContent {
+                        status: local_status,
+                        content: local_content,
+                        entity: Some(e),
+                    })
+                }
+                Err(e) => return Err(datadog::Error::Serde(e)),
+            };
+        } else {
+            let local_entity: Option<ListIntegrationsError> =
+                serde_json::from_str(&local_content).ok();
+            let local_error = datadog::ResponseContent {
+                status: local_status,
+                content: local_content,
+                entity: local_entity,
+            };
+            Err(datadog::Error::ResponseError(local_error))
+        }
+    }
+}

src/datadogV2/api/mod.rs

@@ -48,6 +48,7 @@ pub mod api_high_availability_multi_region;
 pub mod api_incident_services;
 pub mod api_incident_teams;
 pub mod api_incidents;
+pub mod api_integrations;
 pub mod api_ip_allowlist;
 pub mod api_jira_integration;
 pub mod api_key_management;

src/datadogV2/mod.rs

@@ -49,6 +49,7 @@ pub use self::api::api_high_availability_multi_region;
 pub use self::api::api_incident_services;
 pub use self::api::api_incident_teams;
 pub use self::api::api_incidents;
+pub use self::api::api_integrations;
 pub use self::api::api_ip_allowlist;
 pub use self::api::api_jira_integration;
 pub use self::api::api_key_management;