MCP Tools Reference: monitoring.googleapis.com

Tool: list_dashboards

Use this as the primary tool to retrieve a list of existing custom monitoring dashboards in a Google Cloud project. Custom monitoring dashboards let users view and analyze data from different sources in the same context. This is useful for understanding what custom dashboards are currently configured and available in a given project.

The following sample demonstrate how to use curl to invoke the list_dashboards MCP tool.

Curl Request 
                  
curl --location 'https://monitoring.googleapis.com/mcp' \
--header 'content-type: application/json' \
--header 'accept: application/json, text/event-stream' \
--data '{
  "method": "tools/call",
  "params": {
    "name": "list_dashboards",
    "arguments": {
      // provide these details according to the tool's MCP specification
    }
  },
  "jsonrpc": "2.0",
  "id": 1
}'

Input Schema

The ListDashboards request.

ListDashboardsRequest

JSON representation 
{
  "parent": string,
  "pageSize": integer,
  "pageToken": string
}
Fields
parent

string

Required. The scope of the dashboards to list. The format is:

projects/[PROJECT_ID_OR_NUMBER]
pageSize

integer

A positive number that is the maximum number of results to return. If unspecified, a default of 1000 is used.
pageToken

string

Optional. If this field is not empty then it must contain the nextPageToken value returned by a previous call to this method. Using this field causes the method to return additional results from the previous method call.

Output Schema

The ListDashboards request.

ListDashboardsResponse

JSON representation 
{
  "dashboards": [
    {
      object (Dashboard)
    }
  ],
  "nextPageToken": string
}
Fields
dashboards[]

object (Dashboard)

The list of requested dashboards.
nextPageToken

string

If there are more results than have been returned, then this field is set to a non-empty value. To see the additional results, use that value as page_token in the next call to this method.

Dashboard

JSON representation 
{
  "name": string,
  "displayName": string,
  "etag": string,
  "dashboardFilters": [
    {
      object (DashboardFilter)
    }
  ],
  "labels": {
    string: string,
    ...
  },
  "annotations": {
    object (DashboardAnnotations)
  },

  // Union field layout can be only one of the following:
  "gridLayout": {
    object (GridLayout)
  },
  "mosaicLayout": {
    object (MosaicLayout)
  },
  "rowLayout": {
    object (RowLayout)
  },
  "columnLayout": {
    object (ColumnLayout)
  }
  // End of list of possible types for union field layout.
}
Fields
name

string

Identifier. The resource name of the dashboard.
displayName

string

Required. The mutable, human-readable name.
etag

string

etag is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. An etag is returned in the response to GetDashboard, and users are expected to put that etag in the request to UpdateDashboard to ensure that their change will be applied to the same version of the Dashboard configuration. The field should not be passed during dashboard creation.
dashboardFilters[]

object (DashboardFilter)

Filters to reduce the amount of data charted based on the filter criteria.
labels

map (key: string, value: string)

Labels applied to the dashboard

An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
annotations

object (DashboardAnnotations)

Configuration for event annotations to display on this dashboard.
Union field layout. A dashboard's root container element that defines the layout style. layout can be only one of the following:
gridLayout

object (GridLayout)

Content is arranged with a basic layout that re-flows a simple list of informational elements like widgets or tiles.
mosaicLayout

object (MosaicLayout)

The content is arranged as a grid of tiles, with each content widget occupying one or more grid blocks.
rowLayout

object (RowLayout)

The content is divided into equally spaced rows and the widgets are arranged horizontally.
columnLayout

object (ColumnLayout)

The content is divided into equally spaced columns and the widgets are arranged vertically.

GridLayout

JSON representation 
{
  "columns": string,
  "widgets": [
    {
      object (Widget)
    }
  ]
}
Fields
columns

string (int64 format)

The number of columns into which the view's width is divided. If omitted or set to zero, a system default will be used while rendering.
widgets[]

object (Widget)

The informational elements that are arranged into the columns row-first.

Widget

JSON representation 
{
  "title": string,
  "id": string,
  "visibilityCondition": {
    object (VisibilityCondition)
  },

  // Union field content can be only one of the following:
  "xyChart": {
    object (XyChart)
  },
  "scorecard": {
    object (Scorecard)
  },
  "text": {
    object (Text)
  },
  "blank": {
    object
  },
  "alertChart": {
    object (AlertChart)
  },
  "timeSeriesTable": {
    object (TimeSeriesTable)
  },
  "collapsibleGroup": {
    object (CollapsibleGroup)
  },
  "logsPanel": {
    object (LogsPanel)
  },
  "incidentList": {
    object (IncidentList)
  },
  "pieChart": {
    object (PieChart)
  },
  "treemap": {
    object (Treemap)
  },
  "errorReportingPanel": {
    object (ErrorReportingPanel)
  },
  "sectionHeader": {
    object (SectionHeader)
  },
  "singleViewGroup": {
    object (SingleViewGroup)
  },
  "filterControl": {
    object (FilterControl)
  }
  // End of list of possible types for union field content.
}
Fields
title

string

Optional. The title of the widget.
id

string

Optional. The widget id. Ids may be made up of alphanumerics, dashes and underscores. Widget ids are optional.
visibilityCondition

object (VisibilityCondition)

Optional. If set, this widget is rendered only when the condition is evaluated to true.
Union field content. Content defines the component used to populate the widget. content can be only one of the following:
xyChart

object (XyChart)

A chart of time series data.
scorecard

object (Scorecard)

A scorecard summarizing time series data.
text

object (Text)

A raw string or markdown displaying textual content.
blank

object

