Create backfilled maintenance

v2 (latest)

POST https://api.ap1.datadoghq.com/api/v2/statuspages/{page_id}/maintenances/backfillhttps://api.ap2.datadoghq.com/api/v2/statuspages/{page_id}/maintenances/backfillhttps://api.datadoghq.eu/api/v2/statuspages/{page_id}/maintenances/backfillhttps://api.ddog-gov.com/api/v2/statuspages/{page_id}/maintenances/backfillhttps://api.us2.ddog-gov.com/api/v2/statuspages/{page_id}/maintenances/backfillhttps://api.datadoghq.com/api/v2/statuspages/{page_id}/maintenances/backfillhttps://api.us3.datadoghq.com/api/v2/statuspages/{page_id}/maintenances/backfillhttps://api.us5.datadoghq.com/api/v2/statuspages/{page_id}/maintenances/backfill

Overview

Creates a backfilled maintenance with predefined updates. This endpoint requires the status_pages_incident_write permission.

Arguments

Path Parameters

Name

Type

Description

page_id [required]

string

The ID of the status page.

Query Strings

Name

Type

Description

include

string

Comma-separated list of resources to include. Supported values: created_by_user, last_modified_by_user, status_page.

Request

Body Data (required)

Expand All

Field

Type

Description

data

object

The data object for creating a backfilled maintenance.

{
  "data": {
    "attributes": {
      "title": "Past Database Maintenance",
      "updates": [
        {
          "components_affected": [
            {
              "id": "4e9d3726-bdd7-0079-613c-e9aaba89eb01",
              "status": "maintenance"
            }
          ],
          "description": "Database maintenance is in progress.",
          "started_at": "2021-11-11T10:11:11+00:00",
          "status": "in_progress"
        },
        {
          "components_affected": [
            {
              "id": "4e9d3726-bdd7-0079-613c-e9aaba89eb01",
              "status": "operational"
            }
          ],
          "description": "Database maintenance has been completed successfully.",
          "started_at": "2021-11-11T11:11:11+00:00",
          "status": "completed"
        }
      ]
    },
    "type": "maintenances"
  }
}

Response

Created

Response object for a single maintenance.

Expand All

Field

Type

Description

data

object

The data object for a maintenance.

included

[ <oneOf>]

The included related resources of a maintenance. Client must explicitly request these resources by name in the include query parameter.

Option 2

object

The included status page resource.

attributes

object

The attributes of a status page.

{
  "data": {
    "attributes": {
      "completed_date": "2019-09-19T10:00:00.000Z",
      "completed_description": "string",
      "components_affected": [
        {
          "id": "1234abcd-12ab-34cd-56ef-123456abcdef",
          "name": "string",
          "status": "operational"
        }
      ],
      "in_progress_description": "string",
      "is_backfilled": false,
      "modified_at": "2019-09-19T10:00:00.000Z",
      "published_date": "2019-09-19T10:00:00.000Z",
      "scheduled_description": "string",
      "start_date": "2019-09-19T10:00:00.000Z",
      "status": "string",
      "title": "string",
      "updates": [
        {
          "components_affected": [
            {
              "id": "1234abcd-12ab-34cd-56ef-123456abcdef",
              "name": "string",
              "status": "operational"
            }
          ],
          "created_at": "2019-09-19T10:00:00.000Z",
          "description": "string",
          "id": "string",
          "manual_transition": false,
          "modified_at": "2019-09-19T10:00:00.000Z",
          "started_at": "2019-09-19T10:00:00.000Z",
          "status": "string"
        }
      ]
    },
    "id": "string",
    "relationships": {
      "created_by_user": {
        "data": {
          "id": "",
          "type": "users"
        }
      },
      "last_modified_by_user": {
        "data": {
          "id": "",
          "type": "users"
        }
      },
      "status_page": {
        "data": {
          "id": "",
          "type": "status_pages"
        }
      }
    },
    "type": "maintenances"
  },
  "included": [
    {
      "attributes": {
        "email": "string",
        "handle": "string",
        "icon": "string",
        "name": "string",
        "uuid": "string"
      },
      "id": "string",
      "type": "users"
    }
  ]
}

