Sign in Dashboard Get started
  1. Packages
  2. Packages
  3. Dynatrace
  4. API Docs
  5. FailureDetectionParameters
Viewing docs for Dynatrace v0.36.0
published on Tuesday, Jun 9, 2026 by Pulumiverse
Schema (JSON)
pulumiverse/pulumi-dynatrace

dynatrace.FailureDetectionParameters

dynatrace logo
Viewing docs for Dynatrace v0.36.0
published on Tuesday, Jun 9, 2026 by Pulumiverse
Schema (JSON)
pulumiverse/pulumi-dynatrace

    This resource requires the API token scopes Read settings (settings.read) and Write settings (settings.write)

    Dynatrace Documentation

    • Configure service failure detection - https://www.dynatrace.com/support/help/platform-modules/applications-and-microservices/services/service-monitoring-settings/configure-service-failure-detection

    • Settings API - https://www.dynatrace.com/support/help/dynatrace-api/environment-api/settings (schemaId: builtin:failure-detection.environment.parameters)

    Export Example Usage

    • terraform-provider-dynatrace -export dynatrace.FailureDetectionParameters downloads all existing failure detection parameters

    The full documentation of the export feature is available here.

    Create FailureDetectionParameters Resource

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

    Constructor syntax

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

@overload
def FailureDetectionParameters(resource_name: str,
                               opts: Optional[ResourceOptions] = None,
                               broken_links: Optional[FailureDetectionParametersBrokenLinksArgs] = None,
                               exception_rules: Optional[FailureDetectionParametersExceptionRulesArgs] = None,
                               http_response_codes: Optional[FailureDetectionParametersHttpResponseCodesArgs] = None,
                               description: Optional[str] = None,
                               name: Optional[str] = None)
    func NewFailureDetectionParameters(ctx *Context, name string, args FailureDetectionParametersArgs, opts ...ResourceOption) (*FailureDetectionParameters, error)
    public FailureDetectionParameters(string name, FailureDetectionParametersArgs args, CustomResourceOptions? opts = null)
    public FailureDetectionParameters(String name, FailureDetectionParametersArgs args)
