@lokalise/playwright-reporters 1.8.0 → 1.9.0

package/dist/datadog/reporter.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineDatadogReporterConfig = void 0;
+/* eslint-disable max-statements */
+const faker_1 = require("@faker-js/faker");
+const datadog_1 = require("./datadog");
+const transform_1 = require("./transform");
+/**
+ * Extracts team name from test annotations
+ */
+const getTeamName = (test) => {
+    const ownerAnnotation = test.annotations?.find((annotation) => annotation.type === 'owner');
+    return ownerAnnotation?.description?.split(',')[0];
+};
+/**
+ * Playwright reporter that sends test execution metrics to Datadog
+ */
+// eslint-disable-next-line import/no-default-export
+class DatadogReporter {
+    options;
+    datadog;
+    testRunId;
+    // Counters
+    runStartTime;
+    runEndTime;
+    totalTests;
+    passedTests;
+    failedTests;
+    flakyTests;
+    skippedTests;
+    timedOutTests;
+    browserCreationMs;
+    retryTimeMs;
+    navigationMs;
+    workerCount;
+    testDurations;
+    // Per-test tracking
+    testMetrics;
+    projectNames;
+    currentTestNavigationMs;
+    constructor(options) {
+        this.options = options;
+        this.testRunId = faker_1.faker.string.uuid();
+        this.datadog = new datadog_1.Datadog({
+            apiKey: options.apiKey,
+            site: options.site,
+            debug: options.debug,
+        });
+        // Initialize counters
+        this.runStartTime = Date.now();
+        this.runEndTime = Date.now();
+        this.totalTests = 0;
+        this.passedTests = 0;
+        this.failedTests = 0;
+        this.flakyTests = 0;
+        this.skippedTests = 0;
+        this.timedOutTests = 0;
+        this.browserCreationMs = 0;
+        this.retryTimeMs = 0;
+        this.navigationMs = 0;
+        this.workerCount = 0;
+        this.testDurations = [];
+        this.testMetrics = [];
+        this.projectNames = [];
+        this.currentTestNavigationMs = new Map();
+    }
+    async onBegin(config, suite) {
+        try {
+            this.runStartTime = Date.now();
+            this.totalTests = suite.allTests().length;
+            this.projectNames = suite.suites.map((testSuite) => testSuite.title);
+            this.workerCount = config.workers;
+            if (!this.options.dryRun) {
+                await this.datadog.setNativeRequestContext();
+            }
+            if (this.options.debug) {
+                // eslint-disable-next-line no-console
+                console.log(`[Datadog Reporter] Starting test run ${this.testRunId} with ${this.totalTests} tests (${this.workerCount} workers)`);
+            }
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error("[Datadog Reporter] Could not perform 'onBegin' step", error);
+        }
+    }
+    onStepEnd(test, result, step) {
+        try {
+            const testKey = `${test.id}-${result.retry}`;
+            const stepTitle = step.title.toLowerCase();
+            // Track browser/context/page creation time
+            // Captures: "Launch browser", "Create context", "Create page"
+            if (stepTitle.includes('launch browser') ||
+                stepTitle.includes('create context') ||
+                stepTitle.includes('create page') ||
+                stepTitle.includes('browsercontext.newpage') ||
+                stepTitle.includes('browser.newcontext')) {
+                this.browserCreationMs += step.duration;
+            }
+            // Track page navigation time
+            // Captures: "Navigate to ..." (Playwright's actual step title for goto)
+            if (stepTitle.includes('navigate to') ||
+                stepTitle.includes('page.goto') ||
+                stepTitle.includes('page.reload') ||
+                stepTitle.includes('frame.goto')) {
+                this.navigationMs += step.duration;
+                const currentNav = this.currentTestNavigationMs.get(testKey) || 0;
+                this.currentTestNavigationMs.set(testKey, currentNav + step.duration);
+            }
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error("[Datadog Reporter] Could not perform 'onStepEnd' step", error);
+        }
+    }
+    onTestEnd(test, result) {
+        try {
+            const { status, retry: currentRetryCount, duration } = result;
+            const { retries: maxRetriesCount } = test;
+            const projectName = test.parent?.project()?.name;
+            const testKey = `${test.id}-${currentRetryCount}`;
+            const testNavigationMs = this.currentTestNavigationMs.get(testKey) || 0;
+            // Track test duration for average calculation (only on final attempt)
+            if (currentRetryCount === 0 || currentRetryCount === maxRetriesCount) {
+                this.testDurations.push(duration);
+            }
+            // Track test outcome
+            if (status === 'skipped') {
+                this.skippedTests++;
+            }
+            else if (status === 'timedOut') {
+                // Track timeout separately
+                if (currentRetryCount === maxRetriesCount) {
+                    this.timedOutTests++;
+                    this.failedTests++;
+                    this.testMetrics.push({
+                        name: test.title,
+                        testId: test.id,
+                        durationMs: duration,
+                        retryCount: currentRetryCount,
+                        isFlaky: false,
+                        isTimedOut: true,
+                        team: getTeamName(test),
+                        project: projectName,
+                        navigationMs: testNavigationMs,
+                    });
+                }
+                if (currentRetryCount > 0) {
+                    this.retryTimeMs += duration;
+                }
+            }
+            else if (['failed', 'interrupted'].includes(status)) {
+                // Only count as failed if all retries exhausted
+                if (currentRetryCount === maxRetriesCount) {
+                    this.failedTests++;
+                    // Track failed test metrics
+                    this.testMetrics.push({
+                        name: test.title,
+                        testId: test.id,
+                        durationMs: duration,
+                        retryCount: currentRetryCount,
+                        isFlaky: false,
+                        isTimedOut: false,
+                        team: getTeamName(test),
+                        project: projectName,
+                        navigationMs: testNavigationMs,
+                    });
+                }
+                // Track retry time
+                if (currentRetryCount > 0) {
+                    this.retryTimeMs += duration;
+                }
+            }
+            else if (status === 'passed') {
+                if (currentRetryCount > 0) {
+                    // Flaky test - passed after retry
+                    this.flakyTests++;
+                    this.passedTests++;
+                    this.retryTimeMs += duration;
+                    // Track flaky test metrics
+                    this.testMetrics.push({
+                        name: test.title,
+                        testId: test.id,
+                        durationMs: duration,
+                        retryCount: currentRetryCount,
+                        isFlaky: true,
+                        isTimedOut: false,
+                        team: getTeamName(test),
+                        project: projectName,
+                        navigationMs: testNavigationMs,
+                    });
+                }
+                else {
+                    // Clean pass
+                    this.passedTests++;
+                }
+            }
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error("[Datadog Reporter] Could not perform 'onTestEnd' step", error);
+        }
+    }
+    async onEnd(result) {
+        try {
+            this.runEndTime = Date.now();
+            // Calculate average test duration
+            const avgTestDurationMs = this.testDurations.length > 0
+                ? Math.round(this.testDurations.reduce((a, b) => a + b, 0) / this.testDurations.length)
+                : 0;
+            // Build run metrics
+            const runMetrics = {
+                testRunId: this.testRunId,
+                timestamp: Math.floor(this.runStartTime / 1000), // Datadog expects seconds
+                totalTests: this.totalTests,
+                passedTests: this.passedTests,
+                failedTests: this.failedTests,
+                flakyTests: this.flakyTests,
+                skippedTests: this.skippedTests,
+                timedOutTests: this.timedOutTests,
+                durationMs: this.runEndTime - this.runStartTime,
+                browserCreationMs: this.browserCreationMs,
+                retryTimeMs: this.retryTimeMs,
+                navigationMs: this.navigationMs,
+                allPassed: this.failedTests === 0 && result.status === 'passed',
+                passRate: (0, transform_1.calculatePassRate)(this.passedTests, this.totalTests - this.skippedTests),
+                flakyRate: (0, transform_1.calculateFlakyRate)(this.flakyTests, this.totalTests - this.skippedTests),
+                workerCount: this.workerCount,
+                avgTestDurationMs,
+            };
+            // Build base tags
+            const baseTags = {
+                branch: this.options.ci?.branchName,
+                project: this.projectNames.length > 0 ? this.projectNames : undefined,
+                prenvId: this.options.prenvId,
+                triggeredBy: this.options.ci?.triggeredBy,
+                env: this.options.env,
+                service: this.options.service ?? 'playwright-tests',
+                product: this.options.product,
+            };
+            // Build metrics payload
+            const payload = (0, transform_1.buildMetricsPayload)(runMetrics, this.testMetrics, baseTags);
+            if (this.options.dryRun || this.options.debug) {
+                // eslint-disable-next-line no-console
+                console.log('\n[Datadog Reporter] Test Run Summary:');
+                // eslint-disable-next-line no-console
+                console.log(`  Total: ${runMetrics.totalTests}`);
+                // eslint-disable-next-line no-console
+                console.log(`  Passed: ${runMetrics.passedTests}`);
+                // eslint-disable-next-line no-console
+                console.log(`  Failed: ${runMetrics.failedTests}`);
+                // eslint-disable-next-line no-console
+                console.log(`  Flaky: ${runMetrics.flakyTests}`);
+                // eslint-disable-next-line no-console
+                console.log(`  Skipped: ${runMetrics.skippedTests}`);
+                // eslint-disable-next-line no-console
+                console.log(`  Timed Out: ${runMetrics.timedOutTests}`);
+                // eslint-disable-next-line no-console
+                console.log(`  Pass Rate: ${runMetrics.passRate}%`);
+                // eslint-disable-next-line no-console
+                console.log(`  Flaky Rate: ${runMetrics.flakyRate}%`);
+                // eslint-disable-next-line no-console
+                console.log(`  Uptime: ${runMetrics.allPassed ? 1 : 0}`);
+                // eslint-disable-next-line no-console
+                console.log(`  Duration: ${runMetrics.durationMs}ms`);
+                // eslint-disable-next-line no-console
+                console.log(`  Avg Test Duration: ${runMetrics.avgTestDurationMs}ms`);
+                // eslint-disable-next-line no-console
+                console.log(`  Browser Creation: ${runMetrics.browserCreationMs}ms`);
+                // eslint-disable-next-line no-console
+                console.log(`  Navigation Time: ${runMetrics.navigationMs}ms`);
+                // eslint-disable-next-line no-console
+                console.log(`  Workers: ${runMetrics.workerCount}`);
+                // eslint-disable-next-line no-console
+                console.log(`  Metrics to send: ${payload.series.length}`);
+            }
+            if (!this.options.dryRun) {
+                await this.datadog.submitMetrics(payload);
+                await this.datadog.dispose();
+            }
+            if (this.options.debug) {
+                // eslint-disable-next-line no-console
+                console.log('[Datadog Reporter] Finished');
+            }
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error("[Datadog Reporter] Could not perform 'onEnd' step", error);
+        }
+    }
+}
+exports.default = DatadogReporter;
+/**
+ * Helper function for type-safe configuration
+ */
+const defineDatadogReporterConfig = (options) => options;
+exports.defineDatadogReporterConfig = defineDatadogReporterConfig;

