Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Coralogix Provider
  3. API Docs
  4. RecordingRulesGroupsSet
coralogix 2.0.17 published on Tuesday, Apr 22, 2025 by coralogix
coralogix/terraform-provider-coralogix

coralogix.RecordingRulesGroupsSet

Explore with Pulumi AI

coralogix logo
coralogix 2.0.17 published on Tuesday, Apr 22, 2025 by coralogix
coralogix/terraform-provider-coralogix

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as coralogix from "@pulumi/coralogix";
import * as fs from "fs";

const recordingRulesGroup = new coralogix.RecordingRulesGroupsSet("recordingRulesGroup", {yamlContent: fs.readFileSync("./rule-group-set.yaml", "utf8")});
const recordingRulesGroupsSetExplicit = new coralogix.RecordingRulesGroupsSet("recordingRulesGroupsSetExplicit", {groups: [
    {
        name: "Foo",
        interval: 180,
        limit: 100,
        rules: [
            {
                record: "ts3db_live_ingester_write_latency:3m",
                expr: "sum(rate(ts3db_live_ingester_write_latency_seconds_count{CX_LEVEL=\"staging\",pod=~\"ts3db-live-ingester.*\"}[2m])) by (pod)",
            },
            {
                record: "job:http_requests_total:sum",
                expr: "sum(rate(http_requests_total[5m])) by (job)",
            },
        ],
    },
    {
        name: "Bar",
        interval: 180,
        limit: 100,
        rules: [
            {
                record: "ts3db_live_ingester_write_latency:3m",
                expr: "sum(rate(ts3db_live_ingester_write_latency_seconds_count{CX_LEVEL=\"staging\",pod=~\"ts3db-live-ingester.*\"}[2m])) by (pod)",
            },
            {
                record: "job:http_requests_total:sum",
                expr: "sum(rate(http_requests_total[5m])) by (job)",
            },
        ],
    },
]});

    import pulumi
import pulumi_coralogix as coralogix

recording_rules_group = coralogix.RecordingRulesGroupsSet("recordingRulesGroup", yaml_content=(lambda path: open(path).read())("./rule-group-set.yaml"))
recording_rules_groups_set_explicit = coralogix.RecordingRulesGroupsSet("recordingRulesGroupsSetExplicit", groups=[
    {
        "name": "Foo",
        "interval": 180,
        "limit": 100,
        "rules": [
            {
                "record": "ts3db_live_ingester_write_latency:3m",
                "expr": "sum(rate(ts3db_live_ingester_write_latency_seconds_count{CX_LEVEL=\"staging\",pod=~\"ts3db-live-ingester.*\"}[2m])) by (pod)",
            },
            {
                "record": "job:http_requests_total:sum",
                "expr": "sum(rate(http_requests_total[5m])) by (job)",
            },
        ],
    },
    {
        "name": "Bar",
        "interval": 180,
        "limit": 100,
        "rules": [
            {
                "record": "ts3db_live_ingester_write_latency:3m",
                "expr": "sum(rate(ts3db_live_ingester_write_latency_seconds_count{CX_LEVEL=\"staging\",pod=~\"ts3db-live-ingester.*\"}[2m])) by (pod)",
            },
            {
                "record": "job:http_requests_total:sum",
                "expr": "sum(rate(http_requests_total[5m])) by (job)",
            },
        ],
    },
])

    package main

