aws.bedrock.AgentcoreOnlineEvaluationConfig

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

const example = new aws.iam.Role("example", {
    name: "agentcore-eval-role",
    assumeRolePolicy: JSON.stringify({
        Version: "2012-10-17",
        Statement: [{
            Effect: "Allow",
            Action: "sts:AssumeRole",
            Principal: {
                Service: "bedrock-agentcore.amazonaws.com",
            },
        }],
    }),
});
const exampleLogGroup = new aws.cloudwatch.LogGroup("example", {name: "/aws/agentcore/my-agent-traces"});
const exampleAgentcoreOnlineEvaluationConfig = new aws.bedrock.AgentcoreOnlineEvaluationConfig("example", {
    onlineEvaluationConfigName: "my_evaluation_config",
    description: "Continuous evaluation of agent performance",
    enableOnCreate: true,
    evaluationExecutionRoleArn: example.arn,
    dataSourceConfig: {
        cloudwatchLogs: {
            logGroupNames: [exampleLogGroup.name],
            serviceNames: ["my_agent_service"],
        },
    },
    evaluators: [
        {
            evaluatorId: "Builtin.Helpfulness",
        },
        {
            evaluatorId: "Builtin.GoalSuccessRate",
        },
    ],
    rule: {
        samplingConfig: {
            samplingPercentage: 10,
        },
    },
});

import pulumi
import json
import pulumi_aws as aws

example = aws.iam.Role("example",
    name="agentcore-eval-role",
    assume_role_policy=json.dumps({
        "Version": "2012-10-17",
        "Statement": [{
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Principal": {
                "Service": "bedrock-agentcore.amazonaws.com",
            },
        }],
    }))