package/dist/datadog/tests/e2e/browser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/datadog/tests/e2e/browser.test.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@playwright/test");
+/**
+ * Browser tests to generate browser creation time and navigation metrics.
+ * These tests actually launch a browser and navigate to pages.
+ */
+test_1.test.describe('Browser Tests - Navigation Metrics', () => {
+    (0, test_1.test)('navigate to example.com', async ({ page }) => {
+        await page.goto('https://example.com');
+        await (0, test_1.expect)(page.locator('h1')).toContainText('Example Domain');
+    });
+    (0, test_1.test)('navigate to httpbin - GET request', async ({ page }) => {
+        await page.goto('https://httpbin.org/get');
+        await (0, test_1.expect)(page.locator('body')).toContainText('origin');
+    });
+    (0, test_1.test)('navigate and interact with elements', async ({ page }) => {
+        await page.goto('https://example.com');
+        const title = await page.title();
+        (0, test_1.expect)(title).toContain('Example');
+        await (0, test_1.expect)(page.locator('a')).toBeVisible();
+    });
+    (0, test_1.test)('multiple page navigations', async ({ page }) => {
+        await page.goto('https://example.com');
+        await (0, test_1.expect)(page.locator('h1')).toBeVisible();
+        await page.goto('https://httpbin.org/html');
+        await (0, test_1.expect)(page.locator('h1')).toBeVisible();
+    });
+    (0, test_1.test)('page with delays', async ({ page }) => {
+        await page.goto('https://httpbin.org/delay/1');
+        await (0, test_1.expect)(page.locator('body')).toContainText('origin');
+    });
+});
+test_1.test.describe('Browser Tests - Performance', () => {
+    (0, test_1.test)('measure page load', async ({ page }) => {
+        const startTime = Date.now();
+        await page.goto('https://example.com');
+        const loadTime = Date.now() - startTime;
+        (0, test_1.expect)(loadTime).toBeLessThan(10000); // Should load within 10s
+        await (0, test_1.expect)(page.locator('h1')).toBeVisible();
+    });
+    (0, test_1.test)('check page content', async ({ page }) => {
+        await page.goto('https://example.com');
+        // Check multiple elements
+        await (0, test_1.expect)(page.locator('h1')).toBeVisible();
+        await (0, test_1.expect)(page.locator('p').first()).toContainText('This domain is for use in');
+        await (0, test_1.expect)(page.locator('a').first()).toBeVisible();
+    });
+});

