Crate google_monitoring3 [−] [src]

This documentation was generated from Monitoring crate version 1.0.4+20161212, where 20161212 is the exact revision of the monitoring:v3 schema built by the mako code generator v1.0.4.

Everything else about the Monitoring v3 API can be found at the official documentation site. The original source code is on github.

Features

Handle the following Resources with ease from the central hub ...

projects
- collectd time series create, groups create, groups delete, groups get, groups list, groups members list, groups update, metric descriptors create, metric descriptors delete, metric descriptors get, metric descriptors list, monitored resource descriptors get, monitored resource descriptors list, time series create and time series list

Not what you are looking for ? Find all other Google APIs in their Rust documentation index.

Structure of this Library

The API is structured into the following primary items:

Hub
- a central object to maintain state and allow accessing all Activities
- creates Method Builders which in turn allow access to individual Call Builders
Resources
- primary types that you can apply Activities to
- a collection of properties and Parts
- Parts
  - a collection of properties
  - never directly used in Activities
Activities
- operations to apply to Resources

All structures are marked with applicable traits to further categorize them and ease browsing.

Generally speaking, you can invoke Activities like this:

let r = hub.resource().activity(...).doit()

Or specifically ...

let r = hub.projects().metric_descriptors_delete(...).doit()
let r = hub.projects().time_series_create(...).doit()
let r = hub.projects().collectd_time_series_create(...).doit()
let r = hub.projects().groups_delete(...).doit()

The resource() and activity(...) calls create builders. The second one dealing with Activities supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be specified right away (i.e. (...)), whereas all optional ones can be build up as desired. The doit() method performs the actual communication with the server and returns the respective result.

Usage

Setting up your Project

To use this library, you would put the following lines into your Cargo.toml file:

[dependencies]
google-monitoring3 = "*"

A complete example

extern crate hyper;
extern crate yup_oauth2 as oauth2;
extern crate google_monitoring3 as monitoring3;
use monitoring3::CreateTimeSeriesRequest;
use monitoring3::{Result, Error};
use std::default::Default;
use oauth2::{Authenticator, DefaultAuthenticatorDelegate, ApplicationSecret, MemoryStorage};
use monitoring3::Monitoring;
 
// Get an ApplicationSecret instance by some means. It contains the `client_id` and 
// `client_secret`, among other things.
let secret: ApplicationSecret = Default::default();
// Instantiate the authenticator. It will choose a suitable authentication flow for you, 
// unless you replace  `None` with the desired Flow.
// Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about 
// what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and
// retrieve them from storage.
let auth = Authenticator::new(&secret, DefaultAuthenticatorDelegate,
                              hyper::Client::new(),
                              <MemoryStorage as Default>::default(), None);
let mut hub = Monitoring::new(hyper::Client::new(), auth);
// As the method needs a request, you would usually fill it with the desired information
// into the respective structure. Some of the parts shown here might not be applicable !
// Values shown here are possibly random and not representative !
let mut req = CreateTimeSeriesRequest::default();
 
// You can configure optional parameters by calling the respective setters at will, and
// execute the final call using `doit()`.
// Values shown here are possibly random and not representative !
let result = hub.projects().time_series_create(req, "name")
             .doit();
 
match result {
    Err(e) => match e {
        // The Error enum provides details about what exactly happened.
        // You can also just use its `Debug`, `Display` or `Error` traits
         Error::HttpError(_)
        |Error::MissingAPIKey
        |Error::MissingToken(_)
        |Error::Cancelled
        |Error::UploadSizeLimitExceeded(_, _)
        |Error::Failure(_)
        |Error::BadRequest(_)
        |Error::FieldClash(_)
        |Error::JsonDecodeError(_, _) => println!("{}", e),
    },
    Ok(res) => println!("Success: {:?}", res),
}

Handling Errors

All errors produced by the system are provided either as Result enumeration as return value of the doit() methods, or handed as possibly intermediate results to either the Hub Delegate, or the Authenticator Delegate.

When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This makes the system potentially resilient to all kinds of errors.

Uploads and Downloads

If a method supports downloads, the response body, which is part of the Result, should be read by you to obtain the media. If such a method also supports a Response Result, it will return that by default. You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making this call: .param("alt", "media").

Methods supporting uploads can do so using up to 2 different protocols: simple and resumable. The distinctiveness of each is represented by customized doit(...) methods, which are then named upload(...) and upload_resumable(...) respectively.

Customization and Callbacks

You may alter the way an doit() method is called by providing a delegate to the Method Builder before making the final doit() call. Respective methods will be called to provide progress information, as well as determine whether the system should retry on failure.

The delegate trait is default-implemented, allowing you to customize it with minimal effort.

Optional Parts in Server-Requests

All structures provided by this library are made to be enocodable and decodable via json. Optionals are used to indicate that partial requests are responses are valid. Most optionals are are considered Parts which are identifiable by name, which will be sent to the server to indicate either the set parts of the request or the desired parts in the response.

