Skip to main content

aws_sdk_observabilityadmin/operation/
list_telemetry_rules.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2/// Orchestration and serialization glue logic for `ListTelemetryRules`.
3#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
4#[non_exhaustive]
5pub struct ListTelemetryRules;
6impl ListTelemetryRules {
7    /// Creates a new `ListTelemetryRules`
8    pub fn new() -> Self {
9        Self
10    }
11    pub(crate) async fn orchestrate(
12        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
13        input: crate::operation::list_telemetry_rules::ListTelemetryRulesInput,
14    ) -> ::std::result::Result<
15        crate::operation::list_telemetry_rules::ListTelemetryRulesOutput,
16        ::aws_smithy_runtime_api::client::result::SdkError<
17            crate::operation::list_telemetry_rules::ListTelemetryRulesError,
18            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
19        >,
20    > {
21        let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
22            ::aws_smithy_runtime_api::client::interceptors::context::Error,
23            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
24        >| {
25            err.map_service_error(|err| {
26                err.downcast::<crate::operation::list_telemetry_rules::ListTelemetryRulesError>()
27                    .expect("correct error type")
28            })
29        };
30        let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
31            .await
32            .map_err(map_err)?;
33        let output = context.finalize().map_err(map_err)?;
34        ::std::result::Result::Ok(
35            output
36                .downcast::<crate::operation::list_telemetry_rules::ListTelemetryRulesOutput>()
37                .expect("correct output type"),
38        )
39    }
40
41    pub(crate) async fn orchestrate_with_stop_point(
42        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
43        input: crate::operation::list_telemetry_rules::ListTelemetryRulesInput,
44        stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,
45    ) -> ::std::result::Result<
46        ::aws_smithy_runtime_api::client::interceptors::context::InterceptorContext,
47        ::aws_smithy_runtime_api::client::result::SdkError<
48            ::aws_smithy_runtime_api::client::interceptors::context::Error,
49            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
50        >,
51    > {
52        let input = ::aws_smithy_runtime_api::client::interceptors::context::Input::erase(input);
53        use ::tracing::Instrument;
54        ::aws_smithy_runtime::client::orchestrator::invoke_with_stop_point(
55            "ObservabilityAdmin",
56            "ListTelemetryRules",
57            input,
58            runtime_plugins,
59            stop_point,
60        )
61        // Create a parent span for the entire operation. Includes a random, internal-only,
62        // seven-digit ID for the operation orchestration so that it can be correlated in the logs.
63        .instrument(::tracing::debug_span!(
64            "ObservabilityAdmin.ListTelemetryRules",
65            "rpc.service" = "ObservabilityAdmin",
66            "rpc.method" = "ListTelemetryRules",
67            "sdk_invocation_id" = ::fastrand::u32(1_000_000..10_000_000),
68            "rpc.system" = "aws-api",
69        ))
70        .await
71    }
72
73    pub(crate) fn operation_runtime_plugins(
74        client_runtime_plugins: ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
75        client_config: &crate::config::Config,
76        config_override: ::std::option::Option<crate::config::Builder>,
77    ) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
78        let mut runtime_plugins = client_runtime_plugins.with_operation_plugin(Self::new());
79
80        if let ::std::option::Option::Some(config_override) = config_override {
81            for plugin in config_override.runtime_plugins.iter().cloned() {
82                runtime_plugins = runtime_plugins.with_operation_plugin(plugin);
83            }
84            runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(
85                config_override,
86                client_config.config.clone(),
87                &client_config.runtime_components,
88            ));
89        }
90        runtime_plugins
91    }
92}
93impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ListTelemetryRules {
94    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
95        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("ListTelemetryRules");
96
97        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
98            ListTelemetryRulesRequestSerializer,
99        ));
100        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
101            ListTelemetryRulesResponseDeserializer,
102        ));
103
104        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
105            crate::config::auth::Params::builder()
106                .operation_name("ListTelemetryRules")
107                .build()
108                .expect("required fields set"),
109        ));
110
111        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
112            "ListTelemetryRules",
113            "ObservabilityAdmin",
114        ));
115        let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
116        signing_options.double_uri_encode = true;
117        signing_options.content_sha256_header = false;
118        signing_options.normalize_uri_path = true;
119        signing_options.payload_override = None;
120
121        cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
122            signing_options,
123            ..::std::default::Default::default()
124        });
125
126        ::std::option::Option::Some(cfg.freeze())
127    }
128
129    fn runtime_components(
130        &self,
131        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
132    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
133        #[allow(unused_mut)]
134        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ListTelemetryRules")
135            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
136                ListTelemetryRulesTelemetryInputCaptureInterceptor,
137            ))
138            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
139                ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
140            ))
141            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
142                ListTelemetryRulesEndpointParamsInterceptor,
143            ))
144            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
145                crate::operation::list_telemetry_rules::ListTelemetryRulesError,
146            >::new())
147            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
148                crate::operation::list_telemetry_rules::ListTelemetryRulesError,
149            >::new())
150            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
151                crate::operation::list_telemetry_rules::ListTelemetryRulesError,
152            >::new())
153            .with_retry_classifier(::aws_runtime::service_clock_skew::ServiceClockSkewClassifier::<
154                crate::operation::list_telemetry_rules::ListTelemetryRulesError,
155            >::new());
156
157        ::std::borrow::Cow::Owned(rcb)
158    }
159}
160
161#[derive(Debug)]
162struct ListTelemetryRulesTelemetryInputCaptureInterceptor;
163
164#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
165impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListTelemetryRulesTelemetryInputCaptureInterceptor {
166    fn name(&self) -> &'static str {
167        "ListTelemetryRulesTelemetryInputCaptureInterceptor"
168    }
169
170    fn read_before_execution(
171        &self,
172        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
173            '_,
174            ::aws_smithy_runtime_api::client::interceptors::context::Input,
175            ::aws_smithy_runtime_api::client::interceptors::context::Output,
176            ::aws_smithy_runtime_api::client::interceptors::context::Error,
177        >,
178        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
179    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
180        // Nothing to do unless the customer opted in by naming members to record.
181        let ::std::option::Option::Some(requested) = cfg
182            .load::<::aws_smithy_types::telemetry::RequestedTelemetryAttributes>()
183            .filter(|r| !r.is_empty())
184        else {
185            return ::std::result::Result::Ok(());
186        };
187
188        let ::std::option::Option::Some(input) = context.input().downcast_ref::<ListTelemetryRulesInput>() else {
189            // A mismatched input is not this interceptor's concern; skip quietly.
190            return ::std::result::Result::Ok(());
191        };
192
193        let mut captured = ::aws_smithy_types::telemetry::CapturedTelemetryAttributes::default();
194        if requested.should_capture("RuleNamePrefix") {
195            if let ::std::option::Option::Some(value) = input.rule_name_prefix.as_deref() {
196                captured.insert("RuleNamePrefix", value);
197            }
198        }
199        if requested.should_capture("NextToken") {
200            if let ::std::option::Option::Some(value) = input.next_token.as_deref() {
201                captured.insert("NextToken", value);
202            }
203        }
204
205        cfg.interceptor_state().store_put(captured);
206        ::std::result::Result::Ok(())
207    }
208}
209#[derive(Debug)]
210struct ListTelemetryRulesResponseDeserializer;
211impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListTelemetryRulesResponseDeserializer {
212    fn deserialize_nonstreaming_with_config(
213        &self,
214        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
215        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
216    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
217        let (success, status) = (response.status().is_success(), response.status().as_u16());
218        let headers = response.headers();
219        let body = response.body().bytes().expect("body loaded");
220        #[allow(unused_mut)]
221        let mut force_error = false;
222        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
223        let parse_result = if !success && status != 200 || force_error {
224            crate::protocol_serde::shape_list_telemetry_rules::de_list_telemetry_rules_http_error(status, headers, body)
225        } else {
226            crate::protocol_serde::shape_list_telemetry_rules::de_list_telemetry_rules_http_response(status, headers, body)
227        };
228        crate::protocol_serde::type_erase_result(parse_result)
229    }
230}
231#[derive(Debug)]
232struct ListTelemetryRulesRequestSerializer;
233impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListTelemetryRulesRequestSerializer {
234    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
235    fn serialize_input(
236        &self,
237        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
238        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
239    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
240        let input = input
241            .downcast::<crate::operation::list_telemetry_rules::ListTelemetryRulesInput>()
242            .expect("correct type");
243        let _header_serialization_settings = _cfg
244            .load::<crate::serialization_settings::HeaderSerializationSettings>()
245            .cloned()
246            .unwrap_or_default();
247        let mut request_builder = {
248            #[allow(clippy::uninlined_format_args)]
249            fn uri_base(
250                _input: &crate::operation::list_telemetry_rules::ListTelemetryRulesInput,
251                output: &mut ::std::string::String,
252            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
253                use ::std::fmt::Write as _;
254                ::std::write!(output, "/ListTelemetryRules").expect("formatting should succeed");
255                ::std::result::Result::Ok(())
256            }
257            #[allow(clippy::unnecessary_wraps)]
258            fn update_http_builder(
259                input: &crate::operation::list_telemetry_rules::ListTelemetryRulesInput,
260                builder: ::http_1x::request::Builder,
261            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
262                let mut uri = ::std::string::String::new();
263                uri_base(input, &mut uri)?;
264                ::std::result::Result::Ok(builder.method("POST").uri(uri))
265            }
266            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
267            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
268            builder
269        };
270        let body =
271            ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_list_telemetry_rules::ser_list_telemetry_rules_input(&input)?);
272        if let Some(content_length) = body.content_length() {
273            let content_length = content_length.to_string();
274            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
275        }
276        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
277    }
278}
279#[derive(Debug)]
280struct ListTelemetryRulesEndpointParamsInterceptor;
281
282#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
283impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListTelemetryRulesEndpointParamsInterceptor {
284    fn name(&self) -> &'static str {
285        "ListTelemetryRulesEndpointParamsInterceptor"
286    }
287
288    fn read_before_execution(
289        &self,
290        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
291            '_,
292            ::aws_smithy_runtime_api::client::interceptors::context::Input,
293            ::aws_smithy_runtime_api::client::interceptors::context::Output,
294            ::aws_smithy_runtime_api::client::interceptors::context::Error,
295        >,
296        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
297    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
298        let _input = context
299            .input()
300            .downcast_ref::<ListTelemetryRulesInput>()
301            .ok_or("failed to downcast to ListTelemetryRulesInput")?;
302
303        let params = crate::config::endpoint::Params::builder()
304            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
305            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
306            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
307            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
308            .build()
309            .map_err(|err| {
310                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
311            })?;
312        cfg.interceptor_state()
313            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
314        ::std::result::Result::Ok(())
315    }
316}
317
318// The get_* functions below are generated from JMESPath expressions in the
319// operationContextParams trait. They target the operation's input shape.
320
321/// Error type for the `ListTelemetryRulesError` operation.
322#[non_exhaustive]
323#[derive(::std::fmt::Debug)]
324pub enum ListTelemetryRulesError {
325    /// <p>Indicates you don't have permissions to perform the requested operation. The user or role that is making the request must have at least one IAM permissions policy attached that grants the required permissions. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html">Access management for Amazon Web Services resources</a> in the IAM user guide.</p>
326    AccessDeniedException(crate::types::error::AccessDeniedException),
327    /// <p>Indicates the request has failed to process because of an unknown server error, exception, or failure.</p>
328    InternalServerException(crate::types::error::InternalServerException),
329    /// <p>The request throughput limit was exceeded.</p>
330    TooManyRequestsException(crate::types::error::TooManyRequestsException),
331    /// <p>Indicates input validation failed. Check your request parameters and retry the request.</p>
332    ValidationException(crate::types::error::ValidationException),
333    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
334    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
335    variable wildcard pattern and check `.code()`:
336     \
337    &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
338     \
339    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-ListTelemetryRulesError) for what information is available for the error.")]
340    Unhandled(crate::error::sealed_unhandled::Unhandled),
341}
342impl ListTelemetryRulesError {
343    /// Creates the `ListTelemetryRulesError::Unhandled` variant from any error type.
344    pub fn unhandled(
345        err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
346    ) -> Self {
347        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
348            source: err.into(),
349            meta: ::std::default::Default::default(),
350        })
351    }
352
353    /// Creates the `ListTelemetryRulesError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).
354    pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
355        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
356            source: err.clone().into(),
357            meta: err,
358        })
359    }
360    ///
361    /// Returns error metadata, which includes the error code, message,
362    /// request ID, and potentially additional information.
363    ///
364    pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
365        match self {
366            Self::AccessDeniedException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
367            Self::InternalServerException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
368            Self::TooManyRequestsException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
369            Self::ValidationException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
370            Self::Unhandled(e) => &e.meta,
371        }
372    }
373    /// Returns `true` if the error kind is `ListTelemetryRulesError::AccessDeniedException`.
374    pub fn is_access_denied_exception(&self) -> bool {
375        matches!(self, Self::AccessDeniedException(_))
376    }
377    /// Returns `true` if the error kind is `ListTelemetryRulesError::InternalServerException`.
378    pub fn is_internal_server_exception(&self) -> bool {
379        matches!(self, Self::InternalServerException(_))
380    }
381    /// Returns `true` if the error kind is `ListTelemetryRulesError::TooManyRequestsException`.
382    pub fn is_too_many_requests_exception(&self) -> bool {
383        matches!(self, Self::TooManyRequestsException(_))
384    }
385    /// Returns `true` if the error kind is `ListTelemetryRulesError::ValidationException`.
386    pub fn is_validation_exception(&self) -> bool {
387        matches!(self, Self::ValidationException(_))
388    }
389}
390impl ::std::error::Error for ListTelemetryRulesError {
391    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
392        match self {
393            Self::AccessDeniedException(_inner) => ::std::option::Option::Some(_inner),
394            Self::InternalServerException(_inner) => ::std::option::Option::Some(_inner),
395            Self::TooManyRequestsException(_inner) => ::std::option::Option::Some(_inner),
396            Self::ValidationException(_inner) => ::std::option::Option::Some(_inner),
397            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
398        }
399    }
400}
401impl ::std::fmt::Display for ListTelemetryRulesError {
402    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
403        match self {
404            Self::AccessDeniedException(_inner) => _inner.fmt(f),
405            Self::InternalServerException(_inner) => _inner.fmt(f),
406            Self::TooManyRequestsException(_inner) => _inner.fmt(f),
407            Self::ValidationException(_inner) => _inner.fmt(f),
408            Self::Unhandled(_inner) => {
409                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
410                    write!(f, "unhandled error ({code})")
411                } else {
412                    f.write_str("unhandled error")
413                }
414            }
415        }
416    }
417}
418impl ::aws_smithy_types::retry::ProvideErrorKind for ListTelemetryRulesError {
419    fn code(&self) -> ::std::option::Option<&str> {
420        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
421    }
422    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
423        ::std::option::Option::None
424    }
425}
426impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for ListTelemetryRulesError {
427    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
428        match self {
429            Self::AccessDeniedException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
430            Self::InternalServerException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
431            Self::TooManyRequestsException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
432            Self::ValidationException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
433            Self::Unhandled(_inner) => &_inner.meta,
434        }
435    }
436}
437impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for ListTelemetryRulesError {
438    fn create_unhandled_error(
439        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
440        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
441    ) -> Self {
442        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
443            source,
444            meta: meta.unwrap_or_default(),
445        })
446    }
447}
448impl ::aws_types::request_id::RequestId for crate::operation::list_telemetry_rules::ListTelemetryRulesError {
449    fn request_id(&self) -> Option<&str> {
450        self.meta().request_id()
451    }
452}
453
454pub use crate::operation::list_telemetry_rules::_list_telemetry_rules_input::ListTelemetryRulesInput;
455
456pub use crate::operation::list_telemetry_rules::_list_telemetry_rules_output::ListTelemetryRulesOutput;
457
458mod _list_telemetry_rules_input;
459
460mod _list_telemetry_rules_output;
461
462/// Builders
463pub mod builders;
464
465/// Paginator for this operation
466pub mod paginator;