cwchristerw/musix-oss
1
0
Fork 0
mirror of https://github.com/musix-org/musix-oss synced 2025-06-17 20:15:59 +00:00
Code Activity

Modules

Browse Source
This commit is contained in:
MatteZ02
2020-03-03 22:30:50 +02:00
parent edfcc6f474
commit 30022c7634
11800 changed files with 1984416 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

339
node_modules/google-gax/protos/google/monitoring/v3/alert.proto generated vendored Normal file
View File

@ -0,0 +1,339 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
import "google/monitoring/v3/common.proto";
import "google/monitoring/v3/mutation_record.proto";
import "google/protobuf/duration.proto";
import "google/protobuf/wrappers.proto";
import "google/rpc/status.proto";
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "AlertProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// A description of the conditions under which some aspect of your system is
// considered to be "unhealthy" and the ways to notify people or services about
// this state. For an overview of alert policies, see
// [Introduction to Alerting](/monitoring/alerts/).
message AlertPolicy {
// A content string and a MIME type that describes the content string's
// format.
message Documentation {
// The text of the documentation, interpreted according to `mime_type`.
// The content may not exceed 8,192 Unicode characters and may not exceed
// more than 10,240 bytes when encoded in UTF-8 format, whichever is
// smaller.
string content = 1;
// The format of the `content` field. Presently, only the value
// `"text/markdown"` is supported. See
// [Markdown](https://en.wikipedia.org/wiki/Markdown) for more information.
string mime_type = 2;
}
// A condition is a true/false test that determines when an alerting policy
// should open an incident. If a condition evaluates to true, it signifies
// that something is wrong.
message Condition {
// Specifies how many time series must fail a predicate to trigger a
// condition. If not specified, then a `{count: 1}` trigger is used.
message Trigger {
// A type of trigger.
oneof type {
// The absolute number of time series that must fail
// the predicate for the condition to be triggered.
int32 count = 1;
// The percentage of time series that must fail the
// predicate for the condition to be triggered.
double percent = 2;
}
}
// A condition type that compares a collection of time series
// against a threshold.
message MetricThreshold {
// A [filter](/monitoring/api/v3/filters) that
// identifies which time series should be compared with the threshold.
//
// The filter is similar to the one that is specified in the
// [`ListTimeSeries`
// request](/monitoring/api/ref_v3/rest/v3/projects.timeSeries/list) (that
// call is useful to verify the time series that will be retrieved /
// processed) and must specify the metric type and optionally may contain
// restrictions on resource type, resource labels, and metric labels.
// This field may not exceed 2048 Unicode characters in length.
string filter = 2;
// Specifies the alignment of data points in individual time series as
// well as how to combine the retrieved time series together (such as
// when aggregating multiple streams on each resource to a single
// stream for each resource or when aggregating streams across all
// members of a group of resrouces). Multiple aggregations
// are applied in the order specified.
//
// This field is similar to the one in the [`ListTimeSeries`
// request](/monitoring/api/ref_v3/rest/v3/projects.timeSeries/list). It
// is advisable to use the `ListTimeSeries` method when debugging this
// field.
repeated Aggregation aggregations = 8;
// A [filter](/monitoring/api/v3/filters) that identifies a time
// series that should be used as the denominator of a ratio that will be
// compared with the threshold. If a `denominator_filter` is specified,
// the time series specified by the `filter` field will be used as the
// numerator.
//
// The filter must specify the metric type and optionally may contain
// restrictions on resource type, resource labels, and metric labels.
// This field may not exceed 2048 Unicode characters in length.
string denominator_filter = 9;
// Specifies the alignment of data points in individual time series
// selected by `denominatorFilter` as
// well as how to combine the retrieved time series together (such as
// when aggregating multiple streams on each resource to a single
// stream for each resource or when aggregating streams across all
// members of a group of resources).
//
// When computing ratios, the `aggregations` and
// `denominator_aggregations` fields must use the same alignment period
// and produce time series that have the same periodicity and labels.
repeated Aggregation denominator_aggregations = 10;
// The comparison to apply between the time series (indicated by `filter`
// and `aggregation`) and the threshold (indicated by `threshold_value`).
// The comparison is applied on each time series, with the time series
// on the left-hand side and the threshold on the right-hand side.
//
// Only `COMPARISON_LT` and `COMPARISON_GT` are supported currently.
ComparisonType comparison = 4;
// A value against which to compare the time series.
double threshold_value = 5;
// The amount of time that a time series must violate the
// threshold to be considered failing. Currently, only values
// that are a multiple of a minute--e.g., 0, 60, 120, or 300
// seconds--are supported. If an invalid value is given, an
// error will be returned. When choosing a duration, it is useful to
// keep in mind the frequency of the underlying time series data
// (which may also be affected by any alignments specified in the
// `aggregations` field); a good duration is long enough so that a single
// outlier does not generate spurious alerts, but short enough that
// unhealthy states are detected and alerted on quickly.
google.protobuf.Duration duration = 6;
// The number/percent of time series for which the comparison must hold
// in order for the condition to trigger. If unspecified, then the
// condition will trigger if the comparison is true for any of the
// time series that have been identified by `filter` and `aggregations`,
// or by the ratio, if `denominator_filter` and `denominator_aggregations`
// are specified.
Trigger trigger = 7;
}
// A condition type that checks that monitored resources
// are reporting data. The configuration defines a metric and
// a set of monitored resources. The predicate is considered in violation
// when a time series for the specified metric of a monitored
// resource does not include any data in the specified `duration`.
message MetricAbsence {
// A [filter](/monitoring/api/v3/filters) that
// identifies which time series should be compared with the threshold.
//
// The filter is similar to the one that is specified in the
// [`ListTimeSeries`
// request](/monitoring/api/ref_v3/rest/v3/projects.timeSeries/list) (that
// call is useful to verify the time series that will be retrieved /
// processed) and must specify the metric type and optionally may contain
// restrictions on resource type, resource labels, and metric labels.
// This field may not exceed 2048 Unicode characters in length.
string filter = 1;
// Specifies the alignment of data points in individual time series as
// well as how to combine the retrieved time series together (such as
// when aggregating multiple streams on each resource to a single
// stream for each resource or when aggregating streams across all
// members of a group of resrouces). Multiple aggregations
// are applied in the order specified.
//
// This field is similar to the one in the [`ListTimeSeries`
// request](/monitoring/api/ref_v3/rest/v3/projects.timeSeries/list). It
// is advisable to use the `ListTimeSeries` method when debugging this
// field.
repeated Aggregation aggregations = 5;
// The amount of time that a time series must fail to report new
// data to be considered failing. Currently, only values that
// are a multiple of a minute--e.g. 60, 120, or 300
// seconds--are supported. If an invalid value is given, an
// error will be returned. The `Duration.nanos` field is
// ignored.
google.protobuf.Duration duration = 2;
// The number/percent of time series for which the comparison must hold
// in order for the condition to trigger. If unspecified, then the
// condition will trigger if the comparison is true for any of the
// time series that have been identified by `filter` and `aggregations`.
Trigger trigger = 3;
}
// Required if the condition exists. The unique resource name for this
// condition. Its syntax is:
//
// projects/[PROJECT_ID]/alertPolicies/[POLICY_ID]/conditions/[CONDITION_ID]
//
// `[CONDITION_ID]` is assigned by Stackdriver Monitoring when the
// condition is created as part of a new or updated alerting policy.
//
// When calling the
// [alertPolicies.create][google.monitoring.v3.AlertPolicyService.CreateAlertPolicy]
// method, do not include the `name` field in the conditions of the
// requested alerting policy. Stackdriver Monitoring creates the
// condition identifiers and includes them in the new policy.
//
// When calling the
// [alertPolicies.update][google.monitoring.v3.AlertPolicyService.UpdateAlertPolicy]
// method to update a policy, including a condition `name` causes the
// existing condition to be updated. Conditions without names are added to
// the updated policy. Existing conditions are deleted if they are not
// updated.
//
// Best practice is to preserve `[CONDITION_ID]` if you make only small
// changes, such as those to condition thresholds, durations, or trigger
// values. Otherwise, treat the change as a new condition and let the
// existing condition be deleted.
string name = 12;
// A short name or phrase used to identify the condition in dashboards,
// notifications, and incidents. To avoid confusion, don't use the same
// display name for multiple conditions in the same policy.
string display_name = 6;
// Only one of the following condition types will be specified.
oneof condition {
// A condition that compares a time series against a threshold.
MetricThreshold condition_threshold = 1;
// A condition that checks that a time series continues to
// receive new data points.
MetricAbsence condition_absent = 2;
}
}
// Operators for combining conditions.
enum ConditionCombinerType {
// An unspecified combiner.
COMBINE_UNSPECIFIED = 0;
// Combine conditions using the logical `AND` operator. An
// incident is created only if all conditions are met
// simultaneously. This combiner is satisfied if all conditions are
// met, even if they are met on completely different resources.
AND = 1;
// Combine conditions using the logical `OR` operator. An incident
// is created if any of the listed conditions is met.
OR = 2;
// Combine conditions using logical `AND` operator, but unlike the regular
// `AND` option, an incident is created only if all conditions are met
// simultaneously on at least one resource.
AND_WITH_MATCHING_RESOURCE = 3;
}
// Required if the policy exists. The resource name for this policy. The
// syntax is:
//
// projects/[PROJECT_ID]/alertPolicies/[ALERT_POLICY_ID]
//
// `[ALERT_POLICY_ID]` is assigned by Stackdriver Monitoring when the policy
// is created. When calling the
// [alertPolicies.create][google.monitoring.v3.AlertPolicyService.CreateAlertPolicy]
// method, do not include the `name` field in the alerting policy passed as
// part of the request.
string name = 1;
// A short name or phrase used to identify the policy in dashboards,
// notifications, and incidents. To avoid confusion, don't use the same
// display name for multiple policies in the same project. The name is
// limited to 512 Unicode characters.
string display_name = 2;
// Documentation that is included with notifications and incidents related to
// this policy. Best practice is for the documentation to include information
// to help responders understand, mitigate, escalate, and correct the
// underlying problems detected by the alerting policy. Notification channels
// that have limited capacity might not show this documentation.
Documentation documentation = 13;
// User-supplied key/value data to be used for organizing and
// identifying the `AlertPolicy` objects.
//
// The field can contain up to 64 entries. Each key and value is limited to
// 63 Unicode characters or 128 bytes, whichever is smaller. Labels and
// values can contain only lowercase letters, numerals, underscores, and
// dashes. Keys must begin with a letter.
map<string, string> user_labels = 16;
// A list of conditions for the policy. The conditions are combined by AND or
// OR according to the `combiner` field. If the combined conditions evaluate
// to true, then an incident is created. A policy can have from one to six
// conditions.
repeated Condition conditions = 12;
// How to combine the results of multiple conditions to determine if an
// incident should be opened.
ConditionCombinerType combiner = 6;
// Whether or not the policy is enabled. On write, the default interpretation
// if unset is that the policy is enabled. On read, clients should not make
// any assumption about the state if it has not been populated. The
// field should always be populated on List and Get operations, unless
// a field projection has been specified that strips it out.
google.protobuf.BoolValue enabled = 17;
// Read-only description of how the alert policy is invalid. OK if the alert
// policy is valid. If not OK, the alert policy will not generate incidents.
google.rpc.Status validity = 18;
// Identifies the notification channels to which notifications should be sent
// when incidents are opened or closed or when new violations occur on
// an already opened incident. Each element of this array corresponds to
// the `name` field in each of the
// [`NotificationChannel`][google.monitoring.v3.NotificationChannel]
// objects that are returned from the [`ListNotificationChannels`]
// [google.monitoring.v3.NotificationChannelService.ListNotificationChannels]
// method. The syntax of the entries in this field is:
//
// projects/[PROJECT_ID]/notificationChannels/[CHANNEL_ID]
repeated string notification_channels = 14;
// A read-only record of the creation of the alerting policy. If provided
// in a call to create or update, this field will be ignored.
MutationRecord creation_record = 10;
// A read-only record of the most recent change to the alerting policy. If
// provided in a call to create or update, this field will be ignored.
MutationRecord mutation_record = 11;
}

204
node_modules/google-gax/protos/google/monitoring/v3/alert_service.proto generated vendored Normal file
View File