A blank space.
alertChart

object (AlertChart)

A chart of alert policy data.
timeSeriesTable

object (TimeSeriesTable)

A widget that displays time series data in a tabular format.
collapsibleGroup

object (CollapsibleGroup)

A widget that groups the other widgets. All widgets that are within the area spanned by the grouping widget are considered member widgets.
logsPanel

object (LogsPanel)

A widget that shows a stream of logs.
incidentList

object (IncidentList)

A widget that shows list of incidents.
pieChart

object (PieChart)

A widget that displays timeseries data as a pie chart.
treemap

object (Treemap)

A widget that displays data as a treemap.
errorReportingPanel

object (ErrorReportingPanel)

A widget that displays a list of error groups.
sectionHeader

object (SectionHeader)

A widget that defines a section header for easier navigation of the dashboard.
singleViewGroup

object (SingleViewGroup)

A widget that groups the other widgets by using a dropdown menu.
filterControl

object (FilterControl)

A widget that displays an input field to change the value of a template variable.

XyChart

JSON representation 
{
  "dataSets": [
    {
      object (DataSet)
    }
  ],
  "timeshiftDuration": string,
  "thresholds": [
    {
      object (Threshold)
    }
  ],
  "xAxis": {
    object (Axis)
  },
  "yAxis": {
    object (Axis)
  },
  "y2Axis": {
    object (Axis)
  },
  "chartOptions": {
    object (ChartOptions)
  }
}
Fields
dataSets[]

object (DataSet)

Required. The data displayed in this chart.
timeshiftDuration

string (Duration format)

The duration used to display a comparison chart. A comparison chart simultaneously shows values from two similar-length time periods (e.g., week-over-week metrics). The duration must be positive, and it can only be applied to charts with data sets of LINE plot type.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
thresholds[]

object (Threshold)

Threshold lines drawn horizontally across the chart.
xAxis

object (Axis)

The properties applied to the x-axis.
yAxis

object (Axis)

The properties applied to the y-axis.
y2Axis

object (Axis)

The properties applied to the y2-axis.
chartOptions

object (ChartOptions)

Display options for the chart.

DataSet

JSON representation 
{
  "timeSeriesQuery": {
    object (TimeSeriesQuery)
  },
  "plotType": enum (PlotType),
  "legendTemplate": string,
  "minAlignmentPeriod": string,
  "targetAxis": enum (TargetAxis),
  "dimensions": [
    {
      object (Dimension)
    }
  ],
  "measures": [
    {
      object (Measure)
    }
  ],
  "breakdowns": [
    {
      object (Breakdown)
    }
  ],
  "sort": [
    {
      object (ColumnSortingOptions)
    }
  ]
}
Fields
timeSeriesQuery

object (TimeSeriesQuery)

Required. Fields for querying time series data from the Stackdriver metrics API.
plotType

enum (PlotType)

How this data should be plotted on the chart.
legendTemplate

string

A template string for naming TimeSeries in the resulting data set. This should be a string with interpolations of the form ${label_name}, which will resolve to the label's value.
minAlignmentPeriod

string (Duration format)

Optional. The lower bound on data point frequency for this data set, implemented by specifying the minimum alignment period to use in a time series query. For example, if the data is published once every 10 minutes, the min_alignment_period should be at least 10 minutes. It would not make sense to fetch and align data at one minute intervals.

For PromQL queries, this field is used to set the minimum interval for the query step, controlling data granularity. Larger values can improve performance on long time ranges. See Querying Basics and Range Queries for more details on the PromQL step.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
targetAxis

enum (TargetAxis)

Optional. The target axis to use for plotting the metric.
dimensions[]

object (Dimension)

Optional. A collection of dimension columns.
measures[]

object (Measure)

Optional. A collection of measures.
breakdowns[]

object (Breakdown)

Optional. The collection of breakdowns to be applied to the dataset.
sort[]

object (ColumnSortingOptions)

Optional. A collection of sort options, affects the order of the data and legend.

TimeSeriesQuery

JSON representation 
{
  "unitOverride": string,
  "outputFullDuration": boolean,

  // Union field source can be only one of the following:
  "timeSeriesFilter": {
    object (TimeSeriesFilter)
  },
  "timeSeriesFilterRatio": {
    object (TimeSeriesFilterRatio)
  },
  "timeSeriesQueryLanguage": string,
  "prometheusQuery": string,
  "opsAnalyticsQuery": {
    object (OpsAnalyticsQuery)
  }
  // End of list of possible types for union field source.
}
Fields
unitOverride

string

The unit of data contained in fetched time series. If non-empty, this unit will override any unit that accompanies fetched data. The format is the same as the unit field in MetricDescriptor.
outputFullDuration

boolean

Optional. If set, Cloud Monitoring will treat the full query duration as the alignment period so that there will be only 1 output value.

*Note: This could override the configured alignment period except for the cases where a series of data points are expected, like - XyChart - Scorecard's spark chart
Union field source. Parameters needed to obtain data for the chart. source can be only one of the following:
timeSeriesFilter

object (TimeSeriesFilter)

Filter parameters to fetch time series.
timeSeriesFilterRatio

object (TimeSeriesFilterRatio)

Parameters to fetch a ratio between two time series filters.
timeSeriesQueryLanguage

string

A query used to fetch time series with MQL.
prometheusQuery

string

A query used to fetch time series with PromQL.
opsAnalyticsQuery

object (OpsAnalyticsQuery)

Preview: A query used to fetch a time series, category series, or numeric series with SQL. This is a preview feature and may be subject to change before final release.

TimeSeriesFilter

