AWS SDK

rev. 13a03abd8623d956e96296b8c3fffbcbb753e99e

Files changed:

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/Cargo.toml

@@ -0,1 +0,24 @@

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "aws-smithy-observability"
 version = "0.1.0"
 authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>"]
 description = "Smithy observability implementation."
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/awslabs/smithy-rs"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-+
 [dependencies]
 once_cell = "1.19.0"
-+
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 version = "1.7.3"
-+
 [dev-dependencies]
 serial_test = "3.1.1"

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/LICENSE

@@ -0,1 +0,175 @@

-+
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
-+
    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-+
 . Definitions.
-+
       "License" shall mean the terms and conditions for use, reproduction,
       and distribution as defined by Sections 1 through 9 of this document.
-+
       "Licensor" shall mean the copyright owner or entity authorized by
       the copyright owner that is granting the License.
-+
       "Legal Entity" shall mean the union of the acting entity and all
       other entities that control, are controlled by, or are under common
       control with that entity. For the purposes of this definition,
       "control" means (i) the power, direct or indirect, to cause the
       direction or management of such entity, whether by contract or
       otherwise, or (ii) ownership of fifty percent (50%) or more of the
       outstanding shares, or (iii) beneficial ownership of such entity.
-+
       "You" (or "Your") shall mean an individual or Legal Entity
       exercising permissions granted by this License.
-+
       "Source" form shall mean the preferred form for making modifications,
       including but not limited to software source code, documentation
       source, and configuration files.
-+
       "Object" form shall mean any form resulting from mechanical
       transformation or translation of a Source form, including but
       not limited to compiled object code, generated documentation,
       and conversions to other media types.
-+
       "Work" shall mean the work of authorship, whether in Source or
       Object form, made available under the License, as indicated by a
       copyright notice that is included in or attached to the work
       (an example is provided in the Appendix below).
-+
       "Derivative Works" shall mean any work, whether in Source or Object
       form, that is based on (or derived from) the Work and for which the
       editorial revisions, annotations, elaborations, or other modifications
       represent, as a whole, an original work of authorship. For the purposes
       of this License, Derivative Works shall not include works that remain
       separable from, or merely link (or bind by name) to the interfaces of,
       the Work and Derivative Works thereof.
-+
       "Contribution" shall mean any work of authorship, including
       the original version of the Work and any modifications or additions
       to that Work or Derivative Works thereof, that is intentionally
       submitted to Licensor for inclusion in the Work by the copyright owner
       or by an individual or Legal Entity authorized to submit on behalf of
       the copyright owner. For the purposes of this definition, "submitted"
       means any form of electronic, verbal, or written communication sent
       to the Licensor or its representatives, including but not limited to
       communication on electronic mailing lists, source code control systems,
       and issue tracking systems that are managed by, or on behalf of, the
       Licensor for the purpose of discussing and improving the Work, but
       excluding communication that is conspicuously marked or otherwise
       designated in writing by the copyright owner as "Not a Contribution."
-+
       "Contributor" shall mean Licensor and any individual or Legal Entity
       on behalf of whom a Contribution has been received by Licensor and
       subsequently incorporated within the Work.
-+
 . Grant of Copyright License. Subject to the terms and conditions of
       this License, each Contributor hereby grants to You a perpetual,
       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
       copyright license to reproduce, prepare Derivative Works of,
       publicly display, publicly perform, sublicense, and distribute the
       Work and such Derivative Works in Source or Object form.
-+
 . Grant of Patent License. Subject to the terms and conditions of
       this License, each Contributor hereby grants to You a perpetual,
       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
       (except as stated in this section) patent license to make, have made,
       use, offer to sell, sell, import, and otherwise transfer the Work,
       where such license applies only to those patent claims licensable
       by such Contributor that are necessarily infringed by their
       Contribution(s) alone or by combination of their Contribution(s)
       with the Work to which such Contribution(s) was submitted. If You
       institute patent litigation against any entity (including a
       cross-claim or counterclaim in a lawsuit) alleging that the Work
       or a Contribution incorporated within the Work constitutes direct
       or contributory patent infringement, then any patent licenses
       granted to You under this License for that Work shall terminate
       as of the date such litigation is filed.
-+
 . Redistribution. You may reproduce and distribute copies of the
       Work or Derivative Works thereof in any medium, with or without
       modifications, and in Source or Object form, provided that You
       meet the following conditions:
-+
       (a) You must give any other recipients of the Work or
           Derivative Works a copy of this License; and
-+
       (b) You must cause any modified files to carry prominent notices
           stating that You changed the files; and
-+
       (c) You must retain, in the Source form of any Derivative Works
           that You distribute, all copyright, patent, trademark, and
           attribution notices from the Source form of the Work,
           excluding those notices that do not pertain to any part of
           the Derivative Works; and
