/// This message defines the standard attribute vocabulary for Google APIs. /// /// An attribute is a piece of metadata that describes an activity on a network /// service. For example, the size of an HTTP request, or the status code of /// an HTTP response. /// /// Each attribute has a type and a name, which is logically defined as /// a proto message field in `AttributeContext`. The field type becomes the /// attribute type, and the field path becomes the attribute name. For example, /// the attribute `source.ip` maps to field `AttributeContext.source.ip`. /// /// This message definition is guaranteed not to have any wire breaking change. /// So you can use it directly for passing attributes across different systems. /// /// NOTE: Different system may generate different subset of attributes. Please /// verify the system specification before relying on an attribute generated /// a system. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AttributeContext { /// The origin of a network activity. In a multi hop network activity, /// the origin represents the sender of the first hop. For the first hop, /// the `source` and the `origin` must have the same content. #[prost(message, optional, tag = "7")] pub origin: ::core::option::Option, /// The source of a network activity, such as starting a TCP connection. /// In a multi hop network activity, the source represents the sender of the /// last hop. #[prost(message, optional, tag = "1")] pub source: ::core::option::Option, /// The destination of a network activity, such as accepting a TCP connection. /// In a multi hop network activity, the destination represents the receiver of /// the last hop. #[prost(message, optional, tag = "2")] pub destination: ::core::option::Option, /// Represents a network request, such as an HTTP request. #[prost(message, optional, tag = "3")] pub request: ::core::option::Option, /// Represents a network response, such as an HTTP response. #[prost(message, optional, tag = "4")] pub response: ::core::option::Option, /// Represents a target resource that is involved with a network activity. /// If multiple resources are involved with an activity, this must be the /// primary one. #[prost(message, optional, tag = "5")] pub resource: ::core::option::Option, /// Represents an API operation that is involved to a network activity. #[prost(message, optional, tag = "6")] pub api: ::core::option::Option, /// Supports extensions for advanced use cases, such as logs and metrics. #[prost(message, repeated, tag = "8")] pub extensions: ::prost::alloc::vec::Vec<::prost_types::Any>, } /// Nested message and enum types in `AttributeContext`. pub mod attribute_context { /// This message defines attributes for a node that handles a network request. /// The node can be either a service or an application that sends, forwards, /// or receives the request. Service peers should fill in /// `principal` and `labels` as appropriate. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Peer { /// The IP address of the peer. #[prost(string, tag = "1")] pub ip: ::prost::alloc::string::String, /// The network port of the peer. #[prost(int64, tag = "2")] pub port: i64, /// The labels associated with the peer. #[prost(map = "string, string", tag = "6")] pub labels: ::std::collections::HashMap< ::prost::alloc::string::String, ::prost::alloc::string::String, >, /// The identity of this peer. Similar to `Request.auth.principal`, but /// relative to the peer instead of the request. For example, the /// idenity associated with a load balancer that forwared the request. #[prost(string, tag = "7")] pub principal: ::prost::alloc::string::String, /// The CLDR country/region code associated with the above IP address. /// If the IP address is private, the `region_code` should reflect the /// physical location where this peer is running. #[prost(string, tag = "8")] pub region_code: ::prost::alloc::string::String, } /// This message defines attributes associated with API operations, such as /// a network API request. The terminology is based on the conventions used /// by Google APIs, Istio, and OpenAPI. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Api { /// The API service name. It is a logical identifier for a networked API, /// such as "pubsub.googleapis.com". The naming syntax depends on the /// API management system being used for handling the request. #[prost(string, tag = "1")] pub service: ::prost::alloc::string::String, /// The API operation name. For gRPC requests, it is the fully qualified API /// method name, such as "google.pubsub.v1.Publisher.Publish". For OpenAPI /// requests, it is the `operationId`, such as "getPet". #[prost(string, tag = "2")] pub operation: ::prost::alloc::string::String, /// The API protocol used for sending the request, such as "http", "https", /// "grpc", or "internal". #[prost(string, tag = "3")] pub protocol: ::prost::alloc::string::String, /// The API version associated with the API operation above, such as "v1" or /// "v1alpha1". #[prost(string, tag = "4")] pub version: ::prost::alloc::string::String, } /// This message defines request authentication attributes. Terminology is /// based on the JSON Web Token (JWT) standard, but the terms also /// correlate to concepts in other standards. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Auth { /// The authenticated principal. Reflects the issuer (`iss`) and subject /// (`sub`) claims within a JWT. The issuer and subject should be `/` /// delimited, with `/` percent-encoded within the subject fragment. For /// Google accounts, the principal format is: /// " #[prost(string, tag = "1")] pub principal: ::prost::alloc::string::String, /// The intended audience(s) for this authentication information. Reflects /// the audience (`aud`) claim within a JWT. The audience /// value(s) depends on the `issuer`, but typically include one or more of /// the following pieces of information: /// /// * The services intended to receive the credential. For example, /// [" " /// * A set of service-based scopes. For example, /// \[" /// * The client id of an app, such as the Firebase project id for JWTs /// from Firebase Auth. /// /// Consult the documentation for the credential issuer to determine the /// information provided. #[prost(string, repeated, tag = "2")] pub audiences: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// The authorized presenter of the credential. Reflects the optional /// Authorized Presenter (`azp`) claim within a JWT or the /// OAuth client id. For example, a Google Cloud Platform client id looks /// as follows: "123456789012.apps.googleusercontent.com". #[prost(string, tag = "3")] pub presenter: ::prost::alloc::string::String, /// Structured claims presented with the credential. JWTs include /// `{key: value}` pairs for standard and private claims. The following /// is a subset of the standard required and optional claims that would /// typically be presented for a Google-based JWT: /// /// {'iss': 'accounts.google.com', /// 'sub': '113289723416554971153', /// 'aud': ['123456789012', 'pubsub.googleapis.com'], /// 'azp': '123456789012.apps.googleusercontent.com', /// 'email': 'jsmith@example.com', /// 'iat': 1353601026, /// 'exp': 1353604926} /// /// SAML assertions are similarly specified, but with an identity provider /// dependent structure. #[prost(message, optional, tag = "4")] pub claims: ::core::option::Option<::prost_types::Struct>, /// A list of access level resource names that allow resources to be /// accessed by authenticated requester. It is part of Secure GCP processing /// for the incoming request. An access level string has the format: /// "//{api_service_name}/accessPolicies/{policy_id}/accessLevels/{short_name}" /// /// Example: /// "//accesscontextmanager.googleapis.com/accessPolicies/MY_POLICY_ID/accessLevels/MY_LEVEL" #[prost(string, repeated, tag = "5")] pub access_levels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// This message defines attributes for an HTTP request. If the actual /// request is not an HTTP request, the runtime system should try to map /// the actual request to an equivalent HTTP request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Request { /// The unique ID for a request, which can be propagated to downstream /// systems. The ID should have low probability of collision /// within a single day for a specific service. #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, /// The HTTP request method, such as `GET`, `POST`. #[prost(string, tag = "2")] pub method: ::prost::alloc::string::String, /// The HTTP request headers. If multiple headers share the same key, they /// must be merged according to the HTTP spec. All header keys must be /// lowercased, because HTTP header keys are case-insensitive. #[prost(map = "string, string", tag = "3")] pub headers: ::std::collections::HashMap< ::prost::alloc::string::String, ::prost::alloc::string::String, >, /// The HTTP URL path. #[prost(string, tag = "4")] pub path: ::prost::alloc::string::String, /// The HTTP request `Host` header value. #[prost(string, tag = "5")] pub host: ::prost::alloc::string::String, /// The HTTP URL scheme, such as `http` and `https`. #[prost(string, tag = "6")] pub scheme: ::prost::alloc::string::String, /// The HTTP URL query in the format of `name1=value1&name2=value2`, as it /// appears in the first line of the HTTP request. No decoding is performed. #[prost(string, tag = "7")] pub query: ::prost::alloc::string::String, /// The timestamp when the `destination` service receives the last byte of /// the request. #[prost(message, optional, tag = "9")] pub time: ::core::option::Option<::prost_types::Timestamp>, /// The HTTP request size in bytes. If unknown, it must be -1. #[prost(int64, tag = "10")] pub size: i64, /// The network protocol used with the request, such as "http/1.1", /// "spdy/3", "h2", "h2c", "webrtc", "tcp", "udp", "quic". See /// /// for details. #[prost(string, tag = "11")] pub protocol: ::prost::alloc::string::String, /// A special parameter for request reason. It is used by security systems /// to associate auditing information with a request. #[prost(string, tag = "12")] pub reason: ::prost::alloc::string::String, /// The request authentication. May be absent for unauthenticated requests. /// Derived from the HTTP request `Authorization` header or equivalent. #[prost(message, optional, tag = "13")] pub auth: ::core::option::Option, } /// This message defines attributes for a typical network response. It /// generally models semantics of an HTTP response. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Response { /// The HTTP response status code, such as `200` and `404`. #[prost(int64, tag = "1")] pub code: i64, /// The HTTP response size in bytes. If unknown, it must be -1. #[prost(int64, tag = "2")] pub size: i64, /// The HTTP response headers. If multiple headers share the same key, they /// must be merged according to HTTP spec. All header keys must be /// lowercased, because HTTP header keys are case-insensitive. #[prost(map = "string, string", tag = "3")] pub headers: ::std::collections::HashMap< ::prost::alloc::string::String, ::prost::alloc::string::String, >, /// The timestamp when the `destination` service sends the last byte of /// the response. #[prost(message, optional, tag = "4")] pub time: ::core::option::Option<::prost_types::Timestamp>, /// The length of time it takes the backend service to fully respond to a /// request. Measured from when the destination service starts to send the /// request to the backend until when the destination service receives the /// complete response from the backend. #[prost(message, optional, tag = "5")] pub backend_latency: ::core::option::Option<::prost_types::Duration>, } /// This message defines core attributes for a resource. A resource is an /// addressable (named) entity provided by the destination service. For /// example, a file stored on a network storage service. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Resource { /// The name of the service that this resource belongs to, such as /// `pubsub.googleapis.com`. The service may be different from the DNS /// hostname that actually serves the request. #[prost(string, tag = "1")] pub service: ::prost::alloc::string::String, /// The stable identifier (name) of a resource on the `service`. A resource /// can be logically identified as "//{resource.service}/{resource.name}". /// The differences between a resource name and a URI are: /// /// * Resource name is a logical identifier, independent of network /// protocol and API version. For example, /// `//pubsub.googleapis.com/projects/123/topics/news-feed`. /// * URI often includes protocol and version information, so it can /// be used directly by applications. For example, /// ` /// /// See for details. #[prost(string, tag = "2")] pub name: ::prost::alloc::string::String, /// The type of the resource. The syntax is platform-specific because /// different platforms define their resources differently. /// /// For Google APIs, the type format must be "{service}/{kind}". #[prost(string, tag = "3")] pub r#type: ::prost::alloc::string::String, /// The labels or tags on the resource, such as AWS resource tags and /// Kubernetes resource labels. #[prost(map = "string, string", tag = "4")] pub labels: ::std::collections::HashMap< ::prost::alloc::string::String, ::prost::alloc::string::String, >, /// The unique identifier of the resource. UID is unique in the time /// and space for this resource within the scope of the service. It is /// typically generated by the server on successful creation of a resource /// and must not be changed. UID is used to uniquely identify resources /// with resource name reuses. This should be a UUID4. #[prost(string, tag = "5")] pub uid: ::prost::alloc::string::String, /// Annotations is an unstructured key-value map stored with a resource that /// may be set by external tools to store and retrieve arbitrary metadata. /// They are not queryable and should be preserved when modifying objects. /// /// More info: #[prost(map = "string, string", tag = "6")] pub annotations: ::std::collections::HashMap< ::prost::alloc::string::String, ::prost::alloc::string::String, >, /// Mutable. The display name set by clients. Must be <= 63 characters. #[prost(string, tag = "7")] pub display_name: ::prost::alloc::string::String, /// Output only. The timestamp when the resource was created. This may /// be either the time creation was initiated or when it was completed. #[prost(message, optional, tag = "8")] pub create_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The timestamp when the resource was last updated. Any /// change to the resource made by users must refresh this value. /// Changes to a resource made by the service should refresh this value. #[prost(message, optional, tag = "9")] pub update_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The timestamp when the resource was deleted. /// If the resource is not deleted, this must be empty. #[prost(message, optional, tag = "10")] pub delete_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. An opaque value that uniquely identifies a version or /// generation of a resource. It can be used to confirm that the client /// and server agree on the ordering of a resource being written. #[prost(string, tag = "11")] pub etag: ::prost::alloc::string::String, /// Immutable. The location of the resource. The location encoding is /// specific to the service provider, and new encoding may be introduced /// as the service evolves. /// /// For Google Cloud products, the encoding is what is used by Google Cloud /// APIs, such as `us-east1`, `aws-us-east-1`, and `azure-eastus2`. The /// semantics of `location` is identical to the /// `cloud.googleapis.com/location` label used by some Google Cloud APIs. #[prost(string, tag = "12")] pub location: ::prost::alloc::string::String, } }