volcengine.tls.Rule

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Volcengine = Pulumi.Volcengine;

return await Deployment.RunAsync(() => 
{
    var foo = new Volcengine.Tls.Rule("foo", new()
    {
        TopicId = "7bfa2cdc-4f8b-4cf9-b4c9-0ed05c33349f",
        RuleName = "test",
        LogType = "minimalist_log",
        LogSample = "2018-05-22 15:35:53.850 INFO XXXX",
        InputType = 1,
        UserDefineRule = new Volcengine.Tls.Inputs.RuleUserDefineRuleArgs
        {
            EnableRawLog = false,
            TailFiles = true,
            ShardHashKey = new Volcengine.Tls.Inputs.RuleUserDefineRuleShardHashKeyArgs
            {
                HashKey = "3C",
            },
            Plugin = new Volcengine.Tls.Inputs.RuleUserDefineRulePluginArgs
            {
                Processors = new[]
                {
                    JsonSerializer.Serialize(new Dictionary<string, object?>
                    {
                        ["json"] = new Dictionary<string, object?>
                        {
                            ["field"] = "__content__",
                            ["trim_keys"] = new Dictionary<string, object?>
                            {
                                ["mode"] = "all",
                                ["chars"] = "#",
                            },
                            ["trim_values"] = new Dictionary<string, object?>
                            {
                                ["mode"] = "all",
                                ["chars"] = "#t",
                            },
                            ["allow_overwrite_keys"] = true,
                            ["allow_empty_values"] = true,
                        },
                    }),
                    JsonSerializer.Serialize(new Dictionary<string, object?>
                    {
                        ["json"] = new Dictionary<string, object?>
                        {
                            ["field"] = "__content__",
                            ["trim_keys"] = new Dictionary<string, object?>
                            {
                                ["mode"] = "all",
                                ["chars"] = "#xx",
                            },
                            ["trim_values"] = new Dictionary<string, object?>
                            {
                                ["mode"] = "all",
                                ["chars"] = "#txxxt",
                            },
                            ["allow_overwrite_keys"] = true,
                            ["allow_empty_values"] = true,
                        },
                    }),
                },
            },
            Advanced = new Volcengine.Tls.Inputs.RuleUserDefineRuleAdvancedArgs
            {
                CloseInactive = 10,
                CloseRemoved = false,
                CloseRenamed = false,
                CloseEof = false,
                CloseTimeout = 1,
            },
        },
        ContainerRule = new Volcengine.Tls.Inputs.RuleContainerRuleArgs
        {
            Stream = "all",
            ContainerNameRegex = ".*test.*",
            IncludeContainerLabelRegex = 
            {
                { "Key1", "Value12" },
                { "Key2", "Value23" },
            },
            ExcludeContainerLabelRegex = 
            {
                { "Key1", "Value12" },
                { "Key2", "Value22" },
            },
            IncludeContainerEnvRegex = 
            {
                { "Key1", "Value1" },
                { "Key2", "Value2" },
            },
            ExcludeContainerEnvRegex = 
            {
                { "Key1", "Value1" },
                { "Key2", "Value2" },
            },
            EnvTag = 
            {
                { "Key1", "Value1" },
                { "Key2", "Value2" },
            },
            KubernetesRule = new Volcengine.Tls.Inputs.RuleContainerRuleKubernetesRuleArgs
            {
                NamespaceNameRegex = ".*test.*",
                WorkloadType = "Deployment",
                WorkloadNameRegex = ".*test.*",
                IncludePodLabelRegex = 
                {
                    { "Key1", "Value1" },
                    { "Key2", "Value2" },
                },
                ExcludePodLabelRegex = 
                {
                    { "Key1", "Value1" },
                    { "Key2", "Value2" },
                },
                PodNameRegex = ".*test.*",
                LabelTag = 
                {
                    { "Key1", "Value1" },
                    { "Key2", "Value2" },
                },
                AnnotationTag = 
                {
                    { "Key1", "Value1" },
                    { "Key2", "Value2" },
                },
            },
        },
    });

});

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/tls"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"json": map[string]interface{}{
				"field": "__content__",
				"trim_keys": map[string]interface{}{
					"mode":  "all",
					"chars": "#",
				},
				"trim_values": map[string]interface{}{
					"mode":  "all",
					"chars": "#t",
				},
				"allow_overwrite_keys": true,
				"allow_empty_values":   true,
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"json": map[string]interface{}{
				"field": "__content__",
				"trim_keys": map[string]interface{}{
					"mode":  "all",
					"chars": "#xx",
				},
				"trim_values": map[string]interface{}{
					"mode":  "all",
					"chars": "#txxxt",
				},
				"allow_overwrite_keys": true,
				"allow_empty_values":   true,
			},
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		_, err = tls.NewRule(ctx, "foo", &tls.RuleArgs{
			TopicId:   pulumi.String("7bfa2cdc-4f8b-4cf9-b4c9-0ed05c33349f"),
			RuleName:  pulumi.String("test"),
			LogType:   pulumi.String("minimalist_log"),
			LogSample: pulumi.String("2018-05-22 15:35:53.850 INFO XXXX"),
			InputType: pulumi.Int(1),
			UserDefineRule: &tls.RuleUserDefineRuleArgs{
				EnableRawLog: pulumi.Bool(false),
				TailFiles:    pulumi.Bool(true),
				ShardHashKey: &tls.RuleUserDefineRuleShardHashKeyArgs{
					HashKey: pulumi.String("3C"),
				},
				Plugin: &tls.RuleUserDefineRulePluginArgs{
					Processors: pulumi.StringArray{
						pulumi.String(json0),
						pulumi.String(json1),
					},
				},
				Advanced: &tls.RuleUserDefineRuleAdvancedArgs{
					CloseInactive: pulumi.Int(10),
					CloseRemoved:  pulumi.Bool(false),
					CloseRenamed:  pulumi.Bool(false),
					CloseEof:      pulumi.Bool(false),
					CloseTimeout:  pulumi.Int(1),
				},
			},
			ContainerRule: &tls.RuleContainerRuleArgs{
				Stream:             pulumi.String("all"),
				ContainerNameRegex: pulumi.String(".*test.*"),
				IncludeContainerLabelRegex: pulumi.StringMap{
					"Key1": pulumi.String("Value12"),
					"Key2": pulumi.String("Value23"),
				},
				ExcludeContainerLabelRegex: pulumi.StringMap{
					"Key1": pulumi.String("Value12"),
					"Key2": pulumi.String("Value22"),
				},
				IncludeContainerEnvRegex: pulumi.StringMap{
					"Key1": pulumi.String("Value1"),
					"Key2": pulumi.String("Value2"),
				},
				ExcludeContainerEnvRegex: pulumi.StringMap{
					"Key1": pulumi.String("Value1"),
					"Key2": pulumi.String("Value2"),
				},
				EnvTag: pulumi.StringMap{
					"Key1": pulumi.String("Value1"),
					"Key2": pulumi.String("Value2"),
				},
				KubernetesRule: &tls.RuleContainerRuleKubernetesRuleArgs{
					NamespaceNameRegex: pulumi.String(".*test.*"),
					WorkloadType:       pulumi.String("Deployment"),
					WorkloadNameRegex:  pulumi.String(".*test.*"),
					IncludePodLabelRegex: pulumi.StringMap{
						"Key1": pulumi.String("Value1"),
						"Key2": pulumi.String("Value2"),
					},
					ExcludePodLabelRegex: pulumi.StringMap{
						"Key1": pulumi.String("Value1"),
						"Key2": pulumi.String("Value2"),
					},
					PodNameRegex: pulumi.String(".*test.*"),
					LabelTag: pulumi.StringMap{
						"Key1": pulumi.String("Value1"),
						"Key2": pulumi.String("Value2"),
					},
					AnnotationTag: pulumi.StringMap{
						"Key1": pulumi.String("Value1"),
						"Key2": pulumi.String("Value2"),
					},
				},
			},
		})
		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.volcengine.tls.Rule;
