testbeats 2.0.0 → 2.0.2

package/README.md

@@ -1,4 +1,4 @@
-> !IMPORTANT - This npm package has been renamed from [test-results-reporter](https://www.npmjs.com/package/test-results-reporter) to [testbeats](https://www.npmjs.com/package/testbeats). test-results-reporter will soon be phased out, and users are encouraged to transition to testbeats.
+> This npm package has been renamed from [test-results-reporter](https://www.npmjs.com/package/test-results-reporter) to [testbeats](https://www.npmjs.com/package/testbeats). test-results-reporter will soon be phased out, and users are encouraged to transition to testbeats.
 
 <span align="center">
 
@@ -19,35 +19,23 @@
 
 <hr>
 
-### Targets
-
-<img height="48" style="margin: 6px;" src="./assets/slack.png" alt="slack" /> <img height="48" style="margin: 6px;"  src="./assets/teams.png" alt="teams" /> <img height="48" style="margin: 6px;"  src="./assets/chat.png" alt="chat" />
-
-### Extensions
-
-<img height="48" style="margin: 6px;" src="./assets/reportportal.jpeg" alt="reportportal" /> <img height="48" style="margin: 6px;"  src="./assets/quickchart.png" alt="quickchart" /> <img height="48" style="margin: 6px;"  src="./assets/hyperlink.png" alt="hyperlink" /> <img height="48" style="margin: 6px;"  src="./assets/mentions.png" alt="mentions" />
-
-### Test Results
-
-<img height="48" style="margin: 6px;" src="./assets/testng.png" alt="testng" /> <img height="48" style="margin: 6px;"  src="./assets/junit.png" alt="junit" /> <img height="48" style="margin: 6px;"  src="./assets/cucumber.png" alt="cucumber" /> <img height="48" style="margin: 6px;"  src="./assets/mocha.png" alt="mocha" /> <img height="48" style="margin: 6px;"  src="./assets/xunit.png" alt="xunit" /> <img height="48" style="margin: 6px;"  src="./assets/jmeter.png" alt="jmeter" />
+</span>
 
-<hr>
+### Get Started
 
-## Sample Reports
+TestBeats is a tool designed to streamline the process of publishing test results from various automation testing frameworks to communication platforms like **slack**, **teams** and more for easy access and collaboration. It unifies your test reporting to build quality insights and make faster decisions.
 
-<br>
+Read more about the project at [https://testbeats.com](https://testbeats.com)
 
-![teams-summary-report](https://github.com/test-results-reporter/testbeats/raw/main/assets/teams-qc.png)
+### Sample Reports
 
-![slack-summary-report](https://github.com/test-results-reporter/testbeats/raw/main/assets/slack-report-portal-analysis.png)
+#### Alerts in Slack
 
-<br />
+![testbeats-failure-summary](./assets/testbeats-slack-failure-summary.png)
 
-<hr >
+#### Results in Portal
 
-# [Documentation](https://test-results-reporter.github.io/)
-
-</span>
+![testbeats-failure-summary](./assets/testbeats-failure-summary.png)
 
 <br />
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testbeats",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Publish test results to Microsoft Teams, Google Chat, Slack and InfluxDB",
   "main": "src/index.js",
   "types": "./src/index.d.ts",
@@ -44,7 +44,7 @@
   "bugs": {
     "url": "https://github.com/test-results-reporter/testbeats/issues"
   },
-  "homepage": "https://test-results-reporter.github.io",
+  "homepage": "https://testbeats.com",
   "dependencies": {
     "async-retry": "^1.3.3",
     "dotenv": "^14.3.2",

package/src/beats/beats.api.js

@@ -0,0 +1,40 @@
+const request = require('phin-retry');
+
+class BeatsApi {
+
+  /**
+   * @param {import('../index').PublishReport} config
+   */
+  constructor(config) {
+    this.config = config;
+  }
+
+  postTestRun(payload) {
+    return request.post({
+      url: `${this.getBaseUrl()}/api/core/v1/test-runs`,
+      headers: {
+        'x-api-key': this.config.api_key
+      },
+      body: payload
+    });
+  }
+
+ /**
+  * @param {string} run_id
+  * @returns
+  */
+  getTestRun(run_id) {
+    return request.get({
+      url: `${this.getBaseUrl()}/api/core/v1/test-runs/key?id=${run_id}`,
+      headers: {
+        'x-api-key': this.config.api_key
+      }
+    });
+  }
+
+  getBaseUrl() {
+    return process.env.TEST_BEATS_URL || "https://app.testbeats.com";
+  }
+}
+
+module.exports = { BeatsApi }

package/src/beats/beats.js

@@ -0,0 +1,151 @@
+const { getCIInformation } = require('../helpers/ci');
+const logger = require('../utils/logger');
+const { BeatsApi } = require('./beats.api');
+const { HOOK } = require('../helpers/constants');
+
+class Beats {
+
+  /**
+   * @param {import('../index').PublishReport} config
+   * @param {TestResult} result
+   */
+  constructor(config, result) {
+    this.config = config;
+    this.result = result;
+    this.api = new BeatsApi(config);
+    this.test_run_id = '';
+  }
+
+  async publish() {
+    this.#setCIInfo();
+    this.#setProjectName();
+    this.#setRunName();
+    this.#setApiKey();
+    await this.#publishTestResults();
+    this.#updateTitleLink();
+    await this.#attachFailureSummary();
+  }
+
+  #setCIInfo() {
+    this.ci = getCIInformation();
+  }
+
+  #setProjectName() {
+    this.config.project = this.config.project || process.env.TEST_BEATS_PROJECT || (this.ci && this.ci.repository_name) || 'demo-project';
+  }
+
+  #setApiKey() {
+    this.config.api_key = this.config.api_key || process.env.TEST_BEATS_API_KEY;
+  }
+
+  #setRunName() {
+    this.config.run = this.config.run || process.env.TEST_BEATS_RUN || (this.ci && this.ci.build_name) || 'demo-run';
+  }
+
+  async #publishTestResults() {
+    if (!this.config.api_key) {
+      logger.warn('😿 No API key provided, skipping publishing results to TestBeats Portal');
+      return;
+    }
+    logger.info("🚀 Publishing results to TestBeats Portal...");
+    try {
+      const payload = this.#getPayload();
+      const response = await this.api.postTestRun(payload);
+      this.test_run_id = response.id;
+    } catch (error) {
+      logger.error(`❌ Unable to publish results to TestBeats Portal: ${error.message}`, error);
+    }
+  }
+
+  #getPayload() {
+    const payload = {
+      project: this.config.project,
+      run: this.config.run,
+      ...this.result
+    }
+    if (this.ci) {
+      payload.ci_details = [this.ci];
+    }
+    return payload;
+  }
+
+  #updateTitleLink() {
+    if (!this.test_run_id) {
+      return;
+    }
+    if (!this.config.targets) {
+      return;
+    }
+    const link = `${this.api.getBaseUrl()}/reports/${this.test_run_id}`;
+    for (const target of this.config.targets) {
+      target.inputs.title_link = link;
+    }
+  }
+
+  async #attachFailureSummary() {
+    if (!this.test_run_id) {
+      return;
+    }
+    if (!this.config.targets) {
+      return;
+    }
+    if (this.result.status !== 'FAIL') {
+      return;
+    }
+    if (this.config.show_failure_summary === false) {
+      return;
+    }
+    const text = await this.#getFailureSummary();
+    if (!text) {
+      return;
+    }
+    const extension = this.#getAIFailureSummaryExtension(text);
+    for (const target of this.config.targets) {
+      target.extensions = target.extensions || [];
+      target.extensions.push(extension);
+    }
+  }
+
+  async #getFailureSummary() {
+    logger.info('✨ Fetching AI Failure Summary...');
+    let retry = 3;
+    while (retry >= 0) {
+      retry = retry - 1;
+      await new Promise(resolve => setTimeout(resolve, this.#getDelay()));
+      const test_run = await this.api.getTestRun(this.test_run_id);
+      const status = test_run && test_run.failure_summary_status;
+      switch (status) {
+        case 'COMPLETED':
+          return test_run.execution_metrics[0].failure_summary;
+        case 'FAILED':
+          logger.error(`❌ Failed to generate AI Failure Summary`);
+          return;
+        case 'SKIPPED':
+          logger.warn(`❗ Skipped generating AI Failure Summary`);
+          return;
+      }
+      logger.info(`🔄 AI Failure Summary not generated, retrying...`);
+    }
+    logger.warn(`🙈 AI Failure Summary not generated in given time`);
+  }
+
+  #getDelay() {
+    if (process.env.TEST_BEATS_DELAY) {
+      return parseInt(process.env.TEST_BEATS_DELAY);
+    }
+    return 3000;
+  }
+
+  #getAIFailureSummaryExtension(text) {
+    return {
+      name: 'ai-failure-summary',
+      hook: HOOK.AFTER_SUMMARY,
+      inputs: {
+        failure_summary: text
+      }
+    };
+  }
+
+}
+
+module.exports = { Beats }

