diff --git a/.github/component_owners.yml b/.github/component_owners.yml index f04e7f2001..a3ad46b401 100644 --- a/.github/component_owners.yml +++ b/.github/component_owners.yml @@ -38,6 +38,8 @@ components: - blumamir plugins/node/instrumentation-amqplib: - blumamir + plugins/node/instrumentation-cucumber: + - Ugzuzg plugins/node/instrumentation-dataloader: - henrinormak plugins/node/instrumentation-fs: diff --git a/.release-please-manifest.json b/.release-please-manifest.json index d70e6b8150..b56847c2f5 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1 +1 @@ -{"detectors/node/opentelemetry-resource-detector-alibaba-cloud":"0.28.0","detectors/node/opentelemetry-resource-detector-aws":"1.3.0","detectors/node/opentelemetry-resource-detector-container":"0.3.0","detectors/node/opentelemetry-resource-detector-gcp":"0.29.0","detectors/node/opentelemetry-resource-detector-github":"0.28.0","detectors/node/opentelemetry-resource-detector-instana":"0.5.0","metapackages/auto-instrumentations-node":"0.38.0","metapackages/auto-instrumentations-web":"0.33.0","packages/opentelemetry-host-metrics":"0.33.0","packages/opentelemetry-id-generator-aws-xray":"1.2.0","packages/opentelemetry-propagation-utils":"0.30.0","packages/opentelemetry-redis-common":"0.36.0","packages/opentelemetry-sql-common":"0.40.0","packages/opentelemetry-test-utils":"0.34.0","plugins/node/instrumentation-amqplib":"0.33.0","plugins/node/instrumentation-dataloader":"0.5.0","plugins/node/instrumentation-fs":"0.8.0","plugins/node/instrumentation-lru-memoizer":"0.33.0","plugins/node/instrumentation-mongoose":"0.33.0","plugins/node/instrumentation-socket.io":"0.34.0","plugins/node/instrumentation-tedious":"0.6.0","plugins/node/opentelemetry-instrumentation-aws-lambda":"0.36.0","plugins/node/opentelemetry-instrumentation-aws-sdk":"0.35.0","plugins/node/opentelemetry-instrumentation-bunyan":"0.32.0","plugins/node/opentelemetry-instrumentation-cassandra":"0.33.0","plugins/node/opentelemetry-instrumentation-connect":"0.32.0","plugins/node/opentelemetry-instrumentation-dns":"0.32.0","plugins/node/opentelemetry-instrumentation-express":"0.33.0","plugins/node/opentelemetry-instrumentation-fastify":"0.32.0","plugins/node/opentelemetry-instrumentation-generic-pool":"0.32.0","plugins/node/opentelemetry-instrumentation-graphql":"0.35.0","plugins/node/opentelemetry-instrumentation-hapi":"0.32.0","plugins/node/opentelemetry-instrumentation-ioredis":"0.35.0","plugins/node/opentelemetry-instrumentation-knex":"0.32.0","plugins/node/opentelemetry-instrumentation-koa":"0.35.0","plugins/node/opentelemetry-instrumentation-memcached":"0.32.0","plugins/node/opentelemetry-instrumentation-mongodb":"0.36.0","plugins/node/opentelemetry-instrumentation-mysql":"0.34.0","plugins/node/opentelemetry-instrumentation-mysql2":"0.34.0","plugins/node/opentelemetry-instrumentation-nestjs-core":"0.33.0","plugins/node/opentelemetry-instrumentation-net":"0.32.0","plugins/node/opentelemetry-instrumentation-pg":"0.36.0","plugins/node/opentelemetry-instrumentation-pino":"0.34.0","plugins/node/opentelemetry-instrumentation-redis":"0.35.0","plugins/node/opentelemetry-instrumentation-redis-4":"0.35.0","plugins/node/opentelemetry-instrumentation-restify":"0.33.0","plugins/node/opentelemetry-instrumentation-router":"0.33.0","plugins/node/opentelemetry-instrumentation-winston":"0.32.0","plugins/web/opentelemetry-instrumentation-document-load":"0.33.0","plugins/web/opentelemetry-instrumentation-long-task":"0.33.0","plugins/web/opentelemetry-instrumentation-user-interaction":"0.33.0","plugins/web/opentelemetry-plugin-react-load":"0.29.0","propagators/opentelemetry-propagator-aws-xray":"1.3.0","propagators/opentelemetry-propagator-grpc-census-binary":"0.27.0","propagators/opentelemetry-propagator-instana":"0.3.0","propagators/opentelemetry-propagator-ot-trace":"0.27.0"} +{"detectors/node/opentelemetry-resource-detector-alibaba-cloud":"0.28.0","detectors/node/opentelemetry-resource-detector-aws":"1.3.0","detectors/node/opentelemetry-resource-detector-container":"0.3.0","detectors/node/opentelemetry-resource-detector-gcp":"0.29.0","detectors/node/opentelemetry-resource-detector-github":"0.28.0","detectors/node/opentelemetry-resource-detector-instana":"0.5.0","metapackages/auto-instrumentations-node":"0.38.0","metapackages/auto-instrumentations-web":"0.33.0","packages/opentelemetry-host-metrics":"0.33.0","packages/opentelemetry-id-generator-aws-xray":"1.2.0","packages/opentelemetry-propagation-utils":"0.30.0","packages/opentelemetry-redis-common":"0.36.0","packages/opentelemetry-sql-common":"0.40.0","packages/opentelemetry-test-utils":"0.34.0","plugins/node/instrumentation-amqplib":"0.33.0","plugins/node/instrumentation-cucumber":"0.0.1","plugins/node/instrumentation-dataloader":"0.5.0","plugins/node/instrumentation-fs":"0.8.0","plugins/node/instrumentation-lru-memoizer":"0.33.0","plugins/node/instrumentation-mongoose":"0.33.0","plugins/node/instrumentation-socket.io":"0.34.0","plugins/node/instrumentation-tedious":"0.6.0","plugins/node/opentelemetry-instrumentation-aws-lambda":"0.36.0","plugins/node/opentelemetry-instrumentation-aws-sdk":"0.35.0","plugins/node/opentelemetry-instrumentation-bunyan":"0.32.0","plugins/node/opentelemetry-instrumentation-cassandra":"0.33.0","plugins/node/opentelemetry-instrumentation-connect":"0.32.0","plugins/node/opentelemetry-instrumentation-dns":"0.32.0","plugins/node/opentelemetry-instrumentation-express":"0.33.0","plugins/node/opentelemetry-instrumentation-fastify":"0.32.0","plugins/node/opentelemetry-instrumentation-generic-pool":"0.32.0","plugins/node/opentelemetry-instrumentation-graphql":"0.35.0","plugins/node/opentelemetry-instrumentation-hapi":"0.32.0","plugins/node/opentelemetry-instrumentation-ioredis":"0.35.0","plugins/node/opentelemetry-instrumentation-knex":"0.32.0","plugins/node/opentelemetry-instrumentation-koa":"0.35.0","plugins/node/opentelemetry-instrumentation-memcached":"0.32.0","plugins/node/opentelemetry-instrumentation-mongodb":"0.36.0","plugins/node/opentelemetry-instrumentation-mysql":"0.34.0","plugins/node/opentelemetry-instrumentation-mysql2":"0.34.0","plugins/node/opentelemetry-instrumentation-nestjs-core":"0.33.0","plugins/node/opentelemetry-instrumentation-net":"0.32.0","plugins/node/opentelemetry-instrumentation-pg":"0.36.0","plugins/node/opentelemetry-instrumentation-pino":"0.34.0","plugins/node/opentelemetry-instrumentation-redis":"0.35.0","plugins/node/opentelemetry-instrumentation-redis-4":"0.35.0","plugins/node/opentelemetry-instrumentation-restify":"0.33.0","plugins/node/opentelemetry-instrumentation-router":"0.33.0","plugins/node/opentelemetry-instrumentation-winston":"0.32.0","plugins/web/opentelemetry-instrumentation-document-load":"0.33.0","plugins/web/opentelemetry-instrumentation-long-task":"0.33.0","plugins/web/opentelemetry-instrumentation-user-interaction":"0.33.0","plugins/web/opentelemetry-plugin-react-load":"0.29.0","propagators/opentelemetry-propagator-aws-xray":"1.3.0","propagators/opentelemetry-propagator-grpc-census-binary":"0.27.0","propagators/opentelemetry-propagator-instana":"0.3.0","propagators/opentelemetry-propagator-ot-trace":"0.27.0"} diff --git a/metapackages/auto-instrumentations-node/README.md b/metapackages/auto-instrumentations-node/README.md index 0795f15b77..cc45a14dbe 100644 --- a/metapackages/auto-instrumentations-node/README.md +++ b/metapackages/auto-instrumentations-node/README.md @@ -140,6 +140,7 @@ registerInstrumentations({ - [@opentelemetry/instrumentation-bunyan](https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/plugins/node/opentelemetry-instrumentation-bunyan) - [@opentelemetry/instrumentation-cassandra-driver](https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/plugins/node/opentelemetry-instrumentation-cassandra) - [@opentelemetry/instrumentation-connect](https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/plugins/node/opentelemetry-instrumentation-connect) +- [@opentelemetry/instrumentation-cucumber](https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/plugins/node/instrumentation-cucumber) - [@opentelemetry/instrumentation-dataloader](https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/plugins/node/instrumentation-dataloader) - [@opentelemetry/instrumentation-dns](https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/plugins/node/opentelemetry-instrumentation-dns) - [@opentelemetry/instrumentation-express](https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/plugins/node/opentelemetry-instrumentation-express) diff --git a/metapackages/auto-instrumentations-node/package.json b/metapackages/auto-instrumentations-node/package.json index 7e9502eeb9..3902c6ee3e 100644 --- a/metapackages/auto-instrumentations-node/package.json +++ b/metapackages/auto-instrumentations-node/package.json @@ -56,6 +56,7 @@ "@opentelemetry/instrumentation-bunyan": "^0.32.0", "@opentelemetry/instrumentation-cassandra-driver": "^0.33.0", "@opentelemetry/instrumentation-connect": "^0.32.0", + "@opentelemetry/instrumentation-cucumber": "^0.0.1", "@opentelemetry/instrumentation-dataloader": "^0.5.0", "@opentelemetry/instrumentation-dns": "^0.32.0", "@opentelemetry/instrumentation-express": "^0.33.0", diff --git a/metapackages/auto-instrumentations-node/src/utils.ts b/metapackages/auto-instrumentations-node/src/utils.ts index 0c194f7a30..ce9f6c8966 100644 --- a/metapackages/auto-instrumentations-node/src/utils.ts +++ b/metapackages/auto-instrumentations-node/src/utils.ts @@ -23,6 +23,7 @@ import { AwsInstrumentation } from '@opentelemetry/instrumentation-aws-sdk'; import { BunyanInstrumentation } from '@opentelemetry/instrumentation-bunyan'; import { CassandraDriverInstrumentation } from '@opentelemetry/instrumentation-cassandra-driver'; import { ConnectInstrumentation } from '@opentelemetry/instrumentation-connect'; +import { CucumberInstrumentation } from '@opentelemetry/instrumentation-cucumber'; import { DataloaderInstrumentation } from '@opentelemetry/instrumentation-dataloader'; import { DnsInstrumentation } from '@opentelemetry/instrumentation-dns'; import { ExpressInstrumentation } from '@opentelemetry/instrumentation-express'; @@ -90,6 +91,7 @@ const InstrumentationMap = { '@opentelemetry/instrumentation-cassandra-driver': CassandraDriverInstrumentation, '@opentelemetry/instrumentation-connect': ConnectInstrumentation, + '@opentelemetry/instrumentation-cucumber': CucumberInstrumentation, '@opentelemetry/instrumentation-dataloader': DataloaderInstrumentation, '@opentelemetry/instrumentation-dns': DnsInstrumentation, '@opentelemetry/instrumentation-express': ExpressInstrumentation, diff --git a/plugins/node/instrumentation-cucumber/.eslintignore b/plugins/node/instrumentation-cucumber/.eslintignore new file mode 100644 index 0000000000..378eac25d3 --- /dev/null +++ b/plugins/node/instrumentation-cucumber/.eslintignore @@ -0,0 +1 @@ +build diff --git a/plugins/node/instrumentation-cucumber/.eslintrc.js b/plugins/node/instrumentation-cucumber/.eslintrc.js new file mode 100644 index 0000000000..f756f4488b --- /dev/null +++ b/plugins/node/instrumentation-cucumber/.eslintrc.js @@ -0,0 +1,7 @@ +module.exports = { + "env": { + "mocha": true, + "node": true + }, + ...require('../../../eslint.config.js') +} diff --git a/plugins/node/instrumentation-cucumber/.npmignore b/plugins/node/instrumentation-cucumber/.npmignore new file mode 100644 index 0000000000..9505ba9450 --- /dev/null +++ b/plugins/node/instrumentation-cucumber/.npmignore @@ -0,0 +1,4 @@ +/bin +/coverage +/doc +/test diff --git a/plugins/node/instrumentation-cucumber/.tav.yml b/plugins/node/instrumentation-cucumber/.tav.yml new file mode 100644 index 0000000000..c1930c8cb2 --- /dev/null +++ b/plugins/node/instrumentation-cucumber/.tav.yml @@ -0,0 +1,3 @@ +'@cucumber/cucumber': + versions: '^8.0.0 || ^9.0.0' + commands: npm test diff --git a/plugins/node/instrumentation-cucumber/LICENSE b/plugins/node/instrumentation-cucumber/LICENSE new file mode 100644 index 0000000000..e50e8c80f9 --- /dev/null +++ b/plugins/node/instrumentation-cucumber/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [2022] OpenTelemetry Authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/plugins/node/instrumentation-cucumber/README.md b/plugins/node/instrumentation-cucumber/README.md new file mode 100644 index 0000000000..c3fd434353 --- /dev/null +++ b/plugins/node/instrumentation-cucumber/README.md @@ -0,0 +1,60 @@ +# OpenTelemetry Cucumber Instrumentation for Node.js + +[![NPM Published Version][npm-img]][npm-url] +[![Apache License][license-image]][license-image] + +This module provides automatic instrumentation for the [`@cucumber/cucumber`](https://www.npmjs.com/package/@cucumber/cucumber) module, which may be loaded using the [`@opentelemetry/sdk-trace-node`](https://github.com/open-telemetry/opentelemetry-js/tree/main/packages/opentelemetry-sdk-trace-node) package and is included in the [`@opentelemetry/auto-instrumentations-node`](https://www.npmjs.com/package/@opentelemetry/auto-instrumentations-node) bundle. + +If total installation size is not constrained, it is recommended to use the [`@opentelemetry/auto-instrumentations-node`](https://www.npmjs.com/package/@opentelemetry/auto-instrumentations-node) bundle with [@opentelemetry/sdk-node](`https://www.npmjs.com/package/@opentelemetry/sdk-node`) for the most seamless instrumentation experience. + +Compatible with OpenTelemetry JS API and SDK `1.0+`. + +## Installation + +```bash +npm install --save @opentelemetry/instrumentation-cucumber +``` + +## Usage + +```js +const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node'); +const { + CucumberInstrumentation, +} = require('@opentelemetry/instrumentation-cucumber'); +const { registerInstrumentations } = require('@opentelemetry/instrumentation'); + +const provider = new NodeTracerProvider(); +provider.register(); + +registerInstrumentations({ + instrumentations: [ + new CucucmberInstrumentation({ + // see below for available configuration + }), + ], +}); +``` + +### Cucumber Instrumentation Options + +Cucumber instrumentation has currently no options. + +| Options | Type | Description | +| ------- | ---- | ----------- | + +## Useful links + +- For more information on OpenTelemetry, visit: +- For more about OpenTelemetry JavaScript: +- For help or feedback on this project, join us in [GitHub Discussions][discussions-url] + +## License + +Apache 2.0 - See [LICENSE][license-url] for more information. + +[discussions-url]: https://github.com/open-telemetry/opentelemetry-js/discussions +[license-url]: https://github.com/open-telemetry/opentelemetry-js-contrib/blob/main/LICENSE +[license-image]: https://img.shields.io/badge/license-Apache_2.0-green.svg?style=flat +[npm-url]: https://www.npmjs.com/package/@opentelemetry/instrumentation-cucumber +[npm-img]: https://badge.fury.io/js/%40opentelemetry%2Finstrumentation-cucumber.svg diff --git a/plugins/node/instrumentation-cucumber/package.json b/plugins/node/instrumentation-cucumber/package.json new file mode 100644 index 0000000000..01015203cd --- /dev/null +++ b/plugins/node/instrumentation-cucumber/package.json @@ -0,0 +1,73 @@ +{ + "name": "@opentelemetry/instrumentation-cucumber", + "version": "0.0.1", + "description": "OpenTelemetry cucumber automatic instrumentation package.", + "main": "build/src/index.js", + "types": "build/src/index.d.ts", + "repository": "open-telemetry/opentelemetry-js-contrib", + "scripts": { + "test": "nyc ts-mocha -p tsconfig.json 'test/**/*.test.ts'", + "test-all-versions": "tav", + "tdd": "npm run test -- --watch-extensions ts --watch", + "clean": "rimraf build/*", + "lint": "eslint . --ext .ts", + "lint:fix": "eslint . --ext .ts --fix", + "precompile": "tsc --version && lerna run version:update --scope @opentelemetry/instrumentation-cucumber --include-dependencies", + "prewatch": "npm run precompile", + "prepare": "npm run compile", + "version:update": "node ../../../scripts/version-update.js", + "compile": "tsc -p ." + }, + "keywords": [ + "cucumber", + "instrumentation", + "nodejs", + "opentelemetry", + "profiling", + "tracing" + ], + "author": "OpenTelemetry Authors", + "license": "Apache-2.0", + "engines": { + "node": ">=14" + }, + "files": [ + "build/src/**/*.js", + "build/src/**/*.js.map", + "build/src/**/*.d.ts", + "doc", + "LICENSE", + "README.md" + ], + "publishConfig": { + "access": "public" + }, + "peerDependencies": { + "@opentelemetry/api": "^1.0.0" + }, + "devDependencies": { + "@cucumber/cucumber": "^8.8.0", + "@opentelemetry/api": "^1.0.0", + "@opentelemetry/core": "^1.3.1", + "@opentelemetry/sdk-trace-base": "^1.3.1", + "@opentelemetry/sdk-trace-node": "^1.3.1", + "@types/mocha": "7.0.2", + "@types/semver": "7.3.8", + "@types/shimmer": "1.0.2", + "@types/sinon": "10.0.2", + "gts": "3.1.0", + "mocha": "7.2.0", + "nyc": "15.1.0", + "rimraf": "3.0.2", + "semver": "^7.3.2", + "sinon": "14.0.0", + "test-all-versions": "5.0.1", + "ts-mocha": "10.0.0", + "typescript": "4.3.5" + }, + "dependencies": { + "@opentelemetry/instrumentation": "^0.36.0", + "@opentelemetry/semantic-conventions": "^1.0.0" + }, + "homepage": "https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/plugins/node/instrumentation-cucumber#readme" +} diff --git a/plugins/node/instrumentation-cucumber/src/index.ts b/plugins/node/instrumentation-cucumber/src/index.ts new file mode 100644 index 0000000000..c26f998cff --- /dev/null +++ b/plugins/node/instrumentation-cucumber/src/index.ts @@ -0,0 +1,18 @@ +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +export * from './instrumentation'; +export * from './types'; diff --git a/plugins/node/instrumentation-cucumber/src/instrumentation.ts b/plugins/node/instrumentation-cucumber/src/instrumentation.ts new file mode 100644 index 0000000000..cf759ddaae --- /dev/null +++ b/plugins/node/instrumentation-cucumber/src/instrumentation.ts @@ -0,0 +1,400 @@ +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { Span, SpanKind, SpanStatusCode } from '@opentelemetry/api'; +import { + InstrumentationBase, + InstrumentationNodeModuleDefinition, + InstrumentationNodeModuleFile, + isWrapped, +} from '@opentelemetry/instrumentation'; +import { SemanticAttributes } from '@opentelemetry/semantic-conventions'; + +import type * as cucumber from '@cucumber/cucumber'; +import type * as messages from '@cucumber/messages'; +import type TestCaseRunner from '@cucumber/cucumber/lib/runtime/test_case_runner'; +import type { + DefineStepPattern, + IDefineStepOptions, + IDefineTestRunHookOptions, +} from '@cucumber/cucumber/lib/support_code_library_builder/types'; + +import { AttributeNames, CucumberInstrumentationConfig } from './types'; +import { VERSION } from './version'; + +const hooks = ['Before', 'BeforeStep', 'AfterStep', 'After'] as const; +const steps = ['Given', 'When', 'Then'] as const; +type Cucumber = typeof cucumber; +type Hook = (typeof hooks)[number]; +type Step = (typeof steps)[number]; + +export class CucumberInstrumentation extends InstrumentationBase { + private module: Cucumber | undefined; + + constructor(config: CucumberInstrumentationConfig = {}) { + super('@opentelemetry/instrumentation-cucumber', VERSION, config); + } + + init(): InstrumentationNodeModuleDefinition[] { + return [ + new InstrumentationNodeModuleDefinition( + '@cucumber/cucumber', + ['^8.0.0', '^9.0.0'], + (moduleExports, moduleVersion) => { + this._diag.debug( + `Applying patch for @cucumber/cucumber@${moduleVersion}` + ); + this.module = moduleExports; + steps.forEach(step => { + if (isWrapped(moduleExports[step])) { + this._unwrap(moduleExports, step); + } + this._wrap(moduleExports, step, this._getStepPatch(step)); + }); + hooks.forEach(hook => { + if (isWrapped(moduleExports[hook])) { + this._unwrap(moduleExports, hook); + } + this._wrap(moduleExports, hook, this._getHookPatch(hook)); + }); + return moduleExports; + }, + (moduleExports, moduleVersion) => { + if (moduleExports === undefined) return; + this._diag.debug( + `Removing patch for @cucumber/cucumber@${moduleVersion}` + ); + [...hooks, ...steps].forEach(method => { + this._unwrap(moduleExports, method); + }); + }, + [ + new InstrumentationNodeModuleFile<{ + default: { new (): TestCaseRunner; prototype: TestCaseRunner }; + }>( + '@cucumber/cucumber/lib/runtime/test_case_runner.js', + ['^8.0.0', '^9.0.0'], + (moduleExports, moduleVersion) => { + this._diag.debug( + `Applying patch for @cucumber/cucumber/lib/runtime/test_case_runner.js@${moduleVersion}` + ); + if (isWrapped(moduleExports.default.prototype.run)) { + this._unwrap(moduleExports.default.prototype, 'run'); + this._unwrap(moduleExports.default.prototype, 'runStep'); + if ('runAttempt' in moduleExports.default.prototype) { + this._unwrap(moduleExports.default.prototype, 'runAttempt'); + } + } + this._wrap( + moduleExports.default.prototype, + 'run', + this._getTestCaseRunPatch() + ); + this._wrap( + moduleExports.default.prototype, + 'runStep', + this._getTestCaseRunStepPatch() + ); + if ('runAttempt' in moduleExports.default.prototype) { + this._wrap( + moduleExports.default.prototype, + 'runAttempt', + this._getTestCaseRunAttemptPatch() + ); + } + return moduleExports; + }, + (moduleExports, moduleVersion) => { + if (moduleExports === undefined) return; + this._diag.debug( + `Removing patch for @cucumber/cucumber/lib/runtime/test_case_runner.js@${moduleVersion}` + ); + this._unwrap(moduleExports.default.prototype, 'run'); + this._unwrap(moduleExports.default.prototype, 'runStep'); + if ('runAttempt' in moduleExports.default.prototype) { + this._unwrap(moduleExports.default.prototype, 'runAttempt'); + } + } + ), + ] + ), + ]; + } + + private static mapTags(tags: readonly messages.Tag[]): string[] { + return tags.map(tag => tag.name); + } + + private static setSpanToError(span: Span, error: any) { + span.recordException(error); + span.setStatus({ + code: SpanStatusCode.ERROR, + message: error?.message ?? error, + }); + } + + private setSpanToStepStatus( + span: Span, + status: messages.TestStepResultStatus, + context?: string + ) { + // if the telemetry is enabled, the module should be defined + if (!this.module) return; + + span.setAttribute(AttributeNames.STEP_STATUS, status); + if ( + [ + this.module.Status.UNDEFINED, + this.module.Status.AMBIGUOUS, + this.module.Status.FAILED, + ].includes(status) + ) { + span.recordException(status); + span.setStatus({ + code: SpanStatusCode.ERROR, + message: context || status, + }); + } + } + + private _getTestCaseRunPatch() { + const instrumentation = this; + return function (original: TestCaseRunner['run']): TestCaseRunner['run'] { + return async function (this: TestCaseRunner, ...args) { + const gherkinDocument = this[ + 'gherkinDocument' + ] as Required; + const { feature } = gherkinDocument; + const pickle = this['pickle'] as messages.Pickle; + const scenario = feature.children.find( + node => node?.scenario?.id === pickle.astNodeIds[0] + )?.scenario as messages.Scenario; + + return instrumentation.tracer.startActiveSpan( + `Feature: ${feature.name}. Scenario: ${pickle.name}`, + { + kind: SpanKind.CLIENT, + attributes: { + [SemanticAttributes.CODE_FILEPATH]: gherkinDocument.uri, + [SemanticAttributes.CODE_LINENO]: scenario.location.line, + [SemanticAttributes.CODE_FUNCTION]: scenario.name, + [SemanticAttributes.CODE_NAMESPACE]: feature.name, + [AttributeNames.FEATURE_TAGS]: CucumberInstrumentation.mapTags( + feature.tags + ), + [AttributeNames.FEATURE_LANGUAGE]: feature.language, + [AttributeNames.FEATURE_DESCRIPTION]: feature.description, + [AttributeNames.SCENARIO_TAGS]: CucumberInstrumentation.mapTags( + scenario.tags + ), + [AttributeNames.SCENARIO_DESCRIPTION]: scenario.description, + }, + }, + async span => { + try { + const status = await original.apply(this, args); + instrumentation.setSpanToStepStatus(span, status); + return status; + } catch (error: any) { + CucumberInstrumentation.setSpanToError(span, error); + throw error; + } finally { + span.end(); + } + } + ); + }; + }; + } + + private _getTestCaseRunStepPatch() { + const instrumentation = this; + return function ( + original: TestCaseRunner['runStep'] + ): TestCaseRunner['runStep'] { + return async function ( + this: TestCaseRunner, + ...args + ): Promise { + const [pickleStep] = args; + return instrumentation.tracer.startActiveSpan( + pickleStep.text, + { + kind: SpanKind.CLIENT, + attributes: { + [AttributeNames.STEP_TYPE]: pickleStep.type, + }, + }, + async span => { + try { + const result = await original.apply(this, args); + instrumentation.setSpanToStepStatus( + span, + result.status, + result.message + ); + return result; + } catch (error) { + CucumberInstrumentation.setSpanToError(span, error); + throw error; + } finally { + span.end(); + } + } + ); + }; + }; + } + + private _getTestCaseRunAttemptPatch() { + const instrumentation = this; + return function ( + original: TestCaseRunner['runAttempt'] + ): TestCaseRunner['runAttempt'] { + return async function (this: TestCaseRunner, ...args): Promise { + const [attempt] = args; + return instrumentation.tracer.startActiveSpan( + `Attempt #${attempt}`, + { + kind: SpanKind.CLIENT, + attributes: {}, + }, + async span => { + try { + const result = await original.apply(this, args); + const worstResult = this.getWorstStepResult(); + instrumentation.setSpanToStepStatus( + span, + worstResult.status, + worstResult.message + ); + return result; + } catch (error) { + CucumberInstrumentation.setSpanToError(span, error); + throw error; + } finally { + span.end(); + } + } + ); + }; + }; + } + + private _getHookPatch(name: H) { + const instrumentation = this; + return function (original: Cucumber[H]): Cucumber[H] { + return function ( + this: {}, + tagsOrOptions: string | IDefineTestRunHookOptions | Function, + code?: Function + ) { + if (typeof tagsOrOptions === 'function') { + code = tagsOrOptions; + tagsOrOptions = {}; + } + + function traceableCode( + this: cucumber.IWorld, + arg: cucumber.ITestCaseHookParameter + ) { + // because we're wrapping the function that was passed to the hook, + // it will stay wrapped in cucumber's internal state + // even if we disable the instrumentation + if (!instrumentation.isEnabled()) return code?.call(this, arg); + + return instrumentation.tracer.startActiveSpan( + name, + { + kind: SpanKind.CLIENT, + }, + async span => { + try { + return await code?.call(this, arg); + } catch (error: any) { + this.attach?.(JSON.stringify(span.spanContext())); + CucumberInstrumentation.setSpanToError(span, error); + throw error; + } finally { + span.end(); + } + } + ); + } + return original.call(this, tagsOrOptions as any, traceableCode as any); + }; + }; + } + + private _getStepPatch(name: S) { + const instrumentation = this; + return function (original: Cucumber[S]): Cucumber[S] { + return function ( + this: {}, + pattern: DefineStepPattern, + options: IDefineStepOptions | Function, + code?: Function + ): void { + if (typeof options === 'function') { + code = options; + options = {}; + } + + function traceableCode(this: cucumber.IWorld, ...args: any[]) { + // because we're wrapping the function that was passed to the hook, + // it will stay wrapped in cucumber's internal state + // even if we disable the instrumentation + if (!instrumentation.isEnabled()) return code?.apply(this, args); + + return instrumentation.tracer.startActiveSpan( + `${name}(${pattern.toString()})`, + { + kind: SpanKind.CLIENT, + // ignore the last argument because it's a callback + attributes: args.slice(0, -1).reduce( + (attrs, arg, index) => ({ + ...attrs, + [`${AttributeNames.STEP_ARGS}[${index}]`]: + arg?.raw instanceof Function + ? JSON.stringify(arg.raw()) + : arg, + }), + {} + ), + }, + async span => { + try { + return await code?.apply(this, args); + } catch (error: any) { + this.attach?.(JSON.stringify(span.spanContext())); + CucumberInstrumentation.setSpanToError(span, error); + throw error; + } finally { + span.end(); + } + } + ); + } + // cucumber asks for the number of arguments to match the specified pattern + // copy the value from the original function + Object.defineProperty(traceableCode, 'length', { + value: code?.length, + }); + return original.call(this, pattern, options, traceableCode as any); + }; + }; + } +} diff --git a/plugins/node/instrumentation-cucumber/src/types.ts b/plugins/node/instrumentation-cucumber/src/types.ts new file mode 100644 index 0000000000..3cd7e56747 --- /dev/null +++ b/plugins/node/instrumentation-cucumber/src/types.ts @@ -0,0 +1,30 @@ +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { InstrumentationConfig } from '@opentelemetry/instrumentation'; + +export type CucumberInstrumentationConfig = InstrumentationConfig; + +export enum AttributeNames { + FEATURE_TAGS = 'cucumber.feature.tags', + FEATURE_LANGUAGE = 'cucumber.feature.language', + FEATURE_DESCRIPTION = 'cucumber.feature.description', + SCENARIO_TAGS = 'cucumber.scenario.tags', + SCENARIO_DESCRIPTION = 'cucumber.scenario.description', + STEP_TYPE = 'cucumber.step.type', + STEP_STATUS = 'cucumber.step.status', + STEP_ARGS = 'cucumber.step.args', +} diff --git a/plugins/node/instrumentation-cucumber/test/.gitignore b/plugins/node/instrumentation-cucumber/test/.gitignore new file mode 100644 index 0000000000..f9e3307ddb --- /dev/null +++ b/plugins/node/instrumentation-cucumber/test/.gitignore @@ -0,0 +1 @@ +*.feature diff --git a/plugins/node/instrumentation-cucumber/test/cucumber.test.ts b/plugins/node/instrumentation-cucumber/test/cucumber.test.ts new file mode 100644 index 0000000000..1820380854 --- /dev/null +++ b/plugins/node/instrumentation-cucumber/test/cucumber.test.ts @@ -0,0 +1,559 @@ +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { context, SpanStatusCode } from '@opentelemetry/api'; +import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'; +import { AsyncHooksContextManager } from '@opentelemetry/context-async-hooks'; +import { + InMemorySpanExporter, + SimpleSpanProcessor, +} from '@opentelemetry/sdk-trace-base'; +import { SemanticAttributes } from '@opentelemetry/semantic-conventions'; +import { Resource } from '@opentelemetry/resources'; +import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions'; + +import * as path from 'path'; +import * as assert from 'assert'; +import * as fs from 'fs'; +import * as semver from 'semver'; + +import { CucumberInstrumentation, AttributeNames } from '../src'; + +const LIB_VERSION = require('@cucumber/cucumber/package.json').version; +const hasRunAttempt = semver.gte(LIB_VERSION, '8.8.0'); + +const instrumentation = new CucumberInstrumentation(); +instrumentation.enable(); +instrumentation.disable(); + +import { + IConfiguration, + loadConfiguration, + loadSupport, + runCucumber, +} from '@cucumber/cucumber/api'; +import { PassThrough } from 'stream'; + +describe('CucumberInstrumentation', () => { + const provider = new NodeTracerProvider({ + resource: new Resource({ + [SemanticResourceAttributes.SERVICE_NAME]: 'CucumberInstrumentation', + }), + }); + const memoryExporter = new InMemorySpanExporter(); + const spanProcessor = new SimpleSpanProcessor(memoryExporter); + provider.addSpanProcessor(spanProcessor); + const contextManager = new AsyncHooksContextManager().enable(); + + before(() => { + instrumentation.setTracerProvider(provider); + context.setGlobalContextManager(contextManager); + instrumentation.enable(); + }); + + afterEach(() => { + contextManager.disable(); + contextManager.enable(); + memoryExporter.reset(); + }); + + after(async () => { + await provider.shutdown(); + }); + + const init = async ( + feature: string, + providedConfiguration?: Partial + ) => { + // clean-up require cache to re-register cucumber hooks for a new run + ['features/support/world', 'features/step_definitions/steps'].forEach( + search => { + const key = Object.keys(require.cache).find(key => + key.includes(search) + ); + if (key == null) return; + delete require.cache[key]; + } + ); + const featurePath = path.join(__dirname, 'current.feature'); + await fs.promises.writeFile(featurePath, feature, 'utf-8'); + const { runConfiguration } = await loadConfiguration({ + provided: { + ...providedConfiguration, + paths: [featurePath], + require: [ + path.join(__dirname, 'features/support/world.ts'), + path.join(__dirname, 'features/step_definitions/steps.ts'), + ], + }, + }); + const support = await loadSupport(runConfiguration); + const merged = { ...runConfiguration, support }; + await runCucumber(merged, { + // mute cucumber's output + stderr: new PassThrough(), + stdout: new PassThrough(), + }); + }; + + describe('enabled instrumentation', () => { + describe('basic.feature', () => { + beforeEach(async () => { + await init(` + @feature-tag + Feature: Basic + A very basic feature file with a single scenario + + @scenario-tag @tag + Scenario: Button pushing + Mostly pushing buttons + but also tables + When I push the button + Then it is pushed to "limit" + And does something with the table + | Cucumber | Cucumis sativus | + | Burr Gherkin | Cucumis anguria | + `); + }); + + it('generates spans for cucumber execution', () => { + const spans = memoryExporter.getFinishedSpans(); + // should have Feature span + const parent = spans.find(span => span.name.startsWith('Feature')); + assert(parent, 'Expected a parent span'); + + assert.deepEqual( + spans.map(span => span.name), + [ + 'Before', + 'BeforeStep', + 'When(/I push the button/)', + 'AfterStep', + 'I push the button', + 'BeforeStep', + 'Then(it is pushed to {string})', + 'AfterStep', + 'it is pushed to "limit"', + 'BeforeStep', + 'Then(does something with the table)', + 'AfterStep', + 'does something with the table', + 'After', + hasRunAttempt && 'Attempt #0', + 'Feature: Basic. Scenario: Button pushing', + ].filter(Boolean), + 'Expected all hooks to be patched' + ); + }); + + it('adds scenario attributes to parent span', () => { + const spans = memoryExporter.getFinishedSpans(); + const parent = spans.find(span => span.name.startsWith('Feature')); + assert(parent, 'Expected a parent span'); + + assert.deepEqual(parent.attributes, { + [SemanticAttributes.CODE_FILEPATH]: 'test/current.feature', + [SemanticAttributes.CODE_LINENO]: 7, + [SemanticAttributes.CODE_FUNCTION]: 'Button pushing', + [SemanticAttributes.CODE_NAMESPACE]: 'Basic', + [AttributeNames.FEATURE_DESCRIPTION]: + ' A very basic feature file with a single scenario', + [AttributeNames.FEATURE_LANGUAGE]: 'en', + [AttributeNames.FEATURE_TAGS]: ['@feature-tag'], + [AttributeNames.SCENARIO_DESCRIPTION]: + ' Mostly pushing buttons\n but also tables', + [AttributeNames.SCENARIO_TAGS]: ['@scenario-tag', '@tag'], + [AttributeNames.STEP_STATUS]: 'PASSED', + }); + }); + + it('adds step args to span attributes', () => { + const spans = memoryExporter.getFinishedSpans(); + const parametrisedSpan = spans.find(span => + span.name.startsWith('Then(it is pushed') + ); + assert(parametrisedSpan); + + assert.deepEqual(parametrisedSpan.attributes, { + [`${AttributeNames.STEP_ARGS}[0]`]: 'limit', + }); + }); + + it('adds step table to span attributes', () => { + const spans = memoryExporter.getFinishedSpans(); + const tableSpan = spans.find(span => + span.name.startsWith('Then(does something') + ); + assert(tableSpan); + + assert.deepEqual(tableSpan.attributes, { + [`${AttributeNames.STEP_ARGS}[0]`]: JSON.stringify([ + ['Cucumber', 'Cucumis sativus'], + ['Burr Gherkin', 'Cucumis anguria'], + ]), + }); + }); + }); + + describe('examples.feature', () => { + beforeEach(async () => { + await init(` + Feature: Examples + + Scenario: button pushing + Given a step + When I push the button + Then it is pushed to "limit" + And does something with the table + | Cucumber | Cucumis sativus | + | Burr Gherkin | Cucumis anguria | + + Examples: + | type | + | passing | + | failing | + `); + }); + + it('has a scenario for every example', () => { + const spans = memoryExporter.getFinishedSpans(); + const scenarios = spans.filter(span => span.name.startsWith('Feature')); + assert.equal(scenarios.length, 2); + + assert.deepEqual( + scenarios.map(span => span.name), + [ + 'Feature: Examples. Scenario: passing button pushing', + 'Feature: Examples. Scenario: failing button pushing', + ] + ); + }); + + it('sets a span of a failing step to error', () => { + const spans = memoryExporter.getFinishedSpans(); + const span = spans.find(span => span.name === 'Given(a failing step)'); + assert(span); + + assert.equal(span.status.code, SpanStatusCode.ERROR); + }); + }); + + if (hasRunAttempt) { + describe('attempts.feature', () => { + beforeEach(async () => { + await init( + ` + Feature: Attempts + + Scenario: fail button pushing + Given a failing step + When I push the button + `, + { retry: 2 } + ); + }); + + it('generates spans for each attempt', () => { + const spans = memoryExporter.getFinishedSpans(); + const parent = spans.find(span => span.name.includes('Feature')); + assert(parent); + + const attemptSpans = spans.filter(span => + span.name.startsWith('Attempt') + ); + assert.equal(attemptSpans.length, 3); + + assert.deepEqual( + attemptSpans.map(span => span.parentSpanId), + Array(3).fill(parent.spanContext().spanId) + ); + }); + + it('creates scanario spans as children of attempts', () => { + const spans = memoryExporter.getFinishedSpans(); + const attemptSpans = spans.filter(span => + span.name.startsWith('Attempt') + ); + assert.equal(attemptSpans.length, 3); + + attemptSpans.forEach(attempt => { + assert.equal( + spans.filter( + span => span.parentSpanId === attempt.spanContext().spanId + ).length, + 4 + ); + }); + }); + }); + } + + describe('doc-string.feature', () => { + beforeEach(async () => { + await init(` + Feature: a feature + Scenario: a scenario + Given a doc string step + """ + The cucumber (Cucumis sativus) is a widely cultivated plant in the gourd family Cucurbitaceae. + """ + When I push the button + `); + }); + + it('adds doc strings as arg to span attributes', () => { + const spans = memoryExporter.getFinishedSpans(); + const parent = spans.find(span => span.name.includes('Feature')); + assert(parent); + + const span = spans.find(span => span.name.startsWith('Given(a doc')); + assert(span); + assert.deepEqual(span.attributes, { + [`${AttributeNames.STEP_ARGS}[0]`]: + 'The cucumber (Cucumis sativus) is a widely cultivated plant in the gourd family Cucurbitaceae.', + }); + }); + }); + + describe('background.feature', () => { + beforeEach(async () => { + await init(` + Feature: a feature + Background: + Given a doc string step + """ + This is a background + """ + + Scenario: a scenario + When I push the button + `); + }); + + it('adds spans for background steps', () => { + const spans = memoryExporter.getFinishedSpans(); + const parent = spans.find(span => span.name.includes('Feature')); + assert(parent); + + const span = spans.find(span => span.name.startsWith('Given(a doc')); + assert(span); + assert.deepEqual(span.attributes, { + [`${AttributeNames.STEP_ARGS}[0]`]: 'This is a background', + }); + }); + }); + + describe('hook-failures.feature', () => { + ['Before', 'BeforeStep', 'After', 'AfterStep'].forEach(hook => { + it(`sets ${hook} hook to error`, async () => { + await init(` + Feature: Hook failure spans + + Scenario: Fails ${hook} Hook + When I push the button + `); + const spans = memoryExporter.getFinishedSpans(); + const parent = spans.find(span => + span.name.includes(`Fails ${hook}`) + ); + assert(parent); + assert.equal(parent.status.code, SpanStatusCode.ERROR); + assert.equal(parent.status.message, 'FAILED'); + assert.equal(parent.attributes[AttributeNames.STEP_STATUS], 'FAILED'); + + const span = spans.find( + span => + span.spanContext().traceId === parent.spanContext().traceId && + span.name === hook + ); + assert(span); + + assert.equal(span.status.code, SpanStatusCode.ERROR); + }); + }); + }); + + describe('undefined.feature', () => { + beforeEach(async () => { + await init(` + Feature: Undefined steps + + Scenario: + When an undefined step is encountered + Then does nothing + `); + }); + + it('sets undefined steps to error', () => { + const spans = memoryExporter.getFinishedSpans(); + const parent = spans.find(span => span.name.includes('Feature')); + assert(parent); + assert.equal(parent.status.code, SpanStatusCode.ERROR); + assert.equal(parent.status.message, 'UNDEFINED'); + assert.equal( + parent.attributes[AttributeNames.STEP_STATUS], + 'UNDEFINED' + ); + + const span = spans.find(span => span.name.startsWith('an undefined')); + assert(span); + assert.equal(span.status.code, SpanStatusCode.ERROR); + assert.equal(span.status.message, 'UNDEFINED'); + assert.equal(span.attributes[AttributeNames.STEP_STATUS], 'UNDEFINED'); + + const skippedSpan = spans.find(span => span.name === 'does nothing'); + assert(skippedSpan); + assert.equal( + skippedSpan.attributes[AttributeNames.STEP_STATUS], + 'SKIPPED' + ); + }); + }); + + describe('ambiguous.feature', () => { + beforeEach(async () => { + await init(` + Feature: Ambiguous step + + Scenario: + When an ambiguous step is encountered + `); + }); + + it('sets ambiguous steps to error', () => { + const spans = memoryExporter.getFinishedSpans(); + const parent = spans.find(span => span.name.includes('Feature')); + assert(parent); + assert.equal(parent.status.code, SpanStatusCode.ERROR); + assert.equal(parent.status.message, 'AMBIGUOUS'); + assert.equal( + parent.attributes[AttributeNames.STEP_STATUS], + 'AMBIGUOUS' + ); + + const span = spans.find(span => span.name.startsWith('an ambiguous')); + assert(span); + + assert.equal(span.status.code, SpanStatusCode.ERROR); + assert.equal( + span.status.message?.split('\n')[0], + 'Multiple step definitions match:' + ); + }); + }); + + describe('skipped.feature', () => { + it('adds skipped event to skipped steps', async () => { + await init(` + Feature: Skipping a step + + Scenario: + Given a skipped step + Then it is pushed to "limit" + `); + const spans = memoryExporter.getFinishedSpans(); + const parent = spans.find(span => span.name.includes('Feature')); + assert(parent); + assert.equal(parent.attributes[AttributeNames.STEP_STATUS], 'SKIPPED'); + + const span = spans.find(span => span.name.startsWith('a skipped step')); + assert(span); + assert.equal(span.attributes[AttributeNames.STEP_STATUS], 'SKIPPED'); + }); + + it('adds skipped event to skipped steps in before hook', async () => { + await init(` + Feature: Skipping a step + + @skip + Scenario: + When I push the button + `); + const spans = memoryExporter.getFinishedSpans(); + const parent = spans.find( + span => + span.name.includes('Feature') && + ( + span.attributes[AttributeNames.SCENARIO_TAGS] as string[] + )?.includes?.('@skip') + ); + assert(parent); + assert.equal(parent.attributes[AttributeNames.STEP_STATUS], 'SKIPPED'); + }); + }); + + describe('pending.feature', () => { + it('adds pending event to pending steps', async () => { + await init(` + Feature: pending + + Scenario: pending scenario + Given a pending step + When I push the button + `); + const spans = memoryExporter.getFinishedSpans(); + const parent = spans.find(span => span.name.includes('Feature')); + assert(parent); + assert.equal(parent.attributes[AttributeNames.STEP_STATUS], 'PENDING'); + + const span = spans.find(span => span.name.startsWith('a pending step')); + assert(span); + assert.equal(span.attributes[AttributeNames.STEP_STATUS], 'PENDING'); + }); + + it('adds pending event to pending steps in before hook', async () => { + await init(` + Feature: pending + + @pending + Scenario: pending scenario + When I push the button + `); + const spans = memoryExporter.getFinishedSpans(); + const parent = spans.find(span => span.name.includes('Feature')); + assert(parent); + assert.equal(parent.attributes[AttributeNames.STEP_STATUS], 'PENDING'); + + const span = spans.find(span => + span.name.startsWith('I push the button') + ); + assert(span); + assert.equal(span.attributes[AttributeNames.STEP_STATUS], 'SKIPPED'); + }); + }); + }); + + describe('disabled instrumentation', () => { + before(() => { + instrumentation.disable(); + }); + + after(() => { + instrumentation.enable(); + }); + + it('does not create spans', async () => { + await init(` + Feature: a feature + Scenario: a scenario + When I do anything at all + Then no spans are recorded + `); + const spans = memoryExporter.getFinishedSpans(); + assert.equal(spans.length, 0); + }); + }); +}); diff --git a/plugins/node/instrumentation-cucumber/test/features/step_definitions/steps.ts b/plugins/node/instrumentation-cucumber/test/features/step_definitions/steps.ts new file mode 100644 index 0000000000..82978a2d7e --- /dev/null +++ b/plugins/node/instrumentation-cucumber/test/features/step_definitions/steps.ts @@ -0,0 +1,31 @@ +/* eslint-disable */ +import { When, Then, Given } from '@cucumber/cucumber'; + +Given('a failing step', async function () { + throw new Error('failing'); +}); + +Given('a passing step', function () {}); + +When(/I push the button/, async function () { + await new Promise(resolve => setTimeout(resolve, 10)); +}); + +Then('it is pushed to {string}', function (to) {}); + +Then('does nothing', function () {}); + +Then('does something with the table', function (table) {}); + +When('an ambiguous step is encountered', function () {}); +When(/an ambig(.*) step is encountered/, function () {}); + +Given('a skipped step', function () { + return 'skipped'; +}); + +Given('a pending step', function () { + return 'pending'; +}); + +Given('a doc string step', function (docString) {}); diff --git a/plugins/node/instrumentation-cucumber/test/features/support/world.ts b/plugins/node/instrumentation-cucumber/test/features/support/world.ts new file mode 100644 index 0000000000..29bab018be --- /dev/null +++ b/plugins/node/instrumentation-cucumber/test/features/support/world.ts @@ -0,0 +1,34 @@ +/* eslint-disable */ +import { BeforeStep, AfterStep, After, Before } from '@cucumber/cucumber'; + +Before('@skip', function () { + return 'skipped'; +}); + +Before('@pending', function () { + return 'pending'; +}); + +Before(async gherkinDocument => { + if (gherkinDocument.pickle.name === 'Fails Before Hook') { + throw new Error('error'); + } +}); + +BeforeStep(async gherkinDocument => { + if (gherkinDocument.pickle.name === 'Fails BeforeStep Hook') { + throw new Error('error'); + } +}); + +AfterStep(async gherkinDocument => { + if (gherkinDocument.pickle.name === 'Fails AfterStep Hook') { + throw new Error('error'); + } +}); + +After(async gherkinDocument => { + if (gherkinDocument.pickle.name === 'Fails After Hook') { + throw new Error('error'); + } +}); diff --git a/plugins/node/instrumentation-cucumber/tsconfig.json b/plugins/node/instrumentation-cucumber/tsconfig.json new file mode 100644 index 0000000000..568e7bb7cb --- /dev/null +++ b/plugins/node/instrumentation-cucumber/tsconfig.json @@ -0,0 +1,9 @@ +{ + "extends": "../../../tsconfig.base", + "compilerOptions": { + "rootDir": ".", + "outDir": "build", + "skipLibCheck": true + }, + "include": ["src/**/*.ts", "test/**/*.ts"] +} diff --git a/release-please-config.json b/release-please-config.json index c92ac926df..be9ea170ab 100644 --- a/release-please-config.json +++ b/release-please-config.json @@ -21,6 +21,7 @@ "packages/opentelemetry-sql-common": {}, "packages/opentelemetry-test-utils": {}, "plugins/node/instrumentation-amqplib": {}, + "plugins/node/instrumentation-cucumber": {}, "plugins/node/instrumentation-dataloader": {}, "plugins/node/instrumentation-fs": {}, "plugins/node/instrumentation-lru-memoizer": {},