-+
       (d) If the Work includes a "NOTICE" text file as part of its
           distribution, then any Derivative Works that You distribute must
           include a readable copy of the attribution notices contained
           within such NOTICE file, excluding those notices that do not
           pertain to any part of the Derivative Works, in at least one
           of the following places: within a NOTICE text file distributed
           as part of the Derivative Works; within the Source form or
           documentation, if provided along with the Derivative Works; or,
           within a display generated by the Derivative Works, if and
           wherever such third-party notices normally appear. The contents
           of the NOTICE file are for informational purposes only and
           do not modify the License. You may add Your own attribution
           notices within Derivative Works that You distribute, alongside
           or as an addendum to the NOTICE text from the Work, provided
           that such additional attribution notices cannot be construed
           as modifying the License.
-+
       You may add Your own copyright statement to Your modifications and
       may provide additional or different license terms and conditions
       for use, reproduction, or distribution of Your modifications, or
       for any such Derivative Works as a whole, provided Your use,
       reproduction, and distribution of the Work otherwise complies with
       the conditions stated in this License.
-+
 . Submission of Contributions. Unless You explicitly state otherwise,
       any Contribution intentionally submitted for inclusion in the Work
       by You to the Licensor shall be under the terms and conditions of
       this License, without any additional terms or conditions.
       Notwithstanding the above, nothing herein shall supersede or modify
       the terms of any separate license agreement you may have executed
       with Licensor regarding such Contributions.
-+
 . Trademarks. This License does not grant permission to use the trade
       names, trademarks, service marks, or product names of the Licensor,
       except as required for reasonable and customary use in describing the
       origin of the Work and reproducing the content of the NOTICE file.
-+
 . Disclaimer of Warranty. Unless required by applicable law or
       agreed to in writing, Licensor provides the Work (and each
       Contributor provides its Contributions) on an "AS IS" BASIS,
       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
       implied, including, without limitation, any warranties or conditions
       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
       PARTICULAR PURPOSE. You are solely responsible for determining the
       appropriateness of using or redistributing the Work and assume any
       risks associated with Your exercise of permissions under this License.
-+
 . Limitation of Liability. In no event and under no legal theory,
       whether in tort (including negligence), contract, or otherwise,
       unless required by applicable law (such as deliberate and grossly
       negligent acts) or agreed to in writing, shall any Contributor be
       liable to You for damages, including any direct, indirect, special,
       incidental, or consequential damages of any character arising as a
       result of this License or out of the use or inability to use the
       Work (including but not limited to damages for loss of goodwill,
       work stoppage, computer failure or malfunction, or any and all
       other commercial damages or losses), even if such Contributor
       has been advised of the possibility of such damages.
-+
 . Accepting Warranty or Additional Liability. While redistributing
       the Work or Derivative Works thereof, You may choose to offer,
       and charge a fee for, acceptance of support, warranty, indemnity,
       or other liability obligations and/or rights consistent with this
       License. However, in accepting such obligations, You may act only
       on Your own behalf and on Your sole responsibility, not on behalf
       of any other Contributor, and only if You agree to indemnify,
       defend, and hold each Contributor harmless for any liability
       incurred by, or claims asserted against, such Contributor by reason
       of your accepting any such warranty or additional liability.

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/README.md

@@ -0,1 +0,7 @@

 # aws-smithy-observability
-+
 This crate contains traits allowing for the implementation of `TelemetryProvider`s for the AWS SDK for Rust. It also contains a `global` module for setting and interacting with the current `GlobalTelemetryProvider`.