example_log_group = aws.cloudwatch.LogGroup("example", name="/aws/agentcore/my-agent-traces")
example_agentcore_online_evaluation_config = aws.bedrock.AgentcoreOnlineEvaluationConfig("example",
    online_evaluation_config_name="my_evaluation_config",
    description="Continuous evaluation of agent performance",
    enable_on_create=True,
    evaluation_execution_role_arn=example.arn,
    data_source_config={
        "cloudwatch_logs": {
            "log_group_names": [example_log_group.name],
            "service_names": ["my_agent_service"],
        },
    },
    evaluators=[
        {
            "evaluator_id": "Builtin.Helpfulness",
        },
        {
            "evaluator_id": "Builtin.GoalSuccessRate",
        },
    ],
    rule={
        "sampling_config": {
            "sampling_percentage": float(10),
        },
    })

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/bedrock"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"Version": "2012-10-17",
			"Statement": []map[string]interface{}{
				map[string]interface{}{
					"Effect": "Allow",
					"Action": "sts:AssumeRole",
					"Principal": map[string]interface{}{
						"Service": "bedrock-agentcore.amazonaws.com",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		example, err := iam.NewRole(ctx, "example", &iam.RoleArgs{
			Name:             pulumi.String("agentcore-eval-role"),
			AssumeRolePolicy: pulumi.String(pulumi.String(json0)),
		})
		if err != nil {
			return err
		}
		exampleLogGroup, err := cloudwatch.NewLogGroup(ctx, "example", &cloudwatch.LogGroupArgs{
			Name: pulumi.String("/aws/agentcore/my-agent-traces"),
		})
		if err != nil {
			return err
		}
		_, err = bedrock.NewAgentcoreOnlineEvaluationConfig(ctx, "example", &bedrock.AgentcoreOnlineEvaluationConfigArgs{
			OnlineEvaluationConfigName: pulumi.String("my_evaluation_config"),
			Description:                pulumi.String("Continuous evaluation of agent performance"),
			EnableOnCreate:             pulumi.Bool(true),
			EvaluationExecutionRoleArn: example.Arn,
			DataSourceConfig: &bedrock.AgentcoreOnlineEvaluationConfigDataSourceConfigArgs{
				CloudwatchLogs: &bedrock.AgentcoreOnlineEvaluationConfigDataSourceConfigCloudwatchLogsArgs{
					LogGroupNames: pulumi.StringArray{
						exampleLogGroup.Name,
					},
					ServiceNames: pulumi.StringArray{
						pulumi.String("my_agent_service"),
					},
				},
			},
			Evaluators: bedrock.AgentcoreOnlineEvaluationConfigEvaluatorArray{
				&bedrock.AgentcoreOnlineEvaluationConfigEvaluatorArgs{
					EvaluatorId: pulumi.String("Builtin.Helpfulness"),
				},
				&bedrock.AgentcoreOnlineEvaluationConfigEvaluatorArgs{
					EvaluatorId: pulumi.String("Builtin.GoalSuccessRate"),
				},
			},
			Rule: &bedrock.AgentcoreOnlineEvaluationConfigRuleArgs{
				SamplingConfig: &bedrock.AgentcoreOnlineEvaluationConfigRuleSamplingConfigArgs{
					SamplingPercentage: pulumi.Float64(10),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Iam.Role("example", new()
    {
        Name = "agentcore-eval-role",
        AssumeRolePolicy = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["Version"] = "2012-10-17",
            ["Statement"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Effect"] = "Allow",
                    ["Action"] = "sts:AssumeRole",
                    ["Principal"] = new Dictionary<string, object?>
                    {
                        ["Service"] = "bedrock-agentcore.amazonaws.com",
                    },
                },
            },
        }),
    });

    var exampleLogGroup = new Aws.CloudWatch.LogGroup("example", new()
    {
        Name = "/aws/agentcore/my-agent-traces",
    });

    var exampleAgentcoreOnlineEvaluationConfig = new Aws.Bedrock.AgentcoreOnlineEvaluationConfig("example", new()
    {
        OnlineEvaluationConfigName = "my_evaluation_config",
        Description = "Continuous evaluation of agent performance",
        EnableOnCreate = true,
        EvaluationExecutionRoleArn = example.Arn,
        DataSourceConfig = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigDataSourceConfigArgs
        {
            CloudwatchLogs = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigDataSourceConfigCloudwatchLogsArgs
            {
                LogGroupNames = new[]
                {
                    exampleLogGroup.Name,
                },
                ServiceNames = new[]
                {
                    "my_agent_service",
                },
            },
        },
        Evaluators = new[]
        {
            new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigEvaluatorArgs
            {
                EvaluatorId = "Builtin.Helpfulness",
            },
            new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigEvaluatorArgs
            {
                EvaluatorId = "Builtin.GoalSuccessRate",
            },
        },
        Rule = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigRuleArgs
        {
            SamplingConfig = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigRuleSamplingConfigArgs
            {
                SamplingPercentage = 10,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.iam.Role;
import com.pulumi.aws.iam.RoleArgs;
import com.pulumi.aws.cloudwatch.LogGroup;
import com.pulumi.aws.cloudwatch.LogGroupArgs;
import com.pulumi.aws.bedrock.AgentcoreOnlineEvaluationConfig;
import com.pulumi.aws.bedrock.AgentcoreOnlineEvaluationConfigArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreOnlineEvaluationConfigDataSourceConfigArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreOnlineEvaluationConfigDataSourceConfigCloudwatchLogsArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreOnlineEvaluationConfigEvaluatorArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreOnlineEvaluationConfigRuleArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreOnlineEvaluationConfigRuleSamplingConfigArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new Role("example", RoleArgs.builder()
            .name("agentcore-eval-role")
            .assumeRolePolicy(serializeJson(
                jsonObject(
                    jsonProperty("Version", "2012-10-17"),
                    jsonProperty("Statement", jsonArray(jsonObject(
                        jsonProperty("Effect", "Allow"),
                        jsonProperty("Action", "sts:AssumeRole"),
                        jsonProperty("Principal", jsonObject(
                            jsonProperty("Service", "bedrock-agentcore.amazonaws.com")
                        ))
                    )))
                )))
            .build());

        var exampleLogGroup = new LogGroup("exampleLogGroup", LogGroupArgs.builder()
            .name("/aws/agentcore/my-agent-traces")
            .build());

        var exampleAgentcoreOnlineEvaluationConfig = new AgentcoreOnlineEvaluationConfig("exampleAgentcoreOnlineEvaluationConfig", AgentcoreOnlineEvaluationConfigArgs.builder()
            .onlineEvaluationConfigName("my_evaluation_config")
            .description("Continuous evaluation of agent performance")
            .enableOnCreate(true)
            .evaluationExecutionRoleArn(example.arn())
            .dataSourceConfig(AgentcoreOnlineEvaluationConfigDataSourceConfigArgs.builder()
                .cloudwatchLogs(AgentcoreOnlineEvaluationConfigDataSourceConfigCloudwatchLogsArgs.builder()
                    .logGroupNames(exampleLogGroup.name())
                    .serviceNames("my_agent_service")
                    .build())
                .build())
            .evaluators(            
                AgentcoreOnlineEvaluationConfigEvaluatorArgs.builder()
                    .evaluatorId("Builtin.Helpfulness")
                    .build(),
                AgentcoreOnlineEvaluationConfigEvaluatorArgs.builder()
                    .evaluatorId("Builtin.GoalSuccessRate")
                    .build())
            .rule(AgentcoreOnlineEvaluationConfigRuleArgs.builder()
                .samplingConfig(AgentcoreOnlineEvaluationConfigRuleSamplingConfigArgs.builder()
                    .samplingPercentage(10.0)
                    .build())
                .build())
            .build());

    }
}

resources:
  example:
    type: aws:iam:Role
    properties:
      name: agentcore-eval-role
      assumeRolePolicy:
        fn::toJSON:
          Version: 2012-10-17
          Statement:
            - Effect: Allow
              Action: sts:AssumeRole
              Principal:
                Service: bedrock-agentcore.amazonaws.com
  exampleLogGroup:
    type: aws:cloudwatch:LogGroup
    name: example
    properties:
      name: /aws/agentcore/my-agent-traces
  exampleAgentcoreOnlineEvaluationConfig:
    type: aws:bedrock:AgentcoreOnlineEvaluationConfig
    name: example
    properties:
      onlineEvaluationConfigName: my_evaluation_config
      description: Continuous evaluation of agent performance
      enableOnCreate: true
      evaluationExecutionRoleArn: ${example.arn}
      dataSourceConfig:
        cloudwatchLogs:
          logGroupNames:
            - ${exampleLogGroup.name}
          serviceNames:
            - my_agent_service
      evaluators:
        - evaluatorId: Builtin.Helpfulness
        - evaluatorId: Builtin.GoalSuccessRate
      rule:
        samplingConfig:
          samplingPercentage: 10

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_iam_role" "example" {
  name = "agentcore-eval-role"
  assume_role_policy = jsonencode({
    "Version" = "2012-10-17"
    "Statement" = [{
      "Effect" = "Allow"
      "Action" = "sts:AssumeRole"
      "Principal" = {
        "Service" = "bedrock-agentcore.amazonaws.com"
      }
    }]
  })
}
resource "aws_cloudwatch_loggroup" "example" {
  name = "/aws/agentcore/my-agent-traces"
}
resource "aws_bedrock_agentcoreonlineevaluationconfig" "example" {
  online_evaluation_config_name = "my_evaluation_config"
  description                   = "Continuous evaluation of agent performance"
  enable_on_create              = true
  evaluation_execution_role_arn = aws_iam_role.example.arn
  data_source_config = {
    cloudwatch_logs = {
      log_group_names = [aws_cloudwatch_loggroup.example.name]
      service_names   = ["my_agent_service"]
    }
  }
  evaluators {
    evaluator_id = "Builtin.Helpfulness"
  }
  evaluators {
    evaluator_id = "Builtin.GoalSuccessRate"
  }
  rule = {
    sampling_config = {
      sampling_percentage = 10
    }
  }
}

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

const filtered = new aws.bedrock.AgentcoreOnlineEvaluationConfig("filtered", {
    onlineEvaluationConfigName: "filtered_evaluation",
    enableOnCreate: true,
    evaluationExecutionRoleArn: exampleAwsIamRole.arn,
    dataSourceConfig: {
        cloudwatchLogs: {
            logGroupNames: [example.name],
            serviceNames: ["my_agent_service"],
        },
    },
    evaluators: [{
        evaluatorId: "Builtin.Helpfulness",
    }],
    rule: {
        samplingConfig: {
            samplingPercentage: 50,
        },
        filters: [{
            key: "environment",
            operator: "Equals",
            value: {
                stringValue: "production",
            },
        }],
        sessionConfig: {
            sessionTimeoutMinutes: 30,
        },
    },
});

import pulumi
import pulumi_aws as aws

filtered = aws.bedrock.AgentcoreOnlineEvaluationConfig("filtered",
    online_evaluation_config_name="filtered_evaluation",
    enable_on_create=True,
    evaluation_execution_role_arn=example_aws_iam_role["arn"],
    data_source_config={
        "cloudwatch_logs": {
            "log_group_names": [example["name"]],
            "service_names": ["my_agent_service"],
        },
    },
    evaluators=[{
        "evaluator_id": "Builtin.Helpfulness",
    }],
    rule={
        "sampling_config": {
            "sampling_percentage": float(50),
        },
        "filters": [{
            "key": "environment",
            "operator": "Equals",
            "value": {
                "string_value": "production",
            },
        }],
        "session_config": {
            "session_timeout_minutes": 30,
        },
    })

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/bedrock"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bedrock.NewAgentcoreOnlineEvaluationConfig(ctx, "filtered", &bedrock.AgentcoreOnlineEvaluationConfigArgs{
			OnlineEvaluationConfigName: pulumi.String("filtered_evaluation"),
			EnableOnCreate:             pulumi.Bool(true),
			EvaluationExecutionRoleArn: pulumi.Any(exampleAwsIamRole.Arn),
			DataSourceConfig: &bedrock.AgentcoreOnlineEvaluationConfigDataSourceConfigArgs{
				CloudwatchLogs: &bedrock.AgentcoreOnlineEvaluationConfigDataSourceConfigCloudwatchLogsArgs{
					LogGroupNames: pulumi.StringArray{
						example.Name,
					},
					ServiceNames: pulumi.StringArray{
						pulumi.String("my_agent_service"),
					},
				},
			},
			Evaluators: bedrock.AgentcoreOnlineEvaluationConfigEvaluatorArray{
				&bedrock.AgentcoreOnlineEvaluationConfigEvaluatorArgs{
					EvaluatorId: pulumi.String("Builtin.Helpfulness"),
				},
			},
			Rule: &bedrock.AgentcoreOnlineEvaluationConfigRuleArgs{
				SamplingConfig: &bedrock.AgentcoreOnlineEvaluationConfigRuleSamplingConfigArgs{
					SamplingPercentage: pulumi.Float64(50),
				},
				Filters: bedrock.AgentcoreOnlineEvaluationConfigRuleFilterArray{
					&bedrock.AgentcoreOnlineEvaluationConfigRuleFilterArgs{
						Key:      pulumi.String("environment"),
						Operator: pulumi.String("Equals"),
						Value: &bedrock.AgentcoreOnlineEvaluationConfigRuleFilterValueArgs{
							StringValue: pulumi.String("production"),
						},
					},
				},
				SessionConfig: &bedrock.AgentcoreOnlineEvaluationConfigRuleSessionConfigArgs{
					SessionTimeoutMinutes: pulumi.Int(30),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var filtered = new Aws.Bedrock.AgentcoreOnlineEvaluationConfig("filtered", new()
    {
        OnlineEvaluationConfigName = "filtered_evaluation",
        EnableOnCreate = true,
        EvaluationExecutionRoleArn = exampleAwsIamRole.Arn,
        DataSourceConfig = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigDataSourceConfigArgs
        {
            CloudwatchLogs = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigDataSourceConfigCloudwatchLogsArgs
            {
                LogGroupNames = new[]
                {
                    example.Name,
                },
                ServiceNames = new[]
                {
                    "my_agent_service",
                },
            },
        },
        Evaluators = new[]
        {
            new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigEvaluatorArgs
            {
                EvaluatorId = "Builtin.Helpfulness",
            },
        },
        Rule = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigRuleArgs
        {
            SamplingConfig = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigRuleSamplingConfigArgs
            {
                SamplingPercentage = 50,
            },
            Filters = new[]
            {
                new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigRuleFilterArgs
                {
                    Key = "environment",
                    Operator = "Equals",
                    Value = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigRuleFilterValueArgs
                    {
                        StringValue = "production",
                    },
                },
            },
            SessionConfig = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigRuleSessionConfigArgs
            {
                SessionTimeoutMinutes = 30,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.bedrock.AgentcoreOnlineEvaluationConfig;
import com.pulumi.aws.bedrock.AgentcoreOnlineEvaluationConfigArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreOnlineEvaluationConfigDataSourceConfigArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreOnlineEvaluationConfigDataSourceConfigCloudwatchLogsArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreOnlineEvaluationConfigEvaluatorArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreOnlineEvaluationConfigRuleArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreOnlineEvaluationConfigRuleSamplingConfigArgs;
import com.pulumi.aws.bedrock.inputs.AgentcoreOnlineEvaluationConfigRuleSessionConfigArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var filtered = new AgentcoreOnlineEvaluationConfig("filtered", AgentcoreOnlineEvaluationConfigArgs.builder()
            .onlineEvaluationConfigName("filtered_evaluation")
            .enableOnCreate(true)
            .evaluationExecutionRoleArn(exampleAwsIamRole.arn())
            .dataSourceConfig(AgentcoreOnlineEvaluationConfigDataSourceConfigArgs.builder()
                .cloudwatchLogs(AgentcoreOnlineEvaluationConfigDataSourceConfigCloudwatchLogsArgs.builder()
                    .logGroupNames(example.name())
                    .serviceNames("my_agent_service")
                    .build())
                .build())
            .evaluators(AgentcoreOnlineEvaluationConfigEvaluatorArgs.builder()
                .evaluatorId("Builtin.Helpfulness")
                .build())
            .rule(AgentcoreOnlineEvaluationConfigRuleArgs.builder()
                .samplingConfig(AgentcoreOnlineEvaluationConfigRuleSamplingConfigArgs.builder()
                    .samplingPercentage(50.0)
                    .build())
                .filters(AgentcoreOnlineEvaluationConfigRuleFilterArgs.builder()
                    .key("environment")
                    .operator("Equals")
                    .value(AgentcoreOnlineEvaluationConfigRuleFilterValueArgs.builder()
                        .stringValue("production")
                        .build())
                    .build())
                .sessionConfig(AgentcoreOnlineEvaluationConfigRuleSessionConfigArgs.builder()
                    .sessionTimeoutMinutes(30)
                    .build())
                .build())
            .build());

    }
}

resources:
  filtered:
    type: aws:bedrock:AgentcoreOnlineEvaluationConfig
    properties:
      onlineEvaluationConfigName: filtered_evaluation
      enableOnCreate: true
      evaluationExecutionRoleArn: ${exampleAwsIamRole.arn}
      dataSourceConfig:
        cloudwatchLogs:
          logGroupNames:
            - ${example.name}
          serviceNames:
            - my_agent_service
      evaluators:
        - evaluatorId: Builtin.Helpfulness
      rule:
        samplingConfig:
          samplingPercentage: 50
        filters:
          - key: environment
            operator: Equals
            value:
              stringValue: production
        sessionConfig:
          sessionTimeoutMinutes: 30

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_bedrock_agentcoreonlineevaluationconfig" "filtered" {
  online_evaluation_config_name = "filtered_evaluation"
  enable_on_create              = true
  evaluation_execution_role_arn = exampleAwsIamRole.arn
  data_source_config = {
    cloudwatch_logs = {
      log_group_names = [example.name]
      service_names   = ["my_agent_service"]
    }
  }
  evaluators {
    evaluator_id = "Builtin.Helpfulness"
  }
  rule = {
    sampling_config = {
      sampling_percentage = 50
    }
    filters = [{
      "key"      = "environment"
      "operator" = "Equals"
      "value" = {
        "stringValue" = "production"
      }
    }]
    session_config = {
      session_timeout_minutes = 30
    }
  }
}

var agentcoreOnlineEvaluationConfigResource = new Aws.Bedrock.AgentcoreOnlineEvaluationConfig("agentcoreOnlineEvaluationConfigResource", new()
{
    DataSourceConfig = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigDataSourceConfigArgs
    {
        CloudwatchLogs = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigDataSourceConfigCloudwatchLogsArgs
        {
            LogGroupNames = new[]
            {
                "string",
            },
            ServiceNames = new[]
            {
                "string",
            },
        },
    },
    EnableOnCreate = false,
    EvaluationExecutionRoleArn = "string",
    Evaluators = new[]
    {
        new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigEvaluatorArgs
        {
            EvaluatorId = "string",
        },
    },
    OnlineEvaluationConfigName = "string",
    Rule = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigRuleArgs
    {
        SamplingConfig = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigRuleSamplingConfigArgs
        {
            SamplingPercentage = 0,
        },
        Filters = new[]
        {
            new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigRuleFilterArgs
            {
                Key = "string",
                Operator = "string",
                Value = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigRuleFilterValueArgs
                {
                    BooleanValue = false,
                    DoubleValue = 0,
                    StringValue = "string",
                },
            },
        },
        SessionConfig = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigRuleSessionConfigArgs
        {
            SessionTimeoutMinutes = 0,
        },
    },
    Description = "string",
    ExecutionStatus = "string",
    Region = "string",
    Tags = 
    {
        { "string", "string" },
    },
    Timeouts = new Aws.Bedrock.Inputs.AgentcoreOnlineEvaluationConfigTimeoutsArgs
    {
        Create = "string",
        Delete = "string",
        Update = "string",
    },
});

example, err := bedrock.NewAgentcoreOnlineEvaluationConfig(ctx, "agentcoreOnlineEvaluationConfigResource", &bedrock.AgentcoreOnlineEvaluationConfigArgs{
	DataSourceConfig: &bedrock.AgentcoreOnlineEvaluationConfigDataSourceConfigArgs{
		CloudwatchLogs: &bedrock.AgentcoreOnlineEvaluationConfigDataSourceConfigCloudwatchLogsArgs{
			LogGroupNames: pulumi.StringArray{
				pulumi.String("string"),
			},
			ServiceNames: pulumi.StringArray{
				pulumi.String("string"),
			},
		},
	},
	EnableOnCreate:             pulumi.Bool(false),
	EvaluationExecutionRoleArn: pulumi.String("string"),
	Evaluators: bedrock.AgentcoreOnlineEvaluationConfigEvaluatorArray{
		&bedrock.AgentcoreOnlineEvaluationConfigEvaluatorArgs{
			EvaluatorId: pulumi.String("string"),
		},
	},
	OnlineEvaluationConfigName: pulumi.String("string"),
	Rule: &bedrock.AgentcoreOnlineEvaluationConfigRuleArgs{
		SamplingConfig: &bedrock.AgentcoreOnlineEvaluationConfigRuleSamplingConfigArgs{
			SamplingPercentage: pulumi.Float64(0),
		},
		Filters: bedrock.AgentcoreOnlineEvaluationConfigRuleFilterArray{
			&bedrock.AgentcoreOnlineEvaluationConfigRuleFilterArgs{
				Key:      pulumi.String("string"),
				Operator: pulumi.String("string"),
				Value: &bedrock.AgentcoreOnlineEvaluationConfigRuleFilterValueArgs{
					BooleanValue: pulumi.Bool(false),
					DoubleValue:  pulumi.Float64(0),
					StringValue:  pulumi.String("string"),
				},
			},
		},
		SessionConfig: &bedrock.AgentcoreOnlineEvaluationConfigRuleSessionConfigArgs{
			SessionTimeoutMinutes: pulumi.Int(0),
		},
	},
	Description:     pulumi.String("string"),
	ExecutionStatus: pulumi.String("string"),
	Region:          pulumi.String("string"),
	Tags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Timeouts: &bedrock.AgentcoreOnlineEvaluationConfigTimeoutsArgs{
		Create: pulumi.String("string"),
		Delete: pulumi.String("string"),
		Update: pulumi.String("string"),
	},
})

resource "aws_bedrock_agentcoreonlineevaluationconfig" "agentcoreOnlineEvaluationConfigResource" {
  data_source_config = {
    cloudwatch_logs = {
      log_group_names = ["string"]
      service_names   = ["string"]
    }
  }
  enable_on_create              = false
  evaluation_execution_role_arn = "string"
  evaluators {
    evaluator_id = "string"
  }
  online_evaluation_config_name = "string"
  rule = {
    sampling_config = {
      sampling_percentage = 0
    }
    filters = [{
      "key"      = "string"
      "operator" = "string"
      "value" = {
        "booleanValue" = false
        "doubleValue"  = 0
        "stringValue"  = "string"
      }
    }]
    session_config = {
      session_timeout_minutes = 0
    }
  }
  description      = "string"
  execution_status = "string"
  region           = "string"
  tags = {
    "string" = "string"
  }
  timeouts = {
    create = "string"
    delete = "string"
    update = "string"
  }
}

var agentcoreOnlineEvaluationConfigResource = new AgentcoreOnlineEvaluationConfig("agentcoreOnlineEvaluationConfigResource", AgentcoreOnlineEvaluationConfigArgs.builder()
    .dataSourceConfig(AgentcoreOnlineEvaluationConfigDataSourceConfigArgs.builder()
        .cloudwatchLogs(AgentcoreOnlineEvaluationConfigDataSourceConfigCloudwatchLogsArgs.builder()
            .logGroupNames("string")
            .serviceNames("string")
            .build())
        .build())
    .enableOnCreate(false)
    .evaluationExecutionRoleArn("string")
    .evaluators(AgentcoreOnlineEvaluationConfigEvaluatorArgs.builder()
        .evaluatorId("string")
        .build())
    .onlineEvaluationConfigName("string")
    .rule(AgentcoreOnlineEvaluationConfigRuleArgs.builder()
        .samplingConfig(AgentcoreOnlineEvaluationConfigRuleSamplingConfigArgs.builder()
            .samplingPercentage(0.0)
            .build())
        .filters(AgentcoreOnlineEvaluationConfigRuleFilterArgs.builder()
            .key("string")
            .operator("string")
            .value(AgentcoreOnlineEvaluationConfigRuleFilterValueArgs.builder()
                .booleanValue(false)
                .doubleValue(0.0)
                .stringValue("string")
                .build())
            .build())
        .sessionConfig(AgentcoreOnlineEvaluationConfigRuleSessionConfigArgs.builder()
            .sessionTimeoutMinutes(0)
            .build())
        .build())
    .description("string")
    .executionStatus("string")
    .region("string")
    .tags(Map.of("string", "string"))
    .timeouts(AgentcoreOnlineEvaluationConfigTimeoutsArgs.builder()
        .create("string")
        .delete("string")
        .update("string")
        .build())
    .build());

agentcore_online_evaluation_config_resource = aws.bedrock.AgentcoreOnlineEvaluationConfig("agentcoreOnlineEvaluationConfigResource",
    data_source_config={
        "cloudwatch_logs": {
            "log_group_names": ["string"],
            "service_names": ["string"],
        },
    },
    enable_on_create=False,
    evaluation_execution_role_arn="string",
    evaluators=[{
        "evaluator_id": "string",
    }],
    online_evaluation_config_name="string",
    rule={
        "sampling_config": {
            "sampling_percentage": float(0),
        },
        "filters": [{
            "key": "string",
            "operator": "string",
            "value": {
                "boolean_value": False,
                "double_value": float(0),
                "string_value": "string",
            },
        }],
        "session_config": {
            "session_timeout_minutes": 0,
        },
    },
    description="string",
    execution_status="string",
    region="string",
    tags={
        "string": "string",
    },
    timeouts={
        "create": "string",
        "delete": "string",
        "update": "string",
    })

const agentcoreOnlineEvaluationConfigResource = new aws.bedrock.AgentcoreOnlineEvaluationConfig("agentcoreOnlineEvaluationConfigResource", {
    dataSourceConfig: {
        cloudwatchLogs: {
            logGroupNames: ["string"],
            serviceNames: ["string"],
        },
    },
    enableOnCreate: false,
    evaluationExecutionRoleArn: "string",
    evaluators: [{
        evaluatorId: "string",
    }],
    onlineEvaluationConfigName: "string",
    rule: {
        samplingConfig: {
            samplingPercentage: 0,
        },
        filters: [{
            key: "string",
            operator: "string",
            value: {
                booleanValue: false,
                doubleValue: 0,
                stringValue: "string",
            },
        }],
        sessionConfig: {
            sessionTimeoutMinutes: 0,
        },
    },
    description: "string",
    executionStatus: "string",
    region: "string",
    tags: {
        string: "string",
    },
    timeouts: {
        create: "string",
        "delete": "string",
        update: "string",
    },
});

type: aws:bedrock:AgentcoreOnlineEvaluationConfig
properties:
    dataSourceConfig:
        cloudwatchLogs:
            logGroupNames:
                - string
            serviceNames:
                - string
    description: string
    enableOnCreate: false
    evaluationExecutionRoleArn: string
    evaluators:
        - evaluatorId: string
    executionStatus: string
    onlineEvaluationConfigName: string
    region: string
    rule:
        filters:
            - key: string
              operator: string
              value:
                booleanValue: false
                doubleValue: 0
                stringValue: string
        samplingConfig:
            samplingPercentage: 0
        sessionConfig:
            sessionTimeoutMinutes: 0
    tags:
        string: string
    timeouts:
        create: string
        delete: string
        update: string