aws_sdk_networkflowmonitor/
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//! Network Flow Monitor is a feature of Amazon CloudWatch Network Monitoring that provides visibility into the performance of network flows for your Amazon Web Services workloads, between instances in subnets, as well as to and from Amazon Web Services. Lightweight agents that you install on the instances capture performance metrics for your network flows, such as packet loss and latency, and send them to the Network Flow Monitor backend. Then, you can view and analyze metrics from the top contributors for each metric type, to help troubleshoot issues.
22//!
23//! In addition, when you create a monitor, Network Flow Monitor provides a network health indicator (NHI) that informs you whether there were Amazon Web Services network issues for one or more of the network flows tracked by a monitor, during a time period that you choose. By using this value, you can independently determine if the Amazon Web Services network is impacting your workload during a specific time frame, to help you focus troubleshooting efforts.
24//!
25//! To learn more about Network Flow Monitor, see the [Network Flow Monitor User Guide](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-NetworkFlowMonitor.html) in the Amazon CloudWatch User Guide.
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-networkflowmonitor` 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-networkflowmonitor = "1.27.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_networkflowmonitor as networkflowmonitor;
47//!
48//! #[::tokio::main]
49//! async fn main() -> Result<(), networkflowmonitor::Error> {
50//!     let config = aws_config::load_from_env().await;
51//!     let client = aws_sdk_networkflowmonitor::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-networkflowmonitor/latest/aws_sdk_networkflowmonitor/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 Network Flow Monitor. 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 Network Flow Monitor.
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_networkflowmonitor::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_networkflowmonitor::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 [`CreateMonitor`](crate::operation::create_monitor) operation has
157/// a [`Client::create_monitor`], 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.create_monitor()
163///     .monitor_name("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 Network Flow Monitor.
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;