-+
 <!-- anchor_start:footer -->
 This crate is part of the [AWS SDK for Rust](https://awslabs.github.io/aws-sdk-rust/) and the [smithy-rs](https://github.com/smithy-lang/smithy-rs) code generator. In most cases, it should not be used directly.
 <!-- anchor_end:footer -->

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/external-types.toml

@@ -0,1 +0,3 @@

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/src/attributes.rs

@@ -0,1 +0,58 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 //! Attributes (also referred to as tags or annotations in other telemetry systems) are structured
 //! key-value pairs that annotate a span or event. Structured data allows observability backends
 //! to index and process telemetry data in ways that simple log messages lack.
-+
 use std::collections::HashMap;
-+
 /// The valid types of values accepted by [Attributes].
 #[non_exhaustive]
 #[derive(Clone, Debug, PartialEq)]
 pub enum AttributeValue {
     /// Holds an [i64]
     I64(i64),
     /// Holds an [f64]
     F64(f64),
     /// Holds a [String]
     String(String),
     /// Holds a [bool]
     Bool(bool),
-+
+}
-+
 /// Structured telemetry metadata.
 #[non_exhaustive]
 #[derive(Clone, Default)]
 pub struct Attributes {
     attrs: HashMap<String, AttributeValue>,
-+
+}
-+
 impl Attributes {
     /// Create a new empty instance of [Attributes].
     pub fn new() -> Self {
         Self::default()
-+
+    }
-+
     /// Set an attribute.
     pub fn set(&mut self, key: impl Into<String>, value: impl Into<AttributeValue>) {
         self.attrs.insert(key.into(), value.into());
-+
+    }
-+
     /// Get an attribute.
     pub fn get(&self, key: impl Into<String>) -> Option<&AttributeValue> {
         self.attrs.get(&key.into())
-+
+    }
-+
     /// Get all of the attribute key value pairs.
     pub fn attributes(&self) -> &HashMap<String, AttributeValue> {
         &self.attrs
-+
+    }
-+
     /// Get an owned [Iterator] of ([String], [AttributeValue]).
     pub fn into_attributes(self) -> impl Iterator<Item = (String, AttributeValue)> {
         self.attrs.into_iter()
-+
+    }
-+
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/src/context.rs

@@ -0,1 +0,26 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 /// Delineates a logical scope that has some beginning and end
 /// (e.g. a function or block of code).
 pub trait Scope {
     /// invoke when the scope has ended.
     fn end(&self);
-+
+}
-+
 /// A cross cutting concern for carrying execution-scoped values across API
 /// boundaries (both in-process and distributed).
 pub trait Context {
     /// Make this context the currently active context.
     /// The returned handle is used to return the previous
     /// context (if one existed) as active.
     fn make_current(&self) -> &dyn Scope;
-+
+}
-+
 /// Keeps track of the current [Context].
 pub trait ContextManager {
     ///Get the currently active context.
     fn current(&self) -> &dyn Context;
-+
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/src/error.rs

@@ -0,1 +0,80 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 //! Observability Errors
-+
 use std::fmt;
-+
 use aws_smithy_runtime_api::box_error::BoxError;
-+
 /// An error in the SDKs Observability providers
 #[non_exhaustive]
 #[derive(Debug)]
 pub struct ObservabilityError {
     kind: ErrorKind,
     source: BoxError,
-+
+}
-+
 /// The types of errors associated with [ObservabilityError]
 #[non_exhaustive]
 #[derive(Debug)]
 pub enum ErrorKind {
     /// A custom error that does not fall under any other error kind
     Other,
-+
+}
-+
 impl ObservabilityError {
     /// Create a new [`ObservabilityError`] from an [ErrorKind] and a [BoxError]
     pub fn new<E>(kind: ErrorKind, err: E) -> Self
     where
         E: Into<BoxError>,
-+
+    {
         Self {
             kind,
             source: err.into(),
-+
+        }
-+
+    }
-+
     /// Returns the corresponding [`ErrorKind`] for this error.
     pub fn kind(&self) -> &ErrorKind {
         &self.kind
-+
+    }
-+
+}
-+
 impl fmt::Display for ObservabilityError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match &self.kind {
             ErrorKind::Other => write!(f, "unclassified error"),
-+
+        }
-+
+    }
-+
+}
-+
 impl std::error::Error for ObservabilityError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         Some(self.source.as_ref())
-+
+    }
-+
+}
-+
 /// An simple error to represent issues with the global [crate::TelemetryProvider].
 #[non_exhaustive]
 #[derive(Debug)]
 pub struct GlobalTelemetryProviderError {
     reason: &'static str,
-+
+}
-+
 impl GlobalTelemetryProviderError {
     /// Create a new [GlobalTelemetryProviderError] with a given reason for the error.
     pub fn new(reason: &'static str) -> Self {
         Self { reason }
-+
+    }
-+
+}
-+
 impl std::error::Error for GlobalTelemetryProviderError {}
-+
 impl fmt::Display for GlobalTelemetryProviderError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "GlobalTelemetryProviderError: {}", self.reason)
-+
+    }
-+
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/src/global.rs

@@ -0,1 +0,86 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 //! Utilities for interacting with the currently set `GlobalTelemetryProvider`
-+
 use once_cell::sync::Lazy;
 use std::{
     mem,
     sync::{Arc, RwLock},
 };
-+
 use crate::{
     error::{ErrorKind, GlobalTelemetryProviderError},
     provider::{GlobalTelemetryProvider, TelemetryProvider},
     ObservabilityError,
 };
-+
 // Statically store the global provider
 static GLOBAL_TELEMETRY_PROVIDER: Lazy<RwLock<GlobalTelemetryProvider>> =
     Lazy::new(|| RwLock::new(GlobalTelemetryProvider::new(TelemetryProvider::default())));