import com.pulumi.volcengine.tls.RuleArgs;
import com.pulumi.volcengine.tls.inputs.RuleUserDefineRuleArgs;
import com.pulumi.volcengine.tls.inputs.RuleUserDefineRuleShardHashKeyArgs;
import com.pulumi.volcengine.tls.inputs.RuleUserDefineRulePluginArgs;
import com.pulumi.volcengine.tls.inputs.RuleUserDefineRuleAdvancedArgs;
import com.pulumi.volcengine.tls.inputs.RuleContainerRuleArgs;
import com.pulumi.volcengine.tls.inputs.RuleContainerRuleKubernetesRuleArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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 foo = new Rule("foo", RuleArgs.builder()        
            .topicId("7bfa2cdc-4f8b-4cf9-b4c9-0ed05c33349f")
            .ruleName("test")
            .logType("minimalist_log")
            .logSample("2018-05-22 15:35:53.850 INFO XXXX")
            .inputType(1)
            .userDefineRule(RuleUserDefineRuleArgs.builder()
                .enableRawLog(false)
                .tailFiles(true)
                .shardHashKey(RuleUserDefineRuleShardHashKeyArgs.builder()
                    .hashKey("3C")
                    .build())
                .plugin(RuleUserDefineRulePluginArgs.builder()
                    .processors(                    
                        serializeJson(
                            jsonObject(
                                jsonProperty("json", jsonObject(
                                    jsonProperty("field", "__content__"),
                                    jsonProperty("trim_keys", jsonObject(
                                        jsonProperty("mode", "all"),
                                        jsonProperty("chars", "#")
                                    )),
                                    jsonProperty("trim_values", jsonObject(
                                        jsonProperty("mode", "all"),
                                        jsonProperty("chars", "#t")
                                    )),
                                    jsonProperty("allow_overwrite_keys", true),
                                    jsonProperty("allow_empty_values", true)
                                ))
                            )),
                        serializeJson(
                            jsonObject(
                                jsonProperty("json", jsonObject(
                                    jsonProperty("field", "__content__"),
                                    jsonProperty("trim_keys", jsonObject(
                                        jsonProperty("mode", "all"),
                                        jsonProperty("chars", "#xx")
                                    )),
                                    jsonProperty("trim_values", jsonObject(
                                        jsonProperty("mode", "all"),
                                        jsonProperty("chars", "#txxxt")
                                    )),
                                    jsonProperty("allow_overwrite_keys", true),
                                    jsonProperty("allow_empty_values", true)
                                ))
                            )))
                    .build())
                .advanced(RuleUserDefineRuleAdvancedArgs.builder()
                    .closeInactive(10)
                    .closeRemoved(false)
                    .closeRenamed(false)
                    .closeEof(false)
                    .closeTimeout(1)
                    .build())
                .build())
            .containerRule(RuleContainerRuleArgs.builder()
                .stream("all")
                .containerNameRegex(".*test.*")
                .includeContainerLabelRegex(Map.ofEntries(
                    Map.entry("Key1", "Value12"),
                    Map.entry("Key2", "Value23")
                ))
                .excludeContainerLabelRegex(Map.ofEntries(
                    Map.entry("Key1", "Value12"),
                    Map.entry("Key2", "Value22")
                ))
                .includeContainerEnvRegex(Map.ofEntries(
                    Map.entry("Key1", "Value1"),
                    Map.entry("Key2", "Value2")
                ))
                .excludeContainerEnvRegex(Map.ofEntries(
                    Map.entry("Key1", "Value1"),
                    Map.entry("Key2", "Value2")
                ))
                .envTag(Map.ofEntries(
                    Map.entry("Key1", "Value1"),
                    Map.entry("Key2", "Value2")
                ))
                .kubernetesRule(RuleContainerRuleKubernetesRuleArgs.builder()
                    .namespaceNameRegex(".*test.*")
                    .workloadType("Deployment")
                    .workloadNameRegex(".*test.*")
                    .includePodLabelRegex(Map.ofEntries(
                        Map.entry("Key1", "Value1"),
                        Map.entry("Key2", "Value2")
                    ))
                    .excludePodLabelRegex(Map.ofEntries(
                        Map.entry("Key1", "Value1"),
                        Map.entry("Key2", "Value2")
                    ))
                    .podNameRegex(".*test.*")
                    .labelTag(Map.ofEntries(
                        Map.entry("Key1", "Value1"),
                        Map.entry("Key2", "Value2")
                    ))
                    .annotationTag(Map.ofEntries(
                        Map.entry("Key1", "Value1"),
                        Map.entry("Key2", "Value2")
                    ))
                    .build())
                .build())
            .build());

    }
}

