com.pulumi.azurenative.logz.kotlin.inputs.LogRulesArgs.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of pulumi-azure-native-kotlin Show documentation
Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.
There is a newer version: 2.82.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.azurenative.logz.kotlin.inputs

import com.pulumi.azurenative.logz.inputs.LogRulesArgs.builder
import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.Boolean
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.jvm.JvmName

/**
 * Set of rules for sending logs for the Monitor resource.
 * @property filteringTags List of filtering tags to be used for capturing logs. This only takes effect if SendActivityLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
 * @property sendAadLogs Flag specifying if AAD logs should be sent for the Monitor resource.
 * @property sendActivityLogs Flag specifying if activity logs from Azure resources should be sent for the Monitor resource.
 * @property sendSubscriptionLogs Flag specifying if subscription logs should be sent for the Monitor resource.
 */
public data class LogRulesArgs(
    public val filteringTags: Output>? = null,
    public val sendAadLogs: Output? = null,
    public val sendActivityLogs: Output? = null,
    public val sendSubscriptionLogs: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.azurenative.logz.inputs.LogRulesArgs =
        com.pulumi.azurenative.logz.inputs.LogRulesArgs.builder()
            .filteringTags(
                filteringTags?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .sendAadLogs(sendAadLogs?.applyValue({ args0 -> args0 }))
            .sendActivityLogs(sendActivityLogs?.applyValue({ args0 -> args0 }))
            .sendSubscriptionLogs(sendSubscriptionLogs?.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [LogRulesArgs].
 */
@PulumiTagMarker
public class LogRulesArgsBuilder internal constructor() {
    private var filteringTags: Output>? = null

    private var sendAadLogs: Output? = null

    private var sendActivityLogs: Output? = null

    private var sendSubscriptionLogs: Output? = null

    /**
     * @param value List of filtering tags to be used for capturing logs. This only takes effect if SendActivityLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
     */
    @JvmName("pbiuhnenrpcdmnuw")
    public suspend fun filteringTags(`value`: Output>) {
        this.filteringTags = value
    }

    @JvmName("xdvuirryemradswp")
    public suspend fun filteringTags(vararg values: Output) {
        this.filteringTags = Output.all(values.asList())
    }

    /**
     * @param values List of filtering tags to be used for capturing logs. This only takes effect if SendActivityLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
     */
    @JvmName("hvowomevmuifiomy")
    public suspend fun filteringTags(values: List>) {
        this.filteringTags = Output.all(values)
    }

    /**
     * @param value Flag specifying if AAD logs should be sent for the Monitor resource.
     */
    @JvmName("yrcmojjmkfwbbgpu")
    public suspend fun sendAadLogs(`value`: Output) {
        this.sendAadLogs = value
    }

    /**
     * @param value Flag specifying if activity logs from Azure resources should be sent for the Monitor resource.
     */
    @JvmName("ygffglaylgdmxdth")
    public suspend fun sendActivityLogs(`value`: Output) {
        this.sendActivityLogs = value
    }

    /**
     * @param value Flag specifying if subscription logs should be sent for the Monitor resource.
     */
    @JvmName("qrowcumxaxtmerjs")
    public suspend fun sendSubscriptionLogs(`value`: Output) {
        this.sendSubscriptionLogs = value
    }

    /**
     * @param value List of filtering tags to be used for capturing logs. This only takes effect if SendActivityLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
     */
    @JvmName("atnciuvexpjkvtvv")
    public suspend fun filteringTags(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.filteringTags = mapped
    }

    /**
     * @param argument List of filtering tags to be used for capturing logs. This only takes effect if SendActivityLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
     */
    @JvmName("xmupoiuqfqlrfuqy")
    public suspend fun filteringTags(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            FilteringTagArgsBuilder().applySuspend { it() }.build()
        }
        val mapped = of(toBeMapped)
        this.filteringTags = mapped
    }

    /**
     * @param argument List of filtering tags to be used for capturing logs. This only takes effect if SendActivityLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
     */
    @JvmName("dorapwnkuipirxrl")
    public suspend fun filteringTags(vararg argument: suspend FilteringTagArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            FilteringTagArgsBuilder().applySuspend { it() }.build()
        }
        val mapped = of(toBeMapped)
        this.filteringTags = mapped
    }

    /**
     * @param argument List of filtering tags to be used for capturing logs. This only takes effect if SendActivityLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
     */
    @JvmName("qrduynrqqhfsriiw")
    public suspend fun filteringTags(argument: suspend FilteringTagArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(FilteringTagArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.filteringTags = mapped
    }

    /**
     * @param values List of filtering tags to be used for capturing logs. This only takes effect if SendActivityLogs flag is enabled. If empty, all resources will be captured. If only Exclude action is specified, the rules will apply to the list of all available resources. If Include actions are specified, the rules will only include resources with the associated tags.
     */
    @JvmName("bpvldqmhtdshxhox")
    public suspend fun filteringTags(vararg values: FilteringTagArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.filteringTags = mapped
    }

    /**
     * @param value Flag specifying if AAD logs should be sent for the Monitor resource.
     */
    @JvmName("cudbsekiprshyfhn")
    public suspend fun sendAadLogs(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.sendAadLogs = mapped
    }

    /**
     * @param value Flag specifying if activity logs from Azure resources should be sent for the Monitor resource.
     */
    @JvmName("ietdgprbogfgylji")
    public suspend fun sendActivityLogs(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.sendActivityLogs = mapped
    }

    /**
     * @param value Flag specifying if subscription logs should be sent for the Monitor resource.
     */
    @JvmName("aynnufawpiufemfg")
    public suspend fun sendSubscriptionLogs(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.sendSubscriptionLogs = mapped
    }

    internal fun build(): LogRulesArgs = LogRulesArgs(
        filteringTags = filteringTags,
        sendAadLogs = sendAadLogs,
        sendActivityLogs = sendActivityLogs,
        sendSubscriptionLogs = sendSubscriptionLogs,
    )
}