@ -0,0 +1,204 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
import "google/api/annotations.proto";
import "google/monitoring/v3/alert.proto";
import "google/protobuf/empty.proto";
import "google/protobuf/field_mask.proto";
import "google/api/client.proto";
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "AlertServiceProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// The AlertPolicyService API is used to manage (list, create, delete,
// edit) alert policies in Stackdriver Monitoring. An alerting policy is
// a description of the conditions under which some aspect of your
// system is considered to be "unhealthy" and the ways to notify
// people or services about this state. In addition to using this API, alert
// policies can also be managed through
// [Stackdriver Monitoring](https://cloud.google.com/monitoring/docs/),
// which can be reached by clicking the "Monitoring" tab in
// [Cloud Console](https://console.cloud.google.com/).
service AlertPolicyService {
option (google.api.default_host) = "monitoring.googleapis.com";
option (google.api.oauth_scopes) =
"https://www.googleapis.com/auth/cloud-platform,"
"https://www.googleapis.com/auth/monitoring,"
"https://www.googleapis.com/auth/monitoring.read";
// Lists the existing alerting policies for the project.
rpc ListAlertPolicies(ListAlertPoliciesRequest) returns (ListAlertPoliciesResponse) {
option (google.api.http) = {
get: "/v3/{name=projects/*}/alertPolicies"
};
}
// Gets a single alerting policy.
rpc GetAlertPolicy(GetAlertPolicyRequest) returns (AlertPolicy) {
option (google.api.http) = {
get: "/v3/{name=projects/*/alertPolicies/*}"
};
}
// Creates a new alerting policy.
rpc CreateAlertPolicy(CreateAlertPolicyRequest) returns (AlertPolicy) {
option (google.api.http) = {
post: "/v3/{name=projects/*}/alertPolicies"
body: "alert_policy"
};
}
// Deletes an alerting policy.
rpc DeleteAlertPolicy(DeleteAlertPolicyRequest) returns (google.protobuf.Empty) {
option (google.api.http) = {
delete: "/v3/{name=projects/*/alertPolicies/*}"
};
}
// Updates an alerting policy. You can either replace the entire policy with
// a new one or replace only certain fields in the current alerting policy by
// specifying the fields to be updated via `updateMask`. Returns the
// updated alerting policy.
rpc UpdateAlertPolicy(UpdateAlertPolicyRequest) returns (AlertPolicy) {
option (google.api.http) = {
patch: "/v3/{alert_policy.name=projects/*/alertPolicies/*}"
body: "alert_policy"
};
}
}
// The protocol for the `CreateAlertPolicy` request.
message CreateAlertPolicyRequest {
// The project in which to create the alerting policy. The format is
// `projects/[PROJECT_ID]`.
//
// Note that this field names the parent container in which the alerting
// policy will be written, not the name of the created policy. The alerting
// policy that is returned will have a name that contains a normalized
// representation of this name as a prefix but adds a suffix of the form
// `/alertPolicies/[POLICY_ID]`, identifying the policy in the container.
string name = 3;
// The requested alerting policy. You should omit the `name` field in this
// policy. The name will be returned in the new policy, including
// a new [ALERT_POLICY_ID] value.
AlertPolicy alert_policy = 2;
}
// The protocol for the `GetAlertPolicy` request.
message GetAlertPolicyRequest {
// The alerting policy to retrieve. The format is
//
// projects/[PROJECT_ID]/alertPolicies/[ALERT_POLICY_ID]
string name = 3;
}
// The protocol for the `ListAlertPolicies` request.
message ListAlertPoliciesRequest {
// The project whose alert policies are to be listed. The format is
//
// projects/[PROJECT_ID]
//
// Note that this field names the parent container in which the alerting
// policies to be listed are stored. To retrieve a single alerting policy
// by name, use the
// [GetAlertPolicy][google.monitoring.v3.AlertPolicyService.GetAlertPolicy]
// operation, instead.
string name = 4;
// If provided, this field specifies the criteria that must be met by
// alert policies to be included in the response.
//
// For more details, see [sorting and
// filtering](/monitoring/api/v3/sorting-and-filtering).
string filter = 5;
// A comma-separated list of fields by which to sort the result. Supports
// the same set of field references as the `filter` field. Entries can be
// prefixed with a minus sign to sort by the field in descending order.
//
// For more details, see [sorting and
// filtering](/monitoring/api/v3/sorting-and-filtering).
string order_by = 6;
// The maximum number of results to return in a single response.
int32 page_size = 2;
// If this field is not empty then it must contain the `nextPageToken` value
// returned by a previous call to this method. Using this field causes the
// method to return more results from the previous method call.
string page_token = 3;
}
// The protocol for the `ListAlertPolicies` response.
message ListAlertPoliciesResponse {
// The returned alert policies.
repeated AlertPolicy alert_policies = 3;
// If there might be more results than were returned, then this field is set
// to a non-empty value. To see the additional results,
// use that value as `pageToken` in the next call to this method.
string next_page_token = 2;
}
// The protocol for the `UpdateAlertPolicy` request.
message UpdateAlertPolicyRequest {
// Optional. A list of alerting policy field names. If this field is not
// empty, each listed field in the existing alerting policy is set to the
// value of the corresponding field in the supplied policy (`alert_policy`),
// or to the field's default value if the field is not in the supplied
// alerting policy. Fields not listed retain their previous value.
//
// Examples of valid field masks include `display_name`, `documentation`,
// `documentation.content`, `documentation.mime_type`, `user_labels`,
// `user_label.nameofkey`, `enabled`, `conditions`, `combiner`, etc.
//
// If this field is empty, then the supplied alerting policy replaces the
// existing policy. It is the same as deleting the existing policy and
// adding the supplied policy, except for the following:
//
// + The new policy will have the same `[ALERT_POLICY_ID]` as the former
// policy. This gives you continuity with the former policy in your
// notifications and incidents.
// + Conditions in the new policy will keep their former `[CONDITION_ID]` if
// the supplied condition includes the `name` field with that
// `[CONDITION_ID]`. If the supplied condition omits the `name` field,
// then a new `[CONDITION_ID]` is created.
google.protobuf.FieldMask update_mask = 2;
// Required. The updated alerting policy or the updated values for the
// fields listed in `update_mask`.
// If `update_mask` is not empty, any fields in this policy that are
// not in `update_mask` are ignored.
AlertPolicy alert_policy = 3;
}
// The protocol for the `DeleteAlertPolicy` request.
message DeleteAlertPolicyRequest {
// The alerting policy to delete. The format is:
//
// projects/[PROJECT_ID]/alertPolicies/[ALERT_POLICY_ID]
//
// For more information, see [AlertPolicy][google.monitoring.v3.AlertPolicy].
string name = 3;
}

432
node_modules/google-gax/protos/google/monitoring/v3/common.proto generated vendored Normal file
View File

@ -0,0 +1,432 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
import "google/api/distribution.proto";
import "google/protobuf/duration.proto";
import "google/protobuf/timestamp.proto";
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "CommonProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// A single strongly-typed value.
message TypedValue {
// The typed value field.
oneof value {
// A Boolean value: `true` or `false`.
bool bool_value = 1;
// A 64-bit integer. Its range is approximately &plusmn;9.2x10<sup>18</sup>.
int64 int64_value = 2;
// A 64-bit double-precision floating-point number. Its magnitude
// is approximately &plusmn;10<sup>&plusmn;300</sup> and it has 16
// significant digits of precision.
double double_value = 3;
// A variable-length string value.
string string_value = 4;
// A distribution value.
google.api.Distribution distribution_value = 5;
}
}
// A closed time interval. It extends from the start time to the end time, and includes both: `[startTime, endTime]`. Valid time intervals depend on the [`MetricKind`](/monitoring/api/ref_v3/rest/v3/projects.metricDescriptors#MetricKind) of the metric value. In no case can the end time be earlier than the start time.
//
// * For a `GAUGE` metric, the `startTime` value is technically optional; if
// no value is specified, the start time defaults to the value of the
// end time, and the interval represents a single point in time. If both
// start and end times are specified, they must be identical. Such an
// interval is valid only for `GAUGE` metrics, which are point-in-time
// measurements.
//
// * For `DELTA` and `CUMULATIVE` metrics, the start time must be earlier
// than the end time.
//
// * In all cases, the start time of the next interval must be
// at least a microsecond after the end time of the previous interval.
// Because the interval is closed, if the start time of a new interval
// is the same as the end time of the previous interval, data written
// at the new start time could overwrite data written at the previous
// end time.
message TimeInterval {
// Required. The end of the time interval.
google.protobuf.Timestamp end_time = 2;
// Optional. The beginning of the time interval. The default value
// for the start time is the end time. The start time must not be
// later than the end time.
google.protobuf.Timestamp start_time = 1;
}
// Describes how to combine multiple time series to provide different views of
// the data. Aggregation consists of an alignment step on individual time
// series (`alignment_period` and `per_series_aligner`) followed by an optional
// reduction step of the data across the aligned time series
// (`cross_series_reducer` and `group_by_fields`). For more details, see
// [Aggregation](/monitoring/api/learn_more#aggregation).
message Aggregation {
// The Aligner describes how to bring the data points in a single
// time series into temporal alignment.
enum Aligner {
// No alignment. Raw data is returned. Not valid if cross-time
// series reduction is requested. The value type of the result is
// the same as the value type of the input.
ALIGN_NONE = 0;
// Align and convert to delta metric type. This alignment is valid
// for cumulative metrics and delta metrics. Aligning an existing
// delta metric to a delta metric requires that the alignment
// period be increased. The value type of the result is the same
// as the value type of the input.
//
// One can think of this aligner as a rate but without time units; that
// is, the output is conceptually (second_point - first_point).
ALIGN_DELTA = 1;
// Align and convert to a rate. This alignment is valid for
// cumulative metrics and delta metrics with numeric values. The output is a
// gauge metric with value type
// [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE].
//
// One can think of this aligner as conceptually providing the slope of
// the line that passes through the value at the start and end of the
// window. In other words, this is conceptually ((y1 - y0)/(t1 - t0)),
// and the output unit is one that has a "/time" dimension.
//
// If, by rate, you are looking for percentage change, see the
// `ALIGN_PERCENT_CHANGE` aligner option.
ALIGN_RATE = 2;
// Align by interpolating between adjacent points around the
// period boundary. This alignment is valid for gauge
// metrics with numeric values. The value type of the result is the same
// as the value type of the input.
ALIGN_INTERPOLATE = 3;
// Align by shifting the oldest data point before the period
// boundary to the boundary. This alignment is valid for gauge
// metrics. The value type of the result is the same as the
// value type of the input.
ALIGN_NEXT_OLDER = 4;
// Align time series via aggregation. The resulting data point in
// the alignment period is the minimum of all data points in the
// period. This alignment is valid for gauge and delta metrics with numeric
// values. The value type of the result is the same as the value
// type of the input.
ALIGN_MIN = 10;
// Align time series via aggregation. The resulting data point in
// the alignment period is the maximum of all data points in the
// period. This alignment is valid for gauge and delta metrics with numeric
// values. The value type of the result is the same as the value
// type of the input.
ALIGN_MAX = 11;
// Align time series via aggregation. The resulting data point in
// the alignment period is the average or arithmetic mean of all
// data points in the period. This alignment is valid for gauge and delta
// metrics with numeric values. The value type of the output is
// [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE].
ALIGN_MEAN = 12;
// Align time series via aggregation. The resulting data point in
// the alignment period is the count of all data points in the
// period. This alignment is valid for gauge and delta metrics with numeric
// or Boolean values. The value type of the output is
// [INT64][google.api.MetricDescriptor.ValueType.INT64].
ALIGN_COUNT = 13;
// Align time series via aggregation. The resulting data point in
// the alignment period is the sum of all data points in the
// period. This alignment is valid for gauge and delta metrics with numeric
// and distribution values. The value type of the output is the
// same as the value type of the input.
ALIGN_SUM = 14;
// Align time series via aggregation. The resulting data point in
// the alignment period is the standard deviation of all data
// points in the period. This alignment is valid for gauge and delta metrics
// with numeric values. The value type of the output is
// [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE].
ALIGN_STDDEV = 15;
// Align time series via aggregation. The resulting data point in
// the alignment period is the count of True-valued data points in the
// period. This alignment is valid for gauge metrics with
// Boolean values. The value type of the output is
// [INT64][google.api.MetricDescriptor.ValueType.INT64].
ALIGN_COUNT_TRUE = 16;
// Align time series via aggregation. The resulting data point in
// the alignment period is the count of False-valued data points in the
// period. This alignment is valid for gauge metrics with
// Boolean values. The value type of the output is
// [INT64][google.api.MetricDescriptor.ValueType.INT64].
ALIGN_COUNT_FALSE = 24;
// Align time series via aggregation. The resulting data point in
// the alignment period is the fraction of True-valued data points in the
// period. This alignment is valid for gauge metrics with Boolean values.
// The output value is in the range [0, 1] and has value type
// [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE].
ALIGN_FRACTION_TRUE = 17;
// Align time series via aggregation. The resulting data point in
// the alignment period is the 99th percentile of all data
// points in the period. This alignment is valid for gauge and delta metrics
// with distribution values. The output is a gauge metric with value type
// [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE].
ALIGN_PERCENTILE_99 = 18;
// Align time series via aggregation. The resulting data point in
// the alignment period is the 95th percentile of all data
// points in the period. This alignment is valid for gauge and delta metrics
// with distribution values. The output is a gauge metric with value type
// [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE].
ALIGN_PERCENTILE_95 = 19;
// Align time series via aggregation. The resulting data point in
// the alignment period is the 50th percentile of all data
// points in the period. This alignment is valid for gauge and delta metrics
// with distribution values. The output is a gauge metric with value type
// [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE].
ALIGN_PERCENTILE_50 = 20;
// Align time series via aggregation. The resulting data point in
// the alignment period is the 5th percentile of all data
// points in the period. This alignment is valid for gauge and delta metrics
// with distribution values. The output is a gauge metric with value type
// [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE].
ALIGN_PERCENTILE_05 = 21;
// Align and convert to a percentage change. This alignment is valid for
// gauge and delta metrics with numeric values. This alignment conceptually
// computes the equivalent of "((current - previous)/previous)*100"
// where previous value is determined based on the alignmentPeriod.
// In the event that previous is 0 the calculated value is infinity with the
// exception that if both (current - previous) and previous are 0 the
// calculated value is 0.
// A 10 minute moving mean is computed at each point of the time window
// prior to the above calculation to smooth the metric and prevent false
// positives from very short lived spikes.
// Only applicable for data that is >= 0. Any values < 0 are treated as
// no data. While delta metrics are accepted by this alignment special care
// should be taken that the values for the metric will always be positive.
// The output is a gauge metric with value type
// [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE].
ALIGN_PERCENT_CHANGE = 23;
}
// A Reducer describes how to aggregate data points from multiple
// time series into a single time series.
enum Reducer {
// No cross-time series reduction. The output of the aligner is
// returned.
REDUCE_NONE = 0;
// Reduce by computing the mean across time series for each
// alignment period. This reducer is valid for delta and
// gauge metrics with numeric or distribution values. The value type of the
// output is [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE].
REDUCE_MEAN = 1;
// Reduce by computing the minimum across time series for each
// alignment period. This reducer is valid for delta and
// gauge metrics with numeric values. The value type of the output
// is the same as the value type of the input.
REDUCE_MIN = 2;
// Reduce by computing the maximum across time series for each
// alignment period. This reducer is valid for delta and
// gauge metrics with numeric values. The value type of the output
// is the same as the value type of the input.
REDUCE_MAX = 3;
// Reduce by computing the sum across time series for each
// alignment period. This reducer is valid for delta and
// gauge metrics with numeric and distribution values. The value type of
// the output is the same as the value type of the input.
REDUCE_SUM = 4;
// Reduce by computing the standard deviation across time series
// for each alignment period. This reducer is valid for delta
// and gauge metrics with numeric or distribution values. The value type of
// the output is [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE].
REDUCE_STDDEV = 5;
// Reduce by computing the count of data points across time series
// for each alignment period. This reducer is valid for delta
// and gauge metrics of numeric, Boolean, distribution, and string value
// type. The value type of the output is
// [INT64][google.api.MetricDescriptor.ValueType.INT64].
REDUCE_COUNT = 6;
// Reduce by computing the count of True-valued data points across time
// series for each alignment period. This reducer is valid for delta
// and gauge metrics of Boolean value type. The value type of
// the output is [INT64][google.api.MetricDescriptor.ValueType.INT64].
REDUCE_COUNT_TRUE = 7;
// Reduce by computing the count of False-valued data points across time
// series for each alignment period. This reducer is valid for delta
// and gauge metrics of Boolean value type. The value type of
// the output is [INT64][google.api.MetricDescriptor.ValueType.INT64].
REDUCE_COUNT_FALSE = 15;
// Reduce by computing the fraction of True-valued data points across time
// series for each alignment period. This reducer is valid for delta
// and gauge metrics of Boolean value type. The output value is in the
// range [0, 1] and has value type
// [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE].
REDUCE_FRACTION_TRUE = 8;
// Reduce by computing 99th percentile of data points across time series
// for each alignment period. This reducer is valid for gauge and delta
// metrics of numeric and distribution type. The value of the output is
// [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE]
REDUCE_PERCENTILE_99 = 9;
// Reduce by computing 95th percentile of data points across time series
// for each alignment period. This reducer is valid for gauge and delta
// metrics of numeric and distribution type. The value of the output is
// [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE]
REDUCE_PERCENTILE_95 = 10;
// Reduce by computing 50th percentile of data points across time series
// for each alignment period. This reducer is valid for gauge and delta
// metrics of numeric and distribution type. The value of the output is
// [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE]
REDUCE_PERCENTILE_50 = 11;
// Reduce by computing 5th percentile of data points across time series
// for each alignment period. This reducer is valid for gauge and delta
// metrics of numeric and distribution type. The value of the output is
// [DOUBLE][google.api.MetricDescriptor.ValueType.DOUBLE]
REDUCE_PERCENTILE_05 = 12;
}
// The alignment period for per-[time series][google.monitoring.v3.TimeSeries]
// alignment. If present, `alignmentPeriod` must be at least 60
// seconds. After per-time series alignment, each time series will
// contain data points only on the period boundaries. If
// `perSeriesAligner` is not specified or equals `ALIGN_NONE`, then
// this field is ignored. If `perSeriesAligner` is specified and
// does not equal `ALIGN_NONE`, then this field must be defined;
// otherwise an error is returned.
google.protobuf.Duration alignment_period = 1;
// The approach to be used to align individual time series. Not all
// alignment functions may be applied to all time series, depending
// on the metric type and value type of the original time
// series. Alignment may change the metric type or the value type of
// the time series.
//
// Time series data must be aligned in order to perform cross-time
// series reduction. If `crossSeriesReducer` is specified, then
// `perSeriesAligner` must be specified and not equal `ALIGN_NONE`
// and `alignmentPeriod` must be specified; otherwise, an error is
// returned.
Aligner per_series_aligner = 2;
// The approach to be used to combine time series. Not all reducer
// functions may be applied to all time series, depending on the
// metric type and the value type of the original time
// series. Reduction may change the metric type of value type of the
// time series.
//
// Time series data must be aligned in order to perform cross-time
// series reduction. If `crossSeriesReducer` is specified, then
// `perSeriesAligner` must be specified and not equal `ALIGN_NONE`
// and `alignmentPeriod` must be specified; otherwise, an error is
// returned.
Reducer cross_series_reducer = 4;
// The set of fields to preserve when `crossSeriesReducer` is
// specified. The `groupByFields` determine how the time series are
// partitioned into subsets prior to applying the aggregation
// function. Each subset contains time series that have the same
// value for each of the grouping fields. Each individual time
// series is a member of exactly one subset. The
// `crossSeriesReducer` is applied to each subset of time series.
// It is not possible to reduce across different resource types, so
// this field implicitly contains `resource.type`. Fields not
// specified in `groupByFields` are aggregated away. If
// `groupByFields` is not specified and all the time series have
// the same resource type, then the time series are aggregated into
// a single output time series. If `crossSeriesReducer` is not
// defined, this field is ignored.
repeated string group_by_fields = 5;
}
// Specifies an ordering relationship on two arguments, here called left and
// right.
enum ComparisonType {
// No ordering relationship is specified.
COMPARISON_UNSPECIFIED = 0;
// The left argument is greater than the right argument.
COMPARISON_GT = 1;
// The left argument is greater than or equal to the right argument.
COMPARISON_GE = 2;
// The left argument is less than the right argument.
COMPARISON_LT = 3;
// The left argument is less than or equal to the right argument.
COMPARISON_LE = 4;
// The left argument is equal to the right argument.
COMPARISON_EQ = 5;
// The left argument is not equal to the right argument.
COMPARISON_NE = 6;
}
// The tier of service for a Workspace. Please see the
// [service tiers
// documentation](https://cloud.google.com/monitoring/workspaces/tiers) for more
// details.
enum ServiceTier {
option deprecated = true;
// An invalid sentinel value, used to indicate that a tier has not
// been provided explicitly.
SERVICE_TIER_UNSPECIFIED = 0;
// The Stackdriver Basic tier, a free tier of service that provides basic
// features, a moderate allotment of logs, and access to built-in metrics.
// A number of features are not available in this tier. For more details,
// see [the service tiers
// documentation](https://cloud.google.com/monitoring/workspaces/tiers).
SERVICE_TIER_BASIC = 1;
// The Stackdriver Premium tier, a higher, more expensive tier of service
// that provides access to all Stackdriver features, lets you use Stackdriver
// with AWS accounts, and has a larger allotments for logs and metrics. For
// more details, see [the service tiers
// documentation](https://cloud.google.com/monitoring/workspaces/tiers).
SERVICE_TIER_PREMIUM = 2;
}