JSON representation 
{
  "filter": string,
  "aggregation": {
    object (Aggregation)
  },
  "secondaryAggregation": {
    object (Aggregation)
  },

  // Union field output_filter can be only one of the following:
  "pickTimeSeriesFilter": {
    object (PickTimeSeriesFilter)
  },
  "statisticalTimeSeriesFilter": {
    object (StatisticalTimeSeriesFilter)
  }
  // End of list of possible types for union field output_filter.
}
Fields
filter

string

Required. The monitoring filter that identifies the metric types, resources, and projects to query.
aggregation

object (Aggregation)

By default, the raw time series data is returned. Use this field to combine multiple time series for different views of the data.
secondaryAggregation

object (Aggregation)

Apply a second aggregation after aggregation is applied.
Union field output_filter. Selects an optional time series filter. output_filter can be only one of the following:
pickTimeSeriesFilter

object (PickTimeSeriesFilter)

Ranking based time series filter.
statisticalTimeSeriesFilter
(deprecated)

object (StatisticalTimeSeriesFilter)

Statistics based time series filter. Note: This field is deprecated and completely ignored by the API.

Aggregation

JSON representation 
{
  "alignmentPeriod": string,
  "perSeriesAligner": enum (Aligner),
  "crossSeriesReducer": enum (Reducer),
  "groupByFields": [
    string
  ]
}
Fields
alignmentPeriod

string (Duration format)

The alignment_period specifies a time interval, in seconds, that is used to divide the data in all the time series into consistent blocks of time. This will be done before the per-series aligner can be applied to the data.

The value must be at least 60 seconds. If a per-series aligner other than ALIGN_NONE is specified, this field is required or an error is returned. If no per-series aligner is specified, or the aligner ALIGN_NONE is specified, then this field is ignored.

The maximum value of the alignment_period is 2 years, or 104 weeks.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
perSeriesAligner

enum (Aligner)

An Aligner describes how to bring the data points in a single time series into temporal alignment. Except for ALIGN_NONE, all alignments cause all the data points in an alignment_period to be mathematically grouped together, resulting in a single data point for each alignment_period with end timestamp at the end of the period.

Not all alignment operations may be applied to all time series. The valid choices depend on the metric_kind and value_type of the original time series. Alignment can change the metric_kind or the value_type of the time series.

Time series data must be aligned in order to perform cross-time series reduction. If cross_series_reducer is specified, then per_series_aligner must be specified and not equal to ALIGN_NONE and alignment_period must be specified; otherwise, an error is returned.
crossSeriesReducer

enum (Reducer)

The reduction operation to be used to combine time series into a single time series, where the value of each data point in the resulting series is a function of all the already aligned values in the input time series.

Not all reducer operations can be applied to all time series. The valid choices depend on the metric_kind and the value_type of the original time series. Reduction can yield a time series with a different metric_kind or value_type than the input time series.

Time series data must first be aligned (see per_series_aligner) in order to perform cross-time series reduction. If cross_series_reducer is specified, then per_series_aligner must be specified, and must not be ALIGN_NONE. An alignment_period must also be specified; otherwise, an error is returned.
groupByFields[]

string

The set of fields to preserve when cross_series_reducer is specified. The group_by_fields determine how the time series are partitioned into subsets prior to applying the aggregation operation. 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 cross_series_reducer 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 group_by_fields are aggregated away. If group_by_fields 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 cross_series_reducer is not defined, this field is ignored.

Duration

JSON representation 
{
  "seconds": string,
  "nanos": integer
}
Fields
seconds

string (int64 format)

Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
nanos

integer

Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 seconds field and a positive or negative nanos field. For durations of one second or more, a non-zero value for the nanos field must be of the same sign as the seconds field. Must be from -999,999,999 to +999,999,999 inclusive.

PickTimeSeriesFilter

JSON representation 
{
  "rankingMethod": enum (Method),
  "numTimeSeries": integer,
  "direction": enum (Direction),
  "interval": {
    object (Interval)
  }
}
Fields
rankingMethod

enum (Method)

ranking_method is applied to each time series independently to produce the value which will be used to compare the time series to other time series.
numTimeSeries

integer

How many time series to allow to pass through the filter.
direction

enum (Direction)

How to use the ranking to select time series that pass through the filter.
interval

object (Interval)

Select the top N streams/time series within this time interval

Interval

JSON representation 
{
  "startTime": string,
  "endTime": string
}
Fields
startTime

string (Timestamp format)

Optional. Inclusive start of the interval.

If specified, a Timestamp matching this interval will have to be the same or after the start.

Uses RFC 3339, where generated output will always be Z-normalized and use 0, 3, 6 or 9 fractional digits. Offsets other than "Z" are also accepted. Examples: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" or "2014-10-02T15:01:23+05:30".
endTime

string (Timestamp format)

Optional. Exclusive end of the interval.

If specified, a Timestamp matching this interval will have to be before the end.

Uses RFC 3339, where generated output will always be Z-normalized and use 0, 3, 6 or 9 fractional digits. Offsets other than "Z" are also accepted. Examples: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" or "2014-10-02T15:01:23+05:30".

Timestamp

JSON representation 
{
  "seconds": string,
  "nanos": integer
}
Fields
seconds

string (int64 format)

Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be between -62135596800 and 253402300799 inclusive (which corresponds to 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z).
nanos

integer

Non-negative fractions of a second at nanosecond resolution. This field is the nanosecond portion of the duration, not an alternative to seconds. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be between 0 and 999,999,999 inclusive.

StatisticalTimeSeriesFilter

