@lokalise/playwright-reporters 1.8.0 → 1.9.0

package/README.md

@@ -102,3 +102,4 @@ When performing a release, make sure to follow our conventional commit approach,
 ## License
 
 This project is APACHE, VERSION 2.0 licensed, see LICENSE.md for details.
+

package/dist/analytics/elastic.js

@@ -4,6 +4,13 @@ exports.Elastic = void 0;
 const test_1 = require("@playwright/test");
 const logger_1 = require("./logger");
 class Elastic {
+    request;
+    flakyTestIndex;
+    failedTestIndex;
+    testRunIndex;
+    browserUsageIndex;
+    elasticUrl;
+    elasticToken;
     constructor(analyticsConfig) {
         this.flakyTestIndex = analyticsConfig.flakyTestIndex;
         this.failedTestIndex = analyticsConfig.failedTestIndex;

package/dist/analytics/report.types.d.ts

@@ -1,5 +1,20 @@
 import { type TestStatus } from '@playwright/test/reporter';
 import type { ElasticConfig } from './elastic';
+/**
+ * CI/CD context information for test runs
+ */
+export interface CIContext {
+    /** Git branch name */
+    branchName?: string;
+    /** Git commit SHA */
+    commitSha?: string;
+    /** Pull request number */
+    prNumber?: string;
+    /** CI job identifier */
+    ciJobId?: string;
+    /** What triggered the run (push, pr, schedule, manual) */
+    triggeredBy?: string;
+}
 export interface TestAnalyticsData {
     timestamp: number;
     name: string;

package/dist/analytics/reporter.js

@@ -8,6 +8,20 @@ const helpers_1 = require("./helpers");
 const transform_1 = require("./transform");
 // eslint-disable-next-line import/no-default-export
 class AnalyticsReporter {
+    listOfNonPassingTests;
+    listOfFlakyTests;
+    browserCreationTimes;
+    browserUsage;
+    elastic;
+    runStartTime;
+    runEndTime;
+    numberOfTests;
+    testRunId;
+    projectNames;
+    testOwnerCount;
+    options;
+    isMainPREnv;
+    workerCount;
     constructor(options) {
         this.options = options;
         this.listOfNonPassingTests = [];

package/dist/analytics/transform.d.ts

@@ -7,6 +7,7 @@ export declare const calculateHooksDuration: (steps: TestStep[], hook: "before"
 export declare const getTeamNames: (test: TestCase) => {
     type: string;
     description?: string;
+    location?: import("playwright/types/test").Location;
 }[];
 export declare const formFailedTestData: (test: TestCase, result: TestResult, testRunId: string, prenvId?: string) => {
     prenvId?: string | undefined;

package/dist/datadog/datadog.d.ts

@@ -0,0 +1,25 @@
+import type { DatadogMetricsPayload, DatadogReporterOptions } from './report.types';
+/**
+ * Datadog API client for submitting metrics
+ */
+export declare class Datadog {
+    private request;
+    private readonly apiKey;
+    private readonly site;
+    private readonly debug;
+    constructor(options: Pick<DatadogReporterOptions, 'apiKey' | 'site' | 'debug'>);
+    private log;
+    /**
+     * Initialize the Playwright request context for API calls
+     */
+    setNativeRequestContext(): Promise<void>;
+    /**
+     * Submit metrics to Datadog Metrics API v2
+     * @see https://docs.datadoghq.com/api/latest/metrics/#submit-metrics
+     */
+    submitMetrics(payload: DatadogMetricsPayload): Promise<boolean>;
+    /**
+     * Close the request context
+     */
+    dispose(): Promise<void>;
+}

package/dist/datadog/datadog.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Datadog = void 0;
+const test_1 = require("@playwright/test");
+/**
+ * Returns the Datadog API endpoint for the given site
+ */
+const getApiEndpoint = (site) => {
+    const endpoints = {
+        'datadoghq.com': 'https://api.datadoghq.com',
+        'datadoghq.eu': 'https://api.datadoghq.eu',
+        'us3.datadoghq.com': 'https://api.us3.datadoghq.com',
+        'us5.datadoghq.com': 'https://api.us5.datadoghq.com',
+        'ap1.datadoghq.com': 'https://api.ap1.datadoghq.com',
+        'ddog-gov.com': 'https://api.ddog-gov.com',
+    };
+    return endpoints[site];
+};
+/**
+ * Datadog API client for submitting metrics
+ */
+class Datadog {
+    request;
+    apiKey;
+    site;
+    debug;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.site = options.site ?? 'datadoghq.eu';
+        this.debug = options.debug ?? false;
+    }
+    log(message, data) {
+        if (this.debug) {
+            // eslint-disable-next-line no-console
+            console.log(message, data !== undefined ? JSON.stringify(data, null, 2) : '');
+        }
+    }
+    /**
+     * Initialize the Playwright request context for API calls
+     */
+    async setNativeRequestContext() {
+        this.request = await test_1.request.newContext({
+            baseURL: getApiEndpoint(this.site),
+            extraHTTPHeaders: {
+                'DD-API-KEY': this.apiKey,
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    /**
+     * Submit metrics to Datadog Metrics API v2
+     * @see https://docs.datadoghq.com/api/latest/metrics/#submit-metrics
+     */
+    async submitMetrics(payload) {
+        try {
+            if (!this.request) {
+                // eslint-disable-next-line no-console
+                console.error('[Datadog] Request context not initialized. Call setNativeRequestContext first.');
+                return false;
+            }
+            this.log('[Datadog] Submitting metrics:', payload);
+            const response = await this.request.post('/api/v2/series', { data: payload });
+            if (!response.ok()) {
+                // eslint-disable-next-line no-console
+                console.error(`[Datadog] Failed to submit metrics: ${response.status()} - ${await response.text()}`);
+                return false;
+            }
+            this.log(`[Datadog] Successfully submitted ${payload.series.length} metric series`);
+            return true;
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error('[Datadog] Error submitting metrics:', error);
+            return false;
+        }
+    }
+    /**
+     * Close the request context
+     */
+    async dispose() {
+        if (this.request) {
+            await this.request.dispose();
+        }
+    }
+}
+exports.Datadog = Datadog;

package/dist/datadog/index.d.ts

@@ -0,0 +1,2 @@
+export { default as DatadogReporter, defineDatadogReporterConfig } from './reporter';
+export type { DatadogReporterOptions, DatadogSite, MetricTags, TestRunMetrics, TestMetrics, } from './report.types';

package/dist/datadog/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineDatadogReporterConfig = exports.DatadogReporter = void 0;
+var reporter_1 = require("./reporter");
+Object.defineProperty(exports, "DatadogReporter", { enumerable: true, get: function () { return __importDefault(reporter_1).default; } });
+Object.defineProperty(exports, "defineDatadogReporterConfig", { enumerable: true, get: function () { return reporter_1.defineDatadogReporterConfig; } });

package/dist/datadog/report.types.d.ts

@@ -0,0 +1,175 @@
+import type { CIContext } from '../analytics/report.types';
+/**
+ * Datadog site endpoints for different regions
+ */
+export type DatadogSite = 'datadoghq.com' | 'datadoghq.eu' | 'us3.datadoghq.com' | 'us5.datadoghq.com' | 'ap1.datadoghq.com' | 'ddog-gov.com';
+/**
+ * Configuration options for the Datadog reporter
+ */
+export type DatadogReporterOptions = {
+    /**
+     * Datadog API key for authentication.
+     * Can also be set via DD_API_KEY environment variable.
+     */
+    apiKey: string;
+    /**
+     * Datadog site/region endpoint.
+     * @default 'datadoghq.eu'
+     */
+    site?: DatadogSite;
+    /**
+     * Service name for metric namespace.
+     * @default 'playwright-tests'
+     */
+    service?: string;
+    /**
+     * Environment tag (e.g., 'ci', 'local', 'staging').
+     */
+    env?: string;
+    /**
+     * Product identifier for filtering metrics.
+     */
+    product?: string;
+    /**
+     * PR environment identifier.
+     */
+    prenvId?: string;
+    /**
+     * Enable debug logging.
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Skip sending data to Datadog (for testing).
+     * @default false
+     */
+    dryRun?: boolean;
+    /**
+     * CI/CD context information.
+     */
+    ci?: CIContext;
+};
+/**
+ * Datadog metric types for API v2
+ * @see https://docs.datadoghq.com/api/latest/metrics/#submit-metrics
+ * 0 = unspecified, 1 = count, 2 = rate, 3 = gauge
+ */
+export type MetricType = 0 | 1 | 2 | 3;
+export declare const MetricTypes: {
+    UNSPECIFIED: 0;
+    COUNT: 1;
+    RATE: 2;
+    GAUGE: 3;
+};
+/**
+ * A single metric point with timestamp and value
+ */
+export interface MetricPoint {
+    /** Unix timestamp in seconds */
+    timestamp: number;
+    /** Metric value */
+    value: number;
+}
+/**
+ * A metric series to submit to Datadog
+ */
+export interface MetricSeries {
+    /** Metric name (e.g., 'playwright.test_run.uptime') */
+    metric: string;
+    /** Metric type */
+    type: MetricType;
+    /** Metric points (timestamp + value pairs) */
+    points: MetricPoint[];
+    /** Tags for filtering and grouping */
+    tags?: string[];
+    /** Unit of the metric (optional) */
+    unit?: string;
+}
+/**
+ * Datadog Metrics API v2 request body
+ * @see https://docs.datadoghq.com/api/latest/metrics/#submit-metrics
+ */
+export interface DatadogMetricsPayload {
+    series: MetricSeries[];
+}
+/**
+ * Aggregated test run data for metrics generation
+ */
+export interface TestRunMetrics {
+    /** Test run unique identifier */
+    testRunId: string;
+    /** Unix timestamp when run started (seconds) */
+    timestamp: number;
+    /** Total number of tests */
+    totalTests: number;
+    /** Number of passed tests (including flaky that eventually passed) */
+    passedTests: number;
+    /** Number of failed tests (permanently failed) */
+    failedTests: number;
+    /** Number of flaky tests (passed after retry) */
+    flakyTests: number;
+    /** Number of skipped tests */
+    skippedTests: number;
+    /** Number of tests that timed out */
+    timedOutTests: number;
+    /** Total run duration in milliseconds */
+    durationMs: number;
+    /** Total time spent on browser creation in milliseconds */
+    browserCreationMs: number;
+    /** Total time spent on retries in milliseconds */
+    retryTimeMs: number;
+    /** Total time spent on page navigations in milliseconds */
+    navigationMs: number;
+    /** Whether all tests passed (uptime = 1) */
+    allPassed: boolean;
+    /** Pass rate as percentage (0-100) */
+    passRate: number;
+    /** Flaky rate as percentage (0-100) */
+    flakyRate: number;
+    /** Number of parallel workers */
+    workerCount: number;
+    /** Average test duration in milliseconds */
+    avgTestDurationMs: number;
+}
+/**
+ * Individual test metrics
+ */
+export interface TestMetrics {
+    /** Test name/title */
+    name: string;
+    /** Test stable ID */
+    testId: string;
+    /** Test duration in milliseconds */
+    durationMs: number;
+    /** Number of retries */
+    retryCount: number;
+    /** Whether this test was flaky */
+    isFlaky: boolean;
+    /** Whether this test timed out */
+    isTimedOut: boolean;
+    /** Team that owns this test */
+    team?: string;
+    /** Project name */
+    project?: string;
+    /** Navigation time in milliseconds */
+    navigationMs: number;
+}
+/**
+ * Tags to apply to all metrics
+ */
+export interface MetricTags {
+    /** Git branch name */
+    branch?: string;
+    /** Project name(s) */
+    project?: string[];
+    /** PR environment identifier */
+    prenvId?: string;
+    /** What triggered the run */
+    triggeredBy?: string;
+    /** Environment (ci, local, etc.) */
+    env?: string;
+    /** Service name */
+    service?: string;
+    /** Product identifier */
+    product?: string;
+}

package/dist/datadog/report.types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricTypes = void 0;
+exports.MetricTypes = {
+    UNSPECIFIED: 0,
+    COUNT: 1,
+    RATE: 2,
+    GAUGE: 3,
+};

package/dist/datadog/reporter.d.ts

@@ -0,0 +1,35 @@
+import { type FullConfig, type FullResult, type Reporter, type Suite, type TestCase, type TestResult, type TestStep } from '@playwright/test/reporter';
+import type { DatadogReporterOptions } from './report.types';
+/**
+ * Playwright reporter that sends test execution metrics to Datadog
+ */
+export default class DatadogReporter implements Reporter {
+    private readonly options;
+    private readonly datadog;
+    private readonly testRunId;
+    private runStartTime;
+    private runEndTime;
+    private totalTests;
+    private passedTests;
+    private failedTests;
+    private flakyTests;
+    private skippedTests;
+    private timedOutTests;
+    private browserCreationMs;
+    private retryTimeMs;
+    private navigationMs;
+    private workerCount;
+    private readonly testDurations;
+    private readonly testMetrics;
+    private projectNames;
+    private readonly currentTestNavigationMs;
+    constructor(options: DatadogReporterOptions);
+    onBegin(config: FullConfig, suite: Suite): Promise<void>;
+    onStepEnd(test: TestCase, result: TestResult, step: TestStep): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onEnd(result: FullResult): Promise<void>;
+}
+/**
+ * Helper function for type-safe configuration
+ */
+export declare const defineDatadogReporterConfig: (options: ConstructorParameters<typeof DatadogReporter>[0]) => DatadogReporterOptions;