public FailureDetectionParameters(String name, FailureDetectionParametersArgs args, CustomResourceOptions options)

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


    resource "dynatrace_failuredetectionparameters" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args FailureDetectionParametersArgs
    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 FailureDetectionParametersArgs
    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 FailureDetectionParametersArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args FailureDetectionParametersArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args FailureDetectionParametersArgs
    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 failureDetectionParametersResource = new Dynatrace.FailureDetectionParameters("failureDetectionParametersResource", new()
{
    BrokenLinks = new Dynatrace.Inputs.FailureDetectionParametersBrokenLinksArgs
    {
        Http404NotFoundFailures = false,
        BrokenLinkDomains = new[]
        {
            "string",
        },
    },
    ExceptionRules = new Dynatrace.Inputs.FailureDetectionParametersExceptionRulesArgs
    {
        IgnoreAllExceptions = false,
        IgnoreSpanFailureDetection = false,
        CustomErrorRules = new Dynatrace.Inputs.FailureDetectionParametersExceptionRulesCustomErrorRulesArgs
        {
            CustomErrorRules = new[]
            {
                new Dynatrace.Inputs.FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleArgs
                {
                    Condition = new Dynatrace.Inputs.FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleConditionArgs
                    {
                        CompareOperationType = "string",
                        CaseSensitive = false,
                        DoubleValue = 0,
                        IntValue = 0,
                        TextValue = "string",
                    },
                    RequestAttribute = "string",
                },
            },
        },
        CustomHandledExceptions = new Dynatrace.Inputs.FailureDetectionParametersExceptionRulesCustomHandledExceptionsArgs
        {
            CustomHandledExceptions = new[]
            {
                new Dynatrace.Inputs.FailureDetectionParametersExceptionRulesCustomHandledExceptionsCustomHandledExceptionArgs
                {
                    ClassPattern = "string",
                    MessagePattern = "string",
                },
            },
        },
        IgnoredExceptions = new Dynatrace.Inputs.FailureDetectionParametersExceptionRulesIgnoredExceptionsArgs
        {
            CustomHandledExceptions = new[]
            {
                new Dynatrace.Inputs.FailureDetectionParametersExceptionRulesIgnoredExceptionsCustomHandledExceptionArgs
                {
                    ClassPattern = "string",
                    MessagePattern = "string",
                },
            },
        },
        SuccessForcingExceptions = new Dynatrace.Inputs.FailureDetectionParametersExceptionRulesSuccessForcingExceptionsArgs
        {
            CustomHandledExceptions = new[]
            {
                new Dynatrace.Inputs.FailureDetectionParametersExceptionRulesSuccessForcingExceptionsCustomHandledExceptionArgs
                {
                    ClassPattern = "string",
                    MessagePattern = "string",
                },
            },
        },
    },
    HttpResponseCodes = new Dynatrace.Inputs.FailureDetectionParametersHttpResponseCodesArgs
    {
        ClientSideErrors = "string",
        FailOnMissingResponseCodeClientSide = false,
        FailOnMissingResponseCodeServerSide = false,
        ServerSideErrors = "string",
    },
    Description = "string",
    Name = "string",
});

    example, err := dynatrace.NewFailureDetectionParameters(ctx, "failureDetectionParametersResource", &dynatrace.FailureDetectionParametersArgs{
	BrokenLinks: &dynatrace.FailureDetectionParametersBrokenLinksArgs{
		Http404NotFoundFailures: pulumi.Bool(false),
		BrokenLinkDomains: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	ExceptionRules: &dynatrace.FailureDetectionParametersExceptionRulesArgs{
		IgnoreAllExceptions:        pulumi.Bool(false),
		IgnoreSpanFailureDetection: pulumi.Bool(false),
		CustomErrorRules: &dynatrace.FailureDetectionParametersExceptionRulesCustomErrorRulesArgs{
			CustomErrorRules: dynatrace.FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleArray{
				&dynatrace.FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleArgs{
					Condition: &dynatrace.FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleConditionArgs{
						CompareOperationType: pulumi.String("string"),
						CaseSensitive:        pulumi.Bool(false),
						DoubleValue:          pulumi.Float64(0),
						IntValue:             pulumi.Int(0),
						TextValue:            pulumi.String("string"),
					},
					RequestAttribute: pulumi.String("string"),
				},
			},
		},
		CustomHandledExceptions: &dynatrace.FailureDetectionParametersExceptionRulesCustomHandledExceptionsArgs{
			CustomHandledExceptions: dynatrace.FailureDetectionParametersExceptionRulesCustomHandledExceptionsCustomHandledExceptionArray{
				&dynatrace.FailureDetectionParametersExceptionRulesCustomHandledExceptionsCustomHandledExceptionArgs{
					ClassPattern:   pulumi.String("string"),
					MessagePattern: pulumi.String("string"),
				},
			},
		},
		IgnoredExceptions: &dynatrace.FailureDetectionParametersExceptionRulesIgnoredExceptionsArgs{
			CustomHandledExceptions: dynatrace.FailureDetectionParametersExceptionRulesIgnoredExceptionsCustomHandledExceptionArray{
				&dynatrace.FailureDetectionParametersExceptionRulesIgnoredExceptionsCustomHandledExceptionArgs{
					ClassPattern:   pulumi.String("string"),
					MessagePattern: pulumi.String("string"),
				},
			},
		},
		SuccessForcingExceptions: &dynatrace.FailureDetectionParametersExceptionRulesSuccessForcingExceptionsArgs{
			CustomHandledExceptions: dynatrace.FailureDetectionParametersExceptionRulesSuccessForcingExceptionsCustomHandledExceptionArray{
				&dynatrace.FailureDetectionParametersExceptionRulesSuccessForcingExceptionsCustomHandledExceptionArgs{
					ClassPattern:   pulumi.String("string"),
					MessagePattern: pulumi.String("string"),
				},
			},
		},
	},
	HttpResponseCodes: &dynatrace.FailureDetectionParametersHttpResponseCodesArgs{
		ClientSideErrors:                    pulumi.String("string"),
		FailOnMissingResponseCodeClientSide: pulumi.Bool(false),
		FailOnMissingResponseCodeServerSide: pulumi.Bool(false),
		ServerSideErrors:                    pulumi.String("string"),
	},
	Description: pulumi.String("string"),
	Name:        pulumi.String("string"),
})

    resource "dynatrace_failuredetectionparameters" "failureDetectionParametersResource" {
  broken_links = {
    http404_not_found_failures = false
    broken_link_domains        = ["string"]
  }
  exception_rules = {
    ignore_all_exceptions         = false
    ignore_span_failure_detection = false
    custom_error_rules = {
      custom_error_rules = [{
        "condition" = {
          "compareOperationType" = "string"
          "caseSensitive"        = false
          "doubleValue"          = 0
          "intValue"             = 0
          "textValue"            = "string"
        }
        "requestAttribute" = "string"
      }]
    }
    custom_handled_exceptions = {
      custom_handled_exceptions = [{
        "classPattern"   = "string"
        "messagePattern" = "string"
      }]
    }
    ignored_exceptions = {
      custom_handled_exceptions = [{
        "classPattern"   = "string"
        "messagePattern" = "string"
      }]
    }
    success_forcing_exceptions = {
      custom_handled_exceptions = [{
        "classPattern"   = "string"
        "messagePattern" = "string"
      }]
    }
  }
  http_response_codes = {
    client_side_errors                        = "string"
    fail_on_missing_response_code_client_side = false
    fail_on_missing_response_code_server_side = false
    server_side_errors                        = "string"
  }
  description = "string"
  name        = "string"
}

    var failureDetectionParametersResource = new FailureDetectionParameters("failureDetectionParametersResource", FailureDetectionParametersArgs.builder()
    .brokenLinks(FailureDetectionParametersBrokenLinksArgs.builder()
        .http404NotFoundFailures(false)
        .brokenLinkDomains("string")
        .build())
    .exceptionRules(FailureDetectionParametersExceptionRulesArgs.builder()
        .ignoreAllExceptions(false)
        .ignoreSpanFailureDetection(false)
        .customErrorRules(FailureDetectionParametersExceptionRulesCustomErrorRulesArgs.builder()
            .customErrorRules(FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleArgs.builder()
                .condition(FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleConditionArgs.builder()
                    .compareOperationType("string")
                    .caseSensitive(false)
                    .doubleValue(0.0)
                    .intValue(0)
                    .textValue("string")
                    .build())
                .requestAttribute("string")
                .build())
            .build())
        .customHandledExceptions(FailureDetectionParametersExceptionRulesCustomHandledExceptionsArgs.builder()
            .customHandledExceptions(FailureDetectionParametersExceptionRulesCustomHandledExceptionsCustomHandledExceptionArgs.builder()
                .classPattern("string")
                .messagePattern("string")
                .build())
            .build())
        .ignoredExceptions(FailureDetectionParametersExceptionRulesIgnoredExceptionsArgs.builder()
            .customHandledExceptions(FailureDetectionParametersExceptionRulesIgnoredExceptionsCustomHandledExceptionArgs.builder()
                .classPattern("string")
                .messagePattern("string")
                .build())
            .build())
        .successForcingExceptions(FailureDetectionParametersExceptionRulesSuccessForcingExceptionsArgs.builder()
            .customHandledExceptions(FailureDetectionParametersExceptionRulesSuccessForcingExceptionsCustomHandledExceptionArgs.builder()
                .classPattern("string")
                .messagePattern("string")
                .build())
            .build())
        .build())
    .httpResponseCodes(FailureDetectionParametersHttpResponseCodesArgs.builder()
        .clientSideErrors("string")
        .failOnMissingResponseCodeClientSide(false)
        .failOnMissingResponseCodeServerSide(false)
        .serverSideErrors("string")
        .build())
    .description("string")
    .name("string")
    .build());

    failure_detection_parameters_resource = dynatrace.FailureDetectionParameters("failureDetectionParametersResource",
    broken_links={
        "http404_not_found_failures": False,
        "broken_link_domains": ["string"],
    },
    exception_rules={
        "ignore_all_exceptions": False,
        "ignore_span_failure_detection": False,
        "custom_error_rules": {
            "custom_error_rules": [{
                "condition": {
                    "compare_operation_type": "string",
                    "case_sensitive": False,
                    "double_value": float(0),
                    "int_value": 0,
                    "text_value": "string",
                },
                "request_attribute": "string",
            }],
        },
        "custom_handled_exceptions": {
            "custom_handled_exceptions": [{
                "class_pattern": "string",
                "message_pattern": "string",
            }],
        },
        "ignored_exceptions": {
            "custom_handled_exceptions": [{
                "class_pattern": "string",
                "message_pattern": "string",
            }],
        },
        "success_forcing_exceptions": {
            "custom_handled_exceptions": [{
                "class_pattern": "string",
                "message_pattern": "string",
            }],
        },
    },
    http_response_codes={
        "client_side_errors": "string",
        "fail_on_missing_response_code_client_side": False,
        "fail_on_missing_response_code_server_side": False,
        "server_side_errors": "string",
    },
    description="string",
    name="string")

    const failureDetectionParametersResource = new dynatrace.FailureDetectionParameters("failureDetectionParametersResource", {
    brokenLinks: {
        http404NotFoundFailures: false,
        brokenLinkDomains: ["string"],
    },
    exceptionRules: {
        ignoreAllExceptions: false,
        ignoreSpanFailureDetection: false,
        customErrorRules: {
            customErrorRules: [{
                condition: {
                    compareOperationType: "string",
                    caseSensitive: false,
                    doubleValue: 0,
                    intValue: 0,
                    textValue: "string",
                },
                requestAttribute: "string",
            }],
        },
        customHandledExceptions: {
            customHandledExceptions: [{
                classPattern: "string",
                messagePattern: "string",
            }],
        },
        ignoredExceptions: {
            customHandledExceptions: [{
                classPattern: "string",
                messagePattern: "string",
            }],
        },
        successForcingExceptions: {
            customHandledExceptions: [{
                classPattern: "string",
                messagePattern: "string",
            }],
        },
    },
    httpResponseCodes: {
        clientSideErrors: "string",
        failOnMissingResponseCodeClientSide: false,
        failOnMissingResponseCodeServerSide: false,
        serverSideErrors: "string",
    },
    description: "string",
    name: "string",
});

    type: dynatrace:FailureDetectionParameters
properties:
    brokenLinks:
        brokenLinkDomains:
            - string
        http404NotFoundFailures: false
    description: string
    exceptionRules:
        customErrorRules:
            customErrorRules:
                - condition:
                    caseSensitive: false
                    compareOperationType: string
                    doubleValue: 0
                    intValue: 0
                    textValue: string
                  requestAttribute: string
        customHandledExceptions:
            customHandledExceptions:
                - classPattern: string
                  messagePattern: string
        ignoreAllExceptions: false
        ignoreSpanFailureDetection: false
        ignoredExceptions:
            customHandledExceptions:
                - classPattern: string
                  messagePattern: string
        successForcingExceptions:
            customHandledExceptions:
                - classPattern: string
                  messagePattern: string
    httpResponseCodes:
        clientSideErrors: string
        failOnMissingResponseCodeClientSide: false
        failOnMissingResponseCodeServerSide: false
        serverSideErrors: string
    name: string

    FailureDetectionParameters 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 FailureDetectionParameters resource accepts the following input properties:

    BrokenLinks Pulumiverse.Dynatrace.Inputs.FailureDetectionParametersBrokenLinks
    HTTP 404 response codes are thrown when a web server can't find a certain page. 404s are classified as broken links on the client side and therefore aren't considered to be service failures. By enabling this setting, you can have 404s treated as server-side service failures.
    ExceptionRules Pulumiverse.Dynatrace.Inputs.FailureDetectionParametersExceptionRules
    Exception and custom error rules that determine how specific exceptions, handled errors, and request-attribute-based conditions affect failure detection.
    HttpResponseCodes Pulumiverse.Dynatrace.Inputs.FailureDetectionParametersHttpResponseCodes
    HTTP response code settings that control which response codes are treated as server-side or client-side errors.
    Description string
    A short description of this failure detection parameter set.
    Name string
    The display name of this failure detection parameter set.
    BrokenLinks FailureDetectionParametersBrokenLinksArgs
    HTTP 404 response codes are thrown when a web server can't find a certain page. 404s are classified as broken links on the client side and therefore aren't considered to be service failures. By enabling this setting, you can have 404s treated as server-side service failures.
    ExceptionRules FailureDetectionParametersExceptionRulesArgs
    Exception and custom error rules that determine how specific exceptions, handled errors, and request-attribute-based conditions affect failure detection.
    HttpResponseCodes FailureDetectionParametersHttpResponseCodesArgs
    HTTP response code settings that control which response codes are treated as server-side or client-side errors.
    Description string
    A short description of this failure detection parameter set.
    Name string
    The display name of this failure detection parameter set.
    broken_links object
    HTTP 404 response codes are thrown when a web server can't find a certain page. 404s are classified as broken links on the client side and therefore aren't considered to be service failures. By enabling this setting, you can have 404s treated as server-side service failures.
    exception_rules object
    Exception and custom error rules that determine how specific exceptions, handled errors, and request-attribute-based conditions affect failure detection.
    http_response_codes object
    HTTP response code settings that control which response codes are treated as server-side or client-side errors.
    description string
    A short description of this failure detection parameter set.
    name string
    The display name of this failure detection parameter set.
    brokenLinks FailureDetectionParametersBrokenLinks
    HTTP 404 response codes are thrown when a web server can't find a certain page. 404s are classified as broken links on the client side and therefore aren't considered to be service failures. By enabling this setting, you can have 404s treated as server-side service failures.
    exceptionRules FailureDetectionParametersExceptionRules
    Exception and custom error rules that determine how specific exceptions, handled errors, and request-attribute-based conditions affect failure detection.
    httpResponseCodes FailureDetectionParametersHttpResponseCodes
    HTTP response code settings that control which response codes are treated as server-side or client-side errors.
    description String
    A short description of this failure detection parameter set.
    name String
    The display name of this failure detection parameter set.
    brokenLinks FailureDetectionParametersBrokenLinks
    HTTP 404 response codes are thrown when a web server can't find a certain page. 404s are classified as broken links on the client side and therefore aren't considered to be service failures. By enabling this setting, you can have 404s treated as server-side service failures.
    exceptionRules FailureDetectionParametersExceptionRules
    Exception and custom error rules that determine how specific exceptions, handled errors, and request-attribute-based conditions affect failure detection.
    httpResponseCodes FailureDetectionParametersHttpResponseCodes
    HTTP response code settings that control which response codes are treated as server-side or client-side errors.
    description string
    A short description of this failure detection parameter set.
    name string
    The display name of this failure detection parameter set.
    broken_links FailureDetectionParametersBrokenLinksArgs
    HTTP 404 response codes are thrown when a web server can't find a certain page. 404s are classified as broken links on the client side and therefore aren't considered to be service failures. By enabling this setting, you can have 404s treated as server-side service failures.
    exception_rules FailureDetectionParametersExceptionRulesArgs
    Exception and custom error rules that determine how specific exceptions, handled errors, and request-attribute-based conditions affect failure detection.
    http_response_codes FailureDetectionParametersHttpResponseCodesArgs
    HTTP response code settings that control which response codes are treated as server-side or client-side errors.
    description str
    A short description of this failure detection parameter set.
    name str
    The display name of this failure detection parameter set.
    brokenLinks Property Map
    HTTP 404 response codes are thrown when a web server can't find a certain page. 404s are classified as broken links on the client side and therefore aren't considered to be service failures. By enabling this setting, you can have 404s treated as server-side service failures.
    exceptionRules Property Map
    Exception and custom error rules that determine how specific exceptions, handled errors, and request-attribute-based conditions affect failure detection.
    httpResponseCodes Property Map
    HTTP response code settings that control which response codes are treated as server-side or client-side errors.
    description String
    A short description of this failure detection parameter set.
    name String
    The display name of this failure detection parameter set.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the FailureDetectionParameters 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 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 FailureDetectionParameters Resource

    Get an existing FailureDetectionParameters 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?: FailureDetectionParametersState, opts?: CustomResourceOptions): FailureDetectionParameters
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        broken_links: Optional[FailureDetectionParametersBrokenLinksArgs] = None,
        description: Optional[str] = None,
        exception_rules: Optional[FailureDetectionParametersExceptionRulesArgs] = None,
        http_response_codes: Optional[FailureDetectionParametersHttpResponseCodesArgs] = None,
        name: Optional[str] = None) -> FailureDetectionParameters
    func GetFailureDetectionParameters(ctx *Context, name string, id IDInput, state *FailureDetectionParametersState, opts ...ResourceOption) (*FailureDetectionParameters, error)
    public static FailureDetectionParameters Get(string name, Input<string> id, FailureDetectionParametersState? state, CustomResourceOptions? opts = null)
    public static FailureDetectionParameters get(String name, Output<String> id, FailureDetectionParametersState state, CustomResourceOptions options)
    resources:  _:    type: dynatrace:FailureDetectionParameters    get:      id: ${id}
    import {
  to = dynatrace_failuredetectionparameters.example
  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:
    BrokenLinks Pulumiverse.Dynatrace.Inputs.FailureDetectionParametersBrokenLinks
    HTTP 404 response codes are thrown when a web server can't find a certain page. 404s are classified as broken links on the client side and therefore aren't considered to be service failures. By enabling this setting, you can have 404s treated as server-side service failures.
    Description string
    A short description of this failure detection parameter set.
    ExceptionRules Pulumiverse.Dynatrace.Inputs.FailureDetectionParametersExceptionRules
    Exception and custom error rules that determine how specific exceptions, handled errors, and request-attribute-based conditions affect failure detection.
    HttpResponseCodes Pulumiverse.Dynatrace.Inputs.FailureDetectionParametersHttpResponseCodes
    HTTP response code settings that control which response codes are treated as server-side or client-side errors.
    Name string
    The display name of this failure detection parameter set.
    BrokenLinks FailureDetectionParametersBrokenLinksArgs
    HTTP 404 response codes are thrown when a web server can't find a certain page. 404s are classified as broken links on the client side and therefore aren't considered to be service failures. By enabling this setting, you can have 404s treated as server-side service failures.
    Description string
    A short description of this failure detection parameter set.
    ExceptionRules FailureDetectionParametersExceptionRulesArgs
    Exception and custom error rules that determine how specific exceptions, handled errors, and request-attribute-based conditions affect failure detection.
    HttpResponseCodes FailureDetectionParametersHttpResponseCodesArgs
    HTTP response code settings that control which response codes are treated as server-side or client-side errors.
    Name string
    The display name of this failure detection parameter set.
    broken_links object
    HTTP 404 response codes are thrown when a web server can't find a certain page. 404s are classified as broken links on the client side and therefore aren't considered to be service failures. By enabling this setting, you can have 404s treated as server-side service failures.
    description string
    A short description of this failure detection parameter set.
    exception_rules object
    Exception and custom error rules that determine how specific exceptions, handled errors, and request-attribute-based conditions affect failure detection.
    http_response_codes object
    HTTP response code settings that control which response codes are treated as server-side or client-side errors.
    name string
    The display name of this failure detection parameter set.
    brokenLinks FailureDetectionParametersBrokenLinks
    HTTP 404 response codes are thrown when a web server can't find a certain page. 404s are classified as broken links on the client side and therefore aren't considered to be service failures. By enabling this setting, you can have 404s treated as server-side service failures.
    description String
    A short description of this failure detection parameter set.
    exceptionRules FailureDetectionParametersExceptionRules
    Exception and custom error rules that determine how specific exceptions, handled errors, and request-attribute-based conditions affect failure detection.
    httpResponseCodes FailureDetectionParametersHttpResponseCodes
    HTTP response code settings that control which response codes are treated as server-side or client-side errors.
    name String
    The display name of this failure detection parameter set.
    brokenLinks FailureDetectionParametersBrokenLinks
    HTTP 404 response codes are thrown when a web server can't find a certain page. 404s are classified as broken links on the client side and therefore aren't considered to be service failures. By enabling this setting, you can have 404s treated as server-side service failures.
    description string
    A short description of this failure detection parameter set.
    exceptionRules FailureDetectionParametersExceptionRules
    Exception and custom error rules that determine how specific exceptions, handled errors, and request-attribute-based conditions affect failure detection.
    httpResponseCodes FailureDetectionParametersHttpResponseCodes
    HTTP response code settings that control which response codes are treated as server-side or client-side errors.
    name string
    The display name of this failure detection parameter set.
    broken_links FailureDetectionParametersBrokenLinksArgs
    HTTP 404 response codes are thrown when a web server can't find a certain page. 404s are classified as broken links on the client side and therefore aren't considered to be service failures. By enabling this setting, you can have 404s treated as server-side service failures.
    description str
    A short description of this failure detection parameter set.
    exception_rules FailureDetectionParametersExceptionRulesArgs
    Exception and custom error rules that determine how specific exceptions, handled errors, and request-attribute-based conditions affect failure detection.
    http_response_codes FailureDetectionParametersHttpResponseCodesArgs
    HTTP response code settings that control which response codes are treated as server-side or client-side errors.
    name str
    The display name of this failure detection parameter set.
    brokenLinks Property Map
    HTTP 404 response codes are thrown when a web server can't find a certain page. 404s are classified as broken links on the client side and therefore aren't considered to be service failures. By enabling this setting, you can have 404s treated as server-side service failures.
    description String
    A short description of this failure detection parameter set.
    exceptionRules Property Map
    Exception and custom error rules that determine how specific exceptions, handled errors, and request-attribute-based conditions affect failure detection.
    httpResponseCodes Property Map
    HTTP response code settings that control which response codes are treated as server-side or client-side errors.
    name String
    The display name of this failure detection parameter set.

    Supporting Types

    Http404NotFoundFailures bool
    If true, HTTP 404 response codes are treated as server-side service failures. Only applicable when 404 is not already in the list of failing server-side HTTP response codes. Default: false.
    BrokenLinkDomains List<string>
    If your application relies on other hosts at other domains, add the associated domain names here. Once configured, Dynatrace will consider 404s thrown by hosts at these domains to be service failures related to your application.
    Http404NotFoundFailures bool
    If true, HTTP 404 response codes are treated as server-side service failures. Only applicable when 404 is not already in the list of failing server-side HTTP response codes. Default: false.
    BrokenLinkDomains []string
    If your application relies on other hosts at other domains, add the associated domain names here. Once configured, Dynatrace will consider 404s thrown by hosts at these domains to be service failures related to your application.
    http404_not_found_failures bool
    If true, HTTP 404 response codes are treated as server-side service failures. Only applicable when 404 is not already in the list of failing server-side HTTP response codes. Default: false.
    broken_link_domains list(string)
    If your application relies on other hosts at other domains, add the associated domain names here. Once configured, Dynatrace will consider 404s thrown by hosts at these domains to be service failures related to your application.
    http404NotFoundFailures Boolean
    If true, HTTP 404 response codes are treated as server-side service failures. Only applicable when 404 is not already in the list of failing server-side HTTP response codes. Default: false.
    brokenLinkDomains List<String>
    If your application relies on other hosts at other domains, add the associated domain names here. Once configured, Dynatrace will consider 404s thrown by hosts at these domains to be service failures related to your application.
    http404NotFoundFailures boolean
    If true, HTTP 404 response codes are treated as server-side service failures. Only applicable when 404 is not already in the list of failing server-side HTTP response codes. Default: false.
    brokenLinkDomains string[]
    If your application relies on other hosts at other domains, add the associated domain names here. Once configured, Dynatrace will consider 404s thrown by hosts at these domains to be service failures related to your application.
    http404_not_found_failures bool
    If true, HTTP 404 response codes are treated as server-side service failures. Only applicable when 404 is not already in the list of failing server-side HTTP response codes. Default: false.
    broken_link_domains Sequence[str]
    If your application relies on other hosts at other domains, add the associated domain names here. Once configured, Dynatrace will consider 404s thrown by hosts at these domains to be service failures related to your application.
    http404NotFoundFailures Boolean
    If true, HTTP 404 response codes are treated as server-side service failures. Only applicable when 404 is not already in the list of failing server-side HTTP response codes. Default: false.
    brokenLinkDomains List<String>
    If your application relies on other hosts at other domains, add the associated domain names here. Once configured, Dynatrace will consider 404s thrown by hosts at these domains to be service failures related to your application.

    FailureDetectionParametersExceptionRules, FailureDetectionParametersExceptionRulesArgs

    IgnoreAllExceptions bool
    If true, all exceptions are ignored for failure detection. Success forcing exceptions, ignored exceptions, and custom handled exceptions have no effect. Exceptions are still tracked and appear in distributed traces, but requests are not labeled as failed. Default: false.
    IgnoreSpanFailureDetection bool
    If true, span failure detection is ignored. This is specific to OpenTelemetry. Default: false.
    CustomErrorRules Pulumiverse.Dynatrace.Inputs.FailureDetectionParametersExceptionRulesCustomErrorRules
    Some custom error situations are only detectable via a return value or other means. To support such cases, define a request attribute that captures the required data. Then define a custom error rule that determines if the request has failed based on the value of the request attribute.
    CustomHandledExceptions Pulumiverse.Dynatrace.Inputs.FailureDetectionParametersExceptionRulesCustomHandledExceptions
    There may be situations where your application code handles exceptions gracefully in a manner that these failures aren't detected by Dynatrace. Use this setting to define specific gracefully-handled exceptions that should be treated as service failures.
    IgnoredExceptions Pulumiverse.Dynatrace.Inputs.FailureDetectionParametersExceptionRulesIgnoredExceptions
    Some exceptions that are thrown by legacy or 3rd-party code indicate a specific response, not an error. Use this setting to instruct Dynatrace to treat such exceptions as non-failed requests. If an exception matching any of the defined patterns occurs on the entry node of the service, it will not be considered as a failure. Other exceptions occurring at the same request might still mark the request as failed.
    SuccessForcingExceptions Pulumiverse.Dynatrace.Inputs.FailureDetectionParametersExceptionRulesSuccessForcingExceptions
    Define exceptions which indicate that an entire service call should not be considered as failed. E.g. an exception indicating that the client aborted the operation. If an exception matching any of the defined patterns occurs on the entry node of the service, it will be considered successful. Compared to ignored exceptions, the request will be considered successful even if other exceptions occur in the same request.
    IgnoreAllExceptions bool
    If true, all exceptions are ignored for failure detection. Success forcing exceptions, ignored exceptions, and custom handled exceptions have no effect. Exceptions are still tracked and appear in distributed traces, but requests are not labeled as failed. Default: false.
    IgnoreSpanFailureDetection bool
    If true, span failure detection is ignored. This is specific to OpenTelemetry. Default: false.
    CustomErrorRules FailureDetectionParametersExceptionRulesCustomErrorRules
    Some custom error situations are only detectable via a return value or other means. To support such cases, define a request attribute that captures the required data. Then define a custom error rule that determines if the request has failed based on the value of the request attribute.
    CustomHandledExceptions FailureDetectionParametersExceptionRulesCustomHandledExceptions
    There may be situations where your application code handles exceptions gracefully in a manner that these failures aren't detected by Dynatrace. Use this setting to define specific gracefully-handled exceptions that should be treated as service failures.
    IgnoredExceptions FailureDetectionParametersExceptionRulesIgnoredExceptions
    Some exceptions that are thrown by legacy or 3rd-party code indicate a specific response, not an error. Use this setting to instruct Dynatrace to treat such exceptions as non-failed requests. If an exception matching any of the defined patterns occurs on the entry node of the service, it will not be considered as a failure. Other exceptions occurring at the same request might still mark the request as failed.
    SuccessForcingExceptions FailureDetectionParametersExceptionRulesSuccessForcingExceptions
    Define exceptions which indicate that an entire service call should not be considered as failed. E.g. an exception indicating that the client aborted the operation. If an exception matching any of the defined patterns occurs on the entry node of the service, it will be considered successful. Compared to ignored exceptions, the request will be considered successful even if other exceptions occur in the same request.
    ignore_all_exceptions bool
    If true, all exceptions are ignored for failure detection. Success forcing exceptions, ignored exceptions, and custom handled exceptions have no effect. Exceptions are still tracked and appear in distributed traces, but requests are not labeled as failed. Default: false.
    ignore_span_failure_detection bool
    If true, span failure detection is ignored. This is specific to OpenTelemetry. Default: false.
    custom_error_rules object
    Some custom error situations are only detectable via a return value or other means. To support such cases, define a request attribute that captures the required data. Then define a custom error rule that determines if the request has failed based on the value of the request attribute.
    custom_handled_exceptions object
    There may be situations where your application code handles exceptions gracefully in a manner that these failures aren't detected by Dynatrace. Use this setting to define specific gracefully-handled exceptions that should be treated as service failures.
    ignored_exceptions object
    Some exceptions that are thrown by legacy or 3rd-party code indicate a specific response, not an error. Use this setting to instruct Dynatrace to treat such exceptions as non-failed requests. If an exception matching any of the defined patterns occurs on the entry node of the service, it will not be considered as a failure. Other exceptions occurring at the same request might still mark the request as failed.
    success_forcing_exceptions object
    Define exceptions which indicate that an entire service call should not be considered as failed. E.g. an exception indicating that the client aborted the operation. If an exception matching any of the defined patterns occurs on the entry node of the service, it will be considered successful. Compared to ignored exceptions, the request will be considered successful even if other exceptions occur in the same request.
    ignoreAllExceptions Boolean
    If true, all exceptions are ignored for failure detection. Success forcing exceptions, ignored exceptions, and custom handled exceptions have no effect. Exceptions are still tracked and appear in distributed traces, but requests are not labeled as failed. Default: false.
    ignoreSpanFailureDetection Boolean
    If true, span failure detection is ignored. This is specific to OpenTelemetry. Default: false.
    customErrorRules FailureDetectionParametersExceptionRulesCustomErrorRules
    Some custom error situations are only detectable via a return value or other means. To support such cases, define a request attribute that captures the required data. Then define a custom error rule that determines if the request has failed based on the value of the request attribute.
    customHandledExceptions FailureDetectionParametersExceptionRulesCustomHandledExceptions
    There may be situations where your application code handles exceptions gracefully in a manner that these failures aren't detected by Dynatrace. Use this setting to define specific gracefully-handled exceptions that should be treated as service failures.
    ignoredExceptions FailureDetectionParametersExceptionRulesIgnoredExceptions
    Some exceptions that are thrown by legacy or 3rd-party code indicate a specific response, not an error. Use this setting to instruct Dynatrace to treat such exceptions as non-failed requests. If an exception matching any of the defined patterns occurs on the entry node of the service, it will not be considered as a failure. Other exceptions occurring at the same request might still mark the request as failed.
    successForcingExceptions FailureDetectionParametersExceptionRulesSuccessForcingExceptions
    Define exceptions which indicate that an entire service call should not be considered as failed. E.g. an exception indicating that the client aborted the operation. If an exception matching any of the defined patterns occurs on the entry node of the service, it will be considered successful. Compared to ignored exceptions, the request will be considered successful even if other exceptions occur in the same request.
    ignoreAllExceptions boolean
    If true, all exceptions are ignored for failure detection. Success forcing exceptions, ignored exceptions, and custom handled exceptions have no effect. Exceptions are still tracked and appear in distributed traces, but requests are not labeled as failed. Default: false.
    ignoreSpanFailureDetection boolean
    If true, span failure detection is ignored. This is specific to OpenTelemetry. Default: false.
    customErrorRules FailureDetectionParametersExceptionRulesCustomErrorRules
    Some custom error situations are only detectable via a return value or other means. To support such cases, define a request attribute that captures the required data. Then define a custom error rule that determines if the request has failed based on the value of the request attribute.
    customHandledExceptions FailureDetectionParametersExceptionRulesCustomHandledExceptions
    There may be situations where your application code handles exceptions gracefully in a manner that these failures aren't detected by Dynatrace. Use this setting to define specific gracefully-handled exceptions that should be treated as service failures.
    ignoredExceptions FailureDetectionParametersExceptionRulesIgnoredExceptions
    Some exceptions that are thrown by legacy or 3rd-party code indicate a specific response, not an error. Use this setting to instruct Dynatrace to treat such exceptions as non-failed requests. If an exception matching any of the defined patterns occurs on the entry node of the service, it will not be considered as a failure. Other exceptions occurring at the same request might still mark the request as failed.
    successForcingExceptions FailureDetectionParametersExceptionRulesSuccessForcingExceptions
    Define exceptions which indicate that an entire service call should not be considered as failed. E.g. an exception indicating that the client aborted the operation. If an exception matching any of the defined patterns occurs on the entry node of the service, it will be considered successful. Compared to ignored exceptions, the request will be considered successful even if other exceptions occur in the same request.
    ignore_all_exceptions bool
    If true, all exceptions are ignored for failure detection. Success forcing exceptions, ignored exceptions, and custom handled exceptions have no effect. Exceptions are still tracked and appear in distributed traces, but requests are not labeled as failed. Default: false.
    ignore_span_failure_detection bool
    If true, span failure detection is ignored. This is specific to OpenTelemetry. Default: false.
    custom_error_rules FailureDetectionParametersExceptionRulesCustomErrorRules
    Some custom error situations are only detectable via a return value or other means. To support such cases, define a request attribute that captures the required data. Then define a custom error rule that determines if the request has failed based on the value of the request attribute.
    custom_handled_exceptions FailureDetectionParametersExceptionRulesCustomHandledExceptions
    There may be situations where your application code handles exceptions gracefully in a manner that these failures aren't detected by Dynatrace. Use this setting to define specific gracefully-handled exceptions that should be treated as service failures.
    ignored_exceptions FailureDetectionParametersExceptionRulesIgnoredExceptions
    Some exceptions that are thrown by legacy or 3rd-party code indicate a specific response, not an error. Use this setting to instruct Dynatrace to treat such exceptions as non-failed requests. If an exception matching any of the defined patterns occurs on the entry node of the service, it will not be considered as a failure. Other exceptions occurring at the same request might still mark the request as failed.
    success_forcing_exceptions FailureDetectionParametersExceptionRulesSuccessForcingExceptions
    Define exceptions which indicate that an entire service call should not be considered as failed. E.g. an exception indicating that the client aborted the operation. If an exception matching any of the defined patterns occurs on the entry node of the service, it will be considered successful. Compared to ignored exceptions, the request will be considered successful even if other exceptions occur in the same request.
    ignoreAllExceptions Boolean
    If true, all exceptions are ignored for failure detection. Success forcing exceptions, ignored exceptions, and custom handled exceptions have no effect. Exceptions are still tracked and appear in distributed traces, but requests are not labeled as failed. Default: false.
    ignoreSpanFailureDetection Boolean
    If true, span failure detection is ignored. This is specific to OpenTelemetry. Default: false.
    customErrorRules Property Map
    Some custom error situations are only detectable via a return value or other means. To support such cases, define a request attribute that captures the required data. Then define a custom error rule that determines if the request has failed based on the value of the request attribute.
    customHandledExceptions Property Map
    There may be situations where your application code handles exceptions gracefully in a manner that these failures aren't detected by Dynatrace. Use this setting to define specific gracefully-handled exceptions that should be treated as service failures.
    ignoredExceptions Property Map
    Some exceptions that are thrown by legacy or 3rd-party code indicate a specific response, not an error. Use this setting to instruct Dynatrace to treat such exceptions as non-failed requests. If an exception matching any of the defined patterns occurs on the entry node of the service, it will not be considered as a failure. Other exceptions occurring at the same request might still mark the request as failed.
    successForcingExceptions Property Map
    Define exceptions which indicate that an entire service call should not be considered as failed. E.g. an exception indicating that the client aborted the operation. If an exception matching any of the defined patterns occurs on the entry node of the service, it will be considered successful. Compared to ignored exceptions, the request will be considered successful even if other exceptions occur in the same request.

    FailureDetectionParametersExceptionRulesCustomErrorRules, FailureDetectionParametersExceptionRulesCustomErrorRulesArgs

    FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRule, FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleArgs

    Condition Pulumiverse.Dynatrace.Inputs.FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleCondition
    The condition that determines whether the request attribute value indicates a failure.
    RequestAttribute string
    The ID of the request attribute to check. The request attribute must already be defined.
    Condition FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleCondition
    The condition that determines whether the request attribute value indicates a failure.
    RequestAttribute string
    The ID of the request attribute to check. The request attribute must already be defined.
    condition object
    The condition that determines whether the request attribute value indicates a failure.
    request_attribute string
    The ID of the request attribute to check. The request attribute must already be defined.
    condition FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleCondition
    The condition that determines whether the request attribute value indicates a failure.
    requestAttribute String
    The ID of the request attribute to check. The request attribute must already be defined.
    condition FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleCondition
    The condition that determines whether the request attribute value indicates a failure.
    requestAttribute string
    The ID of the request attribute to check. The request attribute must already be defined.
    condition FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleCondition
    The condition that determines whether the request attribute value indicates a failure.
    request_attribute str
    The ID of the request attribute to check. The request attribute must already be defined.
    condition Property Map
    The condition that determines whether the request attribute value indicates a failure.
    requestAttribute String
    The ID of the request attribute to check. The request attribute must already be defined.

    FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleCondition, FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleConditionArgs

    CompareOperationType string
    The type of comparison to apply. Available types depend on the data type of the request attribute:

    • String types support STRING_EXISTS, STRING_EQUALS, NOT_STRING_EQUALS, STARTS_WITH, NOT_STARTS_WITH, CONTAINS, NOT_CONTAINS, ENDS_WITH, NOT_ENDS_WITH.
    • Integer types support INTEGER_EQUALS and related comparisons;
    • Double types support DOUBLE_EQUALS and related comparisons.
    CaseSensitive bool
    If true, the comparison is case-sensitive. Only applicable for string comparison types. Default: false.
    DoubleValue double
    The floating-point value to compare the request attribute against. Only applicable for double comparison types.
    IntValue int
    The integer value to compare the request attribute against. Only applicable for integer comparison types.
    TextValue string
    The text value to compare the request attribute against. Only applicable for string comparison types.
    CompareOperationType string
    The type of comparison to apply. Available types depend on the data type of the request attribute:

    • String types support STRING_EXISTS, STRING_EQUALS, NOT_STRING_EQUALS, STARTS_WITH, NOT_STARTS_WITH, CONTAINS, NOT_CONTAINS, ENDS_WITH, NOT_ENDS_WITH.
    • Integer types support INTEGER_EQUALS and related comparisons;
    • Double types support DOUBLE_EQUALS and related comparisons.
    CaseSensitive bool
    If true, the comparison is case-sensitive. Only applicable for string comparison types. Default: false.
    DoubleValue float64
    The floating-point value to compare the request attribute against. Only applicable for double comparison types.
    IntValue int
    The integer value to compare the request attribute against. Only applicable for integer comparison types.
    TextValue string
    The text value to compare the request attribute against. Only applicable for string comparison types.
    compare_operation_type string
    The type of comparison to apply. Available types depend on the data type of the request attribute:

    • String types support STRING_EXISTS, STRING_EQUALS, NOT_STRING_EQUALS, STARTS_WITH, NOT_STARTS_WITH, CONTAINS, NOT_CONTAINS, ENDS_WITH, NOT_ENDS_WITH.
    • Integer types support INTEGER_EQUALS and related comparisons;
    • Double types support DOUBLE_EQUALS and related comparisons.
    case_sensitive bool
    If true, the comparison is case-sensitive. Only applicable for string comparison types. Default: false.
    double_value number
    The floating-point value to compare the request attribute against. Only applicable for double comparison types.
    int_value number
    The integer value to compare the request attribute against. Only applicable for integer comparison types.
    text_value string
    The text value to compare the request attribute against. Only applicable for string comparison types.
    compareOperationType String
    The type of comparison to apply. Available types depend on the data type of the request attribute:

    • String types support STRING_EXISTS, STRING_EQUALS, NOT_STRING_EQUALS, STARTS_WITH, NOT_STARTS_WITH, CONTAINS, NOT_CONTAINS, ENDS_WITH, NOT_ENDS_WITH.
    • Integer types support INTEGER_EQUALS and related comparisons;
    • Double types support DOUBLE_EQUALS and related comparisons.
    caseSensitive Boolean
    If true, the comparison is case-sensitive. Only applicable for string comparison types. Default: false.
    doubleValue Double
    The floating-point value to compare the request attribute against. Only applicable for double comparison types.
    intValue Integer
    The integer value to compare the request attribute against. Only applicable for integer comparison types.
    textValue String
    The text value to compare the request attribute against. Only applicable for string comparison types.
    compareOperationType string
    The type of comparison to apply. Available types depend on the data type of the request attribute:

    • String types support STRING_EXISTS, STRING_EQUALS, NOT_STRING_EQUALS, STARTS_WITH, NOT_STARTS_WITH, CONTAINS, NOT_CONTAINS, ENDS_WITH, NOT_ENDS_WITH.
    • Integer types support INTEGER_EQUALS and related comparisons;
    • Double types support DOUBLE_EQUALS and related comparisons.
    caseSensitive boolean
    If true, the comparison is case-sensitive. Only applicable for string comparison types. Default: false.
    doubleValue number
    The floating-point value to compare the request attribute against. Only applicable for double comparison types.
    intValue number
    The integer value to compare the request attribute against. Only applicable for integer comparison types.
    textValue string
    The text value to compare the request attribute against. Only applicable for string comparison types.
    compare_operation_type str
    The type of comparison to apply. Available types depend on the data type of the request attribute:

    • String types support STRING_EXISTS, STRING_EQUALS, NOT_STRING_EQUALS, STARTS_WITH, NOT_STARTS_WITH, CONTAINS, NOT_CONTAINS, ENDS_WITH, NOT_ENDS_WITH.
    • Integer types support INTEGER_EQUALS and related comparisons;
    • Double types support DOUBLE_EQUALS and related comparisons.
    case_sensitive bool
    If true, the comparison is case-sensitive. Only applicable for string comparison types. Default: false.
    double_value float
    The floating-point value to compare the request attribute against. Only applicable for double comparison types.
    int_value int
    The integer value to compare the request attribute against. Only applicable for integer comparison types.
    text_value str
    The text value to compare the request attribute against. Only applicable for string comparison types.
    compareOperationType String
    The type of comparison to apply. Available types depend on the data type of the request attribute:

    • String types support STRING_EXISTS, STRING_EQUALS, NOT_STRING_EQUALS, STARTS_WITH, NOT_STARTS_WITH, CONTAINS, NOT_CONTAINS, ENDS_WITH, NOT_ENDS_WITH.
    • Integer types support INTEGER_EQUALS and related comparisons;
    • Double types support DOUBLE_EQUALS and related comparisons.
    caseSensitive Boolean
    If true, the comparison is case-sensitive. Only applicable for string comparison types. Default: false.
    doubleValue Number
    The floating-point value to compare the request attribute against. Only applicable for double comparison types.
    intValue Number
    The integer value to compare the request attribute against. Only applicable for integer comparison types.
    textValue String
    The text value to compare the request attribute against. Only applicable for string comparison types.

    FailureDetectionParametersExceptionRulesCustomHandledExceptions, FailureDetectionParametersExceptionRulesCustomHandledExceptionsArgs

    FailureDetectionParametersExceptionRulesCustomHandledExceptionsCustomHandledException, FailureDetectionParametersExceptionRulesCustomHandledExceptionsCustomHandledExceptionArgs

    ClassPattern string
    The pattern will match if it is contained within the actual class name.
    MessagePattern string
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    ClassPattern string
    The pattern will match if it is contained within the actual class name.
    MessagePattern string
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    class_pattern string
    The pattern will match if it is contained within the actual class name.
    message_pattern string
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    classPattern String
    The pattern will match if it is contained within the actual class name.
    messagePattern String
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    classPattern string
    The pattern will match if it is contained within the actual class name.
    messagePattern string
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    class_pattern str
    The pattern will match if it is contained within the actual class name.
    message_pattern str
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    classPattern String
    The pattern will match if it is contained within the actual class name.
    messagePattern String
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.

    FailureDetectionParametersExceptionRulesIgnoredExceptions, FailureDetectionParametersExceptionRulesIgnoredExceptionsArgs

    FailureDetectionParametersExceptionRulesIgnoredExceptionsCustomHandledException, FailureDetectionParametersExceptionRulesIgnoredExceptionsCustomHandledExceptionArgs

    ClassPattern string
    The pattern will match if it is contained within the actual class name.
    MessagePattern string
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    ClassPattern string
    The pattern will match if it is contained within the actual class name.
    MessagePattern string
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    class_pattern string
    The pattern will match if it is contained within the actual class name.
    message_pattern string
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    classPattern String
    The pattern will match if it is contained within the actual class name.
    messagePattern String
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    classPattern string
    The pattern will match if it is contained within the actual class name.
    messagePattern string
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    class_pattern str
    The pattern will match if it is contained within the actual class name.
    message_pattern str
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    classPattern String
    The pattern will match if it is contained within the actual class name.
    messagePattern String
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.

    FailureDetectionParametersExceptionRulesSuccessForcingExceptions, FailureDetectionParametersExceptionRulesSuccessForcingExceptionsArgs

    FailureDetectionParametersExceptionRulesSuccessForcingExceptionsCustomHandledException, FailureDetectionParametersExceptionRulesSuccessForcingExceptionsCustomHandledExceptionArgs

    ClassPattern string
    The pattern will match if it is contained within the actual class name.
    MessagePattern string
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    ClassPattern string
    The pattern will match if it is contained within the actual class name.
    MessagePattern string
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    class_pattern string
    The pattern will match if it is contained within the actual class name.
    message_pattern string
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    classPattern String
    The pattern will match if it is contained within the actual class name.
    messagePattern String
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    classPattern string
    The pattern will match if it is contained within the actual class name.
    messagePattern string
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    class_pattern str
    The pattern will match if it is contained within the actual class name.
    message_pattern str
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.
    classPattern String
    The pattern will match if it is contained within the actual class name.
    messagePattern String
    Optionally, define an exception message pattern. The pattern will match if the actual exception message contains the pattern.

    FailureDetectionParametersHttpResponseCodes, FailureDetectionParametersHttpResponseCodesArgs

    ClientSideErrors string
    A list of HTTP response code ranges and individual values that are treated as client-side errors. The format is a comma-separated list of ranges and values (e.g., 400-499, 503, 510-599). Default: 400-599.
    FailOnMissingResponseCodeClientSide bool
    If true, a missing HTTP response code on the client side is treated as a failure. Missing response codes can indicate a fire-and-forget call, a timeout, or an error. Default: false.
    FailOnMissingResponseCodeServerSide bool
    If true, a missing HTTP response code on the server side is treated as a failure. Missing response codes can indicate a fire-and-forget call, a timeout, or an error. Default: false.
    ServerSideErrors string
    A list of HTTP response code ranges and individual values that are treated as server-side errors. The format is a comma-separated list of ranges and values (e.g., 500-599, 402, 405-499). Default: 500-599.
    ClientSideErrors string
    A list of HTTP response code ranges and individual values that are treated as client-side errors. The format is a comma-separated list of ranges and values (e.g., 400-499, 503, 510-599). Default: 400-599.
    FailOnMissingResponseCodeClientSide bool
    If true, a missing HTTP response code on the client side is treated as a failure. Missing response codes can indicate a fire-and-forget call, a timeout, or an error. Default: false.
    FailOnMissingResponseCodeServerSide bool
    If true, a missing HTTP response code on the server side is treated as a failure. Missing response codes can indicate a fire-and-forget call, a timeout, or an error. Default: false.
    ServerSideErrors string
    A list of HTTP response code ranges and individual values that are treated as server-side errors. The format is a comma-separated list of ranges and values (e.g., 500-599, 402, 405-499). Default: 500-599.
    client_side_errors string
    A list of HTTP response code ranges and individual values that are treated as client-side errors. The format is a comma-separated list of ranges and values (e.g., 400-499, 503, 510-599). Default: 400-599.
    fail_on_missing_response_code_client_side bool
    If true, a missing HTTP response code on the client side is treated as a failure. Missing response codes can indicate a fire-and-forget call, a timeout, or an error. Default: false.
    fail_on_missing_response_code_server_side bool
    If true, a missing HTTP response code on the server side is treated as a failure. Missing response codes can indicate a fire-and-forget call, a timeout, or an error. Default: false.
    server_side_errors string
    A list of HTTP response code ranges and individual values that are treated as server-side errors. The format is a comma-separated list of ranges and values (e.g., 500-599, 402, 405-499). Default: 500-599.
    clientSideErrors String
    A list of HTTP response code ranges and individual values that are treated as client-side errors. The format is a comma-separated list of ranges and values (e.g., 400-499, 503, 510-599). Default: 400-599.
    failOnMissingResponseCodeClientSide Boolean
    If true, a missing HTTP response code on the client side is treated as a failure. Missing response codes can indicate a fire-and-forget call, a timeout, or an error. Default: false.
    failOnMissingResponseCodeServerSide Boolean
    If true, a missing HTTP response code on the server side is treated as a failure. Missing response codes can indicate a fire-and-forget call, a timeout, or an error. Default: false.
    serverSideErrors String
    A list of HTTP response code ranges and individual values that are treated as server-side errors. The format is a comma-separated list of ranges and values (e.g., 500-599, 402, 405-499). Default: 500-599.
    clientSideErrors string
    A list of HTTP response code ranges and individual values that are treated as client-side errors. The format is a comma-separated list of ranges and values (e.g., 400-499, 503, 510-599). Default: 400-599.
    failOnMissingResponseCodeClientSide boolean
    If true, a missing HTTP response code on the client side is treated as a failure. Missing response codes can indicate a fire-and-forget call, a timeout, or an error. Default: false.
    failOnMissingResponseCodeServerSide boolean
    If true, a missing HTTP response code on the server side is treated as a failure. Missing response codes can indicate a fire-and-forget call, a timeout, or an error. Default: false.
    serverSideErrors string
    A list of HTTP response code ranges and individual values that are treated as server-side errors. The format is a comma-separated list of ranges and values (e.g., 500-599, 402, 405-499). Default: 500-599.
    client_side_errors str
    A list of HTTP response code ranges and individual values that are treated as client-side errors. The format is a comma-separated list of ranges and values (e.g., 400-499, 503, 510-599). Default: 400-599.
    fail_on_missing_response_code_client_side bool
    If true, a missing HTTP response code on the client side is treated as a failure. Missing response codes can indicate a fire-and-forget call, a timeout, or an error. Default: false.
    fail_on_missing_response_code_server_side bool
    If true, a missing HTTP response code on the server side is treated as a failure. Missing response codes can indicate a fire-and-forget call, a timeout, or an error. Default: false.
    server_side_errors str
    A list of HTTP response code ranges and individual values that are treated as server-side errors. The format is a comma-separated list of ranges and values (e.g., 500-599, 402, 405-499). Default: 500-599.
    clientSideErrors String
    A list of HTTP response code ranges and individual values that are treated as client-side errors. The format is a comma-separated list of ranges and values (e.g., 400-499, 503, 510-599). Default: 400-599.
    failOnMissingResponseCodeClientSide Boolean
    If true, a missing HTTP response code on the client side is treated as a failure. Missing response codes can indicate a fire-and-forget call, a timeout, or an error. Default: false.
    failOnMissingResponseCodeServerSide Boolean
    If true, a missing HTTP response code on the server side is treated as a failure. Missing response codes can indicate a fire-and-forget call, a timeout, or an error. Default: false.
    serverSideErrors String
    A list of HTTP response code ranges and individual values that are treated as server-side errors. The format is a comma-separated list of ranges and values (e.g., 500-599, 402, 405-499). Default: 500-599.

    Package Details

    Repository
    dynatrace pulumiverse/pulumi-dynatrace
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the dynatrace Terraform Provider.
    dynatrace logo
    Viewing docs for Dynatrace v0.36.0
    published on Tuesday, Jun 9, 2026 by Pulumiverse
    Schema (JSON)
    pulumiverse/pulumi-dynatrace

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial