Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

3.9 KB
Raw Blame
import { mkdir, writeFile } from 'node:fs/promises';

const apiKey = process.env.DD_API_KEY;
const appKey = process.env.DD_APP_KEY;
if (!apiKey || !appKey)
  throw new Error('Datadog read credentials are required');
const headers = { 'DD-API-KEY': apiKey, 'DD-APPLICATION-KEY': appKey };
async function read(path: string): Promise<unknown> {
  const response = await fetch(`https://api.us5.datadoghq.com/api/v1/${path}`, {
    headers,
    signal: AbortSignal.timeout(30000),
  });
  if (!response.ok) throw new Error(`Datadog ${path}: HTTP ${response.status}`);
  return response.json();
}

const destination = process.argv[2];
if (!destination) throw new Error('Provide an output directory');
await mkdir(destination, { recursive: true });
function errorMessage(error: unknown): string {
  return error instanceof Error ? error.message : 'Export failed';
}
const exports = await Promise.allSettled([
  (async () => {
    const monitors: unknown[] = [];
    const errors: string[] = [];
    try {
      for (let page = 0; ; page++) {
        const batch = await read(`monitor?page=${page}&page_size=100`);
        if (!Array.isArray(batch)) throw new Error('Invalid monitor response');
        monitors.push(...batch);
        if (batch.length < 100) break;
      }
    } catch (error) {
      errors.push(errorMessage(error));
    }
    await writeFile(
      `${destination}/monitors.json`,
      JSON.stringify(monitors, null, 2)
    );
    return {
      kind: 'monitors',
      count: monitors.length,
      complete: errors.length === 0,
      errors,
    };
  })(),
  (async () => {
    const dashboards: { id: string }[] = [];
    const errors: string[] = [];
    try {
      for (let start = 0; ; start += 100) {
        const response = await read(`dashboard?count=100&start=${start}`);
        if (
          !response ||
          typeof response !== 'object' ||
          !('dashboards' in response) ||
          !Array.isArray(response.dashboards)
        )
          throw new Error('Invalid dashboard response');
        const entries: unknown[] = response.dashboards;
        for (const dashboard of entries) {
          if (
            !dashboard ||
            typeof dashboard !== 'object' ||
            !('id' in dashboard) ||
            typeof dashboard.id !== 'string' ||
            !/^[a-zA-Z0-9-]+$/.test(dashboard.id)
          )
            throw new Error('Invalid dashboard ID');
          try {
            const definition = await read(`dashboard/${dashboard.id}`);
            await writeFile(
              `${destination}/dashboard-${dashboard.id}.json`,
              JSON.stringify(definition, null, 2)
            );
            dashboards.push({ id: dashboard.id });
          } catch (error) {
            errors.push(`Dashboard ${dashboard.id}: ${errorMessage(error)}`);
          }
        }
        if (response.dashboards.length < 100) break;
      }
    } catch (error) {
      errors.push(errorMessage(error));
    }
    await writeFile(
      `${destination}/dashboards.json`,
      JSON.stringify(dashboards, null, 2)
    );
    return {
      kind: 'dashboards',
      count: dashboards.length,
      complete: errors.length === 0,
      errors,
    };
  })(),
]);
await writeFile(
  `${destination}/export-status.json`,
  JSON.stringify(
    exports.map((result) =>
      result.status === 'fulfilled'
        ? result.value
        : {
            error:
              result.reason instanceof Error
                ? result.reason.message
                : 'Export failed',
          }
    ),
    null,
    2
  )
);
for (const result of exports) {
  if (result.status === 'fulfilled') {
    console.log(`Exported ${result.value.count} ${result.value.kind}`);
    for (const error of result.value.errors) console.error(error);
  } else
    console.error(
      result.reason instanceof Error ? result.reason.message : 'Export failed'
    );
}
if (
  exports.some(
    (result) => result.status === 'rejected' || !result.value.complete
  )
)
  process.exitCode = 1;