package/dist/datadog/tests/e2e/sample.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/datadog/tests/e2e/sample.test.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@playwright/test");
+/**
+ * Sample tests to verify Datadog reporter metrics collection.
+ *
+ * This file contains:
+ * - Passing tests (to verify pass_rate, uptime)
+ * - A flaky test (to verify flaky detection)
+ * - A failing test (to verify failed_count)
+ * - A skipped test (to verify skipped_count)
+ */
+// Track retry attempts for flaky test simulation (used internally by test)
+test_1.test.describe('Datadog Reporter Test Suite', () => {
+    (0, test_1.test)('should pass - basic assertion', async () => {
+        (0, test_1.expect)(1 + 1).toBe(2);
+    });
+    (0, test_1.test)('should pass - string comparison', async () => {
+        (0, test_1.expect)('hello').toContain('ell');
+    });
+    (0, test_1.test)('should pass - array check', async () => {
+        const arr = [1, 2, 3];
+        (0, test_1.expect)(arr).toHaveLength(3);
+    });
+    (0, test_1.test)('should pass - object matching', async () => {
+        const obj = { name: 'test', value: 42 };
+        (0, test_1.expect)(obj).toMatchObject({ name: 'test' });
+    });
+    (0, test_1.test)('should pass - async operation', async () => {
+        const result = await Promise.resolve('success');
+        (0, test_1.expect)(result).toBe('success');
+    });
+    // This test is flaky - fails on first attempt, passes on retry
+    // eslint-disable-next-line no-empty-pattern
+    (0, test_1.test)('flaky test - passes on retry', async ({}, testInfo) => {
+        // Fail on first attempt (retry 0), pass on subsequent attempts
+        if (testInfo.retry === 0) {
+            (0, test_1.expect)(true).toBe(false); // Will fail
+        }
+        (0, test_1.expect)(true).toBe(true); // Will pass on retry
+    });
+    // Uncomment to test failed test tracking:
+    // test('should fail - intentional failure', async () => {
+    // 	expect(1).toBe(2)
+    // })
+    test_1.test.skip('skipped test - should be counted', async () => {
+        (0, test_1.expect)(true).toBe(true);
+    });
+});
+test_1.test.describe('Additional Passing Tests', () => {
+    (0, test_1.test)('math operations', async () => {
+        (0, test_1.expect)(10 * 5).toBe(50);
+        (0, test_1.expect)(100 / 4).toBe(25);
+    });
+    (0, test_1.test)('boolean logic', async () => {
+        (0, test_1.expect)(true && true).toBe(true);
+        (0, test_1.expect)(false || true).toBe(true);
+    });
+    (0, test_1.test)('type checking', async () => {
+        (0, test_1.expect)(typeof 'string').toBe('string');
+        (0, test_1.expect)(typeof 123).toBe('number');
+    });
+});
+// Team ownership annotation example
+// eslint-disable-next-line no-empty-pattern
+(0, test_1.test)('test with team owner', async ({}, testInfo) => {
+    testInfo.annotations.push({ type: 'owner', description: 'QA-Platform' });
+    (0, test_1.expect)(true).toBe(true);
+});