45
node_modules/google-gax/protos/google/monitoring/v3/dropped_labels.proto generated vendored Normal file
View File

@ -0,0 +1,45 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "DroppedLabelsProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// A set of (label, value) pairs which were dropped during aggregation, attached
// to google.api.Distribution.Exemplars in google.api.Distribution values during
// aggregation.
//
// These values are used in combination with the label values that remain on the
// aggregated Distribution timeseries to construct the full label set for the
// exemplar values. The resulting full label set may be used to identify the
// specific task/job/instance (for example) which may be contributing to a
// long-tail, while allowing the storage savings of only storing aggregated
// distribution values for a large group.
//
// Note that there are no guarantees on ordering of the labels from
// exemplar-to-exemplar and from distribution-to-distribution in the same
// stream, and there may be duplicates. It is up to clients to resolve any
// ambiguities.
message DroppedLabels {
// Map from label to its value, for all labels dropped in any aggregation.
map<string, string> label = 1;
}

76
node_modules/google-gax/protos/google/monitoring/v3/group.proto generated vendored Normal file
View File

@ -0,0 +1,76 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "GroupProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// 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.
message Group {
// Output only. The name of this group. The format is
// `"projects/{project_id_or_number}/groups/{group_id}"`.
// When creating a group, this field is ignored and a new name is created
// consisting of the project specified in the call to `CreateGroup`
// and a unique `{group_id}` that is generated automatically.
string name = 1;
// A user-assigned name for this group, used only for display purposes.
string display_name = 2;
// The name of the group's parent, if it has one.
// The format is `"projects/{project_id_or_number}/groups/{group_id}"`.
// For groups with no parent, `parentName` is the empty string, `""`.
string parent_name = 3;
// The filter used to determine which monitored resources belong to this
// group.
string filter = 5;
// If true, the members of this group are considered to be a cluster.
// The system can perform additional analysis on groups that are clusters.
bool is_cluster = 6;
}

234
node_modules/google-gax/protos/google/monitoring/v3/group_service.proto generated vendored Normal file
View File

@ -0,0 +1,234 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
import "google/api/annotations.proto";
import "google/api/monitored_resource.proto";
import "google/monitoring/v3/common.proto";
import "google/monitoring/v3/group.proto";
import "google/protobuf/empty.proto";
import "google/api/client.proto";
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "GroupServiceProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// The Group API lets you inspect and manage your
// [groups](#google.monitoring.v3.Group).
//
// A group is a named filter that is used to identify
// a collection of monitored resources. Groups are typically used to
// mirror the physical and/or logical topology of the environment.
// Because group membership is computed dynamically, monitored
// resources that are started in the future are automatically placed
// in matching groups. By using a group to name monitored resources in,
// for example, an alert policy, the target of that alert policy is
// updated automatically as monitored resources are added and removed
// from the infrastructure.
service GroupService {
option (google.api.default_host) = "monitoring.googleapis.com";
option (google.api.oauth_scopes) =
"https://www.googleapis.com/auth/cloud-platform,"
"https://www.googleapis.com/auth/monitoring,"
"https://www.googleapis.com/auth/monitoring.read";
// Lists the existing groups.
rpc ListGroups(ListGroupsRequest) returns (ListGroupsResponse) {
option (google.api.http) = {
get: "/v3/{name=projects/*}/groups"
};
}
// Gets a single group.
rpc GetGroup(GetGroupRequest) returns (Group) {
option (google.api.http) = {
get: "/v3/{name=projects/*/groups/*}"
};
}
// Creates a new group.
rpc CreateGroup(CreateGroupRequest) returns (Group) {
option (google.api.http) = {
post: "/v3/{name=projects/*}/groups"
body: "group"
};
}
// Updates an existing group.
// You can change any group attributes except `name`.
rpc UpdateGroup(UpdateGroupRequest) returns (Group) {
option (google.api.http) = {
put: "/v3/{group.name=projects/*/groups/*}"
body: "group"
};
}
// Deletes an existing group.
rpc DeleteGroup(DeleteGroupRequest) returns (google.protobuf.Empty) {
option (google.api.http) = {
delete: "/v3/{name=projects/*/groups/*}"
};
}
// Lists the monitored resources that are members of a group.
rpc ListGroupMembers(ListGroupMembersRequest) returns (ListGroupMembersResponse) {
option (google.api.http) = {
get: "/v3/{name=projects/*/groups/*}/members"
};
}
}
// The `ListGroup` request.
message ListGroupsRequest {
// The project whose groups are to be listed. The format is
// `"projects/{project_id_or_number}"`.
string name = 7;
// An optional filter consisting of a single group name. The filters limit
// the groups returned based on their parent-child relationship with the
// specified group. If no filter is specified, all groups are returned.
oneof filter {
// A group name: `"projects/{project_id_or_number}/groups/{group_id}"`.
// Returns groups whose `parentName` field contains the group
// name. If no groups have this parent, the results are empty.
string children_of_group = 2;
// A group name: `"projects/{project_id_or_number}/groups/{group_id}"`.
// Returns groups that are ancestors of the specified group.
// The groups are returned in order, starting with the immediate parent and
// ending with the most distant ancestor. If the specified group has no
// immediate parent, the results are empty.
string ancestors_of_group = 3;
// A group name: `"projects/{project_id_or_number}/groups/{group_id}"`.
// Returns the descendants of the specified group. This is a superset of
// the results returned by the `childrenOfGroup` filter, and includes
// children-of-children, and so forth.
string descendants_of_group = 4;
}
// A positive number that is the maximum number of results to return.
int32 page_size = 5;
// If this field is not empty then it must contain the `nextPageToken` value
// returned by a previous call to this method. Using this field causes the
// method to return additional results from the previous method call.
string page_token = 6;
}
// The `ListGroups` response.
message ListGroupsResponse {
// The groups that match the specified filters.
repeated Group group = 1;
// If there are more results than have been returned, then this field is set
// to a non-empty value. To see the additional results,
// use that value as `pageToken` in the next call to this method.
string next_page_token = 2;
}
// The `GetGroup` request.
message GetGroupRequest {
// The group to retrieve. The format is
// `"projects/{project_id_or_number}/groups/{group_id}"`.
string name = 3;
}
// The `CreateGroup` request.
message CreateGroupRequest {
// The project in which to create the group. The format is
// `"projects/{project_id_or_number}"`.
string name = 4;
// A group definition. It is an error to define the `name` field because
// the system assigns the name.
Group group = 2;
// If true, validate this request but do not create the group.
bool validate_only = 3;
}
// The `UpdateGroup` request.
message UpdateGroupRequest {
// The new definition of the group. All fields of the existing group,
// excepting `name`, are replaced with the corresponding fields of this group.
Group group = 2;
// If true, validate this request but do not update the existing group.
bool validate_only = 3;
}
// The `DeleteGroup` request. The default behavior is to be able to delete a
// single group without any descendants.
message DeleteGroupRequest {
// The group to delete. The format is
// `"projects/{project_id_or_number}/groups/{group_id}"`.
string name = 3;
// If this field is true, then the request means to delete a group with all
// its descendants. Otherwise, the request means to delete a group only when
// it has no descendants. The default value is false.
bool recursive = 4;
}
// The `ListGroupMembers` request.
message ListGroupMembersRequest {
// The group whose members are listed. The format is
// `"projects/{project_id_or_number}/groups/{group_id}"`.
string name = 7;
// A positive number that is the maximum number of results to return.
int32 page_size = 3;
// If this field is not empty then it must contain the `nextPageToken` value
// returned by a previous call to this method. Using this field causes the
// method to return additional results from the previous method call.
string page_token = 4;
// An optional [list filter](/monitoring/api/learn_more#filtering) describing
// the members to be returned. The filter may reference the type, labels, and
// metadata of monitored resources that comprise the group.
// For example, to return only resources representing Compute Engine VM
// instances, use this filter:
//
// resource.type = "gce_instance"
string filter = 5;
// An optional time interval for which results should be returned. Only
// members that were part of the group during the specified interval are
// included in the response. If no interval is provided then the group
// membership over the last minute is returned.
TimeInterval interval = 6;
}
// The `ListGroupMembers` response.
message ListGroupMembersResponse {
// A set of monitored resources in the group.
repeated google.api.MonitoredResource members = 1;
// If there are more results than have been returned, then this field is
// set to a non-empty value. To see the additional results, use that value as
// `pageToken` in the next call to this method.
string next_page_token = 2;
// The total number of elements matching this request.
int32 total_size = 3;
}

96
node_modules/google-gax/protos/google/monitoring/v3/metric.proto generated vendored Normal file
View File

