rootly.DashboardPanel

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Rootly = Pulumi.Rootly;

return await Deployment.RunAsync(() => 
{
    var overview = new Rootly.Dashboard("overview");

    var incidentsBySeverity = new Rootly.DashboardPanel("incidentsBySeverity", new()
    {
        DashboardId = rootly_dashboard.Foo.Id,
        Params = new Rootly.Inputs.DashboardPanelParamsArgs
        {
            Display = "line_chart",
            Datasets = new[]
            {
                new Rootly.Inputs.DashboardPanelParamsDatasetArgs
                {
                    Collection = "incidents",
                    Filters = new[]
                    {
                        new Rootly.Inputs.DashboardPanelParamsDatasetFilterArgs
                        {
                            Operation = "and",
                            Rules = new[]
                            {
                                new Rootly.Inputs.DashboardPanelParamsDatasetFilterRuleArgs
                                {
                                    Operation = "and",
                                    Condition = "=",
                                    Key = "status",
                                    Value = "started",
                                },
                            },
                        },
                    },
                    GroupBy = "severity",
                    Aggregate = new Rootly.Inputs.DashboardPanelParamsDatasetAggregateArgs
                    {
                        Cumulative = false,
                        Key = "results",
                        Operation = "count",
                    },
                },
            },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-rootly/sdk/go/rootly"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rootly.NewDashboard(ctx, "overview", nil)
		if err != nil {
			return err
		}
		_, err = rootly.NewDashboardPanel(ctx, "incidentsBySeverity", &rootly.DashboardPanelArgs{
			DashboardId: pulumi.Any(rootly_dashboard.Foo.Id),
			Params: &rootly.DashboardPanelParamsArgs{
				Display: pulumi.String("line_chart"),
				Datasets: rootly.DashboardPanelParamsDatasetArray{
					&rootly.DashboardPanelParamsDatasetArgs{
						Collection: pulumi.String("incidents"),
						Filters: rootly.DashboardPanelParamsDatasetFilterArray{
							&rootly.DashboardPanelParamsDatasetFilterArgs{
								Operation: pulumi.String("and"),
								Rules: rootly.DashboardPanelParamsDatasetFilterRuleArray{
									&rootly.DashboardPanelParamsDatasetFilterRuleArgs{
										Operation: pulumi.String("and"),
										Condition: pulumi.String("="),
										Key:       pulumi.String("status"),
										Value:     pulumi.String("started"),
									},
								},
							},
						},
						GroupBy: pulumi.String("severity"),
						Aggregate: &rootly.DashboardPanelParamsDatasetAggregateArgs{
							Cumulative: pulumi.Bool(false),
							Key:        pulumi.String("results"),
							Operation:  pulumi.String("count"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.rootly.Dashboard;
import com.pulumi.rootly.DashboardPanel;
import com.pulumi.rootly.DashboardPanelArgs;
import com.pulumi.rootly.inputs.DashboardPanelParamsArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var overview = new Dashboard("overview");

        var incidentsBySeverity = new DashboardPanel("incidentsBySeverity", DashboardPanelArgs.builder()        
            .dashboardId(rootly_dashboard.foo().id())
            .params(DashboardPanelParamsArgs.builder()
                .display("line_chart")
                .datasets(DashboardPanelParamsDatasetArgs.builder()
                    .collection("incidents")
                    .filters(DashboardPanelParamsDatasetFilterArgs.builder()
                        .operation("and")
                        .rules(DashboardPanelParamsDatasetFilterRuleArgs.builder()
                            .operation("and")
                            .condition("=")
                            .key("status")
                            .value("started")
                            .build())
                        .build())
                    .groupBy("severity")
                    .aggregate(DashboardPanelParamsDatasetAggregateArgs.builder()
                        .cumulative(false)
                        .key("results")
                        .operation("count")
                        .build())
                    .build())
                .build())
            .build());

    }
}

import pulumi
import pulumi_rootly as rootly

overview = rootly.Dashboard("overview")
incidents_by_severity = rootly.DashboardPanel("incidentsBySeverity",
    dashboard_id=rootly_dashboard["foo"]["id"],
    params=rootly.DashboardPanelParamsArgs(
        display="line_chart",
        datasets=[rootly.DashboardPanelParamsDatasetArgs(
            collection="incidents",
            filters=[rootly.DashboardPanelParamsDatasetFilterArgs(
                operation="and",
                rules=[rootly.DashboardPanelParamsDatasetFilterRuleArgs(
                    operation="and",
                    condition="=",
                    key="status",
                    value="started",
                )],
            )],
            group_by="severity",
            aggregate=rootly.DashboardPanelParamsDatasetAggregateArgs(
                cumulative=False,
                key="results",
                operation="count",
            ),
        )],
    ))

import * as pulumi from "@pulumi/pulumi";
import * as rootly from "@pulumi/rootly";

const overview = new rootly.Dashboard("overview", {});
const incidentsBySeverity = new rootly.DashboardPanel("incidentsBySeverity", {
    dashboardId: rootly_dashboard.foo.id,
    params: {
        display: "line_chart",
        datasets: [{
            collection: "incidents",
            filters: [{
                operation: "and",
                rules: [{
                    operation: "and",
                    condition: "=",
                    key: "status",
                    value: "started",
                }],
            }],
            groupBy: "severity",
            aggregate: {
                cumulative: false,
                key: "results",
                operation: "count",
            },
        }],
    },
});

resources:
  overview:
    type: rootly:Dashboard
  incidentsBySeverity:
    type: rootly:DashboardPanel
    properties:
      dashboardId: ${rootly_dashboard.foo.id}
      params:
        display: line_chart
        datasets:
          - collection: incidents
            filters:
              - operation: and
                rules:
                  - operation: and
                    condition: =
                    key: status
                    value: started
            groupBy: severity
            aggregate:
              cumulative: false
              key: results
              operation: count