import (
	"os"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/coralogix/v2/coralogix"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func readFileOrPanic(path string) pulumi.StringPtrInput {
	data, err := os.ReadFile(path)
	if err != nil {
		panic(err.Error())
	}
	return pulumi.String(string(data))
}

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := coralogix.NewRecordingRulesGroupsSet(ctx, "recordingRulesGroup", &coralogix.RecordingRulesGroupsSetArgs{
			YamlContent: pulumi.String(readFileOrPanic("./rule-group-set.yaml")),
		})
		if err != nil {
			return err
		}
		_, err = coralogix.NewRecordingRulesGroupsSet(ctx, "recordingRulesGroupsSetExplicit", &coralogix.RecordingRulesGroupsSetArgs{
			Groups: coralogix.RecordingRulesGroupsSetGroupArray{
				&coralogix.RecordingRulesGroupsSetGroupArgs{
					Name:     pulumi.String("Foo"),
					Interval: pulumi.Float64(180),
					Limit:    pulumi.Float64(100),
					Rules: coralogix.RecordingRulesGroupsSetGroupRuleArray{
						&coralogix.RecordingRulesGroupsSetGroupRuleArgs{
							Record: pulumi.String("ts3db_live_ingester_write_latency:3m"),
							Expr:   pulumi.String("sum(rate(ts3db_live_ingester_write_latency_seconds_count{CX_LEVEL=\"staging\",pod=~\"ts3db-live-ingester.*\"}[2m])) by (pod)"),
						},
						&coralogix.RecordingRulesGroupsSetGroupRuleArgs{
							Record: pulumi.String("job:http_requests_total:sum"),
							Expr:   pulumi.String("sum(rate(http_requests_total[5m])) by (job)"),
						},
					},
				},
				&coralogix.RecordingRulesGroupsSetGroupArgs{
					Name:     pulumi.String("Bar"),
					Interval: pulumi.Float64(180),
					Limit:    pulumi.Float64(100),
					Rules: coralogix.RecordingRulesGroupsSetGroupRuleArray{
						&coralogix.RecordingRulesGroupsSetGroupRuleArgs{
							Record: pulumi.String("ts3db_live_ingester_write_latency:3m"),
							Expr:   pulumi.String("sum(rate(ts3db_live_ingester_write_latency_seconds_count{CX_LEVEL=\"staging\",pod=~\"ts3db-live-ingester.*\"}[2m])) by (pod)"),
						},
						&coralogix.RecordingRulesGroupsSetGroupRuleArgs{
							Record: pulumi.String("job:http_requests_total:sum"),
							Expr:   pulumi.String("sum(rate(http_requests_total[5m])) by (job)"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.IO;
using System.Linq;
using Pulumi;
using Coralogix = Pulumi.Coralogix;

return await Deployment.RunAsync(() => 
{
    var recordingRulesGroup = new Coralogix.RecordingRulesGroupsSet("recordingRulesGroup", new()
    {
        YamlContent = File.ReadAllText("./rule-group-set.yaml"),
    });

    var recordingRulesGroupsSetExplicit = new Coralogix.RecordingRulesGroupsSet("recordingRulesGroupsSetExplicit", new()
    {
        Groups = new[]
        {
            new Coralogix.Inputs.RecordingRulesGroupsSetGroupArgs
            {
                Name = "Foo",
                Interval = 180,
                Limit = 100,
                Rules = new[]
                {
                    new Coralogix.Inputs.RecordingRulesGroupsSetGroupRuleArgs
                    {
                        Record = "ts3db_live_ingester_write_latency:3m",
                        Expr = "sum(rate(ts3db_live_ingester_write_latency_seconds_count{CX_LEVEL=\"staging\",pod=~\"ts3db-live-ingester.*\"}[2m])) by (pod)",
                    },
                    new Coralogix.Inputs.RecordingRulesGroupsSetGroupRuleArgs
                    {
                        Record = "job:http_requests_total:sum",
                        Expr = "sum(rate(http_requests_total[5m])) by (job)",
                    },
                },
            },
            new Coralogix.Inputs.RecordingRulesGroupsSetGroupArgs
            {
                Name = "Bar",
                Interval = 180,
                Limit = 100,
                Rules = new[]
                {
                    new Coralogix.Inputs.RecordingRulesGroupsSetGroupRuleArgs
                    {
                        Record = "ts3db_live_ingester_write_latency:3m",
                        Expr = "sum(rate(ts3db_live_ingester_write_latency_seconds_count{CX_LEVEL=\"staging\",pod=~\"ts3db-live-ingester.*\"}[2m])) by (pod)",
                    },
                    new Coralogix.Inputs.RecordingRulesGroupsSetGroupRuleArgs
                    {
                        Record = "job:http_requests_total:sum",
                        Expr = "sum(rate(http_requests_total[5m])) by (job)",
                    },
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.coralogix.RecordingRulesGroupsSet;
import com.pulumi.coralogix.RecordingRulesGroupsSetArgs;
import com.pulumi.coralogix.inputs.RecordingRulesGroupsSetGroupArgs;
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 recordingRulesGroup = new RecordingRulesGroupsSet("recordingRulesGroup", RecordingRulesGroupsSetArgs.builder()
            .yamlContent(Files.readString(Paths.get("./rule-group-set.yaml")))
            .build());

        var recordingRulesGroupsSetExplicit = new RecordingRulesGroupsSet("recordingRulesGroupsSetExplicit", RecordingRulesGroupsSetArgs.builder()
            .groups(            
                RecordingRulesGroupsSetGroupArgs.builder()
                    .name("Foo")
                    .interval(180)
                    .limit(100)
                    .rules(                    
                        RecordingRulesGroupsSetGroupRuleArgs.builder()
                            .record("ts3db_live_ingester_write_latency:3m")
                            .expr("sum(rate(ts3db_live_ingester_write_latency_seconds_count{CX_LEVEL=\"staging\",pod=~\"ts3db-live-ingester.*\"}[2m])) by (pod)")
                            .build(),
                        RecordingRulesGroupsSetGroupRuleArgs.builder()
                            .record("job:http_requests_total:sum")
                            .expr("sum(rate(http_requests_total[5m])) by (job)")
                            .build())
                    .build(),
                RecordingRulesGroupsSetGroupArgs.builder()
                    .name("Bar")
                    .interval(180)
                    .limit(100)
                    .rules(                    
                        RecordingRulesGroupsSetGroupRuleArgs.builder()
                            .record("ts3db_live_ingester_write_latency:3m")
                            .expr("sum(rate(ts3db_live_ingester_write_latency_seconds_count{CX_LEVEL=\"staging\",pod=~\"ts3db-live-ingester.*\"}[2m])) by (pod)")
                            .build(),
                        RecordingRulesGroupsSetGroupRuleArgs.builder()
                            .record("job:http_requests_total:sum")
                            .expr("sum(rate(http_requests_total[5m])) by (job)")
                            .build())
                    .build())
            .build());

    }
}

    resources:
  recordingRulesGroup:
    type: coralogix:RecordingRulesGroupsSet
    properties:
      yamlContent:
        fn::readFile: ./rule-group-set.yaml
  recordingRulesGroupsSetExplicit:
    type: coralogix:RecordingRulesGroupsSet
    properties:
      groups:
        - name: Foo
          interval: 180
          limit: 100
          rules:
            - record: ts3db_live_ingester_write_latency:3m
              expr: sum(rate(ts3db_live_ingester_write_latency_seconds_count{CX_LEVEL="staging",pod=~"ts3db-live-ingester.*"}[2m])) by (pod)
            - record: job:http_requests_total:sum
              expr: sum(rate(http_requests_total[5m])) by (job)
        - name: Bar
          interval: 180
          limit: 100
          rules:
            - record: ts3db_live_ingester_write_latency:3m
              expr: sum(rate(ts3db_live_ingester_write_latency_seconds_count{CX_LEVEL="staging",pod=~"ts3db-live-ingester.*"}[2m])) by (pod)
            - record: job:http_requests_total:sum
              expr: sum(rate(http_requests_total[5m])) by (job)

    Create RecordingRulesGroupsSet Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new RecordingRulesGroupsSet(name: string, args?: RecordingRulesGroupsSetArgs, opts?: CustomResourceOptions);
    @overload
def RecordingRulesGroupsSet(resource_name: str,
                            args: Optional[RecordingRulesGroupsSetArgs] = None,
                            opts: Optional[ResourceOptions] = None)

@overload
def RecordingRulesGroupsSet(resource_name: str,
                            opts: Optional[ResourceOptions] = None,
                            groups: Optional[Sequence[RecordingRulesGroupsSetGroupArgs]] = None,
                            name: Optional[str] = None,
                            yaml_content: Optional[str] = None)
    func NewRecordingRulesGroupsSet(ctx *Context, name string, args *RecordingRulesGroupsSetArgs, opts ...ResourceOption) (*RecordingRulesGroupsSet, error)
    public RecordingRulesGroupsSet(string name, RecordingRulesGroupsSetArgs? args = null, CustomResourceOptions? opts = null)
    public RecordingRulesGroupsSet(String name, RecordingRulesGroupsSetArgs args)
public RecordingRulesGroupsSet(String name, RecordingRulesGroupsSetArgs args, CustomResourceOptions options)

    type: coralogix:RecordingRulesGroupsSet
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args RecordingRulesGroupsSetArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args RecordingRulesGroupsSetArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args RecordingRulesGroupsSetArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args RecordingRulesGroupsSetArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args RecordingRulesGroupsSetArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var recordingRulesGroupsSetResource = new Coralogix.RecordingRulesGroupsSet("recordingRulesGroupsSetResource", new()
{
    Groups = new[]
    {
        new Coralogix.Inputs.RecordingRulesGroupsSetGroupArgs
        {
            Name = "string",
            Rules = new[]
            {
                new Coralogix.Inputs.RecordingRulesGroupsSetGroupRuleArgs
                {
                    Expr = "string",
                    Record = "string",
                    Labels = 
                    {
                        { "string", "string" },
                    },
                },
            },
            Interval = 0,
            Limit = 0,
        },
    },
    Name = "string",
    YamlContent = "string",
});

    example, err := coralogix.NewRecordingRulesGroupsSet(ctx, "recordingRulesGroupsSetResource", &coralogix.RecordingRulesGroupsSetArgs{
	Groups: coralogix.RecordingRulesGroupsSetGroupArray{
		&coralogix.RecordingRulesGroupsSetGroupArgs{
			Name: pulumi.String("string"),
			Rules: coralogix.RecordingRulesGroupsSetGroupRuleArray{
				&coralogix.RecordingRulesGroupsSetGroupRuleArgs{
					Expr:   pulumi.String("string"),
					Record: pulumi.String("string"),
					Labels: pulumi.StringMap{
						"string": pulumi.String("string"),
					},
				},
			},
			Interval: pulumi.Float64(0),
			Limit:    pulumi.Float64(0),
		},
	},
	Name:        pulumi.String("string"),
	YamlContent: pulumi.String("string"),
})

    var recordingRulesGroupsSetResource = new RecordingRulesGroupsSet("recordingRulesGroupsSetResource", RecordingRulesGroupsSetArgs.builder()
    .groups(RecordingRulesGroupsSetGroupArgs.builder()
        .name("string")
        .rules(RecordingRulesGroupsSetGroupRuleArgs.builder()
            .expr("string")
            .record("string")
            .labels(Map.of("string", "string"))
            .build())
        .interval(0)
        .limit(0)
        .build())
    .name("string")
    .yamlContent("string")
    .build());

    recording_rules_groups_set_resource = coralogix.RecordingRulesGroupsSet("recordingRulesGroupsSetResource",
    groups=[{
        "name": "string",
        "rules": [{
            "expr": "string",
            "record": "string",
            "labels": {
                "string": "string",
            },
        }],
        "interval": 0,
        "limit": 0,
    }],
    name="string",
    yaml_content="string")

    const recordingRulesGroupsSetResource = new coralogix.RecordingRulesGroupsSet("recordingRulesGroupsSetResource", {
    groups: [{
        name: "string",
        rules: [{
            expr: "string",
            record: "string",
            labels: {
                string: "string",
            },
        }],
        interval: 0,
        limit: 0,
    }],
    name: "string",
    yamlContent: "string",
});

    type: coralogix:RecordingRulesGroupsSet
properties:
    groups:
        - interval: 0
          limit: 0
          name: string
          rules:
            - expr: string
              labels:
                string: string
              record: string
    name: string
    yamlContent: string

    RecordingRulesGroupsSet Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The RecordingRulesGroupsSet resource accepts the following input properties:

    Groups List<RecordingRulesGroupsSetGroup>
    Name string
    The name of the rule group. Overrides the name specified in the YAML if provided.
    YamlContent string
    YAML specification of rules. Cannot be used together with groups.
    Groups []RecordingRulesGroupsSetGroupArgs
    Name string
    The name of the rule group. Overrides the name specified in the YAML if provided.
    YamlContent string
    YAML specification of rules. Cannot be used together with groups.
    groups List<RecordingRulesGroupsSetGroup>
    name String
    The name of the rule group. Overrides the name specified in the YAML if provided.
    yamlContent String
    YAML specification of rules. Cannot be used together with groups.
    groups RecordingRulesGroupsSetGroup[]
    name string
    The name of the rule group. Overrides the name specified in the YAML if provided.
    yamlContent string
    YAML specification of rules. Cannot be used together with groups.
    groups Sequence[RecordingRulesGroupsSetGroupArgs]
    name str
    The name of the rule group. Overrides the name specified in the YAML if provided.
    yaml_content str
    YAML specification of rules. Cannot be used together with groups.
    groups List<Property Map>
    name String
    The name of the rule group. Overrides the name specified in the YAML if provided.
    yamlContent String
    YAML specification of rules. Cannot be used together with groups.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the RecordingRulesGroupsSet resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing RecordingRulesGroupsSet Resource

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

    public static get(name: string, id: Input<ID>, state?: RecordingRulesGroupsSetState, opts?: CustomResourceOptions): RecordingRulesGroupsSet
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        groups: Optional[Sequence[RecordingRulesGroupsSetGroupArgs]] = None,
        name: Optional[str] = None,
        yaml_content: Optional[str] = None) -> RecordingRulesGroupsSet
    func GetRecordingRulesGroupsSet(ctx *Context, name string, id IDInput, state *RecordingRulesGroupsSetState, opts ...ResourceOption) (*RecordingRulesGroupsSet, error)
    public static RecordingRulesGroupsSet Get(string name, Input<string> id, RecordingRulesGroupsSetState? state, CustomResourceOptions? opts = null)
    public static RecordingRulesGroupsSet get(String name, Output<String> id, RecordingRulesGroupsSetState state, CustomResourceOptions options)
    resources:  _:    type: coralogix:RecordingRulesGroupsSet    get:      id: ${id}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Groups List<RecordingRulesGroupsSetGroup>
    Name string
    The name of the rule group. Overrides the name specified in the YAML if provided.
    YamlContent string
    YAML specification of rules. Cannot be used together with groups.
    Groups []RecordingRulesGroupsSetGroupArgs
    Name string
    The name of the rule group. Overrides the name specified in the YAML if provided.
    YamlContent string
    YAML specification of rules. Cannot be used together with groups.
    groups List<RecordingRulesGroupsSetGroup>
    name String
    The name of the rule group. Overrides the name specified in the YAML if provided.
    yamlContent String
    YAML specification of rules. Cannot be used together with groups.
    groups RecordingRulesGroupsSetGroup[]
    name string
    The name of the rule group. Overrides the name specified in the YAML if provided.
    yamlContent string
    YAML specification of rules. Cannot be used together with groups.
    groups Sequence[RecordingRulesGroupsSetGroupArgs]
    name str
    The name of the rule group. Overrides the name specified in the YAML if provided.
    yaml_content str
    YAML specification of rules. Cannot be used together with groups.
    groups List<Property Map>
    name String
    The name of the rule group. Overrides the name specified in the YAML if provided.
    yamlContent String
    YAML specification of rules. Cannot be used together with groups.

    Supporting Types

    RecordingRulesGroupsSetGroup, RecordingRulesGroupsSetGroupArgs

    Name string
    The (unique) rule-group name.
    Rules List<RecordingRulesGroupsSetGroupRule>
    Interval double
    How often rules in the group are evaluated (in seconds). Default is 60 seconds.
    Limit double
    Limits the number of alerts an alerting rule and series a recording-rule can produce. 0 is no limit.
    Name string
    The (unique) rule-group name.
    Rules []RecordingRulesGroupsSetGroupRule
    Interval float64
    How often rules in the group are evaluated (in seconds). Default is 60 seconds.
    Limit float64
    Limits the number of alerts an alerting rule and series a recording-rule can produce. 0 is no limit.
    name String
    The (unique) rule-group name.
    rules List<RecordingRulesGroupsSetGroupRule>
    interval Double
    How often rules in the group are evaluated (in seconds). Default is 60 seconds.
    limit Double
    Limits the number of alerts an alerting rule and series a recording-rule can produce. 0 is no limit.
    name string
    The (unique) rule-group name.
    rules RecordingRulesGroupsSetGroupRule[]
    interval number
    How often rules in the group are evaluated (in seconds). Default is 60 seconds.
    limit number
    Limits the number of alerts an alerting rule and series a recording-rule can produce. 0 is no limit.
    name str
    The (unique) rule-group name.
    rules Sequence[RecordingRulesGroupsSetGroupRule]
    interval float
    How often rules in the group are evaluated (in seconds). Default is 60 seconds.
    limit float
    Limits the number of alerts an alerting rule and series a recording-rule can produce. 0 is no limit.
    name String
    The (unique) rule-group name.
    rules List<Property Map>
    interval Number
    How often rules in the group are evaluated (in seconds). Default is 60 seconds.
    limit Number
    Limits the number of alerts an alerting rule and series a recording-rule can produce. 0 is no limit.

    RecordingRulesGroupsSetGroupRule, RecordingRulesGroupsSetGroupRuleArgs

    Expr string
    The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and the result recorded as a new set of time series with the metric name as given by 'record'.
    Record string
    The name of the time series to output to. Must be a valid metric name.
    Labels Dictionary<string, string>
    Labels to add or overwrite before storing the result.
    Expr string
    The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and the result recorded as a new set of time series with the metric name as given by 'record'.
    Record string
    The name of the time series to output to. Must be a valid metric name.
    Labels map[string]string
    Labels to add or overwrite before storing the result.
    expr String
    The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and the result recorded as a new set of time series with the metric name as given by 'record'.
    record String
    The name of the time series to output to. Must be a valid metric name.
    labels Map<String,String>
    Labels to add or overwrite before storing the result.
    expr string
    The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and the result recorded as a new set of time series with the metric name as given by 'record'.
    record string
    The name of the time series to output to. Must be a valid metric name.
    labels {[key: string]: string}
    Labels to add or overwrite before storing the result.
    expr str
    The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and the result recorded as a new set of time series with the metric name as given by 'record'.
    record str
    The name of the time series to output to. Must be a valid metric name.
    labels Mapping[str, str]
    Labels to add or overwrite before storing the result.
    expr String
    The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and the result recorded as a new set of time series with the metric name as given by 'record'.
    record String
    The name of the time series to output to. Must be a valid metric name.
    labels Map<String>
    Labels to add or overwrite before storing the result.

    Package Details

    Repository
    coralogix coralogix/terraform-provider-coralogix
    License
    Notes
    This Pulumi package is based on the coralogix Terraform Provider.
    coralogix logo
    coralogix 2.0.17 published on Tuesday, Apr 22, 2025 by coralogix
    coralogix/terraform-provider-coralogix