JSON representation 
{
  "rankingMethod": enum (Method),
  "numTimeSeries": integer
}
Fields
rankingMethod

enum (Method)

rankingMethod is applied to a set of time series, and then the produced value for each individual time series is used to compare a given time series to others. These are methods that cannot be applied stream-by-stream, but rather require the full context of a request to evaluate time series.
numTimeSeries

integer

How many time series to output.

TimeSeriesFilterRatio

JSON representation 
{
  "numerator": {
    object (RatioPart)
  },
  "denominator": {
    object (RatioPart)
  },
  "secondaryAggregation": {
    object (Aggregation)
  },

  // Union field output_filter can be only one of the following:
  "pickTimeSeriesFilter": {
    object (PickTimeSeriesFilter)
  },
  "statisticalTimeSeriesFilter": {
    object (StatisticalTimeSeriesFilter)
  }
  // End of list of possible types for union field output_filter.
}
Fields
numerator

object (RatioPart)

The numerator of the ratio.
denominator

object (RatioPart)

The denominator of the ratio.
secondaryAggregation

object (Aggregation)

Apply a second aggregation after the ratio is computed.
Union field output_filter. Selects an optional filter that is applied to the time series after computing the ratio. output_filter can be only one of the following:
pickTimeSeriesFilter

object (PickTimeSeriesFilter)

Ranking based time series filter.
statisticalTimeSeriesFilter
(deprecated)

object (StatisticalTimeSeriesFilter)

Statistics based time series filter. Note: This field is deprecated and completely ignored by the API.

RatioPart

JSON representation 
{
  "filter": string,
  "aggregation": {
    object (Aggregation)
  }
}
Fields
filter

string

Required. The monitoring filter that identifies the metric types, resources, and projects to query.
aggregation

object (Aggregation)

By default, the raw time series data is returned. Use this field to combine multiple time series for different views of the data.

OpsAnalyticsQuery

JSON representation 
{
  "sql": string
}
Fields
sql

string

A SQL query to fetch time series, category series, or numeric series data.

Dimension

JSON representation 
{
  "column": string,
  "columnType": string,
  "maxBinCount": integer,
  "sortOrder": enum (SortOrder),
  "sortColumn": string,

  // Union field bin_size can be only one of the following:
  "timeBinSize": string,
  "numericBinSize": integer,
  "floatBinSize": number
  // End of list of possible types for union field bin_size.
}
Fields
column

string

Required. For widgets that use SQL queries, set the value to the name of the column in the results table whose data is charted. For a histogram that uses a time series query, set the value of this field to metric_value.
columnType

string

Optional. The type of the dimension column. This is relevant only if one of the bin_size fields is set. If it is empty, the type TIMESTAMP or INT64 will be assumed based on which bin_size field is set. If populated, this should be set to one of the following types: DATE, TIME, DATETIME, TIMESTAMP, BIGNUMERIC, INT64, NUMERIC, FLOAT64.
maxBinCount

integer

For widgets that use SQL queries, the limit to the number of bins to generate. When 0 is specified, the maximum count is not enforced. For a histogram that uses a time series query, the exact number of bins to generate. If not specified or the value is 0, then the histogram determines the number of bins to use.
sortOrder

enum (SortOrder)

The sort order applied to the sort column.
sortColumn

string

The column name to sort on for binning. This column can be the same column as this dimension or any other column used as a measure in the results. If sort_order is set to NONE, then this value is not used.
Union field bin_size. The values of bin_size are used to configure the grouping of points for the dimension specified by the column field. bin_size can be only one of the following:
timeBinSize

string (Duration format)

time_bin_size is used when the data type of the specified dimension is a time type and the bin size is determined by a time duration. If column_type is DATE, this must be a whole value multiple of 1 day. If column_type is TIME, this must be less than or equal to 24 hours.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
numericBinSize

integer

numeric_bin_size is used when the column type used for a dimension is numeric or string. If the column field is set to metric_value, then numericBinSize overrides maxBinCount.
floatBinSize

number

Optional. float_bin_size is used when the column type used for a dimension is a floating point numeric column.

Measure

JSON representation 
{
  "column": string,
  "aggregationFunction": {
    object (AggregationFunction)
  }
}
Fields
column

string

Required. The column name within in the dataset used for the measure.
aggregationFunction

object (AggregationFunction)

Required. The aggregation function applied to the input column. This must not be set to "none" unless binning is disabled on the dimension. The aggregation function is used to group points on the dimension bins.

AggregationFunction

JSON representation 
{
  "type": string,
  "parameters": [
    {
      object (Parameter)
    }
  ]
}
Fields
type

string

Required. The type of aggregation function, must be one of the following:

  • "none" - no function.
  • "percentile" - APPROX_QUANTILES() - 1 parameter numeric value
  • "average" - AVG()
  • "count" - COUNT()
  • "count-distinct" - COUNT(DISTINCT)
  • "count-distinct-approx" - APPROX_COUNT_DISTINCT()
  • "max" - MAX()
  • "min" - MIN()
  • "sum" - SUM()
parameters[]

object (Parameter)

Optional. Parameters applied to the aggregation function. Only used for functions that require them.

Parameter

JSON representation 
{

  // Union field value can be only one of the following:
  "intValue": string,
  "doubleValue": number
  // End of list of possible types for union field value.
}
Fields
Union field value. Parameter value. value can be only one of the following:
intValue

string (int64 format)

An integer parameter value.
doubleValue

number

A floating-point parameter value.

Breakdown

JSON representation 
{
  "column": string,
  "limit": integer,
  "aggregationFunction": {
    object (AggregationFunction)
  },
  "sortOrder": enum (SortOrder)
}
Fields
column