import pulumi
import json
import pulumi_volcengine as volcengine

foo = volcengine.tls.Rule("foo",
    topic_id="7bfa2cdc-4f8b-4cf9-b4c9-0ed05c33349f",
    rule_name="test",
    log_type="minimalist_log",
    log_sample="2018-05-22 15:35:53.850 INFO XXXX",
    input_type=1,
    user_define_rule=volcengine.tls.RuleUserDefineRuleArgs(
        enable_raw_log=False,
        tail_files=True,
        shard_hash_key=volcengine.tls.RuleUserDefineRuleShardHashKeyArgs(
            hash_key="3C",
        ),
        plugin=volcengine.tls.RuleUserDefineRulePluginArgs(
            processors=[
                json.dumps({
                    "json": {
                        "field": "__content__",
                        "trim_keys": {
                            "mode": "all",
                            "chars": "#",
                        },
                        "trim_values": {
                            "mode": "all",
                            "chars": "#t",
                        },
                        "allow_overwrite_keys": True,
                        "allow_empty_values": True,
                    },
                }),
                json.dumps({
                    "json": {
                        "field": "__content__",
                        "trim_keys": {
                            "mode": "all",
                            "chars": "#xx",
                        },
                        "trim_values": {
                            "mode": "all",
                            "chars": "#txxxt",
                        },
                        "allow_overwrite_keys": True,
                        "allow_empty_values": True,
                    },
                }),
            ],
        ),
        advanced=volcengine.tls.RuleUserDefineRuleAdvancedArgs(
            close_inactive=10,
            close_removed=False,
            close_renamed=False,
            close_eof=False,
            close_timeout=1,
        ),
    ),
    container_rule=volcengine.tls.RuleContainerRuleArgs(
        stream="all",
        container_name_regex=".*test.*",
        include_container_label_regex={
            "Key1": "Value12",
            "Key2": "Value23",
        },
        exclude_container_label_regex={
            "Key1": "Value12",
            "Key2": "Value22",
        },
        include_container_env_regex={
            "Key1": "Value1",
            "Key2": "Value2",
        },
        exclude_container_env_regex={
            "Key1": "Value1",
            "Key2": "Value2",
        },
        env_tag={
            "Key1": "Value1",
            "Key2": "Value2",
        },
        kubernetes_rule=volcengine.tls.RuleContainerRuleKubernetesRuleArgs(
            namespace_name_regex=".*test.*",
            workload_type="Deployment",
            workload_name_regex=".*test.*",
            include_pod_label_regex={
                "Key1": "Value1",
                "Key2": "Value2",
            },
            exclude_pod_label_regex={
                "Key1": "Value1",
                "Key2": "Value2",
            },
            pod_name_regex=".*test.*",
            label_tag={
                "Key1": "Value1",
                "Key2": "Value2",
            },
            annotation_tag={
                "Key1": "Value1",
                "Key2": "Value2",
            },
        ),
    ))

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

