@l.x/datadog-cloud 1.0.0

package/dashboards/dashboard-factory.ts

@@ -0,0 +1,187 @@
+import * as datadog from '@pulumi/datadog';
+import {
+  DashboardDefinition,
+  DashboardWidgetDefinition,
+  GroupWidgetDefinition,
+  PresetDefinition,
+} from './dashboard-types';
+import {settings} from './config';
+
+/**
+ * Default service definitions for universe presets.
+ * Each entry maps a display name to a service tag filter.
+ * Add new services here — they'll automatically appear on all dashboards
+ * that use getDefaultServicePresets().
+ */
+export const DEFAULT_SERVICES: Array<{name: string; filter: string}> = [
+  {name: 'Dev Portal', filter: '*dev-portal*'},
+];
+
+/**
+ * Returns the default set of saved view presets for all universe services.
+ * Includes an "All" option plus one preset per service.
+ *
+ * @param variableName - The template variable name to bind presets to (e.g., 'service', 'cluster')
+ * @param opts.filterPrefix - Optional prefix prepended to each service filter
+ * @param opts.extra - Optional additional presets appended after the defaults
+ */
+export function getDefaultServicePresets(
+  variableName: string,
+  opts?: {filterPrefix?: string; extra?: PresetDefinition[]}
+): PresetDefinition[] {
+  const prefix = opts?.filterPrefix || '';
+  const presets: PresetDefinition[] = [
+    {
+      name: 'All',
+      templateVariables: [{name: variableName, values: ['*']}],
+    },
+    ...DEFAULT_SERVICES.map(svc => ({
+      name: svc.name,
+      templateVariables: [
+        {name: variableName, values: [`${prefix}${svc.filter}`]},
+      ],
+    })),
+  ];
+
+  if (opts?.extra) {
+    presets.push(...opts.extra);
+  }
+
+  return presets;
+}
+
+/**
+ * Build standard dashboard tags
+ * Note: Datadog dashboards only support tags with the `team:` prefix
+ */
+export function buildDashboardTags(opts: {
+  team: string;
+  additionalTags?: string[];
+}): string[] {
+  const tags = [`team:${opts.team}`];
+
+  if (opts.additionalTags) {
+    tags.push(...opts.additionalTags.filter(t => t.startsWith('team:')));
+  }
+
+  return tags;
+}
+
+/**
+ * Transform widget definition recursively to convert layout to widgetLayout
+ * for nested groupDefinition widgets
+ */
+function transformWidgetDefinition(
+  definition: Partial<DashboardWidgetDefinition>
+): Partial<DashboardWidgetDefinition> {
+  if (
+    definition.groupDefinition &&
+    Array.isArray(definition.groupDefinition.widgets)
+  ) {
+    return {
+      ...definition,
+      groupDefinition: {
+        ...definition.groupDefinition,
+        widgets: definition.groupDefinition.widgets.map(
+          (widget: GroupWidgetDefinition) => {
+            const {layout, ...rest} = widget;
+            return {
+              widgetLayout: layout
+                ? {
+                    x: layout.x,
+                    y: layout.y,
+                    width: layout.width,
+                    height: layout.height,
+                  }
+                : undefined,
+              ...transformWidgetDefinition(rest),
+            };
+          }
+        ),
+      },
+    };
+  }
+
+  return definition;
+}
+
+/**
+ * Create a Datadog dashboard from a DashboardDefinition
+ */
+export function createDashboard(def: DashboardDefinition): datadog.Dashboard {
+  const resourceName = `${def.team}-${settings.environment}-${def.id}`;
+
+  const tags = buildDashboardTags({
+    team: def.team,
+    additionalTags: def.additionalTags,
+  });
+
+  return new datadog.Dashboard(resourceName, {
+    title: def.title,
+    description: def.description,
+    layoutType: def.layoutType,
+    reflowType: def.reflowType,
+    tags: tags,
+
+    templateVariables: def.templateVariables.map(tv => ({
+      name: tv.name,
+      prefix: tv.prefix,
+      defaults: tv.defaults,
+      availableValues: tv.availableValues,
+    })),
+
+    templateVariablePresets: def.presets?.map(preset => ({
+      name: preset.name,
+      templateVariables: preset.templateVariables.map(tv => ({
+        name: tv.name,
+        value: tv.value,
+        values: tv.values,
+      })),
+    })),
+
+    widgets: def.widgets.map(w => ({
+      widgetLayout: w.layout
+        ? {
+            x: w.layout.x,
+            y: w.layout.y,
+            width: w.layout.width,
+            height: w.layout.height,
+          }
+        : undefined,
+      ...transformWidgetDefinition(w.definition),
+    })),
+  });
+}
+
+/**
+ * Create multiple dashboards from an array of definitions
+ */
+export function createDashboards(
+  defs: DashboardDefinition[]
+): Record<string, datadog.Dashboard> {
+  const dashboards: Record<string, datadog.Dashboard> = {};
+
+  for (const def of defs) {
+    dashboards[def.id] = createDashboard(def);
+  }
+
+  return dashboards;
+}
+
+/**
+ * Create a Datadog dashboard from raw JSON export.
+ *
+ * Use this when importing a dashboard directly from the Datadog UI JSON export.
+ * The JSON is passed through as-is via the DashboardJson resource.
+ */
+export function createDashboardFromJson(opts: {
+  id: string;
+  team: string;
+  dashboardJson: object;
+}): datadog.DashboardJson {
+  const resourceName = `${opts.team}-${settings.environment}-${opts.id}`;
+
+  return new datadog.DashboardJson(resourceName, {
+    dashboard: JSON.stringify(opts.dashboardJson),
+  });
+}