string

Required. The name of the column in the dataset containing the breakdown values.
limit

integer

Required. A limit to the number of breakdowns. If set to zero then all possible breakdowns are applied. The list of breakdowns is dependent on the value of the sort_order field.
aggregationFunction

object (AggregationFunction)

Required. The Aggregation function is applied across all data in each breakdown created.
sortOrder

enum (SortOrder)

Required. The sort order is applied to the values of the breakdown column.

ColumnSortingOptions

JSON representation 
{
  "column": string,
  "direction": enum (SortOrder)
}
Fields
column

string

Optional. Column name to sort data by
direction

enum (SortOrder)

Optional. A sorting direction that determines ascending or descending order. This is a legacy field kept for backwards compatibility with table.

Threshold

JSON representation 
{
  "label": string,
  "value": number,
  "color": enum (Color),
  "direction": enum (Direction),
  "targetAxis": enum (TargetAxis)
}
Fields
label

string

A label for the threshold.
value

number

The value of the threshold. The value should be defined in the native scale of the metric.
color

enum (Color)

The state color for this threshold. Color is not allowed in a XyChart.
direction

enum (Direction)

The direction for the current threshold. Direction is not allowed in a XyChart.
targetAxis

enum (TargetAxis)

The target axis to use for plotting the threshold. Target axis is not allowed in a Scorecard.

Axis

JSON representation 
{
  "label": string,
  "scale": enum (Scale)
}
Fields
label

string

The label of the axis.
scale

enum (Scale)

The axis scale. By default, a linear scale is used.

ChartOptions

JSON representation 
{
  "mode": enum (Mode),
  "displayHorizontal": boolean
}
Fields
mode

enum (Mode)

The chart mode.
displayHorizontal

boolean

Preview: Configures whether the charted values are shown on the horizontal or vertical axis. By default, values are represented the vertical axis. This is a preview feature and may be subject to change before final release.

Scorecard

JSON representation 
{
  "timeSeriesQuery": {
    object (TimeSeriesQuery)
  },
  "thresholds": [
    {
      object (Threshold)
    }
  ],
  "dimensions": [
    {
      object (Dimension)
    }
  ],
  "measures": [
    {
      object (Measure)
    }
  ],
  "breakdowns": [
    {
      object (Breakdown)
    }
  ],

  // Union field data_view can be only one of the following:
  "gaugeView": {
    object (GaugeView)
  },
  "sparkChartView": {
    object (SparkChartView)
  },
  "blankView": {
    object
  }
  // End of list of possible types for union field data_view.
}
Fields
timeSeriesQuery

object (TimeSeriesQuery)

Required. Fields for querying time series data from the Stackdriver metrics API.
thresholds[]

object (Threshold)

The thresholds used to determine the state of the scorecard given the time series' current value. For an actual value x, the scorecard is in a danger state if x is less than or equal to a danger threshold that triggers below, or greater than or equal to a danger threshold that triggers above. Similarly, if x is above/below a warning threshold that triggers above/below, then the scorecard is in a warning state - unless x also puts it in a danger state. (Danger trumps warning.)

As an example, consider a scorecard with the following four thresholds:

{
  value: 90,
  category: 'DANGER',
  trigger: 'ABOVE',
},
{
  value: 70,
  category: 'WARNING',
  trigger: 'ABOVE',
},
{
  value: 10,
  category: 'DANGER',
  trigger: 'BELOW',
},
{
  value: 20,
  category: 'WARNING',
  trigger: 'BELOW',
}

Then: values less than or equal to 10 would put the scorecard in a DANGER state, values greater than 10 but less than or equal to 20 a WARNING state, values strictly between 20 and 70 an OK state, values greater than or equal to 70 but less than 90 a WARNING state, and values greater than or equal to 90 a DANGER state.
dimensions[]

object (Dimension)

Optional. A dimension is a structured label, class, or category for a set of measurements in your data.
measures[]

object (Measure)

Optional. A measure is a measured value of a property in your data. For example, rainfall in inches, number of units sold, revenue gained, etc.
breakdowns[]

object (Breakdown)

Optional. The collection of breakdowns to be applied to the dataset. A breakdown is a way to slice the data. For example, you can break down the data by region.
Union field data_view. Defines the optional additional chart shown on the scorecard. If neither is included - then a default scorecard is shown. data_view can be only one of the following:
gaugeView

object (GaugeView)

Will cause the scorecard to show a gauge chart.
sparkChartView

object (SparkChartView)

Will cause the scorecard to show a spark chart.
blankView

object

Will cause the Scorecard to show only the value, with no indicator to its value relative to its thresholds.

GaugeView

JSON representation 
{
  "lowerBound": number,
  "upperBound": number
}
Fields
lowerBound

number

The lower bound for this gauge chart. The value of the chart should always be greater than or equal to this.
upperBound

number

The upper bound for this gauge chart. The value of the chart should always be less than or equal to this.

SparkChartView

JSON representation 
{
  "sparkChartType": enum (SparkChartType),
  "minAlignmentPeriod": string
}
Fields
sparkChartType

enum (SparkChartType)

Required. The type of sparkchart to show in this chartView.
minAlignmentPeriod

string (Duration format)

The lower bound on data point frequency in the chart implemented by specifying the minimum alignment period to use in a time series query. For example, if the data is published once every 10 minutes it would not make sense to fetch and align data at one minute intervals. This field is optional and exists only as a hint.