-+
 /// Set the current global [TelemetryProvider].
 ///
 /// This is meant to be run once at the beginning of an application. Will return an [Err] if the
 /// [RwLock] holding the global [TelemetryProvider] is locked or poisoned.
 pub fn set_telemetry_provider(new_provider: TelemetryProvider) -> Result<(), ObservabilityError> {
     if let Ok(mut old_provider) = GLOBAL_TELEMETRY_PROVIDER.try_write() {
         let new_global_provider = GlobalTelemetryProvider::new(new_provider);
-+
         let _ = mem::replace(&mut *old_provider, new_global_provider);
-+
         Ok(())
     } else {
         Err(ObservabilityError::new(
             ErrorKind::Other,
             GlobalTelemetryProviderError::new("Failed to set global TelemetryProvider."),
         ))
-+
+    }
-+
+}
-+
 /// Get an [Arc] reference to the current global [TelemetryProvider]. Will return an [Err] if the
 /// [RwLock] holding the global [TelemetryProvider] is locked or poisoned.
 pub fn get_telemetry_provider() -> Result<Arc<TelemetryProvider>, ObservabilityError> {
     if let Ok(tp) = GLOBAL_TELEMETRY_PROVIDER.try_read() {
         Ok(tp.telemetry_provider().clone())
     } else {
         Err(ObservabilityError::new(
             ErrorKind::Other,
             GlobalTelemetryProviderError::new("Failed to get global TelemetryProvider"),
         ))
-+
+    }
-+
+}
-+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::provider::TelemetryProvider;
     use serial_test::serial;
-+
     // Note: the tests in this module are run serially to prevent them from stepping on each other and poisoning the
     // RwLock holding the GlobalTelemetryProvider
     #[test]
     #[serial]
     fn can_set_global_telemetry_provider() {
         let my_provider = TelemetryProvider::default();
-+
         // Set the new counter and get a reference to the old one
         set_telemetry_provider(my_provider).unwrap();
-+
+    }
-+
     #[test]
     #[serial]
     fn can_get_global_telemetry_provider() {
         let curr_provider = get_telemetry_provider().unwrap();
-+
         // Use the global provider to create an instrument and record a value with it
         let curr_mp = curr_provider.meter_provider();
         let curr_meter = curr_mp.get_meter("TestMeter", None);
         let instrument = curr_meter
             .create_monotonic_counter("TestMonoCounter")
             .build();
         instrument.add(4, None, None);
-+
+    }
-+
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/src/instruments.rs

@@ -0,1 +0,246 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 //! Instruments are used to record values for metrics.
-+
 use std::{borrow::Cow, fmt::Debug, marker::PhantomData, sync::Arc};
-+
 use crate::{meter::Meter, Attributes, Context};
-+
 /// Configuration for building a sync instrument.
 #[non_exhaustive]
 pub struct InstrumentBuilder<'a, T> {
     instrument_provider: &'a dyn ProvideInstrument,
     name: Cow<'static, str>,
     description: Option<Cow<'static, str>>,
     units: Option<Cow<'static, str>>,
     _phantom: PhantomData<T>,
-+
+}
-+
 impl<'a, T> InstrumentBuilder<'a, T> {
     /// Create a new instrument builder
     pub(crate) fn new(meter: &'a Meter, name: Cow<'static, str>) -> Self {
         InstrumentBuilder {
             instrument_provider: meter.instrument_provider.as_ref(),
             name,
             description: None,
             units: None,
             _phantom: PhantomData::<T>,
-+
+        }
-+
+    }
-+
     /// Get the name.
     pub fn get_name(&self) -> &Cow<'static, str> {
         &self.name
-+
+    }
-+
     /// Set the description.
     pub fn set_description(mut self, description: impl Into<Cow<'static, str>>) -> Self {
         self.description = Some(description.into());
         self
-+
+    }
-+
     /// Get the description.
     pub fn get_description(&self) -> &Option<Cow<'static, str>> {
         &self.description
-+
+    }
-+
     /// Set the units.
     pub fn set_units(mut self, units: impl Into<Cow<'static, str>>) -> Self {
         self.units = Some(units.into());
         self
-+
+    }
-+
     /// Get the units.
     pub fn get_units(&self) -> &Option<Cow<'static, str>> {
         &self.units
-+
+    }
-+
+}
-+
 /// Takes in the name of function from [ProvideInstrument] and the type of instrument being created
 /// (ex: [Histogram]) and adds a `build` function for it.
 macro_rules! build_instrument {
     ($name:ident, $instrument:ty) => {
         impl<'a> InstrumentBuilder<'a, $instrument> {
             #[doc = concat!("Create a new `",  stringify!($instrument), "`.")]
             pub fn build(self) -> $instrument {
                 self.instrument_provider.$name(self)
-+
+            }
-+
+        }
     };
-+
+}
-+
 build_instrument!(create_histogram, Arc<dyn Histogram>);
 build_instrument!(create_monotonic_counter, Arc<dyn MonotonicCounter>);
 build_instrument!(create_up_down_counter, Arc<dyn UpDownCounter>);