Too many requests

API error response.

Expand All

Field

Type

Description

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Code Example

                          ## default
# 

# Path parameters
export page_id="CHANGE_ME"
# Curl command
curl -X POST "https://api.ap1.datadoghq.com"https://api.ap2.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.us2.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/statuspages/${page_id}/maintenances/backfill" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "title": "Past Database Maintenance",
      "updates": [
        {
          "components_affected": [
            {
              "id": "1234abcd-12ab-34cd-56ef-123456abcdef",
              "status": "maintenance"
            }
          ],
          "description": "Database maintenance is in progress.",
          "started_at": "2026-04-27T13:37:31Z",
          "status": "in_progress"
        },
        {
          "components_affected": [
            {
              "id": "1234abcd-12ab-34cd-56ef-123456abcdef",
              "status": "operational"
            }
          ],
          "description": "Database maintenance has been completed.",
          "started_at": "2026-04-27T14:37:31Z",
          "status": "completed"
        }
      ]
    },
    "type": "maintenances"
  }
}
EOF

                        

// Create backfilled maintenance returns "Created" response

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"
	"time"

	"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() {
	// there is a valid "status_page" in the system
	StatusPageDataAttributesComponents0Components0ID := uuid.MustParse(os.Getenv("STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID"))
	StatusPageDataID := uuid.MustParse(os.Getenv("STATUS_PAGE_DATA_ID"))

	body := datadogV2.CreateBackfilledMaintenanceRequest{
		Data: &datadogV2.CreateBackfilledMaintenanceRequestData{
			Attributes: &datadogV2.CreateBackfilledMaintenanceRequestDataAttributes{
				Title: "Past Database Maintenance",
				Updates: []datadogV2.CreateBackfilledMaintenanceRequestDataAttributesUpdatesItems{
					{
						ComponentsAffected: []datadogV2.CreateMaintenanceRequestDataAttributesComponentsAffectedItems{
							{
								Id:     StatusPageDataAttributesComponents0Components0ID,
								Status: datadogV2.PATCHMAINTENANCEREQUESTDATAATTRIBUTESCOMPONENTSAFFECTEDITEMSSTATUS_MAINTENANCE,
							},
						},
						Description: "Database maintenance is in progress.",
						StartedAt:   time.Now().Add(time.Hour * -1),
						Status:      datadogV2.CREATEMAINTENANCEREQUESTDATAATTRIBUTESUPDATESITEMSSTATUS_IN_PROGRESS,
					},
					{
						ComponentsAffected: []datadogV2.CreateMaintenanceRequestDataAttributesComponentsAffectedItems{
							{
								Id:     StatusPageDataAttributesComponents0Components0ID,
								Status: datadogV2.PATCHMAINTENANCEREQUESTDATAATTRIBUTESCOMPONENTSAFFECTEDITEMSSTATUS_OPERATIONAL,
							},
						},
						Description: "Database maintenance has been completed successfully.",
						StartedAt:   time.Now(),
						Status:      datadogV2.CREATEMAINTENANCEREQUESTDATAATTRIBUTESUPDATESITEMSSTATUS_COMPLETED,
					},
				},
			},
			Type: datadogV2.PATCHMAINTENANCEREQUESTDATATYPE_MAINTENANCES,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewStatusPagesApi(apiClient)
	resp, r, err := api.CreateBackfilledMaintenance(ctx, StatusPageDataID, body, *datadogV2.NewCreateBackfilledMaintenanceOptionalParameters())

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

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `StatusPagesApi.CreateBackfilledMaintenance`:\n%s\n", responseContent)
}

Instructions

First install the library and its dependencies and then save the example to main.go and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" go run "main.go"

// Create backfilled maintenance returns "Created" response
import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.StatusPagesApi;
import com.datadog.api.client.v2.model.CreateBackfilledMaintenanceRequest;
import com.datadog.api.client.v2.model.CreateBackfilledMaintenanceRequestData;
import com.datadog.api.client.v2.model.CreateBackfilledMaintenanceRequestDataAttributes;
import com.datadog.api.client.v2.model.CreateBackfilledMaintenanceRequestDataAttributesUpdatesItems;
import com.datadog.api.client.v2.model.CreateMaintenanceRequestDataAttributesComponentsAffectedItems;
import com.datadog.api.client.v2.model.CreateMaintenanceRequestDataAttributesUpdatesItemsStatus;
import com.datadog.api.client.v2.model.Maintenance;
import com.datadog.api.client.v2.model.PatchMaintenanceRequestDataAttributesComponentsAffectedItemsStatus;
import com.datadog.api.client.v2.model.PatchMaintenanceRequestDataType;
import java.time.OffsetDateTime;
import java.util.Arrays;
import java.util.Collections;
import java.util.UUID;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    StatusPagesApi apiInstance = new StatusPagesApi(defaultClient);

    // there is a valid "status_page" in the system
    UUID STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID = null;
    try {
      STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID =
          UUID.fromString(
              System.getenv("STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID"));
    } catch (IllegalArgumentException e) {
      System.err.println("Error parsing UUID: " + e.getMessage());
    }
    UUID STATUS_PAGE_DATA_ID = null;
    try {
      STATUS_PAGE_DATA_ID = UUID.fromString(System.getenv("STATUS_PAGE_DATA_ID"));
    } catch (IllegalArgumentException e) {
      System.err.println("Error parsing UUID: " + e.getMessage());
    }

    CreateBackfilledMaintenanceRequest body =
        new CreateBackfilledMaintenanceRequest()
            .data(
                new CreateBackfilledMaintenanceRequestData()
                    .attributes(
                        new CreateBackfilledMaintenanceRequestDataAttributes()
                            .title("Past Database Maintenance")
                            .updates(
                                Arrays.asList(
                                    new CreateBackfilledMaintenanceRequestDataAttributesUpdatesItems()
                                        .componentsAffected(
                                            Collections.singletonList(
                                                new CreateMaintenanceRequestDataAttributesComponentsAffectedItems()
                                                    .id(
                                                        STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID)
                                                    .status(
                                                        PatchMaintenanceRequestDataAttributesComponentsAffectedItemsStatus
                                                            .MAINTENANCE)))
                                        .description("Database maintenance is in progress.")
                                        .startedAt(OffsetDateTime.now().plusHours(-1))
                                        .status(
                                            CreateMaintenanceRequestDataAttributesUpdatesItemsStatus
                                                .IN_PROGRESS),
                                    new CreateBackfilledMaintenanceRequestDataAttributesUpdatesItems()
                                        .componentsAffected(
                                            Collections.singletonList(
                                                new CreateMaintenanceRequestDataAttributesComponentsAffectedItems()
                                                    .id(
                                                        STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID)
                                                    .status(
                                                        PatchMaintenanceRequestDataAttributesComponentsAffectedItemsStatus
                                                            .OPERATIONAL)))
                                        .description(
                                            "Database maintenance has been completed successfully.")
                                        .startedAt(OffsetDateTime.now())
                                        .status(
                                            CreateMaintenanceRequestDataAttributesUpdatesItemsStatus
                                                .COMPLETED))))
                    .type(PatchMaintenanceRequestDataType.MAINTENANCES));

    try {
      Maintenance result = apiInstance.createBackfilledMaintenance(STATUS_PAGE_DATA_ID, body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling StatusPagesApi#createBackfilledMaintenance");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

Instructions

First install the library and its dependencies and then save the example to Example.java and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" java "Example.java"

"""
Create backfilled maintenance returns "Created" response
"""

from datetime import datetime
from dateutil.relativedelta import relativedelta
from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.status_pages_api import StatusPagesApi
from datadog_api_client.v2.model.create_backfilled_maintenance_request import CreateBackfilledMaintenanceRequest
from datadog_api_client.v2.model.create_backfilled_maintenance_request_data import (
    CreateBackfilledMaintenanceRequestData,
)
from datadog_api_client.v2.model.create_backfilled_maintenance_request_data_attributes import (
    CreateBackfilledMaintenanceRequestDataAttributes,
)
from datadog_api_client.v2.model.create_backfilled_maintenance_request_data_attributes_updates_items import (
    CreateBackfilledMaintenanceRequestDataAttributesUpdatesItems,
)
from datadog_api_client.v2.model.create_maintenance_request_data_attributes_components_affected_items import (
    CreateMaintenanceRequestDataAttributesComponentsAffectedItems,
)
from datadog_api_client.v2.model.create_maintenance_request_data_attributes_updates_items_status import (
    CreateMaintenanceRequestDataAttributesUpdatesItemsStatus,
)
from datadog_api_client.v2.model.patch_maintenance_request_data_attributes_components_affected_items_status import (
    PatchMaintenanceRequestDataAttributesComponentsAffectedItemsStatus,
)
from datadog_api_client.v2.model.patch_maintenance_request_data_type import PatchMaintenanceRequestDataType

# there is a valid "status_page" in the system
STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID = environ[
    "STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID"
]
STATUS_PAGE_DATA_ID = environ["STATUS_PAGE_DATA_ID"]

body = CreateBackfilledMaintenanceRequest(
    data=CreateBackfilledMaintenanceRequestData(
        attributes=CreateBackfilledMaintenanceRequestDataAttributes(
            title="Past Database Maintenance",
            updates=[
                CreateBackfilledMaintenanceRequestDataAttributesUpdatesItems(
                    components_affected=[
                        CreateMaintenanceRequestDataAttributesComponentsAffectedItems(
                            id=STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID,
                            status=PatchMaintenanceRequestDataAttributesComponentsAffectedItemsStatus.MAINTENANCE,
                        ),
                    ],
                    description="Database maintenance is in progress.",
                    started_at=(datetime.now() + relativedelta(hours=-1)),
                    status=CreateMaintenanceRequestDataAttributesUpdatesItemsStatus.IN_PROGRESS,
                ),
                CreateBackfilledMaintenanceRequestDataAttributesUpdatesItems(
                    components_affected=[
                        CreateMaintenanceRequestDataAttributesComponentsAffectedItems(
                            id=STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID,
                            status=PatchMaintenanceRequestDataAttributesComponentsAffectedItemsStatus.OPERATIONAL,
                        ),
                    ],
                    description="Database maintenance has been completed successfully.",
                    started_at=datetime.now(),
                    status=CreateMaintenanceRequestDataAttributesUpdatesItemsStatus.COMPLETED,
                ),
            ],
        ),
        type=PatchMaintenanceRequestDataType.MAINTENANCES,
    ),
)

configuration = Configuration()
with ApiClient(configuration) as api_client:
    api_instance = StatusPagesApi(api_client)
    response = api_instance.create_backfilled_maintenance(page_id=STATUS_PAGE_DATA_ID, body=body)

    print(response)

Instructions

First install the library and its dependencies and then save the example to example.py and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" python3 "example.py"

# Create backfilled maintenance returns "Created" response

require "datadog_api_client"
api_instance = DatadogAPIClient::V2::StatusPagesAPI.new

# there is a valid "status_page" in the system
STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID = ENV["STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID"]
STATUS_PAGE_DATA_ID = ENV["STATUS_PAGE_DATA_ID"]

body = DatadogAPIClient::V2::CreateBackfilledMaintenanceRequest.new({
  data: DatadogAPIClient::V2::CreateBackfilledMaintenanceRequestData.new({
    attributes: DatadogAPIClient::V2::CreateBackfilledMaintenanceRequestDataAttributes.new({
      title: "Past Database Maintenance",
      updates: [
        DatadogAPIClient::V2::CreateBackfilledMaintenanceRequestDataAttributesUpdatesItems.new({
          components_affected: [
            DatadogAPIClient::V2::CreateMaintenanceRequestDataAttributesComponentsAffectedItems.new({
              id: STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID,
              status: DatadogAPIClient::V2::PatchMaintenanceRequestDataAttributesComponentsAffectedItemsStatus::MAINTENANCE,
            }),
          ],
          description: "Database maintenance is in progress.",
          started_at: (Time.now + -1 * 3600),
          status: DatadogAPIClient::V2::CreateMaintenanceRequestDataAttributesUpdatesItemsStatus::IN_PROGRESS,
        }),
        DatadogAPIClient::V2::CreateBackfilledMaintenanceRequestDataAttributesUpdatesItems.new({
          components_affected: [
            DatadogAPIClient::V2::CreateMaintenanceRequestDataAttributesComponentsAffectedItems.new({
              id: STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID,
              status: DatadogAPIClient::V2::PatchMaintenanceRequestDataAttributesComponentsAffectedItemsStatus::OPERATIONAL,
            }),
          ],
          description: "Database maintenance has been completed successfully.",
          started_at: Time.now,
          status: DatadogAPIClient::V2::CreateMaintenanceRequestDataAttributesUpdatesItemsStatus::COMPLETED,
        }),
      ],
    }),
    type: DatadogAPIClient::V2::PatchMaintenanceRequestDataType::MAINTENANCES,
  }),
})
p api_instance.create_backfilled_maintenance(STATUS_PAGE_DATA_ID, body)

Instructions

First install the library and its dependencies and then save the example to example.rb and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" rb "example.rb"

// Create backfilled maintenance returns "Created" response
use chrono::{DateTime, Utc};
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_status_pages::CreateBackfilledMaintenanceOptionalParams;
use datadog_api_client::datadogV2::api_status_pages::StatusPagesAPI;
use datadog_api_client::datadogV2::model::CreateBackfilledMaintenanceRequest;
use datadog_api_client::datadogV2::model::CreateBackfilledMaintenanceRequestData;
use datadog_api_client::datadogV2::model::CreateBackfilledMaintenanceRequestDataAttributes;
use datadog_api_client::datadogV2::model::CreateBackfilledMaintenanceRequestDataAttributesUpdatesItems;
use datadog_api_client::datadogV2::model::CreateMaintenanceRequestDataAttributesComponentsAffectedItems;
use datadog_api_client::datadogV2::model::CreateMaintenanceRequestDataAttributesUpdatesItemsStatus;
use datadog_api_client::datadogV2::model::PatchMaintenanceRequestDataAttributesComponentsAffectedItemsStatus;
use datadog_api_client::datadogV2::model::PatchMaintenanceRequestDataType;

#[tokio::main]
async fn main() {
    // there is a valid "status_page" in the system
    let status_page_data_attributes_components_0_components_0_id = uuid::Uuid::parse_str(
        &std::env::var("STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID").unwrap(),
    )
    .expect("Invalid UUID");
    let status_page_data_id = uuid::Uuid::parse_str(&std::env::var("STATUS_PAGE_DATA_ID").unwrap())
        .expect("Invalid UUID");
    let body =
        CreateBackfilledMaintenanceRequest
        ::new().data(
            CreateBackfilledMaintenanceRequestData::new(
                PatchMaintenanceRequestDataType::MAINTENANCES,
            ).attributes(
                CreateBackfilledMaintenanceRequestDataAttributes::new(
                    "Past Database Maintenance".to_string(),
                    vec![
                        CreateBackfilledMaintenanceRequestDataAttributesUpdatesItems::new(
                            vec![
                                CreateMaintenanceRequestDataAttributesComponentsAffectedItems::new(
                                    status_page_data_attributes_components_0_components_0_id.clone(),
                                    PatchMaintenanceRequestDataAttributesComponentsAffectedItemsStatus::MAINTENANCE,
                                )
                            ],
                            "Database maintenance is in progress.".to_string(),
                            DateTime::parse_from_rfc3339("2021-11-11T10:11:11+00:00")
                                .expect("Failed to parse datetime")
                                .with_timezone(&Utc),
                            CreateMaintenanceRequestDataAttributesUpdatesItemsStatus::IN_PROGRESS,
                        ),
                        CreateBackfilledMaintenanceRequestDataAttributesUpdatesItems::new(
                            vec![
                                CreateMaintenanceRequestDataAttributesComponentsAffectedItems::new(
                                    status_page_data_attributes_components_0_components_0_id.clone(),
                                    PatchMaintenanceRequestDataAttributesComponentsAffectedItemsStatus::OPERATIONAL,
                                )
                            ],
                            "Database maintenance has been completed successfully.".to_string(),
                            DateTime::parse_from_rfc3339("2021-11-11T11:11:11+00:00")
                                .expect("Failed to parse datetime")
                                .with_timezone(&Utc),
                            CreateMaintenanceRequestDataAttributesUpdatesItemsStatus::COMPLETED,
                        )
                    ],
                ),
            ),
        );
    let configuration = datadog::Configuration::new();
    let api = StatusPagesAPI::with_config(configuration);
    let resp = api
        .create_backfilled_maintenance(
            status_page_data_id.clone(),
            body,
            CreateBackfilledMaintenanceOptionalParams::default(),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

Instructions

First install the library and its dependencies and then save the example to src/main.rs and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

/**
 * Create backfilled maintenance returns "Created" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration();
const apiInstance = new v2.StatusPagesApi(configuration);

// there is a valid "status_page" in the system
const STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID = process.env
  .STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID as string;
const STATUS_PAGE_DATA_ID = process.env.STATUS_PAGE_DATA_ID as string;

const params: v2.StatusPagesApiCreateBackfilledMaintenanceRequest = {
  body: {
    data: {
      attributes: {
        title: "Past Database Maintenance",
        updates: [
          {
            componentsAffected: [
              {
                id: STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID,
                status: "maintenance",
              },
            ],
            description: "Database maintenance is in progress.",
            startedAt: new Date(new Date().getTime() + -1 * 3600 * 1000),
            status: "in_progress",
          },
          {
            componentsAffected: [
              {
                id: STATUS_PAGE_DATA_ATTRIBUTES_COMPONENTS_0_COMPONENTS_0_ID,
                status: "operational",
              },
            ],
            description:
              "Database maintenance has been completed successfully.",
            startedAt: new Date(),
            status: "completed",
          },
        ],
      },
      type: "maintenances",
    },
  },
  pageId: STATUS_PAGE_DATA_ID,
};

apiInstance
  .createBackfilledMaintenance(params)
  .then((data: v2.Maintenance) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));

Instructions

First install the library and its dependencies and then save the example to example.ts and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" tsc "example.ts"

Create backfilled maintenance

Overview

Arguments

Path Parameters

Query Strings

Request

Body Data (required)

Response

Code Example

Create backfilled maintenance returns "Created" response

Create backfilled maintenance returns "Created" response

Instructions

Create backfilled maintenance returns "Created" response

Instructions

Create backfilled maintenance returns "Created" response

Instructions

Create backfilled maintenance returns "Created" response

Instructions

Create backfilled maintenance returns "Created" response

Instructions

Create backfilled maintenance returns "Created" response

Instructions

How can I help you today?