For PromQL queries, this field is used to set the minimum interval for the query step, controlling data granularity. Larger values can improve performance on long time ranges. See Querying Basics and Range Queries for more details on the PromQL step.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

Text

JSON representation 
{
  "content": string,
  "format": enum (Format),
  "style": {
    object (TextStyle)
  }
}
Fields
content

string

The text content to be displayed.
format

enum (Format)

How the text content is formatted.
style

object (TextStyle)

How the text is styled

TextStyle

JSON representation 
{
  "backgroundColor": string,
  "textColor": string,
  "horizontalAlignment": enum (HorizontalAlignment),
  "verticalAlignment": enum (VerticalAlignment),
  "padding": enum (PaddingSize),
  "fontSize": enum (FontSize),
  "pointerLocation": enum (PointerLocation)
}
Fields
backgroundColor

string

The background color as a hex string. "#RRGGBB" or "#RGB"
textColor

string

The text color as a hex string. "#RRGGBB" or "#RGB"
horizontalAlignment

enum (HorizontalAlignment)

The horizontal alignment of both the title and content
verticalAlignment

enum (VerticalAlignment)

The vertical alignment of both the title and content
padding

enum (PaddingSize)

The amount of padding around the widget
fontSize

enum (FontSize)

Font sizes for both the title and content. The title will still be larger relative to the content.
pointerLocation

enum (PointerLocation)

The pointer location for this widget (also sometimes called a "tail")

AlertChart

JSON representation 
{
  "name": string
}
Fields
name

string

Required. The resource name of the alert policy. The format is:

projects/[PROJECT_ID_OR_NUMBER]/alertPolicies/[ALERT_POLICY_ID]

TimeSeriesTable

JSON representation 
{
  "dataSets": [
    {
      object (TableDataSet)
    }
  ],
  "metricVisualization": enum (MetricVisualization),
  "columnSettings": [
    {
      object (ColumnSettings)
    }
  ]
}
Fields
dataSets[]

object (TableDataSet)

Required. The data displayed in this table.
metricVisualization

enum (MetricVisualization)

Optional. Store rendering strategy
columnSettings[]

object (ColumnSettings)

Optional. The list of the persistent column settings for the table.

TableDataSet

JSON representation 
{
  "timeSeriesQuery": {
    object (TimeSeriesQuery)
  },
  "tableTemplate": string,
  "minAlignmentPeriod": string,
  "tableDisplayOptions": {
    object (TableDisplayOptions)
  }
}
Fields
timeSeriesQuery

object (TimeSeriesQuery)

Required. Fields for querying time series data from the Stackdriver metrics API.
tableTemplate

string

Optional. A template string for naming TimeSeries in the resulting data set. This should be a string with interpolations of the form ${label_name}, which will resolve to the label's value i.e. "${resource.labels.project_id}."
minAlignmentPeriod

string (Duration format)

Optional. The lower bound on data point frequency for this data set, implemented by specifying the minimum alignment period to use in a time series query For example, if the data is published once every 10 minutes, the min_alignment_period should be at least 10 minutes. It would not make sense to fetch and align data at one minute intervals.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
tableDisplayOptions

object (TableDisplayOptions)

Optional. Table display options for configuring how the table is rendered.

TableDisplayOptions

JSON representation 
{
  "shownColumns": [
    string
  ]
}
Fields
shownColumns[]
(deprecated)

string

Optional. This field is unused and has been replaced by TimeSeriesTable.column_settings

ColumnSettings

JSON representation 
{
  "column": string,
  "visible": boolean,
  "alignment": enum (CellAlignment),
  "displayName": string,
  "thresholds": [
    {
      object (Threshold)
    }
  ]
}
Fields
column

string

Required. The id of the column.
visible

boolean

Required. Whether the column should be visible on page load.
alignment

enum (CellAlignment)

Optional. Whether the column should be left / middle / right aligned
displayName

string

Optional. Display name of the column
thresholds[]

object (Threshold)

Optional. The thresholds used to determine how the table cell should be rendered given the time series' current value.

CollapsibleGroup

JSON representation 
{
  "collapsed": boolean
}
Fields
collapsed

boolean

The collapsed state of the widget on first page load.

LogsPanel

JSON representation 
{
  "filter": string,
  "resourceNames": [
    string
  ]
}
Fields
filter

string

A filter that chooses which log entries to return. See Advanced Logs Queries. Only log entries that match the filter are returned. An empty filter matches all log entries.
resourceNames[]

string

The names of logging resources to collect logs for. Currently projects and storage views are supported. If empty, the widget will default to the host project.

IncidentList

JSON representation 
{
  "monitoredResources": [
    {
      object (MonitoredResource)
    }
  ],
  "policyNames": [
    string
  ]
}
Fields
monitoredResources[]

object (MonitoredResource)

Optional. The monitored resource for which incidents are listed. The resource doesn't need to be fully specified. That is, you can specify the resource type but not the values of the resource labels. The resource type and labels are used for filtering.
policyNames[]

string

Optional. A list of alert policy names to filter the incident list by. Don't include the project ID prefix in the policy name. For example, use alertPolicies/utilization.

MonitoredResource

JSON representation 
{
  "type": string,
  "labels": {
    string: string,
    ...
  }
}
Fields
type

string

Required. The monitored resource type. This field must match the type field of a MonitoredResourceDescriptor object. For example, the type of a Compute Engine VM instance is gce_instance. For a list of types, see Monitoring resource types and Logging resource types.
labels

map (key: string, value: string)

Required. 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".

An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

LabelsEntry

JSON representation 
{
  "key": string,
  "value": string
}
Fields
key

string
value

string

PieChart