-+
 /// Configuration for building an async instrument.
 #[non_exhaustive]
 pub struct AsyncInstrumentBuilder<'a, T, M> {
     instrument_provider: &'a dyn ProvideInstrument,
     name: Cow<'static, str>,
     // Implementation note: I could not make the lifetimes work out in the impl ProvideInstrument
     // in aws-smithy-observability-otel without making this field pub
     /// The callback function for this AsyncInstrumentBuilder.
     #[allow(clippy::type_complexity)]
     pub callback: Arc<dyn Fn(&dyn AsyncMeasure<Value = M>) + Send + Sync>,
     description: Option<Cow<'static, str>>,
     units: Option<Cow<'static, str>>,
     _phantom: PhantomData<T>,
-+
+}
-+
 #[allow(clippy::type_complexity)]
 impl<'a, T, M> AsyncInstrumentBuilder<'a, T, M> {
     /// Create a new async instrument builder
     pub(crate) fn new(
         meter: &'a Meter,
         name: Cow<'static, str>,
         callback: Arc<dyn Fn(&dyn AsyncMeasure<Value = M>) + Send + Sync>,
     ) -> Self {
         AsyncInstrumentBuilder {
             instrument_provider: meter.instrument_provider.as_ref(),
             name,
             callback,
             description: None,
             units: None,
             _phantom: PhantomData::<T>,
-+
+        }
-+
+    }
-+
     /// Get the name.
     pub fn get_name(&self) -> &Cow<'static, str> {
         &self.name
-+
+    }
-+
     /// Get the callback function.
     pub fn get_callback(&self) -> Arc<dyn Fn(&dyn AsyncMeasure<Value = M>) + Send + Sync> {
         self.callback.clone()
-+
+    }
-+
     /// Set the description.
     pub fn set_description(mut self, description: impl Into<Cow<'static, str>>) -> Self {
         self.description = Some(description.into());
         self
-+
+    }
-+
     /// Get the description.
     pub fn get_description(&self) -> &Option<Cow<'static, str>> {
         &self.description
-+
+    }
-+
     /// Set the units.
     pub fn set_units(mut self, units: impl Into<Cow<'static, str>>) -> Self {
         self.units = Some(units.into());
         self
-+
+    }
-+
     /// Get the units.
     pub fn get_units(&self) -> &Option<Cow<'static, str>> {
         &self.units
-+
+    }
-+
+}
-+
 /// Takes in the name of function from [ProvideInstrument] and the type of instrument being created
 /// (ex: [AsyncMeasure]) and adds a `build` function for it.
 //TODO(observability): Can I derive the measurement from the Value of the instrument type or vice versa?
 macro_rules! build_async_instrument {
     ($name:ident, $instrument:ty, $measurement:ty) => {
         impl<'a> AsyncInstrumentBuilder<'a, $instrument, $measurement> {
             #[doc = concat!("Create a new `",  stringify!($instrument), "`.")]
             pub fn build(self) -> $instrument {
                 self.instrument_provider.$name(self)
-+
+            }
-+
+        }
     };
-+
+}
-+
 build_async_instrument!(create_gauge, Arc<dyn AsyncMeasure<Value = f64>>, f64);
 build_async_instrument!(
     create_async_up_down_counter,
     Arc<dyn AsyncMeasure<Value = i64>>,
     i64
 );
 build_async_instrument!(
     create_async_monotonic_counter,
     Arc<dyn AsyncMeasure<Value = u64>>,
     u64
 );
