Add OpenAPI spec for sourcemap-admin public endpoints (#1685)

Co-authored-by: ci.datadog-api-spec <packages@datadoghq.com>

Author: api-clients-generation-pipeline[bot]

.generator/schemas/v2/openapi.yaml

@@ -592,6 +592,11 @@ impl Default for Configuration {
             ("v2.update_connection".to_owned(), false),
             ("v2.get_pruned_trace_by_id".to_owned(), false),
             ("v2.get_trace_by_id".to_owned(), false),
+            ("v2.delete_sourcemaps".to_owned(), false),
+            ("v2.get_service_repository_info".to_owned(), false),
+            ("v2.get_sourcemaps".to_owned(), false),
+            ("v2.list_sourcemaps".to_owned(), false),
+            ("v2.restore_sourcemaps".to_owned(), false),
             ("v2.query_aggregated_long_tasks".to_owned(), false),
             ("v2.query_aggregated_signals_problems".to_owned(), false),
             ("v2.query_aggregated_waterfall".to_owned(), false),

src/datadog/configuration.rs

@@ -10388,6 +10388,76 @@ pub mod model_raw_error_budget_remaining;
 pub use self::model_raw_error_budget_remaining::RawErrorBudgetRemaining;
 pub mod model_slo_status_type;
 pub use self::model_slo_status_type::SloStatusType;
+pub mod model_sourcemap_map_kind;
+pub use self::model_sourcemap_map_kind::SourcemapMapKind;
+pub mod model_sourcemaps_response;
+pub use self::model_sourcemaps_response::SourcemapsResponse;
+pub mod model_js_sourcemap_data;
+pub use self::model_js_sourcemap_data::JSSourcemapData;
+pub mod model_js_sourcemap_attributes;
+pub use self::model_js_sourcemap_attributes::JSSourcemapAttributes;
+pub mod model_sourcemap_data_type;
+pub use self::model_sourcemap_data_type::SourcemapDataType;
+pub mod model_react_native_sourcemap_data;
+pub use self::model_react_native_sourcemap_data::ReactNativeSourcemapData;
+pub mod model_react_native_sourcemap_attributes;
+pub use self::model_react_native_sourcemap_attributes::ReactNativeSourcemapAttributes;
+pub mod model_ios_sourcemap_data;
+pub use self::model_ios_sourcemap_data::IOSSourcemapData;
+pub mod model_ios_sourcemap_attributes;
+pub use self::model_ios_sourcemap_attributes::IOSSourcemapAttributes;
+pub mod model_jvm_sourcemap_data;
+pub use self::model_jvm_sourcemap_data::JVMSourcemapData;
+pub mod model_jvm_sourcemap_attributes;
+pub use self::model_jvm_sourcemap_attributes::JVMSourcemapAttributes;
+pub mod model_flutter_sourcemap_data;
+pub use self::model_flutter_sourcemap_data::FlutterSourcemapData;
+pub mod model_flutter_sourcemap_attributes;
+pub use self::model_flutter_sourcemap_attributes::FlutterSourcemapAttributes;
+pub mod model_elf_sourcemap_data;
+pub use self::model_elf_sourcemap_data::ELFSourcemapData;
+pub mod model_elf_sourcemap_attributes;
+pub use self::model_elf_sourcemap_attributes::ELFSourcemapAttributes;
+pub mod model_ndk_sourcemap_data;
+pub use self::model_ndk_sourcemap_data::NDKSourcemapData;
+pub mod model_ndk_sourcemap_attributes;
+pub use self::model_ndk_sourcemap_attributes::NDKSourcemapAttributes;
+pub mod model_il2_cpp_sourcemap_data;
+pub use self::model_il2_cpp_sourcemap_data::IL2CPPSourcemapData;
+pub mod model_il2_cpp_sourcemap_attributes;
+pub use self::model_il2_cpp_sourcemap_attributes::IL2CPPSourcemapAttributes;
+pub mod model_sourcemap_item;
+pub use self::model_sourcemap_item::SourcemapItem;
+pub mod model_sourcemap_file_response;
+pub use self::model_sourcemap_file_response::SourcemapFileResponse;
+pub mod model_sourcemap_file_data;
+pub use self::model_sourcemap_file_data::SourcemapFileData;
+pub mod model_sourcemap_file_attributes;
+pub use self::model_sourcemap_file_attributes::SourcemapFileAttributes;
+pub mod model_sourcemap_file_data_type;
+pub use self::model_sourcemap_file_data_type::SourcemapFileDataType;
+pub mod model_list_sourcemaps_response;
+pub use self::model_list_sourcemaps_response::ListSourcemapsResponse;
+pub mod model_sourcemaps_list_meta;
+pub use self::model_sourcemaps_list_meta::SourcemapsListMeta;
+pub mod model_sourcemaps_list_meta_page;
+pub use self::model_sourcemaps_list_meta_page::SourcemapsListMetaPage;
+pub mod model_service_repository_info_request;
+pub use self::model_service_repository_info_request::ServiceRepositoryInfoRequest;
+pub mod model_service_repository_info_request_data;
+pub use self::model_service_repository_info_request_data::ServiceRepositoryInfoRequestData;
+pub mod model_service_repository_info_request_attributes;
+pub use self::model_service_repository_info_request_attributes::ServiceRepositoryInfoRequestAttributes;
+pub mod model_service_repository_info_data_type;
+pub use self::model_service_repository_info_data_type::ServiceRepositoryInfoDataType;
+pub mod model_service_repository_info_response;
+pub use self::model_service_repository_info_response::ServiceRepositoryInfoResponse;
+pub mod model_service_repository_info_response_data;
+pub use self::model_service_repository_info_response_data::ServiceRepositoryInfoResponseData;
+pub mod model_service_repository_info_response_attributes;
+pub use self::model_service_repository_info_response_attributes::ServiceRepositoryInfoResponseAttributes;
+pub mod model_service_repository_info_status;
+pub use self::model_service_repository_info_status::ServiceRepositoryInfoStatus;
 pub mod model_recommendation_document;
 pub use self::model_recommendation_document::RecommendationDocument;
 pub mod model_recommendation_data;

src/datadogV2/api/api_rum.rs

@@ -0,0 +1,256 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+use serde::de::{Error, MapAccess, Visitor};
+use serde::{Deserialize, Deserializer, Serialize};
+use serde_with::skip_serializing_none;
+use std::fmt::{self, Formatter};
+
+/// Attributes of an ELF symbol file.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct ELFSourcemapAttributes {
+    /// The target CPU architecture.
+    #[serde(rename = "arch")]
+    pub arch: Option<String>,
+    /// The timestamp when the symbol file was created.
+    #[serde(rename = "created_at")]
+    pub created_at: chrono::DateTime<chrono::Utc>,
+    /// The SHA256 hash of the ELF file.
+    #[serde(rename = "file_hash")]
+    pub file_hash: Option<String>,
+    /// The ELF file name.
+    #[serde(rename = "file_name")]
+    pub file_name: Option<String>,
+    /// The GNU build ID (UUID format).
+    #[serde(rename = "gnu_build_id")]
+    pub gnu_build_id: Option<String>,
+    /// The Go build ID (UUID format).
+    #[serde(rename = "go_build_id")]
+    pub go_build_id: Option<String>,
+    /// The type of source map.
+    #[serde(rename = "mapkind")]
+    pub mapkind: String,
+    /// The origin of the ELF file.
+    #[serde(rename = "origin")]
+    pub origin: Option<String>,
+    /// The version of the origin package.
+    #[serde(rename = "origin_version")]
+    pub origin_version: Option<String>,
+    /// The size of the ELF file in bytes.
+    #[serde(rename = "size")]
+    pub size: i64,
+    /// The source of the debug symbols.
+    #[serde(rename = "symbol_source")]
+    pub symbol_source: Option<String>,
+    #[serde(flatten)]
+    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
+    #[serde(skip)]
+    #[serde(default)]
+    pub(crate) _unparsed: bool,
+}
+
+impl ELFSourcemapAttributes {
+    pub fn new(
+        created_at: chrono::DateTime<chrono::Utc>,
+        mapkind: String,
+        size: i64,
+    ) -> ELFSourcemapAttributes {
+        ELFSourcemapAttributes {
+            arch: None,
+            created_at,
+            file_hash: None,
+            file_name: None,
+            gnu_build_id: None,
+            go_build_id: None,
+            mapkind,
+            origin: None,
+            origin_version: None,
+            size,
+            symbol_source: None,
+            additional_properties: std::collections::BTreeMap::new(),
+            _unparsed: false,
+        }
+    }
+
+    pub fn arch(mut self, value: String) -> Self {
+        self.arch = Some(value);
+        self
+    }
+
+    pub fn file_hash(mut self, value: String) -> Self {
+        self.file_hash = Some(value);
+        self
+    }
+
+    pub fn file_name(mut self, value: String) -> Self {
+        self.file_name = Some(value);
+        self
+    }
+
+    pub fn gnu_build_id(mut self, value: String) -> Self {
+        self.gnu_build_id = Some(value);
+        self
+    }
+
+    pub fn go_build_id(mut self, value: String) -> Self {
+        self.go_build_id = Some(value);
+        self
+    }
+
+    pub fn origin(mut self, value: String) -> Self {
+        self.origin = Some(value);
+        self
+    }
+
+    pub fn origin_version(mut self, value: String) -> Self {
+        self.origin_version = Some(value);
+        self
+    }
+
+    pub fn symbol_source(mut self, value: String) -> Self {
+        self.symbol_source = Some(value);
+        self
+    }
+
+    pub fn additional_properties(
+        mut self,
+        value: std::collections::BTreeMap<String, serde_json::Value>,
+    ) -> Self {
+        self.additional_properties = value;
+        self
+    }
+}
+
+impl<'de> Deserialize<'de> for ELFSourcemapAttributes {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct ELFSourcemapAttributesVisitor;
+        impl<'a> Visitor<'a> for ELFSourcemapAttributesVisitor {
+            type Value = ELFSourcemapAttributes;
+
+            fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
+                f.write_str("a mapping")
+            }
+
+            fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
+            where
+                M: MapAccess<'a>,
+            {
+                let mut arch: Option<String> = None;
+                let mut created_at: Option<chrono::DateTime<chrono::Utc>> = None;
+                let mut file_hash: Option<String> = None;
+                let mut file_name: Option<String> = None;
+                let mut gnu_build_id: Option<String> = None;
+                let mut go_build_id: Option<String> = None;
+                let mut mapkind: Option<String> = None;
+                let mut origin: Option<String> = None;
+                let mut origin_version: Option<String> = None;
+                let mut size: Option<i64> = None;
+                let mut symbol_source: Option<String> = None;
+                let mut additional_properties: std::collections::BTreeMap<
+                    String,
+                    serde_json::Value,
+                > = std::collections::BTreeMap::new();
+                let mut _unparsed = false;
+
+                while let Some((k, v)) = map.next_entry::<String, serde_json::Value>()? {
+                    match k.as_str() {
+                        "arch" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            arch = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "created_at" => {
+                            created_at = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "file_hash" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            file_hash = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "file_name" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            file_name = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "gnu_build_id" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            gnu_build_id =
+                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "go_build_id" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            go_build_id =
+                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "mapkind" => {
+                            mapkind = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "origin" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            origin = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "origin_version" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            origin_version =
+                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "size" => {
+                            size = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "symbol_source" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            symbol_source =
+                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        &_ => {
+                            if let Ok(value) = serde_json::from_value(v.clone()) {
+                                additional_properties.insert(k, value);
+                            }
+                        }
+                    }
+                }
+                let created_at = created_at.ok_or_else(|| M::Error::missing_field("created_at"))?;
+                let mapkind = mapkind.ok_or_else(|| M::Error::missing_field("mapkind"))?;
+                let size = size.ok_or_else(|| M::Error::missing_field("size"))?;
+
+                let content = ELFSourcemapAttributes {
+                    arch,
+                    created_at,
+                    file_hash,
+                    file_name,
+                    gnu_build_id,
+                    go_build_id,
+                    mapkind,
+                    origin,
+                    origin_version,
+                    size,
+                    symbol_source,
+                    additional_properties,
+                    _unparsed,
+                };
+
+                Ok(content)
+            }
+        }
+
+        deserializer.deserialize_any(ELFSourcemapAttributesVisitor)
+    }
+}