JSON representation 
{
  "dataSets": [
    {
      object (PieChartDataSet)
    }
  ],
  "chartType": enum (PieChartType),
  "showLabels": boolean
}
Fields
dataSets[]

object (PieChartDataSet)

Required. The queries for the chart's data.
chartType

enum (PieChartType)

Required. Indicates the visualization type for the PieChart.
showLabels

boolean

Optional. Indicates whether or not the pie chart should show slices' labels

PieChartDataSet

JSON representation 
{
  "timeSeriesQuery": {
    object (TimeSeriesQuery)
  },
  "sliceNameTemplate": string,
  "minAlignmentPeriod": string,
  "dimensions": [
    {
      object (Dimension)
    }
  ],
  "measures": [
    {
      object (Measure)
    }
  ]
}
Fields
timeSeriesQuery

object (TimeSeriesQuery)

Required. The query for the PieChart. See, google.monitoring.dashboard.v1.TimeSeriesQuery.
sliceNameTemplate

string

Optional. A template for the name of the slice. This name will be displayed in the legend and the tooltip of the pie chart. It replaces the auto-generated names for the slices. For example, if the template is set to ${resource.labels.zone}, the zone's value will be used for the name instead of the default name.
minAlignmentPeriod

string (Duration format)

Optional. The lower bound on data point frequency for this data set, implemented by specifying the minimum alignment period to use in a time series query. For example, if the data is published once every 10 minutes, the min_alignment_period should be at least 10 minutes. It would not make sense to fetch and align data at one minute intervals.

A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
dimensions[]

object (Dimension)

A dimension is a structured label, class, or category for a set of measurements in your data.
measures[]

object (Measure)

A measure is a measured value of a property in your data. For example, rainfall in inches, number of units sold, revenue gained, etc.

Treemap

JSON representation 
{
  "dataSets": [
    {
      object (TreemapDataSet)
    }
  ],
  "treemapHierarchy": [
    string
  ]
}
Fields
dataSets[]

object (TreemapDataSet)

Required. The collection of datasets used to construct and populate the treemap. For the rendered treemap rectangles:

  • Color is determined by the aggregated value for each grouping.
  • Size is proportional to the count of time series aggregated within that rectangle's segment.
treemapHierarchy[]

string

Required. Ordered labels representing the hierarchical treemap structure.

TreemapDataSet

JSON representation 
{
  "timeSeriesQuery": {
    object (TimeSeriesQuery)
  },
  "measures": [
    {
      object (Measure)
    }
  ],
  "breakdowns": [
    {
      object (Breakdown)
    }
  ]
}
Fields
timeSeriesQuery

object (TimeSeriesQuery)

Required. The query that fetches the relevant data. See google.monitoring.dashboard.v1.TimeSeriesQuery
measures[]

object (Measure)

Optional. A collection of measures. A measure is a measured value of a property in your data. For example, rainfall in inches, number of units sold, revenue gained, etc.
breakdowns[]

object (Breakdown)

Optional. The collection of breakdowns to be applied to the dataset. A breakdown is a way to slice the data. For example, you can break down the data by region.

ErrorReportingPanel

JSON representation 
{
  "projectNames": [
    string
  ],
  "services": [
    string
  ],
  "versions": [
    string
  ]
}
Fields
projectNames[]

string

The resource name of the Google Cloud Platform project. Written as projects/{projectID} or projects/{projectNumber}, where {projectID} and {projectNumber} can be found in the Google Cloud console.

Examples: projects/my-project-123, projects/5551234.
services[]

string

An identifier of the service, such as the name of the executable, job, or Google App Engine service name. This field is expected to have a low number of values that are relatively stable over time, as opposed to version, which can be changed whenever new code is deployed.

Contains the service name for error reports extracted from Google App Engine logs or default if the App Engine default service is used.
versions[]

string

Represents the source code version that the developer provided, which could represent a version label or a Git SHA-1 hash, for example. For App Engine standard environment, the version is set to the version of the app.

SectionHeader

JSON representation 
{
  "subtitle": string,
  "dividerBelow": boolean
}
Fields
subtitle

string

The subtitle of the section
dividerBelow

boolean

Whether to insert a divider below the section in the table of contents

SingleViewGroup

JSON representation 
{
  "displayType": enum (DisplayType)
}
Fields
displayType

enum (DisplayType)

Optional. Determines how the widget selector will be displayed.

FilterControl

JSON representation 
{
  "templateVariable": string
}
Fields
templateVariable

string

Name of the template variable the widget affects.

VisibilityCondition

JSON representation 
{
  "templateVariableCondition": {
    object (TemplateVariableCondition)
  }
}
Fields
templateVariableCondition

object (TemplateVariableCondition)

A condition whose evaluation is based on the value of a template variable.

TemplateVariableCondition

JSON representation 
{
  "templateVariable": string,
  "templateVariableValue": string,
  "comparator": enum (Comparator)
}
Fields
templateVariable

string

The template variable whose value is evaluated.
templateVariableValue

string

The value to compare the template variable to. For example, if the comparator is REGEX_FULL_MATCH, this field should contain a regex.
comparator

enum (Comparator)

Comparator to use to evaluate whether the value of the template variable matches the template_variable_value. For example, if the comparator is REGEX_FULL_MATCH, template_variable_value would contain a regex that is matched against the value of the template variable.

MosaicLayout

JSON representation 
{
  "columns": integer,
  "tiles": [
    {
      object (Tile)
    }
  ]
}
Fields
columns

integer

The number of columns in the mosaic grid. The number of columns must be between 1 and 48, inclusive.
tiles[]

