aws_sdk_devopsguru/
lib.rs

1#![allow(deprecated)]
2#![allow(unknown_lints)]
3#![allow(clippy::module_inception)]
4#![allow(clippy::upper_case_acronyms)]
5#![allow(clippy::large_enum_variant)]
6#![allow(clippy::wrong_self_convention)]
7#![allow(clippy::should_implement_trait)]
8#![allow(clippy::disallowed_names)]
9#![allow(clippy::vec_init_then_push)]
10#![allow(clippy::type_complexity)]
11#![allow(clippy::needless_return)]
12#![allow(clippy::derive_partial_eq_without_eq)]
13#![allow(clippy::result_large_err)]
14#![allow(clippy::unnecessary_map_on_constructor)]
15#![allow(rustdoc::bare_urls)]
16#![allow(rustdoc::redundant_explicit_links)]
17#![allow(rustdoc::invalid_html_tags)]
18#![forbid(unsafe_code)]
19#![warn(missing_docs)]
20#![cfg_attr(docsrs, feature(doc_auto_cfg))]
21//! Amazon DevOps Guru is a fully managed service that helps you identify anomalous behavior in business critical operational applications. You specify the Amazon Web Services resources that you want DevOps Guru to cover, then the Amazon CloudWatch metrics and Amazon Web Services CloudTrail events related to those resources are analyzed. When anomalous behavior is detected, DevOps Guru creates an _insight_ that includes recommendations, related events, and related metrics that can help you improve your operational applications. For more information, see [What is Amazon DevOps Guru](https://docs.aws.amazon.com/devops-guru/latest/userguide/welcome.html).
22//!
23//! You can specify 1 or 2 Amazon Simple Notification Service topics so you are notified every time a new insight is created. You can also enable DevOps Guru to generate an OpsItem in Amazon Web Services Systems Manager for each insight to help you manage and track your work addressing insights.
24//!
25//! To learn about the DevOps Guru workflow, see [How DevOps Guru works](https://docs.aws.amazon.com/devops-guru/latest/userguide/welcome.html#how-it-works). To learn about DevOps Guru concepts, see [Concepts in DevOps Guru](https://docs.aws.amazon.com/devops-guru/latest/userguide/concepts.html).
26//!
27//! ## Getting Started
28//!
29//! > Examples are available for many services and operations, check out the
30//! > [examples folder in GitHub](https://github.com/awslabs/aws-sdk-rust/tree/main/examples).
31//!
32//! The SDK provides one crate per AWS service. You must add [Tokio](https://crates.io/crates/tokio)
33//! as a dependency within your Rust project to execute asynchronous code. To add `aws-sdk-devopsguru` to
34//! your project, add the following to your **Cargo.toml** file:
35//!
36//! ```toml
37//! [dependencies]
38//! aws-config = { version = "1.1.7", features = ["behavior-version-latest"] }
39//! aws-sdk-devopsguru = "1.74.0"
40//! tokio = { version = "1", features = ["full"] }
41//! ```
42//!
43//! Then in code, a client can be created with the following:
44//!
45//! ```rust,no_run
46//! use aws_sdk_devopsguru as devopsguru;
47//!
48//! #[::tokio::main]
49//! async fn main() -> Result<(), devopsguru::Error> {
50//!     let config = aws_config::load_from_env().await;
51//!     let client = aws_sdk_devopsguru::Client::new(&config);
52//!
53//!     // ... make some calls with the client
54//!
55//!     Ok(())
56//! }
57//! ```
58//!
59//! See the [client documentation](https://docs.rs/aws-sdk-devopsguru/latest/aws_sdk_devopsguru/client/struct.Client.html)
60//! for information on what calls can be made, and the inputs and outputs for each of those calls.
61//!
62//! ## Using the SDK
63//!
64//! Until the SDK is released, we will be adding information about using the SDK to the
65//! [Developer Guide](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/welcome.html). Feel free to suggest
66//! additional sections for the guide by opening an issue and describing what you are trying to do.
67//!
68//! ## Getting Help
69//!
70//! * [GitHub discussions](https://github.com/awslabs/aws-sdk-rust/discussions) - For ideas, RFCs & general questions
71//! * [GitHub issues](https://github.com/awslabs/aws-sdk-rust/issues/new/choose) - For bug reports & feature requests
72//! * [Generated Docs (latest version)](https://awslabs.github.io/aws-sdk-rust/)
73//! * [Usage examples](https://github.com/awslabs/aws-sdk-rust/tree/main/examples)
74//!
75//!
76//! # Crate Organization
77//!
78//! The entry point for most customers will be [`Client`], which exposes one method for each API
79//! offered by Amazon DevOps Guru. The return value of each of these methods is a "fluent builder",
80//! where the different inputs for that API are added by builder-style function call chaining,
81//! followed by calling `send()` to get a [`Future`](std::future::Future) that will result in
82//! either a successful output or a [`SdkError`](crate::error::SdkError).
83//!
84//! Some of these API inputs may be structs or enums to provide more complex structured information.
85//! These structs and enums live in [`types`](crate::types). There are some simpler types for
86//! representing data such as date times or binary blobs that live in [`primitives`](crate::primitives).
87//!
88//! All types required to configure a client via the [`Config`](crate::Config) struct live
89//! in [`config`](crate::config).
90//!
91//! The [`operation`](crate::operation) module has a submodule for every API, and in each submodule
92//! is the input, output, and error type for that API, as well as builders to construct each of those.
93//!
94//! There is a top-level [`Error`](crate::Error) type that encompasses all the errors that the
95//! client can return. Any other error type can be converted to this `Error` type via the
96//! [`From`](std::convert::From) trait.
97//!
98//! The other modules within this crate are not required for normal usage.
99
100// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
101pub use error_meta::Error;
102
103#[doc(inline)]
104pub use config::Config;
105
106/// Client for calling Amazon DevOps Guru.
107/// ## Constructing a `Client`
108///
109/// A [`Config`] is required to construct a client. For most use cases, the [`aws-config`]
110/// crate should be used to automatically resolve this config using
111/// [`aws_config::load_from_env()`], since this will resolve an [`SdkConfig`] which can be shared
112/// across multiple different AWS SDK clients. This config resolution process can be customized
113/// by calling [`aws_config::from_env()`] instead, which returns a [`ConfigLoader`] that uses
114/// the [builder pattern] to customize the default config.
115///
116/// In the simplest case, creating a client looks as follows:
117/// ```rust,no_run
118/// # async fn wrapper() {
119/// let config = aws_config::load_from_env().await;
120/// let client = aws_sdk_devopsguru::Client::new(&config);
121/// # }
122/// ```
123///
124/// Occasionally, SDKs may have additional service-specific values that can be set on the [`Config`] that
125/// is absent from [`SdkConfig`], or slightly different settings for a specific client may be desired.
126/// The [`Builder`](crate::config::Builder) struct implements `From<&SdkConfig>`, so setting these specific settings can be
127/// done as follows:
128///
129/// ```rust,no_run
130/// # async fn wrapper() {
131/// let sdk_config = ::aws_config::load_from_env().await;
132/// let config = aws_sdk_devopsguru::config::Builder::from(&sdk_config)
133/// # /*
134///     .some_service_specific_setting("value")
135/// # */
136///     .build();
137/// # }
138/// ```
139///
140/// See the [`aws-config` docs] and [`Config`] for more information on customizing configuration.
141///
142/// _Note:_ Client construction is expensive due to connection thread pool initialization, and should
143/// be done once at application start-up.
144///
145/// [`Config`]: crate::Config
146/// [`ConfigLoader`]: https://docs.rs/aws-config/*/aws_config/struct.ConfigLoader.html
147/// [`SdkConfig`]: https://docs.rs/aws-config/*/aws_config/struct.SdkConfig.html
148/// [`aws-config` docs]: https://docs.rs/aws-config/*
149/// [`aws-config`]: https://crates.io/crates/aws-config
150/// [`aws_config::from_env()`]: https://docs.rs/aws-config/*/aws_config/fn.from_env.html
151/// [`aws_config::load_from_env()`]: https://docs.rs/aws-config/*/aws_config/fn.load_from_env.html
152/// [builder pattern]: https://rust-lang.github.io/api-guidelines/type-safety.html#builders-enable-construction-of-complex-values-c-builder
153/// # Using the `Client`
154///
155/// A client has a function for every operation that can be performed by the service.
156/// For example, the [`DeleteInsight`](crate::operation::delete_insight) operation has
157/// a [`Client::delete_insight`], function which returns a builder for that operation.
158/// The fluent builder ultimately has a `send()` function that returns an async future that
159/// returns a result, as illustrated below:
160///
161/// ```rust,ignore
162/// let result = client.delete_insight()
163///     .id("example")
164///     .send()
165///     .await;
166/// ```
167///
168/// The underlying HTTP requests that get made by this can be modified with the `customize_operation`
169/// function on the fluent builder. See the [`customize`](crate::client::customize) module for more
170/// information.
171pub mod client;
172
173/// Configuration for Amazon DevOps Guru.
174pub mod config;
175
176/// Common errors and error handling utilities.
177pub mod error;
178
179mod error_meta;
180
181/// Information about this crate.
182pub mod meta;
183
184/// All operations that this crate can perform.
185pub mod operation;
186
187/// Primitives such as `Blob` or `DateTime` used by other types.
188pub mod primitives;
189
190/// Data structures used by operation inputs/outputs.
191pub mod types;
192
193mod auth_plugin;
194
195pub(crate) mod client_idempotency_token;
196
197mod idempotency_token;
198
199pub(crate) mod protocol_serde;
200
201mod sdk_feature_tracker;
202
203mod serialization_settings;
204
205mod endpoint_lib;
206
207mod lens;
208
209mod serde_util;
210
211mod json_errors;
212
213#[doc(inline)]
214pub use client::Client;