-+
 /// The entry point to creating instruments. A grouping of related metrics.
 pub trait ProvideInstrument: Send + Sync + Debug {
     /// Create a new Gauge.
     #[allow(clippy::type_complexity)]
     fn create_gauge(
         &self,
         builder: AsyncInstrumentBuilder<'_, Arc<dyn AsyncMeasure<Value = f64>>, f64>,
     ) -> Arc<dyn AsyncMeasure<Value = f64>>;
-+
     /// Create a new [UpDownCounter].
     fn create_up_down_counter(
         &self,
         builder: InstrumentBuilder<'_, Arc<dyn UpDownCounter>>,
     ) -> Arc<dyn UpDownCounter>;
-+
     /// Create a new AsyncUpDownCounter.
     #[allow(clippy::type_complexity)]
     fn create_async_up_down_counter(
         &self,
         builder: AsyncInstrumentBuilder<'_, Arc<dyn AsyncMeasure<Value = i64>>, i64>,
     ) -> Arc<dyn AsyncMeasure<Value = i64>>;
-+
     /// Create a new [MonotonicCounter].
     fn create_monotonic_counter(
         &self,
         builder: InstrumentBuilder<'_, Arc<dyn MonotonicCounter>>,
     ) -> Arc<dyn MonotonicCounter>;
-+
     /// Create a new AsyncMonotonicCounter.
     #[allow(clippy::type_complexity)]
     fn create_async_monotonic_counter(
         &self,
         builder: AsyncInstrumentBuilder<'_, Arc<dyn AsyncMeasure<Value = u64>>, u64>,
     ) -> Arc<dyn AsyncMeasure<Value = u64>>;
-+
     /// Create a new [Histogram].
     fn create_histogram(
         &self,
         builder: InstrumentBuilder<'_, Arc<dyn Histogram>>,
     ) -> Arc<dyn Histogram>;
-+
+}
-+
 /// Collects a set of events with an event count and sum for all events.
 pub trait Histogram: Send + Sync + Debug {
     /// Record a value.
     fn record(&self, value: f64, attributes: Option<&Attributes>, context: Option<&dyn Context>);
-+
+}
-+
 /// A counter that monotonically increases.
 pub trait MonotonicCounter: Send + Sync + Debug {
     /// Increment a counter by a fixed amount.
     fn add(&self, value: u64, attributes: Option<&Attributes>, context: Option<&dyn Context>);
-+
+}
-+
 /// A counter that can increase or decrease.
 pub trait UpDownCounter: Send + Sync + Debug {
     /// Increment or decrement a counter by a fixed amount.
     fn add(&self, value: i64, attributes: Option<&Attributes>, context: Option<&dyn Context>);
-+
+}
-+
 /// A measurement that can be taken asynchronously.
 pub trait AsyncMeasure: Send + Sync + Debug {
     /// The type recorded by the measurement.
     type Value;
-+
     /// Record a value
     fn record(
         &self,
         value: Self::Value,
         attributes: Option<&Attributes>,
         context: Option<&dyn Context>,
     );
-+
     /// Stop recording, unregister callback.
     fn stop(&self);
-+
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/src/lib.rs

@@ -0,1 +0,31 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 /* Automatically managed default lints */
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 /* End of automatically managed default lints */
 #![warn(
     missing_docs,
     rustdoc::missing_crate_level_docs,
     unreachable_pub,
     rust_2018_idioms
 )]
-+
 //! Smithy Observability
 // TODO(smithyobservability): once we have finalized everything and integrated metrics with our runtime
 // libraries update this with detailed usage docs and examples
-+
 mod attributes;
 pub use attributes::{AttributeValue, Attributes};
 mod context;
 pub use context::{Context, ContextManager, Scope};
 mod error;
 pub use error::{ErrorKind, GlobalTelemetryProviderError, ObservabilityError};
 pub mod global;
 pub mod meter;
 mod noop;
 mod provider;
 pub use provider::{TelemetryProvider, TelemetryProviderBuilder};
 pub mod instruments;

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/src/meter.rs

@@ -0,1 +0,98 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 //! Metrics are used to gain insight into the operational performance and health of a system in
 //! real time.
-+
 use crate::instruments::{
     AsyncInstrumentBuilder, AsyncMeasure, Histogram, InstrumentBuilder, MonotonicCounter,
     UpDownCounter,
 };
 use crate::{attributes::Attributes, instruments::ProvideInstrument};
 use std::{borrow::Cow, fmt::Debug, sync::Arc};
