Conclude experiment

"""
Conclude experiment returns "The experiment was concluded and the winning variant was rolled out to its linked feature
flag allocation." response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.experiments_api import ExperimentsApi
from datadog_api_client.v2.model.experiments_conclude_experiment_v2_request import (
    ExperimentsConcludeExperimentV2Request,
)
from datadog_api_client.v2.model.experiments_conclude_experiment_v2_request_data import (
    ExperimentsConcludeExperimentV2RequestData,
)
from datadog_api_client.v2.model.experiments_conclude_experiment_v2_request_data_attributes import (
    ExperimentsConcludeExperimentV2RequestDataAttributes,
)
from datadog_api_client.v2.model.experiments_conclude_experiment_v2_request_data_type import (
    ExperimentsConcludeExperimentV2RequestDataType,
)
from uuid import UUID

body = ExperimentsConcludeExperimentV2Request(
    data=ExperimentsConcludeExperimentV2RequestData(
        attributes=ExperimentsConcludeExperimentV2RequestDataAttributes(
            decision_variant_key="treatment",
        ),
        type=ExperimentsConcludeExperimentV2RequestDataType.CONCLUDE_EXPERIMENT_REQUEST,
    ),
)

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
with ApiClient(configuration) as api_client:
    api_instance = ExperimentsApi(api_client)
    api_instance.conclude_experiment(experiment_id=UUID("550e8400-e29b-41d4-a716-446655440000"), body=body)

# Conclude experiment returns "The experiment was concluded and the winning variant was rolled out to its linked feature
# flag allocation." response

require "datadog_api_client"
DatadogAPIClient.configure do |config|
  config.access_token = ENV["DD_BEARER_TOKEN"]
end
api_instance = DatadogAPIClient::V2::ExperimentsAPI.new

body = DatadogAPIClient::V2::ExperimentsConcludeExperimentV2Request.new({
  data: DatadogAPIClient::V2::ExperimentsConcludeExperimentV2RequestData.new({
    attributes: DatadogAPIClient::V2::ExperimentsConcludeExperimentV2RequestDataAttributes.new({
      decision_variant_key: "treatment",
    }),
    type: DatadogAPIClient::V2::ExperimentsConcludeExperimentV2RequestDataType::CONCLUDE_EXPERIMENT_REQUEST,
  }),
})
api_instance.conclude_experiment("550e8400-e29b-41d4-a716-446655440000", body)

// Conclude experiment returns "The experiment was concluded and the winning variant was rolled out to its linked feature
// flag allocation." response

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
	"github.com/google/uuid"
)

func main() {
	body := datadogV2.ExperimentsConcludeExperimentV2Request{
		Data: datadogV2.ExperimentsConcludeExperimentV2RequestData{
			Attributes: datadogV2.ExperimentsConcludeExperimentV2RequestDataAttributes{
				DecisionVariantKey: "treatment",
			},
			Type: datadogV2.EXPERIMENTSCONCLUDEEXPERIMENTV2REQUESTDATATYPE_CONCLUDE_EXPERIMENT_REQUEST,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	ctx = context.WithValue(ctx, datadog.ContextAccessToken, os.Getenv("DD_BEARER_TOKEN"))
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewExperimentsApi(apiClient)
	r, err := api.ConcludeExperiment(ctx, uuid.MustParse("550e8400-e29b-41d4-a716-446655440000"), body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ExperimentsApi.ConcludeExperiment`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
}

// Conclude experiment returns "The experiment was concluded and the winning variant was rolled out
// to its linked feature
// flag allocation." response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.ExperimentsApi;
import com.datadog.api.client.v2.model.ExperimentsConcludeExperimentV2Request;
import com.datadog.api.client.v2.model.ExperimentsConcludeExperimentV2RequestData;
import com.datadog.api.client.v2.model.ExperimentsConcludeExperimentV2RequestDataAttributes;
import com.datadog.api.client.v2.model.ExperimentsConcludeExperimentV2RequestDataType;
import java.util.UUID;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    defaultClient.setAccessToken(System.getenv("DD_BEARER_TOKEN"));
    ExperimentsApi apiInstance = new ExperimentsApi(defaultClient);

    ExperimentsConcludeExperimentV2Request body =
        new ExperimentsConcludeExperimentV2Request()
            .data(
                new ExperimentsConcludeExperimentV2RequestData()
                    .attributes(
                        new ExperimentsConcludeExperimentV2RequestDataAttributes()
                            .decisionVariantKey("treatment"))
                    .type(
                        ExperimentsConcludeExperimentV2RequestDataType
                            .CONCLUDE_EXPERIMENT_REQUEST));

    try {
      apiInstance.concludeExperiment(UUID.fromString("550e8400-e29b-41d4-a716-446655440000"), body);
    } catch (ApiException e) {
      System.err.println("Exception when calling ExperimentsApi#concludeExperiment");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

// Conclude experiment returns "The experiment was concluded and the winning
// variant was rolled out to its linked feature flag allocation." response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_experiments::ExperimentsAPI;
use datadog_api_client::datadogV2::model::ExperimentsConcludeExperimentV2Request;
use datadog_api_client::datadogV2::model::ExperimentsConcludeExperimentV2RequestData;
use datadog_api_client::datadogV2::model::ExperimentsConcludeExperimentV2RequestDataAttributes;
use datadog_api_client::datadogV2::model::ExperimentsConcludeExperimentV2RequestDataType;
use uuid::Uuid;

#[tokio::main]
async fn main() {
    let body = ExperimentsConcludeExperimentV2Request::new(
        ExperimentsConcludeExperimentV2RequestData::new(
            ExperimentsConcludeExperimentV2RequestDataAttributes::new("treatment".to_string()),
            ExperimentsConcludeExperimentV2RequestDataType::CONCLUDE_EXPERIMENT_REQUEST,
        ),
    );
    let configuration = datadog::Configuration::new();
    let api = ExperimentsAPI::with_config(configuration);
    let resp = api
        .conclude_experiment(
            Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000").expect("invalid UUID"),
            body,
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}