@ -0,0 +1,96 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
import "google/api/distribution.proto";
import "google/api/label.proto";
import "google/api/metric.proto";
import "google/api/monitored_resource.proto";
import "google/monitoring/v3/common.proto";
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "MetricProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// A single data point in a time series.
message Point {
// The time interval to which the data point applies. For `GAUGE` metrics,
// the start time is optional, but if it is supplied, it must equal the
// end time. For `DELTA` metrics, the start
// and end time should specify a non-zero interval, with subsequent points
// specifying contiguous and non-overlapping intervals. For `CUMULATIVE`
// metrics, the start and end time should specify a non-zero interval, with
// subsequent points specifying the same start time and increasing end times,
// until an event resets the cumulative value to zero and sets a new start
// time for the following points.
TimeInterval interval = 1;
// The value of the data point.
TypedValue value = 2;
}
// 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.
message TimeSeries {
// The associated metric. A fully-specified metric used to identify the time
// series.
google.api.Metric metric = 1;
// The associated monitored resource. Custom metrics can use only certain
// monitored resource types in their time series data.
google.api.MonitoredResource resource = 2;
// Output only. The associated monitored resource metadata. When reading a
// a timeseries, this field will include metadata labels that are explicitly
// named in the reduction. When creating a timeseries, this field is ignored.
google.api.MonitoredResourceMetadata metadata = 7;
// The metric kind of the time series. When listing time series, this metric
// kind might be different from the metric kind of the associated metric if
// this time series is an alignment or reduction of other time series.
//
// When creating a time series, this field is optional. If present, it must be
// the same as the metric kind of the associated metric. If the associated
// metric's descriptor must be auto-created, then this field specifies the
// metric kind of the new descriptor and must be either `GAUGE` (the default)
// or `CUMULATIVE`.
google.api.MetricDescriptor.MetricKind metric_kind = 3;
// The value type of the time series. When listing time series, this value
// type might be different from the value type of the associated metric if
// this time series is an alignment or reduction of other time series.
//
// When creating a time series, this field is optional. If present, it must be
// the same as the type of the data in the `points` field.
google.api.MetricDescriptor.ValueType value_type = 4;
// The data points of this time series. When listing time series, points are
// returned in reverse time order.
//
// When creating a time series, this field must contain exactly one point and
// the point's type must be the same as the value type of the associated
// metric. If the associated metric's descriptor must be auto-created, then
// the value type of the descriptor is determined by the point's type, which
// must be `BOOL`, `INT64`, `DOUBLE`, or `DISTRIBUTION`.
repeated Point points = 5;
}

341
node_modules/google-gax/protos/google/monitoring/v3/metric_service.proto generated vendored Normal file
View File

@ -0,0 +1,341 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
import "google/api/annotations.proto";
import "google/api/metric.proto";
import "google/api/monitored_resource.proto";
import "google/monitoring/v3/alert.proto";
import "google/monitoring/v3/common.proto";
import "google/monitoring/v3/metric.proto";
import "google/protobuf/duration.proto";
import "google/protobuf/empty.proto";
import "google/rpc/status.proto";
import "google/api/client.proto";
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "MetricServiceProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// Manages metric descriptors, monitored resource descriptors, and
// time series data.
service MetricService {
option (google.api.default_host) = "monitoring.googleapis.com";
option (google.api.oauth_scopes) =
"https://www.googleapis.com/auth/cloud-platform,"
"https://www.googleapis.com/auth/monitoring,"
"https://www.googleapis.com/auth/monitoring.read,"
"https://www.googleapis.com/auth/monitoring.write";
// Lists monitored resource descriptors that match a filter. This method does not require a Stackdriver account.
rpc ListMonitoredResourceDescriptors(ListMonitoredResourceDescriptorsRequest) returns (ListMonitoredResourceDescriptorsResponse) {
option (google.api.http) = {
get: "/v3/{name=projects/*}/monitoredResourceDescriptors"
};
}
// Gets a single monitored resource descriptor. This method does not require a Stackdriver account.
rpc GetMonitoredResourceDescriptor(GetMonitoredResourceDescriptorRequest) returns (google.api.MonitoredResourceDescriptor) {
option (google.api.http) = {
get: "/v3/{name=projects/*/monitoredResourceDescriptors/*}"
};
}
// Lists metric descriptors that match a filter. This method does not require a Stackdriver account.
rpc ListMetricDescriptors(ListMetricDescriptorsRequest) returns (ListMetricDescriptorsResponse) {
option (google.api.http) = {
get: "/v3/{name=projects/*}/metricDescriptors"
};
}
// Gets a single metric descriptor. This method does not require a Stackdriver account.
rpc GetMetricDescriptor(GetMetricDescriptorRequest) returns (google.api.MetricDescriptor) {
option (google.api.http) = {
get: "/v3/{name=projects/*/metricDescriptors/**}"
};
}
// Creates a new metric descriptor.
// User-created metric descriptors define
// [custom metrics](/monitoring/custom-metrics).
rpc CreateMetricDescriptor(CreateMetricDescriptorRequest) returns (google.api.MetricDescriptor) {
option (google.api.http) = {
post: "/v3/{name=projects/*}/metricDescriptors"
body: "metric_descriptor"
};
}
// Deletes a metric descriptor. Only user-created
// [custom metrics](/monitoring/custom-metrics) can be deleted.
rpc DeleteMetricDescriptor(DeleteMetricDescriptorRequest) returns (google.protobuf.Empty) {
option (google.api.http) = {
delete: "/v3/{name=projects/*/metricDescriptors/**}"
};
}
// Lists time series that match a filter. This method does not require a Stackdriver account.
rpc ListTimeSeries(ListTimeSeriesRequest) returns (ListTimeSeriesResponse) {
option (google.api.http) = {
get: "/v3/{name=projects/*}/timeSeries"
};
}
// 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.
rpc CreateTimeSeries(CreateTimeSeriesRequest) returns (google.protobuf.Empty) {
option (google.api.http) = {
post: "/v3/{name=projects/*}/timeSeries"
body: "*"
};
}
}
// The `ListMonitoredResourceDescriptors` request.
message ListMonitoredResourceDescriptorsRequest {
// The project on which to execute the request. The format is
// `"projects/{project_id_or_number}"`.
string name = 5;
// An optional [filter](/monitoring/api/v3/filters) describing
// the descriptors to be returned. The filter can reference
// the descriptor's type and labels. For example, the
// following filter returns only Google Compute Engine descriptors
// that have an `id` label:
//
// resource.type = starts_with("gce_") AND resource.label:id
string filter = 2;
// A positive number that is the maximum number of results to return.
int32 page_size = 3;
// If this field is not empty then it must contain the `nextPageToken` value
// returned by a previous call to this method. Using this field causes the
// method to return additional results from the previous method call.
string page_token = 4;
}
// The `ListMonitoredResourceDescriptors` response.
message ListMonitoredResourceDescriptorsResponse {
// The monitored resource descriptors that are available to this project
// and that match `filter`, if present.
repeated google.api.MonitoredResourceDescriptor resource_descriptors = 1;
// If there are more results than have been returned, then this field is set
// to a non-empty value. To see the additional results,
// use that value as `pageToken` in the next call to this method.
string next_page_token = 2;
}
// The `GetMonitoredResourceDescriptor` request.
message GetMonitoredResourceDescriptorRequest {
// The monitored resource descriptor to get. The format is
// `"projects/{project_id_or_number}/monitoredResourceDescriptors/{resource_type}"`.
// The `{resource_type}` is a predefined type, such as
// `cloudsql_database`.
string name = 3;
}
// The `ListMetricDescriptors` request.
message ListMetricDescriptorsRequest {
// The project on which to execute the request. The format is
// `"projects/{project_id_or_number}"`.
string name = 5;
// If this field is empty, all custom and
// system-defined metric descriptors are returned.
// Otherwise, the [filter](/monitoring/api/v3/filters)
// specifies which metric descriptors are to be
// returned. For example, the following filter matches all
// [custom metrics](/monitoring/custom-metrics):
//
// metric.type = starts_with("custom.googleapis.com/")
string filter = 2;
// A positive number that is the maximum number of results to return.
int32 page_size = 3;
// If this field is not empty then it must contain the `nextPageToken` value
// returned by a previous call to this method. Using this field causes the
// method to return additional results from the previous method call.
string page_token = 4;
}
// The `ListMetricDescriptors` response.
message ListMetricDescriptorsResponse {
// The metric descriptors that are available to the project
// and that match the value of `filter`, if present.
repeated google.api.MetricDescriptor metric_descriptors = 1;
// If there are more results than have been returned, then this field is set
// to a non-empty value. To see the additional results,
// use that value as `pageToken` in the next call to this method.
string next_page_token = 2;
}
// The `GetMetricDescriptor` request.
message GetMetricDescriptorRequest {
// The metric descriptor on which to execute the request. The format is
// `"projects/{project_id_or_number}/metricDescriptors/{metric_id}"`.
// An example value of `{metric_id}` is
// `"compute.googleapis.com/instance/disk/read_bytes_count"`.
string name = 3;
}
// The `CreateMetricDescriptor` request.
message CreateMetricDescriptorRequest {
// The project on which to execute the request. The format is
// `"projects/{project_id_or_number}"`.
string name = 3;
// The new [custom metric](/monitoring/custom-metrics)
// descriptor.
google.api.MetricDescriptor metric_descriptor = 2;
}
// The `DeleteMetricDescriptor` request.
message DeleteMetricDescriptorRequest {
// The metric descriptor on which to execute the request. The format is
// `"projects/{project_id_or_number}/metricDescriptors/{metric_id}"`.
// An example of `{metric_id}` is:
// `"custom.googleapis.com/my_test_metric"`.
string name = 3;
}
// The `ListTimeSeries` request.
message ListTimeSeriesRequest {
// Controls which fields are returned by `ListTimeSeries`.
enum TimeSeriesView {
// Returns the identity of the metric(s), the time series,
// and the time series data.
FULL = 0;
// Returns the identity of the metric and the time series resource,
// but not the time series data.
HEADERS = 1;
}
// The project on which to execute the request. The format is
// "projects/{project_id_or_number}".
string name = 10;
// A [monitoring filter](/monitoring/api/v3/filters) that specifies which time
// series should be returned. The filter must specify a single metric type,
// and can additionally specify metric labels and other information. For
// example:
//
// metric.type = "compute.googleapis.com/instance/cpu/usage_time" AND
// metric.labels.instance_name = "my-instance-name"
string filter = 2;
// The time interval for which results should be returned. Only time series
// that contain data points in the specified interval are included
// in the response.
TimeInterval interval = 4;
// Specifies the alignment of data points in individual time series as
// well as how to combine the retrieved time series across specified labels.
//
// By default (if no `aggregation` is explicitly specified), the raw time
// series data is returned.
Aggregation aggregation = 5;
// Unsupported: must be left blank. The points in each time series are
// currently returned in reverse time order (most recent to oldest).
string order_by = 6;
// Specifies which information is returned about the time series.
TimeSeriesView view = 7;
// A positive number that is the maximum number of results to return. If
// `page_size` is empty or more than 100,000 results, the effective
// `page_size` is 100,000 results. If `view` is set to `FULL`, this is the
// maximum number of `Points` returned. If `view` is set to `HEADERS`, this is
// the maximum number of `TimeSeries` returned.
int32 page_size = 8;
// If this field is not empty then it must contain the `nextPageToken` value
// returned by a previous call to this method. Using this field causes the
// method to return additional results from the previous method call.
string page_token = 9;
}
// The `ListTimeSeries` response.
message ListTimeSeriesResponse {
// One or more time series that match the filter included in the request.
repeated TimeSeries time_series = 1;
// If there are more results than have been returned, then this field is set
// to a non-empty value. To see the additional results,
// use that value as `pageToken` in the next call to this method.
string next_page_token = 2;
// Query execution errors that may have caused the time series data returned
// to be incomplete.
repeated google.rpc.Status execution_errors = 3;
}
// The `CreateTimeSeries` request.
message CreateTimeSeriesRequest {
// The project on which to execute the request. The format is
// `"projects/{project_id_or_number}"`.
string name = 3;
// The new data to be added to a list of time series.
// Adds at most one data point to each of several time series. The new data
// point must be more recent than any other point in its time series. Each
// `TimeSeries` value must fully specify a unique time series by supplying
// all label values for the metric and the monitored resource.
//
// The maximum number of `TimeSeries` objects per `Create` request is 200.
repeated TimeSeries time_series = 2;
}
// DEPRECATED. Used to hold per-time-series error status.
message CreateTimeSeriesError {
// DEPRECATED. Time series ID that resulted in the `status` error.
TimeSeries time_series = 1 [deprecated = true];
// DEPRECATED. The status of the requested write operation for `time_series`.
google.rpc.Status status = 2 [deprecated = true];
}
// Summary of the result of a failed request to write data to a time series.
message CreateTimeSeriesSummary {
// Detailed information about an error category.
message Error {
// The status of the requested write operation.
google.rpc.Status status = 1;
// The number of points that couldn't be written because of `status`.
int32 point_count = 2;
}
// The number of points in the request.
int32 total_point_count = 1;
// The number of points that were successfully written.
int32 success_point_count = 2;
// The number of points that failed to be written. Order is not guaranteed.
repeated Error errors = 3;
}

36
node_modules/google-gax/protos/google/monitoring/v3/mutation_record.proto generated vendored Normal file
View File

@ -0,0 +1,36 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
import "google/protobuf/timestamp.proto";
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "MutationRecordProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// Describes a change made to a configuration.
message MutationRecord {
// When the change occurred.
google.protobuf.Timestamp mutate_time = 1;
// The email address of the user making the change.
string mutated_by = 2;
}

163
node_modules/google-gax/protos/google/monitoring/v3/notification.proto generated vendored Normal file
View File