package/dashboards/dashboard-types.ts

@@ -0,0 +1,127 @@
+import * as datadog from '@pulumi/datadog';
+
+/**
+ * Template variable definition for dashboard filters
+ */
+export interface TemplateVariableDefinition {
+  /** Variable name (used in queries as $name) */
+  name: string;
+  /** Tag prefix to filter by (e.g., 'unienv' for unienv:* tags) */
+  prefix: string;
+  /** Default value(s) - ['*'] for all */
+  defaults: string[];
+  /** Available values to show in dropdown (empty = auto-discover) */
+  availableValues?: string[];
+}
+
+/**
+ * Template variable preset for quick filtering
+ */
+export interface PresetDefinition {
+  /** Preset display name */
+  name: string;
+  /** Template variable values for this preset */
+  templateVariables: Array<{
+    name: string;
+    /** Single value (deprecated - use values instead) */
+    value?: string;
+    /** Multiple values (preferred) */
+    values?: string[];
+  }>;
+}
+
+/**
+ * Widget layout position for fixed reflow dashboards
+ */
+export interface WidgetLayout {
+  /** X position (horizontal) */
+  x: number;
+  /** Y position (vertical) */
+  y: number;
+  /** Width in grid units */
+  width: number;
+  /** Height in grid units */
+  height: number;
+}
+
+/**
+ * Widget definition that uses 'layout' instead of 'widgetLayout' for consistency.
+ * This type is used for widgets inside groupDefinition.
+ */
+export type GroupWidgetDefinition = Omit<
+  datadog.types.input.DashboardWidgetGroupDefinitionWidget,
+  'widgetLayout'
+> & {
+  layout?: WidgetLayout;
+};
+
+/**
+ * Extended DashboardWidget that supports 'layout' for nested group widgets
+ */
+export type DashboardWidgetDefinition = Omit<
+  datadog.types.input.DashboardWidget,
+  'groupDefinition'
+> & {
+  groupDefinition?: Omit<
+    datadog.types.input.DashboardWidgetGroupDefinition,
+    'widgets'
+  > & {
+    widgets?: GroupWidgetDefinition[];
+  };
+};
+
+/**
+ * Dashboard definition - simplified interface for defining dashboards
+ *
+ * This mirrors the MonitorDefinition pattern for consistency.
+ */
+export interface DashboardDefinition {
+  /** Unique identifier (used in resource name, e.g., 'dev-portal_overview') */
+  id: string;
+
+  /** Dashboard title */
+  title: string;
+
+  /** Dashboard description */
+  description?: string;
+
+  /** Owning team (used for tagging and resource naming) */
+  team: string;
+
+  /** Layout type - 'ordered' for grid layout, 'free' for absolute positioning */
+  layoutType: 'ordered' | 'free';
+
+  /** Reflow type for ordered layouts - 'fixed' requires layouts, 'auto' does not */
+  reflowType?: 'auto' | 'fixed';
+
+  /** Template variables for filtering */
+  templateVariables: TemplateVariableDefinition[];
+
+  /** Presets for quick filtering */
+  presets?: PresetDefinition[];
+
+  /**
+   * Widget definitions using Pulumi Dashboard widget format.
+   * Each widget should have exactly one definition type
+   * (e.g., listStreamDefinition, manageStatusDefinition, etc.)
+   *
+   * For groupDefinition widgets, use 'layout' instead of 'widgetLayout'
+   * for nested widgets. The factory will transform this to the correct format.
+   */
+  widgets: Array<{
+    /** Layout position (required for 'fixed' reflow type) */
+    layout?: WidgetLayout;
+    /**
+     * Widget definition - should contain exactly one widget type property.
+     * Examples:
+     * - { listStreamDefinition: {...} }
+     * - { manageStatusDefinition: {...} }
+     * - { timeseriesDefinition: {...} }
+     * - { groupDefinition: { widgets: [{ layout: {...}, noteDefinition: {...} }] } }
+     */
+    definition: Partial<DashboardWidgetDefinition>;
+  }>;
+
+  /** Additional tags beyond the standard ones (team, env, managed-by) */
+  additionalTags?: string[];
+}