package/src/beats/index.js

@@ -1,74 +1,13 @@
-const request = require('phin-retry');
 const TestResult = require('test-results-parser/src/models/TestResult');
-const { getCIInformation } = require('../helpers/ci');
-
-function get_base_url() {
-  return process.env.TEST_BEATS_URL || "https://app.testbeats.com";
-}
+const { Beats } = require('./beats');
 
 /**
  * @param {import('../index').PublishReport} config
  * @param {TestResult} result
  */
 async function run(config, result) {
-  if (config.project && config.run && config.api_key) {
-    const run_id = await publishTestResults(config, result);
-    if (run_id) {
-      attachTestBeatsReportHyperLink(config, run_id);
-    }
-  }
-}
-
-/**
- * @param {import('../index').PublishReport} config 
- * @param {TestResult} result
- */
-async function publishTestResults(config, result) {
-  try {
-    const payload = {
-      project: config.project,
-      run: config.run,
-      ...result
-    }
-    const ci = getCIInformation();
-    if (ci) {
-      payload.ci_details = [ci];
-    }
-    
-    const response = await request.post({
-      url: `${get_base_url()}/api/core/v1/test-runs`,
-      headers: {
-        'x-api-key': config.api_key
-      },
-      body: payload
-    });
-    return response.id;
-  } catch (error) {
-    console.log("Unable to publish results to TestBeats");
-    console.log(error);
-  }
-}
-
-/**
- * @param {import('../index').PublishReport} config
- * @param {string} run_id
- */
-function attachTestBeatsReportHyperLink(config, run_id) {
-  const beats_link = get_test_beats_report_link(run_id);
-  if (config.targets) {
-    for (const target of config.targets) {
-      target.inputs.title_link = beats_link;
-    }
-  }
-}
-
-/**
- * 
- * @param {string} run_id 
- * @returns 
- */
-function get_test_beats_report_link(run_id) {
-  return `${get_base_url()}/reports/${run_id}`;
+  const beats = new Beats(config, result);
+  await beats.publish();
 }
 
 module.exports = { run }