-+
 /// Provides named instances of [Meter].
 pub trait ProvideMeter: Send + Sync + Debug {
     /// Get or create a named [Meter].
     fn get_meter(&self, scope: &'static str, attributes: Option<&Attributes>) -> Meter;
-+
+}
-+
 /// The entry point to creating instruments. A grouping of related metrics.
 #[derive(Clone)]
 pub struct Meter {
     pub(crate) instrument_provider: Arc<dyn ProvideInstrument + Send + Sync>,
-+
+}
-+
 impl Meter {
     /// Create a new [Meter] from an [ProvideInstrument]
     pub fn new(instrument_provider: Arc<dyn ProvideInstrument + Send + Sync>) -> Self {
         Meter {
             instrument_provider,
-+
+        }
-+
+    }
-+
     /// Create a new Gauge.
     #[allow(clippy::type_complexity)]
     pub fn create_gauge<F>(
         &self,
         name: impl Into<Cow<'static, str>>,
         callback: F,
     ) -> AsyncInstrumentBuilder<'_, Arc<dyn AsyncMeasure<Value = f64>>, f64>
     where
         F: Fn(&dyn AsyncMeasure<Value = f64>) + Send + Sync + 'static,
-+
+    {
         AsyncInstrumentBuilder::new(self, name.into(), Arc::new(callback))
-+
+    }
-+
     /// Create a new [UpDownCounter].
     pub fn create_up_down_counter(
         &self,
         name: impl Into<Cow<'static, str>>,
     ) -> InstrumentBuilder<'_, Arc<dyn UpDownCounter>> {
         InstrumentBuilder::new(self, name.into())
-+
+    }
-+
     /// Create a new AsyncUpDownCounter.
     #[allow(clippy::type_complexity)]
     pub fn create_async_up_down_counter<F>(
         &self,
         name: impl Into<Cow<'static, str>>,
         callback: F,
     ) -> AsyncInstrumentBuilder<'_, Arc<dyn AsyncMeasure<Value = i64>>, i64>
     where
         F: Fn(&dyn AsyncMeasure<Value = i64>) + Send + Sync + 'static,
-+
+    {
         AsyncInstrumentBuilder::new(self, name.into(), Arc::new(callback))
-+
+    }
-+
     /// Create a new [MonotonicCounter].
     pub fn create_monotonic_counter(
         &self,
         name: impl Into<Cow<'static, str>>,
     ) -> InstrumentBuilder<'_, Arc<dyn MonotonicCounter>> {
         InstrumentBuilder::new(self, name.into())
-+
+    }
-+
     /// Create a new AsyncMonotonicCounter.
     #[allow(clippy::type_complexity)]
     pub fn create_async_monotonic_counter<F>(
         &self,
         name: impl Into<Cow<'static, str>>,
         callback: F,
     ) -> AsyncInstrumentBuilder<'_, Arc<dyn AsyncMeasure<Value = u64>>, u64>
     where
         F: Fn(&dyn AsyncMeasure<Value = u64>) + Send + Sync + 'static,
-+
+    {
         AsyncInstrumentBuilder::new(self, name.into(), Arc::new(callback))
-+
+    }
-+
     /// Create a new [Histogram].
     pub fn create_histogram(
         &self,
         name: impl Into<Cow<'static, str>>,
     ) -> InstrumentBuilder<'_, Arc<dyn Histogram>> {
         InstrumentBuilder::new(self, name.into())
-+
+    }
-+
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/src/noop.rs

@@ -0,1 +0,107 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 //! An noop implementation of the Meter traits
-+
 use std::marker::PhantomData;
 use std::{fmt::Debug, sync::Arc};
-+
 use crate::instruments::{
     AsyncInstrumentBuilder, AsyncMeasure, Histogram, InstrumentBuilder, MonotonicCounter,
     ProvideInstrument, UpDownCounter,
 };
 use crate::{
     attributes::Attributes,
     context::Context,
     meter::{Meter, ProvideMeter},
 };
-+
 #[derive(Debug)]
 pub(crate) struct NoopMeterProvider;
 impl ProvideMeter for NoopMeterProvider {
     fn get_meter(&self, _scope: &'static str, _attributes: Option<&Attributes>) -> Meter {
         Meter::new(Arc::new(NoopMeter))
-+
+    }
-+
+}
-+
 #[derive(Debug)]
 pub(crate) struct NoopMeter;
 impl ProvideInstrument for NoopMeter {
     fn create_gauge(
         &self,
         _builder: AsyncInstrumentBuilder<'_, Arc<dyn AsyncMeasure<Value = f64>>, f64>,
     ) -> Arc<dyn AsyncMeasure<Value = f64>> {
         Arc::new(NoopAsyncMeasurement(PhantomData::<f64>))
-+
+    }
-+
     fn create_up_down_counter(
         &self,
         _builder: InstrumentBuilder<'_, Arc<dyn UpDownCounter>>,
     ) -> Arc<dyn UpDownCounter> {
         Arc::new(NoopUpDownCounter)
-+
+    }
-+
     fn create_async_up_down_counter(
         &self,
         _builder: AsyncInstrumentBuilder<'_, Arc<dyn AsyncMeasure<Value = i64>>, i64>,
     ) -> Arc<dyn AsyncMeasure<Value = i64>> {
         Arc::new(NoopAsyncMeasurement(PhantomData::<i64>))
-+
+    }
-+
     fn create_monotonic_counter(
         &self,
         _builder: InstrumentBuilder<'_, Arc<dyn MonotonicCounter>>,
     ) -> Arc<dyn MonotonicCounter> {
         Arc::new(NoopMonotonicCounter)
-+
+    }
-+
     fn create_async_monotonic_counter(
         &self,
         _builder: AsyncInstrumentBuilder<'_, Arc<dyn AsyncMeasure<Value = u64>>, u64>,
     ) -> Arc<dyn AsyncMeasure<Value = u64>> {
         Arc::new(NoopAsyncMeasurement(PhantomData::<u64>))
-+
+    }
-+
     fn create_histogram(
         &self,
         _builder: InstrumentBuilder<'_, Arc<dyn Histogram>>,
     ) -> Arc<dyn Histogram> {
         Arc::new(NoopHistogram)
-+
+    }
-+
+}
-+
 #[derive(Debug)]
 struct NoopAsyncMeasurement<T: Send + Sync + Debug>(PhantomData<T>);
 impl<T: Send + Sync + Debug> AsyncMeasure for NoopAsyncMeasurement<T> {
     type Value = T;
-+
     fn record(&self, _value: T, _attributes: Option<&Attributes>, _context: Option<&dyn Context>) {}
-+
     fn stop(&self) {}
-+
+}
-+
 #[derive(Debug)]
 struct NoopUpDownCounter;
 impl UpDownCounter for NoopUpDownCounter {
     fn add(&self, _value: i64, _attributes: Option<&Attributes>, _context: Option<&dyn Context>) {}
-+
+}
-+
 #[derive(Debug)]
 struct NoopMonotonicCounter;
 impl MonotonicCounter for NoopMonotonicCounter {
     fn add(&self, _value: u64, _attributes: Option<&Attributes>, _context: Option<&dyn Context>) {}
-+
+}
-+
 #[derive(Debug)]
 struct NoopHistogram;
 impl Histogram for NoopHistogram {
     fn record(
         &self,
         _value: f64,
         _attributes: Option<&Attributes>,
         _context: Option<&dyn Context>,
     ) {
-+
+    }
-+
+}

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-observability/src/provider.rs