@ -0,0 +1,163 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
import "google/api/label.proto";
import "google/api/launch_stage.proto";
import "google/monitoring/v3/common.proto";
import "google/protobuf/wrappers.proto";
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "NotificationProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// A description of a notification channel. The descriptor includes
// the properties of the channel and the set of labels or fields that
// must be specified to configure channels of a given type.
message NotificationChannelDescriptor {
// The full REST resource name for this descriptor. The syntax is:
//
// projects/[PROJECT_ID]/notificationChannelDescriptors/[TYPE]
//
// In the above, `[TYPE]` is the value of the `type` field.
string name = 6;
// The type of notification channel, such as "email", "sms", etc.
// Notification channel types are globally unique.
string type = 1;
// A human-readable name for the notification channel type. This
// form of the name is suitable for a user interface.
string display_name = 2;
// A human-readable description of the notification channel
// type. The description may include a description of the properties
// of the channel and pointers to external documentation.
string description = 3;
// The set of labels that must be defined to identify a particular
// channel of the corresponding type. Each label includes a
// description for how that field should be populated.
repeated google.api.LabelDescriptor labels = 4;
// The tiers that support this notification channel; the project service tier
// must be one of the supported_tiers.
repeated ServiceTier supported_tiers = 5 [deprecated = true];
}
// A `NotificationChannel` is a medium through which an alert is
// delivered when a policy violation is detected. Examples of channels
// include email, SMS, and third-party messaging applications. Fields
// containing sensitive information like authentication tokens or
// contact info are only partially populated on retrieval.
message NotificationChannel {
// Indicates whether the channel has been verified or not. It is illegal
// to specify this field in a
// [`CreateNotificationChannel`][google.monitoring.v3.NotificationChannelService.CreateNotificationChannel]
// or an
// [`UpdateNotificationChannel`][google.monitoring.v3.NotificationChannelService.UpdateNotificationChannel]
// operation.
enum VerificationStatus {
// Sentinel value used to indicate that the state is unknown, omitted, or
// is not applicable (as in the case of channels that neither support
// nor require verification in order to function).
VERIFICATION_STATUS_UNSPECIFIED = 0;
// The channel has yet to be verified and requires verification to function.
// Note that this state also applies to the case where the verification
// process has been initiated by sending a verification code but where
// the verification code has not been submitted to complete the process.
UNVERIFIED = 1;
// It has been proven that notifications can be received on this
// notification channel and that someone on the project has access
// to messages that are delivered to that channel.
VERIFIED = 2;
}
// The type of the notification channel. This field matches the
// value of the [NotificationChannelDescriptor.type][google.monitoring.v3.NotificationChannelDescriptor.type] field.
string type = 1;
// The full REST resource name for this channel. The syntax is:
//
// projects/[PROJECT_ID]/notificationChannels/[CHANNEL_ID]
//
// The `[CHANNEL_ID]` is automatically assigned by the server on creation.
string name = 6;
// An optional human-readable name for this notification channel. It is
// recommended that you specify a non-empty and unique name in order to
// make it easier to identify the channels in your project, though this is
// not enforced. The display name is limited to 512 Unicode characters.
string display_name = 3;
// An optional human-readable description of this notification channel. This
// description may provide additional details, beyond the display
// name, for the channel. This may not exceed 1024 Unicode characters.
string description = 4;
// Configuration fields that define the channel and its behavior. The
// permissible and required labels are specified in the
// [NotificationChannelDescriptor.labels][google.monitoring.v3.NotificationChannelDescriptor.labels] of the
// `NotificationChannelDescriptor` corresponding to the `type` field.
map<string, string> labels = 5;
// User-supplied key/value data that does not need to conform to
// the corresponding `NotificationChannelDescriptor`'s schema, unlike
// the `labels` field. This field is intended to be used for organizing
// and identifying the `NotificationChannel` objects.
//
// The field can contain up to 64 entries. Each key and value is limited to
// 63 Unicode characters or 128 bytes, whichever is smaller. Labels and
// values can contain only lowercase letters, numerals, underscores, and
// dashes. Keys must begin with a letter.
map<string, string> user_labels = 8;
// Indicates whether this channel has been verified or not. On a
// [`ListNotificationChannels`][google.monitoring.v3.NotificationChannelService.ListNotificationChannels]
// or
// [`GetNotificationChannel`][google.monitoring.v3.NotificationChannelService.GetNotificationChannel]
// operation, this field is expected to be populated.
//
// If the value is `UNVERIFIED`, then it indicates that the channel is
// non-functioning (it both requires verification and lacks verification);
// otherwise, it is assumed that the channel works.
//
// If the channel is neither `VERIFIED` nor `UNVERIFIED`, it implies that
// the channel is of a type that does not require verification or that
// this specific channel has been exempted from verification because it was
// created prior to verification being required for channels of this type.
//
// This field cannot be modified using a standard
// [`UpdateNotificationChannel`][google.monitoring.v3.NotificationChannelService.UpdateNotificationChannel]
// operation. To change the value of this field, you must call
// [`VerifyNotificationChannel`][google.monitoring.v3.NotificationChannelService.VerifyNotificationChannel].
VerificationStatus verification_status = 9;
// Whether notifications are forwarded to the described channel. This makes
// it possible to disable delivery of notifications to a particular channel
// without removing the channel from all alerting policies that reference
// the channel. This is a more convenient approach when the change is
// temporary and you want to receive notifications from the same set
// of alerting policies on the channel at some point in the future.
google.protobuf.BoolValue enabled = 11;
}

344
node_modules/google-gax/protos/google/monitoring/v3/notification_service.proto generated vendored Normal file
View File

@ -0,0 +1,344 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
import "google/api/annotations.proto";
import "google/monitoring/v3/notification.proto";
import "google/protobuf/empty.proto";
import "google/protobuf/field_mask.proto";
import "google/protobuf/struct.proto";
import "google/protobuf/timestamp.proto";
import "google/api/client.proto";
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "NotificationServiceProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// The Notification Channel API provides access to configuration that
// controls how messages related to incidents are sent.
service NotificationChannelService {
option (google.api.default_host) = "monitoring.googleapis.com";
option (google.api.oauth_scopes) =
"https://www.googleapis.com/auth/cloud-platform,"
"https://www.googleapis.com/auth/monitoring,"
"https://www.googleapis.com/auth/monitoring.read";
// Lists the descriptors for supported channel types. The use of descriptors
// makes it possible for new channel types to be dynamically added.
rpc ListNotificationChannelDescriptors(ListNotificationChannelDescriptorsRequest) returns (ListNotificationChannelDescriptorsResponse) {
option (google.api.http) = {
get: "/v3/{name=projects/*}/notificationChannelDescriptors"
};
}
// Gets a single channel descriptor. The descriptor indicates which fields
// are expected / permitted for a notification channel of the given type.
rpc GetNotificationChannelDescriptor(GetNotificationChannelDescriptorRequest) returns (NotificationChannelDescriptor) {
option (google.api.http) = {
get: "/v3/{name=projects/*/notificationChannelDescriptors/*}"
};
}
// Lists the notification channels that have been created for the project.
rpc ListNotificationChannels(ListNotificationChannelsRequest) returns (ListNotificationChannelsResponse) {
option (google.api.http) = {
get: "/v3/{name=projects/*}/notificationChannels"
};
}
// Gets a single notification channel. The channel includes the relevant
// configuration details with which the channel was created. However, the
// response may truncate or omit passwords, API keys, or other private key
// matter and thus the response may not be 100% identical to the information
// that was supplied in the call to the create method.
rpc GetNotificationChannel(GetNotificationChannelRequest) returns (NotificationChannel) {
option (google.api.http) = {
get: "/v3/{name=projects/*/notificationChannels/*}"
};
}
// Creates a new notification channel, representing a single notification
// endpoint such as an email address, SMS number, or PagerDuty service.
rpc CreateNotificationChannel(CreateNotificationChannelRequest) returns (NotificationChannel) {
option (google.api.http) = {
post: "/v3/{name=projects/*}/notificationChannels"
body: "notification_channel"
};
}
// Updates a notification channel. Fields not specified in the field mask
// remain unchanged.
rpc UpdateNotificationChannel(UpdateNotificationChannelRequest) returns (NotificationChannel) {
option (google.api.http) = {
patch: "/v3/{notification_channel.name=projects/*/notificationChannels/*}"
body: "notification_channel"
};
}
// Deletes a notification channel.
rpc DeleteNotificationChannel(DeleteNotificationChannelRequest) returns (google.protobuf.Empty) {
option (google.api.http) = {
delete: "/v3/{name=projects/*/notificationChannels/*}"
};
}
// Causes a verification code to be delivered to the channel. The code
// can then be supplied in `VerifyNotificationChannel` to verify the channel.
rpc SendNotificationChannelVerificationCode(SendNotificationChannelVerificationCodeRequest) returns (google.protobuf.Empty) {
option (google.api.http) = {
post: "/v3/{name=projects/*/notificationChannels/*}:sendVerificationCode"
body: "*"
};
}
// Requests a verification code for an already verified channel that can then
// be used in a call to VerifyNotificationChannel() on a different channel
// with an equivalent identity in the same or in a different project. This
// makes it possible to copy a channel between projects without requiring
// manual reverification of the channel. If the channel is not in the
// verified state, this method will fail (in other words, this may only be
// used if the SendNotificationChannelVerificationCode and
// VerifyNotificationChannel paths have already been used to put the given
// channel into the verified state).
//
// There is no guarantee that the verification codes returned by this method
// will be of a similar structure or form as the ones that are delivered
// to the channel via SendNotificationChannelVerificationCode; while
// VerifyNotificationChannel() will recognize both the codes delivered via
// SendNotificationChannelVerificationCode() and returned from
// GetNotificationChannelVerificationCode(), it is typically the case that
// the verification codes delivered via
// SendNotificationChannelVerificationCode() will be shorter and also
// have a shorter expiration (e.g. codes such as "G-123456") whereas
// GetVerificationCode() will typically return a much longer, websafe base
// 64 encoded string that has a longer expiration time.
rpc GetNotificationChannelVerificationCode(GetNotificationChannelVerificationCodeRequest) returns (GetNotificationChannelVerificationCodeResponse) {
option (google.api.http) = {
post: "/v3/{name=projects/*/notificationChannels/*}:getVerificationCode"
body: "*"
};
}
// Verifies a `NotificationChannel` by proving receipt of the code
// delivered to the channel as a result of calling
// `SendNotificationChannelVerificationCode`.
rpc VerifyNotificationChannel(VerifyNotificationChannelRequest) returns (NotificationChannel) {
option (google.api.http) = {
post: "/v3/{name=projects/*/notificationChannels/*}:verify"
body: "*"
};
}
}
// The `ListNotificationChannelDescriptors` request.
message ListNotificationChannelDescriptorsRequest {
// The REST resource name of the parent from which to retrieve
// the notification channel descriptors. The expected syntax is:
//
// projects/[PROJECT_ID]
//
// Note that this names the parent container in which to look for the
// descriptors; to retrieve a single descriptor by name, use the
// [GetNotificationChannelDescriptor][google.monitoring.v3.NotificationChannelService.GetNotificationChannelDescriptor]
// operation, instead.
string name = 4;
// The maximum number of results to return in a single response. If
// not set to a positive number, a reasonable value will be chosen by the
// service.
int32 page_size = 2;
// If non-empty, `page_token` must contain a value returned as the
// `next_page_token` in a previous response to request the next set
// of results.
string page_token = 3;
}
// The `ListNotificationChannelDescriptors` response.
message ListNotificationChannelDescriptorsResponse {
// The monitored resource descriptors supported for the specified
// project, optionally filtered.
repeated NotificationChannelDescriptor channel_descriptors = 1;
// If not empty, indicates that there may be more results that match
// the request. Use the value in the `page_token` field in a
// subsequent request to fetch the next set of results. If empty,
// all results have been returned.
string next_page_token = 2;
}
// The `GetNotificationChannelDescriptor` response.
message GetNotificationChannelDescriptorRequest {
// The channel type for which to execute the request. The format is
// `projects/[PROJECT_ID]/notificationChannelDescriptors/{channel_type}`.
string name = 3;
}
// The `CreateNotificationChannel` request.
message CreateNotificationChannelRequest {
// The project on which to execute the request. The format is:
//
// projects/[PROJECT_ID]
//
// Note that this names the container into which the channel will be
// written. This does not name the newly created channel. The resulting
// channel's name will have a normalized version of this field as a prefix,
// but will add `/notificationChannels/[CHANNEL_ID]` to identify the channel.
string name = 3;
// The definition of the `NotificationChannel` to create.
NotificationChannel notification_channel = 2;
}
// The `ListNotificationChannels` request.
message ListNotificationChannelsRequest {
// The project on which to execute the request. The format is
// `projects/[PROJECT_ID]`. That is, this names the container
// in which to look for the notification channels; it does not name a
// specific channel. To query a specific channel by REST resource name, use
// the
// [`GetNotificationChannel`][google.monitoring.v3.NotificationChannelService.GetNotificationChannel]
// operation.
string name = 5;
// If provided, this field specifies the criteria that must be met by
// notification channels to be included in the response.
//
// For more details, see [sorting and
// filtering](/monitoring/api/v3/sorting-and-filtering).
string filter = 6;
// A comma-separated list of fields by which to sort the result. Supports
// the same set of fields as in `filter`. Entries can be prefixed with
// a minus sign to sort in descending rather than ascending order.
//
// For more details, see [sorting and
// filtering](/monitoring/api/v3/sorting-and-filtering).
string order_by = 7;
// The maximum number of results to return in a single response. If
// not set to a positive number, a reasonable value will be chosen by the
// service.
int32 page_size = 3;
// If non-empty, `page_token` must contain a value returned as the
// `next_page_token` in a previous response to request the next set
// of results.
string page_token = 4;
}
// The `ListNotificationChannels` response.
message ListNotificationChannelsResponse {
// The notification channels defined for the specified project.
repeated NotificationChannel notification_channels = 3;
// If not empty, indicates that there may be more results that match
// the request. Use the value in the `page_token` field in a
// subsequent request to fetch the next set of results. If empty,
// all results have been returned.
string next_page_token = 2;
}
// The `GetNotificationChannel` request.
message GetNotificationChannelRequest {
// The channel for which to execute the request. The format is
// `projects/[PROJECT_ID]/notificationChannels/[CHANNEL_ID]`.
string name = 3;
}
// The `UpdateNotificationChannel` request.
message UpdateNotificationChannelRequest {
// The fields to update.
google.protobuf.FieldMask update_mask = 2;
// A description of the changes to be applied to the specified
// notification channel. The description must provide a definition for
// fields to be updated; the names of these fields should also be
// included in the `update_mask`.
NotificationChannel notification_channel = 3;
}
// The `DeleteNotificationChannel` request.
message DeleteNotificationChannelRequest {
// The channel for which to execute the request. The format is
// `projects/[PROJECT_ID]/notificationChannels/[CHANNEL_ID]`.
string name = 3;
// If true, the notification channel will be deleted regardless of its
// use in alert policies (the policies will be updated to remove the
// channel). If false, channels that are still referenced by an existing
// alerting policy will fail to be deleted in a delete operation.
bool force = 5;
}
// The `SendNotificationChannelVerificationCode` request.
message SendNotificationChannelVerificationCodeRequest {
// The notification channel to which to send a verification code.
string name = 1;
}
// The `GetNotificationChannelVerificationCode` request.
message GetNotificationChannelVerificationCodeRequest {
// The notification channel for which a verification code is to be generated
// and retrieved. This must name a channel that is already verified; if
// the specified channel is not verified, the request will fail.
string name = 1;
// The desired expiration time. If specified, the API will guarantee that
// the returned code will not be valid after the specified timestamp;
// however, the API cannot guarantee that the returned code will be
// valid for at least as long as the requested time (the API puts an upper
// bound on the amount of time for which a code may be valid). If omitted,
// a default expiration will be used, which may be less than the max
// permissible expiration (so specifying an expiration may extend the
// code's lifetime over omitting an expiration, even though the API does
// impose an upper limit on the maximum expiration that is permitted).
google.protobuf.Timestamp expire_time = 2;
}
// The `GetNotificationChannelVerificationCode` request.
message GetNotificationChannelVerificationCodeResponse {
// The verification code, which may be used to verify other channels
// that have an equivalent identity (i.e. other channels of the same
// type with the same fingerprint such as other email channels with
// the same email address or other sms channels with the same number).
string code = 1;
// The expiration time associated with the code that was returned. If
// an expiration was provided in the request, this is the minimum of the
// requested expiration in the request and the max permitted expiration.
google.protobuf.Timestamp expire_time = 2;
}
// The `VerifyNotificationChannel` request.
message VerifyNotificationChannelRequest {
// The notification channel to verify.
string name = 1;
// The verification code that was delivered to the channel as
// a result of invoking the `SendNotificationChannelVerificationCode` API
// method or that was retrieved from a verified channel via
// `GetNotificationChannelVerificationCode`. For example, one might have
// "G-123456" or "TKNZGhhd2EyN3I1MnRnMjRv" (in general, one is only
// guaranteed that the code is valid UTF-8; one should not
// make any assumptions regarding the structure or format of the code).
string code = 2;
}

