This page documents the language specification for the gcp package. If you're looking for help working with the inputs, outputs, or functions of gcp resources in a Pulumi program, please see the resource documentation for examples and API reference.

monitoring¶

This provider is a derived work of the Terraform Provider distributed under MPL 2.0. If you encounter a bug or missing feature, first check the pulumi/pulumi-gcp repo; however, if that doesn’t turn up anything, please consult the source terraform-providers/terraform-provider-google repo.

class pulumi_gcp.monitoring.AlertPolicy(resource_name, opts=None, combiner=None, conditions=None, display_name=None, documentation=None, enabled=None, notification_channels=None, project=None, user_labels=None, __props__=None, __name__=None, __opts__=None)¶

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.

To get more information about AlertPolicy, see:

API documentation
How-to Guides
- Official Documentation

import pulumi
import pulumi_gcp as gcp

alert_policy = gcp.monitoring.AlertPolicy("alertPolicy",
    combiner="OR",
    conditions=[{
        "conditionThreshold": {
            "aggregations": [{
                "alignmentPeriod": "60s",
                "perSeriesAligner": "ALIGN_RATE",
            }],
            "comparison": "COMPARISON_GT",
            "duration": "60s",
            "filter": "metric.type="compute.googleapis.com/instance/disk/write_bytes_count" AND resource.type="gce_instance"",
        },
        "display_name": "test condition",
    }],
    display_name="My Alert Policy",
    user_labels={
        "foo": "bar",
    })

Parameters

resource_name (str) – The name of the resource.
opts (pulumi.ResourceOptions) – Options for the resource.
combiner (pulumi.Input[str]) – How to combine the results of multiple conditions to determine if an incident should be opened.
conditions (pulumi.Input[list]) – 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. Structure is documented below.
display_name (pulumi.Input[str]) – 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.
documentation (pulumi.Input[dict]) – 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. Structure is documented below.
enabled (pulumi.Input[bool]) – Whether or not the policy is enabled. The default is true.
notification_channels (pulumi.Input[list]) – 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 objects that are returned from the notificationChannels.list method. The syntax of the entries in this field is projects/[PROJECT_ID]/notificationChannels/[CHANNEL_ID]
project (pulumi.Input[str]) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
user_labels (pulumi.Input[dict]) – This field is intended 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.

The conditions object supports the following:

conditionAbsent (pulumi.Input[dict]) - A condition that checks that a time series continues to receive new data points. Structure is documented below.
- aggregations (pulumi.Input[list]) - 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 resources). Multiple aggregations are applied in the order specified.This field is similar to the one in the MetricService.ListTimeSeries request. It is advisable to use the ListTimeSeries method when debugging this field. Structure is documented below.
  - alignmentPeriod (pulumi.Input[str]) - The alignment period for per-time series 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.
  - crossSeriesReducer (pulumi.Input[str]) - 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.
  - groupByFields (pulumi.Input[list]) - 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.
  - perSeriesAligner (pulumi.Input[str]) - 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.
- duration (pulumi.Input[str]) - 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.
- filter (pulumi.Input[str]) - A filter that identifies which time series should be compared with the threshold.The filter is similar to the one that is specified in the MetricService.ListTimeSeries request (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.
- trigger (pulumi.Input[dict]) - 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. Structure is documented below.
  - count (pulumi.Input[float]) - The absolute number of time series that must fail the predicate for the condition to be triggered.
  - percent (pulumi.Input[float]) - The percentage of time series that must fail the predicate for the condition to be triggered.
conditionThreshold (pulumi.Input[dict]) - A condition that compares a time series against a threshold. Structure is documented below.
- aggregations (pulumi.Input[list]) - 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 resources). Multiple aggregations are applied in the order specified.This field is similar to the one in the MetricService.ListTimeSeries request. It is advisable to use the ListTimeSeries method when debugging this field. Structure is documented below.
  - alignmentPeriod (pulumi.Input[str]) - The alignment period for per-time series 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.
  - crossSeriesReducer (pulumi.Input[str]) - 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.
  - groupByFields (pulumi.Input[list]) - 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.
  - perSeriesAligner (pulumi.Input[str]) - 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.
- comparison (pulumi.Input[str]) - 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.
- denominatorAggregations (pulumi.Input[list]) - 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.This field is similar to the one in the MetricService.ListTimeSeries request. It is advisable to use the ListTimeSeries method when debugging this field. Structure is documented below.
  - alignmentPeriod (pulumi.Input[str]) - The alignment period for per-time series 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.
  - crossSeriesReducer (pulumi.Input[str]) - 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.
  - groupByFields (pulumi.Input[list]) - 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.
  - perSeriesAligner (pulumi.Input[str]) - 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.