object (Tile)

The tiles to display.

Tile

JSON representation 
{
  "xPos": integer,
  "yPos": integer,
  "width": integer,
  "height": integer,
  "widget": {
    object (Widget)
  }
}
Fields
xPos

integer

The zero-indexed position of the tile in grid blocks relative to the left edge of the grid. Tiles must be contained within the specified number of columns. x_pos cannot be negative.
yPos

integer

The zero-indexed position of the tile in grid blocks relative to the top edge of the grid. y_pos cannot be negative.
width

integer

The width of the tile, measured in grid blocks. Tiles must have a minimum width of 1.
height

integer

The height of the tile, measured in grid blocks. Tiles must have a minimum height of 1.
widget

object (Widget)

The informational widget contained in the tile. For example an XyChart.

RowLayout

JSON representation 
{
  "rows": [
    {
      object (Row)
    }
  ]
}
Fields
rows[]

object (Row)

The rows of content to display.

Row

JSON representation 
{
  "weight": string,
  "widgets": [
    {
      object (Widget)
    }
  ]
}
Fields
weight

string (int64 format)

The relative weight of this row. The row weight is used to adjust the height of rows on the screen (relative to peers). Greater the weight, greater the height of the row on the screen. If omitted, a value of 1 is used while rendering.
widgets[]

object (Widget)

The display widgets arranged horizontally in this row.

ColumnLayout

JSON representation 
{
  "columns": [
    {
      object (Column)
    }
  ]
}
Fields
columns[]

object (Column)

The columns of content to display.

Column

JSON representation 
{
  "weight": string,
  "widgets": [
    {
      object (Widget)
    }
  ]
}
Fields
weight

string (int64 format)

The relative weight of this column. The column weight is used to adjust the width of columns on the screen (relative to peers). Greater the weight, greater the width of the column on the screen. If omitted, a value of 1 is used while rendering.
widgets[]

object (Widget)

The display widgets arranged vertically in this column.

DashboardFilter

JSON representation 
{
  "labelKey": string,
  "templateVariable": string,
  "valueType": enum (ValueType),
  "filterType": enum (FilterType),

  // Union field default_value can be only one of the following:
  "stringValue": string,
  "stringArrayValue": {
    object (StringArray)
  }
  // End of list of possible types for union field default_value.

  // Union field value_source can be only one of the following:
  "timeSeriesQuery": {
    object (TimeSeriesQuery)
  },
  "stringArray": {
    object (StringArray)
  }
  // End of list of possible types for union field value_source.
}
Fields
labelKey

string

Optional. The key for the label. This must be omitted if the filter_type is VALUE_ONLY but is required otherwise.
templateVariable

string

The placeholder text that can be referenced in a filter string or MQL query. If omitted, the dashboard filter will be applied to all relevant widgets in the dashboard.
valueType

enum (ValueType)

The type of the filter value. If value_type is not provided, it will be inferred from the default_value. If neither value_type nor default_value is provided, value_type will be set to STRING by default.
filterType

enum (FilterType)

The specified filter type
Union field default_value. The default value used in the filter comparison default_value can be only one of the following:
stringValue

string

A variable-length string value. If this field is set, value_type must be set to STRING or VALUE_TYPE_UNSPECIFIED
stringArrayValue

object (StringArray)

An array of variable-length string values. If this field is set, value_type must be set to STRING_ARRAY or VALUE_TYPE_UNSPECIFIED
Union field value_source. A definition of the set of valid values for the filter. This is optional but recommended for VALUE_ONLY filters. For other filter types, the set of valid values will be inferred from the charted data. value_source can be only one of the following:
timeSeriesQuery

object (TimeSeriesQuery)

A query to run to fetch possible values for the filter. Only OpsAnalyticsQueries are supported
stringArray

object (StringArray)

A list of possible string values for the filter

StringArray

JSON representation 
{
  "values": [
    string
  ]
}
Fields
values[]

string

The values of the array

LabelsEntry

JSON representation 
{
  "key": string,
  "value": string
}
Fields
key

string
value

string

DashboardAnnotations

JSON representation 
{
  "defaultResourceNames": [
    string
  ],
  "eventAnnotations": [
    {
      object (EventAnnotation)
    }
  ]
}
Fields
defaultResourceNames[]

string

Dashboard level defaults for names of logging resources to search for events. Currently only projects are supported. Each individual EventAnnotation may have its own overrides. If both this field and the per annotation field is empty, then the scoping project is used. Limit: 50 projects. For example:

“projects/some-project-id”
eventAnnotations[]

object (EventAnnotation)

List of annotation configurations for this dashboard. Each entry specifies one event type.

EventAnnotation

JSON representation 
{
  "displayName": string,
  "eventType": enum (EventType),
  "filter": string,
  "enabled": boolean,
  "resourceNames": [
    string
  ]
}
Fields
displayName

string

Solely for UI display. Should not be used programmatically.
eventType

enum (EventType)

The type of event to display.
filter

string

string filtering the events - event dependant. Example values:

"resource.labels.pod_name = 'pod-1'"
"protoPayload.authenticationInfo.principalEmail='user@example.com'"
enabled

boolean

Whether or not to show the events on the dashboard by default
resourceNames[]

string

Per annotation level override for the names of logging resources to search for events. Currently only projects are supported. If both this field and the per annotation field is empty, it will default to the host project. Limit: 50 projects. For example:

“projects/another-project-id”

Tool Annotations

Destructive Hint: ❌ | Idempotent Hint: ✅ | Read Only Hint: ✅ | Open World Hint: ❌