Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Dynatrace
  3. API Docs
  4. FailureDetectionParameters
Dynatrace v0.21.0 published on Sunday, Nov 17, 2024 by Pulumiverse
lbrlabs/pulumi-dynatrace

dynatrace.FailureDetectionParameters

Explore with Pulumi AI

dynatrace logo
Dynatrace v0.21.0 published on Sunday, Nov 17, 2024 by Pulumiverse
lbrlabs/pulumi-dynatrace

    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.

    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"),
})

    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)
                    .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": 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
    Customize failure detection for specific exceptions and errors
    HttpResponseCodes Pulumiverse.Dynatrace.Inputs.FailureDetectionParametersHttpResponseCodes
    HTTP response codes
    Description string
    Description
    Name string
    Name
    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
    Customize failure detection for specific exceptions and errors
    HttpResponseCodes FailureDetectionParametersHttpResponseCodesArgs
    HTTP response codes
    Description string
    Description
    Name string
    Name
    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
    Customize failure detection for specific exceptions and errors
    httpResponseCodes FailureDetectionParametersHttpResponseCodes
    HTTP response codes
    description String
    Description
    name String
    Name
    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
    Customize failure detection for specific exceptions and errors
    httpResponseCodes FailureDetectionParametersHttpResponseCodes
    HTTP response codes
    description string
    Description
    name string
    Name
    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
    Customize failure detection for specific exceptions and errors
    http_response_codes FailureDetectionParametersHttpResponseCodesArgs
    HTTP response codes
    description str
    Description
    name str
    Name
    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
    Customize failure detection for specific exceptions and errors
    httpResponseCodes Property Map
    HTTP response codes
    description String
    Description
    name String
    Name

    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 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)
    Resource lookup is not supported in YAML
    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
    Description
    ExceptionRules Pulumiverse.Dynatrace.Inputs.FailureDetectionParametersExceptionRules
    Customize failure detection for specific exceptions and errors
    HttpResponseCodes Pulumiverse.Dynatrace.Inputs.FailureDetectionParametersHttpResponseCodes
    HTTP response codes
    Name string
    Name
    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
    Description
    ExceptionRules FailureDetectionParametersExceptionRulesArgs
    Customize failure detection for specific exceptions and errors
    HttpResponseCodes FailureDetectionParametersHttpResponseCodesArgs
    HTTP response codes
    Name string
    Name
    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
    Description
    exceptionRules FailureDetectionParametersExceptionRules
    Customize failure detection for specific exceptions and errors
    httpResponseCodes FailureDetectionParametersHttpResponseCodes
    HTTP response codes
    name String
    Name
    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
    Description
    exceptionRules FailureDetectionParametersExceptionRules
    Customize failure detection for specific exceptions and errors
    httpResponseCodes FailureDetectionParametersHttpResponseCodes
    HTTP response codes
    name string
    Name
    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
    Description
    exception_rules FailureDetectionParametersExceptionRulesArgs
    Customize failure detection for specific exceptions and errors
    http_response_codes FailureDetectionParametersHttpResponseCodesArgs
    HTTP response codes
    name str
    Name
    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
    Description
    exceptionRules Property Map
    Customize failure detection for specific exceptions and errors
    httpResponseCodes Property Map
    HTTP response codes
    name String
    Name

    Supporting Types

    Http404NotFoundFailures bool
    Consider 404 HTTP response codes as failures
    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
    Consider 404 HTTP response codes as failures
    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.
    http404NotFoundFailures Boolean
    Consider 404 HTTP response codes as failures
    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
    Consider 404 HTTP response codes as failures
    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
    Consider 404 HTTP response codes as failures
    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
    Consider 404 HTTP response codes as failures
    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
    Ignore all exceptions
    IgnoreSpanFailureDetection bool
    Ignore span failure detection
    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 in a request, 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 a 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
    Ignore all exceptions
    IgnoreSpanFailureDetection bool
    Ignore span failure detection
    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 in a request, 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 a 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
    Ignore all exceptions
    ignoreSpanFailureDetection Boolean
    Ignore span failure detection
    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 in a request, 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 a 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
    Ignore all exceptions
    ignoreSpanFailureDetection boolean
    Ignore span failure detection
    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 in a request, 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 a 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
    Ignore all exceptions
    ignore_span_failure_detection bool
    Ignore span failure detection
    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 in a request, 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 a 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
    Ignore all exceptions
    ignoreSpanFailureDetection Boolean
    Ignore span failure detection
    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 in a request, 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 a 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 Property Map
    Request attribute condition
    requestAttribute String
    Request attribute

    FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleCondition, FailureDetectionParametersExceptionRulesCustomErrorRulesCustomErrorRuleConditionArgs

    CompareOperationType string
    Apply this comparison
    CaseSensitive bool
    Case sensitive
    DoubleValue double
    Value
    IntValue int
    Value
    TextValue string
    Value
    CompareOperationType string
    Apply this comparison
    CaseSensitive bool
    Case sensitive
    DoubleValue float64
    Value
    IntValue int
    Value
    TextValue string
    Value
    compareOperationType String
    Apply this comparison
    caseSensitive Boolean
    Case sensitive
    doubleValue Double
    Value
    intValue Integer
    Value
    textValue String
    Value
    compareOperationType string
    Apply this comparison
    caseSensitive boolean
    Case sensitive
    doubleValue number
    Value
    intValue number
    Value
    textValue string
    Value
    compare_operation_type str
    Apply this comparison
    case_sensitive bool
    Case sensitive
    double_value float
    Value
    int_value int
    Value
    text_value str
    Value
    compareOperationType String
    Apply this comparison
    caseSensitive Boolean
    Case sensitive
    doubleValue Number
    Value
    intValue Number
    Value
    textValue String
    Value

    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.
    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.
    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.
    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
    HTTP response codes which indicate client side errors
    FailOnMissingResponseCodeClientSide bool
    Treat missing HTTP response code as client side error
    FailOnMissingResponseCodeServerSide bool
    Treat missing HTTP response code as server side errors
    ServerSideErrors string
    HTTP response codes which indicate an error on the server side
    ClientSideErrors string
    HTTP response codes which indicate client side errors
    FailOnMissingResponseCodeClientSide bool
    Treat missing HTTP response code as client side error
    FailOnMissingResponseCodeServerSide bool
    Treat missing HTTP response code as server side errors
    ServerSideErrors string
    HTTP response codes which indicate an error on the server side
    clientSideErrors String
    HTTP response codes which indicate client side errors
    failOnMissingResponseCodeClientSide Boolean
    Treat missing HTTP response code as client side error
    failOnMissingResponseCodeServerSide Boolean
    Treat missing HTTP response code as server side errors
    serverSideErrors String
    HTTP response codes which indicate an error on the server side
    clientSideErrors string
    HTTP response codes which indicate client side errors
    failOnMissingResponseCodeClientSide boolean
    Treat missing HTTP response code as client side error
    failOnMissingResponseCodeServerSide boolean
    Treat missing HTTP response code as server side errors
    serverSideErrors string
    HTTP response codes which indicate an error on the server side
    client_side_errors str
    HTTP response codes which indicate client side errors
    fail_on_missing_response_code_client_side bool
    Treat missing HTTP response code as client side error
    fail_on_missing_response_code_server_side bool
    Treat missing HTTP response code as server side errors
    server_side_errors str
    HTTP response codes which indicate an error on the server side
    clientSideErrors String
    HTTP response codes which indicate client side errors
    failOnMissingResponseCodeClientSide Boolean
    Treat missing HTTP response code as client side error
    failOnMissingResponseCodeServerSide Boolean
    Treat missing HTTP response code as server side errors
    serverSideErrors String
    HTTP response codes which indicate an error on the server side

    Package Details

    Repository
    dynatrace pulumiverse/pulumi-dynatrace
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the dynatrace Terraform Provider.
    dynatrace logo
    Dynatrace v0.21.0 published on Sunday, Nov 17, 2024 by Pulumiverse
    lbrlabs/pulumi-dynatrace