- denominatorFilter (pulumi.Input[str]) - A filter 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 is similar to the one that is specified in the MetricService.ListTimeSeries request (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.
- duration (pulumi.Input[str]) - 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.
- filter (pulumi.Input[str]) - A filter that identifies which time series should be compared with the threshold.The filter is similar to the one that is specified in the MetricService.ListTimeSeries request (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.
- thresholdValue (pulumi.Input[float]) - A value against which to compare the time series.
- trigger (pulumi.Input[dict]) - 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. Structure is documented below.
  - count (pulumi.Input[float]) - The absolute number of time series that must fail the predicate for the condition to be triggered.
  - percent (pulumi.Input[float]) - The percentage of time series that must fail the predicate for the condition to be triggered.
display_name (pulumi.Input[str]) - 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.
name (pulumi.Input[str]) - - 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.

The documentation object supports the following:

content (pulumi.Input[str]) - The text of the documentation, interpreted according to mimeType. 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.
mimeType (pulumi.Input[str]) - The format of the content field. Presently, only the value “text/markdown” is supported.

combiner: pulumi.Output[str] = None¶: How to combine the results of multiple conditions to determine if an incident should be opened.

conditions: pulumi.Output[list] = None¶

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. Structure is documented below.

conditionAbsent (dict) - A condition that checks that a time series continues to receive new data points. Structure is documented below.
- aggregations (list) - 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 resources). Multiple aggregations are applied in the order specified.This field is similar to the one in the MetricService.ListTimeSeries request. It is advisable to use the ListTimeSeries method when debugging this field. Structure is documented below.
  - alignmentPeriod (str) - The alignment period for per-time series 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.
  - crossSeriesReducer (str) - 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.
  - groupByFields (list) - 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.
  - perSeriesAligner (str) - 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.
- duration (str) - 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.
- filter (str) - A filter that identifies which time series should be compared with the threshold.The filter is similar to the one that is specified in the MetricService.ListTimeSeries request (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.
- trigger (dict) - 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. Structure is documented below.
  - count (float) - The absolute number of time series that must fail the predicate for the condition to be triggered.
  - percent (float) - The percentage of time series that must fail the predicate for the condition to be triggered.
conditionThreshold (dict) - A condition that compares a time series against a threshold. Structure is documented below.
- aggregations (list) - 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 resources). Multiple aggregations are applied in the order specified.This field is similar to the one in the MetricService.ListTimeSeries request. It is advisable to use the ListTimeSeries method when debugging this field. Structure is documented below.
  - alignmentPeriod (str) - The alignment period for per-time series 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.
  - crossSeriesReducer (str) - 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.
  - groupByFields (list) - 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.
  - perSeriesAligner (str) - 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.
- comparison (str) - 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.
- denominatorAggregations (list) - 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.This field is similar to the one in the MetricService.ListTimeSeries request. It is advisable to use the ListTimeSeries method when debugging this field. Structure is documented below.
  - alignmentPeriod (str) - The alignment period for per-time series 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.
  - crossSeriesReducer (str) - 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.
  - groupByFields (list) - 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.
  - perSeriesAligner (str) - 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.
- denominatorFilter (str) - A filter 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 is similar to the one that is specified in the MetricService.ListTimeSeries request (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.
- duration (str) - 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.
- filter (str) - A filter that identifies which time series should be compared with the threshold.The filter is similar to the one that is specified in the MetricService.ListTimeSeries request (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.
- thresholdValue (float) - A value against which to compare the time series.
- trigger (dict) - 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. Structure is documented below.
  - count (float) - The absolute number of time series that must fail the predicate for the condition to be triggered.
  - percent (float) - The percentage of time series that must fail the predicate for the condition to be triggered.
display_name (str) - 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.
name (str) - - 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.

creation_record: pulumi.Output[dict] = None¶

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.

mutateTime (str)
mutatedBy (str)

display_name: pulumi.Output[str] = None¶: 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.

documentation: pulumi.Output[dict] = None¶

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. Structure is documented below.

content (str) - The text of the documentation, interpreted according to mimeType. 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.
mimeType (str) - The format of the content field. Presently, only the value “text/markdown” is supported.

enabled: pulumi.Output[bool] = None¶: Whether or not the policy is enabled. The default is true.

name: pulumi.Output[str] = None¶

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.

notification_channels: pulumi.Output[list] = None¶: 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 objects that are returned from the notificationChannels.list method. The syntax of the entries in this field is projects/[PROJECT_ID]/notificationChannels/[CHANNEL_ID]

project: pulumi.Output[str] = None¶: The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

user_labels: pulumi.Output[dict] = None¶: This field is intended 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.

static get(resource_name, id, opts=None, combiner=None, conditions=None, creation_record=None, display_name=None, documentation=None, enabled=None, name=None, notification_channels=None, project=None, user_labels=None)¶

Get an existing AlertPolicy resource’s state with the given name, id, and optional extra properties used to qualify the lookup.

Parameters

resource_name (str) – The unique name of the resulting resource.
id (str) – The unique provider ID of the resource to lookup.
opts (pulumi.ResourceOptions) – Options for the resource.
combiner (pulumi.Input[str]) – How to combine the results of multiple conditions to determine if an incident should be opened.
conditions (pulumi.Input[list]) – 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. Structure is documented below.
creation_record (pulumi.Input[dict]) – 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.
display_name (pulumi.Input[str]) – 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.
documentation (pulumi.Input[dict]) – 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. Structure is documented below.
enabled (pulumi.Input[bool]) – Whether or not the policy is enabled. The default is true.
name (pulumi.Input[str]) –
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.
notification_channels (pulumi.Input[list]) – 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 objects that are returned from the notificationChannels.list method. The syntax of the entries in this field is projects/[PROJECT_ID]/notificationChannels/[CHANNEL_ID]
project (pulumi.Input[str]) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
user_labels (pulumi.Input[dict]) – This field is intended 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.

The conditions object supports the following:

conditionAbsent (pulumi.Input[dict]) - A condition that checks that a time series continues to receive new data points. Structure is documented below.
- aggregations (pulumi.Input[list]) - 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 resources). Multiple aggregations are applied in the order specified.This field is similar to the one in the MetricService.ListTimeSeries request. It is advisable to use the ListTimeSeries method when debugging this field. Structure is documented below.
  - alignmentPeriod (pulumi.Input[str]) - The alignment period for per-time series 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.
  - crossSeriesReducer (pulumi.Input[str]) - 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.
  - groupByFields (pulumi.Input[list]) - 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.
  - perSeriesAligner (pulumi.Input[str]) - 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.
- duration (pulumi.Input[str]) - 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.
- filter (pulumi.Input[str]) - A filter that identifies which time series should be compared with the threshold.The filter is similar to the one that is specified in the MetricService.ListTimeSeries request (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.
- trigger (pulumi.Input[dict]) - 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. Structure is documented below.
  - count (pulumi.Input[float]) - The absolute number of time series that must fail the predicate for the condition to be triggered.
  - percent (pulumi.Input[float]) - The percentage of time series that must fail the predicate for the condition to be triggered.
conditionThreshold (pulumi.Input[dict]) - A condition that compares a time series against a threshold. Structure is documented below.
- aggregations (pulumi.Input[list]) - 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 resources). Multiple aggregations are applied in the order specified.This field is similar to the one in the MetricService.ListTimeSeries request. It is advisable to use the ListTimeSeries method when debugging this field. Structure is documented below.
  - alignmentPeriod (pulumi.Input[str]) - The alignment period for per-time series 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.
  - crossSeriesReducer (pulumi.Input[str]) - 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.
  - groupByFields (pulumi.Input[list]) - 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.
  - perSeriesAligner (pulumi.Input[str]) - 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.
- comparison (pulumi.Input[str]) - 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.
- denominatorAggregations (pulumi.Input[list]) - 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.This field is similar to the one in the MetricService.ListTimeSeries request. It is advisable to use the ListTimeSeries method when debugging this field. Structure is documented below.
  - alignmentPeriod (pulumi.Input[str]) - The alignment period for per-time series 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.
  - crossSeriesReducer (pulumi.Input[str]) - 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.
  - groupByFields (pulumi.Input[list]) - 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.
  - perSeriesAligner (pulumi.Input[str]) - 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.
- denominatorFilter (pulumi.Input[str]) - A filter 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 is similar to the one that is specified in the MetricService.ListTimeSeries request (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.
- duration (pulumi.Input[str]) - 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.
- filter (pulumi.Input[str]) - A filter that identifies which time series should be compared with the threshold.The filter is similar to the one that is specified in the MetricService.ListTimeSeries request (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.
- thresholdValue (pulumi.Input[float]) - A value against which to compare the time series.
- trigger (pulumi.Input[dict]) - 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. Structure is documented below.
  - count (pulumi.Input[float]) - The absolute number of time series that must fail the predicate for the condition to be triggered.
  - percent (pulumi.Input[float]) - The percentage of time series that must fail the predicate for the condition to be triggered.
display_name (pulumi.Input[str]) - 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.
name (pulumi.Input[str]) - - 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.

The creation_record object supports the following:

mutateTime (pulumi.Input[str])
mutatedBy (pulumi.Input[str])

The documentation object supports the following:

content (pulumi.Input[str]) - The text of the documentation, interpreted according to mimeType. 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.
mimeType (pulumi.Input[str]) - The format of the content field. Presently, only the value “text/markdown” is supported.

translate_output_property(prop)¶

Provides subclasses of Resource an opportunity to translate names of output properties into a format of their choosing before writing those properties to the resource object.

Parameters: prop (str) – A property name.
Returns: A potentially transformed property name.
Return type: str

translate_input_property(prop)¶

Provides subclasses of Resource an opportunity to translate names of input properties into a format of their choosing before sending those properties to the Pulumi engine.

Parameters: prop (str) – A property name.
Returns: A potentially transformed property name.
Return type: str

class pulumi_gcp.monitoring.AwaitableGetAppEngineServiceResult(display_name=None, id=None, module_id=None, name=None, project=None, service_id=None, telemetries=None)¶

class pulumi_gcp.monitoring.AwaitableGetNotificationChannelResult(description=None, display_name=None, enabled=None, id=None, labels=None, name=None, project=None, sensitive_labels=None, type=None, user_labels=None, verification_status=None)¶

class pulumi_gcp.monitoring.AwaitableGetSecretVersionResult(create_time=None, destroy_time=None, enabled=None, id=None, name=None, project=None, secret=None, secret_data=None, version=None)¶

class pulumi_gcp.monitoring.AwaitableGetUptimeCheckIPsResult(id=None, uptime_check_ips=None)¶

class pulumi_gcp.monitoring.CustomService(resource_name, opts=None, display_name=None, project=None, service_id=None, telemetry=None, __props__=None, __name__=None, __opts__=None)¶

A Service is a discrete, autonomous, and network-accessible unit, designed to solve an individual concern (Wikipedia). In Cloud Monitoring, a Service acts as the root resource under which operational aspects of the service are accessible

To get more information about Service, see:

API documentation
How-to Guides
- Service Monitoring
- Monitoring API Documentation

import pulumi
import pulumi_gcp as gcp

custom = gcp.monitoring.CustomService("custom",
    display_name="My Custom Service custom-srv",
    service_id="custom-srv",
    telemetry={
        "resourceName": "//product.googleapis.com/foo/foo/services/test",
    })

Parameters

resource_name (str) – The name of the resource.
opts (pulumi.ResourceOptions) – Options for the resource.
display_name (pulumi.Input[str]) – Name used for UI elements listing this Service.
project (pulumi.Input[str]) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
service_id (pulumi.Input[str]) – An optional service ID to use. If not given, the server will generate a service ID.
telemetry (pulumi.Input[dict]) – Configuration for how to query telemetry on a Service. Structure is documented below.

The telemetry object supports the following:

resourceName (pulumi.Input[str]) - The full name of the resource that defines this service. Formatted as described in https://cloud.google.com/apis/design/resource_names.

display_name: pulumi.Output[str] = None¶: Name used for UI elements listing this Service.

name: pulumi.Output[str] = None¶: The full resource name for this service. The syntax is: projects/[PROJECT_ID]/services/[SERVICE_ID].

project: pulumi.Output[str] = None¶: The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

service_id: pulumi.Output[str] = None¶: An optional service ID to use. If not given, the server will generate a service ID.

telemetry: pulumi.Output[dict] = None¶

Configuration for how to query telemetry on a Service. Structure is documented below.

resourceName (str) - The full name of the resource that defines this service. Formatted as described in https://cloud.google.com/apis/design/resource_names.

static get(resource_name, id, opts=None, display_name=None, name=None, project=None, service_id=None, telemetry=None)¶

Get an existing CustomService resource’s state with the given name, id, and optional extra properties used to qualify the lookup.

Parameters

resource_name (str) – The unique name of the resulting resource.
id (str) – The unique provider ID of the resource to lookup.
opts (pulumi.ResourceOptions) – Options for the resource.
display_name (pulumi.Input[str]) – Name used for UI elements listing this Service.
name (pulumi.Input[str]) – The full resource name for this service. The syntax is: projects/[PROJECT_ID]/services/[SERVICE_ID].
project (pulumi.Input[str]) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
service_id (pulumi.Input[str]) – An optional service ID to use. If not given, the server will generate a service ID.
telemetry (pulumi.Input[dict]) – Configuration for how to query telemetry on a Service. Structure is documented below.

The telemetry object supports the following:

resourceName (pulumi.Input[str]) - The full name of the resource that defines this service. Formatted as described in https://cloud.google.com/apis/design/resource_names.

translate_output_property(prop)¶

Provides subclasses of Resource an opportunity to translate names of output properties into a format of their choosing before writing those properties to the resource object.

Parameters: prop (str) – A property name.
Returns: A potentially transformed property name.
Return type: str

translate_input_property(prop)¶

Provides subclasses of Resource an opportunity to translate names of input properties into a format of their choosing before sending those properties to the Pulumi engine.

Parameters: prop (str) – A property name.
Returns: A potentially transformed property name.
Return type: str

class pulumi_gcp.monitoring.Dashboard(resource_name, opts=None, dashboard_json=None, project=None, __props__=None, __name__=None, __opts__=None)¶

A Google Stackdriver dashboard. Dashboards define the content and layout of pages in the Stackdriver web application.

To get more information about Dashboards, see:

API documentation
How-to Guides
- Official Documentation

import pulumi
import pulumi_gcp as gcp

dashboard = gcp.monitoring.Dashboard("dashboard", dashboard_json="""{
  "displayName": "Demo Dashboard",
  "gridLayout": {
    "widgets": [
      {
        "blank": {}
      }
    ]
  }
}


""")

import pulumi
import pulumi_gcp as gcp

dashboard = gcp.monitoring.Dashboard("dashboard", dashboard_json="""{
  "displayName": "Grid Layout Example",
  "gridLayout": {
    "columns": "2",
    "widgets": [
      {
        "title": "Widget 1",
        "xyChart": {
          "dataSets": [{
            "timeSeriesQuery": {
              "timeSeriesFilter": {
                "filter": "metric.type="agent.googleapis.com/nginx/connections/accepted_count"",
                "aggregation": {
                  "perSeriesAligner": "ALIGN_RATE"
                }
              },
              "unitOverride": "1"
            },
            "plotType": "LINE"
          }],
          "timeshiftDuration": "0s",
          "yAxis": {
            "label": "y1Axis",
            "scale": "LINEAR"
          }
        }
      },
      {
        "text": {
          "content": "Widget 2",
          "format": "MARKDOWN"
        }
      },
      {
        "title": "Widget 3",
        "xyChart": {
          "dataSets": [{
            "timeSeriesQuery": {
              "timeSeriesFilter": {
                "filter": "metric.type="agent.googleapis.com/nginx/connections/accepted_count"",
                "aggregation": {
                  "perSeriesAligner": "ALIGN_RATE"
                }
              },
              "unitOverride": "1"
            },
            "plotType": "STACKED_BAR"
          }],
          "timeshiftDuration": "0s",
          "yAxis": {
            "label": "y1Axis",
            "scale": "LINEAR"
          }
        }
      }
    ]
  }
}


""")

Parameters

resource_name (str) – The name of the resource.
opts (pulumi.ResourceOptions) – Options for the resource.
dashboard_json (pulumi.Input[str]) – The JSON representation of a dashboard, following the format at https://cloud.google.com/monitoring/api/ref_v3/rest/v1/projects.dashboards. The representation of an existing dashboard can be found by using the API Explorer
project (pulumi.Input[str]) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

dashboard_json: pulumi.Output[str] = None¶: The JSON representation of a dashboard, following the format at https://cloud.google.com/monitoring/api/ref_v3/rest/v1/projects.dashboards. The representation of an existing dashboard can be found by using the API Explorer

project: pulumi.Output[str] = None¶: The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

static get(resource_name, id, opts=None, dashboard_json=None, project=None)¶

Get an existing Dashboard resource’s state with the given name, id, and optional extra properties used to qualify the lookup.

Parameters

resource_name (str) – The unique name of the resulting resource.
id (str) – The unique provider ID of the resource to lookup.
opts (pulumi.ResourceOptions) – Options for the resource.
dashboard_json (pulumi.Input[str]) –
The JSON representation of a dashboard, following the format at https://cloud.google.com/monitoring/api/ref_v3/rest/v1/projects.dashboards. The representation of an existing dashboard can be found by using the API Explorer
project (pulumi.Input[str]) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

translate_output_property(prop)¶

Provides subclasses of Resource an opportunity to translate names of output properties into a format of their choosing before writing those properties to the resource object.

Parameters: prop (str) – A property name.
Returns: A potentially transformed property name.
Return type: str

translate_input_property(prop)¶

Provides subclasses of Resource an opportunity to translate names of input properties into a format of their choosing before sending those properties to the Pulumi engine.

Parameters: prop (str) – A property name.
Returns: A potentially transformed property name.
Return type: str

class pulumi_gcp.monitoring.GetAppEngineServiceResult(display_name=None, id=None, module_id=None, name=None, project=None, service_id=None, telemetries=None)¶

A collection of values returned by getAppEngineService.

id = None¶: The provider-assigned unique ID for this managed resource.

class pulumi_gcp.monitoring.GetNotificationChannelResult(description=None, display_name=None, enabled=None, id=None, labels=None, name=None, project=None, sensitive_labels=None, type=None, user_labels=None, verification_status=None)¶

A collection of values returned by getNotificationChannel.

id = None¶: The provider-assigned unique ID for this managed resource.

class pulumi_gcp.monitoring.GetSecretVersionResult(create_time=None, destroy_time=None, enabled=None, id=None, name=None, project=None, secret=None, secret_data=None, version=None)¶

A collection of values returned by getSecretVersion.

create_time = None¶: The time at which the Secret was created.

destroy_time = None¶: The time at which the Secret was destroyed. Only present if state is DESTROYED.

enabled = None¶: True if the current state of the SecretVersion is enabled.

id = None¶: The provider-assigned unique ID for this managed resource.

name = None¶: The resource name of the SecretVersion. Format: projects/{{project}}/secrets/{{secret_id}}/versions/{{version}}

secret_data = None¶: The secret data. No larger than 64KiB.

class pulumi_gcp.monitoring.GetUptimeCheckIPsResult(id=None, uptime_check_ips=None)¶

A collection of values returned by getUptimeCheckIPs.

id = None¶: The provider-assigned unique ID for this managed resource.

uptime_check_ips = None¶: A list of uptime check IPs used by Stackdriver Monitoring. Each uptime_check_ip contains:

class pulumi_gcp.monitoring.Group(resource_name, opts=None, display_name=None, filter=None, is_cluster=None, parent_name=None, project=None, __props__=None, __name__=None, __opts__=None)¶

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.

To get more information about Group, see:

API documentation
How-to Guides
- Official Documentation

import pulumi
import pulumi_gcp as gcp

basic = gcp.monitoring.Group("basic",
    display_name="tf-test MonitoringGroup",
    filter="resource.metadata.region="europe-west2"")

import pulumi
import pulumi_gcp as gcp

parent = gcp.monitoring.Group("parent",
    display_name="tf-test MonitoringParentGroup",
    filter="resource.metadata.region="europe-west2"")
subgroup = gcp.monitoring.Group("subgroup",
    display_name="tf-test MonitoringSubGroup",
    filter="resource.metadata.region="europe-west2"",
    parent_name=parent.name)

Parameters

resource_name (str) – The name of the resource.
opts (pulumi.ResourceOptions) – Options for the resource.
display_name (pulumi.Input[str]) – A user-assigned name for this group, used only for display purposes.
filter (pulumi.Input[str]) – The filter used to determine which monitored resources belong to this group.
is_cluster (pulumi.Input[bool]) – If true, the members of this group are considered to be a cluster. The system can perform additional analysis on groups that are clusters.
parent_name (pulumi.Input[str]) – 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, “”.
project (pulumi.Input[str]) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

display_name: pulumi.Output[str] = None¶: A user-assigned name for this group, used only for display purposes.

filter: pulumi.Output[str] = None¶: The filter used to determine which monitored resources belong to this group.

is_cluster: pulumi.Output[bool] = None¶: If true, the members of this group are considered to be a cluster. The system can perform additional analysis on groups that are clusters.

name: pulumi.Output[str] = None¶: A unique identifier for this group. The format is “projects/{project_id_or_number}/groups/{group_id}”.

parent_name: pulumi.Output[str] = None¶: 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, “”.

project: pulumi.Output[str] = None¶: The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

static get(resource_name, id, opts=None, display_name=None, filter=None, is_cluster=None, name=None, parent_name=None, project=None)¶

Get an existing Group resource’s state with the given name, id, and optional extra properties used to qualify the lookup.

Parameters

resource_name (str) – The unique name of the resulting resource.
id (str) – The unique provider ID of the resource to lookup.
opts (pulumi.ResourceOptions) – Options for the resource.
display_name (pulumi.Input[str]) – A user-assigned name for this group, used only for display purposes.
filter (pulumi.Input[str]) – The filter used to determine which monitored resources belong to this group.
is_cluster (pulumi.Input[bool]) – If true, the members of this group are considered to be a cluster. The system can perform additional analysis on groups that are clusters.
name (pulumi.Input[str]) – A unique identifier for this group. The format is “projects/{project_id_or_number}/groups/{group_id}”.
parent_name (pulumi.Input[str]) – 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, “”.
project (pulumi.Input[str]) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

translate_output_property(prop)¶

Provides subclasses of Resource an opportunity to translate names of output properties into a format of their choosing before writing those properties to the resource object.

Parameters: prop (str) – A property name.
Returns: A potentially transformed property name.
Return type: str

translate_input_property(prop)¶

Provides subclasses of Resource an opportunity to translate names of input properties into a format of their choosing before sending those properties to the Pulumi engine.

Parameters: prop (str) – A property name.
Returns: A potentially transformed property name.
Return type: str

class pulumi_gcp.monitoring.NotificationChannel(resource_name, opts=None, description=None, display_name=None, enabled=None, labels=None, project=None, sensitive_labels=None, type=None, user_labels=None, __props__=None, __name__=None, __opts__=None)¶

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.

Notification Channels are designed to be flexible and are made up of a supported type and labels to configure that channel. Each type has specific labels that need to be present for that channel to be correctly configured. The labels that are required to be present for one channel type are often different than those required for another. Due to these loose constraints it’s often best to set up a channel through the UI and import it to the provider when setting up a brand new channel type to determine which labels are required.

A list of supported channels per project the list endpoint can be accessed programmatically or through the api explorer at https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.notificationChannelDescriptors/list . This provides the channel type and all of the required labels that must be passed.

To get more information about NotificationChannel, see:

API documentation
How-to Guides
- Notification Options
- Monitoring API Documentation

import pulumi
import pulumi_gcp as gcp

basic = gcp.monitoring.NotificationChannel("basic",
    display_name="Test Notification Channel",
    labels={
        "email_address": "fake_email@blahblah.com",
    },
    type="email")

import pulumi
import pulumi_gcp as gcp

default = gcp.monitoring.NotificationChannel("default",
    display_name="Test Slack Channel",
    labels={
        "channel_name": "#foobar",
    },
    sensitive_labels={
        "authToken": "one",
    },
    type="slack")

Parameters

resource_name (str) – The name of the resource.
opts (pulumi.ResourceOptions) – Options for the resource.
description (pulumi.Input[str]) – 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.
display_name (pulumi.Input[str]) – 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.
enabled (pulumi.Input[bool]) – 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.
labels (pulumi.Input[dict]) – Configuration fields that define the channel and its behavior. The permissible and required labels are specified in the NotificationChannelDescriptor corresponding to the type field. Labels with sensitive data are obfuscated by the API and therefore the provider cannot determine if there are upstream changes to these fields. They can also be configured via the sensitive_labels block, but cannot be configured in both places.
project (pulumi.Input[str]) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
sensitive_labels (pulumi.Input[dict]) – Different notification type behaviors are configured primarily using the the labels field on this resource. This block contains the labels which contain secrets or passwords so that they can be marked sensitive and hidden from plan output. The name of the field, eg: password, will be the key in the labels map in the api request. Credentials may not be specified in both locations and will cause an error. Changing from one location to a different credential configuration in the config will require an apply to update state. Structure is documented below.
type (pulumi.Input[str]) – The type of the notification channel. This field matches the value of the NotificationChannelDescriptor.type field. See https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.notificationChannelDescriptors/list to get the list of valid values such as “email”, “slack”, etc…
user_labels (pulumi.Input[dict]) – 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.

The sensitive_labels object supports the following:

authToken (pulumi.Input[str]) - An authorization token for a notification channel. Channel types that support this field include: slack Note: This property is sensitive and will not be displayed in the plan.
password (pulumi.Input[str]) - An password for a notification channel. Channel types that support this field include: webhook_basicauth Note: This property is sensitive and will not be displayed in the plan.
serviceKey (pulumi.Input[str]) - An servicekey token for a notification channel. Channel types that support this field include: pagerduty Note: This property is sensitive and will not be displayed in the plan.

description: pulumi.Output[str] = None¶: 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.

display_name: pulumi.Output[str] = None¶: 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.

enabled: pulumi.Output[bool] = None¶: 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.

labels: pulumi.Output[dict] = None¶: Configuration fields that define the channel and its behavior. The permissible and required labels are specified in the NotificationChannelDescriptor corresponding to the type field. Labels with sensitive data are obfuscated by the API and therefore the provider cannot determine if there are upstream changes to these fields. They can also be configured via the sensitive_labels block, but cannot be configured in both places.

name: pulumi.Output[str] = None¶: 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.

project: pulumi.Output[str] = None¶: The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

sensitive_labels: pulumi.Output[dict] = None¶

Different notification type behaviors are configured primarily using the the labels field on this resource. This block contains the labels which contain secrets or passwords so that they can be marked sensitive and hidden from plan output. The name of the field, eg: password, will be the key in the labels map in the api request. Credentials may not be specified in both locations and will cause an error. Changing from one location to a different credential configuration in the config will require an apply to update state. Structure is documented below.

authToken (str) - An authorization token for a notification channel. Channel types that support this field include: slack Note: This property is sensitive and will not be displayed in the plan.
password (str) - An password for a notification channel. Channel types that support this field include: webhook_basicauth Note: This property is sensitive and will not be displayed in the plan.
serviceKey (str) - An servicekey token for a notification channel. Channel types that support this field include: pagerduty Note: This property is sensitive and will not be displayed in the plan.

type: pulumi.Output[str] = None¶: The type of the notification channel. This field matches the value of the NotificationChannelDescriptor.type field. See https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.notificationChannelDescriptors/list to get the list of valid values such as “email”, “slack”, etc…

user_labels: pulumi.Output[dict] = None¶: 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.

verification_status: pulumi.Output[str] = None¶: Indicates whether this channel has been verified or not. On a ListNotificationChannels or 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 operation. To change the value of this field, you must call VerifyNotificationChannel.

static get(resource_name, id, opts=None, description=None, display_name=None, enabled=None, labels=None, name=None, project=None, sensitive_labels=None, type=None, user_labels=None, verification_status=None)¶

Get an existing NotificationChannel resource’s state with the given name, id, and optional extra properties used to qualify the lookup.

Parameters

resource_name (str) – The unique name of the resulting resource.
id (str) – The unique provider ID of the resource to lookup.
opts (pulumi.ResourceOptions) – Options for the resource.
description (pulumi.Input[str]) – 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.
display_name (pulumi.Input[str]) – 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.
enabled (pulumi.Input[bool]) – 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.
labels (pulumi.Input[dict]) – Configuration fields that define the channel and its behavior. The permissible and required labels are specified in the NotificationChannelDescriptor corresponding to the type field. Labels with sensitive data are obfuscated by the API and therefore the provider cannot determine if there are upstream changes to these fields. They can also be configured via the sensitive_labels block, but cannot be configured in both places.
name (pulumi.Input[str]) – 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.
project (pulumi.Input[str]) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
sensitive_labels (pulumi.Input[dict]) – Different notification type behaviors are configured primarily using the the labels field on this resource. This block contains the labels which contain secrets or passwords so that they can be marked sensitive and hidden from plan output. The name of the field, eg: password, will be the key in the labels map in the api request. Credentials may not be specified in both locations and will cause an error. Changing from one location to a different credential configuration in the config will require an apply to update state. Structure is documented below.
type (pulumi.Input[str]) – The type of the notification channel. This field matches the value of the NotificationChannelDescriptor.type field. See https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.notificationChannelDescriptors/list to get the list of valid values such as “email”, “slack”, etc…
user_labels (pulumi.Input[dict]) – 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.
verification_status (pulumi.Input[str]) – Indicates whether this channel has been verified or not. On a ListNotificationChannels or 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 operation. To change the value of this field, you must call VerifyNotificationChannel.

The sensitive_labels object supports the following:

authToken (pulumi.Input[str]) - An authorization token for a notification channel. Channel types that support this field include: slack Note: This property is sensitive and will not be displayed in the plan.
password (pulumi.Input[str]) - An password for a notification channel. Channel types that support this field include: webhook_basicauth Note: This property is sensitive and will not be displayed in the plan.
serviceKey (pulumi.Input[str]) - An servicekey token for a notification channel. Channel types that support this field include: pagerduty Note: This property is sensitive and will not be displayed in the plan.

translate_output_property(prop)¶

Provides subclasses of Resource an opportunity to translate names of output properties into a format of their choosing before writing those properties to the resource object.

Parameters: prop (str) – A property name.
Returns: A potentially transformed property name.
Return type: str

translate_input_property(prop)¶

Provides subclasses of Resource an opportunity to translate names of input properties into a format of their choosing before sending those properties to the Pulumi engine.

Parameters: prop (str) – A property name.
Returns: A potentially transformed property name.
Return type: str

class pulumi_gcp.monitoring.Slo(resource_name, opts=None, basic_sli=None, calendar_period=None, display_name=None, goal=None, project=None, request_based_sli=None, rolling_period_days=None, service=None, slo_id=None, windows_based_sli=None, __props__=None, __name__=None, __opts__=None)¶

A Service-Level Objective (SLO) describes the 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.”

To get more information about Slo, see:

API documentation
How-to Guides
- Service Monitoring
- Monitoring API Documentation

import pulumi
import pulumi_gcp as gcp

default = gcp.monitoring.get_app_engine_service(module_id="default")
appeng_slo = gcp.monitoring.Slo("appengSlo",
    service=default.service_id,
    slo_id="ae-slo",
    display_name="Test SLO for App Engine",
    goal=0.9,
    calendar_period="DAY",
    basic_sli={
        "latency": {
            "threshold": "1s",
        },
    })

Parameters

resource_name (str) – The name of the resource.
opts (pulumi.ResourceOptions) – Options for the resource.
basic_sli (pulumi.Input[dict]) – Basic Service-Level Indicator (SLI) on a well-known service type. Performance will be computed on the basis of pre-defined metrics. SLIs are used to measure and calculate the quality of the Service’s performance with respect to a single aspect of service quality. Exactly one of the following must be set: basic_sli, request_based_sli, windows_based_sli Structure is documented below.
calendar_period (pulumi.Input[str]) – A calendar period, semantically “since the start of the current ”.
display_name (pulumi.Input[str]) – Name used for UI elements listing this SLO.
goal (pulumi.Input[float]) – The fraction of service that must be good in order for this objective to be met. 0 < goal <= 0.999
project (pulumi.Input[str]) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
request_based_sli (pulumi.Input[dict]) – A request-based SLI defines a SLI for which atomic units of service are counted directly. A SLI describes a good service. It is used to measure and calculate the quality of the Service’s performance with respect to a single aspect of service quality. Exactly one of the following must be set: basic_sli, request_based_sli, windows_based_sli Structure is documented below.
rolling_period_days (pulumi.Input[float]) – A rolling time period, semantically “in the past X days”. Must be between 1 to 30 days, inclusive.
service (pulumi.Input[str]) – ID of the service to which this SLO belongs.
slo_id (pulumi.Input[str]) – The id to use for this ServiceLevelObjective. If omitted, an id will be generated instead.
windows_based_sli (pulumi.Input[dict]) – A windows-based SLI defines the criteria for time windows. good_service is defined based off the count of these time windows for which the provided service was of good quality. A SLI describes a good service. It is used to measure and calculate the quality of the Service’s performance with respect to a single aspect of service quality. Exactly one of the following must be set: basic_sli, request_based_sli, windows_based_sli Structure is documented below.

The basic_sli object supports the following:

latency (pulumi.Input[dict]) - Parameters for a latency threshold SLI. Structure is documented below.
- threshold (pulumi.Input[str]) - A duration string, e.g. 10s. Good service is defined to be the count of requests made to this service that return in no more than threshold.
locations (pulumi.Input[list]) - An optional 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.
methods (pulumi.Input[list]) - An optional 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.
versions (pulumi.Input[list]) - 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.

The request_based_sli object supports the following:

distributionCut (pulumi.Input[dict]) - Used when good_service is defined by 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. Defines a distribution TimeSeries filter and thresholds used for measuring good service and total service. Structure is documented below.
- distributionFilter (pulumi.Input[str]) - A TimeSeries monitoring filter aggregating values to quantify the good service provided. Must have ValueType = DISTRIBUTION and MetricKind = DELTA or MetricKind = CUMULATIVE.
- range (pulumi.Input[dict]) - Range of numerical values. The computed good_service will be the count of values x in the Distribution such that range.min <= x < range.max. inclusive of min and exclusive of max. Open ranges can be defined by setting just one of min or max. Summed value X should satisfy range.min <= X < range.max for a good window. Structure is documented below.
  - max (pulumi.Input[float]) - max value for the range (inclusive). If not given, will be set to “infinity”, defining an open range “>= range.min”
  - min (pulumi.Input[float]) - Min value for the range (inclusive). If not given, will be set to “-infinity”, defining an open range “< range.max”
goodTotalRatio (pulumi.Input[dict]) - A means to compute a ratio of good_service to total_service. Defines computing this ratio with two TimeSeries monitoring filters Must specify exactly two of good, bad, and total service filters. The relationship good_service + bad_service = total_service will be assumed. Structure is documented below.
- badServiceFilter (pulumi.Input[str]) - A TimeSeries monitoring filter quantifying bad service provided, either demanded service that was not provided or demanded service that was of inadequate quality. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
- goodServiceFilter (pulumi.Input[str]) - A TimeSeries monitoring filter quantifying good service provided. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
- totalServiceFilter (pulumi.Input[str]) - A TimeSeries monitoring filter quantifying total demanded service. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.

The windows_based_sli object supports the following:

goodBadMetricFilter (pulumi.Input[str]) - A TimeSeries monitoring filter with ValueType = BOOL. The window is good if any true values appear in the window. One of good_bad_metric_filter, good_total_ratio_threshold, metric_mean_in_range, metric_sum_in_range must be set for windows_based_sli.
goodTotalRatioThreshold (pulumi.Input[dict]) - Criterion that describes a window as good if its performance is high enough. One of good_bad_metric_filter, good_total_ratio_threshold, metric_mean_in_range, metric_sum_in_range must be set for windows_based_sli. Structure is documented below.
- basicSliPerformance (pulumi.Input[dict]) - Basic SLI to evaluate to judge window quality. Structure is documented below.
  - latency (pulumi.Input[dict]) - Parameters for a latency threshold SLI. Structure is documented below.
    - threshold (pulumi.Input[str]) - A duration string, e.g. 10s. Good service is defined to be the count of requests made to this service that return in no more than threshold.
  - locations (pulumi.Input[list]) - An optional 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.
  - methods (pulumi.Input[list]) - An optional 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.
  - versions (pulumi.Input[list]) - 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.
- performance (pulumi.Input[dict]) - Request-based SLI to evaluate to judge window quality. Structure is documented below.
  - distributionCut (pulumi.Input[dict]) - Used when good_service is defined by 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. Defines a distribution TimeSeries filter and thresholds used for measuring good service and total service. Structure is documented below.
    - distributionFilter (pulumi.Input[str]) - A TimeSeries monitoring filter aggregating values to quantify the good service provided. Must have ValueType = DISTRIBUTION and MetricKind = DELTA or MetricKind = CUMULATIVE.
    - range (pulumi.Input[dict]) - Range of numerical values. The computed good_service will be the count of values x in the Distribution such that range.min <= x < range.max. inclusive of min and exclusive of max. Open ranges can be defined by setting just one of min or max. Summed value X should satisfy range.min <= X < range.max for a good window. Structure is documented below.
      - max (pulumi.Input[float]) - max value for the range (inclusive). If not given, will be set to “infinity”, defining an open range “>= range.min”
      - min (pulumi.Input[float]) - Min value for the range (inclusive). If not given, will be set to “-infinity”, defining an open range “< range.max”
  - goodTotalRatio (pulumi.Input[dict]) - A means to compute a ratio of good_service to total_service. Defines computing this ratio with two TimeSeries monitoring filters Must specify exactly two of good, bad, and total service filters. The relationship good_service + bad_service = total_service will be assumed. Structure is documented below.
    - badServiceFilter (pulumi.Input[str]) - A TimeSeries monitoring filter quantifying bad service provided, either demanded service that was not provided or demanded service that was of inadequate quality. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
    - goodServiceFilter (pulumi.Input[str]) - A TimeSeries monitoring filter quantifying good service provided. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
    - totalServiceFilter (pulumi.Input[str]) - A TimeSeries monitoring filter quantifying total demanded service. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
- threshold (pulumi.Input[float]) - A duration string, e.g. 10s. Good service is defined to be the count of requests made to this service that return in no more than threshold.
metricMeanInRange (pulumi.Input[dict]) - Criterion that describes a window as good if the metric’s value is in a good range, averaged across returned streams. One of good_bad_metric_filter, good_total_ratio_threshold, metric_mean_in_range, metric_sum_in_range must be set for windows_based_sli. Average value X of time_series should satisfy range.min <= X < range.max for a good window. Structure is documented below.
- range (pulumi.Input[dict]) - Range of numerical values. The computed good_service will be the count of values x in the Distribution such that range.min <= x < range.max. inclusive of min and exclusive of max. Open ranges can be defined by setting just one of min or max. Summed value X should satisfy range.min <= X < range.max for a good window. Structure is documented below.
  - max (pulumi.Input[float]) - max value for the range (inclusive). If not given, will be set to “infinity”, defining an open range “>= range.min”
  - min (pulumi.Input[float]) - Min value for the range (inclusive). If not given, will be set to “-infinity”, defining an open range “< range.max”
- timeSeries (pulumi.Input[str]) - A monitoring filter specifying the TimeSeries to use for evaluating window quality. The provided TimeSeries must have ValueType = INT64 or ValueType = DOUBLE and MetricKind = GAUGE. Summed value X should satisfy range.min <= X < range.max for a good window.
metricSumInRange (pulumi.Input[dict]) - Criterion that describes a window as good if the metric’s value is in a good range, summed across returned streams. Summed value X of time_series should satisfy range.min <= X < range.max for a good window. One of good_bad_metric_filter, good_total_ratio_threshold, metric_mean_in_range, metric_sum_in_range must be set for windows_based_sli. Structure is documented below.
- range (pulumi.Input[dict]) - Range of numerical values. The computed good_service will be the count of values x in the Distribution such that range.min <= x < range.max. inclusive of min and exclusive of max. Open ranges can be defined by setting just one of min or max. Summed value X should satisfy range.min <= X < range.max for a good window. Structure is documented below.
  - max (pulumi.Input[float]) - max value for the range (inclusive). If not given, will be set to “infinity”, defining an open range “>= range.min”
  - min (pulumi.Input[float]) - Min value for the range (inclusive). If not given, will be set to “-infinity”, defining an open range “< range.max”
- timeSeries (pulumi.Input[str]) - A monitoring filter specifying the TimeSeries to use for evaluating window quality. The provided TimeSeries must have ValueType = INT64 or ValueType = DOUBLE and MetricKind = GAUGE. Summed value X should satisfy range.min <= X < range.max for a good window.
windowPeriod (pulumi.Input[str]) - Duration over which window quality is evaluated, given as a duration string “{X}s” representing X seconds. Must be an integer fraction of a day and at least 60s.

basic_sli: pulumi.Output[dict] = None¶

Basic Service-Level Indicator (SLI) on a well-known service type. Performance will be computed on the basis of pre-defined metrics. SLIs are used to measure and calculate the quality of the Service’s performance with respect to a single aspect of service quality. Exactly one of the following must be set: basic_sli, request_based_sli, windows_based_sli Structure is documented below.

latency (dict) - Parameters for a latency threshold SLI. Structure is documented below.
- threshold (str) - A duration string, e.g. 10s. Good service is defined to be the count of requests made to this service that return in no more than threshold.
locations (list) - An optional 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.
methods (list) - An optional 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.
versions (list) - 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.

calendar_period: pulumi.Output[str] = None¶

A calendar period, semantically “since the start of the current

”.

display_name: pulumi.Output[str] = None¶: Name used for UI elements listing this SLO.

goal: pulumi.Output[float] = None¶: The fraction of service that must be good in order for this objective to be met. 0 < goal <= 0.999

name: pulumi.Output[str] = None¶: The full resource name for this service. The syntax is: projects/[PROJECT_ID_OR_NUMBER]/services/[SERVICE_ID]/serviceLevelObjectives/[SLO_NAME]

project: pulumi.Output[str] = None¶: The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

request_based_sli: pulumi.Output[dict] = None¶

A request-based SLI defines a SLI for which atomic units of service are counted directly. A SLI describes a good service. It is used to measure and calculate the quality of the Service’s performance with respect to a single aspect of service quality. Exactly one of the following must be set: basic_sli, request_based_sli, windows_based_sli Structure is documented below.

distributionCut (dict) - Used when good_service is defined by 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. Defines a distribution TimeSeries filter and thresholds used for measuring good service and total service. Structure is documented below.
- distributionFilter (str) - A TimeSeries monitoring filter aggregating values to quantify the good service provided. Must have ValueType = DISTRIBUTION and MetricKind = DELTA or MetricKind = CUMULATIVE.
- range (dict) - Range of numerical values. The computed good_service will be the count of values x in the Distribution such that range.min <= x < range.max. inclusive of min and exclusive of max. Open ranges can be defined by setting just one of min or max. Summed value X should satisfy range.min <= X < range.max for a good window. Structure is documented below.
  - max (float) - max value for the range (inclusive). If not given, will be set to “infinity”, defining an open range “>= range.min”
  - min (float) - Min value for the range (inclusive). If not given, will be set to “-infinity”, defining an open range “< range.max”
goodTotalRatio (dict) - A means to compute a ratio of good_service to total_service. Defines computing this ratio with two TimeSeries monitoring filters Must specify exactly two of good, bad, and total service filters. The relationship good_service + bad_service = total_service will be assumed. Structure is documented below.
- badServiceFilter (str) - A TimeSeries monitoring filter quantifying bad service provided, either demanded service that was not provided or demanded service that was of inadequate quality. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
- goodServiceFilter (str) - A TimeSeries monitoring filter quantifying good service provided. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
- totalServiceFilter (str) - A TimeSeries monitoring filter quantifying total demanded service. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.

rolling_period_days: pulumi.Output[float] = None¶: A rolling time period, semantically “in the past X days”. Must be between 1 to 30 days, inclusive.

service: pulumi.Output[str] = None¶: ID of the service to which this SLO belongs.

slo_id: pulumi.Output[str] = None¶: The id to use for this ServiceLevelObjective. If omitted, an id will be generated instead.

windows_based_sli: pulumi.Output[dict] = None¶

A windows-based SLI defines the criteria for time windows. good_service is defined based off the count of these time windows for which the provided service was of good quality. A SLI describes a good service. It is used to measure and calculate the quality of the Service’s performance with respect to a single aspect of service quality. Exactly one of the following must be set: basic_sli, request_based_sli, windows_based_sli Structure is documented below.

goodBadMetricFilter (str) - A TimeSeries monitoring filter with ValueType = BOOL. The window is good if any true values appear in the window. One of good_bad_metric_filter, good_total_ratio_threshold, metric_mean_in_range, metric_sum_in_range must be set for windows_based_sli.
goodTotalRatioThreshold (dict) - Criterion that describes a window as good if its performance is high enough. One of good_bad_metric_filter, good_total_ratio_threshold, metric_mean_in_range, metric_sum_in_range must be set for windows_based_sli. Structure is documented below.
- basicSliPerformance (dict) - Basic SLI to evaluate to judge window quality. Structure is documented below.
  - latency (dict) - Parameters for a latency threshold SLI. Structure is documented below.
    - threshold (str) - A duration string, e.g. 10s. Good service is defined to be the count of requests made to this service that return in no more than threshold.
  - locations (list) - An optional 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.
  - methods (list) - An optional 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.
  - versions (list) - 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.
- performance (dict) - Request-based SLI to evaluate to judge window quality. Structure is documented below.
  - distributionCut (dict) - Used when good_service is defined by 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. Defines a distribution TimeSeries filter and thresholds used for measuring good service and total service. Structure is documented below.
    - distributionFilter (str) - A TimeSeries monitoring filter aggregating values to quantify the good service provided. Must have ValueType = DISTRIBUTION and MetricKind = DELTA or MetricKind = CUMULATIVE.
    - range (dict) - Range of numerical values. The computed good_service will be the count of values x in the Distribution such that range.min <= x < range.max. inclusive of min and exclusive of max. Open ranges can be defined by setting just one of min or max. Summed value X should satisfy range.min <= X < range.max for a good window. Structure is documented below.
      - max (float) - max value for the range (inclusive). If not given, will be set to “infinity”, defining an open range “>= range.min”
      - min (float) - Min value for the range (inclusive). If not given, will be set to “-infinity”, defining an open range “< range.max”
  - goodTotalRatio (dict) - A means to compute a ratio of good_service to total_service. Defines computing this ratio with two TimeSeries monitoring filters Must specify exactly two of good, bad, and total service filters. The relationship good_service + bad_service = total_service will be assumed. Structure is documented below.
    - badServiceFilter (str) - A TimeSeries monitoring filter quantifying bad service provided, either demanded service that was not provided or demanded service that was of inadequate quality. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
    - goodServiceFilter (str) - A TimeSeries monitoring filter quantifying good service provided. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
    - totalServiceFilter (str) - A TimeSeries monitoring filter quantifying total demanded service. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
- threshold (float) - A duration string, e.g. 10s. Good service is defined to be the count of requests made to this service that return in no more than threshold.
metricMeanInRange (dict) - Criterion that describes a window as good if the metric’s value is in a good range, averaged across returned streams. One of good_bad_metric_filter, good_total_ratio_threshold, metric_mean_in_range, metric_sum_in_range must be set for windows_based_sli. Average value X of time_series should satisfy range.min <= X < range.max for a good window. Structure is documented below.
- range (dict) - Range of numerical values. The computed good_service will be the count of values x in the Distribution such that range.min <= x < range.max. inclusive of min and exclusive of max. Open ranges can be defined by setting just one of min or max. Summed value X should satisfy range.min <= X < range.max for a good window. Structure is documented below.
  - max (float) - max value for the range (inclusive). If not given, will be set to “infinity”, defining an open range “>= range.min”
  - min (float) - Min value for the range (inclusive). If not given, will be set to “-infinity”, defining an open range “< range.max”
- timeSeries (str) - A monitoring filter specifying the TimeSeries to use for evaluating window quality. The provided TimeSeries must have ValueType = INT64 or ValueType = DOUBLE and MetricKind = GAUGE. Summed value X should satisfy range.min <= X < range.max for a good window.
metricSumInRange (dict) - Criterion that describes a window as good if the metric’s value is in a good range, summed across returned streams. Summed value X of time_series should satisfy range.min <= X < range.max for a good window. One of good_bad_metric_filter, good_total_ratio_threshold, metric_mean_in_range, metric_sum_in_range must be set for windows_based_sli. Structure is documented below.
- range (dict) - Range of numerical values. The computed good_service will be the count of values x in the Distribution such that range.min <= x < range.max. inclusive of min and exclusive of max. Open ranges can be defined by setting just one of min or max. Summed value X should satisfy range.min <= X < range.max for a good window. Structure is documented below.
  - max (float) - max value for the range (inclusive). If not given, will be set to “infinity”, defining an open range “>= range.min”
  - min (float) - Min value for the range (inclusive). If not given, will be set to “-infinity”, defining an open range “< range.max”
- timeSeries (str) - A monitoring filter specifying the TimeSeries to use for evaluating window quality. The provided TimeSeries must have ValueType = INT64 or ValueType = DOUBLE and MetricKind = GAUGE. Summed value X should satisfy range.min <= X < range.max for a good window.
windowPeriod (str) - Duration over which window quality is evaluated, given as a duration string “{X}s” representing X seconds. Must be an integer fraction of a day and at least 60s.

static get(resource_name, id, opts=None, basic_sli=None, calendar_period=None, display_name=None, goal=None, name=None, project=None, request_based_sli=None, rolling_period_days=None, service=None, slo_id=None, windows_based_sli=None)¶

Get an existing Slo resource’s state with the given name, id, and optional extra properties used to qualify the lookup.

Parameters

resource_name (str) – The unique name of the resulting resource.
id (str) – The unique provider ID of the resource to lookup.
opts (pulumi.ResourceOptions) – Options for the resource.
basic_sli (pulumi.Input[dict]) – Basic Service-Level Indicator (SLI) on a well-known service type. Performance will be computed on the basis of pre-defined metrics. SLIs are used to measure and calculate the quality of the Service’s performance with respect to a single aspect of service quality. Exactly one of the following must be set: basic_sli, request_based_sli, windows_based_sli Structure is documented below.
calendar_period (pulumi.Input[str]) – A calendar period, semantically “since the start of the current ”.
display_name (pulumi.Input[str]) – Name used for UI elements listing this SLO.
goal (pulumi.Input[float]) – The fraction of service that must be good in order for this objective to be met. 0 < goal <= 0.999
name (pulumi.Input[str]) – The full resource name for this service. The syntax is: projects/[PROJECT_ID_OR_NUMBER]/services/[SERVICE_ID]/serviceLevelObjectives/[SLO_NAME]
project (pulumi.Input[str]) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
request_based_sli (pulumi.Input[dict]) – A request-based SLI defines a SLI for which atomic units of service are counted directly. A SLI describes a good service. It is used to measure and calculate the quality of the Service’s performance with respect to a single aspect of service quality. Exactly one of the following must be set: basic_sli, request_based_sli, windows_based_sli Structure is documented below.
rolling_period_days (pulumi.Input[float]) – A rolling time period, semantically “in the past X days”. Must be between 1 to 30 days, inclusive.
service (pulumi.Input[str]) – ID of the service to which this SLO belongs.
slo_id (pulumi.Input[str]) – The id to use for this ServiceLevelObjective. If omitted, an id will be generated instead.
windows_based_sli (pulumi.Input[dict]) – A windows-based SLI defines the criteria for time windows. good_service is defined based off the count of these time windows for which the provided service was of good quality. A SLI describes a good service. It is used to measure and calculate the quality of the Service’s performance with respect to a single aspect of service quality. Exactly one of the following must be set: basic_sli, request_based_sli, windows_based_sli Structure is documented below.

The basic_sli object supports the following:

latency (pulumi.Input[dict]) - Parameters for a latency threshold SLI. Structure is documented below.
- threshold (pulumi.Input[str]) - A duration string, e.g. 10s. Good service is defined to be the count of requests made to this service that return in no more than threshold.
locations (pulumi.Input[list]) - An optional 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.
methods (pulumi.Input[list]) - An optional 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.
versions (pulumi.Input[list]) - 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.

The request_based_sli object supports the following:

distributionCut (pulumi.Input[dict]) - Used when good_service is defined by 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. Defines a distribution TimeSeries filter and thresholds used for measuring good service and total service. Structure is documented below.
- distributionFilter (pulumi.Input[str]) - A TimeSeries monitoring filter aggregating values to quantify the good service provided. Must have ValueType = DISTRIBUTION and MetricKind = DELTA or MetricKind = CUMULATIVE.
- range (pulumi.Input[dict]) - Range of numerical values. The computed good_service will be the count of values x in the Distribution such that range.min <= x < range.max. inclusive of min and exclusive of max. Open ranges can be defined by setting just one of min or max. Summed value X should satisfy range.min <= X < range.max for a good window. Structure is documented below.
  - max (pulumi.Input[float]) - max value for the range (inclusive). If not given, will be set to “infinity”, defining an open range “>= range.min”
  - min (pulumi.Input[float]) - Min value for the range (inclusive). If not given, will be set to “-infinity”, defining an open range “< range.max”
goodTotalRatio (pulumi.Input[dict]) - A means to compute a ratio of good_service to total_service. Defines computing this ratio with two TimeSeries monitoring filters Must specify exactly two of good, bad, and total service filters. The relationship good_service + bad_service = total_service will be assumed. Structure is documented below.
- badServiceFilter (pulumi.Input[str]) - A TimeSeries monitoring filter quantifying bad service provided, either demanded service that was not provided or demanded service that was of inadequate quality. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
- goodServiceFilter (pulumi.Input[str]) - A TimeSeries monitoring filter quantifying good service provided. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
- totalServiceFilter (pulumi.Input[str]) - A TimeSeries monitoring filter quantifying total demanded service. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.

The windows_based_sli object supports the following:

goodBadMetricFilter (pulumi.Input[str]) - A TimeSeries monitoring filter with ValueType = BOOL. The window is good if any true values appear in the window. One of good_bad_metric_filter, good_total_ratio_threshold, metric_mean_in_range, metric_sum_in_range must be set for windows_based_sli.
goodTotalRatioThreshold (pulumi.Input[dict]) - Criterion that describes a window as good if its performance is high enough. One of good_bad_metric_filter, good_total_ratio_threshold, metric_mean_in_range, metric_sum_in_range must be set for windows_based_sli. Structure is documented below.
- basicSliPerformance (pulumi.Input[dict]) - Basic SLI to evaluate to judge window quality. Structure is documented below.
  - latency (pulumi.Input[dict]) - Parameters for a latency threshold SLI. Structure is documented below.
    - threshold (pulumi.Input[str]) - A duration string, e.g. 10s. Good service is defined to be the count of requests made to this service that return in no more than threshold.
  - locations (pulumi.Input[list]) - An optional 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.
  - methods (pulumi.Input[list]) - An optional 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.
  - versions (pulumi.Input[list]) - 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.
- performance (pulumi.Input[dict]) - Request-based SLI to evaluate to judge window quality. Structure is documented below.
  - distributionCut (pulumi.Input[dict]) - Used when good_service is defined by 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. Defines a distribution TimeSeries filter and thresholds used for measuring good service and total service. Structure is documented below.
    - distributionFilter (pulumi.Input[str]) - A TimeSeries monitoring filter aggregating values to quantify the good service provided. Must have ValueType = DISTRIBUTION and MetricKind = DELTA or MetricKind = CUMULATIVE.
    - range (pulumi.Input[dict]) - Range of numerical values. The computed good_service will be the count of values x in the Distribution such that range.min <= x < range.max. inclusive of min and exclusive of max. Open ranges can be defined by setting just one of min or max. Summed value X should satisfy range.min <= X < range.max for a good window. Structure is documented below.
      - max (pulumi.Input[float]) - max value for the range (inclusive). If not given, will be set to “infinity”, defining an open range “>= range.min”
      - min (pulumi.Input[float]) - Min value for the range (inclusive). If not given, will be set to “-infinity”, defining an open range “< range.max”
  - goodTotalRatio (pulumi.Input[dict]) - A means to compute a ratio of good_service to total_service. Defines computing this ratio with two TimeSeries monitoring filters Must specify exactly two of good, bad, and total service filters. The relationship good_service + bad_service = total_service will be assumed. Structure is documented below.
    - badServiceFilter (pulumi.Input[str]) - A TimeSeries monitoring filter quantifying bad service provided, either demanded service that was not provided or demanded service that was of inadequate quality. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
    - goodServiceFilter (pulumi.Input[str]) - A TimeSeries monitoring filter quantifying good service provided. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
    - totalServiceFilter (pulumi.Input[str]) - A TimeSeries monitoring filter quantifying total demanded service. Exactly two of good, bad, or total service filter must be defined (where good + bad = total is assumed) Must have ValueType = DOUBLE or ValueType = INT64 and must have MetricKind = DELTA or MetricKind = CUMULATIVE.
- threshold (pulumi.Input[float]) - A duration string, e.g. 10s. Good service is defined to be the count of requests made to this service that return in no more than threshold.
metricMeanInRange (pulumi.Input[dict]) - Criterion that describes a window as good if the metric’s value is in a good range, averaged across returned streams. One of good_bad_metric_filter, good_total_ratio_threshold, metric_mean_in_range, metric_sum_in_range must be set for windows_based_sli. Average value X of time_series should satisfy range.min <= X < range.max for a good window. Structure is documented below.
- range (pulumi.Input[dict]) - Range of numerical values. The computed good_service will be the count of values x in the Distribution such that range.min <= x < range.max. inclusive of min and exclusive of max. Open ranges can be defined by setting just one of min or max. Summed value X should satisfy range.min <= X < range.max for a good window. Structure is documented below.
  - max (pulumi.Input[float]) - max value for the range (inclusive). If not given, will be set to “infinity”, defining an open range “>= range.min”
  - min (pulumi.Input[float]) - Min value for the range (inclusive). If not given, will be set to “-infinity”, defining an open range “< range.max”
- timeSeries (pulumi.Input[str]) - A monitoring filter specifying the TimeSeries to use for evaluating window quality. The provided TimeSeries must have ValueType = INT64 or ValueType = DOUBLE and MetricKind = GAUGE. Summed value X should satisfy range.min <= X < range.max for a good window.
metricSumInRange (pulumi.Input[dict]) - Criterion that describes a window as good if the metric’s value is in a good range, summed across returned streams. Summed value X of time_series should satisfy range.min <= X < range.max for a good window. One of good_bad_metric_filter, good_total_ratio_threshold, metric_mean_in_range, metric_sum_in_range must be set for windows_based_sli. Structure is documented below.
- range (pulumi.Input[dict]) - Range of numerical values. The computed good_service will be the count of values x in the Distribution such that range.min <= x < range.max. inclusive of min and exclusive of max. Open ranges can be defined by setting just one of min or max. Summed value X should satisfy range.min <= X < range.max for a good window. Structure is documented below.
  - max (pulumi.Input[float]) - max value for the range (inclusive). If not given, will be set to “infinity”, defining an open range “>= range.min”
  - min (pulumi.Input[float]) - Min value for the range (inclusive). If not given, will be set to “-infinity”, defining an open range “< range.max”
- timeSeries (pulumi.Input[str]) - A monitoring filter specifying the TimeSeries to use for evaluating window quality. The provided TimeSeries must have ValueType = INT64 or ValueType = DOUBLE and MetricKind = GAUGE. Summed value X should satisfy range.min <= X < range.max for a good window.
windowPeriod (pulumi.Input[str]) - Duration over which window quality is evaluated, given as a duration string “{X}s” representing X seconds. Must be an integer fraction of a day and at least 60s.

translate_output_property(prop)¶

Provides subclasses of Resource an opportunity to translate names of output properties into a format of their choosing before writing those properties to the resource object.

Parameters: prop (str) – A property name.
Returns: A potentially transformed property name.
Return type: str

translate_input_property(prop)¶

Provides subclasses of Resource an opportunity to translate names of input properties into a format of their choosing before sending those properties to the Pulumi engine.

Parameters: prop (str) – A property name.
Returns: A potentially transformed property name.
Return type: str

class pulumi_gcp.monitoring.UptimeCheckConfig(resource_name, opts=None, content_matchers=None, display_name=None, http_check=None, monitored_resource=None, period=None, project=None, resource_group=None, selected_regions=None, tcp_check=None, timeout=None, __props__=None, __name__=None, __opts__=None)¶

This message configures which resources and services to monitor for availability.

To get more information about UptimeCheckConfig, see:

API documentation
How-to Guides
- Official Documentation

Warning: All arguments including http_check.auth_info.password will be stored in the raw state as plain-text. Read more about secrets in state.

import pulumi
import pulumi_gcp as gcp

http = gcp.monitoring.UptimeCheckConfig("http",
    content_matchers=[{
        "content": "example",
    }],
    display_name="http-uptime-check",
    http_check={
        "path": "/some-path",
        "port": "8010",
    },
    monitored_resource={
        "labels": {
            "host": "192.168.1.1",
            "project_id": "my-project-name",
        },
        "type": "uptime_url",
    },
    timeout="60s")

import pulumi
import pulumi_gcp as gcp

https = gcp.monitoring.UptimeCheckConfig("https",
    content_matchers=[{
        "content": "example",
    }],
    display_name="https-uptime-check",
    http_check={
        "path": "/some-path",
        "port": "443",
        "useSsl": True,
        "validateSsl": True,
    },
    monitored_resource={
        "labels": {
            "host": "192.168.1.1",
            "project_id": "my-project-name",
        },
        "type": "uptime_url",
    },
    timeout="60s")

import pulumi
import pulumi_gcp as gcp

check = gcp.monitoring.Group("check",
    display_name="uptime-check-group",
    filter="resource.metadata.name=has_substring("foo")")
tcp_group = gcp.monitoring.UptimeCheckConfig("tcpGroup",
    display_name="tcp-uptime-check",
    timeout="60s",
    tcp_check={
        "port": 888,
    },
    resource_group={
        "resourceType": "INSTANCE",
        "groupId": check.name,
    })

Parameters

resource_name (str) – The name of the resource.
opts (pulumi.ResourceOptions) – Options for the resource.
content_matchers (pulumi.Input[list]) – The expected content on the page the check is run against. Currently, only the first entry in the list is supported, and other entries will be ignored. The server will look for an exact match of the string in the page response’s content. This field is optional and should only be specified if a content match is required. Structure is documented below.
display_name (pulumi.Input[str]) – 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.
http_check (pulumi.Input[dict]) – Contains information needed to make an HTTP or HTTPS check. Structure is documented below.
monitored_resource (pulumi.Input[dict]) – 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 Structure is documented below.
period (pulumi.Input[str]) – 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 300s.
project (pulumi.Input[str]) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
resource_group (pulumi.Input[dict]) – The group resource associated with the configuration. Structure is documented below.
selected_regions (pulumi.Input[list]) – 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 to include a minimum of 3 locations must be provided, or an error message is returned. Not specifying this field will result in uptime checks running from all regions.
tcp_check (pulumi.Input[dict]) – Contains information needed to make a TCP check. Structure is documented below.
timeout (pulumi.Input[str]) – The maximum amount of time to wait for the request to complete (must be between 1 and 60 seconds). Accepted formats https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.Duration

The content_matchers object supports the following:

content (pulumi.Input[str]) - String or regex content to match (max 1024 bytes)
matcher (pulumi.Input[str]) - The type of content matcher that will be applied to the server output, compared to the content string when the check is run.

The http_check object supports the following:

authInfo (pulumi.Input[dict]) - The authentication information. Optional when creating an HTTP check; defaults to empty. Structure is documented below.
- password (pulumi.Input[str]) - The password to authenticate. Note: This property is sensitive and will not be displayed in the plan.
- username (pulumi.Input[str]) - The username to authenticate.
headers (pulumi.Input[dict]) - 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.
maskHeaders (pulumi.Input[bool]) - Boolean specifying 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 **.
path (pulumi.Input[str]) - The path to the page to run the check against. Will be combined with the host (specified within the MonitoredResource) and port to construct the full URL. Optional (defaults to “/”).
port (pulumi.Input[float]) - The port to the page to run the check against. Will be combined with host (specified within the MonitoredResource) to construct the full URL.
useSsl (pulumi.Input[bool]) - If true, use HTTPS instead of HTTP to run the check.
validateSsl (pulumi.Input[bool]) - Boolean specifying whether to include SSL certificate validation as a part of the Uptime check. Only applies to checks where monitoredResource is set to uptime_url. If useSsl is false, setting validateSsl to true has no effect.

The monitored_resource object supports the following:

labels (pulumi.Input[dict]) - Values for all of the labels listed in the associated monitored resource descriptor. For example, Compute Engine VM instances use the labels “project_id”, “instance_id”, and “zone”.
type (pulumi.Input[str]) - The monitored resource type. This field must match the type field of a MonitoredResourceDescriptor (https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.monitoredResourceDescriptors#MonitoredResourceDescriptor) object. For example, the type of a Compute Engine VM instance is gce_instance. For a list of types, see Monitoring resource types (https://cloud.google.com/monitoring/api/resources) and Logging resource types (https://cloud.google.com/logging/docs/api/v2/resource-list).

The resource_group object supports the following:

groupId (pulumi.Input[str]) - The group of resources being monitored. Should be the name of a group
resourceType (pulumi.Input[str]) - The resource type of the group members.

The tcp_check object supports the following:

port (pulumi.Input[float]) - The port to the page to run the check against. Will be combined with host (specified within the MonitoredResource) to construct the full URL.

content_matchers: pulumi.Output[list] = None¶

The expected content on the page the check is run against. Currently, only the first entry in the list is supported, and other entries will be ignored. The server will look for an exact match of the string in the page response’s content. This field is optional and should only be specified if a content match is required. Structure is documented below.

content (str) - String or regex content to match (max 1024 bytes)
matcher (str) - The type of content matcher that will be applied to the server output, compared to the content string when the check is run.

display_name: pulumi.Output[str] = None¶: 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.

http_check: pulumi.Output[dict] = None¶

Contains information needed to make an HTTP or HTTPS check. Structure is documented below.

authInfo (dict) - The authentication information. Optional when creating an HTTP check; defaults to empty. Structure is documented below.
- password (str) - The password to authenticate. Note: This property is sensitive and will not be displayed in the plan.
- username (str) - The username to authenticate.
headers (dict) - 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.
maskHeaders (bool) - Boolean specifying 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 **.
path (str) - The path to the page to run the check against. Will be combined with the host (specified within the MonitoredResource) and port to construct the full URL. Optional (defaults to “/”).
port (float) - The port to the page to run the check against. Will be combined with host (specified within the MonitoredResource) to construct the full URL.
useSsl (bool) - If true, use HTTPS instead of HTTP to run the check.
validateSsl (bool) - Boolean specifying whether to include SSL certificate validation as a part of the Uptime check. Only applies to checks where monitoredResource is set to uptime_url. If useSsl is false, setting validateSsl to true has no effect.

monitored_resource: pulumi.Output[dict] = None¶

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 Structure is documented below.

labels (dict) - Values for all of the labels listed in the associated monitored resource descriptor. For example, Compute Engine VM instances use the labels “project_id”, “instance_id”, and “zone”.
type (str) - The monitored resource type. This field must match the type field of a MonitoredResourceDescriptor (https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.monitoredResourceDescriptors#MonitoredResourceDescriptor) object. For example, the type of a Compute Engine VM instance is gce_instance. For a list of types, see Monitoring resource types (https://cloud.google.com/monitoring/api/resources) and Logging resource types (https://cloud.google.com/logging/docs/api/v2/resource-list).

name: pulumi.Output[str] = None¶: A unique resource name for this UptimeCheckConfig. The format is projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID].

period: pulumi.Output[str] = None¶: 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 300s.

project: pulumi.Output[str] = None¶: The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

resource_group: pulumi.Output[dict] = None¶

The group resource associated with the configuration. Structure is documented below.

groupId (str) - The group of resources being monitored. Should be the name of a group
resourceType (str) - The resource type of the group members.

selected_regions: pulumi.Output[list] = None¶: 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 to include a minimum of 3 locations must be provided, or an error message is returned. Not specifying this field will result in uptime checks running from all regions.

tcp_check: pulumi.Output[dict] = None¶

Contains information needed to make a TCP check. Structure is documented below.

port (float) - The port to the page to run the check against. Will be combined with host (specified within the MonitoredResource) to construct the full URL.

timeout: pulumi.Output[str] = None¶: The maximum amount of time to wait for the request to complete (must be between 1 and 60 seconds). Accepted formats https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.Duration

uptime_check_id: pulumi.Output[str] = None¶: The id of the uptime check

static get(resource_name, id, opts=None, content_matchers=None, display_name=None, http_check=None, monitored_resource=None, name=None, period=None, project=None, resource_group=None, selected_regions=None, tcp_check=None, timeout=None, uptime_check_id=None)¶

Get an existing UptimeCheckConfig resource’s state with the given name, id, and optional extra properties used to qualify the lookup.

Parameters

resource_name (str) – The unique name of the resulting resource.
id (str) – The unique provider ID of the resource to lookup.
opts (pulumi.ResourceOptions) – Options for the resource.
content_matchers (pulumi.Input[list]) – The expected content on the page the check is run against. Currently, only the first entry in the list is supported, and other entries will be ignored. The server will look for an exact match of the string in the page response’s content. This field is optional and should only be specified if a content match is required. Structure is documented below.
display_name (pulumi.Input[str]) – 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.
http_check (pulumi.Input[dict]) – Contains information needed to make an HTTP or HTTPS check. Structure is documented below.
monitored_resource (pulumi.Input[dict]) – 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 Structure is documented below.
name (pulumi.Input[str]) – A unique resource name for this UptimeCheckConfig. The format is projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID].
period (pulumi.Input[str]) – 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 300s.
project (pulumi.Input[str]) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
resource_group (pulumi.Input[dict]) – The group resource associated with the configuration. Structure is documented below.
selected_regions (pulumi.Input[list]) – 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 to include a minimum of 3 locations must be provided, or an error message is returned. Not specifying this field will result in uptime checks running from all regions.
tcp_check (pulumi.Input[dict]) – Contains information needed to make a TCP check. Structure is documented below.
timeout (pulumi.Input[str]) – The maximum amount of time to wait for the request to complete (must be between 1 and 60 seconds). Accepted formats https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.Duration
uptime_check_id (pulumi.Input[str]) – The id of the uptime check

The content_matchers object supports the following:

content (pulumi.Input[str]) - String or regex content to match (max 1024 bytes)
matcher (pulumi.Input[str]) - The type of content matcher that will be applied to the server output, compared to the content string when the check is run.

The http_check object supports the following:

authInfo (pulumi.Input[dict]) - The authentication information. Optional when creating an HTTP check; defaults to empty. Structure is documented below.
- password (pulumi.Input[str]) - The password to authenticate. Note: This property is sensitive and will not be displayed in the plan.
- username (pulumi.Input[str]) - The username to authenticate.
headers (pulumi.Input[dict]) - 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.
maskHeaders (pulumi.Input[bool]) - Boolean specifying 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 **.
path (pulumi.Input[str]) - The path to the page to run the check against. Will be combined with the host (specified within the MonitoredResource) and port to construct the full URL. Optional (defaults to “/”).
port (pulumi.Input[float]) - The port to the page to run the check against. Will be combined with host (specified within the MonitoredResource) to construct the full URL.
useSsl (pulumi.Input[bool]) - If true, use HTTPS instead of HTTP to run the check.
validateSsl (pulumi.Input[bool]) - Boolean specifying whether to include SSL certificate validation as a part of the Uptime check. Only applies to checks where monitoredResource is set to uptime_url. If useSsl is false, setting validateSsl to true has no effect.

The monitored_resource object supports the following:

labels (pulumi.Input[dict]) - Values for all of the labels listed in the associated monitored resource descriptor. For example, Compute Engine VM instances use the labels “project_id”, “instance_id”, and “zone”.
type (pulumi.Input[str]) - The monitored resource type. This field must match the type field of a MonitoredResourceDescriptor (https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.monitoredResourceDescriptors#MonitoredResourceDescriptor) object. For example, the type of a Compute Engine VM instance is gce_instance. For a list of types, see Monitoring resource types (https://cloud.google.com/monitoring/api/resources) and Logging resource types (https://cloud.google.com/logging/docs/api/v2/resource-list).

The resource_group object supports the following:

groupId (pulumi.Input[str]) - The group of resources being monitored. Should be the name of a group
resourceType (pulumi.Input[str]) - The resource type of the group members.

The tcp_check object supports the following:

port (pulumi.Input[float]) - The port to the page to run the check against. Will be combined with host (specified within the MonitoredResource) to construct the full URL.

translate_output_property(prop)¶

Provides subclasses of Resource an opportunity to translate names of output properties into a format of their choosing before writing those properties to the resource object.

Parameters: prop (str) – A property name.
Returns: A potentially transformed property name.
Return type: str

translate_input_property(prop)¶

Provides subclasses of Resource an opportunity to translate names of input properties into a format of their choosing before sending those properties to the Pulumi engine.

Parameters: prop (str) – A property name.
Returns: A potentially transformed property name.
Return type: str

pulumi_gcp.monitoring.get_app_engine_service(module_id=None, project=None, opts=None)¶

A Monitoring Service is the root resource under which operational aspects of a generic service are accessible. A service is some discrete, autonomous, and network-accessible unit, designed to solve an individual concern

An App Engine monitoring service is automatically created by GCP to monitor App Engine services.

To get more information about Service, see:

API documentation
How-to Guides
- Service Monitoring
- Monitoring API Documentation

import pulumi
import pulumi_gcp as gcp

bucket = gcp.storage.Bucket("bucket")
object = gcp.storage.BucketObject("object",
    bucket=bucket.name,
    source=pulumi.FileAsset("./test-fixtures/appengine/hello-world.zip"))
myapp = gcp.appengine.StandardAppVersion("myapp",
    version_id="v1",
    service="myapp",
    runtime="nodejs10",
    entrypoint={
        "shell": "node ./app.js",
    },
    deployment={
        "zip": {
            "sourceUrl": pulumi.Output.all(bucket.name, object.name).apply(lambda bucketName, objectName: f"https://storage.googleapis.com/{bucket_name}/{object_name}"),
        },
    },
    env_variables={
        "port": "8080",
    },
    delete_service_on_destroy=False)
srv = myapp.service.apply(lambda service: gcp.monitoring.get_app_engine_service(module_id=service))

Parameters

module_id (str) – The ID of the App Engine module underlying this service. Corresponds to the moduleId resource label in the gae_app monitored resource, or the service/module name.
project (str) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

pulumi_gcp.monitoring.get_notification_channel(display_name=None, labels=None, project=None, type=None, user_labels=None, opts=None)¶

To get more information about NotificationChannel, see:

API documentation
How-to Guides
- Notification Options
- Monitoring API Documentation

import pulumi
import pulumi_gcp as gcp

basic = gcp.monitoring.get_notification_channel(display_name="Test Notification Channel")
alert_policy = gcp.monitoring.AlertPolicy("alertPolicy",
    display_name="My Alert Policy",
    notification_channels=[basic.name],
    combiner="OR",
    conditions=[{
        "display_name": "test condition",
        "condition_threshold": {
            "filter": "metric.type="compute.googleapis.com/instance/disk/write_bytes_count" AND resource.type="gce_instance"",
            "duration": "60s",
            "comparison": "COMPARISON_GT",
            "aggregations": [{
                "alignmentPeriod": "60s",
                "perSeriesAligner": "ALIGN_RATE",
            }],
        },
    }])

Parameters

display_name (str) – The display name for this notification channel.
labels (dict) – Labels (corresponding to the NotificationChannelDescriptor schema) to filter the notification channels by.
project (str) – The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
type (str) – The type of the notification channel.
user_labels (dict) – User-provided key-value labels to filter by.

pulumi_gcp.monitoring.get_secret_version(project=None, secret=None, version=None, opts=None)¶

Get a Secret Manager secret’s version. For more information see the official documentation and API.

import pulumi
import pulumi_gcp as gcp

basic = gcp.secretmanager.get_secret_version(secret="my-secret")

Parameters

project (str) – The project to get the secret version for. If it is not provided, the provider project is used.
secret (str) – The secret to get the secret version for.
version (str) – The version of the secret to get. If it is not provided, the latest version is retrieved.

pulumi_gcp.monitoring.get_uptime_check_i_ps(opts=None)¶

Returns the list of IP addresses that checkers run from. For more information see the official documentation.

import pulumi
import pulumi_gcp as gcp

ips = gcp.monitoring.get_uptime_check_i_ps()
pulumi.export("ipList", ips.uptime_check_ips)

The Pulumi Platform

Get Started

Migrate to Pulumi

Solutions for All Teams and Engineers

Any Code

Any Cloud

monitoring¶

On This Page