379
node_modules/google-gax/protos/google/monitoring/v3/service.proto generated vendored Normal file
View File

@ -0,0 +1,379 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
import "google/api/monitored_resource.proto";
import "google/protobuf/duration.proto";
import "google/protobuf/timestamp.proto";
import "google/type/calendar_period.proto";
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "ServiceMonitoringProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// A `Service` is a discrete, autonomous, and network-accessible unit, designed
// to solve an individual concern
// ([Wikipedia](https://en.wikipedia.org/wiki/Service-orientation)). In
// Stackdriver Monitoring, a `Service` acts as the root resource under which
// operational aspects of the service are accessible.
message Service {
// Custom view of service telemetry. Currently a place-holder pending final
// design.
message Custom {
}
// App Engine service. Learn more at https://cloud.google.com/appengine.
message AppEngine {
// The ID of the App Engine module underlying this service. Corresponds to
// the `module_id` resource label in the `gae_app` monitored resource:
// https://cloud.google.com/monitoring/api/resources#tag_gae_app
string module_id = 1;
}
// Cloud Endpoints service. Learn more at https://cloud.google.com/endpoints.
message CloudEndpoints {
// The name of the Cloud Endpoints service underlying this service.
// Corresponds to the `service` resource label in the `api` monitored
// resource: https://cloud.google.com/monitoring/api/resources#tag_api
string service = 1;
}
// Istio service. Learn more at http://istio.io.
message ClusterIstio {
// The location of the Kubernetes cluster in which this Istio service is
// defined. Corresponds to the `location` resource label in `k8s_cluster`
// resources.
string location = 1;
// The name of the Kubernetes cluster in which this Istio service is
// defined. Corresponds to the `cluster_name` resource label in
// `k8s_cluster` resources.
string cluster_name = 2;
// The namespace of the Istio service underlying this service. Corresponds
// to the `destination_service_namespace` metric label in Istio metrics.
string service_namespace = 3;
// The name of the Istio service underlying this service. Corresponds to the
// `destination_service_name` metric label in Istio metrics.
string service_name = 4;
}
// Configuration for how to query telemetry on a Service.
message Telemetry {
// The full name of the resource that defines this service. Formatted as
// described in https://cloud.google.com/apis/design/resource_names.
string resource_name = 1;
}
// Resource name for this Service. Of the form
// `projects/{project_id}/services/{service_id}`.
string name = 1;
// Name used for UI elements listing this Service.
string display_name = 2;
// REQUIRED. Service-identifying atoms specifying the underlying service.
oneof identifier {
// Custom service type.
Custom custom = 6;
// Type used for App Engine services.
AppEngine app_engine = 7;
// Type used for Cloud Endpoints services.
CloudEndpoints cloud_endpoints = 8;
// Type used for Istio services that live in a Kubernetes cluster.
ClusterIstio cluster_istio = 9;
}
// Configuration for how to query telemetry on a Service.
Telemetry telemetry = 13;
}
// A Service-Level Objective (SLO) describes a level of desired good service. It
// consists of a service-level indicator (SLI), a performance goal, and a period
// over which the objective is to be evaluated against that goal. The SLO can
// use SLIs defined in a number of different manners. Typical SLOs might include
// "99% of requests in each rolling week have latency below 200 milliseconds" or
// "99.5% of requests in each calendar month return successfully."
message ServiceLevelObjective {
// `ServiceLevelObjective.View` determines what form of
// `ServiceLevelObjective` is returned from `GetServiceLevelObjective`,
// `ListServiceLevelObjectives`, and `ListServiceLevelObjectiveVersions` RPCs.
enum View {
// Same as FULL.
VIEW_UNSPECIFIED = 0;
// Return the embedded `ServiceLevelIndicator` in the form in which it was
// defined. If it was defined using a `BasicSli`, return that `BasicSli`.
FULL = 2;
// For `ServiceLevelIndicator`s using `BasicSli` articulation, instead
// return the `ServiceLevelIndicator` with its mode of computation fully
// spelled out as a `RequestBasedSli`. For `ServiceLevelIndicator`s using
// `RequestBasedSli` or `WindowsBasedSli`, return the
// `ServiceLevelIndicator` as it was provided.
EXPLICIT = 1;
}
// Resource name for this `ServiceLevelObjective`.
// Of the form
// `projects/{project_id}/services/{service_id}/serviceLevelObjectives/{slo_name}`.
string name = 1;
// Name used for UI elements listing this SLO.
string display_name = 11;
// The definition of good service, used to measure and calculate the quality
// of the `Service`'s performance with respect to a single aspect of service
// quality.
ServiceLevelIndicator service_level_indicator = 3;
// The fraction of service that must be good in order for this objective to be
// met. `0 < goal <= 0.999`.
double goal = 4;
// The time period over which the objective will be evaluated.
oneof period {
// A rolling time period, semantically "in the past `<rolling_period>`".
// Must be an integer multiple of 1 day no larger than 30 days.
google.protobuf.Duration rolling_period = 5;
// A calendar period, semantically "since the start of the current
// `<calendar_period>`". At this time, only `DAY`, `WEEK`, `FORTNIGHT`, and
// `MONTH` are supported.
google.type.CalendarPeriod calendar_period = 6;
}
}
// A Service-Level Indicator (SLI) describes the "performance" of a service. For
// some services, the SLI is well-defined. In such cases, the SLI can be
// described easily by referencing the well-known SLI and providing the needed
// parameters. Alternatively, a "custom" SLI can be defined with a query to the
// underlying metric store. An SLI is defined to be `good_service /
// total_service` over any queried time interval. The value of performance
// always falls into the range `0 <= performance <= 1`. A custom SLI describes
// how to compute this ratio, whether this is by dividing values from a pair of
// time series, cutting a `Distribution` into good and bad counts, or counting
// time windows in which the service complies with a criterion. For separation
// of concerns, a single Service-Level Indicator measures performance for only
// one aspect of service quality, such as fraction of successful queries or
// fast-enough queries.
message ServiceLevelIndicator {
// Service level indicators can be grouped by whether the "unit" of service
// being measured is based on counts of good requests or on counts of good
// time windows
oneof type {
// Basic SLI on a well-known service type.
BasicSli basic_sli = 4;
// Request-based SLIs
RequestBasedSli request_based = 1;
// Windows-based SLIs
WindowsBasedSli windows_based = 2;
}
}
// An SLI measuring performance on a well-known service type. Performance will
// be computed on the basis of pre-defined metrics. The type of the
// `service_resource` determines the metrics to use and the
// `service_resource.labels` and `metric_labels` are used to construct a
// monitoring filter to filter that metric down to just the data relevant to
// this service.
message BasicSli {
// Future parameters for the availability SLI.
message AvailabilityCriteria {
}
// Parameters for a latency threshold SLI.
message LatencyCriteria {
// Good service is defined to be the count of requests made to this service
// that return in no more than `threshold`.
google.protobuf.Duration threshold = 3;
}
// OPTIONAL: The set of RPCs to which this SLI is relevant. Telemetry from
// other methods will not be used to calculate performance for this SLI. If
// omitted, this SLI applies to all the Service's methods. For service types
// that don't support breaking down by method, setting this field will result
// in an error.
repeated string method = 7;
// OPTIONAL: The set of locations to which this SLI is relevant. Telemetry
// from other locations will not be used to calculate performance for this
// SLI. If omitted, this SLI applies to all locations in which the Service has
// activity. For service types that don't support breaking down by location,
// setting this field will result in an error.
repeated string location = 8;
// OPTIONAL: The set of API versions to which this SLI is relevant. Telemetry
// from other API versions will not be used to calculate performance for this
// SLI. If omitted, this SLI applies to all API versions. For service types
// that don't support breaking down by version, setting this field will result
// in an error.
repeated string version = 9;
// This SLI can be evaluated on the basis of availability or latency.
oneof sli_criteria {
// Good service is defined to be the count of requests made to this service
// that return successfully.
AvailabilityCriteria availability = 2;
// Good service is defined to be the count of requests made to this service
// that are fast enough with respect to `latency.threshold`.
LatencyCriteria latency = 3;
}
}
// Range of numerical values, inclusive of `min` and exclusive of `max`. If the
// open range "< range.max" is desired, set `range.min = -infinity`. If the open
// range ">= range.min" is desired, set `range.max = infinity`.
message Range {
// Range minimum.
double min = 1;
// Range maximum.
double max = 2;
}
// Service Level Indicators for which atomic units of service are counted
// directly.
message RequestBasedSli {
// The means to compute a ratio of `good_service` to `total_service`.
oneof method {
// `good_total_ratio` is used when the ratio of `good_service` to
// `total_service` is computed from two `TimeSeries`.
TimeSeriesRatio good_total_ratio = 1;
// `distribution_cut` is used when `good_service` is a count of values
// aggregated in a `Distribution` that fall into a good range. The
// `total_service` is the total count of all values aggregated in the
// `Distribution`.
DistributionCut distribution_cut = 3;
}
}
// A `TimeSeriesRatio` specifies two `TimeSeries` to use for computing the
// `good_service / total_service` ratio. The specified `TimeSeries` must have
// `ValueType = DOUBLE` or `ValueType = INT64` and must have `MetricKind =
// DELTA` or `MetricKind = CUMULATIVE`. The `TimeSeriesRatio` must specify
// exactly two of good, bad, and total, and the relationship `good_service +
// bad_service = total_service` will be assumed.
message TimeSeriesRatio {
// A [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
// specifying a `TimeSeries` quantifying good service provided. Must have
// `ValueType = DOUBLE` or `ValueType = INT64` and must have `MetricKind =
// DELTA` or `MetricKind = CUMULATIVE`.
string good_service_filter = 4;
// A [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
// specifying a `TimeSeries` quantifying bad service, either demanded service
// that was not provided or demanded service that was of inadequate quality.
// Must have `ValueType = DOUBLE` or `ValueType = INT64` and must have
// `MetricKind = DELTA` or `MetricKind = CUMULATIVE`.
string bad_service_filter = 5;
// A [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
// specifying a `TimeSeries` quantifying total demanded service. Must have
// `ValueType = DOUBLE` or `ValueType = INT64` and must have `MetricKind =
// DELTA` or `MetricKind = CUMULATIVE`.
string total_service_filter = 6;
}
// A `DistributionCut` defines a `TimeSeries` and thresholds used for measuring
// good service and total service. The `TimeSeries` must have `ValueType =
// DISTRIBUTION` and `MetricKind = DELTA` or `MetricKind = CUMULATIVE`. The
// computed `good_service` will be the count of values x in the `Distribution`
// such that `range.min <= x < range.max`.
message DistributionCut {
// A [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
// specifying a `TimeSeries` aggregating values. Must have `ValueType =
// DISTRIBUTION` and `MetricKind = DELTA` or `MetricKind = CUMULATIVE`.
string distribution_filter = 4;
// Range of values considered "good." For a one-sided range, set one bound to
// an infinite value.
Range range = 5;
}
// A `WindowsBasedSli` defines `good_service` as the count of time windows for
// which the provided service was of good quality. Criteria for determining
// if service was good are embedded in the `window_criterion`.
message WindowsBasedSli {
// A `PerformanceThreshold` is used when each window is good when that window
// has a sufficiently high `performance`.
message PerformanceThreshold {
// The means, either a request-based SLI or a basic SLI, by which to compute
// performance over a window.
oneof type {
// `RequestBasedSli` to evaluate to judge window quality.
RequestBasedSli performance = 1;
// `BasicSli` to evaluate to judge window quality.
BasicSli basic_sli_performance = 3;
}
// If window `performance >= threshold`, the window is counted as good.
double threshold = 2;
}
// A `MetricRange` is used when each window is good when the value x of a
// single `TimeSeries` satisfies `range.min <= x < range.max`. The provided
// `TimeSeries` must have `ValueType = INT64` or `ValueType = DOUBLE` and
// `MetricKind = GAUGE`.
message MetricRange {
// A [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
// specifying the `TimeSeries` to use for evaluating window quality.
string time_series = 1;
// Range of values considered "good." For a one-sided range, set one bound
// to an infinite value.
Range range = 4;
}
// The criterion to use for evaluating window goodness.
oneof window_criterion {
// A [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
// specifying a `TimeSeries` with `ValueType = BOOL`. The window is good if
// any `true` values appear in the window.
string good_bad_metric_filter = 5;
// A window is good if its `performance` is high enough.
PerformanceThreshold good_total_ratio_threshold = 2;
// A window is good if the metric's value is in a good range, averaged
// across returned streams.
MetricRange metric_mean_in_range = 6;
// A window is good if the metric's value is in a good range, summed across
// returned streams.
MetricRange metric_sum_in_range = 7;
}
// Duration over which window quality is evaluated. Must be an integer
// fraction of a day and at least `60s`.
google.protobuf.Duration window_period = 4;
}