@@ -0,1 +0,89 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-+
 //! Definitions of high level Telemetry Providers.
-+
 use std::sync::Arc;
-+
 use crate::{meter::ProvideMeter, noop::NoopMeterProvider};
-+
 /// A struct to hold the various types of telemetry providers.
 #[non_exhaustive]
 pub struct TelemetryProvider {
     meter_provider: Arc<dyn ProvideMeter + Send + Sync>,
-+
+}
-+
 impl TelemetryProvider {
     /// Returns a builder struct for [TelemetryProvider]
     pub fn builder() -> TelemetryProviderBuilder {
         TelemetryProviderBuilder {
             meter_provider: Arc::new(NoopMeterProvider),
-+
+        }
-+
+    }
-+
     /// Returns a noop [TelemetryProvider]
     pub fn noop() -> TelemetryProvider {
         Self {
             meter_provider: Arc::new(NoopMeterProvider),
-+
+        }
-+
+    }
-+
     /// Get the set [ProvideMeter]
     pub fn meter_provider(&self) -> &(dyn ProvideMeter + Send + Sync) {
         self.meter_provider.as_ref()
-+
+    }
-+
+}
-+
 // If we choose to expand our Telemetry provider and make Logging and Tracing
 // configurable at some point in the future we can do that by adding default
 // logger_provider and tracer_providers based on `tracing` to maintain backwards
 // compatibilty with what we have today.
 impl Default for TelemetryProvider {
     fn default() -> Self {
         Self {
             meter_provider: Arc::new(NoopMeterProvider),
-+
+        }
-+
+    }
-+
+}
-+
 /// A builder for [TelemetryProvider].
 #[non_exhaustive]
 pub struct TelemetryProviderBuilder {
     meter_provider: Arc<dyn ProvideMeter + Send + Sync>,
-+
+}
-+
 impl TelemetryProviderBuilder {
     /// Set the [ProvideMeter].
     pub fn meter_provider(mut self, meter_provider: Arc<impl ProvideMeter + 'static>) -> Self {
         self.meter_provider = meter_provider;
         self
-+
+    }
-+
     /// Build the [TelemetryProvider].
     pub fn build(self) -> TelemetryProvider {
         TelemetryProvider {
             meter_provider: self.meter_provider,
-+
+        }
-+
+    }
-+
+}
-+
 /// Wrapper type to hold a implementer of TelemetryProvider in an Arc so that
 /// it can be safely used across threads.
 #[non_exhaustive]
 pub(crate) struct GlobalTelemetryProvider {
     pub(crate) telemetry_provider: Arc<TelemetryProvider>,
-+
+}
-+
 impl GlobalTelemetryProvider {
     pub(crate) fn new(telemetry_provider: TelemetryProvider) -> Self {
         Self {
             telemetry_provider: Arc::new(telemetry_provider),
-+
+        }
-+
+    }
-+
     pub(crate) fn telemetry_provider(&self) -> &Arc<TelemetryProvider> {
         &self.telemetry_provider
-+
+    }
-+
+}

Pages: 1 2

1 +	`allowed_external_types = [`
2 +	`"aws_smithy_runtime_api::box_error::BoxError",`
3 +	`]`