package/src/cli.js

@@ -2,20 +2,24 @@
 require('dotenv').config();
 
 const sade = require('sade');
- 
-const prog = sade('test-results-reporter');
+
+const prog = sade('testbeats');
 const publish = require('./commands/publish');
- 
+const logger = require('./utils/logger');
+
 prog
-  .version('0.0.7')
-  .option('-c, --config', 'Provide path to custom config', 'config.json');
+  .version('2.0.1')
+  .option('-c, --config', 'Provide path to custom config', 'config.json')
+  .option('-l, --logLevel', 'Log Level', "INFO");
 
 prog.command('publish')
   .action(async (opts) => {
     try {
+      logger.setLevel(opts.logLevel);
+      logger.info(`Initiating...`);
       await publish.run(opts);
     } catch (error) {
-      console.error(error);
+      logger.error(`Report publish failed: ${error.message}`);
       process.exit(1);
     }
   });

package/src/commands/publish.js

@@ -2,33 +2,51 @@ const path = require('path');
 const trp = require('test-results-parser');
 const prp = require('performance-results-parser');
 
+const pkg = require('../../package.json');
 const { processData } = require('../helpers/helper');
 const beats = require('../beats');
 const target_manager = require('../targets');
+const logger = require('../utils/logger');
 
 /**
- * @param {import('../index').PublishOptions} opts 
+ * @param {import('../index').PublishOptions} opts
  */
 async function run(opts) {
+  logger.info(`💡 TestBeats v${pkg.version}`);
+  if (!opts) {
+    throw new Error('Missing publish options');
+  }
+  if (!opts.config) {
+    throw new Error('Missing publish config');
+  }
   if (typeof opts.config === 'string') {
     const cwd = process.cwd();
-    opts.config = require(path.join(cwd, opts.config));
+    const file_path = path.join(cwd, opts.config);
+    try {
+      opts.config = require(path.join(cwd, opts.config));
+    } catch (error) {
+      throw new Error(`Config file not found: ${file_path}`);
+    }
   }
   const config = processData(opts.config);
   if (config.reports) {
     for (const report of config.reports) {
+      validateConfig(report);
       await processReport(report);
     }
   } else {
+    validateConfig(config);
     await processReport(config);
   }
+  logger.info('✅ Results published successfully!');
 }
 
 /**
- * 
- * @param {import('../index').PublishReport} report 
+ *
+ * @param {import('../index').PublishReport} report
  */
 async function processReport(report) {
+  logger.debug("processReport: Started")
   const parsed_results = [];
   for (const result_options of report.results) {
     if (result_options.type === 'custom') {
@@ -43,10 +61,106 @@ async function processReport(report) {
   for (let i = 0; i < parsed_results.length; i++) {
     const result = parsed_results[i];
     await beats.run(report, result);
-    for (const target of report.targets) {
-      await target_manager.run(target, result);
+    if (report.targets) {
+      for (const target of report.targets) {
+        await target_manager.run(target, result);
+      }
+    } else {
+      logger.warn('No targets defined, skipping sending results to targets');
+    }
+  }
+  logger.debug("processReport: Ended")
+}
+
+/**
+ *
+ * @param {import('../index').PublishReport} config
+ */
+function validateConfig(config) {
+  logger.info("🛠️  Validating configuration...")
+  if (!config) {
+    throw new Error('Missing configuration');
+  }
+  validateResults(config);
+  validateTargets(config);
+}
+
+/**
+ *
+ * @param {import('../index').PublishReport} config
+ */
+function validateResults(config) {
+  logger.debug("Validating results...")
+  if (!config.results) {
+    throw new Error('Missing results properties in config');
+  }
+  if (!Array.isArray(config.results)) {
+    throw new Error('results must be an array');
+  }
+  if (!config.results.length) {
+    throw new Error('At least one result must be defined');
+  }
+  for (const result of config.results) {
+    if (!result.type) {
+      throw new Error('Missing result type');
+    }
+    if (result.type === 'custom') {
+      if (!result.result) {
+        throw new Error('Missing result');
+      }
+    } else {
+      if (!result.files) {
+        throw new Error('Missing result files');
+      }
+      if (!Array.isArray(result.files)) {
+        throw new Error('result files must be an array');
+      }
+      if (!result.files.length) {
+        throw new Error('At least one result file must be defined');
+      }
+    }
+  }
+  logger.debug("Validating results - Successful!")
+}
+
+/**
+ *
+ * @param {import('../index').PublishReport} config
+ */
+function validateTargets(config) {
+  logger.debug("Validating targets...")
+  if (!config.targets) {
+    logger.warn('⚠️ Targets are not defined in config');
+    return;
+  }
+  if (!Array.isArray(config.targets)) {
+    throw new Error('targets must be an array');
+  }
+  for (const target of config.targets) {
+    if (!target.name) {
+      throw new Error('missing target name');
+    }
+    if (target.name === 'slack' || target.name === 'teams' || target.name === 'chat') {
+      if (!target.inputs) {
+        throw new Error(`missing inputs in ${target.name} target`);
+      }
+    }
+    if (target.inputs) {
+      const inputs = target.inputs;
+      if (target.name === 'slack' || target.name === 'teams' || target.name === 'chat') {
+        if (!inputs.url) {
+          throw new Error(`missing url in ${target.name} target inputs`);
+        }
+        if (typeof inputs.url !== 'string') {
+          throw new Error(`url in ${target.name} target inputs must be a string`);
+        }
+        if (!inputs.url.startsWith('http')) {
+          throw new Error(`url in ${target.name} target inputs must start with 'http' or 'https'`);
+        }
+      }
     }
   }
+  logger.debug("Validating targets - Successful!")
 }
 
 module.exports = {

package/src/extensions/ai-failure-summary.js

@@ -0,0 +1,72 @@
+const { STATUS, HOOK } = require("../helpers/constants");
+const { addChatExtension, addSlackExtension, addTeamsExtension } = require('../helpers/extension.helper');
+
+/**
+ * @param {object} param0
+ * @param {import('..').Target} param0.target
+ * @param {import('..').MetadataExtension} param0.extension
+ */
+async function run({ target, extension, result, payload, root_payload }) {
+  extension.inputs = Object.assign({}, default_inputs, extension.inputs);
+  if (target.name === 'teams') {
+    extension.inputs = Object.assign({}, default_inputs_teams, extension.inputs);
+    await attachForTeams({ target, extension, payload, result });
+  } else if (target.name === 'slack') {
+    extension.inputs = Object.assign({}, default_inputs_slack, extension.inputs);
+    await attachForSlack({ target, extension, payload, result });
+  } else if (target.name === 'chat') {
+    extension.inputs = Object.assign({}, default_inputs_chat, extension.inputs);
+    await attachForChat({ target, extension, payload, result });
+  }
+}
+
+/**
+ * @param {object} param0
+ * @param {import('..').MetadataExtension} param0.extension
+ */
+async function attachForTeams({ target, extension, payload, result }) {
+  const text = extension.inputs.failure_summary
+  if (text) {
+    addTeamsExtension({ payload, extension, text });
+  }
+}
+
+async function attachForSlack({ target, extension, payload, result }) {
+  const text = extension.inputs.failure_summary
+  if (text) {
+    addSlackExtension({ payload, extension, text });
+  }
+}
+
+async function attachForChat({ target, extension, payload, result }) {
+  const text = extension.inputs.failure_summary
+  if (text) {
+    addChatExtension({ payload, extension, text });
+  }
+}
+
+const default_options = {
+  hook: HOOK.AFTER_SUMMARY,
+  condition: STATUS.FAIL,
+}
+
+const default_inputs = {
+  title: 'AI Failure Summary ✨'
+}
+
+const default_inputs_teams = {
+  separator: true
+}
+
+const default_inputs_slack = {
+  separator: false
+}
+
+const default_inputs_chat = {
+  separator: true
+}
+
+module.exports = {
+  run,
+  default_options
+}

package/src/extensions/index.js

@@ -7,8 +7,10 @@ const percy_analysis = require('./percy-analysis');
 const custom = require('./custom');
 const metadata = require('./metadata');
 const ci_info = require('./ci-info');
+const ai_failure_summary = require('./ai-failure-summary');
 const { EXTENSION } = require('../helpers/constants');
 const { checkCondition } = require('../helpers/helper');
+const logger = require('../utils/logger');
 
 async function run(options) {
   const { target, result, hook } = options;
@@ -24,9 +26,9 @@ async function run(options) {
         try {
           await extension_runner.run(options);
         } catch (error) {
-          console.log('Failed to run extension');
-          console.log(extension);
-          console.log(error);
+          logger.error(`Failed to run extension: ${error.message}`);
+          logger.debug(`Extension details`, extension);
+          logger.debug(`Error: `, error);
         }
       }
     }
@@ -53,6 +55,8 @@ function getExtensionRunner(extension) {
       return metadata;
     case EXTENSION.CI_INFO:
       return ci_info;
+    case EXTENSION.AI_FAILURE_SUMMARY:
+      return ai_failure_summary;
     default:
       return require(extension.name);
   }

package/src/extensions/report-portal-history.js

@@ -1,6 +1,7 @@
 const { getSuiteHistory, getLastLaunchByName, getLaunchDetails } = require('../helpers/report-portal');
 const { addChatExtension, addSlackExtension, addTeamsExtension } = require('../helpers/extension.helper');
 const { HOOK, STATUS } = require('../helpers/constants');
+const logger = require('../utils/logger');
 
 async function getLaunchHistory(extension) {
   const { inputs, outputs } = extension;
@@ -71,8 +72,8 @@ async function run({ extension, target, payload }) {
       }
     }
   } catch (error) {
-    console.log('Failed to get report portal history');
-    console.log(error);
+    logger.error(`Failed to get report portal history: ${error.message}`);
+    logger.debug(`Error: ${error}`);
   }
 }
 

package/src/helpers/constants.js

@@ -20,6 +20,7 @@ const TARGET = Object.freeze({
 });
 
 const EXTENSION = Object.freeze({
+  AI_FAILURE_SUMMARY: 'ai-failure-summary',
   HYPERLINKS: 'hyperlinks',
   MENTIONS: 'mentions',
   REPORT_PORTAL_ANALYSIS: 'report-portal-analysis',

package/src/index.d.ts

@@ -4,7 +4,7 @@ import { Schedule, User } from 'rosters';
 import { ParseOptions } from 'test-results-parser';
 import TestResult from 'test-results-parser/src/models/TestResult';
 
-export type ExtensionName = 'report-portal-analysis' | 'hyperlinks' | 'mentions' | 'report-portal-history' | 'quick-chart-test-summary' | 'metadata' | 'ci-info' | 'custom';
+export type ExtensionName = 'report-portal-analysis' | 'hyperlinks' | 'mentions' | 'report-portal-history' | 'quick-chart-test-summary' | 'metadata' | 'ci-info' | 'custom' | 'ai-failure-summary';
 export type Hook = 'start' | 'end' | 'after-summary';
 export type TargetName = 'slack' | 'teams' | 'chat' | 'custom' | 'delay';
 export type PublishReportType = 'test-summary' | 'test-summary-slim' | 'failure-details';
@@ -61,11 +61,15 @@ export interface CIInfoInputs extends ExtensionInputs {
   data?: Metadata[];
 }
 
+export interface AIFailureSummaryInputs extends ExtensionInputs {
+  failure_summary: string;
+}
+
 export interface Extension {
   name: ExtensionName;
   condition?: Condition;
   hook?: Hook;
-  inputs?: ReportPortalAnalysisInputs | ReportPortalHistoryInputs | HyperlinkInputs | MentionInputs | QuickChartTestSummaryInputs | PercyAnalysisInputs | CustomExtensionInputs | MetadataInputs | CIInfoInputs;
+  inputs?: ReportPortalAnalysisInputs | ReportPortalHistoryInputs | HyperlinkInputs | MentionInputs | QuickChartTestSummaryInputs | PercyAnalysisInputs | CustomExtensionInputs | MetadataInputs | CIInfoInputs | AIFailureSummaryInputs;
 }
 
 export interface PercyAnalysisInputs extends ExtensionInputs {
@@ -208,8 +212,8 @@ export interface CustomTargetInputs {
 
 export interface Target {
   name: TargetName;
-  condition: Condition;
-  inputs: SlackInputs | TeamsInputs | ChatInputs | CustomTargetInputs | InfluxDBTargetInputs;
+  condition?: Condition;
+  inputs?: SlackInputs | TeamsInputs | ChatInputs | CustomTargetInputs | InfluxDBTargetInputs;
   extensions?: Extension[];
 }
 
@@ -222,6 +226,7 @@ export interface PublishReport {
   api_key?: string;
   project?: string;
   run?: string;
+  show_failure_summary?: boolean;
   targets?: Target[];
   results?: ParseOptions[] | PerformanceParseOptions[] | CustomResultOptions[];
 }
@@ -232,7 +237,6 @@ export interface PublishConfig {
   run?: string;
   targets?: Target[];
   results?: ParseOptions[] | PerformanceParseOptions[] | CustomResultOptions[];
-  reports?: PublishReport[];
 }
 
 export interface PublishOptions {

package/src/utils/logger.js

@@ -0,0 +1,98 @@
+const trm = console;
+
+const LEVEL_VERBOSE = 2;
+const LEVEL_TRACE = 3;
+const LEVEL_DEBUG = 4;
+const LEVEL_INFO = 5;
+const LEVEL_WARN = 6;
+const LEVEL_ERROR = 7;
+const LEVEL_SILENT = 8;
+
+/**
+ * returns log level value
+ * @param {string} level - log level
+ */
+function getLevelValue(level) {
+  const logLevel = level.toUpperCase();
+  switch (logLevel) {
+    case 'TRACE':
+      return LEVEL_TRACE;
+    case 'DEBUG':
+      return LEVEL_DEBUG;
+    case 'INFO':
+      return LEVEL_INFO;
+    case 'WARN':
+      return LEVEL_WARN;
+    case 'ERROR':
+      return LEVEL_ERROR;
+    case 'SILENT':
+      return LEVEL_SILENT;
+    case 'VERBOSE':
+      return LEVEL_VERBOSE;
+    default:
+      return LEVEL_INFO;
+  }
+}
+
+class Logger {
+
+  constructor() {
+    this.level = process.env.TESTBEATS_LOG_LEVEL || 'INFO';
+    this.levelValue = getLevelValue(this.level);
+    if (process.env.TESTBEATS_DISABLE_LOG_COLORS === 'true') {
+      options.disableColors = true;
+    }
+  }
+
+  /**
+   * sets log level
+   * @param {('TRACE'|'DEBUG'|'INFO'|'WARN'|'ERROR')} level - log level
+   */
+  setLevel(level) {
+    this.level = level;
+    this.levelValue = getLevelValue(this.level);
+  }
+
+  trace(...msg) {
+    if (this.levelValue <= LEVEL_TRACE) {
+      msg.forEach(m => trm.debug(m));
+    }
+  }
+
+  debug(...msg) {
+    if (this.levelValue <= LEVEL_DEBUG) {
+      msg.forEach(m => trm.debug(m));
+    }
+  }
+
+  info(...msg) {
+    if (this.levelValue <= LEVEL_INFO) {
+      msg.forEach(m => trm.info(m));
+    }
+  }
+
+  warn(...msg) {
+    if (this.levelValue <= LEVEL_WARN) {
+      msg.forEach(m => trm.warn(getMessage(m)));
+    }
+  }
+
+  error(...msg) {
+    if (this.levelValue <= LEVEL_ERROR) {
+      msg.forEach(m => trm.error(getMessage(m)));
+    }
+  }
+
+}
+
+
+function getMessage(msg) {
+  try {
+    return typeof msg === 'object' ? JSON.stringify(msg, null, 2) : msg;
+  } catch (_) {
+    return msg;
+  }
+}
+
+
+module.exports = new Logger();