285
node_modules/google-gax/protos/google/monitoring/v3/service_service.proto generated vendored Normal file
View File

@ -0,0 +1,285 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
import "google/api/annotations.proto";
import "google/api/monitored_resource.proto";
import "google/monitoring/v3/service.proto";
import "google/protobuf/empty.proto";
import "google/protobuf/field_mask.proto";
import "google/api/client.proto";
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "ServiceMonitoringServiceProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// The Stackdriver Monitoring Service-Oriented Monitoring API has endpoints for
// managing and querying aspects of a workspace's services. These include the
// `Service`'s monitored resources, its Service-Level Objectives, and a taxonomy
// of categorized Health Metrics.
service ServiceMonitoringService {
option (google.api.default_host) = "monitoring.googleapis.com";
option (google.api.oauth_scopes) =
"https://www.googleapis.com/auth/cloud-platform,"
"https://www.googleapis.com/auth/monitoring,"
"https://www.googleapis.com/auth/monitoring.read";
// Create a `Service`.
rpc CreateService(CreateServiceRequest) returns (Service) {
option (google.api.http) = {
post: "/v3/{parent=*/*}/services"
body: "service"
};
}
// Get the named `Service`.
rpc GetService(GetServiceRequest) returns (Service) {
option (google.api.http) = {
get: "/v3/{name=*/*/services/*}"
};
}
// List `Service`s for this workspace.
rpc ListServices(ListServicesRequest) returns (ListServicesResponse) {
option (google.api.http) = {
get: "/v3/{parent=*/*}/services"
};
}
// Update this `Service`.
rpc UpdateService(UpdateServiceRequest) returns (Service) {
option (google.api.http) = {
patch: "/v3/{service.name=*/*/services/*}"
body: "service"
};
}
// Soft delete this `Service`.
rpc DeleteService(DeleteServiceRequest) returns (google.protobuf.Empty) {
option (google.api.http) = {
delete: "/v3/{name=*/*/services/*}"
};
}
// Create a `ServiceLevelObjective` for the given `Service`.
rpc CreateServiceLevelObjective(CreateServiceLevelObjectiveRequest) returns (ServiceLevelObjective) {
option (google.api.http) = {
post: "/v3/{parent=*/*/services/*}/serviceLevelObjectives"
body: "service_level_objective"
};
}
// Get a `ServiceLevelObjective` by name.
rpc GetServiceLevelObjective(GetServiceLevelObjectiveRequest) returns (ServiceLevelObjective) {
option (google.api.http) = {
get: "/v3/{name=*/*/services/*/serviceLevelObjectives/*}"
};
}
// List the `ServiceLevelObjective`s for the given `Service`.
rpc ListServiceLevelObjectives(ListServiceLevelObjectivesRequest) returns (ListServiceLevelObjectivesResponse) {
option (google.api.http) = {
get: "/v3/{parent=*/*/services/*}/serviceLevelObjectives"
};
}
// Update the given `ServiceLevelObjective`.
rpc UpdateServiceLevelObjective(UpdateServiceLevelObjectiveRequest) returns (ServiceLevelObjective) {
option (google.api.http) = {
patch: "/v3/{service_level_objective.name=*/*/services/*/serviceLevelObjectives/*}"
body: "service_level_objective"
};
}
// Delete the given `ServiceLevelObjective`.
rpc DeleteServiceLevelObjective(DeleteServiceLevelObjectiveRequest) returns (google.protobuf.Empty) {
option (google.api.http) = {
delete: "/v3/{name=*/*/services/*/serviceLevelObjectives/*}"
};
}
}
// The `CreateService` request.
message CreateServiceRequest {
// Resource name of the parent workspace.
// Of the form `projects/{project_id}`.
string parent = 1;
// Optional. The Service id to use for this Service. If omitted, an id will be
// generated instead. Must match the pattern [a-z0-9\-]+
string service_id = 3;
// The `Service` to create.
Service service = 2;
}
// The `GetService` request.
message GetServiceRequest {
// Resource name of the `Service`.
// Of the form `projects/{project_id}/services/{service_id}`.
string name = 1;
}
// The `ListServices` request.
message ListServicesRequest {
// Resource name of the parent `Workspace`.
// Of the form `projects/{project_id}`.
string parent = 1;
// A filter specifying what `Service`s to return. The filter currently
// supports the following fields:
//
// - `identifier_case`
// - `app_engine.module_id`
// - `cloud_endpoints.service`
// - `cluster_istio.location`
// - `cluster_istio.cluster_name`
// - `cluster_istio.service_namespace`
// - `cluster_istio.service_name`
//
// `identifier_case` refers to which option in the identifier oneof is
// populated. For example, the filter `identifier_case = "CUSTOM"` would match
// all services with a value for the `custom` field. Valid options are
// "CUSTOM", "APP_ENGINE", "CLOUD_ENDPOINTS", and "CLUSTER_ISTIO".
string filter = 2;
// A non-negative number that is the maximum number of results to return.
// When 0, use default page size.
int32 page_size = 3;
// If this field is not empty then it must contain the `nextPageToken` value
// returned by a previous call to this method. Using this field causes the
// method to return additional results from the previous method call.
string page_token = 4;
}
// The `ListServices` response.
message ListServicesResponse {
// The `Service`s matching the specified filter.
repeated Service services = 1;
// If there are more results than have been returned, then this field is set
// to a non-empty value. To see the additional results,
// use that value as `pageToken` in the next call to this method.
string next_page_token = 2;
}
// The `UpdateService` request.
message UpdateServiceRequest {
// The `Service` to draw updates from.
// The given `name` specifies the resource to update.
Service service = 1;
// A set of field paths defining which fields to use for the update.
google.protobuf.FieldMask update_mask = 2;
}
// The `DeleteService` request.
message DeleteServiceRequest {
// Resource name of the `Service` to delete.
// Of the form `projects/{project_id}/service/{service_id}`.
string name = 1;
}
// The `CreateServiceLevelObjective` request.
message CreateServiceLevelObjectiveRequest {
// Resource name of the parent `Service`.
// Of the form `projects/{project_id}/services/{service_id}`.
string parent = 1;
// Optional. The ServiceLevelObjective id to use for this
// ServiceLevelObjective. If omitted, an id will be generated instead. Must
// match the pattern [a-z0-9\-]+
string service_level_objective_id = 3;
// The `ServiceLevelObjective` to create.
// The provided `name` will be respected if no `ServiceLevelObjective` exists
// with this name.
ServiceLevelObjective service_level_objective = 2;
}
// The `GetServiceLevelObjective` request.
message GetServiceLevelObjectiveRequest {
// Resource name of the `ServiceLevelObjective` to get.
// Of the form
// `projects/{project_id}/services/{service_id}/serviceLevelObjectives/{slo_name}`.
string name = 1;
// View of the `ServiceLevelObjective` to return. If `DEFAULT`, return the
// `ServiceLevelObjective` as originally defined. If `EXPLICIT` and the
// `ServiceLevelObjective` is defined in terms of a `BasicSli`, replace the
// `BasicSli` with a `RequestBasedSli` spelling out how the SLI is computed.
ServiceLevelObjective.View view = 2;
}
// The `ListServiceLevelObjectives` request.
message ListServiceLevelObjectivesRequest {
// Resource name of the parent `Service`.
// Of the form `projects/{project_id}/services/{service_id}`.
string parent = 1;
// A filter specifying what `ServiceLevelObjective`s to return.
string filter = 2;
// A non-negative number that is the maximum number of results to return.
// When 0, use default page size.
int32 page_size = 3;
// If this field is not empty then it must contain the `nextPageToken` value
// returned by a previous call to this method. Using this field causes the
// method to return additional results from the previous method call.
string page_token = 4;
// View of the `ServiceLevelObjective`s to return. If `DEFAULT`, return each
// `ServiceLevelObjective` as originally defined. If `EXPLICIT` and the
// `ServiceLevelObjective` is defined in terms of a `BasicSli`, replace the
// `BasicSli` with a `RequestBasedSli` spelling out how the SLI is computed.
ServiceLevelObjective.View view = 5;
}
// The `ListServiceLevelObjectives` response.
message ListServiceLevelObjectivesResponse {
// The `ServiceLevelObjective`s matching the specified filter.
repeated ServiceLevelObjective service_level_objectives = 1;
// If there are more results than have been returned, then this field is set
// to a non-empty value. To see the additional results,
// use that value as `pageToken` in the next call to this method.
string next_page_token = 2;
}
// The `UpdateServiceLevelObjective` request.
message UpdateServiceLevelObjectiveRequest {
// The `ServiceLevelObjective` to draw updates from.
// The given `name` specifies the resource to update.
ServiceLevelObjective service_level_objective = 1;
// A set of field paths defining which fields to use for the update.
google.protobuf.FieldMask update_mask = 2;
}
// The `DeleteServiceLevelObjective` request.
message DeleteServiceLevelObjectiveRequest {
// Resource name of the `ServiceLevelObjective` to delete.
// Of the form
// `projects/{project_id}/services/{service_id}/serviceLevelObjectives/{slo_name}`.
string name = 1;
}

43
node_modules/google-gax/protos/google/monitoring/v3/span_context.proto generated vendored Normal file
View File

@ -0,0 +1,43 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "SpanContextProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// The context of a span, attached to google.api.Distribution.Exemplars
// in google.api.Distribution values during aggregation.
//
// It contains the name of a span with format:
// projects/[PROJECT_ID]/traces/[TRACE_ID]/spans/[SPAN_ID]
message SpanContext {
// The resource name of the span in the following format:
//
// projects/[PROJECT_ID]/traces/[TRACE_ID]/spans/[SPAN_ID]
//
// [TRACE_ID] is a unique identifier for a trace within a project;
// it is a 32-character hexadecimal encoding of a 16-byte array.
//
// [SPAN_ID] is a unique identifier for a span within a trace; it
// is a 16-character hexadecimal encoding of an 8-byte array.
string span_name = 1;
}

341
node_modules/google-gax/protos/google/monitoring/v3/uptime.proto generated vendored Normal file
View File

