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.16 published on Monday, Apr 14, 2025 by coralogix
coralogix/terraform-provider-coralogix

coralogix.RecordingRulesGroupsSet

Explore with Pulumi AI

coralogix 2.0.16 published on Monday, Apr 14, 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)",
            },
        ],
    },
]});
Copy
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)",
            },
        ],
    },
])
Copy
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
	})
}
Copy
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)",
                    },
                },
            },
        },
    });

});
Copy
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());

    }
}
Copy
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)
Copy

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 This property is required. 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 This property is required. 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 This property is required. 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 This property is required. 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 This property is required. String
The unique name of the resource.
args This property is required. 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",
});
Copy
example, err := coralogix.NewRecordingRulesGroupsSet(ctx, "recordingRulesGroupsSetResource", &coralogix.RecordingRulesGroupsSetArgs{
Groups: .RecordingRulesGroupsSetGroupArray{
&.RecordingRulesGroupsSetGroupArgs{
Name: pulumi.String("string"),
Rules: .RecordingRulesGroupsSetGroupRuleArray{
&.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"),
})
Copy
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());
Copy
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")
Copy
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",
});
Copy
type: coralogix:RecordingRulesGroupsSet
properties:
    groups:
        - interval: 0
          limit: 0
          name: string
          rules:
            - expr: string
              labels:
                string: string
              record: string
    name: string
    yamlContent: string
Copy

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 This property is required.
The unique name of the resulting resource.
id This property is required.
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 This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
name This property is required.
The unique name of the resulting resource.
id This property is required.
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 This property is required.
The unique name of the resulting resource.
id This property is required.
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 This property is required.
The unique name of the resulting resource.
id This property is required.
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 This property is required. string
The (unique) rule-group name.
Rules This property is required. 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 This property is required. string
The (unique) rule-group name.
Rules This property is required. []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 This property is required. String
The (unique) rule-group name.
rules This property is required. 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 This property is required. string
The (unique) rule-group name.
rules This property is required. 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 This property is required. str
The (unique) rule-group name.
rules This property is required. 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 This property is required. String
The (unique) rule-group name.
rules This property is required. 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 This property is required. 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 This property is required. 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 This property is required. 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 This property is required. 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 This property is required. 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 This property is required. 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 This property is required. 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 This property is required. 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 This property is required. 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 This property is required. 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 This property is required. 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 This property is required. 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 2.0.16 published on Monday, Apr 14, 2025 by coralogix
coralogix/terraform-provider-coralogix