Update dependency grafana/k6 to v0.52.0

[grafanarenovatebot]

This PR contains the following updates:

Package	Update	Change
grafana/k6	minor	v0.50.0 -> v0.52.0

---

Release Notes

grafana/k6 (grafana/k6)

v0.52.0

Compare Source

k6 v0.52.0 is here 🎉! Some special mentions included in this release:

• We've switched to our own fork of goja named sobek.
• Panics are no longer captured.
• We've added experimental support for TypeScript and ES6+.
• k6/browser has graduated from an experimental module, and now has a fully Async API.

Breaking changes

Switch goja to our own fork named sobek #​3775

To accelerate the development speed and bring ECMAScript Modules (ESM) support to k6 earlier (https://github.com/grafana/k6/issues/3265),
we have decided to create a fork of the goja project under the Grafana GitHub organization,
named sobek.

Starting on this release, k6 (and its extensions) now use sobek instead of the original goja, for all (of the
publicly exposed parts of the API) except for a couple of packages that are only used internally by k6.

All k6 extensions linked in the docs have had a PR for this transition opened, as explained in this comment. Any extension author who hasn't gotten a PR can follow the same steps.

Find further details in #​3772 and #​3773.

Panics are no longer being captured #​3777

Since this release, Go panics are no longer being captured by k6. This means that if a panic occurs while running a test,
the k6 process will crash, and the panic stack trace will be printed to the console.

We decided to change this behavior because it's something that was left from the past as a safeguard, but it's not as
good as it might seem. For most cases with multiple goroutines/async, it's not enough and also makes a bunch of potential
bugs seem like less of an issue.

Thus, this will help us to identify and fix bugs earlier, improve the overall stability of k6, and
most likely make the experience of developing k6 extensions friendlier.

lib.State no longer has Group #​3750

As the result of refactoring the implementation of group and check methods, in order to decouple them, and thus
enable other future improvements, the lib.State object no longer has a Group field.

This change should not affect most users, except for a couple of extensions, for which the use of Group was
already questionable:

• xk6-fasthttp
• xk6-g0

Other breaking changes

• #​3797 starts using - as a special value for --archive-out to output the archive to stdout.
• browser#1318 makes the Mouse.up and Mouse.down methods no longer take x and y coordinates. Instead, they dispatch events on the current mouse position.

New features

Experimental support for TypeScript and ES6+ using esbuild #​3738

This release of k6 introduces experimental support for TypeScript and ES6+ using esbuild, thanks to a new
compatibility mode named experimental_enhanced.

k6 run --compatibility-mode=experimental_enhanced script.js

With this new compatibility mode, the test source code is transformed using esbuild instead of Babel, which also means
that source files with the extension ".ts" are loaded by esbuild's TypeScript loader, which results in partial
TypeScript support: it removes the type information but doesn't provide type safety.

k6/browser has graduated from an experimental module #​3793

The browser module is now available as k6/browser instead of k6/experimental/browser. The previous k6/experimental/browser module will be removed on September 23rd, 2024. Refer to the migration guide for more information on how to update your scripts.

k6/browser has now a fully Async API browser#428

This release introduces a fully Async API for the k6/browser module. This means that nearly all the methods in the module now return promises. This change is part of the ongoing effort to make the browser module more user-friendly and easier to use. Please see the browser documentation for more information on how to use the new Async API.

Related Changes:

• browser#1310, browser#1311, browser#1312, browser#1316, browser#1328, browser#1337, browser#1367, browser#1366, browser#1314, browser#1332, browser#1323, browser#1355, browser#1348, browser#1364 Migrates Browser, BrowserContext, ElementHandle, Frame, JSHandle, Keyboard, Locator, Mouse, Page, Request, Response APIs to async.

UX improvements and enhancements

• #​3740 enables k6 extensions to initialize ReadableStream objects from Go code (io.Reader).
• #​3798 adjusts a severity level of a log message from warn to debug for cases when k6 can't detect the terminal's size.
• #​3797 makes it possible to output the archive to stdout by using - as the --archive-out. Thanks to @​roobre! 🙇 🎉
• browser#1370 makes the GetAttribute method now return false when the attribute is missing, making it easier to check for the presence of an attribute.
• browser#1371 makes the TextContent method now return false when the element's text content cannot be grabbed (like a JS document), making it easier to check for the presence of text content.
• browser#1376 makes Request.headerValue and Response.headerValue to be case-insensitive.
• browser#1368 enhances await usage in Javascript examples.
• browser#1326 adds forgotten BrowserContext.browser and Page.context mappings.
• browser#1360, browser#1327, browser#1335, browser#1365, browser#1313, browser#1322, browser#1330, browser#1343, browser#1345, browser#1352 turns the Browser, BrowserContext, ElementHandle, JSHandle, Keyboard, Mouse, Locator, and Page types' panics into errors for stability and better error handling.

Bug fixes

• #​3774 fixes a require warning for those tests using the stdin.
• #​3776 fixes a panic caused by passing an undefined handler to timers.
• #​3779 fixes a panic caused by registering an undefined handler in gRPC streams.
• xk6-websockets#73 fixes a panic caused by registering an undefined handler in WebSockets.
• browser#1369 improves valueFromRemoteObject null detection by returning a Go nil instead of "null" as a string.
• browser#1386 correctly handles empty string flags that don't have a value.
• browser#1380 ensures that JSHandle.evaluate and JSHandle.evaluateHandle both set themselves as the first argument.
• browser#1346 fixes an IFrame panic ("we either navigate top level or have old version of the navigated frame") that happens during navigation.
• browser#1349, browser#1354 fixes Request mappings.
• browser#1334 fixes an issue where clicking on a link that opens a new tab never navigates to the href link.
• browser#1318 fixes the Mouse.move to correctly dispatch a down event.
• browser#1301 fixes an error that occurs when working with a second tab and navigating to a URL.
• browser#1387 fixes a panic when the new document or request is missing.

Maintenance and internal improvements

• #​3752, #​3767, #​3770, #​3780, #​3782, #​3795 updates several dependencies.
• #​3786, #​3787, #​3788, #​3789, #​3803 updates experimental modules.
• #​3749 stops printing goja stack traces on panics, which has been empty since a while.
• #​3760 fixes race conditions in ramping-vus tests.
• #​3769 removes a linter setting no longer used.
• #​3800 adds test coverage for outputting the archive to stdout.
• browser#1298 splits browser mappings into separate files for better organization and maintainability.
• browser#1321 adds test helpers for async VU execution to reduce the boilerplate in the tests.
• browser#1357 updates Group and Tag usage for the latest k6.
• browser#1361 precalculates the browser version information to prevent I/O calls when the version and userAgent methods are called. This change allows the browser module to expose these methods as a sync API to be consistent with the Playwright's API.
• browser#1377 uses the goja fork called sobek in the browser module.
• browser#1373 provides sync and async APIs within the browser module for making the migration to the async API easier.

Roadmap

Native ECMAScript modules

As mentioned above, the k6 team has forked goja into sobek and is currently working on native ECMAScript modules support. The current work in progress can be found in this PR and any feedback is welcome.

As part of that there likely will be some breaking changes due to the current not native support allowing stuff that shouldn't work. Like for example mixing CommonJS and ESM in the same file. Which is for example why we have added a warning that it won't work.

Support across multiple files is also not standard but due to amount of users that seems to be mixing them across files a lot of work has been done to support it. It is still likely that in the future warnings and potentially at some point future breaking changes will be enacted.

OpenTelemetry metrics output

We're also happy to share that this release cycle, we've been working on xk6-output-opentelemetry, a k6 output extension that allows you to send k6 metrics to OpenTelemetry-compatible backends. We're looking for feedback from the community. If you're interested, please try it and let us know via the extension repository!

Depending on the feedback, we plan to include this extension as an experimental output in the next k6 release.

v0.51.0

Compare Source

k6 v0.51.0 is here 🎉! Some special mentions included in this release:

• A new experimental streams module
• New algorithms for WebCrypto module
• Timers are globally available

Breaking changes

Transition browser APIs to Async

In the last release notes we mentioned this breaking change, and we wanted to remind and update you on the plan. In the next release (v0.52.0), most of the synchronous browser APIs will be migrated to be asynchronous (promisifying them). We expect this will affect most if not all of our users.

This breaking change will require you to add await in front of most of the browser module APIs. Without this await you will witness undocumented and unknown behavior during the runtime. To make the migration simpler we advise that you work with the latest k6 type definitions.

You can find a list of all the APIs that we expect to convert to async in a comment in issue browser#428.

Awaiting on something that’s not a thenable just returns that value, which means you can add the await keyword today on the APIs that will become async to future proof your test scripts.

Here are the reasons for making this large breaking change:

1. Most browser APIs use some form of long-running IO operation (networking) to perform the requested action on the web browser against the website under test. We need to avoid blocking JavaScript's runtime event loop for such operations.
2. We're going to add more asynchronous event-based APIs (such as page.on) that our current synchronous APIs would block.
3. To align with how developers expect to work with JavaScript APIs.
4. To have better compatibility with Playwright.

As a starting point, we have migrated a single API (the tap method), which you can find the details below that will help visualize the upcoming breaking changes.

Browser Tap is now an async method grafana/xk6-browser#1268

This release converts the Tap method in the browser module into an asynchronous method. This change is necessary to ensure that the method can be used in async contexts and to align with the rest of the browser module's planned asynchronous API. To use the Tap method, you must now add the await keyword before the method call.

Affected components:

• locator.tap
• page.tap
• frame.tap
• elementHandle.tap

See the following example for how to use the Tap method after this change:

Before:

import browser from 'k6/experimental/browser'

// ...

export default function () {
	// ...
	page.tap(selector, { modifiers: ["Alt", "Control", "Meta", "Shift"] });
	// ...
}

After:

import browser from 'k6/experimental/browser'

// ...

export default function () {
	// ...
	await page.tap(selector, { modifiers: ["Alt", "Control", "Meta", "Shift"] });
	// ...
}

k6/experimental/websockets will not default binaryType to `"arraybuffer"'

As part of the stabilization of the API it needs to become as close to the specification.

Early in the development the idea of adding Blob support as part was deemed feature creep and was dropped in favor of going with only "arraybuffer". But the specification defaults to returning binary responses as Blob - which was another thing that was changed.

While adding Blob is still on our radar, moving the default is always going to be a breaking change that we need to do to align with the specification.

For this release there is now a warning that will be printed if binaryType is not set to "arraybuffer" and a binary response is received. The warning will go away when binaryType is set to "arraybuffer".

In the next release the warning will become an error.

More info and place for discussion can be found in an this issue.

k6/experimental/grpc is no longer available #​3530

As the last step of the graduation process for the experimental gRPC module, we completely removed the module. It is now fully integrated into the stable k6/net/grpc module. So, if you haven't done this yet, replace your imports from k6/experimental/grpc to k6/net/grpc.

Deprecations

The following pull requests start the process to introduce breaking changes. They are currently starting to emit warning if their condition is hit, but they will turn to return errors in the future release.
It is recommended to use the suggested alternative, or to fix the script if you see the warning message.

• #​3681 Use of not-compliant require expressions.
• #​3680 Modules resolution of modules not previously seen during the initialization phase.
• #​3676 Working directory is set to the current location when the script is provided using stdin, instead of the root folder.
• #​3530 Automagically resolve modules from cdnjs and github "URLs".

New features

Introduction of k6/experimental/streams module #​3696

This release of k6 introduces the new k6/experimental/streams module, which partially supports the JavaScript
Streams API, focusing initially on the ReadableStream construct.

With the ReadableStream, users can define and consume data streams within k6 scripts. This is particularly useful for
efficiently handling large datasets or for processing data sequentially in a controlled flow.

Expand to see an example of stream's usage

The following example demonstrates creating and consuming a simple stream that emits numbers until it reaches a predefined limit:

import { ReadableStream } from 'k6/experimental/streams'

function numbersStream() {
    let currentNumber = 0

	return new ReadableStream({
		start(controller) {
			const fn = () => {
				if (currentNumber < 5) {
					controller.enqueue(++currentNumber)
					setTimeout(fn, 1000)
					return;
				}

				controller.close()
			}
			setTimeout(fn, 1000)
		},
	})
}

export default async function () {
	const stream = numbersStream()
	const reader = stream.getReader()

	while (true) {
		const { done, value } = await reader.read()
		if (done) break
		console.log(`received number ${value} from stream`)
	}

	console.log('we are done')
}

For more advanced examples, please head to the MDN Web Docs on the Streams API.

Limitations

Currently, users can define and consume readable streams. However, this release does not include support for byte readers
and controllers, nor does it include support the tee, pipeTo, and
pipeThrough methods of the ReadableStream object.

New features and updates of WebCrypto API support #​3714

This release brings support for asymmetric cryptography to the k6/experimental/webcrypto module. We added support of the elliptic curves algorithms ECDH (xk6-webcrypto#67) and ECDSA (xk6-webcrypto#69) algorithms along with new import/export key formats like spki and pkcs8.

One of the newly added operations is deriveBits, which allows parties to generate a unique shared secret by using shared public and non-shared private keys.

Expand to see an example of generating a shared secret for Alice and Bob.

import { crypto } from 'k6/experimental/webcrypto';

export default async function () {
  // Generate a key pair for Alice
  const aliceKeyPair = await crypto.subtle.generateKey(
    {
      name: 'ECDH',
      namedCurve: 'P-256',
    },
    true,
    ['deriveKey', 'deriveBits']
  );

  // Generate a key pair for Bob
  const bobKeyPair = await crypto.subtle.generateKey(
    {
      name: 'ECDH',
      namedCurve: 'P-256',
    },
    true,
    ['deriveKey', 'deriveBits']
  );

  // Derive shared secret for Alice
  const aliceSharedSecret = await deriveSharedSecret(aliceKeyPair.privateKey, bobKeyPair.publicKey);

  // Derive shared secret for Bob
  const bobSharedSecret = await deriveSharedSecret(bobKeyPair.privateKey, aliceKeyPair.publicKey);

  // alice shared secret and bob shared secret should be the same
  console.log('alice shared secret: ' + printArrayBuffer(aliceSharedSecret));
  console.log('bob shared secret: ' + printArrayBuffer(bobSharedSecret));
}

async function deriveSharedSecret(privateKey, publicKey) {
  return crypto.subtle.deriveBits(
    {
      name: 'ECDH',
      public: publicKey,
    },
    privateKey,
    256
  );
}

const printArrayBuffer = (buffer) => {
  const view = new Uint8Array(buffer);
  return Array.from(view);
};

The sign and verify operations got support for ECDSA algorithm. The sign operation allows you to sign a message with a private key, while the verify operation allows you to verify the signature with a public key.

Other notable updates and fixes:

• xk6-webcrypto#68 fixes a degradation for the sign/verify operations for HMAC algorithm.
• xk6-webcrypto#75, xk6-webcrypto#76 refactor webcrypto module to be thread-safe.
• xk6-webcrypto#74 adds JWK import/export support for ECDH and ECDSA. Refactors JWK import/export to use only go standard library.

See webcrypto's module documentation for more details.

Timers globally available #​3589

setTimeout, setInterval and related clear functions have been part of the JavaScript ecosystem, probably for as long as it has existed.

In the previous releases we stabilized and made them available through k6/timers module. While the module isn't going anywhere and might get more identifiers, setTimeout is usually used without importing it. For this reason it is now globally available along clearTimeout, setInterval and clearInterval.

No code needs to be changed, but you no longer need to import k6/timers to use this functionality.

UX improvements and enhancements

• #​3670 adds the ability to enable profiling via environment variable. Thanks @​Bablzz for your contribution!
• #​3655 clarifies the error message for the validation of scenario's name.
• #​3693 adds a gRPC client's asyncInvoke method to the k6/net/grpc module. It's a non-blocking version of the invoke method.
• browser#1259, browser#1260 adds errors to the traces that the browser module generates.

Bug fixes

• #​3708 denies access to execution.test.options from Init context.
• #​3672 picks the correct value when SystemTags are set via the k6_SYSTEM_TAGS environment variable.
• #​3657 fixes a panic when mappings field is empty in the provided SourceMap.
• #​3717 returns a correct line number when an inlined SourceMap is used.
• browser#1261 fixes dispose context canceled errors.
• browser#1254 fixes an indefinite wait when testing websites with iframes.
• browser#1291 fixes a panic on dispose of resources during a navigation.

Maintenance and internal improvements

• #​3663, #​3673 updates several dependencies.
• #​3674 updates the Go version, now k6 binary is built and tested using Go 1.22.
• #​3688 updates the link to installation instructions for golangci-lint in the contribution guide. Thanks @​yomek33 for your contribution!
• browser#1262 fixes a flaky test.
• browser#1264 removes unimplemented APIs.

Future plans

Use Blob as default value for WebSocket.binaryType

As the changes in documentation mention, binaryType was by default set to arraybuffer, now instead it is "" (empty string).
In a not so remote future, instead, we expect to introduce and use Blob object.

WebCrypto graduation

WebCrypto got more features in the current release, and we expect to continue its expansion in the next iterations. Reaching a wider coverage will push WebCrypto module to being graduated as a stable module.

Streams API

In the not so distant future, we have plans to start using the Streams API in existing modules. Our first iteration being adding a .readable property to the already existing fs.File object.

Improve user experience for Cloud related commands

In the near future, we intend to reiterate on k6 cloud and related commands to create a simplified and more ergonomic user experience.

Remove experimental timers module

The k6/experimental/timers module is now part of the stable k6 API as k6/timers and via the globally available functions. The next release will make the experimental import no longer available.

---

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR has been generated by Renovate Bot.

[CLAassistant]

Thank you for your submission! We really appreciate it. Like many open source projects, we ask that you sign our Contributor License Agreement before we can accept your contribution.
_{You have signed the CLA already but the status is still pending? Let us recheck it.}

[CLAassistant]

Thank you for your submission! We really appreciate it. Like many open source projects, we ask that you sign our Contributor License Agreement before we can accept your contribution.
_{You have signed the CLA already but the status is still pending? Let us recheck it.}