@prismatic-io/components-datadog 0.0.0-stage → 0.0.1

package/npm-dist/index.cjs

@@ -0,0 +1,1003 @@
+let _prismatic_io_spectral = require("@prismatic-io/spectral");
+let _prismatic_io_spectral_http = require("@prismatic-io/spectral/http");
+//#region src/constants.ts
+const DATADOG_SITES = [
+	{
+		label: "US1 (datadoghq.com)",
+		value: "https://api.datadoghq.com"
+	},
+	{
+		label: "US3 (us3.datadoghq.com)",
+		value: "https://api.us3.datadoghq.com"
+	},
+	{
+		label: "US5 (us5.datadoghq.com)",
+		value: "https://api.us5.datadoghq.com"
+	},
+	{
+		label: "EU (datadoghq.eu)",
+		value: "https://api.datadoghq.eu"
+	},
+	{
+		label: "AP1 (ap1.datadoghq.com)",
+		value: "https://api.ap1.datadoghq.com"
+	},
+	{
+		label: "AP2 (ap2.datadoghq.com)",
+		value: "https://api.ap2.datadoghq.com"
+	},
+	{
+		label: "US1-FED (ddog-gov.com)",
+		value: "https://api.ddog-gov.com"
+	}
+];
+const DEFAULT_DATADOG_SITE = DATADOG_SITES[0].value;
+const METRIC_TYPE_OPTIONS = [
+	{
+		label: "Unspecified",
+		value: "0"
+	},
+	{
+		label: "Count",
+		value: "1"
+	},
+	{
+		label: "Rate",
+		value: "2"
+	},
+	{
+		label: "Gauge",
+		value: "3"
+	}
+];
+const WEBHOOK_ENCODE_AS_OPTIONS = [{
+	label: "JSON",
+	value: "json"
+}, {
+	label: "Form",
+	value: "form"
+}];
+const DEFAULT_WEBHOOK_ENCODE_AS = "json";
+const WEBHOOK_STATE_KEY_PREFIX = "datadogWebhook";
+const WEBHOOKS_CONFIGURATION_PATH = "/api/v1/integration/webhooks/configuration/webhooks";
+const SUBMIT_METRICS_PATH = "/api/v2/series";
+const SEARCH_METRICS_PATH = "/api/v1/search";
+const METRICS_QUERY_PREFIX = "metrics:";
+//#endregion
+//#region src/connections/apiKey.ts
+const apiKeyConnection = (0, _prismatic_io_spectral.connection)({
+	key: "apiKey",
+	display: {
+		label: "API Key + Application Key",
+		description: "Authenticate using a Datadog API Key and Application Key. The API Key authenticates the organization, and the Application Key authorizes management operations."
+	},
+	inputs: {
+		datadogSite: {
+			label: "Datadog Site",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "Select the Datadog site that matches the organization. This determines the API base URL.",
+			default: DEFAULT_DATADOG_SITE,
+			model: DATADOG_SITES
+		},
+		apiKey: {
+			label: "API Key",
+			placeholder: "Enter Datadog API Key",
+			type: "password",
+			required: true,
+			shown: true,
+			comments: "The Datadog API Key. Create one at Organization Settings > API Keys in Datadog.",
+			example: "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6"
+		},
+		applicationKey: {
+			label: "Application Key",
+			placeholder: "Enter Datadog Application Key",
+			type: "password",
+			required: true,
+			shown: true,
+			comments: "The Datadog Application Key. Required for management and read endpoints. Create one at Organization Settings > Application Keys in Datadog.",
+			example: "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0"
+		}
+	}
+});
+//#endregion
+//#region src/connections/oauth2.ts
+const oauth2AuthorizationCode = (0, _prismatic_io_spectral.oauth2Connection)({
+	key: "oauth2",
+	display: {
+		label: "OAuth 2.0 Authorization Code",
+		description: "Authenticate using OAuth 2.0 Authorization Code flow. Primarily used for Datadog integration partners and marketplace apps."
+	},
+	oauth2Type: _prismatic_io_spectral.OAuth2Type.AuthorizationCode,
+	inputs: {
+		datadogSite: {
+			label: "Datadog Site",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "Select the Datadog site that matches the organization. This determines the API base URL.",
+			default: DEFAULT_DATADOG_SITE,
+			model: DATADOG_SITES
+		},
+		authorizeUrl: {
+			label: "Authorize URL",
+			placeholder: "Enter Authorize URL",
+			type: "string",
+			required: false,
+			shown: false,
+			comments: "The Datadog OAuth 2.0 authorization endpoint.",
+			default: "https://app.datadoghq.com/oauth2/v1/authorize"
+		},
+		tokenUrl: {
+			label: "Token URL",
+			placeholder: "Enter Token URL",
+			type: "string",
+			required: false,
+			shown: false,
+			comments: "The Datadog OAuth 2.0 token endpoint.",
+			default: "https://api.datadoghq.com/oauth2/v1/token"
+		},
+		revokeUrl: {
+			label: "Revoke URL",
+			placeholder: "Enter Revoke URL",
+			type: "string",
+			required: false,
+			shown: false,
+			comments: "The Datadog OAuth 2.0 token revocation endpoint.",
+			default: "https://api.datadoghq.com/oauth2/v1/revoke"
+		},
+		scopes: {
+			label: "Scopes",
+			placeholder: "Enter scopes",
+			type: "string",
+			required: false,
+			shown: false,
+			comments: "Space-separated OAuth 2.0 scopes. Available scopes include: metrics_read, timeseries_query, metric_tags_manage, create_webhooks.",
+			default: "metrics_read timeseries_query metric_tags_manage create_webhooks"
+		},
+		clientId: {
+			label: "Client ID",
+			placeholder: "Enter Client ID",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "The Client ID from the Datadog OAuth application."
+		},
+		clientSecret: {
+			label: "Client Secret",
+			placeholder: "Enter Client Secret",
+			type: "password",
+			required: true,
+			shown: true,
+			comments: "The Client Secret from the Datadog OAuth application."
+		}
+	}
+});
+//#endregion
+//#region src/connections/index.ts
+var connections_default = [apiKeyConnection, oauth2AuthorizationCode];
+//#endregion
+//#region src/utils/clean.ts
+const toOptionalString = (value) => value ? _prismatic_io_spectral.util.types.toString(value) : void 0;
+const toOptionalNumber = (value) => value ? _prismatic_io_spectral.util.types.toNumber(value) : void 0;
+const toRequiredNumber = (label) => (value) => {
+	if (value === void 0 || value === null || typeof value === "string" && value.trim() === "") throw new Error(`${label} is required and must be a number.`);
+	return _prismatic_io_spectral.util.types.toNumber(value);
+};
+const toMetricSeries = (value) => {
+	const series = _prismatic_io_spectral.util.types.toObject(value);
+	if (!Array.isArray(series)) throw new Error("Metric Series must be a JSON array of metric series.");
+	return series;
+};
+const toOptionalMetricIntakeType = (value) => value ? _prismatic_io_spectral.util.types.toNumber(value) : void 0;
+const toStringList = (value) => value;
+//#endregion
+//#region src/utils/connection.ts
+const validateConnection = (connection) => {
+	if (![apiKeyConnection.key, oauth2AuthorizationCode.key].includes(connection.key)) throw new _prismatic_io_spectral.ConnectionError(connection, `Received unexpected connection type: ${connection.key}`);
+};
+//#endregion
+//#region src/utils/webhook.ts
+const webhookConfigurationPath = (webhookName) => `${WEBHOOKS_CONFIGURATION_PATH}/${encodeURIComponent(webhookName)}`;
+const isNotFoundError = (error) => error?.response?.status === 404;
+const findWebhook = async (client, webhookName) => {
+	try {
+		const { data } = await client.get(webhookConfigurationPath(webhookName));
+		return data;
+	} catch (error) {
+		if (isNotFoundError(error)) return void 0;
+		throw error;
+	}
+};
+const deleteOwnedWebhook = async (client, logger, webhookName, webhookUrl) => {
+	if (!webhookUrl) {
+		logger.warn(`Skipped deleting Datadog webhook "${webhookName}": the URL of this flow is unknown.`);
+		return;
+	}
+	const existing = await findWebhook(client, webhookName);
+	if (!existing) return;
+	if (existing.url !== webhookUrl) {
+		logger.warn(`Skipped deleting Datadog webhook "${webhookName}": it points to a different URL.`);
+		return;
+	}
+	await client.delete(webhookConfigurationPath(webhookName));
+	logger.info(`Deleted Datadog webhook "${webhookName}".`);
+};
+//#endregion
+//#region src/client.ts
+const getBaseUrl = (connection) => {
+	return _prismatic_io_spectral.util.types.toString(connection.fields.datadogSite);
+};
+const getAuthHeaders = (connection) => {
+	if (connection.key === apiKeyConnection.key) return {
+		"DD-API-KEY": _prismatic_io_spectral.util.types.toString(connection.fields.apiKey),
+		"DD-APPLICATION-KEY": _prismatic_io_spectral.util.types.toString(connection.fields.applicationKey)
+	};
+	return { Authorization: `Bearer ${_prismatic_io_spectral.util.types.toString(connection.token?.access_token)}` };
+};
+const createClient = (connection) => {
+	validateConnection(connection);
+	return (0, _prismatic_io_spectral_http.createClient)({
+		baseUrl: getBaseUrl(connection),
+		responseType: "json",
+		headers: {
+			...getAuthHeaders(connection),
+			Accept: "application/json",
+			"Content-Type": "application/json"
+		},
+		debug: false
+	});
+};
+//#endregion
+//#region src/examplePayloads.ts
+const submitMetricsExamplePayload = { data: { errors: [] } };
+const submitSingleMetricExamplePayload = submitMetricsExamplePayload;
+const listMetricsExamplePayload = { data: {
+	metrics: [
+		"system.cpu.idle",
+		"system.cpu.user",
+		"system.disk.free",
+		"system.load.1",
+		"system.mem.free"
+	],
+	from: "1636629071"
+} };
+const searchMetricsExamplePayload = { data: { results: { metrics: [
+	"system.cpu.idle",
+	"system.cpu.iowait",
+	"system.cpu.system",
+	"system.cpu.user"
+] } } };
+const getWebhookExamplePayload = { data: {
+	name: "datadog-alert-webhook",
+	url: "https://example.com/webhook",
+	custom_headers: null,
+	encode_as: "json",
+	payload: null
+} };
+const createWebhookExamplePayload = getWebhookExamplePayload;
+const updateWebhookExamplePayload = getWebhookExamplePayload;
+const deleteWebhookExamplePayload = { data: null };
+const selectMetricExamplePayload = { result: [
+	{
+		label: "system.cpu.idle",
+		key: "system.cpu.idle"
+	},
+	{
+		label: "system.cpu.user",
+		key: "system.cpu.user"
+	},
+	{
+		label: "system.disk.free",
+		key: "system.disk.free"
+	},
+	{
+		label: "system.load.1",
+		key: "system.load.1"
+	}
+] };
+const webhookExamplePayload = { payload: {
+	headers: { "Content-Type": "application/json" },
+	queryParameters: {},
+	rawBody: {
+		data: "{\"ALERT_ID\":\"12345678\",\"ALERT_METRIC\":\"system.load.1\",\"ALERT_QUERY\":\"avg(last_5m):avg:system.load.1{host:my-host} > 5\",\"ALERT_SCOPE\":\"host:my-host\",\"ALERT_STATUS\":\"Triggered\",\"ALERT_TITLE\":\"CPU load is high on my-host\",\"ALERT_TRANSITION\":\"Triggered\",\"ALERT_TYPE\":\"metric alert\",\"DATE\":\"2024-01-15 10:30:00 UTC\",\"EVENT_MSG\":\"CPU load exceeded threshold\",\"HOSTNAME\":\"my-host\",\"ID\":\"12345678\",\"LAST_UPDATED\":\"2024-01-15 10:30:00 UTC\",\"LINK\":\"https://app.datadoghq.com/monitors/12345678\",\"ORG_ID\":\"123456\",\"ORG_NAME\":\"My Organization\",\"TAGS\":\"environment:production,region:us-east-1\"}",
+		contentType: "application/json"
+	},
+	body: {
+		data: {
+			ALERT_ID: "12345678",
+			ALERT_METRIC: "system.load.1",
+			ALERT_QUERY: "avg(last_5m):avg:system.load.1{host:my-host} > 5",
+			ALERT_SCOPE: "host:my-host",
+			ALERT_STATUS: "Triggered",
+			ALERT_TITLE: "CPU load is high on my-host",
+			ALERT_TRANSITION: "Triggered",
+			ALERT_TYPE: "metric alert",
+			DATE: "2024-01-15 10:30:00 UTC",
+			EVENT_MSG: "CPU load exceeded threshold",
+			HOSTNAME: "my-host",
+			ID: "12345678",
+			LAST_UPDATED: "2024-01-15 10:30:00 UTC",
+			LINK: "https://app.datadoghq.com/monitors/12345678",
+			ORG_ID: "123456",
+			ORG_NAME: "My Organization",
+			TAGS: "environment:production,region:us-east-1"
+		},
+		contentType: "application/json"
+	},
+	pathFragment: "",
+	webhookUrls: {},
+	webhookApiKeys: {},
+	invokeUrl: "",
+	executionId: "RXhhbXBsZUV4ZWN1dGlvblJlc3VsdElk",
+	customer: {
+		id: "testCustomerId",
+		name: "Test Customer",
+		externalId: "testExternalId"
+	},
+	instance: {
+		id: "testInstanceId",
+		name: "Test Instance"
+	},
+	user: {
+		id: "testUserId",
+		email: "user@example.com",
+		name: "Test User",
+		externalId: "testUserExternalId"
+	},
+	integration: {
+		id: "testIntegrationId",
+		name: "Test Integration",
+		versionSequenceId: "1",
+		externalVersion: ""
+	},
+	flow: {
+		id: "testFlowId",
+		name: "Test Flow",
+		stableId: "testFlowStableId"
+	},
+	startedAt: "2024-01-15T00:00:00.000Z",
+	globalDebug: false
+} };
+//#endregion
+//#region src/inputs/common.ts
+const connection = (0, _prismatic_io_spectral.input)({
+	label: "Connection",
+	type: "connection",
+	required: true,
+	comments: "The Datadog connection to use for authentication."
+});
+//#endregion
+//#region src/inputs/dataSources.ts
+const selectMetricInputs = { connection };
+//#endregion
+//#region src/inputs/metrics.ts
+const metricName = (0, _prismatic_io_spectral.input)({
+	label: "Metric Name",
+	type: "string",
+	required: true,
+	placeholder: "Enter metric name",
+	comments: "The name of the timeseries metric (e.g., system.load.1, custom.my_metric).",
+	example: "system.load.1",
+	dataSource: "selectMetric",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const metricSeries = (0, _prismatic_io_spectral.input)({
+	label: "Metric Series",
+	type: "code",
+	required: true,
+	language: "json",
+	placeholder: "Enter metric series as a JSON array",
+	comments: "JSON array of metric series to submit. Each series must include \"metric\" (name) and \"points\" (array of {timestamp, value}). Optional fields: type, interval, unit, tags, resources.",
+	example: JSON.stringify([{
+		metric: "system.load.1",
+		type: 3,
+		points: [{
+			timestamp: 1636629071,
+			value: .7
+		}],
+		resources: [{
+			name: "dummyhost",
+			type: "host"
+		}],
+		tags: ["environment:production"]
+	}], null, 2),
+	clean: toMetricSeries
+});
+const metricType = (0, _prismatic_io_spectral.input)({
+	label: "Type",
+	type: "string",
+	required: false,
+	model: METRIC_TYPE_OPTIONS,
+	comments: "The type of metric. Gauge is the default if unspecified. Count and Rate types require an interval.",
+	clean: toOptionalMetricIntakeType
+});
+const metricValue = (0, _prismatic_io_spectral.input)({
+	label: "Value",
+	type: "string",
+	required: true,
+	placeholder: "Enter metric value",
+	comments: "The numeric value for the metric data point (64-bit float).",
+	example: "0.7",
+	clean: toRequiredNumber("Value")
+});
+const metricTimestamp = (0, _prismatic_io_spectral.input)({
+	label: "Timestamp",
+	type: "string",
+	required: false,
+	placeholder: "Enter Unix timestamp in seconds",
+	comments: "Unix timestamp in seconds. Defaults to the current time if not provided. Must be within 10 minutes in the future or 1 hour in the past.",
+	example: "1636629071",
+	clean: toOptionalNumber
+});
+const metricTags = (0, _prismatic_io_spectral.input)({
+	label: "Tags",
+	type: "string",
+	required: false,
+	collection: "valuelist",
+	placeholder: "Enter tag",
+	comments: "Tags associated with the metric. Each tag is a string in \"key:value\" format.",
+	example: "environment:production",
+	clean: toStringList
+});
+const metricUnit = (0, _prismatic_io_spectral.input)({
+	label: "Unit",
+	type: "string",
+	required: false,
+	placeholder: "Enter metric unit",
+	comments: "The unit of the metric value (e.g., byte, second, request).",
+	example: "byte",
+	clean: toOptionalString
+});
+const metricInterval = (0, _prismatic_io_spectral.input)({
+	label: "Interval",
+	type: "string",
+	required: false,
+	placeholder: "Enter interval in seconds",
+	comments: "The interval in seconds. Required if the metric type is rate or count.",
+	example: "60",
+	clean: toOptionalNumber
+});
+const resourceName = (0, _prismatic_io_spectral.input)({
+	label: "Resource Name",
+	type: "string",
+	required: false,
+	placeholder: "Enter resource name",
+	comments: "The name of the resource to associate with this metric (e.g., hostname).",
+	example: "my-host",
+	clean: toOptionalString
+});
+const resourceType = (0, _prismatic_io_spectral.input)({
+	label: "Resource Type",
+	type: "string",
+	required: false,
+	placeholder: "Enter resource type",
+	comments: "The type of resource (e.g., \"host\").",
+	example: "host",
+	clean: toOptionalString
+});
+const metricsFrom = (0, _prismatic_io_spectral.input)({
+	label: "From",
+	type: "string",
+	required: true,
+	placeholder: "Enter Unix timestamp in seconds",
+	comments: "Unix timestamp (seconds) from which to list active metrics. Metrics reported after this time are returned.",
+	example: "1636629071",
+	clean: toRequiredNumber("From")
+});
+const metricsHost = (0, _prismatic_io_spectral.input)({
+	label: "Host",
+	type: "string",
+	required: false,
+	placeholder: "Enter hostname to filter by",
+	comments: "Hostname to filter the list of active metrics. Only metrics reported by this host are returned.",
+	example: "my-host",
+	clean: toOptionalString
+});
+const metricsTagFilter = (0, _prismatic_io_spectral.input)({
+	label: "Tag Filter",
+	type: "string",
+	required: false,
+	placeholder: "Enter tag filter expression",
+	comments: "Filter metrics by tag. Supports boolean expressions (e.g., \"env:production AND role:web\").",
+	example: "env:production",
+	clean: toOptionalString
+});
+const metricsQuery = (0, _prismatic_io_spectral.input)({
+	label: "Query",
+	type: "string",
+	required: true,
+	placeholder: "Enter metric name search query",
+	comments: "Search query to find metrics by name prefix. The \"metrics:\" prefix is added automatically.",
+	example: "system.cpu",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const submitMetricsInputs = {
+	connection,
+	metricSeries
+};
+const submitSingleMetricInputs = {
+	connection,
+	metricName,
+	metricValue,
+	metricTimestamp,
+	metricTags,
+	metricFields: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Metric Fields",
+		comments: "Optional metric configuration and resource details.",
+		inputs: {
+			metricType,
+			metricUnit,
+			metricInterval,
+			resourceName,
+			resourceType
+		}
+	})
+};
+const listMetricsInputs = {
+	connection,
+	metricsFrom,
+	metricsHost,
+	metricsTagFilter
+};
+const searchMetricsInputs = {
+	connection,
+	metricsQuery
+};
+//#endregion
+//#region src/inputs/misc.ts
+const rawRequestInputs = {
+	connection,
+	..._prismatic_io_spectral_http.inputs,
+	url: {
+		..._prismatic_io_spectral_http.inputs.url,
+		comments: "The URL path to send the request to. The base URL is determined by the Datadog Site configured in the connection. For example, to call the Submit Metrics endpoint, enter /api/v2/series.",
+		example: "/api/v2/series"
+	}
+};
+//#endregion
+//#region src/inputs/webhooks.ts
+const webhookName = (0, _prismatic_io_spectral.input)({
+	label: "Webhook Name",
+	type: "string",
+	required: true,
+	placeholder: "Enter webhook name",
+	comments: "The name of the webhook. Used in Datadog monitor notifications as @webhook-NAME.",
+	example: "my-integration-webhook",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const webhookUrl = (0, _prismatic_io_spectral.input)({
+	label: "Webhook URL",
+	type: "string",
+	required: true,
+	placeholder: "Enter webhook URL",
+	comments: "The URL of the webhook endpoint that will receive the data.",
+	example: "https://hooks.example.com/datadog",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const webhookCustomHeaders = (0, _prismatic_io_spectral.input)({
+	label: "Custom Headers",
+	type: "code",
+	required: false,
+	language: "json",
+	placeholder: "Enter custom headers as JSON",
+	comments: "Custom headers to attach to webhook requests as a JSON string. Useful for authentication headers.",
+	example: "{\"Authorization\": \"Bearer my-token\"}",
+	clean: toOptionalString
+});
+const webhookEncodeAs = (0, _prismatic_io_spectral.input)({
+	label: "Encode As",
+	type: "string",
+	required: false,
+	model: WEBHOOK_ENCODE_AS_OPTIONS,
+	comments: "Encoding type for the webhook payload. Defaults to \"json\".",
+	clean: toOptionalString
+});
+const webhookPayload = (0, _prismatic_io_spectral.input)({
+	label: "Payload",
+	type: "code",
+	required: false,
+	language: "json",
+	placeholder: "Enter custom JSON payload",
+	comments: "Custom JSON payload for the webhook. If not provided, uses the default Datadog payload with standard variables like $ALERT_TITLE, $ALERT_STATUS, etc.",
+	example: "{\"title\": \"$ALERT_TITLE\", \"status\": \"$ALERT_STATUS\"}",
+	clean: toOptionalString
+});
+const createWebhookInputs = {
+	connection,
+	webhookName,
+	webhookUrl,
+	webhookCustomHeaders,
+	webhookEncodeAs,
+	webhookPayload
+};
+const updateWebhookInputs = {
+	connection,
+	webhookName,
+	webhookUrl: {
+		...webhookUrl,
+		required: false,
+		clean: toOptionalString
+	},
+	webhookCustomHeaders,
+	webhookEncodeAs,
+	webhookPayload
+};
+const getWebhookInputs = {
+	connection,
+	webhookName
+};
+const deleteWebhookInputs = {
+	connection,
+	webhookName
+};
+//#endregion
+//#region src/inputs/triggers.ts
+const webhookInputs = {
+	connection,
+	webhookName,
+	webhookPayload,
+	webhookCustomHeaders
+};
+//#endregion
+//#region src/outputSchemas/metrics.ts
+const listMetricsOutputSchema = {
+	type: "object",
+	properties: {
+		from: { type: "string" },
+		metrics: {
+			type: "array",
+			items: { type: "string" }
+		}
+	}
+};
+const searchMetricsOutputSchema = {
+	type: "object",
+	properties: { results: {
+		type: "object",
+		properties: { metrics: {
+			type: "array",
+			items: { type: "string" }
+		} }
+	} }
+};
+const submitMetricsOutputSchema = {
+	type: "object",
+	properties: { errors: {
+		type: "array",
+		items: { type: "string" }
+	} }
+};
+//#endregion
+//#region src/outputSchemas/webhooks.ts
+const webhooksIntegrationSchema = {
+	type: "object",
+	properties: {
+		name: { type: "string" },
+		url: { type: "string" },
+		custom_headers: { type: ["string", "null"] },
+		encode_as: {
+			type: "string",
+			enum: ["json", "form"]
+		},
+		payload: { type: ["string", "null"] }
+	},
+	required: ["name", "url"]
+};
+const createWebhookOutputSchema = webhooksIntegrationSchema;
+const getWebhookOutputSchema = webhooksIntegrationSchema;
+const updateWebhookOutputSchema = webhooksIntegrationSchema;
+const deleteWebhookOutputSchema = { type: "null" };
+//#endregion
+//#region src/actions/metrics/index.ts
+var metrics_default = {
+	listMetrics: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Metrics",
+			description: "List active metric names that have reported data since a given timestamp, with optional host and tag filtering."
+		},
+		inputs: listMetricsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: listMetricsOutputSchema
+		}),
+		performSafety: "notAllowed",
+		perform: async (context, { connection, metricsFrom, metricsHost, metricsTagFilter }) => {
+			const client = createClient(connection);
+			const params = {
+				from: metricsFrom,
+				...metricsHost && { host: metricsHost },
+				...metricsTagFilter && { tag_filter: metricsTagFilter }
+			};
+			return { data: (await client.get("/api/v1/metrics", { params })).data };
+		},
+		examplePerform: async (_context, { metricsFrom }) => ({ data: {
+			...listMetricsExamplePayload.data,
+			from: String(metricsFrom)
+		} }),
+		examplePayload: listMetricsExamplePayload
+	}),
+	searchMetrics: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Search Metrics",
+			description: "Search for Datadog metrics by name prefix. Returns matching metric names."
+		},
+		inputs: searchMetricsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: searchMetricsOutputSchema
+		}),
+		performSafety: "notAllowed",
+		perform: async (_context, { connection, metricsQuery }) => {
+			return { data: (await createClient(connection).get(SEARCH_METRICS_PATH, { params: { q: `${METRICS_QUERY_PREFIX}${metricsQuery}` } })).data };
+		},
+		examplePerform: async () => ({ ...searchMetricsExamplePayload }),
+		examplePayload: searchMetricsExamplePayload
+	}),
+	submitMetrics: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Submit Metrics",
+			description: "Submit time-series metric data to Datadog for graphing on dashboards. Uses the v2 API endpoint."
+		},
+		inputs: submitMetricsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: submitMetricsOutputSchema
+		}),
+		performSafety: "notAllowed",
+		perform: async (_context, { connection, metricSeries }) => {
+			return { data: (await createClient(connection).post(SUBMIT_METRICS_PATH, { series: metricSeries })).data };
+		},
+		examplePerform: async () => ({ ...submitMetricsExamplePayload }),
+		examplePayload: submitMetricsExamplePayload
+	}),
+	submitSingleMetric: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Submit Single Metric",
+			description: "Submit a single metric data point to Datadog. For bulk submissions, use the Submit Metrics action."
+		},
+		inputs: submitSingleMetricInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: submitMetricsOutputSchema
+		}),
+		performSafety: "notAllowed",
+		perform: async (context, { connection, metricName, metricValue, metricTimestamp, metricTags, metricFields }) => {
+			const client = createClient(connection);
+			const series = {
+				metric: metricName,
+				points: [{
+					timestamp: metricTimestamp,
+					value: metricValue
+				}],
+				type: metricFields.metricType,
+				tags: metricTags,
+				unit: metricFields.metricUnit,
+				interval: metricFields.metricInterval,
+				...metricFields.resourceName || metricFields.resourceType ? { resources: [{
+					name: metricFields.resourceName,
+					type: metricFields.resourceType
+				}] } : {}
+			};
+			return { data: (await client.post(SUBMIT_METRICS_PATH, { series: [series] })).data };
+		},
+		examplePerform: async () => ({ ...submitSingleMetricExamplePayload }),
+		examplePayload: submitSingleMetricExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/misc/index.ts
+var misc_default = { rawRequest: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Raw Request",
+		description: "Send a raw HTTP request to any Datadog API endpoint."
+	},
+	inputs: rawRequestInputs,
+	performSafety: "notAllowed",
+	perform: async (_context, { connection: conn, ...httpInputs }) => {
+		validateConnection(conn);
+		const { data } = await (0, _prismatic_io_spectral_http.sendRawRequest)(getBaseUrl(conn), {
+			...httpInputs,
+			debugRequest: false
+		}, getAuthHeaders(conn));
+		return { data };
+	}
+}) };
+//#endregion
+//#region src/actions/webhooks/index.ts
+var webhooks_default = {
+	createWebhook: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Create Webhook",
+			description: "Create a new webhook integration endpoint in Datadog. The webhook can then be referenced in monitor notifications as @webhook-NAME."
+		},
+		inputs: createWebhookInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: createWebhookOutputSchema
+		}),
+		performSafety: "notAllowed",
+		perform: async (context, { connection, webhookName, webhookUrl, webhookCustomHeaders, webhookEncodeAs, webhookPayload }) => {
+			return { data: (await createClient(connection).post(WEBHOOKS_CONFIGURATION_PATH, {
+				name: webhookName,
+				url: webhookUrl,
+				custom_headers: webhookCustomHeaders,
+				encode_as: webhookEncodeAs,
+				payload: webhookPayload
+			})).data };
+		},
+		examplePerform: async (_context, { webhookName, webhookUrl, webhookCustomHeaders, webhookEncodeAs, webhookPayload }) => ({ data: {
+			...createWebhookExamplePayload.data,
+			name: webhookName,
+			url: webhookUrl,
+			custom_headers: webhookCustomHeaders ?? null,
+			encode_as: webhookEncodeAs ?? "json",
+			payload: webhookPayload ?? null
+		} }),
+		examplePayload: createWebhookExamplePayload
+	}),
+	deleteWebhook: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Delete Webhook",
+			description: "Delete a Datadog webhook integration by name. This action cannot be undone."
+		},
+		inputs: deleteWebhookInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: deleteWebhookOutputSchema
+		}),
+		performSafety: "notAllowed",
+		perform: async (_context, { connection, webhookName }) => {
+			await createClient(connection).delete(`${WEBHOOKS_CONFIGURATION_PATH}/${encodeURIComponent(webhookName)}`);
+			return { data: null };
+		},
+		examplePerform: async () => ({ ...deleteWebhookExamplePayload }),
+		examplePayload: deleteWebhookExamplePayload
+	}),
+	getWebhook: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Webhook",
+			description: "Retrieve the configuration of a specific Datadog webhook integration by name."
+		},
+		inputs: getWebhookInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: getWebhookOutputSchema
+		}),
+		performSafety: "safe",
+		perform: async (_context, { connection, webhookName }) => {
+			return { data: (await createClient(connection).get(`${WEBHOOKS_CONFIGURATION_PATH}/${encodeURIComponent(webhookName)}`)).data };
+		},
+		examplePayload: getWebhookExamplePayload
+	}),
+	updateWebhook: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Update Webhook",
+			description: "Update the configuration of an existing Datadog webhook integration."
+		},
+		inputs: updateWebhookInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: updateWebhookOutputSchema
+		}),
+		performSafety: "notAllowed",
+		perform: async (context, { connection, webhookName, webhookUrl, webhookCustomHeaders, webhookEncodeAs, webhookPayload }) => {
+			return { data: (await createClient(connection).put(`${WEBHOOKS_CONFIGURATION_PATH}/${encodeURIComponent(webhookName)}`, {
+				url: webhookUrl,
+				custom_headers: webhookCustomHeaders,
+				encode_as: webhookEncodeAs,
+				payload: webhookPayload
+			})).data };
+		},
+		examplePerform: async (_context, { webhookName, webhookUrl, webhookCustomHeaders, webhookEncodeAs, webhookPayload }) => ({ data: {
+			...updateWebhookExamplePayload.data,
+			name: webhookName,
+			url: webhookUrl || updateWebhookExamplePayload.data.url,
+			custom_headers: webhookCustomHeaders ?? null,
+			encode_as: webhookEncodeAs ?? "json",
+			payload: webhookPayload ?? null
+		} }),
+		examplePayload: updateWebhookExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/index.ts
+var actions_default = {
+	...metrics_default,
+	...misc_default,
+	...webhooks_default
+};
+//#endregion
+//#region src/dataSources/index.ts
+var dataSources_default = { selectMetric: (0, _prismatic_io_spectral.dataSource)({
+	display: {
+		label: "Select Metric",
+		description: "A searchable picklist of metric names in the Datadog account."
+	},
+	inputs: selectMetricInputs,
+	perform: async (_context, { connection }) => {
+		const { data } = await createClient(connection).get(SEARCH_METRICS_PATH, { params: { q: METRICS_QUERY_PREFIX } });
+		return { result: (data.results?.metrics ?? []).map((metric) => ({
+			label: metric,
+			key: metric
+		})).sort((a, b) => (a.label ?? "") < (b.label ?? "") ? -1 : 1) };
+	},
+	examplePayload: selectMetricExamplePayload,
+	dataSourceType: "picklist"
+}) };
+//#endregion
+//#region src/triggers/index.ts
+var triggers_default = { webhook: (0, _prismatic_io_spectral.trigger)({
+	display: {
+		label: "Alert Notification Events",
+		description: "Receive Datadog monitor alert notifications via webhook. Automatically registers a webhook in Datadog on deploy and removes it on delete."
+	},
+	inputs: webhookInputs,
+	examplePayload: webhookExamplePayload,
+	perform: async (context, payload, params) => {
+		return Promise.resolve({ payload });
+	},
+	webhookLifecycleHandlers: {
+		create: async (context, { connection, webhookName, webhookPayload, webhookCustomHeaders }) => {
+			const client = createClient(connection);
+			const webhookUrl = context.webhookUrls[context.flow.name];
+			const stateKey = `${WEBHOOK_STATE_KEY_PREFIX}:${context.flow.stableId}`;
+			const previous = context.crossFlowState[stateKey];
+			if (previous && previous.webhookName !== webhookName) await deleteOwnedWebhook(client, context.logger, previous.webhookName, previous.webhookUrl);
+			const body = {
+				url: webhookUrl,
+				encode_as: DEFAULT_WEBHOOK_ENCODE_AS,
+				payload: webhookPayload,
+				custom_headers: webhookCustomHeaders
+			};
+			const existing = await findWebhook(client, webhookName);
+			if (existing && existing.url !== webhookUrl) throw new Error(`A Datadog webhook named "${webhookName}" already exists and points to a different URL. Choose a unique Webhook Name.`);
+			if (existing) await client.put(webhookConfigurationPath(webhookName), body);
+			else await client.post(WEBHOOKS_CONFIGURATION_PATH, {
+				name: webhookName,
+				...body
+			});
+			context.logger.info(`Registered Datadog webhook "${webhookName}" pointing to ${webhookUrl}`);
+			const registered = {
+				webhookName,
+				webhookUrl
+			};
+			return { crossFlowState: {
+				...context.crossFlowState,
+				[stateKey]: registered
+			} };
+		},
+		delete: async (context, { connection, webhookName }) => {
+			const client = createClient(connection);
+			const stateKey = `${WEBHOOK_STATE_KEY_PREFIX}:${context.flow.stableId}`;
+			const registered = context.crossFlowState[stateKey];
+			await deleteOwnedWebhook(client, context.logger, webhookName, registered?.webhookUrl ?? context.webhookUrls?.[context.flow.name]);
+		}
+	},
+	synchronousResponseSupport: "invalid",
+	scheduleSupport: "invalid"
+}) };
+//#endregion
+//#region src/index.ts
+var src_default = (0, _prismatic_io_spectral.component)({
+	key: "datadog",
+	public: true,
+	documentationUrl: "https://prismatic.io/docs/components/datadog/",
+	display: {
+		label: "Datadog",
+		description: "Interact with the Datadog API to submit metrics, manage webhooks, and monitor infrastructure and application performance.",
+		iconPath: "icon.png",
+		category: "Data Platforms"
+	},
+	hooks: { error: _prismatic_io_spectral_http.handleErrors },
+	actions: actions_default,
+	connections: connections_default,
+	dataSources: dataSources_default,
+	triggers: triggers_default
+});
+//#endregion
+//#region npm-dist/.entry.ts
+var _entry_default = (0, _prismatic_io_spectral.callableComponent)(src_default);
+//#endregion
+module.exports = _entry_default;