package/dashboards/definitions/dev-portal/index.ts

@@ -0,0 +1 @@
+export {devPortalDashboards} from './service-dashboard';

package/dashboards/definitions/dev-portal/service-dashboard.ts

@@ -0,0 +1,169 @@
+import {DashboardDefinition} from '../../dashboard-types';
+import {getDefaultServicePresets} from '../../dashboard-factory';
+import {settings} from '../../config';
+
+// ALB metrics — these have data immediately via AWS integration (no APM required)
+const albFilter = `name:dev-portal-lb,unienv:${settings.environment}`;
+
+export const devPortalDashboards: DashboardDefinition[] = [
+  {
+    id: 'dev-portal_service_overview',
+    title: `[Dev Portal] [${settings.environment}] Service Overview`,
+    description:
+      'Dev Portal service health: request rate, errors, latency, and status codes (ALB metrics).',
+    team: 'dev-portal',
+    layoutType: 'ordered',
+    reflowType: 'fixed',
+    templateVariables: [
+      {
+        name: 'env',
+        prefix: 'unienv',
+        defaults: [settings.environment],
+      },
+    ],
+    presets: getDefaultServicePresets('service'),
+    widgets: [
+      // Row 1: Request Rate + Error Rate
+      {
+        layout: {x: 0, y: 0, width: 6, height: 4},
+        definition: {
+          timeseriesDefinition: {
+            title: 'Request Rate',
+            showLegend: true,
+            requests: [
+              {
+                formulas: [{formulaExpression: 'query1'}],
+                queries: [
+                  {
+                    metricQuery: {
+                      dataSource: 'metrics',
+                      name: 'query1',
+                      query: `sum:aws.applicationelb.request_count{${albFilter}}.as_rate()`,
+                    },
+                  },
+                ],
+                style: {palette: 'dog_classic', lineType: 'solid', lineWidth: 'normal'},
+                displayType: 'line',
+              },
+            ],
+          },
+        },
+      },
+      {
+        layout: {x: 6, y: 0, width: 6, height: 4},
+        definition: {
+          timeseriesDefinition: {
+            title: 'Error Rate (%)',
+            showLegend: true,
+            requests: [
+              {
+                formulas: [{formulaExpression: 'query1 / query2 * 100'}],
+                queries: [
+                  {
+                    metricQuery: {
+                      dataSource: 'metrics',
+                      name: 'query1',
+                      query: `sum:aws.applicationelb.httpcode_target_5xx{${albFilter}}.as_count()`,
+                    },
+                  },
+                  {
+                    metricQuery: {
+                      dataSource: 'metrics',
+                      name: 'query2',
+                      query: `sum:aws.applicationelb.request_count{${albFilter}}.as_count()`,
+                    },
+                  },
+                ],
+                style: {palette: 'warm', lineType: 'solid', lineWidth: 'normal'},
+                displayType: 'line',
+              },
+            ],
+          },
+        },
+      },
+      // Row 2: Latency Percentiles + HTTP Status Distribution
+      {
+        layout: {x: 0, y: 4, width: 6, height: 4},
+        definition: {
+          timeseriesDefinition: {
+            title: 'Latency Percentiles',
+            showLegend: true,
+            requests: [
+              {
+                formulas: [
+                  {formulaExpression: 'query1', alias: 'P95'},
+                  {formulaExpression: 'query2', alias: 'P99'},
+                ],
+                queries: [
+                  {
+                    metricQuery: {
+                      dataSource: 'metrics',
+                      name: 'query1',
+                      query: `avg:aws.applicationelb.target_response_time.p95{${albFilter}}`,
+                    },
+                  },
+                  {
+                    metricQuery: {
+                      dataSource: 'metrics',
+                      name: 'query2',
+                      query: `avg:aws.applicationelb.target_response_time.p99{${albFilter}}`,
+                    },
+                  },
+                ],
+                style: {palette: 'dog_classic', lineType: 'solid', lineWidth: 'normal'},
+                displayType: 'line',
+              },
+            ],
+          },
+        },
+      },
+      {
+        layout: {x: 6, y: 4, width: 6, height: 4},
+        definition: {
+          toplistDefinition: {
+            title: 'HTTP Status Code Distribution',
+            requests: [
+              {
+                formulas: [{formulaExpression: 'query1 + query2 + query3 + query4', limit: {count: 10, order: 'desc'}}],
+                queries: [
+                  {
+                    metricQuery: {
+                      dataSource: 'metrics',
+                      name: 'query1',
+                      query: `sum:aws.applicationelb.httpcode_target_2xx{${albFilter}}.as_count()`,
+                      aggregator: 'sum',
+                    },
+                  },
+                  {
+                    metricQuery: {
+                      dataSource: 'metrics',
+                      name: 'query2',
+                      query: `sum:aws.applicationelb.httpcode_target_3xx{${albFilter}}.as_count()`,
+                      aggregator: 'sum',
+                    },
+                  },
+                  {
+                    metricQuery: {
+                      dataSource: 'metrics',
+                      name: 'query3',
+                      query: `sum:aws.applicationelb.httpcode_target_4xx{${albFilter}}.as_count()`,
+                      aggregator: 'sum',
+                    },
+                  },
+                  {
+                    metricQuery: {
+                      dataSource: 'metrics',
+                      name: 'query4',
+                      query: `sum:aws.applicationelb.httpcode_target_5xx{${albFilter}}.as_count()`,
+                      aggregator: 'sum',
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        },
+      },
+    ],
+  },
+];

package/dashboards/definitions/index.ts

@@ -0,0 +1 @@
+export {devPortalDashboards} from './dev-portal';

package/dashboards/esc/shared.yaml

@@ -0,0 +1,7 @@
+imports:
+  - shared-infra/datadog-2026
+
+values:
+  pulumiConfig:
+    datadog:apiKey: ${pulumiConfig["env:DD_API_KEY"]}
+    datadog:appKey: ${pulumiConfig["env:DD_APP_KEY"]}

package/dashboards/index.ts

@@ -0,0 +1,40 @@
+import * as pulumi from '@pulumi/pulumi';
+import {createDashboards} from './dashboard-factory';
+import {devPortalDashboards} from './definitions';
+import {settings} from './config';
+import {DashboardDefinition} from './dashboard-types';
+
+// Log configuration
+pulumi.log.info(`Environment: ${settings.environment}`);
+pulumi.log.info(`Team: ${settings.defaultTeam}`);
+pulumi.log.info(`Tag Filter: ${settings.tagFilter}`);
+
+// Team dashboard definitions
+const teamDashboards: Record<string, DashboardDefinition[]> = {
+  'dev-portal': devPortalDashboards,
+};
+
+// Get dashboards for current team
+const team = settings.defaultTeam;
+const currentTeamDashboards = teamDashboards[team] || [];
+
+if (currentTeamDashboards.length === 0) {
+  pulumi.log.warn(`No dashboards defined for team: ${team}`);
+}
+
+// Create dashboards
+const createdDashboards = createDashboards(currentTeamDashboards);
+const dashboardIdMap: Record<string, pulumi.Output<string>> =
+  Object.fromEntries(
+    Object.entries(createdDashboards).map(([k, v]) => [k, v.id])
+  );
+
+// Exports
+export const dashboardIds = dashboardIdMap;
+
+export const summary = {
+  team,
+  environment: settings.environment,
+  totalDashboards: Object.keys(dashboardIdMap).length,
+  dashboards: Object.keys(dashboardIdMap),
+};

package/dashboards/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "datadog-dashboards-universe",
+  "version": "1.0.0",
+  "description": "Datadog dashboards for Universe services",
+  "main": "index.ts",
+  "scripts": {
+    "preview": "pulumi preview",
+    "up": "pulumi up",
+    "destroy": "pulumi destroy",
+    "refresh": "pulumi refresh"
+  },
+  "dependencies": {
+    "@pulumi/datadog": "4.60.0",
+    "@pulumi/pulumi": "3.207.0"
+  },
+  "devDependencies": {
+    "@types/node": "22.13.1",
+    "typescript": "5.8.3"
+  }
+}

package/esc/dev-portal.yaml

@@ -0,0 +1,13 @@
+imports:
+  - shared-infra/datadog-2026
+  - shared-infra/incident
+
+values:
+  pulumiConfig:
+    datadog:apiKey: ${pulumiConfig["env:DD_API_KEY"]}
+    datadog:appKey: ${pulumiConfig["env:DD_APP_KEY"]}
+    datadog-cloud-universe:teams: ${teams}
+    datadog-cloud-universe:tagFilterExtra: "service:dev-portal*"
+    datadog-cloud-universe:defaultTeam: dev-portal
+    datadog-cloud-universe:disablePaging: 'true'
+    datadog-cloud-universe:disableSlack: 'true'

package/factory.ts

@@ -0,0 +1,79 @@
+import * as datadog from '@pulumi/datadog';
+import {MonitorDefinition, defaultMonitorOptions} from './types';
+import {buildTags, buildMessage, settings} from './config';
+
+/**
+ * Create a Datadog monitor from a MonitorDefinition
+ */
+export function createMonitor(def: MonitorDefinition): datadog.Monitor {
+  const resourceName = `${def.team}-${settings.environment}-${def.id}`;
+
+  // Format team name for display: sre -> SRE, dev-portal -> Dev-portal
+  const teamDisplay =
+    def.team.toUpperCase() === def.team
+      ? def.team
+      : def.team.charAt(0).toUpperCase() + def.team.slice(1);
+
+  // Auto-prepend [TEAM] to monitor name if not already present
+  const monitorName = def.name.startsWith('[')
+    ? def.name
+    : `[${teamDisplay}] ${def.name}`;
+
+  const tags = buildTags({
+    signalId: def.id,
+    team: def.team,
+    enablePaging: def.enablePaging,
+    additionalTags: def.additionalTags,
+  });
+
+  const message = buildMessage({
+    alertBody: def.alertBody,
+    recoveryBody: def.recoveryBody,
+    team: def.team,
+    logQuery: def.logQuery,
+    runbookUrl: def.runbookUrl,
+    readmeUrl: def.readmeUrl,
+    dashboards: def.dashboards,
+    includeIncidentWebhook: def.includeIncidentWebhook,
+  });
+
+  return new datadog.Monitor(resourceName, {
+    ...defaultMonitorOptions,
+    name: monitorName,
+    type: def.type,
+    query: def.query,
+    message: message,
+    tags: tags,
+    priority: def.priority.toString(),
+    monitorThresholds: def.thresholds
+      ? {
+          critical: def.thresholds.critical?.toString(),
+          warning: def.thresholds.warning?.toString(),
+          criticalRecovery: def.thresholds.criticalRecovery?.toString(),
+          warningRecovery: def.thresholds.warningRecovery?.toString(),
+        }
+      : undefined,
+    monitorThresholdWindows: def.thresholdWindows,
+    noDataTimeframe: def.noDataTimeframe,
+    notifyNoData: def.notifyNoData,
+    renotifyInterval: def.renotifyInterval,
+    newGroupDelay: def.newGroupDelay,
+    evaluationDelay: def.evaluationDelay,
+    onMissingData: def.onMissingData,
+  });
+}
+
+/**
+ * Create multiple monitors from an array of definitions
+ */
+export function createMonitors(
+  defs: MonitorDefinition[]
+): Record<string, datadog.Monitor> {
+  const monitors: Record<string, datadog.Monitor> = {};
+
+  for (const def of defs) {
+    monitors[def.id] = createMonitor(def);
+  }
+
+  return monitors;
+}