dynatrace.getSyntheticLocation

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dynatrace.DynatraceFunctions;
import com.pulumi.dynatrace.inputs.GetSyntheticLocationArgs;
import com.pulumi.dynatrace.HttpMonitor;
import com.pulumi.dynatrace.HttpMonitorArgs;
import com.pulumi.dynatrace.inputs.HttpMonitorAnomalyDetectionArgs;
import com.pulumi.dynatrace.inputs.HttpMonitorScriptArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var test = DynatraceFunctions.getSyntheticLocation(GetSyntheticLocationArgs.builder()
            .cloudPlatform("AMAZON_EC2")
            .name("Sydney")
            .type("PUBLIC")
            .build());

        var _name_ = new HttpMonitor("#name#", HttpMonitorArgs.builder()
            .anomalyDetections(HttpMonitorAnomalyDetectionArgs.builder()
                .loadingTimeThresholds(HttpMonitorAnomalyDetectionLoadingTimeThresholdArgs.builder()
                    .enabled(true)
                    .build())
                .outageHandlings(HttpMonitorAnomalyDetectionOutageHandlingArgs.builder()
                    .globalOutage(true)
                    .localOutage(false)
                    .retryOnError(false)
                    .build())
                .build())
            .enabled(true)
            .frequency(60)
            .locations(test.applyValue(getSyntheticLocationResult -> getSyntheticLocationResult.id()))
            .script(HttpMonitorScriptArgs.builder()
                .requests(HttpMonitorScriptRequestArgs.builder()
                    .configuration(HttpMonitorScriptRequestConfigurationArgs.builder()
                        .acceptAnyCertificate(true)
                        .followRedirects(true)
                        .build())
                    .description("google.com")
                    .method("GET")
                    .url("https://www.google.com")
                    .validation(HttpMonitorScriptRequestValidationArgs.builder()
                        .rule(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  '#name#':
    type: dynatrace:HttpMonitor
    properties:
      anomalyDetections:
        - loadingTimeThresholds:
            - enabled: true
          outageHandlings:
            - globalOutage: true
              localOutage: false
              retryOnError: false
      enabled: true
      frequency: 60
      locations:
        - ${test.id}
      script:
        requests:
          - configuration:
              acceptAnyCertificate: true
              followRedirects: true
            description: google.com
            method: GET
            url: https://www.google.com
            validation:
              rule:
                - passIfFound: false
                  type: httpStatusesList
                  value: '>=400'
variables:
  test:
    fn::invoke:
      Function: dynatrace:getSyntheticLocation
      Arguments:
        cloudPlatform: AMAZON_EC2
        name: Sydney
        type: PUBLIC

function getSyntheticLocation(args: GetSyntheticLocationArgs, opts?: InvokeOptions): Promise<GetSyntheticLocationResult>
function getSyntheticLocationOutput(args: GetSyntheticLocationOutputArgs, opts?: InvokeOptions): Output<GetSyntheticLocationResult>

def get_synthetic_location(cloud_platform: Optional[str] = None,
                           entity_id: Optional[str] = None,
                           ips: Optional[Sequence[str]] = None,
                           name: Optional[str] = None,
                           stage: Optional[str] = None,
                           status: Optional[str] = None,
                           type: Optional[str] = None,
                           opts: Optional[InvokeOptions] = None) -> GetSyntheticLocationResult
def get_synthetic_location_output(cloud_platform: Optional[pulumi.Input[str]] = None,
                           entity_id: Optional[pulumi.Input[str]] = None,
                           ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                           name: Optional[pulumi.Input[str]] = None,
                           stage: Optional[pulumi.Input[str]] = None,
                           status: Optional[pulumi.Input[str]] = None,
                           type: Optional[pulumi.Input[str]] = None,
                           opts: Optional[InvokeOptions] = None) -> Output[GetSyntheticLocationResult]

func LookupSyntheticLocation(ctx *Context, args *LookupSyntheticLocationArgs, opts ...InvokeOption) (*LookupSyntheticLocationResult, error)
func LookupSyntheticLocationOutput(ctx *Context, args *LookupSyntheticLocationOutputArgs, opts ...InvokeOption) LookupSyntheticLocationResultOutput

public static class GetSyntheticLocation 
{
    public static Task<GetSyntheticLocationResult> InvokeAsync(GetSyntheticLocationArgs args, InvokeOptions? opts = null)
    public static Output<GetSyntheticLocationResult> Invoke(GetSyntheticLocationInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSyntheticLocationResult> getSyntheticLocation(GetSyntheticLocationArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: dynatrace:index/getSyntheticLocation:getSyntheticLocation
  arguments:
    # arguments dictionary