Builder Arguments

Using method builders, you are able to prepare an action call by repeatedly calling it's methods. These will always take a single argument, for which the following statements are true.

PODs are handed by copy
strings are passed as &str
request values are moved

Arguments will always be copied or cloned into the builder, to make them independent of their original life times.

Structs

BucketOptions	A Distribution may optionally contain a histogram of the values in the population. The histogram is given in bucket_counts as counts of values that fall into one of a sequence of non-overlapping buckets. The sequence of buckets is described by bucket_options.A bucket specifies an inclusive lower bound and exclusive upper bound for the values that are counted for that bucket. The upper bound of a bucket is strictly greater than the lower bound.The sequence of N buckets for a Distribution consists of an underflow bucket (number 0), zero or more finite buckets (number 1 through N - 2) and an overflow bucket (number N - 1). The buckets are contiguous: the lower bound of bucket i (i > 0) is the same as the upper bound of bucket i - 1. The buckets span the whole range of finite values: lower bound of the underflow bucket is -infinity and the upper bound of the overflow bucket is +infinity. The finite buckets are so-called because both bounds are finite.BucketOptions describes bucket boundaries in one of three ways. Two describe the boundaries by giving parameters for a formula to generate boundaries and one gives the bucket boundaries explicitly.If bucket_options is not given, then no bucket_counts may be given.
CollectdPayload	A collection of data points sent from a collectd-based plugin. See the collectd documentation for more information.
CollectdValue	A single data point from a collectd-based plugin.
CreateCollectdTimeSeriesRequest	The CreateCollectdTimeSeries request.
CreateTimeSeriesRequest	The CreateTimeSeries request.
DefaultDelegate	A delegate with a conservative default implementation, which is used if no other delegate is set.
Distribution	Distribution contains summary statistics for a population of values and, optionally, a histogram representing the distribution of those values across a specified set of histogram buckets.The summary statistics are the count, mean, sum of the squared deviation from the mean, the minimum, and the maximum of the set of population of values.The histogram is based on a sequence of buckets and gives a count of values that fall into each bucket. The boundaries of the buckets are given either explicitly or by specifying parameters for a method of computing them (buckets of fixed width or buckets of exponentially increasing width).Although it is not forbidden, it is generally a bad idea to include non-finite values (infinities or NaNs) in the population of values, as this will render the mean and sum_of_squared_deviation fields meaningless.
Empty	A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON representation for Empty is empty JSON object {}.
ErrorResponse	A utility to represent detailed errors we might see in case there are BadRequests. The latter happen if the sent parameters or request structures are unsound
Explicit	A set of buckets with arbitrary widths.Defines size(bounds) + 1 (= N) buckets with these boundaries for bucket i:Upper bound (0 <= i < N-1): boundsi Lower bound (1 <= i < N); boundsi - 1There must be at least one element in bounds. If bounds has only one element, there are no finite buckets, and that single element is the common boundary of the overflow and underflow buckets.
Exponential	Specify a sequence of buckets that have a width that is proportional to the value of the lower bound. Each bucket represents a constant relative uncertainty on a specific value in the bucket.Defines num_finite_buckets + 2 (= N) buckets with these boundaries for bucket i:Upper bound (0 <= i < N-1): scale * (growth_factor ^ i). Lower bound (1 <= i < N): scale * (growth_factor ^ (i - 1)).
Group	The description of a dynamic collection of monitored resources. Each group has a filter that is matched against monitored resources and their associated metadata. If a group's filter matches an available monitored resource, then that resource is a member of that group. Groups can contain any number of monitored resources, and each monitored resource can be a member of any number of groups.Groups can be nested in parent-child hierarchies. The parentName field identifies an optional parent for each group. If a group has a parent, then the only monitored resources available to be matched by the group's filter are the resources contained in the parent group. In other words, a group contains the monitored resources that match its filter and the filters of all the group's ancestors. A group without a parent can contain any monitored resource.For example, consider an infrastructure running a set of instances with two user-defined tags: "environment" and "role". A parent group has a filter, environment="production". A child of that parent group has a filter, role="transcoder". The parent group contains all instances in the production environment, regardless of their roles. The child group contains instances that have the transcoder role and are in the production environment.The monitored resources contained in a group can change at any moment, depending on what resources exist and what filters are associated with the group and its ancestors.
LabelDescriptor	A description of a label.
Linear	Specify a sequence of buckets that all have the same width (except overflow and underflow). Each bucket represents a constant absolute uncertainty on the specific value in the bucket.Defines num_finite_buckets + 2 (= N) buckets with these boundaries for bucket i:Upper bound (0 <= i < N-1): offset + (width * i). Lower bound (1 <= i < N): offset + (width * (i - 1)).
ListGroupMembersResponse	The ListGroupMembers response.
ListGroupsResponse	The ListGroups response.
ListMetricDescriptorsResponse	The ListMetricDescriptors response.
ListMonitoredResourceDescriptorsResponse	The ListMonitoredResourcDescriptors response.
ListTimeSeriesResponse	The ListTimeSeries response.
MethodInfo	Contains information about an API request.
Metric	A specific metric, identified by specifying values for all of the labels of a MetricDescriptor.
MetricDescriptor	Defines a metric type and its schema. Once a metric descriptor is created, deleting or altering it stops data collection and makes the metric type's existing data unusable.
MonitoredResource	An object representing a resource that can be used for monitoring, logging, billing, or other purposes. Examples include virtual machine instances, databases, and storage devices such as disks. The type field identifies a MonitoredResourceDescriptor object that describes the resource's schema. Information in the labels field identifies the actual resource and its attributes according to the schema. For example, a particular Compute Engine VM instance could be represented by the following object, because the MonitoredResourceDescriptor for "gce_instance" has labels "instance_id" and "zone": { "type": "gce_instance", "labels": { "instance_id": "12345678901234", "zone": "us-central1-a" }}
MonitoredResourceDescriptor	An object that describes the schema of a MonitoredResource object using a type name and a set of labels. For example, the monitored resource descriptor for Google Compute Engine VM instances has a type of "gce_instance" and specifies the use of the labels "instance_id" and "zone" to identify particular VM instances.Different APIs can support different monitored resource types. APIs generally provide a list method that returns the monitored resource descriptors used by the API.
Monitoring	Central instance to access all Monitoring related resource activities
MultiPartReader	Provides a `Read` interface that converts multiple parts into the protocol identified by RFC2387. Note: This implementation is just as rich as it needs to be to perform uploads to google APIs, and might not be a fully-featured implementation.
Point	A single data point in a time series.
ProjectCollectdTimeSeryCreateCall	Stackdriver Monitoring Agent only: Creates a new time series. This method is only for use by the Stackdriver Monitoring Agent. Use projects.timeSeries.create instead.
ProjectGroupCreateCall	Creates a new group.
ProjectGroupDeleteCall	Deletes an existing group.
ProjectGroupGetCall	Gets a single group.
ProjectGroupListCall	Lists the existing groups.
ProjectGroupMemberListCall	Lists the monitored resources that are members of a group.
ProjectGroupUpdateCall	Updates an existing group. You can change any group attributes except name.
ProjectMethods	A builder providing access to all methods supported on project resources. It is not used directly, but through the `Monitoring` hub.
ProjectMetricDescriptorCreateCall	Creates a new metric descriptor. User-created metric descriptors define custom metrics.
ProjectMetricDescriptorDeleteCall	Deletes a metric descriptor. Only user-created custom metrics can be deleted.
ProjectMetricDescriptorGetCall	Gets a single metric descriptor. This method does not require a Stackdriver account.
ProjectMetricDescriptorListCall	Lists metric descriptors that match a filter. This method does not require a Stackdriver account.
ProjectMonitoredResourceDescriptorGetCall	Gets a single monitored resource descriptor. This method does not require a Stackdriver account.
ProjectMonitoredResourceDescriptorListCall	Lists monitored resource descriptors that match a filter. This method does not require a Stackdriver account.
ProjectTimeSeryCreateCall	Creates or adds data to one or more time series. The response is empty if all time series in the request were written. If any time series could not be written, a corresponding failure message is included in the error response.
ProjectTimeSeryListCall	Lists time series that match a filter. This method does not require a Stackdriver account.
Range	The range of the population values.
TimeInterval	A time interval extending just after a start time through an end time. If the start time is the same as the end time, then the interval represents a single point in time.
TimeSeries	A collection of data points that describes the time-varying values of a metric. A time series is identified by a combination of a fully-specified monitored resource and a fully-specified metric. This type is used for both listing and creating time series.
TypedValue	A single strongly-typed value.

Enums

Error
Scope	Identifies the an OAuth2 authorization scope. A scope is needed when requesting an authorization token.

Traits

CallBuilder	Identifies types which represent builders for a particular resource method
Delegate	A trait specifying functionality to help controlling any request performed by the API. The trait has a conservative default implementation.
Hub	Identifies the Hub. There is only one per library, this trait is supposed to make intended use more explicit. The hub allows to access all resource methods more easily.
MethodsBuilder	Identifies types for building methods of a particular resource type
NestedType	Identifies types which are only used by other types internally. They have no special meaning, this trait just marks them for completeness.
Part	Identifies types which are only used as part of other types, which usually are carrying the `Resource` trait.
ReadSeek	A utility to specify reader types which provide seeking capabilities too
RequestValue	Identifies types which are used in API requests.
Resource	Identifies types which can be inserted and deleted. Types with this trait are most commonly used by clients of this API.
ResponseResult	Identifies types which are used in API responses.
ToParts	A trait for all types that can convert themselves into a parts string

Functions

remove_json_null_values

Type Definitions

Result

A universal result type used as return for all calls.