@ -0,0 +1,341 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
import "google/api/monitored_resource.proto";
import "google/protobuf/duration.proto";
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "UptimeProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// An internal checker allows Uptime checks to run on private/internal GCP
// resources.
message InternalChecker {
option deprecated = true;
// Operational states for an internal checker.
enum State {
// An internal checker should never be in the unspecified state.
UNSPECIFIED = 0;
// The checker is being created, provisioned, and configured. A checker in
// this state can be returned by `ListInternalCheckers` or
// `GetInternalChecker`, as well as by examining the [long running
// Operation](https://cloud.google.com/apis/design/design_patterns#long_running_operations)
// that created it.
CREATING = 1;
// The checker is running and available for use. A checker in this state
// can be returned by `ListInternalCheckers` or `GetInternalChecker` as
// well as by examining the [long running
// Operation](https://cloud.google.com/apis/design/design_patterns#long_running_operations)
// that created it.
// If a checker is being torn down, it is neither visible nor usable, so
// there is no "deleting" or "down" state.
RUNNING = 2;
}
// A unique resource name for this InternalChecker. The format is:
//
// `projects/[PROJECT_ID]/internalCheckers/[INTERNAL_CHECKER_ID]`.
//
// `[PROJECT_ID]` is the Stackdriver Workspace project for the
// Uptime check config associated with the internal checker.
string name = 1;
// The checker's human-readable name. The display name
// should be unique within a Stackdriver Workspace in order to make it easier
// to identify; however, uniqueness is not enforced.
string display_name = 2;
// The [GCP VPC network](https://cloud.google.com/vpc/docs/vpc) where the
// internal resource lives (ex: "default").
string network = 3;
// The GCP zone the Uptime check should egress from. Only respected for
// internal Uptime checks, where internal_network is specified.
string gcp_zone = 4;
// The GCP project ID where the internal checker lives. Not necessary
// the same as the Workspace project.
string peer_project_id = 6;
// The current operational state of the internal checker.
State state = 7;
}
// This message configures which resources and services to monitor for
// availability.
message UptimeCheckConfig {
// The resource submessage for group checks. It can be used instead of a
// monitored resource, when multiple resources are being monitored.
message ResourceGroup {
// The group of resources being monitored. Should be only the `[GROUP_ID]`,
// and not the full-path `projects/[PROJECT_ID]/groups/[GROUP_ID]`.
string group_id = 1;
// The resource type of the group members.
GroupResourceType resource_type = 2;
}
// Information involved in an HTTP/HTTPS Uptime check request.
message HttpCheck {
// The authentication parameters to provide to the specified resource or
// URL that requires a username and password. Currently, only
// [Basic HTTP authentication](https://tools.ietf.org/html/rfc7617) is
// supported in Uptime checks.
message BasicAuthentication {
// The username to use when authenticating with the HTTP server.
string username = 1;
// The password to use when authenticating with the HTTP server.
string password = 2;
}
// If `true`, use HTTPS instead of HTTP to run the check.
bool use_ssl = 1;
// Optional (defaults to "/"). The path to the page against which to run
// the check. Will be combined with the `host` (specified within the
// `monitored_resource`) and `port` to construct the full URL. If the
// provided path does not begin with "/", a "/" will be prepended
// automatically.
string path = 2;
// Optional (defaults to 80 when `use_ssl` is `false`, and 443 when
// `use_ssl` is `true`). The TCP port on the HTTP server against which to
// run the check. Will be combined with host (specified within the
// `monitored_resource`) and `path` to construct the full URL.
int32 port = 3;
// The authentication information. Optional when creating an HTTP check;
// defaults to empty.
BasicAuthentication auth_info = 4;
// Boolean specifiying whether to encrypt the header information.
// Encryption should be specified for any headers related to authentication
// that you do not wish to be seen when retrieving the configuration. The
// server will be responsible for encrypting the headers.
// On Get/List calls, if `mask_headers` is set to `true` then the headers
// will be obscured with `******.`
bool mask_headers = 5;
// The list of headers to send as part of the Uptime check request.
// If two headers have the same key and different values, they should
// be entered as a single header, with the value being a comma-separated
// list of all the desired values as described at
// https://www.w3.org/Protocols/rfc2616/rfc2616.txt (page 31).
// Entering two separate headers with the same key in a Create call will
// cause the first to be overwritten by the second.
// The maximum number of headers allowed is 100.
map<string, string> headers = 6;
// Boolean specifying whether to include SSL certificate validation as a
// part of the Uptime check. Only applies to checks where
// `monitored_resource` is set to `uptime_url`. If `use_ssl` is `false`,
// setting `validate_ssl` to `true` has no effect.
bool validate_ssl = 7;
}
// Information required for a TCP Uptime check request.
message TcpCheck {
// The TCP port on the server against which to run the check. Will be
// combined with host (specified within the `monitored_resource`) to
// construct the full URL. Required.
int32 port = 1;
}
// Optional. Used to perform content matching. This allows matching based on
// substrings and regular expressions, together with their negations. Only the
// first 4&nbsp;MB of an HTTP or HTTPS check's response (and the first
// 1&nbsp;MB of a TCP check's response) are examined for purposes of content
// matching.
message ContentMatcher {
// Options to perform content matching.
enum ContentMatcherOption {
// No content matcher type specified (maintained for backward
// compatibility, but deprecated for future use).
// Treated as `CONTAINS_STRING`.
CONTENT_MATCHER_OPTION_UNSPECIFIED = 0;
// Selects substring matching. The match succeeds if the output contains
// the `content` string. This is the default value for checks without
// a `matcher` option, or where the value of `matcher` is
// `CONTENT_MATCHER_OPTION_UNSPECIFIED`.
CONTAINS_STRING = 1;
// Selects negation of substring matching. The match succeeds if the
// output does _NOT_ contain the `content` string.
NOT_CONTAINS_STRING = 2;
// Selects regular-expression matching. The match succeeds of the output
// matches the regular expression specified in the `content` string.
MATCHES_REGEX = 3;
// Selects negation of regular-expression matching. The match succeeds if
// the output does _NOT_ match the regular expression specified in the
// `content` string.
NOT_MATCHES_REGEX = 4;
}
// String or regex content to match. Maximum 1024 bytes. An empty `content`
// string indicates no content matching is to be performed.
string content = 1;
// The type of content matcher that will be applied to the server output,
// compared to the `content` string when the check is run.
ContentMatcherOption matcher = 2;
}
// A unique resource name for this Uptime check configuration. The format is:
//
// `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
//
// This field should be omitted when creating the Uptime check configuration;
// on create, the resource name is assigned by the server and included in the
// response.
string name = 1;
// A human-friendly name for the Uptime check configuration. The display name
// should be unique within a Stackdriver Workspace in order to make it easier
// to identify; however, uniqueness is not enforced. Required.
string display_name = 2;
// The resource the check is checking. Required.
oneof resource {
// The [monitored
// resource](https://cloud.google.com/monitoring/api/resources) associated
// with the configuration.
// The following monitored resource types are supported for Uptime checks:
// `uptime_url`,
// `gce_instance`,
// `gae_app`,
// `aws_ec2_instance`,
// `aws_elb_load_balancer`
google.api.MonitoredResource monitored_resource = 3;
// The group resource associated with the configuration.
ResourceGroup resource_group = 4;
}
// The type of Uptime check request.
oneof check_request_type {
// Contains information needed to make an HTTP or HTTPS check.
HttpCheck http_check = 5;
// Contains information needed to make a TCP check.
TcpCheck tcp_check = 6;
}
// How often, in seconds, the Uptime check is performed.
// Currently, the only supported values are `60s` (1 minute), `300s`
// (5 minutes), `600s` (10 minutes), and `900s` (15 minutes). Optional,
// defaults to `60s`.
google.protobuf.Duration period = 7;
// The maximum amount of time to wait for the request to complete (must be
// between 1 and 60 seconds). Required.
google.protobuf.Duration timeout = 8;
// The content that is expected to appear in the data returned by the target
// server against which the check is run. Currently, only the first entry
// in the `content_matchers` list is supported, and additional entries will
// be ignored. This field is optional and should only be specified if a
// content match is required as part of the/ Uptime check.
repeated ContentMatcher content_matchers = 9;
// The list of regions from which the check will be run.
// Some regions contain one location, and others contain more than one.
// If this field is specified, enough regions must be provided to include a
// minimum of 3 locations. Not specifying this field will result in Uptime
// checks running from all available regions.
repeated UptimeCheckRegion selected_regions = 10;
// If this is `true`, then checks are made only from the 'internal_checkers'.
// If it is `false`, then checks are made only from the 'selected_regions'.
// It is an error to provide 'selected_regions' when is_internal is `true`,
// or to provide 'internal_checkers' when is_internal is `false`.
bool is_internal = 15 [deprecated = true];
// The internal checkers that this check will egress from. If `is_internal` is
// `true` and this list is empty, the check will egress from all the
// InternalCheckers configured for the project that owns this
// `UptimeCheckConfig`.
repeated InternalChecker internal_checkers = 14 [deprecated = true];
}
// The regions from which an Uptime check can be run.
enum UptimeCheckRegion {
// Default value if no region is specified. Will result in Uptime checks
// running from all regions.
REGION_UNSPECIFIED = 0;
// Allows checks to run from locations within the United States of America.
USA = 1;
// Allows checks to run from locations within the continent of Europe.
EUROPE = 2;
// Allows checks to run from locations within the continent of South
// America.
SOUTH_AMERICA = 3;
// Allows checks to run from locations within the Asia Pacific area (ex:
// Singapore).
ASIA_PACIFIC = 4;
}
// Contains the region, location, and list of IP
// addresses where checkers in the location run from.
message UptimeCheckIp {
// A broad region category in which the IP address is located.
UptimeCheckRegion region = 1;
// A more specific location within the region that typically encodes
// a particular city/town/metro (and its containing state/province or country)
// within the broader umbrella region category.
string location = 2;
// The IP address from which the Uptime check originates. This is a fully
// specified IP address (not an IP address range). Most IP addresses, as of
// this publication, are in IPv4 format; however, one should not rely on the
// IP addresses being in IPv4 format indefinitely, and should support
// interpreting this field in either IPv4 or IPv6 format.
string ip_address = 3;
}
// The supported resource types that can be used as values of
// `group_resource.resource_type`.
// `INSTANCE` includes `gce_instance` and `aws_ec2_instance` resource types.
// The resource types `gae_app` and `uptime_url` are not valid here because
// group checks on App Engine modules and URLs are not allowed.
enum GroupResourceType {
// Default value (not valid).
RESOURCE_TYPE_UNSPECIFIED = 0;
// A group of instances from Google Cloud Platform (GCP) or
// Amazon Web Services (AWS).
INSTANCE = 1;
// A group of Amazon ELB load balancers.
AWS_ELB_LOAD_BALANCER = 2;
}

210
node_modules/google-gax/protos/google/monitoring/v3/uptime_service.proto generated vendored Normal file
View File

@ -0,0 +1,210 @@
// Copyright 2019 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
syntax = "proto3";
package google.monitoring.v3;
import "google/api/annotations.proto";
import "google/monitoring/v3/uptime.proto";
import "google/protobuf/duration.proto";
import "google/protobuf/empty.proto";
import "google/protobuf/field_mask.proto";
import "google/api/client.proto";
option csharp_namespace = "Google.Cloud.Monitoring.V3";
option go_package = "google.golang.org/genproto/googleapis/monitoring/v3;monitoring";
option java_multiple_files = true;
option java_outer_classname = "UptimeServiceProto";
option java_package = "com.google.monitoring.v3";
option php_namespace = "Google\\Cloud\\Monitoring\\V3";
// The UptimeCheckService API is used to manage (list, create, delete, edit)
// Uptime check configurations in the Stackdriver Monitoring product. An Uptime
// check is a piece of configuration that determines which resources and
// services to monitor for availability. These configurations can also be
// configured interactively by navigating to the [Cloud Console]
// (http://console.cloud.google.com), selecting the appropriate project,
// clicking on "Monitoring" on the left-hand side to navigate to Stackdriver,
// and then clicking on "Uptime".
service UptimeCheckService {
option (google.api.default_host) = "monitoring.googleapis.com";
option (google.api.oauth_scopes) =
"https://www.googleapis.com/auth/cloud-platform,"
"https://www.googleapis.com/auth/monitoring,"
"https://www.googleapis.com/auth/monitoring.read";
// Lists the existing valid Uptime check configurations for the project
// (leaving out any invalid configurations).
rpc ListUptimeCheckConfigs(ListUptimeCheckConfigsRequest) returns (ListUptimeCheckConfigsResponse) {
option (google.api.http) = {
get: "/v3/{parent=projects/*}/uptimeCheckConfigs"
};
}
// Gets a single Uptime check configuration.
rpc GetUptimeCheckConfig(GetUptimeCheckConfigRequest) returns (UptimeCheckConfig) {
option (google.api.http) = {
get: "/v3/{name=projects/*/uptimeCheckConfigs/*}"
};
}
// Creates a new Uptime check configuration.
rpc CreateUptimeCheckConfig(CreateUptimeCheckConfigRequest) returns (UptimeCheckConfig) {
option (google.api.http) = {
post: "/v3/{parent=projects/*}/uptimeCheckConfigs"
body: "uptime_check_config"
};
}
// Updates an Uptime check configuration. You can either replace the entire
// configuration with a new one or replace only certain fields in the current
// configuration by specifying the fields to be updated via `updateMask`.
// Returns the updated configuration.
rpc UpdateUptimeCheckConfig(UpdateUptimeCheckConfigRequest) returns (UptimeCheckConfig) {
option (google.api.http) = {
patch: "/v3/{uptime_check_config.name=projects/*/uptimeCheckConfigs/*}"
body: "uptime_check_config"
};
}
// Deletes an Uptime check configuration. Note that this method will fail
// if the Uptime check configuration is referenced by an alert policy or
// other dependent configs that would be rendered invalid by the deletion.
rpc DeleteUptimeCheckConfig(DeleteUptimeCheckConfigRequest) returns (google.protobuf.Empty) {
option (google.api.http) = {
delete: "/v3/{name=projects/*/uptimeCheckConfigs/*}"
};
}
// Returns the list of IP addresses that checkers run from
rpc ListUptimeCheckIps(ListUptimeCheckIpsRequest) returns (ListUptimeCheckIpsResponse) {
option (google.api.http) = {
get: "/v3/uptimeCheckIps"
};
}
}
// The protocol for the `ListUptimeCheckConfigs` request.
message ListUptimeCheckConfigsRequest {
// The project whose Uptime check configurations are listed. The format
// is `projects/[PROJECT_ID]`.
string parent = 1;
// The maximum number of results to return in a single response. The server
// may further constrain the maximum number of results returned in a single
// page. If the page_size is <=0, the server will decide the number of results
// to be returned.
int32 page_size = 3;
// If this field is not empty then it must contain the `nextPageToken` value
// returned by a previous call to this method. Using this field causes the
// method to return more results from the previous method call.
string page_token = 4;
}
// The protocol for the `ListUptimeCheckConfigs` response.
message ListUptimeCheckConfigsResponse {
// The returned Uptime check configurations.
repeated UptimeCheckConfig uptime_check_configs = 1;
// This field represents the pagination token to retrieve the next page of
// results. If the value is empty, it means no further results for the
// request. To retrieve the next page of results, the value of the
// next_page_token is passed to the subsequent List method call (in the
// request message's page_token field).
string next_page_token = 2;
// The total number of Uptime check configurations for the project,
// irrespective of any pagination.
int32 total_size = 3;
}
// The protocol for the `GetUptimeCheckConfig` request.
message GetUptimeCheckConfigRequest {
// The Uptime check configuration to retrieve. The format
// is `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
string name = 1;
}
// The protocol for the `CreateUptimeCheckConfig` request.
message CreateUptimeCheckConfigRequest {
// The project in which to create the Uptime check. The format
// is `projects/[PROJECT_ID]`.
string parent = 1;
// The new Uptime check configuration.
UptimeCheckConfig uptime_check_config = 2;
}
// The protocol for the `UpdateUptimeCheckConfig` request.
message UpdateUptimeCheckConfigRequest {
// Optional. If present, only the listed fields in the current Uptime check
// configuration are updated with values from the new configuration. If this
// field is empty, then the current configuration is completely replaced with
// the new configuration.
google.protobuf.FieldMask update_mask = 2;
// Required. If an `updateMask` has been specified, this field gives
// the values for the set of fields mentioned in the `updateMask`. If an
// `updateMask` has not been given, this Uptime check configuration replaces
// the current configuration. If a field is mentioned in `updateMask` but
// the corresonding field is omitted in this partial Uptime check
// configuration, it has the effect of deleting/clearing the field from the
// configuration on the server.
//
// The following fields can be updated: `display_name`,
// `http_check`, `tcp_check`, `timeout`, `content_matchers`, and
// `selected_regions`.
UptimeCheckConfig uptime_check_config = 3;
}
// The protocol for the `DeleteUptimeCheckConfig` request.
message DeleteUptimeCheckConfigRequest {
// The Uptime check configuration to delete. The format
// is `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
string name = 1;
}
// The protocol for the `ListUptimeCheckIps` request.
message ListUptimeCheckIpsRequest {
// The maximum number of results to return in a single response. The server
// may further constrain the maximum number of results returned in a single
// page. If the page_size is <=0, the server will decide the number of results
// to be returned.
// NOTE: this field is not yet implemented
int32 page_size = 2;
// If this field is not empty then it must contain the `nextPageToken` value
// returned by a previous call to this method. Using this field causes the
// method to return more results from the previous method call.
// NOTE: this field is not yet implemented
string page_token = 3;
}
// The protocol for the `ListUptimeCheckIps` response.
message ListUptimeCheckIpsResponse {
// The returned list of IP addresses (including region and location) that the
// checkers run from.
repeated UptimeCheckIp uptime_check_ips = 1;
// This field represents the pagination token to retrieve the next page of
// results. If the value is empty, it means no further results for the
// request. To retrieve the next page of results, the value of the
// next_page_token is passed to the subsequent List method call (in the
// request message's page_token field).
// NOTE: this field is not yet implemented
string next_page_token = 2;
}