package/dist/datadog/transform.d.ts

@@ -0,0 +1,26 @@
+import { type DatadogMetricsPayload, type MetricSeries, type MetricTags, type TestMetrics, type TestRunMetrics } from './report.types';
+/**
+ * Converts MetricTags to Datadog tag format (key:value strings)
+ */
+export declare const formatTags: (tags: MetricTags) => string[];
+/**
+ * Transforms test run metrics into Datadog metric series
+ */
+export declare const transformTestRunMetrics: (runMetrics: TestRunMetrics, baseTags: MetricTags) => MetricSeries[];
+/**
+ * Transforms individual test metrics into Datadog metric series
+ * Used for tracking per-test duration and flakiness
+ */
+export declare const transformTestMetrics: (testMetrics: TestMetrics, timestamp: number, baseTags: MetricTags) => MetricSeries[];
+/**
+ * Builds the complete Datadog metrics payload from test run data
+ */
+export declare const buildMetricsPayload: (runMetrics: TestRunMetrics, testMetricsList: TestMetrics[], baseTags: MetricTags) => DatadogMetricsPayload;
+/**
+ * Calculates pass rate as a percentage
+ */
+export declare const calculatePassRate: (passed: number, total: number) => number;
+/**
+ * Calculates flaky rate as a percentage
+ */
+export declare const calculateFlakyRate: (flaky: number, total: number) => number;