const foo = new volcengine.tls.Rule("foo", {
    topicId: "7bfa2cdc-4f8b-4cf9-b4c9-0ed05c33349f",
    ruleName: "test",
    logType: "minimalist_log",
    logSample: "2018-05-22 15:35:53.850 INFO XXXX",
    inputType: 1,
    userDefineRule: {
        enableRawLog: false,
        tailFiles: true,
        shardHashKey: {
            hashKey: "3C",
        },
        plugin: {
            processors: [
                JSON.stringify({
                    json: {
                        field: "__content__",
                        trim_keys: {
                            mode: "all",
                            chars: "#",
                        },
                        trim_values: {
                            mode: "all",
                            chars: "#t",
                        },
                        allow_overwrite_keys: true,
                        allow_empty_values: true,
                    },
                }),
                JSON.stringify({
                    json: {
                        field: "__content__",
                        trim_keys: {
                            mode: "all",
                            chars: "#xx",
                        },
                        trim_values: {
                            mode: "all",
                            chars: "#txxxt",
                        },
                        allow_overwrite_keys: true,
                        allow_empty_values: true,
                    },
                }),
            ],
        },
        advanced: {
            closeInactive: 10,
            closeRemoved: false,
            closeRenamed: false,
            closeEof: false,
            closeTimeout: 1,
        },
    },
    containerRule: {
        stream: "all",
        containerNameRegex: ".*test.*",
        includeContainerLabelRegex: {
            Key1: "Value12",
            Key2: "Value23",
        },
        excludeContainerLabelRegex: {
            Key1: "Value12",
            Key2: "Value22",
        },
        includeContainerEnvRegex: {
            Key1: "Value1",
            Key2: "Value2",
        },
        excludeContainerEnvRegex: {
            Key1: "Value1",
            Key2: "Value2",
        },
        envTag: {
            Key1: "Value1",
            Key2: "Value2",
        },
        kubernetesRule: {
            namespaceNameRegex: ".*test.*",
            workloadType: "Deployment",
            workloadNameRegex: ".*test.*",
            includePodLabelRegex: {
                Key1: "Value1",
                Key2: "Value2",
            },
            excludePodLabelRegex: {
                Key1: "Value1",
                Key2: "Value2",
            },
            podNameRegex: ".*test.*",
            labelTag: {
                Key1: "Value1",
                Key2: "Value2",
            },
            annotationTag: {
                Key1: "Value1",
                Key2: "Value2",
            },
        },
    },
});