package/dist/datadog/transform.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateFlakyRate = exports.calculatePassRate = exports.buildMetricsPayload = exports.transformTestMetrics = exports.transformTestRunMetrics = exports.formatTags = void 0;
+/* eslint-disable max-statements, max-params */
+const report_types_1 = require("./report.types");
+/**
+ * Metric name prefix for all Playwright metrics
+ */
+const METRIC_PREFIX = 'playwright';
+/**
+ * Converts MetricTags to Datadog tag format (key:value strings)
+ */
+const formatTags = (tags) => {
+    const formattedTags = [];
+    if (tags.branch) {
+        formattedTags.push(`branch:${tags.branch}`);
+    }
+    if (tags.project && tags.project.length > 0) {
+        tags.project.forEach((p) => formattedTags.push(`project:${p}`));
+    }
+    if (tags.prenvId) {
+        formattedTags.push(`prenv_id:${tags.prenvId}`);
+    }
+    if (tags.triggeredBy) {
+        formattedTags.push(`triggered_by:${tags.triggeredBy}`);
+    }
+    if (tags.env) {
+        formattedTags.push(`env:${tags.env}`);
+    }
+    if (tags.service) {
+        formattedTags.push(`service:${tags.service}`);
+    }
+    if (tags.product) {
+        formattedTags.push(`product:${tags.product}`);
+    }
+    return formattedTags;
+};
+exports.formatTags = formatTags;
+/**
+ * Creates a metric series for a gauge value
+ */
+const createGauge = (name, value, timestamp, tags, unit) => ({
+    metric: `${METRIC_PREFIX}.${name}`,
+    type: report_types_1.MetricTypes.GAUGE,
+    points: [{ timestamp, value }],
+    tags,
+    ...(unit && { unit }),
+});
+/**
+ * Creates a metric series for a count value
+ */
+const createCount = (name, value, timestamp, tags) => ({
+    metric: `${METRIC_PREFIX}.${name}`,
+    type: report_types_1.MetricTypes.COUNT,
+    points: [{ timestamp, value }],
+    tags,
+});
+/**
+ * Creates a metric series for a gauge value (used for distributions since API v2 doesn't support distribution type directly)
+ */
+const createDistribution = (name, value, timestamp, tags, unit) => ({
+    metric: `${METRIC_PREFIX}.${name}`,
+    type: report_types_1.MetricTypes.GAUGE, // Use gauge for distribution-like metrics in v2 API
+    points: [{ timestamp, value }],
+    tags,
+    ...(unit && { unit }),
+});
+/**
+ * Transforms test run metrics into Datadog metric series
+ */
+const transformTestRunMetrics = (runMetrics, baseTags) => {
+    const tags = (0, exports.formatTags)(baseTags);
+    const { timestamp } = runMetrics;
+    const series = [];
+    // Executive View Metrics
+    // Uptime: 1 if all tests passed, 0 otherwise
+    series.push(createGauge('test_run.uptime', runMetrics.allPassed ? 1 : 0, timestamp, tags));
+    // Pass rate as percentage (0-100)
+    series.push(createGauge('test_run.pass_rate', runMetrics.passRate, timestamp, tags, 'percent'));
+    // Engineer View Metrics
+    // Flaky rate as percentage (0-100)
+    series.push(createGauge('test_run.flaky_rate', runMetrics.flakyRate, timestamp, tags, 'percent'));
+    // Test counts
+    series.push(createGauge('test_run.test_count', runMetrics.totalTests, timestamp, tags));
+    series.push(createCount('test_run.failed_count', runMetrics.failedTests, timestamp, tags));
+    series.push(createCount('test_run.flaky_count', runMetrics.flakyTests, timestamp, tags));
+    series.push(createCount('test_run.skipped_count', runMetrics.skippedTests, timestamp, tags));
+    series.push(createCount('test_run.passed_count', runMetrics.passedTests, timestamp, tags));
+    // Duration metrics
+    series.push(createDistribution('test_run.duration_ms', runMetrics.durationMs, timestamp, tags, 'millisecond'));
+    // Average test duration
+    if (runMetrics.avgTestDurationMs > 0) {
+        series.push(createDistribution('test_run.avg_test_duration_ms', runMetrics.avgTestDurationMs, timestamp, tags, 'millisecond'));
+    }
+    // Browser creation time
+    if (runMetrics.browserCreationMs > 0) {
+        series.push(createDistribution('test_run.browser_creation_ms', runMetrics.browserCreationMs, timestamp, tags, 'millisecond'));
+    }
+    // Navigation time
+    if (runMetrics.navigationMs > 0) {
+        series.push(createDistribution('test_run.navigation_ms', runMetrics.navigationMs, timestamp, tags, 'millisecond'));
+    }
+    // Retry time
+    if (runMetrics.retryTimeMs > 0) {
+        series.push(createDistribution('test_run.retry_time_ms', runMetrics.retryTimeMs, timestamp, tags, 'millisecond'));
+    }
+    // Worker count
+    if (runMetrics.workerCount > 0) {
+        series.push(createGauge('test_run.worker_count', runMetrics.workerCount, timestamp, tags));
+    }
+    // Timeout count
+    if (runMetrics.timedOutTests > 0) {
+        series.push(createCount('test_run.timeout_count', runMetrics.timedOutTests, timestamp, tags));
+    }
+    return series;
+};
+exports.transformTestRunMetrics = transformTestRunMetrics;
+/**
+ * Transforms individual test metrics into Datadog metric series
+ * Used for tracking per-test duration and flakiness
+ */
+const transformTestMetrics = (testMetrics, timestamp, baseTags) => {
+    const series = [];
+    // Build tags with test-specific info
+    const testTags = (0, exports.formatTags)(baseTags);
+    testTags.push(`test_name:${testMetrics.name.replace(/[,|]/g, '_').substring(0, 200)}`);
+    if (testMetrics.team) {
+        testTags.push(`team:${testMetrics.team}`);
+    }
+    if (testMetrics.project) {
+        testTags.push(`test_project:${testMetrics.project}`);
+    }
+    // Test duration
+    series.push(createDistribution('test.duration_ms', testMetrics.durationMs, timestamp, testTags, 'millisecond'));
+    // Track navigation time per test
+    if (testMetrics.navigationMs > 0) {
+        series.push(createDistribution('test.navigation_ms', testMetrics.navigationMs, timestamp, testTags, 'millisecond'));
+    }
+    // Track retries
+    if (testMetrics.retryCount > 0) {
+        series.push(createCount('test.retry_count', testMetrics.retryCount, timestamp, testTags));
+    }
+    // Track flaky tests
+    if (testMetrics.isFlaky) {
+        series.push(createCount('test.flaky', 1, timestamp, testTags));
+    }
+    // Track timed out tests
+    if (testMetrics.isTimedOut) {
+        series.push(createCount('test.timeout', 1, timestamp, testTags));
+    }
+    return series;
+};
+exports.transformTestMetrics = transformTestMetrics;
+/**
+ * Builds the complete Datadog metrics payload from test run data
+ */
+const buildMetricsPayload = (runMetrics, testMetricsList, baseTags) => {
+    const series = [];
+    // Add test run level metrics
+    series.push(...(0, exports.transformTestRunMetrics)(runMetrics, baseTags));
+    // Add individual test metrics (for flaky tests and duration tracking)
+    for (const testMetrics of testMetricsList) {
+        series.push(...(0, exports.transformTestMetrics)(testMetrics, runMetrics.timestamp, baseTags));
+    }
+    return { series };
+};
+exports.buildMetricsPayload = buildMetricsPayload;
+/**
+ * Calculates pass rate as a percentage
+ */
+const calculatePassRate = (passed, total) => {
+    if (total === 0)
+        return 100;
+    return Math.round((passed / total) * 10000) / 100; // Round to 2 decimal places
+};
+exports.calculatePassRate = calculatePassRate;
+/**
+ * Calculates flaky rate as a percentage
+ */
+const calculateFlakyRate = (flaky, total) => {
+    if (total === 0)
+        return 0;
+    return Math.round((flaky / total) * 10000) / 100; // Round to 2 decimal places
+};
+exports.calculateFlakyRate = calculateFlakyRate;

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import AnalyticsReporter, { defineAnalyticsReporterConfig } from './analytics/reporter';
+import DatadogReporter, { defineDatadogReporterConfig } from './datadog/reporter';
 import PermissionsReporter, { definePermissionsReporterConfig } from './permissions/reporter';
 import RetryReporter, { defineRetryReporterConfig } from './retry/reporter';
 import StepDurationReporter, { defineStepDurationReporterConfig } from './stepDuration/reporter';
 import TimelineReporter, { defineTimelineReporterConfig } from './timeline/reporter';
 import TranslationReporter, { defineTranslationReporterConfig } from './translation/reporter';
-export { AnalyticsReporter, defineAnalyticsReporterConfig, RetryReporter, defineRetryReporterConfig, TimelineReporter, defineTimelineReporterConfig, StepDurationReporter, defineStepDurationReporterConfig, PermissionsReporter, definePermissionsReporterConfig, TranslationReporter, defineTranslationReporterConfig, };
+export { AnalyticsReporter, defineAnalyticsReporterConfig, DatadogReporter, defineDatadogReporterConfig, RetryReporter, defineRetryReporterConfig, TimelineReporter, defineTimelineReporterConfig, StepDurationReporter, defineStepDurationReporterConfig, PermissionsReporter, definePermissionsReporterConfig, TranslationReporter, defineTranslationReporterConfig, };