resources:
  foo:
    type: volcengine:tls:Rule
    properties:
      topicId: 7bfa2cdc-4f8b-4cf9-b4c9-0ed05c33349f
      ruleName: test
      # paths = ["/data/nginx/log/xx.log"]
      logType: minimalist_log
      logSample: 2018-05-22 15:35:53.850 INFO XXXX
      inputType: 1
      userDefineRule:
        enableRawLog: false
        tailFiles: true
        shardHashKey:
          hashKey: 3C
        plugin:
          processors:
            - fn::toJSON:
                json:
                  field: __content__
                  trim_keys:
                    mode: all
                    chars: '#'
                  trim_values:
                    mode: all
                    chars: '#t'
                  allow_overwrite_keys: true
                  allow_empty_values: true
            - fn::toJSON:
                json:
                  field: __content__
                  trim_keys:
                    mode: all
                    chars: '#xx'
                  trim_values:
                    mode: all
                    chars: '#txxxt'
                  allow_overwrite_keys: true
                  allow_empty_values: true
        advanced:
          closeInactive: 10
          closeRemoved: false
          closeRenamed: false
          closeEof: false
          closeTimeout: 1
      containerRule:
        stream: all
        containerNameRegex: .*test.*
        includeContainerLabelRegex:
          Key1: Value12
          Key2: Value23
        excludeContainerLabelRegex:
          Key1: Value12
          Key2: Value22
        includeContainerEnvRegex:
          Key1: Value1
          Key2: Value2
        excludeContainerEnvRegex:
          Key1: Value1
          Key2: Value2
        envTag:
          Key1: Value1
          Key2: Value2
        kubernetesRule:
          namespaceNameRegex: .*test.*
          workloadType: Deployment
          workloadNameRegex: .*test.*
          includePodLabelRegex:
            Key1: Value1
            Key2: Value2
          excludePodLabelRegex:
            Key1: Value1
            Key2: Value2
          podNameRegex: .*test.*
          labelTag:
            Key1: Value1
            Key2: Value2
          annotationTag:
            Key1: Value1
            Key2: Value2