rebase: bump github.com/onsi/ginkgo/v2 from 2.1.6 to 2.3.1

Bumps [github.com/onsi/ginkgo/v2](https://github.com/onsi/ginkgo) from 2.1.6 to 2.3.1. - [Release notes](https://github.com/onsi/ginkgo/releases) - [Changelog](https://github.com/onsi/ginkgo/blob/master/CHANGELOG.md) - [Commits](https://github.com/onsi/ginkgo/compare/v2.1.6...v2.3.1) --- updated-dependencies: - dependency-name: github.com/onsi/ginkgo/v2 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>
2025-06-13 02:33:34 +00:00 · 2022-10-17 17:38:08 +00:00
parent 53bb28e0d9
commit 3a490a4df0
46 changed files with 2752 additions and 939 deletions
--- a/vendor/github.com/onsi/ginkgo/v2/CHANGELOG.md
+++ b/vendor/github.com/onsi/ginkgo/v2/CHANGELOG.md
@ -1,3 +1,76 @@
+## 2.3.1
+
+## Fixes
+Several users were invoking `ginkgo` by installing the latest version of the cli via `go install github.com/onsi/ginkgo/v2/ginkgo@latest`.  When 2.3.0 was released this resulted in an influx of issues as CI systems failed due to a change in the internal contract between the Ginkgo CLI and the Ginkgo library.  Ginkgo only supports running the same version of the library as the cli (which is why both are packaged in the same repository).
+
+With this patch release, the ginkgo CLI can now identify a version mismatch and emit a helpful error message.
+
+- Ginkgo cli can identify version mismatches and emit a helpful error message [bc4ae2f]
+- further emphasize that a version match is required when running Ginkgo on CI and/or locally [2691dd8]
+
+## Maintenance
+- bump gomega to v1.22.0 [822a937]
+
+## 2.3.0
+
+### Interruptible Nodes and Timeouts
+
+Ginkgo now supports per-node and per-spec timeouts on interruptible nodes.  Check out the [documentation for all the details](https://onsi.github.io/ginkgo/#spec-timeouts-and-interruptible-nodes) but the gist is you can now write specs like this:
+
+```go
+It("is interruptible", func(ctx SpecContext) { // or context.Context instead of SpecContext, both are valid.
+    // do things until `ctx.Done()` is closed, for example:
+    req, err := http.NewRequestWithContext(ctx, "POST", "/build-widgets", nil)
+    Expect(err).NotTo(HaveOccured())
+    _, err := http.DefaultClient.Do(req)
+    Expect(err).NotTo(HaveOccured())
+
+    Eventually(client.WidgetCount).WithContext(ctx).Should(Equal(17))
+}, NodeTimeout(time.Second*20), GracePeriod(5*time.Second))
+```
+
+and have Ginkgo ensure that the node completes before the timeout elapses.  If it does elapse, or if an external interrupt is received (e.g. `^C`) then Ginkgo will cancel the context and wait for the Grace Period for the node to exit before proceeding with any cleanup nodes associated with the spec.  The `ctx` provided by Ginkgo can also be passed down to Gomega's `Eventually` to have all assertions within the node governed by a single deadline.
+
+### Features
+
+- Ginkgo now records any additional failures that occur during the cleanup of a failed spec.  In prior versions this information was quietly discarded, but the introduction of a more rigorous approach to timeouts and interruptions allows Ginkgo to better track subsequent failures.
+- `SpecContext` also provides a mechanism for third-party libraries to provide additional information when a Progress Report is generated.  Gomega uses this to provide the current state of an `Eventually().WithContext()` assertion when a Progress Report is requested.
+- DescribeTable now exits with an error if it is not passed any Entries [a4c9865]
+
+## Fixes
+- fixes crashes on newer Ruby 3 installations by upgrading github-pages gem dependency [92c88d5]
+- Make the outline command able to use the DSL import [1be2427]
+
+## Maintenance
+- chore(docs): delete no meaning d [57c373c]
+- chore(docs): Fix hyperlinks [30526d5]
+- chore(docs): fix code blocks without language settings [cf611c4]
+- fix intra-doc link [b541bcb]
+
+## 2.2.0
+
+### Generate real-time Progress Reports [f91377c]
+
+Ginkgo can now generate Progress Reports to point users at the current running line of code (including a preview of the actual source code) and a best guess at the most relevant subroutines.
+
+These Progress Reports allow users to debug stuck or slow tests without exiting the Ginkgo process.  A Progress Report can be generated at any time by sending Ginkgo a `SIGINFO` (`^T` on MacOS/BSD) or `SIGUSR1`.
+
+In addition, the user can specify `--poll-progress-after` and `--poll-progress-interval` to have Ginkgo start periodically emitting progress reports if a given node takes too long.  These can be overriden/set on a per-node basis with the `PollProgressAfter` and `PollProgressInterval` decorators.
+
+Progress Reports are emitted to stdout, and also stored in the machine-redable report formats that Ginkgo supports.
+
+Ginkgo also uses this progress reporting infrastructure under the hood when handling timeouts and interrupts.  This yields much more focused, useful, and informative stack traces than previously.
+
+### Features
+- `BeforeSuite`, `AfterSuite`, `SynchronizedBeforeSuite`, `SynchronizedAfterSuite`, and `ReportAfterSuite` now support (the relevant subset of) decorators.  These can be passed in _after_ the callback functions that are usually passed into these nodes.
+
+  As a result the **signature of these methods has changed** and now includes a trailing `args ...interface{}`.  For most users simply using the DSL, this change is transparent.  However if you were assigning one of these functions to a custom variable (or passing it around) then your code may need to change to reflect the new signature.
+
+### Maintenance
+- Modernize the invocation of Ginkgo in github actions [0ffde58]
+- Update reocmmended CI settings in docs [896bbb9]
+- Speed up unnecessarily slow integration test [6d3a90e]
+
 ## 2.1.6

 ### Fixes
@ -77,7 +150,7 @@ See [https://onsi.github.io/ginkgo/MIGRATING_TO_V2](https://onsi.github.io/ginkg
 Ginkgo 2.0 now has a Release Candidate.  1.16.5 advertises the existence of the RC.
 1.16.5 deprecates GinkgoParallelNode in favor of GinkgoParallelProcess

-You can silence the RC advertisement by setting an `ACK_GINKG_RC=true` environment variable or creating a file in your home directory called `.ack-ginkgo-rc`
+You can silence the RC advertisement by setting an `ACK_GINKGO_RC=true` environment variable or creating a file in your home directory called `.ack-ginkgo-rc`

 ## 1.16.4

@ -184,7 +257,7 @@ You can silence the RC advertisement by setting an `ACK_GINKG_RC=true` environme
 - replace tail package with maintained one. this fixes go get errors (#667) [4ba33d4]
 - improve ginkgo performance - makes progress on #644 [a14f98e]
 - fix convert integration tests [1f8ba69]
- fix typo succesful -> successful (#663) [1ea49cf]
+- fix typo successful -> successful (#663) [1ea49cf]
 - Fix invalid link (#658) [b886136]
 - convert utility : Include comments from source (#657) [1077c6d]
 - Explain what BDD means [d79e7fb]
@ -278,7 +351,7 @@ You can silence the RC advertisement by setting an `ACK_GINKG_RC=true` environme
 - Make generated Junit file compatible with "Maven Surefire" (#488) [e51bee6]
 - all: gofmt [000d317]
 - Increase eventually timeout to 30s [c73579c]
- Clarify asynchronous test behaviour [294d8f4]
+- Clarify asynchronous test behavior [294d8f4]
 - Travis badge should only show master [26d2143]

 ## 1.5.0 5/10/2018
@ -296,13 +369,13 @@ You can silence the RC advertisement by setting an `ACK_GINKG_RC=true` environme
 - When running a test and calculating the coverage using the `-coverprofile` and `-outputdir` flags, Ginkgo fails with an error if the directory does not exist. This is due to an [issue in go 1.10](https://github.com/golang/go/issues/24588) (#446) [b36a6e0]
 - `unfocus` command ignores vendor folder (#459) [e5e551c, c556e43, a3b6351, 9a820dd]
 - Ignore packages whose tests are all ignored by go (#456) [7430ca7, 6d8be98]
- Increase the threshold when checking time measuments (#455) [2f714bf, 68f622c]
+- Increase the threshold when checking time measurements (#455) [2f714bf, 68f622c]
 - Fix race condition in coverage tests (#423) [a5a8ff7, ab9c08b]
 - Add an extra new line after reporting spec run completion for test2json [874520d]
 - added name name field to junit reported testsuite [ae61c63]
 - Do not set the run time of a spec when the dryRun flag is used (#438) [457e2d9, ba8e856]
 - Process FWhen and FSpecify when unfocusing (#434) [9008c7b, ee65bd, df87dfe]
- Synchronise the access to the state of specs to avoid race conditions (#430) [7d481bc, ae6829d]
+- Synchronies the access to the state of specs to avoid race conditions (#430) [7d481bc, ae6829d]
 - Added Duration on GinkgoTestDescription (#383) [5f49dad, 528417e, 0747408, 329d7ed]
 - Fix Ginkgo stack trace on failure for Specify (#415) [b977ede, 65ca40e, 6c46eb8]
 - Update README with Go 1.6+, Golang -> Go (#409) [17f6b97, bc14b66, 20d1598]
--- a/vendor/github.com/onsi/ginkgo/v2/CONTRIBUTING.md
+++ b/vendor/github.com/onsi/ginkgo/v2/CONTRIBUTING.md
@ -8,6 +8,6 @@ Your contributions to Ginkgo are essential for its long-term maintenance and imp
    - When adding to the Ginkgo CLI, note that there are very few unit tests.  Please add an integration test.
 - Make sure all the tests succeed via `ginkgo -r -p`
 - Vet your changes via `go vet ./...`
- Update the documentation. Ginko uses `godoc` comments and documentation in `docs/index.md`.  You can run `bundle exec jekyll serve` in the `docs` directory to preview your changes.
+- Update the documentation. Ginkgo uses `godoc` comments and documentation in `docs/index.md`.  You can run `bundle exec jekyll serve` in the `docs` directory to preview your changes.

 Thanks for supporting Ginkgo!
--- a/vendor/github.com/onsi/ginkgo/v2/RELEASING.md
+++ b/vendor/github.com/onsi/ginkgo/v2/RELEASING.md
@ -1,7 +1,13 @@
 A Ginkgo release is a tagged git sha and a GitHub release.  To cut a release:

 1. Ensure CHANGELOG.md is up to date.
-  - Use `git log --pretty=format:'- %s [%h]' HEAD...vX.X.X` to list all the commits since the last release
+  - Use 
+    ```bash
+    LAST_VERSION=$(git tag --sort=version:refname | tail -n1)
+    CHANGES=$(git log --pretty=format:'- %s [%h]' HEAD...$LAST_VERSION)
+    echo -e "## NEXT\n\n$CHANGES\n\n### Features\n\n## Fixes\n\n## Maintenance\n\n$(cat CHANGELOG.md)" > CHANGELOG.md
+    ```
+   to update the changelog
  - Categorize the changes into
    - Breaking Changes (requires a major version)
    - New Features (minor version)
--- a/vendor/github.com/onsi/ginkgo/v2/core_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/v2/core_dsl.go
@ -77,7 +77,7 @@ func exitIfErrors(errors []error) {
 	}
 }

-//The interface implemented by GinkgoWriter
+// The interface implemented by GinkgoWriter
 type GinkgoWriterInterface interface {
 	io.Writer

@ -89,6 +89,15 @@ type GinkgoWriterInterface interface {
 	ClearTeeWriters()
 }

+/*
+ SpecContext is the context object passed into nodes that are subject to a timeout or need to be notified of an interrupt.  It implements the standard context.Context interface but also contains additional helpers to provide an extensibility point for Ginkgo.  (As an example, Gomega's Eventually can use the methods defined on SpecContext to provide deeper integratoin with Ginkgo).
+
+ You can do anything with SpecContext that you do with a typical context.Context including wrapping it with any of the context.With* methods.
+
+ Ginkgo will cancel the SpecContext when a node is interrupted (e.g. by the user sending an interupt signal) or when a node has exceeded it's allowed run-time.  Note, however, that even in cases where a node has a deadline, SpecContext will not return a deadline via .Deadline().  This is because Ginkgo does not use a WithDeadline() context to model node deadlines as Ginkgo needs control over the precise timing of the context cancellation to ensure it can provide an accurate progress report at the moment of cancellation.
+*/
+type SpecContext = internal.SpecContext
+
 /*
 GinkgoWriter implements a GinkgoWriterInterface and io.Writer

@ -103,7 +112,7 @@ You can learn more at https://onsi.github.io/ginkgo/#logging-output
 */
 var GinkgoWriter GinkgoWriterInterface

-//The interface by which Ginkgo receives *testing.T
+// The interface by which Ginkgo receives *testing.T
 type GinkgoTestingT interface {
 	Fail()
 }
@ -168,7 +177,7 @@ func PauseOutputInterception() {
 	outputInterceptor.PauseIntercepting()
 }

-//ResumeOutputInterception() - see docs for PauseOutputInterception()
+// ResumeOutputInterception() - see docs for PauseOutputInterception()
 func ResumeOutputInterception() {
 	if outputInterceptor == nil {
 		return
@ -277,7 +286,7 @@ func RunSpecs(t GinkgoTestingT, description string, args ...interface{}) bool {
 	suitePath, err = filepath.Abs(suitePath)
 	exitIfErr(err)

-	passed, hasFocusedTests := global.Suite.Run(description, suiteLabels, suitePath, global.Failer, reporter, writer, outputInterceptor, interrupt_handler.NewInterruptHandler(suiteConfig.Timeout, client), client, suiteConfig)
+	passed, hasFocusedTests := global.Suite.Run(description, suiteLabels, suitePath, global.Failer, reporter, writer, outputInterceptor, interrupt_handler.NewInterruptHandler(client), client, internal.RegisterForProgressSignal, suiteConfig)
 	outputInterceptor.Shutdown()

 	flagSet.ValidateDeprecations(deprecationTracker)
@ -444,6 +453,8 @@ It nodes are Subject nodes that contain your spec code and assertions.

 Each It node corresponds to an individual Ginkgo spec.  You cannot nest any other Ginkgo nodes within an It node's closure.

+You can pass It nodes bare functions (func() {}) or functions that receive a SpecContext or context.Context: func(ctx SpecContext) {} and func (ctx context.Context) {}. If the function takes a context then the It is deemed interruptible and Ginkgo will cancel the context in the event of a timeout (configured via the SpecTimeout() or NodeTimeout() decorators) or of an interrupt signal.
+
 You can learn more at https://onsi.github.io/ginkgo/#spec-subjects-it
 In addition, subject nodes can be decorated with a variety of decorators.  You can learn more here: https://onsi.github.io/ginkgo/#decorator-reference
 */
@ -504,6 +515,11 @@ func By(text string, callback ...func()) {
 		Text: text,
 	}
 	t := time.Now()
+	global.Suite.SetProgressStepCursor(internal.ProgressStepCursor{
+		Text:         text,
+		CodeLocation: types.NewCodeLocation(1),
+		StartTime:    t,
+	})
 	AddReportEntry("By Step", ReportEntryVisibilityNever, Offset(1), &value, t)
 	formatter := formatter.NewWithNoColorBool(reporterConfig.NoColor)
 	GinkgoWriter.Println(formatter.F("{{bold}}STEP:{{/}} %s {{gray}}%s{{/}}", text, t.Format(types.GINKGO_TIME_FORMAT)))
@ -522,11 +538,15 @@ When running in parallel, each parallel process will call BeforeSuite.

 You may only register *one* BeforeSuite handler per test suite.  You typically do so in your bootstrap file at the top level.

+BeforeSuite can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
+
 You cannot nest any other Ginkgo nodes within a BeforeSuite node's closure.
 You can learn more here: https://onsi.github.io/ginkgo/#suite-setup-and-cleanup-beforesuite-and-aftersuite
 */
-func BeforeSuite(body func()) bool {
-	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeBeforeSuite, "", body))
+func BeforeSuite(body interface{}, args ...interface{}) bool {
+	combinedArgs := []interface{}{body}
+	combinedArgs = append(combinedArgs, args...)
+	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeBeforeSuite, "", combinedArgs...))
 }

 /*
@ -537,11 +557,15 @@ When running in parallel, each parallel process will call AfterSuite.

 You may only register *one* AfterSuite handler per test suite.  You typically do so in your bootstrap file at the top level.

+AfterSuite can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
+
 You cannot nest any other Ginkgo nodes within an AfterSuite node's closure.
 You can learn more here: https://onsi.github.io/ginkgo/#suite-setup-and-cleanup-beforesuite-and-aftersuite
 */
-func AfterSuite(body func()) bool {
-	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeAfterSuite, "", body))
+func AfterSuite(body interface{}, args ...interface{}) bool {
+	combinedArgs := []interface{}{body}
+	combinedArgs = append(combinedArgs, args...)
+	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeAfterSuite, "", combinedArgs...))
 }

 /*
@ -552,19 +576,34 @@ information from that setup to all parallel processes.
 SynchronizedBeforeSuite accomplishes this by taking *two* function arguments and passing data between them.
 The first function is only run on parallel process #1.  The second is run on all processes, but *only* after the first function completes successfully.  The functions have the following signatures:

-The first function (which only runs on process #1) has the signature:
+The first function (which only runs on process #1) can have any of the following the signatures:

+	func()
+	func(ctx context.Context)
+	func(ctx SpecContext)
 	func() []byte
+	func(ctx context.Context) []byte
+	func(ctx SpecContext) []byte

-The byte array returned by the first function is then passed to the second function, which has the signature:
+The byte array returned by the first function (if present) is then passed to the second function, which can have any of the following signature:

+	func()
+	func(ctx context.Context)
+	func(ctx SpecContext)
 	func(data []byte)
+	func(ctx context.Context, data []byte)
+	func(ctx SpecContext, data []byte)
+
+If either function receives a context.Context/SpecContext it is considered interruptible.

 You cannot nest any other Ginkgo nodes within an SynchronizedBeforeSuite node's closure.
 You can learn more, and see some examples, here: https://onsi.github.io/ginkgo/#parallel-suite-setup-and-cleanup-synchronizedbeforesuite-and-synchronizedaftersuite
 */
-func SynchronizedBeforeSuite(process1Body func() []byte, allProcessBody func([]byte)) bool {
-	return pushNode(internal.NewSynchronizedBeforeSuiteNode(process1Body, allProcessBody, types.NewCodeLocation(1)))
+func SynchronizedBeforeSuite(process1Body interface{}, allProcessBody interface{}, args ...interface{}) bool {
+	combinedArgs := []interface{}{process1Body, allProcessBody}
+	combinedArgs = append(combinedArgs, args...)
+
+	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeSynchronizedBeforeSuite, "", combinedArgs...))
 }

 /*
@ -573,21 +612,26 @@ and a piece that must only run once - on process #1.

 SynchronizedAfterSuite accomplishes this by taking *two* function arguments.  The first runs on all processes.  The second runs only on parallel process #1
 and *only* after all other processes have finished and exited.  This ensures that process #1, and any resources it is managing, remain alive until
-all other processes are finished.
+all other processes are finished.  These two functions can be bare functions (func()) or interruptible (func(context.Context)/func(SpecContext))

 Note that you can also use DeferCleanup() in SynchronizedBeforeSuite to accomplish similar results.

 You cannot nest any other Ginkgo nodes within an SynchronizedAfterSuite node's closure.
 You can learn more, and see some examples, here: https://onsi.github.io/ginkgo/#parallel-suite-setup-and-cleanup-synchronizedbeforesuite-and-synchronizedaftersuite
 */
-func SynchronizedAfterSuite(allProcessBody func(), process1Body func()) bool {
-	return pushNode(internal.NewSynchronizedAfterSuiteNode(allProcessBody, process1Body, types.NewCodeLocation(1)))
+func SynchronizedAfterSuite(allProcessBody interface{}, process1Body interface{}, args ...interface{}) bool {
+	combinedArgs := []interface{}{allProcessBody, process1Body}
+	combinedArgs = append(combinedArgs, args...)
+
+	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeSynchronizedAfterSuite, "", combinedArgs...))
 }

 /*
 BeforeEach nodes are Setup nodes whose closures run before It node closures.  When multiple BeforeEach nodes
 are defined in nested Container nodes the outermost BeforeEach node closures are run first.

+BeforeEach can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
+
 You cannot nest any other Ginkgo nodes within a BeforeEach node's closure.
 You can learn more here: https://onsi.github.io/ginkgo/#extracting-common-setup-beforeeach
 */
@ -599,6 +643,8 @@ func BeforeEach(args ...interface{}) bool {
 JustBeforeEach nodes are similar to BeforeEach nodes, however they are guaranteed to run *after* all BeforeEach node closures - just before the It node closure.
 This can allow you to separate configuration from creation of resources for a spec.

+JustBeforeEach can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
+
 You cannot nest any other Ginkgo nodes within a JustBeforeEach node's closure.
 You can learn more and see some examples here: https://onsi.github.io/ginkgo/#separating-creation-and-configuration-justbeforeeach
 */
@ -612,6 +658,8 @@ are defined in nested Container nodes the innermost AfterEach node closures are

 Note that you can also use DeferCleanup() in other Setup or Subject nodes to accomplish similar results.

+AfterEach can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
+
 You cannot nest any other Ginkgo nodes within an AfterEach node's closure.
 You can learn more here: https://onsi.github.io/ginkgo/#spec-cleanup-aftereach-and-defercleanup
 */
@ -622,6 +670,8 @@ func AfterEach(args ...interface{}) bool {
 /*
 JustAfterEach nodes are similar to AfterEach nodes, however they are guaranteed to run *before* all AfterEach node closures - just after the It node closure. This can allow you to separate diagnostics collection from teardown for a spec.

+JustAfterEach can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
+
 You cannot nest any other Ginkgo nodes within a JustAfterEach node's closure.
 You can learn more and see some examples here: https://onsi.github.io/ginkgo/#separating-diagnostics-collection-and-teardown-justaftereach
 */
@ -634,6 +684,9 @@ BeforeAll nodes are Setup nodes that can occur inside Ordered containers.  They

 Multiple BeforeAll nodes can be defined in a given Ordered container however they cannot be nested inside any other container.

+BeforeAll can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
+
+
 You cannot nest any other Ginkgo nodes within a BeforeAll node's closure.
 You can learn more about Ordered Containers at: https://onsi.github.io/ginkgo/#ordered-containers
 And you can learn more about BeforeAll at: https://onsi.github.io/ginkgo/#setup-in-ordered-containers-beforeall-and-afterall
@ -649,6 +702,8 @@ Multiple AfterAll nodes can be defined in a given Ordered container however they

 Note that you can also use DeferCleanup() in a BeforeAll node to accomplish similar behavior.

+AfterAll can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
+
 You cannot nest any other Ginkgo nodes within an AfterAll node's closure.
 You can learn more about Ordered Containers at: https://onsi.github.io/ginkgo/#ordered-containers
 And you can learn more about AfterAll at: https://onsi.github.io/ginkgo/#setup-in-ordered-containers-beforeall-and-afterall
@ -663,15 +718,32 @@ DeferCleanup can be called within any Setup or Subject node to register a cleanu
 DeferCleanup can be passed:
 1. A function that takes no arguments and returns no values.
 2. A function that returns an error (in which case it will assert that the returned error was nil, or it will fail the spec).
-3. A function that takes arguments (and optionally returns an error) followed by a list of arguments to passe to the function. For example:
+3. A function that takes a context.Context or SpecContext (and optionally returns an error).  The resulting cleanup node is deemed interruptible and the passed-in context will be cancelled in the event of a timeout or interrupt.
+4. A function that takes arguments (and optionally returns an error) followed by a list of arguments to pass to the function.
+5. A function that takes SpecContext and a list of arguments (and optionally returns an error) followed by a list of arguments to pass to the function.

-    BeforeEach(func() {
-        DeferCleanup(os.SetEnv, "FOO", os.GetEnv("FOO"))
-        os.SetEnv("FOO", "BAR")
-    })
+For example:
+
+	BeforeEach(func() {
+	    DeferCleanup(os.SetEnv, "FOO", os.GetEnv("FOO"))
+	    os.SetEnv("FOO", "BAR")
+	})

 will register a cleanup handler that will set the environment variable "FOO" to it's current value (obtained by os.GetEnv("FOO")) after the spec runs and then sets the environment variable "FOO" to "BAR" for the current spec.

+Similarly:
+
+	BeforeEach(func() {
+	    DeferCleanup(func(ctx SpecContext, path) {
+	    	req, err := http.NewRequestWithContext(ctx, "POST", path, nil)
+	    	Expect(err).NotTo(HaveOccured())
+	    	_, err := http.DefaultClient.Do(req)
+	    	Expect(err).NotTo(HaveOccured())
+	    }, "example.com/cleanup", NodeTimeout(time.Second*3))
+	})
+
+will register a cleanup handler that will have three seconds to successfully complete a request to the specified path. Note that we do not specify a context in the list of arguments passed to DeferCleanup - only in the signature of the function we pass in.  Ginkgo will detect the requested context and supply a SpecContext when it invokes the cleanup node.  If you want to pass in your own context in addition to the Ginkgo-provided SpecContext you must specify the SpecContext as the first argument (e.g. func(ctx SpecContext, otherCtx context.Context)).
+
 When DeferCleanup is called in BeforeEach, JustBeforeEach, It, AfterEach, or JustAfterEach the registered callback will be invoked when the spec completes (i.e. it will behave like an AfterEach node)
 When DeferCleanup is called in BeforeAll or AfterAll the registered callback will be invoked when the ordered container completes (i.e. it will behave like an AfterAll node)
 When DeferCleanup is called in BeforeSuite, SynchronizedBeforeSuite, AfterSuite, or SynchronizedAfterSuite the registered callback will be invoked when the suite completes (i.e. it will behave like an AfterSuite node)
@ -683,5 +755,5 @@ func DeferCleanup(args ...interface{}) {
 	fail := func(message string, cl types.CodeLocation) {
 		global.Failer.Fail(message, cl)
 	}
-	pushNode(internal.NewCleanupNode(fail, args...))
+	pushNode(internal.NewCleanupNode(deprecationTracker, fail, args...))
 }
--- a/vendor/github.com/onsi/ginkgo/v2/decorator_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/v2/decorator_dsl.go
@ -59,7 +59,7 @@ OncePerOrdered is a decorator that allows you to mark outer BeforeEach, AfterEac
 per ordered context.  Normally these setup nodes run around each individual spec, with OncePerOrdered they will run once around the set of specs in an ordered container.
 The behavior for non-Ordered containers/specs is unchanged.

-You can learh more here: https://onsi.github.io/ginkgo/#setup-around-ordered-containers-the-onceperordered-decorator
+You can learn more here: https://onsi.github.io/ginkgo/#setup-around-ordered-containers-the-onceperordered-decorator
 You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
 */
 const OncePerOrdered = internal.OncePerOrdered
@ -81,6 +81,43 @@ You can learn more here: https://onsi.github.io/ginkgo/#spec-labels
 */
 type Labels = internal.Labels

+/*
+PollProgressAfter allows you to override the configured value for --poll-progress-after for a particular node.
+
+Ginkgo will start emitting node progress if the node is still running after a duration of PollProgressAfter.  This allows you to get quicker feedback about the state of a long-running spec.
+*/
+type PollProgressAfter = internal.PollProgressAfter
+
+/*
+PollProgressInterval allows you to override the configured value for --poll-progress-interval for a particular node.
+
+Once a node has been running for longer than PollProgressAfter Ginkgo will emit node progress periodically at an interval of PollProgresInterval.
+*/
+type PollProgressInterval = internal.PollProgressInterval
+
+/*
+NodeTimeout allows you to specify a timeout for an indivdiual node.  The node cannot be a container and must be interruptible (i.e. it must be passed a function that accepts a SpecContext or context.Context).
+
+If the node does not exit within the specified NodeTimeout its context will be cancelled.  The node wil then have a period of time controlled by the GracePeriod decorator (or global --grace-period command-line argument) to exit.  If the node does not exit within GracePeriod Ginkgo will leak the node and proceed to any clean-up nodes associated with the current spec.
+*/
+type NodeTimeout = internal.NodeTimeout
+
+/*
+SpecTimeout allows you to specify a timeout for an indivdiual spec.  SpecTimeout can only decorate interruptible It nodes.
+
+All nodes associated with the It node will need to complete before the SpecTimeout has elapsed.  Individual nodes (e.g. BeforeEach) may be decorated with different NodeTimeouts - but these can only serve to provide a more stringent deadline for the node in question; they cannot extend the deadline past the SpecTimeout.
+
+If the spec does not complete within the specified SpecTimeout the currently running node will have its context cancelled.  The node wil then have a period of time controlled by that node's GracePeriod decorator (or global --grace-period command-line argument) to exit.  If the node does not exit within GracePeriod Ginkgo will leak the node and proceed to any clean-up nodes associated with the current spec.
+*/
+type SpecTimeout = internal.SpecTimeout
+
+/*
+GracePeriod denotes the period of time Ginkgo will wait for an interruptible node to exit once an interruption (whether due to a timeout or a user-invoked signal) has occurred.  If both the global --grace-period cli flag and a GracePeriod decorator are specified the value in the decorator will take precedence.
+
+Nodes that do not finish within a GracePeriod will be leaked and Ginkgo will proceed to run subsequent nodes.  In the event of a timeout, such leaks will be reported to the user.
+*/
+type GracePeriod = internal.GracePeriod
+
 /*
 SuppressProgressReporting is a decorator that allows you to disable progress reporting of a particular node.  This is useful if `ginkgo -v -progress` is generating too much noise; particularly
 if you have a `ReportAfterEach` node that is running for every skipped spec and is generating lots of progress reports.
--- a/vendor/github.com/onsi/ginkgo/v2/deprecated_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/v2/deprecated_dsl.go
@ -13,7 +13,7 @@ import (
 Deprecated: Done Channel for asynchronous testing

 The Done channel pattern is no longer supported in Ginkgo 2.0.
-See here for better patterns for asynchronouse testing: https://onsi.github.io/ginkgo/#patterns-for-asynchronous-testing
+See here for better patterns for asynchronous testing: https://onsi.github.io/ginkgo/#patterns-for-asynchronous-testing

 For a migration guide see: https://onsi.github.io/ginkgo/MIGRATING_TO_V2#removed-async-testing
 */
--- a/vendor/github.com/onsi/ginkgo/v2/internal/group.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/group.go
@ -128,7 +128,10 @@ func (g *group) evaluateSkipStatus(spec Spec) (types.SpecState, types.Failure) {
 	if spec.Skip {
 		return types.SpecStateSkipped, types.Failure{}
 	}
-	if g.suite.interruptHandler.Status().Interrupted || g.suite.skipAll {
+	if g.suite.interruptHandler.Status().Interrupted() || g.suite.skipAll {
+		return types.SpecStateSkipped, types.Failure{}
+	}
+	if !g.suite.deadline.IsZero() && g.suite.deadline.Before(time.Now()) {
 		return types.SpecStateSkipped, types.Failure{}
 	}
 	if !g.succeeded {
@ -163,8 +166,6 @@ func (g *group) isLastSpecWithPair(specID uint, pair runOncePair) bool {
 }

 func (g *group) attemptSpec(isFinalAttempt bool, spec Spec) {
-	interruptStatus := g.suite.interruptHandler.Status()
-
 	pairs := g.runOncePairs[spec.SubjectID()]

 	nodes := spec.Nodes.WithType(types.NodeTypeBeforeAll)
@ -173,12 +174,17 @@ func (g *group) attemptSpec(isFinalAttempt bool, spec Spec) {
 	nodes = append(nodes, spec.Nodes.FirstNodeWithType(types.NodeTypeIt))
 	terminatingNode, terminatingPair := Node{}, runOncePair{}

+	deadline := time.Time{}
+	if spec.SpecTimeout() > 0 {
+		deadline = time.Now().Add(spec.SpecTimeout())
+	}
+
 	for _, node := range nodes {
 		oncePair := pairs.runOncePairFor(node.ID)
 		if !oncePair.isZero() && g.runOnceTracker[oncePair].Is(types.SpecStatePassed) {
 			continue
 		}
-		g.suite.currentSpecReport.State, g.suite.currentSpecReport.Failure = g.suite.runNode(node, interruptStatus.Channel, spec.Nodes.BestTextFor(node))
+		g.suite.currentSpecReport.State, g.suite.currentSpecReport.Failure = g.suite.runNode(node, deadline, spec.Nodes.BestTextFor(node))
 		g.suite.currentSpecReport.RunTime = time.Since(g.suite.currentSpecReport.StartTime)
 		if !oncePair.isZero() {
 			g.runOnceTracker[oncePair] = g.suite.currentSpecReport.State
@ -260,11 +266,13 @@ func (g *group) attemptSpec(isFinalAttempt bool, spec Spec) {

 		for _, node := range nodes {
 			afterNodeWasRun[node.ID] = true
-			state, failure := g.suite.runNode(node, g.suite.interruptHandler.Status().Channel, spec.Nodes.BestTextFor(node))
+			state, failure := g.suite.runNode(node, deadline, spec.Nodes.BestTextFor(node))
 			g.suite.currentSpecReport.RunTime = time.Since(g.suite.currentSpecReport.StartTime)
 			if g.suite.currentSpecReport.State == types.SpecStatePassed || state == types.SpecStateAborted {
 				g.suite.currentSpecReport.State = state
 				g.suite.currentSpecReport.Failure = failure
+			} else if state.Is(types.SpecStateFailureStates) {
+				g.suite.currentSpecReport.AdditionalFailures = append(g.suite.currentSpecReport.AdditionalFailures, types.AdditionalFailure{State: state, Failure: failure})
 			}
 		}
 		includeDeferCleanups = true
@ -279,7 +287,10 @@ func (g *group) run(specs Specs) {
 	}

 	for _, spec := range g.specs {
+		g.suite.selectiveLock.Lock()
 		g.suite.currentSpecReport = g.initialReportForSpec(spec)
+		g.suite.selectiveLock.Unlock()
+
 		g.suite.currentSpecReport.State, g.suite.currentSpecReport.Failure = g.evaluateSkipStatus(spec)
 		g.suite.reporter.WillRun(g.suite.currentSpecReport)
 		g.suite.reportEach(spec, types.NodeTypeReportBeforeEach)
@ -318,227 +329,8 @@ func (g *group) run(specs Specs) {
 		if g.suite.currentSpecReport.State.Is(types.SpecStateFailureStates) {
 			g.succeeded = false
 		}
+		g.suite.selectiveLock.Lock()
 		g.suite.currentSpecReport = types.SpecReport{}
-	}
-}
-
-func (g *group) oldRun(specs Specs) {
-	var suite = g.suite
-	nodeState := map[uint]types.SpecState{}
-	groupSucceeded := true
-
-	indexOfLastSpecContainingNodeID := func(id uint) int {
-		lastIdx := -1
-		for idx := range specs {
-			if specs[idx].Nodes.ContainsNodeID(id) && !specs[idx].Skip {
-				lastIdx = idx
-			}
-		}
-		return lastIdx
-	}
-
-	for i, spec := range specs {
-		suite.currentSpecReport = types.SpecReport{
-			ContainerHierarchyTexts:     spec.Nodes.WithType(types.NodeTypeContainer).Texts(),
-			ContainerHierarchyLocations: spec.Nodes.WithType(types.NodeTypeContainer).CodeLocations(),
-			ContainerHierarchyLabels:    spec.Nodes.WithType(types.NodeTypeContainer).Labels(),
-			LeafNodeLocation:            spec.FirstNodeWithType(types.NodeTypeIt).CodeLocation,
-			LeafNodeType:                types.NodeTypeIt,
-			LeafNodeText:                spec.FirstNodeWithType(types.NodeTypeIt).Text,
-			LeafNodeLabels:              []string(spec.FirstNodeWithType(types.NodeTypeIt).Labels),
-			ParallelProcess:             suite.config.ParallelProcess,
-			IsSerial:                    spec.Nodes.HasNodeMarkedSerial(),
-			IsInOrderedContainer:        !spec.Nodes.FirstNodeMarkedOrdered().IsZero(),
-		}
-
-		skip := spec.Skip
-		if spec.Nodes.HasNodeMarkedPending() {
-			skip = true
-			suite.currentSpecReport.State = types.SpecStatePending
-		} else {
-			if suite.interruptHandler.Status().Interrupted || suite.skipAll {
-				skip = true
-			}
-			if !groupSucceeded {
-				skip = true
-				suite.currentSpecReport.Failure = suite.failureForLeafNodeWithMessage(spec.FirstNodeWithType(types.NodeTypeIt),
-					"Spec skipped because an earlier spec in an ordered container failed")
-			}
-			for _, node := range spec.Nodes.WithType(types.NodeTypeBeforeAll) {
-				if nodeState[node.ID] == types.SpecStateSkipped {
-					skip = true
-					suite.currentSpecReport.Failure = suite.failureForLeafNodeWithMessage(spec.FirstNodeWithType(types.NodeTypeIt),
-						"Spec skipped because Skip() was called in BeforeAll")
-					break
-				}
-			}
-			if skip {
-				suite.currentSpecReport.State = types.SpecStateSkipped
-			}
-		}
-
-		if suite.config.DryRun && !skip {
-			skip = true
-			suite.currentSpecReport.State = types.SpecStatePassed
-		}
-
-		suite.reporter.WillRun(suite.currentSpecReport)
-		//send the spec report to any attached ReportBeforeEach blocks - this will update suite.currentSpecReport if failures occur in these blocks
-		suite.reportEach(spec, types.NodeTypeReportBeforeEach)
-		if suite.currentSpecReport.State.Is(types.SpecStateFailureStates) {
-			//the reportEach failed, skip this spec
-			skip = true
-		}
-
-		suite.currentSpecReport.StartTime = time.Now()
-		maxAttempts := max(1, spec.FlakeAttempts())
-		if suite.config.FlakeAttempts > 0 {
-			maxAttempts = suite.config.FlakeAttempts
-		}
-
-		for attempt := 0; !skip && (attempt < maxAttempts); attempt++ {
-			suite.currentSpecReport.NumAttempts = attempt + 1
-			suite.writer.Truncate()
-			suite.outputInterceptor.StartInterceptingOutput()
-			if attempt > 0 {
-				fmt.Fprintf(suite.writer, "\nGinkgo: Attempt #%d Failed.  Retrying...\n", attempt)
-			}
-			isFinalAttempt := (attempt == maxAttempts-1)
-
-			interruptStatus := suite.interruptHandler.Status()
-			deepestNestingLevelAttained := -1
-			var nodes = spec.Nodes.WithType(types.NodeTypeBeforeAll).Filter(func(n Node) bool {
-				return nodeState[n.ID] != types.SpecStatePassed
-			})
-			nodes = nodes.CopyAppend(spec.Nodes.WithType(types.NodeTypeBeforeEach)...).SortedByAscendingNestingLevel()
-			nodes = nodes.CopyAppend(spec.Nodes.WithType(types.NodeTypeJustBeforeEach).SortedByAscendingNestingLevel()...)
-			nodes = nodes.CopyAppend(spec.Nodes.WithType(types.NodeTypeIt)...)
-
-			var terminatingNode Node
-			for j := range nodes {
-				deepestNestingLevelAttained = max(deepestNestingLevelAttained, nodes[j].NestingLevel)
-				suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(nodes[j], interruptStatus.Channel, spec.Nodes.BestTextFor(nodes[j]))
-				suite.currentSpecReport.RunTime = time.Since(suite.currentSpecReport.StartTime)
-				nodeState[nodes[j].ID] = suite.currentSpecReport.State
-				if suite.currentSpecReport.State != types.SpecStatePassed {
-					terminatingNode = nodes[j]
-					break
-				}
-			}
-
-			afterAllNodesThatRan := map[uint]bool{}
-			// pull out some shared code so we aren't repeating ourselves down below. this just runs after and cleanup nodes
-			runAfterAndCleanupNodes := func(nodes Nodes) {
-				for j := range nodes {
-					state, failure := suite.runNode(nodes[j], suite.interruptHandler.Status().Channel, spec.Nodes.BestTextFor(nodes[j]))
-					suite.currentSpecReport.RunTime = time.Since(suite.currentSpecReport.StartTime)
-					nodeState[nodes[j].ID] = state
-					if suite.currentSpecReport.State == types.SpecStatePassed || state == types.SpecStateAborted {
-						suite.currentSpecReport.State = state
-						suite.currentSpecReport.Failure = failure
-						if state != types.SpecStatePassed {
-							terminatingNode = nodes[j]
-						}
-					}
-					if nodes[j].NodeType.Is(types.NodeTypeAfterAll) {
-						afterAllNodesThatRan[nodes[j].ID] = true
-					}
-				}
-			}
-
-			// pull out a helper that captures the logic of whether or not we should run a given After node.
-			// there is complexity here stemming from the fact that we allow nested ordered contexts and flakey retries
-			shouldRunAfterNode := func(n Node) bool {
-				if n.NodeType.Is(types.NodeTypeAfterEach | types.NodeTypeJustAfterEach) {
-					return true
-				}
-				var id uint
-				if n.NodeType.Is(types.NodeTypeAfterAll) {
-					id = n.ID
-					if afterAllNodesThatRan[id] { //we've already run on this attempt. don't run again.
-						return false
-					}
-				}
-				if n.NodeType.Is(types.NodeTypeCleanupAfterAll) {
-					id = n.NodeIDWhereCleanupWasGenerated
-				}
-				isLastSpecWithNode := indexOfLastSpecContainingNodeID(id) == i
-
-				switch suite.currentSpecReport.State {
-				case types.SpecStatePassed: //we've passed so far...
-					return isLastSpecWithNode //... and we're the last spec with this AfterNode, so we should run it
-				case types.SpecStateSkipped: //the spec was skipped by the user...
-					if isLastSpecWithNode {
-						return true //...we're the last spec, so we should run the AfterNode
-					}
-					if terminatingNode.NodeType.Is(types.NodeTypeBeforeAll) && terminatingNode.NestingLevel == n.NestingLevel {
-						return true //...or, a BeforeAll was skipped and it's at our nesting level, so our subgroup is going to skip
-					}
-				case types.SpecStateFailed, types.SpecStatePanicked: // the spec has failed...
-					if isFinalAttempt {
-						return true //...if this was the last attempt then we're the last spec to run and so the AfterNode should run
-					}
-					if terminatingNode.NodeType.Is(types.NodeTypeBeforeAll) {
-						//...we'll be rerunning a BeforeAll so we should cleanup after it if...
-						if n.NodeType.Is(types.NodeTypeAfterAll) && terminatingNode.NestingLevel == n.NestingLevel {
-							return true //we're at the same nesting level
-						}
-						if n.NodeType.Is(types.NodeTypeCleanupAfterAll) && terminatingNode.ID == n.NodeIDWhereCleanupWasGenerated {
-							return true //we're a DeferCleanup generated by it
-						}
-					}
-					if terminatingNode.NodeType.Is(types.NodeTypeAfterAll) {
-						//...we'll be rerunning an AfterAll so we should cleanup after it if...
-						if n.NodeType.Is(types.NodeTypeCleanupAfterAll) && terminatingNode.ID == n.NodeIDWhereCleanupWasGenerated {
-							return true //we're a DeferCleanup generated by it
-						}
-					}
-				case types.SpecStateInterrupted, types.SpecStateAborted: // ...we've been interrupted and/or aborted
-					return true //...that means the test run is over and we should clean up the stack.  Run the AfterNode
-				}
-				return false
-			}
-
-			// first pass - run all the JustAfterEach, Aftereach, and AfterAlls.  Our shoudlRunAfterNode filter function will clean up the AfterAlls for us.
-			afterNodes := spec.Nodes.WithType(types.NodeTypeJustAfterEach).SortedByDescendingNestingLevel()
-			afterNodes = afterNodes.CopyAppend(spec.Nodes.WithType(types.NodeTypeAfterEach).CopyAppend(spec.Nodes.WithType(types.NodeTypeAfterAll)...).SortedByDescendingNestingLevel()...)
-			afterNodes = afterNodes.WithinNestingLevel(deepestNestingLevelAttained)
-			afterNodes = afterNodes.Filter(shouldRunAfterNode)
-			runAfterAndCleanupNodes(afterNodes)
-
-			// second-pass perhaps we didn't run the AfterAlls but a state change due to an AfterEach now requires us to run the AfterAlls:
-			afterNodes = spec.Nodes.WithType(types.NodeTypeAfterAll).WithinNestingLevel(deepestNestingLevelAttained).Filter(shouldRunAfterNode)
-			runAfterAndCleanupNodes(afterNodes)
-
-			// now we run any DeferCleanups
-			afterNodes = suite.cleanupNodes.WithType(types.NodeTypeCleanupAfterEach).Reverse()
-			afterNodes = append(afterNodes, suite.cleanupNodes.WithType(types.NodeTypeCleanupAfterAll).Filter(shouldRunAfterNode).Reverse()...)
-			runAfterAndCleanupNodes(afterNodes)
-
-			// third-pass, perhaps a DeferCleanup failed and now we need to run the AfterAlls.
-			afterNodes = spec.Nodes.WithType(types.NodeTypeAfterAll).WithinNestingLevel(deepestNestingLevelAttained).Filter(shouldRunAfterNode)
-			runAfterAndCleanupNodes(afterNodes)
-
-			// and finally - running AfterAlls may have generated some new DeferCleanup nodes, let's run them to finish up
-			afterNodes = suite.cleanupNodes.WithType(types.NodeTypeCleanupAfterAll).Reverse().Filter(shouldRunAfterNode)
-			runAfterAndCleanupNodes(afterNodes)
-
-			suite.currentSpecReport.EndTime = time.Now()
-			suite.currentSpecReport.RunTime = suite.currentSpecReport.EndTime.Sub(suite.currentSpecReport.StartTime)
-			suite.currentSpecReport.CapturedGinkgoWriterOutput += string(suite.writer.Bytes())
-			suite.currentSpecReport.CapturedStdOutErr += suite.outputInterceptor.StopInterceptingAndReturnOutput()
-
-			if suite.currentSpecReport.State.Is(types.SpecStatePassed | types.SpecStateSkipped | types.SpecStateAborted | types.SpecStateInterrupted) {
-				break
-			}
-		}
-
-		//send the spec report to any attached ReportAfterEach blocks - this will update suite.currentSpecReport if failures occur in these blocks
-		suite.reportEach(spec, types.NodeTypeReportAfterEach)
-		suite.processCurrentSpecReport()
-		if suite.currentSpecReport.State.Is(types.SpecStateFailureStates) {
-			groupSucceeded = false
-		}
-		suite.currentSpecReport = types.SpecReport{}
+		g.suite.selectiveLock.Unlock()
 	}
 }
--- a/vendor/github.com/onsi/ginkgo/v2/internal/interrupt_handler/interrupt_handler.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/interrupt_handler/interrupt_handler.go
@ -1,39 +1,38 @@
 package interrupt_handler

 import (
-	"fmt"
 	"os"
 	"os/signal"
-	"runtime"
 	"sync"
 	"syscall"
 	"time"

-	"github.com/onsi/ginkgo/v2/formatter"
 	"github.com/onsi/ginkgo/v2/internal/parallel_support"
 )

-const TIMEOUT_REPEAT_INTERRUPT_MAXIMUM_DURATION = 30 * time.Second
-const TIMEOUT_REPEAT_INTERRUPT_FRACTION_OF_TIMEOUT = 10
 const ABORT_POLLING_INTERVAL = 500 * time.Millisecond
-const ABORT_REPEAT_INTERRUPT_DURATION = 30 * time.Second

 type InterruptCause uint

 const (
 	InterruptCauseInvalid InterruptCause = iota
-
 	InterruptCauseSignal
-	InterruptCauseTimeout
 	InterruptCauseAbortByOtherProcess
 )

+type InterruptLevel uint
+
+const (
+	InterruptLevelUninterrupted InterruptLevel = iota
+	InterruptLevelCleanupAndReport
+	InterruptLevelReportOnly
+	InterruptLevelBailOut
+)
+
 func (ic InterruptCause) String() string {
 	switch ic {
 	case InterruptCauseSignal:
 		return "Interrupted by User"
-	case InterruptCauseTimeout:
-		return "Interrupted by Timeout"
 	case InterruptCauseAbortByOtherProcess:
 		return "Interrupted by Other Ginkgo Process"
 	}
@ -41,37 +40,49 @@ func (ic InterruptCause) String() string {
 }

 type InterruptStatus struct {
-	Interrupted bool
-	Channel     chan interface{}
-	Cause       InterruptCause
+	Channel chan interface{}
+	Level   InterruptLevel
+	Cause   InterruptCause
+}
+
+func (s InterruptStatus) Interrupted() bool {
+	return s.Level != InterruptLevelUninterrupted
+}
+
+func (s InterruptStatus) Message() string {
+	return s.Cause.String()
+}
+
+func (s InterruptStatus) ShouldIncludeProgressReport() bool {
+	return s.Cause != InterruptCauseAbortByOtherProcess
 }

 type InterruptHandlerInterface interface {
 	Status() InterruptStatus
-	SetInterruptPlaceholderMessage(string)
-	ClearInterruptPlaceholderMessage()
-	InterruptMessageWithStackTraces() string
 }

 type InterruptHandler struct {
-	c                           chan interface{}
-	lock                        *sync.Mutex
-	interrupted                 bool
-	interruptPlaceholderMessage string
-	interruptCause              InterruptCause
-	client                      parallel_support.Client
-	stop                        chan interface{}
+	c       chan interface{}
+	lock    *sync.Mutex
+	level   InterruptLevel
+	cause   InterruptCause
+	client  parallel_support.Client
+	stop    chan interface{}
+	signals []os.Signal
 }

-func NewInterruptHandler(timeout time.Duration, client parallel_support.Client) *InterruptHandler {
-	handler := &InterruptHandler{
-		c:           make(chan interface{}),
-		lock:        &sync.Mutex{},
-		interrupted: false,
-		stop:        make(chan interface{}),
-		client:      client,
+func NewInterruptHandler(client parallel_support.Client, signals ...os.Signal) *InterruptHandler {
+	if len(signals) == 0 {
+		signals = []os.Signal{os.Interrupt, syscall.SIGTERM}
 	}
-	handler.registerForInterrupts(timeout)
+	handler := &InterruptHandler{
+		c:       make(chan interface{}),
+		lock:    &sync.Mutex{},
+		stop:    make(chan interface{}),
+		client:  client,
+		signals: signals,
+	}
+	handler.registerForInterrupts()
 	return handler
 }

@ -79,30 +90,22 @@ func (handler *InterruptHandler) Stop() {
 	close(handler.stop)
 }

-func (handler *InterruptHandler) registerForInterrupts(timeout time.Duration) {
+func (handler *InterruptHandler) registerForInterrupts() {
 	// os signal handling
 	signalChannel := make(chan os.Signal, 1)
-	signal.Notify(signalChannel, os.Interrupt, syscall.SIGTERM)
-
-	// timeout handling
-	var timeoutChannel <-chan time.Time
-	var timeoutTimer *time.Timer
-	if timeout > 0 {
-		timeoutTimer = time.NewTimer(timeout)
-		timeoutChannel = timeoutTimer.C
-	}
+	signal.Notify(signalChannel, handler.signals...)

 	// cross-process abort handling
-	var abortChannel chan bool
+	var abortChannel chan interface{}
 	if handler.client != nil {
-		abortChannel = make(chan bool)
+		abortChannel = make(chan interface{})
 		go func() {
 			pollTicker := time.NewTicker(ABORT_POLLING_INTERVAL)
 			for {
 				select {
 				case <-pollTicker.C:
 					if handler.client.ShouldAbort() {
-						abortChannel <- true
+						close(abortChannel)
 						pollTicker.Stop()
 						return
 					}
@ -114,55 +117,37 @@ func (handler *InterruptHandler) registerForInterrupts(timeout time.Duration) {
 		}()
 	}

-	// listen for any interrupt signals
-	// note that some (timeouts, cross-process aborts) will only trigger once
-	// for these we set up a ticker to keep interrupting the suite until it ends
-	// this ensures any `AfterEach` or `AfterSuite`s that get stuck cleaning up
-	// get interrupted eventually
-	go func() {
+	go func(abortChannel chan interface{}) {
 		var interruptCause InterruptCause
-		var repeatChannel <-chan time.Time
-		var repeatTicker *time.Ticker
 		for {
 			select {
 			case <-signalChannel:
 				interruptCause = InterruptCauseSignal
-			case <-timeoutChannel:
-				interruptCause = InterruptCauseTimeout
-				repeatInterruptTimeout := timeout / time.Duration(TIMEOUT_REPEAT_INTERRUPT_FRACTION_OF_TIMEOUT)
-				if repeatInterruptTimeout > TIMEOUT_REPEAT_INTERRUPT_MAXIMUM_DURATION {
-					repeatInterruptTimeout = TIMEOUT_REPEAT_INTERRUPT_MAXIMUM_DURATION
-				}
-				timeoutTimer.Stop()
-				repeatTicker = time.NewTicker(repeatInterruptTimeout)
-				repeatChannel = repeatTicker.C
 			case <-abortChannel:
 				interruptCause = InterruptCauseAbortByOtherProcess
-				repeatTicker = time.NewTicker(ABORT_REPEAT_INTERRUPT_DURATION)
-				repeatChannel = repeatTicker.C
-			case <-repeatChannel:
-				//do nothing, just interrupt again using the same interruptCause
 			case <-handler.stop:
-				if timeoutTimer != nil {
-					timeoutTimer.Stop()
-				}
-				if repeatTicker != nil {
-					repeatTicker.Stop()
-				}
 				signal.Stop(signalChannel)
 				return
 			}
+			abortChannel = nil
+
 			handler.lock.Lock()
-			handler.interruptCause = interruptCause
-			if handler.interruptPlaceholderMessage != "" {
-				fmt.Println(handler.interruptPlaceholderMessage)
+			oldLevel := handler.level
+			handler.cause = interruptCause
+			if handler.level == InterruptLevelUninterrupted {
+				handler.level = InterruptLevelCleanupAndReport
+			} else if handler.level == InterruptLevelCleanupAndReport {
+				handler.level = InterruptLevelReportOnly
+			} else if handler.level == InterruptLevelReportOnly {
+				handler.level = InterruptLevelBailOut
+			}
+			if handler.level != oldLevel {
+				close(handler.c)
+				handler.c = make(chan interface{})
 			}
-			handler.interrupted = true
-			close(handler.c)
-			handler.c = make(chan interface{})
 			handler.lock.Unlock()
 		}
-	}()
+	}(abortChannel)
 }

 func (handler *InterruptHandler) Status() InterruptStatus {
@ -170,43 +155,8 @@ func (handler *InterruptHandler) Status() InterruptStatus {
 	defer handler.lock.Unlock()

 	return InterruptStatus{
-		Interrupted: handler.interrupted,
-		Channel:     handler.c,
-		Cause:       handler.interruptCause,
+		Level:   handler.level,
+		Channel: handler.c,
+		Cause:   handler.cause,
 	}
 }
-
-func (handler *InterruptHandler) SetInterruptPlaceholderMessage(message string) {
-	handler.lock.Lock()
-	defer handler.lock.Unlock()
-
-	handler.interruptPlaceholderMessage = message
-}
-
-func (handler *InterruptHandler) ClearInterruptPlaceholderMessage() {
-	handler.lock.Lock()
-	defer handler.lock.Unlock()
-
-	handler.interruptPlaceholderMessage = ""
-}
-
-func (handler *InterruptHandler) InterruptMessageWithStackTraces() string {
-	handler.lock.Lock()
-	out := fmt.Sprintf("%s\n\n", handler.interruptCause.String())
-	defer handler.lock.Unlock()
-	if handler.interruptCause == InterruptCauseAbortByOtherProcess {
-		return out
-	}
-	out += "Here's a stack trace of all running goroutines:\n"
-	buf := make([]byte, 8192)
-	for {
-		n := runtime.Stack(buf, true)
-		if n < len(buf) {
-			buf = buf[:n]
-			break
-		}
-		buf = make([]byte, 2*len(buf))
-	}
-	out += formatter.Fi(1, "%s", string(buf))
-	return out
-}
--- a/vendor/github.com/onsi/ginkgo/v2/internal/node.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/node.go
@ -1,9 +1,11 @@
 package internal

 import (
+	"context"
 	"fmt"
 	"reflect"
 	"sort"
+	"time"

 	"sync"

@ -27,15 +29,20 @@ type Node struct {
 	NodeType types.NodeType

 	Text         string
-	Body         func()
+	Body         func(SpecContext)
 	CodeLocation types.CodeLocation
 	NestingLevel int
+	HasContext   bool

-	SynchronizedBeforeSuiteProc1Body    func() []byte
-	SynchronizedBeforeSuiteAllProcsBody func([]byte)
+	SynchronizedBeforeSuiteProc1Body              func(SpecContext) []byte
+	SynchronizedBeforeSuiteProc1BodyHasContext    bool
+	SynchronizedBeforeSuiteAllProcsBody           func(SpecContext, []byte)
+	SynchronizedBeforeSuiteAllProcsBodyHasContext bool

-	SynchronizedAfterSuiteAllProcsBody func()
-	SynchronizedAfterSuiteProc1Body    func()
+	SynchronizedAfterSuiteAllProcsBody           func(SpecContext)
+	SynchronizedAfterSuiteAllProcsBodyHasContext bool
+	SynchronizedAfterSuiteProc1Body              func(SpecContext)
+	SynchronizedAfterSuiteProc1BodyHasContext    bool

 	ReportEachBody       func(types.SpecReport)
 	ReportAfterSuiteBody func(types.Report)
@ -48,6 +55,11 @@ type Node struct {
 	MarkedSuppressProgressReporting bool
 	FlakeAttempts                   int
 	Labels                          Labels
+	PollProgressAfter               time.Duration
+	PollProgressInterval            time.Duration
+	NodeTimeout                     time.Duration
+	SpecTimeout                     time.Duration
+	GracePeriod                     time.Duration

 	NodeIDWhereCleanupWasGenerated uint
 }
@ -71,6 +83,11 @@ type FlakeAttempts uint
 type Offset uint
 type Done chan<- interface{} // Deprecated Done Channel for asynchronous testing
 type Labels []string
+type PollProgressInterval time.Duration
+type PollProgressAfter time.Duration
+type NodeTimeout time.Duration
+type SpecTimeout time.Duration
+type GracePeriod time.Duration

 func UnionOfLabels(labels ...Labels) Labels {
 	out := Labels{}
@ -123,6 +140,16 @@ func isDecoration(arg interface{}) bool {
 		return true
 	case t == reflect.TypeOf(Labels{}):
 		return true
+	case t == reflect.TypeOf(PollProgressInterval(0)):
+		return true
+	case t == reflect.TypeOf(PollProgressAfter(0)):
+		return true
+	case t == reflect.TypeOf(NodeTimeout(0)):
+		return true
+	case t == reflect.TypeOf(SpecTimeout(0)):
+		return true
+	case t == reflect.TypeOf(GracePeriod(0)):
+		return true
 	case t.Kind() == reflect.Slice && isSliceOfDecorations(arg):
 		return true
 	default:
@ -143,16 +170,23 @@ func isSliceOfDecorations(slice interface{}) bool {
 	return true
 }

+var contextType = reflect.TypeOf(new(context.Context)).Elem()
+var specContextType = reflect.TypeOf(new(SpecContext)).Elem()
+
 func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeType, text string, args ...interface{}) (Node, []error) {
 	baseOffset := 2
 	node := Node{
-		ID:           UniqueNodeID(),
-		NodeType:     nodeType,
-		Text:         text,
-		Labels:       Labels{},
-		CodeLocation: types.NewCodeLocation(baseOffset),
-		NestingLevel: -1,
+		ID:                   UniqueNodeID(),
+		NodeType:             nodeType,
+		Text:                 text,
+		Labels:               Labels{},
+		CodeLocation:         types.NewCodeLocation(baseOffset),
+		NestingLevel:         -1,
+		PollProgressAfter:    -1,
+		PollProgressInterval: -1,
+		GracePeriod:          -1,
 	}
+
 	errors := []error{}
 	appendError := func(err error) {
 		if err != nil {
@ -219,6 +253,31 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
 			if !nodeType.Is(types.NodeTypesForContainerAndIt) {
 				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "FlakeAttempts"))
 			}
+		case t == reflect.TypeOf(PollProgressAfter(0)):
+			node.PollProgressAfter = time.Duration(arg.(PollProgressAfter))
+			if nodeType.Is(types.NodeTypeContainer) {
+				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "PollProgressAfter"))
+			}
+		case t == reflect.TypeOf(PollProgressInterval(0)):
+			node.PollProgressInterval = time.Duration(arg.(PollProgressInterval))
+			if nodeType.Is(types.NodeTypeContainer) {
+				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "PollProgressInterval"))
+			}
+		case t == reflect.TypeOf(NodeTimeout(0)):
+			node.NodeTimeout = time.Duration(arg.(NodeTimeout))
+			if nodeType.Is(types.NodeTypeContainer) {
+				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "NodeTimeout"))
+			}
+		case t == reflect.TypeOf(SpecTimeout(0)):
+			node.SpecTimeout = time.Duration(arg.(SpecTimeout))
+			if !nodeType.Is(types.NodeTypeIt) {
+				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "SpecTimeout"))
+			}
+		case t == reflect.TypeOf(GracePeriod(0)):
+			node.GracePeriod = time.Duration(arg.(GracePeriod))
+			if nodeType.Is(types.NodeTypeContainer) {
+				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "GracePeriod"))
+			}
 		case t == reflect.TypeOf(Labels{}):
 			if !nodeType.Is(types.NodeTypesForContainerAndIt) {
 				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "Label"))
@ -232,35 +291,85 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
 				}
 			}
 		case t.Kind() == reflect.Func:
-			if nodeType.Is(types.NodeTypeReportBeforeEach | types.NodeTypeReportAfterEach) {
-				if node.ReportEachBody != nil {
+			if nodeType.Is(types.NodeTypeContainer) {
+				if node.Body != nil {
 					appendError(types.GinkgoErrors.MultipleBodyFunctions(node.CodeLocation, nodeType))
 					trackedFunctionError = true
 					break
 				}
-
-				//we can trust that the function is valid because the compiler has our back here
-				node.ReportEachBody = arg.(func(types.SpecReport))
-				break
-			}
-
-			if node.Body != nil {
-				appendError(types.GinkgoErrors.MultipleBodyFunctions(node.CodeLocation, nodeType))
-				trackedFunctionError = true
-				break
-			}
-			isValid := (t.NumOut() == 0) && (t.NumIn() <= 1) && (t.NumIn() == 0 || t.In(0) == reflect.TypeOf(make(Done)))
-			if !isValid {
-				appendError(types.GinkgoErrors.InvalidBodyType(t, node.CodeLocation, nodeType))
-				trackedFunctionError = true
-				break
-			}
-			if t.NumIn() == 0 {
-				node.Body = arg.(func())
+				if t.NumOut() > 0 || t.NumIn() > 0 {
+					appendError(types.GinkgoErrors.InvalidBodyTypeForContainer(t, node.CodeLocation, nodeType))
+					trackedFunctionError = true
+					break
+				}
+				body := arg.(func())
+				node.Body = func(SpecContext) { body() }
+			} else if nodeType.Is(types.NodeTypeReportBeforeEach | types.NodeTypeReportAfterEach) {
+				if node.ReportEachBody == nil {
+					node.ReportEachBody = arg.(func(types.SpecReport))
+				} else {
+					appendError(types.GinkgoErrors.MultipleBodyFunctions(node.CodeLocation, nodeType))
+					trackedFunctionError = true
+					break
+				}
+			} else if nodeType.Is(types.NodeTypeReportAfterSuite) {
+				if node.ReportAfterSuiteBody == nil {
+					node.ReportAfterSuiteBody = arg.(func(types.Report))
+				} else {
+					appendError(types.GinkgoErrors.MultipleBodyFunctions(node.CodeLocation, nodeType))
+					trackedFunctionError = true
+					break
+				}
+			} else if nodeType.Is(types.NodeTypeSynchronizedBeforeSuite) {
+				if node.SynchronizedBeforeSuiteProc1Body != nil && node.SynchronizedBeforeSuiteAllProcsBody != nil {
+					appendError(types.GinkgoErrors.MultipleBodyFunctions(node.CodeLocation, nodeType))
+					trackedFunctionError = true
+					break
+				}
+				if node.SynchronizedBeforeSuiteProc1Body == nil {
+					body, hasContext := extractSynchronizedBeforeSuiteProc1Body(arg)
+					if body == nil {
+						appendError(types.GinkgoErrors.InvalidBodyTypeForSynchronizedBeforeSuiteProc1(t, node.CodeLocation))
+						trackedFunctionError = true
+					}
+					node.SynchronizedBeforeSuiteProc1Body, node.SynchronizedBeforeSuiteProc1BodyHasContext = body, hasContext
+				} else if node.SynchronizedBeforeSuiteAllProcsBody == nil {
+					body, hasContext := extractSynchronizedBeforeSuiteAllProcsBody(arg)
+					if body == nil {
+						appendError(types.GinkgoErrors.InvalidBodyTypeForSynchronizedBeforeSuiteAllProcs(t, node.CodeLocation))
+						trackedFunctionError = true
+					}
+					node.SynchronizedBeforeSuiteAllProcsBody, node.SynchronizedBeforeSuiteAllProcsBodyHasContext = body, hasContext
+				}
+			} else if nodeType.Is(types.NodeTypeSynchronizedAfterSuite) {
+				if node.SynchronizedAfterSuiteAllProcsBody != nil && node.SynchronizedAfterSuiteProc1Body != nil {
+					appendError(types.GinkgoErrors.MultipleBodyFunctions(node.CodeLocation, nodeType))
+					trackedFunctionError = true
+					break
+				}
+				body, hasContext := extractBodyFunction(deprecationTracker, node.CodeLocation, arg)
+				if body == nil {
+					appendError(types.GinkgoErrors.InvalidBodyType(t, node.CodeLocation, nodeType))
+					trackedFunctionError = true
+					break
+				}
+				if node.SynchronizedAfterSuiteAllProcsBody == nil {
+					node.SynchronizedAfterSuiteAllProcsBody, node.SynchronizedAfterSuiteAllProcsBodyHasContext = body, hasContext
+				} else if node.SynchronizedAfterSuiteProc1Body == nil {
+					node.SynchronizedAfterSuiteProc1Body, node.SynchronizedAfterSuiteProc1BodyHasContext = body, hasContext
+				}
 			} else {
-				deprecationTracker.TrackDeprecation(types.Deprecations.Async(), node.CodeLocation)
-				deprecatedAsyncBody := arg.(func(Done))
-				node.Body = func() { deprecatedAsyncBody(make(Done)) }
+				if node.Body != nil {
+					appendError(types.GinkgoErrors.MultipleBodyFunctions(node.CodeLocation, nodeType))
+					trackedFunctionError = true
+					break
+				}
+				node.Body, node.HasContext = extractBodyFunction(deprecationTracker, node.CodeLocation, arg)
+				if node.Body == nil {
+					appendError(types.GinkgoErrors.InvalidBodyType(t, node.CodeLocation, nodeType))
+					trackedFunctionError = true
+					break
+				}
 			}
 		default:
 			remainingArgs = append(remainingArgs, arg)
@ -272,9 +381,24 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
 		appendError(types.GinkgoErrors.InvalidDeclarationOfFocusedAndPending(node.CodeLocation, nodeType))
 	}

-	if node.Body == nil && node.ReportEachBody == nil && !node.MarkedPending && !trackedFunctionError {
+	hasContext := node.HasContext || node.SynchronizedAfterSuiteProc1BodyHasContext || node.SynchronizedAfterSuiteAllProcsBodyHasContext || node.SynchronizedBeforeSuiteProc1BodyHasContext || node.SynchronizedBeforeSuiteAllProcsBodyHasContext
+
+	if !hasContext && (node.NodeTimeout > 0 || node.SpecTimeout > 0 || node.GracePeriod > 0) && len(errors) == 0 {
+		appendError(types.GinkgoErrors.InvalidTimeoutOrGracePeriodForNonContextNode(node.CodeLocation, nodeType))
+	}
+
+	if !node.NodeType.Is(types.NodeTypeReportBeforeEach|types.NodeTypeReportAfterEach|types.NodeTypeSynchronizedBeforeSuite|types.NodeTypeSynchronizedAfterSuite|types.NodeTypeReportAfterSuite) && node.Body == nil && !node.MarkedPending && !trackedFunctionError {
 		appendError(types.GinkgoErrors.MissingBodyFunction(node.CodeLocation, nodeType))
 	}
+
+	if node.NodeType.Is(types.NodeTypeSynchronizedBeforeSuite) && !trackedFunctionError && (node.SynchronizedBeforeSuiteProc1Body == nil || node.SynchronizedBeforeSuiteAllProcsBody == nil) {
+		appendError(types.GinkgoErrors.MissingBodyFunction(node.CodeLocation, nodeType))
+	}
+
+	if node.NodeType.Is(types.NodeTypeSynchronizedAfterSuite) && !trackedFunctionError && (node.SynchronizedAfterSuiteProc1Body == nil || node.SynchronizedAfterSuiteAllProcsBody == nil) {
+		appendError(types.GinkgoErrors.MissingBodyFunction(node.CodeLocation, nodeType))
+	}
+
 	for _, arg := range remainingArgs {
 		appendError(types.GinkgoErrors.UnknownDecorator(node.CodeLocation, nodeType, arg))
 	}
@ -286,76 +410,151 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
 	return node, errors
 }

-func NewSynchronizedBeforeSuiteNode(proc1Body func() []byte, allProcsBody func([]byte), codeLocation types.CodeLocation) (Node, []error) {
-	return Node{
-		ID:                                  UniqueNodeID(),
-		NodeType:                            types.NodeTypeSynchronizedBeforeSuite,
-		SynchronizedBeforeSuiteProc1Body:    proc1Body,
-		SynchronizedBeforeSuiteAllProcsBody: allProcsBody,
-		CodeLocation:                        codeLocation,
-	}, nil
-}
+var doneType = reflect.TypeOf(make(Done))

-func NewSynchronizedAfterSuiteNode(allProcsBody func(), proc1Body func(), codeLocation types.CodeLocation) (Node, []error) {
-	return Node{
-		ID:                                 UniqueNodeID(),
-		NodeType:                           types.NodeTypeSynchronizedAfterSuite,
-		SynchronizedAfterSuiteAllProcsBody: allProcsBody,
-		SynchronizedAfterSuiteProc1Body:    proc1Body,
-		CodeLocation:                       codeLocation,
-	}, nil
-}
-
-func NewReportAfterSuiteNode(text string, body func(types.Report), codeLocation types.CodeLocation) (Node, []error) {
-	return Node{
-		ID:                   UniqueNodeID(),
-		Text:                 text,
-		NodeType:             types.NodeTypeReportAfterSuite,
-		ReportAfterSuiteBody: body,
-		CodeLocation:         codeLocation,
-	}, nil
-}
-
-func NewCleanupNode(fail func(string, types.CodeLocation), args ...interface{}) (Node, []error) {
-	baseOffset := 2
-	node := Node{
-		ID:           UniqueNodeID(),
-		NodeType:     types.NodeTypeCleanupInvalid,
-		CodeLocation: types.NewCodeLocation(baseOffset),
-		NestingLevel: -1,
+func extractBodyFunction(deprecationTracker *types.DeprecationTracker, cl types.CodeLocation, arg interface{}) (func(SpecContext), bool) {
+	t := reflect.TypeOf(arg)
+	if t.NumOut() > 0 || t.NumIn() > 1 {
+		return nil, false
 	}
-	remainingArgs := []interface{}{}
-	for _, arg := range args {
+	if t.NumIn() == 1 {
+		if t.In(0) == doneType {
+			deprecationTracker.TrackDeprecation(types.Deprecations.Async(), cl)
+			deprecatedAsyncBody := arg.(func(Done))
+			return func(SpecContext) { deprecatedAsyncBody(make(Done)) }, false
+		} else if t.In(0).Implements(specContextType) {
+			return arg.(func(SpecContext)), true
+		} else if t.In(0).Implements(contextType) {
+			body := arg.(func(context.Context))
+			return func(c SpecContext) { body(c) }, true
+		}
+
+		return nil, false
+	}
+
+	body := arg.(func())
+	return func(SpecContext) { body() }, false
+}
+
+var byteType = reflect.TypeOf([]byte{})
+
+func extractSynchronizedBeforeSuiteProc1Body(arg interface{}) (func(SpecContext) []byte, bool) {
+	t := reflect.TypeOf(arg)
+	v := reflect.ValueOf(arg)
+
+	if t.NumOut() > 1 || t.NumIn() > 1 {
+		return nil, false
+	} else if t.NumOut() == 1 && t.Out(0) != byteType {
+		return nil, false
+	} else if t.NumIn() == 1 && !t.In(0).Implements(contextType) {
+		return nil, false
+	}
+	hasContext := t.NumIn() == 1
+
+	return func(c SpecContext) []byte {
+		var out []reflect.Value
+		if hasContext {
+			out = v.Call([]reflect.Value{reflect.ValueOf(c)})
+		} else {
+			out = v.Call([]reflect.Value{})
+		}
+		if len(out) == 1 {
+			return (out[0].Interface()).([]byte)
+		} else {
+			return []byte{}
+		}
+	}, hasContext
+}
+
+func extractSynchronizedBeforeSuiteAllProcsBody(arg interface{}) (func(SpecContext, []byte), bool) {
+	t := reflect.TypeOf(arg)
+	v := reflect.ValueOf(arg)
+	hasContext, hasByte := false, false
+
+	if t.NumOut() > 0 || t.NumIn() > 2 {
+		return nil, false
+	} else if t.NumIn() == 2 && t.In(0).Implements(contextType) && t.In(1) == byteType {
+		hasContext, hasByte = true, true
+	} else if t.NumIn() == 1 && t.In(0).Implements(contextType) {
+		hasContext = true
+	} else if t.NumIn() == 1 && t.In(0) == byteType {
+		hasByte = true
+	} else if t.NumIn() != 0 {
+		return nil, false
+	}
+
+	return func(c SpecContext, b []byte) {
+		in := []reflect.Value{}
+		if hasContext {
+			in = append(in, reflect.ValueOf(c))
+		}
+		if hasByte {
+			in = append(in, reflect.ValueOf(b))
+		}
+		v.Call(in)
+	}, hasContext
+}
+
+func NewCleanupNode(deprecationTracker *types.DeprecationTracker, fail func(string, types.CodeLocation), args ...interface{}) (Node, []error) {
+	decorations, remainingArgs := PartitionDecorations(args...)
+	baseOffset := 2
+	cl := types.NewCodeLocation(baseOffset)
+	finalArgs := []interface{}{}
+	for _, arg := range decorations {
 		switch t := reflect.TypeOf(arg); {
 		case t == reflect.TypeOf(Offset(0)):
-			node.CodeLocation = types.NewCodeLocation(baseOffset + int(arg.(Offset)))
+			cl = types.NewCodeLocation(baseOffset + int(arg.(Offset)))
 		case t == reflect.TypeOf(types.CodeLocation{}):
-			node.CodeLocation = arg.(types.CodeLocation)
+			cl = arg.(types.CodeLocation)
 		default:
-			remainingArgs = append(remainingArgs, arg)
+			finalArgs = append(finalArgs, arg)
 		}
 	}
+	finalArgs = append(finalArgs, cl)

 	if len(remainingArgs) == 0 {
-		return Node{}, []error{types.GinkgoErrors.DeferCleanupInvalidFunction(node.CodeLocation)}
+		return Node{}, []error{types.GinkgoErrors.DeferCleanupInvalidFunction(cl)}
 	}
+
 	callback := reflect.ValueOf(remainingArgs[0])
 	if !(callback.Kind() == reflect.Func && callback.Type().NumOut() <= 1) {
-		return Node{}, []error{types.GinkgoErrors.DeferCleanupInvalidFunction(node.CodeLocation)}
+		return Node{}, []error{types.GinkgoErrors.DeferCleanupInvalidFunction(cl)}
 	}
+
 	callArgs := []reflect.Value{}
 	for _, arg := range remainingArgs[1:] {
 		callArgs = append(callArgs, reflect.ValueOf(arg))
 	}
-	cl := node.CodeLocation
-	node.Body = func() {
-		out := callback.Call(callArgs)
+
+	hasContext := false
+	t := callback.Type()
+	if t.NumIn() > 0 {
+		if t.In(0).Implements(specContextType) {
+			hasContext = true
+		} else if t.In(0).Implements(contextType) && (len(callArgs) == 0 || !callArgs[0].Type().Implements(contextType)) {
+			hasContext = true
+		}
+	}
+
+	handleFailure := func(out []reflect.Value) {
 		if len(out) == 1 && !out[0].IsNil() {
 			fail(fmt.Sprintf("DeferCleanup callback returned error: %v", out[0]), cl)
 		}
 	}

-	return node, nil
+	if hasContext {
+		finalArgs = append(finalArgs, func(c SpecContext) {
+			out := callback.Call(append([]reflect.Value{reflect.ValueOf(c)}, callArgs...))
+			handleFailure(out)
+		})
+	} else {
+		finalArgs = append(finalArgs, func() {
+			out := callback.Call(callArgs)
+			handleFailure(out)
+		})
+	}
+
+	return NewNode(deprecationTracker, types.NodeTypeCleanupInvalid, "", finalArgs...)
 }

 func (n Node) IsZero() bool {
--- a/vendor/github.com/onsi/ginkgo/v2/internal/output_interceptor.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/output_interceptor.go
@ -143,7 +143,7 @@ func (interceptor *genericOutputInterceptor) ResumeIntercepting() {
 		go startPipeFactory(interceptor.pipeChannel, interceptor.shutdown)
 	}

-	// Now we make a pipe, we'll use this to redirect the input to the 1 and 2 file descriptors (this is how everything else in the world is tring to log to stdout and stderr)
+	// Now we make a pipe, we'll use this to redirect the input to the 1 and 2 file descriptors (this is how everything else in the world is string to log to stdout and stderr)
 	// we get the pipe from our pipe factory.  it runs in the background so we can request the next pipe while the spec being intercepted is running
 	interceptor.pipe = <-interceptor.pipeChannel

--- a/vendor/github.com/onsi/ginkgo/v2/internal/output_interceptor_unix.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/output_interceptor_unix.go
@ -28,7 +28,7 @@ func (impl *dupSyscallOutputInterceptorImpl) CreateStdoutStderrClones() (*os.Fil

 	// And then wrap the clone file descriptors in files.
 	// One benefit of this (that we don't use yet) is that we can actually write
-	// to these files to emit output to the console evne though we're intercepting output
+	// to these files to emit output to the console even though we're intercepting output
 	stdoutClone := os.NewFile(uintptr(stdoutCloneFD), "stdout-clone")
 	stderrClone := os.NewFile(uintptr(stderrCloneFD), "stderr-clone")

--- a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/client_server.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/client_server.go
@ -49,6 +49,7 @@ type Client interface {
 	FetchNextCounter() (int, error)
 	PostAbort() error
 	ShouldAbort() bool
+	PostEmitProgressReport(report types.ProgressReport) error
 	Write(p []byte) (int, error)
 }

--- a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/http_client.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/http_client.go
@ -94,6 +94,10 @@ func (client *httpClient) PostSuiteDidEnd(report types.Report) error {
 	return client.post("/suite-did-end", report)
 }

+func (client *httpClient) PostEmitProgressReport(report types.ProgressReport) error {
+	return client.post("/progress-report", report)
+}
+
 func (client *httpClient) PostSynchronizedBeforeSuiteCompleted(state types.SpecState, data []byte) error {
 	beforeSuiteState := BeforeSuiteState{
 		State: state,
--- a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/http_server.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/http_server.go
@ -49,6 +49,7 @@ func (server *httpServer) Start() {
 	mux.HandleFunc("/did-run", server.didRun)
 	mux.HandleFunc("/suite-did-end", server.specSuiteDidEnd)
 	mux.HandleFunc("/emit-output", server.emitOutput)
+	mux.HandleFunc("/progress-report", server.emitProgressReport)

 	//synchronization endpoints
 	mux.HandleFunc("/before-suite-completed", server.handleBeforeSuiteCompleted)
@ -155,6 +156,14 @@ func (server *httpServer) emitOutput(writer http.ResponseWriter, request *http.R
 	server.handleError(server.handler.EmitOutput(output, &n), writer)
 }

+func (server *httpServer) emitProgressReport(writer http.ResponseWriter, request *http.Request) {
+	var report types.ProgressReport
+	if !server.decode(writer, request, &report) {
+		return
+	}
+	server.handleError(server.handler.EmitProgressReport(report, voidReceiver), writer)
+}
+
 func (server *httpServer) handleBeforeSuiteCompleted(writer http.ResponseWriter, request *http.Request) {
 	var beforeSuiteState BeforeSuiteState
 	if !server.decode(writer, request, &beforeSuiteState) {
--- a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/rpc_client.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/rpc_client.go
@ -72,6 +72,10 @@ func (client *rpcClient) Write(p []byte) (int, error) {
 	return n, err
 }

+func (client *rpcClient) PostEmitProgressReport(report types.ProgressReport) error {
+	return client.client.Call("Server.EmitProgressReport", report, voidReceiver)
+}
+
 func (client *rpcClient) PostSynchronizedBeforeSuiteCompleted(state types.SpecState, data []byte) error {
 	beforeSuiteState := BeforeSuiteState{
 		State: state,
--- a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/server_handler.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/server_handler.go
@ -108,6 +108,13 @@ func (handler *ServerHandler) EmitOutput(output []byte, n *int) error {
 	return err
 }

+func (handler *ServerHandler) EmitProgressReport(report types.ProgressReport, _ *Void) error {
+	handler.lock.Lock()
+	defer handler.lock.Unlock()
+	handler.reporter.EmitProgressReport(report)
+	return nil
+}
+
 func (handler *ServerHandler) registerAlive(proc int, alive func() bool) {
 	handler.lock.Lock()
 	defer handler.lock.Unlock()
--- a/vendor/github.com/onsi/ginkgo/v2/internal/progress_report.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/progress_report.go
@ -0,0 +1,291 @@
+package internal
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/onsi/ginkgo/v2/types"
+)
+
+var _SOURCE_CACHE = map[string][]string{}
+
+type ProgressSignalRegistrar func(func()) context.CancelFunc
+
+func RegisterForProgressSignal(handler func()) context.CancelFunc {
+	signalChannel := make(chan os.Signal, 1)
+	if len(PROGRESS_SIGNALS) > 0 {
+		signal.Notify(signalChannel, PROGRESS_SIGNALS...)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	go func() {
+		for {
+			select {
+			case <-signalChannel:
+				handler()
+			case <-ctx.Done():
+				signal.Stop(signalChannel)
+				return
+			}
+		}
+	}()
+
+	return cancel
+}
+
+type ProgressStepCursor struct {
+	Text         string
+	CodeLocation types.CodeLocation
+	StartTime    time.Time
+}
+
+func NewProgressReport(isRunningInParallel bool, report types.SpecReport, currentNode Node, currentNodeStartTime time.Time, currentStep ProgressStepCursor, gwOutput string, additionalReports []string, sourceRoots []string, includeAll bool) (types.ProgressReport, error) {
+	pr := types.ProgressReport{
+		ParallelProcess:   report.ParallelProcess,
+		RunningInParallel: isRunningInParallel,
+
+		Time: time.Now(),
+
+		ContainerHierarchyTexts: report.ContainerHierarchyTexts,
+		LeafNodeText:            report.LeafNodeText,
+		LeafNodeLocation:        report.LeafNodeLocation,
+		SpecStartTime:           report.StartTime,
+
+		CurrentNodeType:      currentNode.NodeType,
+		CurrentNodeText:      currentNode.Text,
+		CurrentNodeLocation:  currentNode.CodeLocation,
+		CurrentNodeStartTime: currentNodeStartTime,
+
+		CurrentStepText:      currentStep.Text,
+		CurrentStepLocation:  currentStep.CodeLocation,
+		CurrentStepStartTime: currentStep.StartTime,
+
+		AdditionalReports: additionalReports,
+
+		CapturedGinkgoWriterOutput: gwOutput,
+		GinkgoWriterOffset:         len(gwOutput),
+	}
+
+	goroutines, err := extractRunningGoroutines()
+	if err != nil {
+		return pr, err
+	}
+	pr.Goroutines = goroutines
+
+	// now we want to try to find goroutines of interest.  these will be goroutines that have any function calls with code in packagesOfInterest:
+	packagesOfInterest := map[string]bool{}
+	packageFromFilename := func(filename string) string {
+		return filepath.Dir(filename)
+	}
+	addPackageFor := func(filename string) {
+		if filename != "" {
+			packagesOfInterest[packageFromFilename(filename)] = true
+		}
+	}
+	isPackageOfInterest := func(filename string) bool {
+		stackPackage := packageFromFilename(filename)
+		for packageOfInterest := range packagesOfInterest {
+			if strings.HasPrefix(stackPackage, packageOfInterest) {
+				return true
+			}
+		}
+		return false
+	}
+	for _, location := range report.ContainerHierarchyLocations {
+		addPackageFor(location.FileName)
+	}
+	addPackageFor(report.LeafNodeLocation.FileName)
+	addPackageFor(currentNode.CodeLocation.FileName)
+	addPackageFor(currentStep.CodeLocation.FileName)
+
+	//First, we find the SpecGoroutine - this will be the goroutine that includes `runNode`
+	specGoRoutineIdx := -1
+	runNodeFunctionCallIdx := -1
+OUTER:
+	for goroutineIdx, goroutine := range pr.Goroutines {
+		for functionCallIdx, functionCall := range goroutine.Stack {
+			if strings.Contains(functionCall.Function, "ginkgo/v2/internal.(*Suite).runNode.func") {
+				specGoRoutineIdx = goroutineIdx
+				runNodeFunctionCallIdx = functionCallIdx
+				break OUTER
+			}
+		}
+	}
+
+	//Now, we find the first non-Ginkgo function call
+	if specGoRoutineIdx > -1 {
+		for runNodeFunctionCallIdx >= 0 {
+			fn := goroutines[specGoRoutineIdx].Stack[runNodeFunctionCallIdx].Function
+			file := goroutines[specGoRoutineIdx].Stack[runNodeFunctionCallIdx].Filename
+			// these are all things that could potentially happen from within ginkgo
+			if strings.Contains(fn, "ginkgo/v2/internal") || strings.Contains(fn, "reflect.Value") || strings.Contains(file, "ginkgo/table_dsl") || strings.Contains(file, "ginkgo/core_dsl") {
+				runNodeFunctionCallIdx--
+				continue
+			}
+			if strings.Contains(goroutines[specGoRoutineIdx].Stack[runNodeFunctionCallIdx].Function, "ginkgo/table_dsl") {
+
+			}
+			//found it!  lets add its package of interest
+			addPackageFor(goroutines[specGoRoutineIdx].Stack[runNodeFunctionCallIdx].Filename)
+			break
+		}
+	}
+
+	ginkgoEntryPointIdx := -1
+OUTER_GINKGO_ENTRY_POINT:
+	for goroutineIdx, goroutine := range pr.Goroutines {
+		for _, functionCall := range goroutine.Stack {
+			if strings.Contains(functionCall.Function, "ginkgo/v2.RunSpecs") {
+				ginkgoEntryPointIdx = goroutineIdx
+				break OUTER_GINKGO_ENTRY_POINT
+			}
+		}
+	}
+
+	// Now we go through all goroutines and highlight any lines with packages in `packagesOfInterest`
+	// Any goroutines with highlighted lines end up in the HighlightGoRoutines
+	for goroutineIdx, goroutine := range pr.Goroutines {
+		if goroutineIdx == ginkgoEntryPointIdx {
+			continue
+		}
+		if goroutineIdx == specGoRoutineIdx {
+			pr.Goroutines[goroutineIdx].IsSpecGoroutine = true
+		}
+		for functionCallIdx, functionCall := range goroutine.Stack {
+			if isPackageOfInterest(functionCall.Filename) {
+				goroutine.Stack[functionCallIdx].Highlight = true
+				goroutine.Stack[functionCallIdx].Source, goroutine.Stack[functionCallIdx].SourceHighlight = fetchSource(functionCall.Filename, functionCall.Line, 2, sourceRoots)
+			}
+		}
+	}
+
+	if !includeAll {
+		goroutines := []types.Goroutine{pr.SpecGoroutine()}
+		goroutines = append(goroutines, pr.HighlightedGoroutines()...)
+		pr.Goroutines = goroutines
+	}
+
+	return pr, nil
+}
+
+func extractRunningGoroutines() ([]types.Goroutine, error) {
+	var stack []byte
+	for size := 64 * 1024; ; size *= 2 {
+		stack = make([]byte, size)
+		if n := runtime.Stack(stack, true); n < size {
+			stack = stack[:n]
+			break
+		}
+	}
+
+	r := bufio.NewReader(bytes.NewReader(stack))
+	out := []types.Goroutine{}
+	idx := -1
+	for {
+		line, err := r.ReadString('\n')
+		if err == io.EOF {
+			break
+		}
+
+		line = strings.TrimSuffix(line, "\n")
+
+		//skip blank lines
+		if line == "" {
+			continue
+		}
+
+		//parse headers for new goroutine frames
+		if strings.HasPrefix(line, "goroutine") {
+			out = append(out, types.Goroutine{})
+			idx = len(out) - 1
+
+			line = strings.TrimPrefix(line, "goroutine ")
+			line = strings.TrimSuffix(line, ":")
+			fields := strings.SplitN(line, " ", 2)
+			if len(fields) != 2 {
+				return nil, types.GinkgoErrors.FailedToParseStackTrace(fmt.Sprintf("Invalid goroutine frame header: %s", line))
+			}
+			out[idx].ID, err = strconv.ParseUint(fields[0], 10, 64)
+			if err != nil {
+				return nil, types.GinkgoErrors.FailedToParseStackTrace(fmt.Sprintf("Invalid goroutine ID: %s", fields[1]))
+			}
+
+			out[idx].State = strings.TrimSuffix(strings.TrimPrefix(fields[1], "["), "]")
+			continue
+		}
+
+		//if we are here we must be at a function call entry in the stack
+		functionCall := types.FunctionCall{
+			Function: strings.TrimPrefix(line, "created by "), // no need to track 'created by'
+		}
+
+		line, err = r.ReadString('\n')
+		line = strings.TrimSuffix(line, "\n")
+		if err == io.EOF {
+			return nil, types.GinkgoErrors.FailedToParseStackTrace(fmt.Sprintf("Invalid function call: %s -- missing file name and line number", functionCall.Function))
+		}
+		line = strings.TrimLeft(line, " \t")
+		fields := strings.SplitN(line, ":", 2)
+		if len(fields) != 2 {
+			return nil, types.GinkgoErrors.FailedToParseStackTrace(fmt.Sprintf("Invalid filename nad line number: %s", line))
+		}
+		functionCall.Filename = fields[0]
+		line = strings.Split(fields[1], " ")[0]
+		lineNumber, err := strconv.ParseInt(line, 10, 64)
+		functionCall.Line = int(lineNumber)
+		if err != nil {
+			return nil, types.GinkgoErrors.FailedToParseStackTrace(fmt.Sprintf("Invalid function call line number: %s\n%s", line, err.Error()))
+		}
+		out[idx].Stack = append(out[idx].Stack, functionCall)
+	}
+
+	return out, nil
+}
+
+func fetchSource(filename string, lineNumber int, span int, configuredSourceRoots []string) ([]string, int) {
+	if filename == "" {
+		return []string{}, 0
+	}
+
+	var lines []string
+	var ok bool
+	if lines, ok = _SOURCE_CACHE[filename]; !ok {
+		sourceRoots := []string{""}
+		sourceRoots = append(sourceRoots, configuredSourceRoots...)
+		var data []byte
+		var err error
+		var found bool
+		for _, root := range sourceRoots {
+			data, err = os.ReadFile(filepath.Join(root, filename))
+			if err == nil {
+				found = true
+				break
+			}
+		}
+		if !found {
+			return []string{}, 0
+		}
+		lines = strings.Split(string(data), "\n")
+		_SOURCE_CACHE[filename] = lines
+	}
+
+	startIndex := lineNumber - span - 1
+	endIndex := startIndex + span + span + 1
+	if startIndex < 0 {
+		startIndex = 0
+	}
+	if endIndex > len(lines) {
+		endIndex = len(lines)
+	}
+	highlightIndex := lineNumber - 1 - startIndex
+	return lines[startIndex:endIndex], highlightIndex
+}
--- a/vendor/github.com/onsi/ginkgo/v2/internal/progress_report_bsd.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/progress_report_bsd.go
@ -0,0 +1,11 @@
+//go:build freebsd || openbsd || netbsd || darwin || dragonfly
+// +build freebsd openbsd netbsd darwin dragonfly
+
+package internal
+
+import (
+	"os"
+	"syscall"
+)
+
+var PROGRESS_SIGNALS = []os.Signal{syscall.SIGINFO, syscall.SIGUSR1}
--- a/vendor/github.com/onsi/ginkgo/v2/internal/progress_report_unix.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/progress_report_unix.go
@ -0,0 +1,11 @@
+//go:build linux || solaris
+// +build linux solaris
+
+package internal
+
+import (
+	"os"
+	"syscall"
+)
+
+var PROGRESS_SIGNALS = []os.Signal{syscall.SIGUSR1}
--- a/vendor/github.com/onsi/ginkgo/v2/internal/progress_report_win.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/progress_report_win.go
@ -0,0 +1,8 @@
+//go:build windows
+// +build windows
+
+package internal
+
+import "os"
+
+var PROGRESS_SIGNALS = []os.Signal{}
--- a/vendor/github.com/onsi/ginkgo/v2/internal/spec.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/spec.go
@ -2,6 +2,7 @@ package internal

 import (
 	"strings"
+	"time"

 	"github.com/onsi/ginkgo/v2/types"
 )
@ -40,6 +41,10 @@ func (s Spec) FlakeAttempts() int {
 	return flakeAttempts
 }

+func (s Spec) SpecTimeout() time.Duration {
+	return s.FirstNodeWithType(types.NodeTypeIt).SpecTimeout
+}
+
 type Specs []Spec

 func (s Specs) HasAnySpecsMarkedPending() bool {
--- a/vendor/github.com/onsi/ginkgo/v2/internal/spec_context.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/spec_context.go
@ -0,0 +1,90 @@
+package internal
+
+import (
+	"context"
+	"sort"
+	"sync"
+
+	"github.com/onsi/ginkgo/v2/types"
+)
+
+type SpecContext interface {
+	context.Context
+
+	SpecReport() types.SpecReport
+	AttachProgressReporter(func() string) func()
+}
+
+type specContext struct {
+	context.Context
+
+	cancel            context.CancelFunc
+	lock              *sync.Mutex
+	progressReporters map[int]func() string
+	prCounter         int
+
+	suite *Suite
+}
+
+/*
+SpecContext includes a reference to `suite` and embeds itself in itself as a "GINKGO_SPEC_CONTEXT" value.  This allows users to create child Contexts without having down-stream consumers (e.g. Gomega) lose access to the SpecContext and its methods.  This allows us to build extensions on top of Ginkgo that simply take an all-encompassing context.
+
+Note that while SpecContext is used to enforce deadlines by Ginkgo it is not configured as a context.WithDeadline.  Instead, Ginkgo owns responsibility for cancelling the context when the deadline elapses.
+
+This is because Ginkgo needs finer control over when the context is canceled.  Specifically, Ginkgo needs to generate a ProgressReport before it cancels the context to ensure progress is captured where the spec is currently running.  The only way to avoid a race here is to manually control the cancellation.
+*/
+func NewSpecContext(suite *Suite) *specContext {
+	ctx, cancel := context.WithCancel(context.Background())
+	sc := &specContext{
+		cancel:            cancel,
+		suite:             suite,
+		lock:              &sync.Mutex{},
+		prCounter:         0,
+		progressReporters: map[int]func() string{},
+	}
+	ctx = context.WithValue(ctx, "GINKGO_SPEC_CONTEXT", sc) //yes, yes, the go docs say don't use a string for a key... but we'd rather avoid a circular dependency between Gomega and Ginkgo
+	sc.Context = ctx                                        //thank goodness for garbage collectors that can handle circular dependencies
+
+	return sc
+}
+
+func (sc *specContext) SpecReport() types.SpecReport {
+	return sc.suite.CurrentSpecReport()
+}
+
+func (sc *specContext) AttachProgressReporter(reporter func() string) func() {
+	sc.lock.Lock()
+	defer sc.lock.Unlock()
+	sc.prCounter += 1
+	prCounter := sc.prCounter
+	sc.progressReporters[prCounter] = reporter
+
+	return func() {
+		sc.lock.Lock()
+		defer sc.lock.Unlock()
+		delete(sc.progressReporters, prCounter)
+	}
+}
+
+func (sc *specContext) QueryProgressReporters() []string {
+	sc.lock.Lock()
+	keys := []int{}
+	for key := range sc.progressReporters {
+		keys = append(keys, key)
+	}
+	sort.Ints(keys)
+	reporters := []func() string{}
+	for _, key := range keys {
+		reporters = append(reporters, sc.progressReporters[key])
+	}
+	sc.lock.Unlock()
+
+	if len(reporters) == 0 {
+		return nil
+	}
+	out := []string{}
+	for _, reporter := range reporters {
+		out = append(out, reporter())
+	}
+	return out
+}
--- a/vendor/github.com/onsi/ginkgo/v2/internal/suite.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/suite.go
@ -5,7 +5,6 @@ import (
 	"sync"
 	"time"

-	"github.com/onsi/ginkgo/v2/formatter"
 	"github.com/onsi/ginkgo/v2/internal/interrupt_handler"
 	"github.com/onsi/ginkgo/v2/internal/parallel_support"
 	"github.com/onsi/ginkgo/v2/reporters"
@ -35,21 +34,39 @@ type Suite struct {
 	outputInterceptor OutputInterceptor
 	interruptHandler  interrupt_handler.InterruptHandlerInterface
 	config            types.SuiteConfig
+	deadline          time.Time

-	skipAll                         bool
-	report                          types.Report
-	currentSpecReport               types.SpecReport
-	currentSpecReportUserAccessLock *sync.Mutex
-	currentNode                     Node
+	skipAll              bool
+	report               types.Report
+	currentSpecReport    types.SpecReport
+	currentNode          Node
+	currentNodeStartTime time.Time
+
+	currentSpecContext *specContext
+
+	progressStepCursor ProgressStepCursor
+
+	/*
+		We don't need to lock around all operations.  Just those that *could* happen concurrently.
+
+		Suite, generally, only runs one node at a time - and so the possibiity for races is small.  In fact, the presence of a race usually indicates the user has launched a goroutine that has leaked past the node it was launched in.
+
+		However, there are some operations that can happen concurrently:
+
+		- AddReportEntry and CurrentSpecReport can be accessed at any point by the user - including in goroutines that outlive the node intentionally (see, e.g. #1020).  They both form a self-contained read-write pair and so a lock in them is sufficent.
+		- generateProgressReport can be invoked at any point in time by an interrupt or a progres poll.  Moreover, it requires access to currentSpecReport, currentNode, currentNodeStartTime, and progressStepCursor.  To make it threadsafe we need to lock around generateProgressReport when we read those variables _and_ everywhere those variables are *written*.  In general we don't need to worry about all possible field writes to these variables as what `generateProgressReport` does with these variables is fairly selective (hence the name of the lock).  Specifically, we dont' need to lock around state and failure message changes on `currentSpecReport` - just the setting of the variable itself.
+	*/
+	selectiveLock *sync.Mutex

 	client parallel_support.Client
 }

 func NewSuite() *Suite {
 	return &Suite{
-		tree:                            &TreeNode{},
-		phase:                           PhaseBuildTopLevel,
-		currentSpecReportUserAccessLock: &sync.Mutex{},
+		tree:  &TreeNode{},
+		phase: PhaseBuildTopLevel,
+
+		selectiveLock: &sync.Mutex{},
 	}
 }

@ -66,7 +83,7 @@ func (suite *Suite) BuildTree() error {
 	return nil
 }

-func (suite *Suite) Run(description string, suiteLabels Labels, suitePath string, failer *Failer, reporter reporters.Reporter, writer WriterInterface, outputInterceptor OutputInterceptor, interruptHandler interrupt_handler.InterruptHandlerInterface, client parallel_support.Client, suiteConfig types.SuiteConfig) (bool, bool) {
+func (suite *Suite) Run(description string, suiteLabels Labels, suitePath string, failer *Failer, reporter reporters.Reporter, writer WriterInterface, outputInterceptor OutputInterceptor, interruptHandler interrupt_handler.InterruptHandlerInterface, client parallel_support.Client, progressSignalRegistrar ProgressSignalRegistrar, suiteConfig types.SuiteConfig) (bool, bool) {
 	if suite.phase != PhaseBuildTree {
 		panic("cannot run before building the tree = call suite.BuildTree() first")
 	}
@ -83,8 +100,16 @@ func (suite *Suite) Run(description string, suiteLabels Labels, suitePath string
 	suite.interruptHandler = interruptHandler
 	suite.config = suiteConfig

+	if suite.config.Timeout > 0 {
+		suite.deadline = time.Now().Add(suite.config.Timeout)
+	}
+
+	cancelProgressHandler := progressSignalRegistrar(suite.handleProgressSignal)
+
 	success := suite.runSpecs(description, suiteLabels, suitePath, hasProgrammaticFocus, specs)

+	cancelProgressHandler()
+
 	return success, hasProgrammaticFocus
 }

@ -146,7 +171,7 @@ func (suite *Suite) PushNode(node Node) error {
 						err = types.GinkgoErrors.CaughtPanicDuringABuildPhase(e, node.CodeLocation)
 					}
 				}()
-				node.Body()
+				node.Body(nil)
 				return err
 			}()
 			suite.tree = parentTree
@ -211,12 +236,23 @@ func (suite *Suite) pushCleanupNode(node Node) error {
 	return nil
 }

+/*
+  Pushing and popping the Step Cursor stack
+*/
+
+func (suite *Suite) SetProgressStepCursor(cursor ProgressStepCursor) {
+	suite.selectiveLock.Lock()
+	defer suite.selectiveLock.Unlock()
+
+	suite.progressStepCursor = cursor
+}
+
 /*
  Spec Running methods - used during PhaseRun
 */
 func (suite *Suite) CurrentSpecReport() types.SpecReport {
-	suite.currentSpecReportUserAccessLock.Lock()
-	defer suite.currentSpecReportUserAccessLock.Unlock()
+	suite.selectiveLock.Lock()
+	defer suite.selectiveLock.Unlock()
 	report := suite.currentSpecReport
 	if suite.writer != nil {
 		report.CapturedGinkgoWriterOutput = string(suite.writer.Bytes())
@ -227,8 +263,8 @@ func (suite *Suite) CurrentSpecReport() types.SpecReport {
 }

 func (suite *Suite) AddReportEntry(entry ReportEntry) error {
-	suite.currentSpecReportUserAccessLock.Lock()
-	defer suite.currentSpecReportUserAccessLock.Unlock()
+	suite.selectiveLock.Lock()
+	defer suite.selectiveLock.Unlock()
 	if suite.phase != PhaseRun {
 		return types.GinkgoErrors.AddReportEntryNotDuringRunPhase(entry.Location)
 	}
@ -236,6 +272,45 @@ func (suite *Suite) AddReportEntry(entry ReportEntry) error {
 	return nil
 }

+func (suite *Suite) generateProgressReport(fullReport bool) types.ProgressReport {
+	suite.selectiveLock.Lock()
+	defer suite.selectiveLock.Unlock()
+
+	var additionalReports []string
+	if suite.currentSpecContext != nil {
+		additionalReports = suite.currentSpecContext.QueryProgressReporters()
+	}
+	stepCursor := suite.progressStepCursor
+
+	gwOutput := suite.currentSpecReport.CapturedGinkgoWriterOutput + string(suite.writer.Bytes())
+	pr, err := NewProgressReport(suite.isRunningInParallel(), suite.currentSpecReport, suite.currentNode, suite.currentNodeStartTime, stepCursor, gwOutput, additionalReports, suite.config.SourceRoots, fullReport)
+
+	if err != nil {
+		fmt.Printf("{{red}}Failed to generate progress report:{{/}}\n%s\n", err.Error())
+	}
+	return pr
+}
+
+func (suite *Suite) handleProgressSignal() {
+	report := suite.generateProgressReport(false)
+	report.Message = "{{bold}}You've requested a progress report:{{/}}"
+	suite.emitProgressReport(report)
+}
+
+func (suite *Suite) emitProgressReport(report types.ProgressReport) {
+	suite.selectiveLock.Lock()
+	suite.currentSpecReport.ProgressReports = append(suite.currentSpecReport.ProgressReports, report.WithoutCapturedGinkgoWriterOutput())
+	suite.selectiveLock.Unlock()
+
+	suite.reporter.EmitProgressReport(report)
+	if suite.isRunningInParallel() {
+		err := suite.client.PostEmitProgressReport(report)
+		if err != nil {
+			fmt.Println(err.Error())
+		}
+	}
+}
+
 func (suite *Suite) isRunningInParallel() bool {
 	return suite.config.ParallelTotal > 1
 }
@ -322,12 +397,16 @@ func (suite *Suite) runSpecs(description string, suiteLabels Labels, suitePath s
 	suite.runAfterSuiteCleanup(numSpecsThatWillBeRun)

 	interruptStatus := suite.interruptHandler.Status()
-	if interruptStatus.Interrupted {
+	if interruptStatus.Interrupted() {
 		suite.report.SpecialSuiteFailureReasons = append(suite.report.SpecialSuiteFailureReasons, interruptStatus.Cause.String())
 		suite.report.SuiteSucceeded = false
 	}
 	suite.report.EndTime = time.Now()
 	suite.report.RunTime = suite.report.EndTime.Sub(suite.report.StartTime)
+	if !suite.deadline.IsZero() && suite.report.EndTime.After(suite.deadline) {
+		suite.report.SpecialSuiteFailureReasons = append(suite.report.SpecialSuiteFailureReasons, "Suite Timeout Elapsed")
+		suite.report.SuiteSucceeded = false
+	}

 	if suite.config.ParallelProcess == 1 {
 		suite.runReportAfterSuite()
@ -341,16 +420,18 @@ func (suite *Suite) runSpecs(description string, suiteLabels Labels, suitePath s
 }

 func (suite *Suite) runBeforeSuite(numSpecsThatWillBeRun int) {
-	interruptStatus := suite.interruptHandler.Status()
 	beforeSuiteNode := suite.suiteNodes.FirstNodeWithType(types.NodeTypeBeforeSuite | types.NodeTypeSynchronizedBeforeSuite)
-	if !beforeSuiteNode.IsZero() && !interruptStatus.Interrupted && numSpecsThatWillBeRun > 0 {
+	if !beforeSuiteNode.IsZero() && numSpecsThatWillBeRun > 0 {
+		suite.selectiveLock.Lock()
 		suite.currentSpecReport = types.SpecReport{
 			LeafNodeType:     beforeSuiteNode.NodeType,
 			LeafNodeLocation: beforeSuiteNode.CodeLocation,
 			ParallelProcess:  suite.config.ParallelProcess,
 		}
+		suite.selectiveLock.Unlock()
+
 		suite.reporter.WillRun(suite.currentSpecReport)
-		suite.runSuiteNode(beforeSuiteNode, interruptStatus.Channel)
+		suite.runSuiteNode(beforeSuiteNode)
 		if suite.currentSpecReport.State.Is(types.SpecStateSkipped) {
 			suite.report.SpecialSuiteFailureReasons = append(suite.report.SpecialSuiteFailureReasons, "Suite skipped in BeforeSuite")
 			suite.skipAll = true
@ -362,26 +443,32 @@ func (suite *Suite) runBeforeSuite(numSpecsThatWillBeRun int) {
 func (suite *Suite) runAfterSuiteCleanup(numSpecsThatWillBeRun int) {
 	afterSuiteNode := suite.suiteNodes.FirstNodeWithType(types.NodeTypeAfterSuite | types.NodeTypeSynchronizedAfterSuite)
 	if !afterSuiteNode.IsZero() && numSpecsThatWillBeRun > 0 {
+		suite.selectiveLock.Lock()
 		suite.currentSpecReport = types.SpecReport{
 			LeafNodeType:     afterSuiteNode.NodeType,
 			LeafNodeLocation: afterSuiteNode.CodeLocation,
 			ParallelProcess:  suite.config.ParallelProcess,
 		}
+		suite.selectiveLock.Unlock()
+
 		suite.reporter.WillRun(suite.currentSpecReport)
-		suite.runSuiteNode(afterSuiteNode, suite.interruptHandler.Status().Channel)
+		suite.runSuiteNode(afterSuiteNode)
 		suite.processCurrentSpecReport()
 	}

 	afterSuiteCleanup := suite.cleanupNodes.WithType(types.NodeTypeCleanupAfterSuite).Reverse()
 	if len(afterSuiteCleanup) > 0 {
 		for _, cleanupNode := range afterSuiteCleanup {
+			suite.selectiveLock.Lock()
 			suite.currentSpecReport = types.SpecReport{
 				LeafNodeType:     cleanupNode.NodeType,
 				LeafNodeLocation: cleanupNode.CodeLocation,
 				ParallelProcess:  suite.config.ParallelProcess,
 			}
+			suite.selectiveLock.Unlock()
+
 			suite.reporter.WillRun(suite.currentSpecReport)
-			suite.runSuiteNode(cleanupNode, suite.interruptHandler.Status().Channel)
+			suite.runSuiteNode(cleanupNode)
 			suite.processCurrentSpecReport()
 		}
 	}
@ -389,12 +476,15 @@ func (suite *Suite) runAfterSuiteCleanup(numSpecsThatWillBeRun int) {

 func (suite *Suite) runReportAfterSuite() {
 	for _, node := range suite.suiteNodes.WithType(types.NodeTypeReportAfterSuite) {
+		suite.selectiveLock.Lock()
 		suite.currentSpecReport = types.SpecReport{
 			LeafNodeType:     node.NodeType,
 			LeafNodeLocation: node.CodeLocation,
 			LeafNodeText:     node.Text,
 			ParallelProcess:  suite.config.ParallelProcess,
 		}
+		suite.selectiveLock.Unlock()
+
 		suite.reporter.WillRun(suite.currentSpecReport)
 		suite.runReportAfterSuiteNode(node, suite.report)
 		suite.processCurrentSpecReport()
@ -417,16 +507,11 @@ func (suite *Suite) reportEach(spec Spec, nodeType types.NodeType) {
 		suite.writer.Truncate()
 		suite.outputInterceptor.StartInterceptingOutput()
 		report := suite.currentSpecReport
-		nodes[i].Body = func() {
+		nodes[i].Body = func(SpecContext) {
 			nodes[i].ReportEachBody(report)
 		}
-		suite.interruptHandler.SetInterruptPlaceholderMessage(formatter.Fiw(0, formatter.COLS,
-			"{{yellow}}Ginkgo received an interrupt signal but is currently running a %s node.  To avoid an invalid report the %s node will not be interrupted however subsequent tests will be skipped.{{/}}\n\n{{bold}}The running %s node is at:\n%s.{{/}}",
-			nodeType, nodeType, nodeType,
-			nodes[i].CodeLocation,
-		))
-		state, failure := suite.runNode(nodes[i], nil, spec.Nodes.BestTextFor(nodes[i]))
-		suite.interruptHandler.ClearInterruptPlaceholderMessage()
+		state, failure := suite.runNode(nodes[i], time.Time{}, spec.Nodes.BestTextFor(nodes[i]))
+
 		// If the spec is not in a failure state (i.e. it's Passed/Skipped/Pending) and the reporter has failed, override the state.
 		// Also, if the reporter is every aborted - always override the state to propagate the abort
 		if (!suite.currentSpecReport.State.Is(types.SpecStateFailureStates) && state.Is(types.SpecStateFailureStates)) || state.Is(types.SpecStateAborted) {
@ -438,7 +523,7 @@ func (suite *Suite) reportEach(spec Spec, nodeType types.NodeType) {
 	}
 }

-func (suite *Suite) runSuiteNode(node Node, interruptChannel chan interface{}) {
+func (suite *Suite) runSuiteNode(node Node) {
 	if suite.config.DryRun {
 		suite.currentSpecReport.State = types.SpecStatePassed
 		return
@ -451,13 +536,13 @@ func (suite *Suite) runSuiteNode(node Node, interruptChannel chan interface{}) {
 	var err error
 	switch node.NodeType {
 	case types.NodeTypeBeforeSuite, types.NodeTypeAfterSuite:
-		suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(node, interruptChannel, "")
+		suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(node, time.Time{}, "")
 	case types.NodeTypeCleanupAfterSuite:
 		if suite.config.ParallelTotal > 1 && suite.config.ParallelProcess == 1 {
 			err = suite.client.BlockUntilNonprimaryProcsHaveFinished()
 		}
 		if err == nil {
-			suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(node, interruptChannel, "")
+			suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(node, time.Time{}, "")
 		}
 	case types.NodeTypeSynchronizedBeforeSuite:
 		var data []byte
@ -467,8 +552,9 @@ func (suite *Suite) runSuiteNode(node Node, interruptChannel chan interface{}) {
 				suite.outputInterceptor.StopInterceptingAndReturnOutput()
 				suite.outputInterceptor.StartInterceptingOutputAndForwardTo(suite.client)
 			}
-			node.Body = func() { data = node.SynchronizedBeforeSuiteProc1Body() }
-			suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(node, interruptChannel, "")
+			node.Body = func(c SpecContext) { data = node.SynchronizedBeforeSuiteProc1Body(c) }
+			node.HasContext = node.SynchronizedBeforeSuiteProc1BodyHasContext
+			suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(node, time.Time{}, "")
 			if suite.config.ParallelTotal > 1 {
 				suite.currentSpecReport.CapturedStdOutErr += suite.outputInterceptor.StopInterceptingAndReturnOutput()
 				suite.outputInterceptor.StartInterceptingOutput()
@ -485,19 +571,21 @@ func (suite *Suite) runSuiteNode(node Node, interruptChannel chan interface{}) {
 			switch proc1State {
 			case types.SpecStatePassed:
 				runAllProcs = true
-			case types.SpecStateFailed, types.SpecStatePanicked:
+			case types.SpecStateFailed, types.SpecStatePanicked, types.SpecStateTimedout:
 				err = types.GinkgoErrors.SynchronizedBeforeSuiteFailedOnProc1()
 			case types.SpecStateInterrupted, types.SpecStateAborted, types.SpecStateSkipped:
 				suite.currentSpecReport.State = proc1State
 			}
 		}
 		if runAllProcs {
-			node.Body = func() { node.SynchronizedBeforeSuiteAllProcsBody(data) }
-			suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(node, interruptChannel, "")
+			node.Body = func(c SpecContext) { node.SynchronizedBeforeSuiteAllProcsBody(c, data) }
+			node.HasContext = node.SynchronizedBeforeSuiteAllProcsBodyHasContext
+			suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(node, time.Time{}, "")
 		}
 	case types.NodeTypeSynchronizedAfterSuite:
 		node.Body = node.SynchronizedAfterSuiteAllProcsBody
-		suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(node, interruptChannel, "")
+		node.HasContext = node.SynchronizedAfterSuiteAllProcsBodyHasContext
+		suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(node, time.Time{}, "")
 		if suite.config.ParallelProcess == 1 {
 			if suite.config.ParallelTotal > 1 {
 				err = suite.client.BlockUntilNonprimaryProcsHaveFinished()
@ -509,7 +597,8 @@ func (suite *Suite) runSuiteNode(node Node, interruptChannel chan interface{}) {
 				}

 				node.Body = node.SynchronizedAfterSuiteProc1Body
-				state, failure := suite.runNode(node, interruptChannel, "")
+				node.HasContext = node.SynchronizedAfterSuiteProc1BodyHasContext
+				state, failure := suite.runNode(node, time.Time{}, "")
 				if suite.currentSpecReport.State.Is(types.SpecStatePassed) {
 					suite.currentSpecReport.State, suite.currentSpecReport.Failure = state, failure
 				}
@ -543,13 +632,8 @@ func (suite *Suite) runReportAfterSuiteNode(node Node, report types.Report) {
 		report = report.Add(aggregatedReport)
 	}

-	node.Body = func() { node.ReportAfterSuiteBody(report) }
-	suite.interruptHandler.SetInterruptPlaceholderMessage(formatter.Fiw(0, formatter.COLS,
-		"{{yellow}}Ginkgo received an interrupt signal but is currently running a ReportAfterSuite node.  To avoid an invalid report the ReportAfterSuite node will not be interrupted.{{/}}\n\n{{bold}}The running ReportAfterSuite node is at:\n%s.{{/}}",
-		node.CodeLocation,
-	))
-	suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(node, nil, "")
-	suite.interruptHandler.ClearInterruptPlaceholderMessage()
+	node.Body = func(SpecContext) { node.ReportAfterSuiteBody(report) }
+	suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(node, time.Time{}, "")

 	suite.currentSpecReport.EndTime = time.Now()
 	suite.currentSpecReport.RunTime = suite.currentSpecReport.EndTime.Sub(suite.currentSpecReport.StartTime)
@ -559,14 +643,32 @@ func (suite *Suite) runReportAfterSuiteNode(node Node, report types.Report) {
 	return
 }

-func (suite *Suite) runNode(node Node, interruptChannel chan interface{}, text string) (types.SpecState, types.Failure) {
+func (suite *Suite) runNode(node Node, specDeadline time.Time, text string) (types.SpecState, types.Failure) {
 	if node.NodeType.Is(types.NodeTypeCleanupAfterEach | types.NodeTypeCleanupAfterAll | types.NodeTypeCleanupAfterSuite) {
 		suite.cleanupNodes = suite.cleanupNodes.WithoutNode(node)
 	}

+	interruptStatus := suite.interruptHandler.Status()
+	if interruptStatus.Level == interrupt_handler.InterruptLevelBailOut {
+		return types.SpecStateSkipped, types.Failure{}
+	}
+	if interruptStatus.Level == interrupt_handler.InterruptLevelReportOnly && !node.NodeType.Is(types.NodeTypesAllowedDuringReportInterrupt) {
+		return types.SpecStateSkipped, types.Failure{}
+	}
+	if interruptStatus.Level == interrupt_handler.InterruptLevelCleanupAndReport && !node.NodeType.Is(types.NodeTypesAllowedDuringReportInterrupt|types.NodeTypesAllowedDuringCleanupInterrupt) {
+		return types.SpecStateSkipped, types.Failure{}
+	}
+
+	suite.selectiveLock.Lock()
 	suite.currentNode = node
+	suite.currentNodeStartTime = time.Now()
+	suite.progressStepCursor = ProgressStepCursor{}
+	suite.selectiveLock.Unlock()
 	defer func() {
+		suite.selectiveLock.Lock()
 		suite.currentNode = Node{}
+		suite.currentNodeStartTime = time.Time{}
+		suite.selectiveLock.Unlock()
 	}()

 	if suite.config.EmitSpecProgress && !node.MarkedSuppressProgressReporting {
@ -586,6 +688,49 @@ func (suite *Suite) runNode(node Node, interruptChannel chan interface{}, text s
 	} else {
 		failure.FailureNodeContext, failure.FailureNodeContainerIndex = types.FailureNodeInContainer, node.NestingLevel-1
 	}
+	var outcome types.SpecState
+
+	gracePeriod := suite.config.GracePeriod
+	if node.GracePeriod >= 0 {
+		gracePeriod = node.GracePeriod
+	}
+
+	now := time.Now()
+	deadline := suite.deadline
+	if deadline.IsZero() || (!specDeadline.IsZero() && specDeadline.Before(deadline)) {
+		deadline = specDeadline
+	}
+	if node.NodeTimeout > 0 && (deadline.IsZero() || deadline.Sub(now) > node.NodeTimeout) {
+		deadline = now.Add(node.NodeTimeout)
+	}
+	if (!deadline.IsZero() && deadline.Before(now)) || interruptStatus.Interrupted() {
+		//we're out of time already.  let's wait for a NodeTimeout if we have it, or GracePeriod if we don't
+		if node.NodeTimeout > 0 {
+			deadline = now.Add(node.NodeTimeout)
+		} else {
+			deadline = now.Add(gracePeriod)
+		}
+	}
+
+	if !node.HasContext {
+		// this maps onto the pre-context behavior:
+		// - an interrupted node exits immediately.  with this, context-less nodes that are in a spec with a SpecTimeout and/or are interrupted by other means will simply exit immediately after the timeout/interrupt
+		// - clean up nodes have up to GracePeriod (formerly hard-coded at 30s) to complete before they are interrupted
+		gracePeriod = 0
+	}
+
+	sc := NewSpecContext(suite)
+	defer sc.cancel()
+
+	suite.selectiveLock.Lock()
+	suite.currentSpecContext = sc
+	suite.selectiveLock.Unlock()
+
+	var deadlineChannel <-chan time.Time
+	if !deadline.IsZero() {
+		deadlineChannel = time.After(deadline.Sub(now))
+	}
+	var gracePeriodChannel <-chan time.Time

 	outcomeC := make(chan types.SpecState)
 	failureC := make(chan types.Failure)
@ -597,26 +742,125 @@ func (suite *Suite) runNode(node Node, interruptChannel chan interface{}, text s
 				suite.failer.Panic(types.NewCodeLocationWithStackTrace(2), e)
 			}

-			outcome, failureFromRun := suite.failer.Drain()
-			outcomeC <- outcome
+			outcomeFromRun, failureFromRun := suite.failer.Drain()
+			outcomeC <- outcomeFromRun
 			failureC <- failureFromRun
 		}()

-		node.Body()
+		node.Body(sc)
 		finished = true
 	}()

-	select {
-	case outcome := <-outcomeC:
-		failureFromRun := <-failureC
-		if outcome == types.SpecStatePassed {
-			return outcome, types.Failure{}
+	// progress polling timer and channel
+	var emitProgressNow <-chan time.Time
+	var progressPoller *time.Timer
+	var pollProgressAfter, pollProgressInterval = suite.config.PollProgressAfter, suite.config.PollProgressInterval
+	if node.PollProgressAfter >= 0 {
+		pollProgressAfter = node.PollProgressAfter
+	}
+	if node.PollProgressInterval >= 0 {
+		pollProgressInterval = node.PollProgressInterval
+	}
+	if pollProgressAfter > 0 {
+		progressPoller = time.NewTimer(pollProgressAfter)
+		emitProgressNow = progressPoller.C
+		defer progressPoller.Stop()
+	}
+
+	// now we wait for an outcome, an interrupt, a timeout, or a progress poll
+	for {
+		select {
+		case outcomeFromRun := <-outcomeC:
+			failureFromRun := <-failureC
+			if outcome == types.SpecStateInterrupted {
+				// we've already been interrupted.  we just managed to actually exit
+				// before the grace period elapsed
+				return outcome, failure
+			} else if outcome == types.SpecStateTimedout {
+				// we've already timed out.  we just managed to actually exit
+				// before the grace period elapsed.  if we have a failure message we should include it
+				if outcomeFromRun != types.SpecStatePassed {
+					failure.Location, failure.ForwardedPanic = failureFromRun.Location, failureFromRun.ForwardedPanic
+					failure.Message = "This spec timed out and reported the following failure after the timeout:\n\n" + failureFromRun.Message
+				}
+				return outcome, failure
+			}
+			if outcomeFromRun.Is(types.SpecStatePassed) {
+				return outcomeFromRun, types.Failure{}
+			} else {
+				failure.Message, failure.Location, failure.ForwardedPanic = failureFromRun.Message, failureFromRun.Location, failureFromRun.ForwardedPanic
+				return outcomeFromRun, failure
+			}
+		case <-gracePeriodChannel:
+			if node.HasContext && outcome.Is(types.SpecStateTimedout) {
+				report := suite.generateProgressReport(false)
+				report.Message = "{{bold}}{{orange}}A running node failed to exit in time{{/}}\nGinkgo is moving on but a node has timed out and failed to exit before its grace period elapsed.  The node has now leaked and is running in the background.\nHere's a current progress report:"
+				suite.emitProgressReport(report)
+			}
+			return outcome, failure
+		case <-deadlineChannel:
+			// we're out of time - the outcome is a timeout and we capture the failure and progress report
+			outcome = types.SpecStateTimedout
+			failure.Message, failure.Location = "Timedout", node.CodeLocation
+			failure.ProgressReport = suite.generateProgressReport(false).WithoutCapturedGinkgoWriterOutput()
+			failure.ProgressReport.Message = "{{bold}}This is the Progress Report generated when the timeout occurred:{{/}}"
+			deadlineChannel = nil
+			// tell the spec to stop.  it's important we generate the progress report first to make sure we capture where
+			// the spec is actually stuck
+			sc.cancel()
+			//and now we wait for the grace period
+			gracePeriodChannel = time.After(gracePeriod)
+		case <-interruptStatus.Channel:
+			interruptStatus = suite.interruptHandler.Status()
+			deadlineChannel = nil // don't worry about deadlines, time's up now
+
+			if outcome == types.SpecStateInvalid {
+				outcome = types.SpecStateInterrupted
+				failure.Message, failure.Location = interruptStatus.Message(), node.CodeLocation
+				if interruptStatus.ShouldIncludeProgressReport() {
+					failure.ProgressReport = suite.generateProgressReport(true).WithoutCapturedGinkgoWriterOutput()
+					failure.ProgressReport.Message = "{{bold}}This is the Progress Report generated when the interrupt was received:{{/}}"
+				}
+			}
+
+			var report types.ProgressReport
+			if interruptStatus.ShouldIncludeProgressReport() {
+				report = suite.generateProgressReport(false)
+			}
+
+			sc.cancel()
+
+			if interruptStatus.Level == interrupt_handler.InterruptLevelBailOut {
+				if interruptStatus.ShouldIncludeProgressReport() {
+					report.Message = fmt.Sprintf("{{bold}}{{orange}}%s{{/}}\n{{bold}}{{red}}Final interrupt received{{/}}; Ginkgo will not run any cleanup or reporting nodes and will terminate as soon as possible.\nHere's a current progress report:", interruptStatus.Message())
+					suite.emitProgressReport(report)
+				}
+				return outcome, failure
+			}
+			if interruptStatus.ShouldIncludeProgressReport() {
+				if interruptStatus.Level == interrupt_handler.InterruptLevelCleanupAndReport {
+					report.Message = fmt.Sprintf("{{bold}}{{orange}}%s{{/}}\nFirst interrupt received; Ginkgo will run any cleanup and reporting nodes but will skip all remaining specs.  {{bold}}Interrupt again to skip cleanup{{/}}.\nHere's a current progress report:", interruptStatus.Message())
+				} else if interruptStatus.Level == interrupt_handler.InterruptLevelReportOnly {
+					report.Message = fmt.Sprintf("{{bold}}{{orange}}%s{{/}}\nSecond interrupt received; Ginkgo will run any reporting nodes but will skip all remaining specs and cleanup nodes.  {{bold}}Interrupt again to bail immediately{{/}}.\nHere's a current progress report:", interruptStatus.Message())
+				}
+				suite.emitProgressReport(report)
+			}
+
+			if gracePeriodChannel == nil {
+				// we haven't given grace yet... so let's
+				gracePeriodChannel = time.After(gracePeriod)
+			} else {
+				// we've already given grace.  time's up.  now.
+				return outcome, failure
+			}
+		case <-emitProgressNow:
+			report := suite.generateProgressReport(false)
+			report.Message = "{{bold}}Automatically polling progress:{{/}}"
+			suite.emitProgressReport(report)
+			if pollProgressInterval > 0 {
+				progressPoller.Reset(pollProgressInterval)
+			}
 		}
-		failure.Message, failure.Location, failure.ForwardedPanic = failureFromRun.Message, failureFromRun.Location, failureFromRun.ForwardedPanic
-		return outcome, failure
-	case <-interruptChannel:
-		failure.Message, failure.Location = suite.interruptHandler.InterruptMessageWithStackTraces(), node.CodeLocation
-		return types.SpecStateInterrupted, failure
 	}
 }

--- a/vendor/github.com/onsi/ginkgo/v2/reporters/default_reporter.go
+++ b/vendor/github.com/onsi/ginkgo/v2/reporters/default_reporter.go
@ -12,6 +12,7 @@ import (
 	"io"
 	"runtime"
 	"strings"
+	"time"

 	"github.com/onsi/ginkgo/v2/formatter"
 	"github.com/onsi/ginkgo/v2/types"
@ -134,9 +135,11 @@ func (r *DefaultReporter) DidRun(report types.SpecReport) {
 		denoter = fmt.Sprintf("[%s]", report.LeafNodeType)
 	}

+	highlightColor = r.highlightColorForState(report.State)
+
 	switch report.State {
 	case types.SpecStatePassed:
-		highlightColor, succinctLocationBlock = "{{green}}", v.LT(types.VerbosityLevelVerbose)
+		succinctLocationBlock = v.LT(types.VerbosityLevelVerbose)
 		emitGinkgoWriterOutput = (r.conf.AlwaysEmitGinkgoWriter || v.GTE(types.VerbosityLevelVerbose)) && hasGW
 		if report.LeafNodeType.Is(types.NodeTypesForSuiteLevelNodes) {
 			if v.GTE(types.VerbosityLevelVerbose) || hasStd || hasEmittableReports {
@ -157,7 +160,6 @@ func (r *DefaultReporter) DidRun(report types.SpecReport) {
 			stream = false
 		}
 	case types.SpecStatePending:
-		highlightColor = "{{yellow}}"
 		includeRuntime, emitGinkgoWriterOutput = false, false
 		if v.Is(types.VerbosityLevelSuccinct) {
 			header, stream = "P", true
@ -165,20 +167,21 @@ func (r *DefaultReporter) DidRun(report types.SpecReport) {
 			header, succinctLocationBlock = "P [PENDING]", v.LT(types.VerbosityLevelVeryVerbose)
 		}
 	case types.SpecStateSkipped:
-		highlightColor = "{{cyan}}"
 		if report.Failure.Message != "" || v.Is(types.VerbosityLevelVeryVerbose) {
 			header = "S [SKIPPED]"
 		} else {
 			header, stream = "S", true
 		}
 	case types.SpecStateFailed:
-		highlightColor, header = "{{red}}", fmt.Sprintf("%s [FAILED]", denoter)
+		header = fmt.Sprintf("%s [FAILED]", denoter)
+	case types.SpecStateTimedout:
+		header = fmt.Sprintf("%s [TIMEDOUT]", denoter)
 	case types.SpecStatePanicked:
-		highlightColor, header = "{{magenta}}", fmt.Sprintf("%s! [PANICKED]", denoter)
+		header = fmt.Sprintf("%s! [PANICKED]", denoter)
 	case types.SpecStateInterrupted:
-		highlightColor, header = "{{orange}}", fmt.Sprintf("%s! [INTERRUPTED]", denoter)
+		header = fmt.Sprintf("%s! [INTERRUPTED]", denoter)
 	case types.SpecStateAborted:
-		highlightColor, header = "{{coral}}", fmt.Sprintf("%s! [ABORTED]", denoter)
+		header = fmt.Sprintf("%s! [ABORTED]", denoter)
 	}

 	// Emit stream and return
@ -208,9 +211,7 @@ func (r *DefaultReporter) DidRun(report types.SpecReport) {
 	//Emit Captured GinkgoWriter Output
 	if emitGinkgoWriterOutput && hasGW {
 		r.emitBlock("\n")
-		r.emitBlock(r.fi(1, "{{gray}}Begin Captured GinkgoWriter Output >>{{/}}"))
-		r.emitBlock(r.fi(2, "%s", report.CapturedGinkgoWriterOutput))
-		r.emitBlock(r.fi(1, "{{gray}}<< End Captured GinkgoWriter Output{{/}}"))
+		r.emitGinkgoWriterOutput(1, report.CapturedGinkgoWriterOutput, 0)
 	}

 	if hasEmittableReports {
@ -232,23 +233,87 @@ func (r *DefaultReporter) DidRun(report types.SpecReport) {
 	// Emit Failure Message
 	if !report.Failure.IsZero() {
 		r.emitBlock("\n")
-		r.emitBlock(r.fi(1, highlightColor+"%s{{/}}", report.Failure.Message))
-		r.emitBlock(r.fi(1, highlightColor+"In {{bold}}[%s]{{/}}"+highlightColor+" at: {{bold}}%s{{/}}\n", report.Failure.FailureNodeType, report.Failure.Location))
-		if report.Failure.ForwardedPanic != "" {
-			r.emitBlock("\n")
-			r.emitBlock(r.fi(1, highlightColor+"%s{{/}}", report.Failure.ForwardedPanic))
-		}
+		r.EmitFailure(1, report.State, report.Failure, false)
+	}

-		if r.conf.FullTrace || report.Failure.ForwardedPanic != "" {
+	if len(report.AdditionalFailures) > 0 {
+		if v.GTE(types.VerbosityLevelVerbose) {
 			r.emitBlock("\n")
-			r.emitBlock(r.fi(1, highlightColor+"Full Stack Trace{{/}}"))
-			r.emitBlock(r.fi(2, "%s", report.Failure.Location.FullStackTrace))
+			r.emitBlock(r.fi(1, "{{bold}}There were additional failures detected after the initial failure:{{/}}"))
+			for i, additionalFailure := range report.AdditionalFailures {
+				r.EmitFailure(2, additionalFailure.State, additionalFailure.Failure, true)
+				if i < len(report.AdditionalFailures)-1 {
+					r.emitBlock(r.fi(2, "{{gray}}%s{{/}}", strings.Repeat("-", 10)))
+				}
+			}
+		} else {
+			r.emitBlock("\n")
+			r.emitBlock(r.fi(1, "{{bold}}There were additional failures detected after the initial failure.  Here's a summary - for full details run Ginkgo in verbose mode:{{/}}"))
+			for _, additionalFailure := range report.AdditionalFailures {
+				r.emitBlock(r.fi(2, r.highlightColorForState(additionalFailure.State)+"[%s]{{/}} in [%s] at %s",
+					r.humanReadableState(additionalFailure.State),
+					additionalFailure.Failure.FailureNodeType,
+					additionalFailure.Failure.Location,
+				))
+			}
+
 		}
 	}

 	r.emitDelimiter()
 }

+func (r *DefaultReporter) highlightColorForState(state types.SpecState) string {
+	switch state {
+	case types.SpecStatePassed:
+		return "{{green}}"
+	case types.SpecStatePending:
+		return "{{yellow}}"
+	case types.SpecStateSkipped:
+		return "{{cyan}}"
+	case types.SpecStateFailed:
+		return "{{red}}"
+	case types.SpecStateTimedout:
+		return "{{orange}}"
+	case types.SpecStatePanicked:
+		return "{{magenta}}"
+	case types.SpecStateInterrupted:
+		return "{{orange}}"
+	case types.SpecStateAborted:
+		return "{{coral}}"
+	default:
+		return "{{gray}}"
+	}
+}
+
+func (r *DefaultReporter) humanReadableState(state types.SpecState) string {
+	return strings.ToUpper(state.String())
+}
+
+func (r *DefaultReporter) EmitFailure(indent uint, state types.SpecState, failure types.Failure, includeState bool) {
+	highlightColor := r.highlightColorForState(state)
+	if includeState {
+		r.emitBlock(r.fi(indent, highlightColor+"[%s]{{/}}", r.humanReadableState(state)))
+	}
+	r.emitBlock(r.fi(indent, highlightColor+"%s{{/}}", failure.Message))
+	r.emitBlock(r.fi(indent, highlightColor+"In {{bold}}[%s]{{/}}"+highlightColor+" at: {{bold}}%s{{/}}\n", failure.FailureNodeType, failure.Location))
+	if failure.ForwardedPanic != "" {
+		r.emitBlock("\n")
+		r.emitBlock(r.fi(indent, highlightColor+"%s{{/}}", failure.ForwardedPanic))
+	}
+
+	if r.conf.FullTrace || failure.ForwardedPanic != "" {
+		r.emitBlock("\n")
+		r.emitBlock(r.fi(indent, highlightColor+"Full Stack Trace{{/}}"))
+		r.emitBlock(r.fi(indent+1, "%s", failure.Location.FullStackTrace))
+	}
+
+	if !failure.ProgressReport.IsZero() {
+		r.emitBlock("\n")
+		r.emitProgressReport(indent, false, failure.ProgressReport)
+	}
+}
+
 func (r *DefaultReporter) SuiteDidEnd(report types.Report) {
 	failures := report.SpecReports.WithState(types.SpecStateFailureStates)
 	if len(failures) > 0 {
@ -265,6 +330,8 @@ func (r *DefaultReporter) SuiteDidEnd(report types.Report) {
 				highlightColor, heading = "{{magenta}}", "[PANICKED!]"
 			case types.SpecStateAborted:
 				highlightColor, heading = "{{coral}}", "[ABORTED]"
+			case types.SpecStateTimedout:
+				highlightColor, heading = "{{orange}}", "[TIMEDOUT]"
 			case types.SpecStateInterrupted:
 				highlightColor, heading = "{{orange}}", "[INTERRUPTED]"
 			}
@ -314,6 +381,161 @@ func (r *DefaultReporter) SuiteDidEnd(report types.Report) {
 	}
 }

+func (r *DefaultReporter) EmitProgressReport(report types.ProgressReport) {
+	r.emitDelimiter()
+
+	if report.RunningInParallel {
+		r.emit(r.f("{{coral}}Progress Report for Ginkgo Process #{{bold}}%d{{/}}\n", report.ParallelProcess))
+	}
+	r.emitProgressReport(0, true, report)
+	r.emitDelimiter()
+}
+
+func (r *DefaultReporter) emitProgressReport(indent uint, emitGinkgoWriterOutput bool, report types.ProgressReport) {
+	if report.Message != "" {
+		r.emitBlock(r.fi(indent, report.Message+"\n"))
+		indent += 1
+	}
+	if report.LeafNodeText != "" {
+		subjectIndent := indent
+		if len(report.ContainerHierarchyTexts) > 0 {
+			r.emit(r.fi(indent, r.cycleJoin(report.ContainerHierarchyTexts, " ")))
+			r.emit(" ")
+			subjectIndent = 0
+		}
+		r.emit(r.fi(subjectIndent, "{{bold}}{{orange}}%s{{/}} (Spec Runtime: %s)\n", report.LeafNodeText, report.Time.Sub(report.SpecStartTime).Round(time.Millisecond)))
+		r.emit(r.fi(indent+1, "{{gray}}%s{{/}}\n", report.LeafNodeLocation))
+		indent += 1
+	}
+	if report.CurrentNodeType != types.NodeTypeInvalid {
+		r.emit(r.fi(indent, "In {{bold}}{{orange}}[%s]{{/}}", report.CurrentNodeType))
+		if report.CurrentNodeText != "" && !report.CurrentNodeType.Is(types.NodeTypeIt) {
+			r.emit(r.f(" {{bold}}{{orange}}%s{{/}}", report.CurrentNodeText))
+		}
+
+		r.emit(r.f(" (Node Runtime: %s)\n", report.Time.Sub(report.CurrentNodeStartTime).Round(time.Millisecond)))
+		r.emit(r.fi(indent+1, "{{gray}}%s{{/}}\n", report.CurrentNodeLocation))
+		indent += 1
+	}
+	if report.CurrentStepText != "" {
+		r.emit(r.fi(indent, "At {{bold}}{{orange}}[By Step] %s{{/}} (Step Runtime: %s)\n", report.CurrentStepText, report.Time.Sub(report.CurrentStepStartTime).Round(time.Millisecond)))
+		r.emit(r.fi(indent+1, "{{gray}}%s{{/}}\n", report.CurrentStepLocation))
+		indent += 1
+	}
+
+	if indent > 0 {
+		indent -= 1
+	}
+
+	if emitGinkgoWriterOutput && report.CapturedGinkgoWriterOutput != "" && (report.RunningInParallel || r.conf.Verbosity().LT(types.VerbosityLevelVerbose)) {
+		r.emit("\n")
+		r.emitGinkgoWriterOutput(indent, report.CapturedGinkgoWriterOutput, 10)
+	}
+
+	if !report.SpecGoroutine().IsZero() {
+		r.emit("\n")
+		r.emit(r.fi(indent, "{{bold}}{{underline}}Spec Goroutine{{/}}\n"))
+		r.emitGoroutines(indent, report.SpecGoroutine())
+	}
+
+	if len(report.AdditionalReports) > 0 {
+		r.emit("\n")
+		r.emitBlock(r.fi(indent, "{{gray}}Begin Additional Progress Reports >>{{/}}"))
+		for i, additionalReport := range report.AdditionalReports {
+			r.emit(r.fi(indent+1, additionalReport))
+			if i < len(report.AdditionalReports)-1 {
+				r.emitBlock(r.fi(indent+1, "{{gray}}%s{{/}}", strings.Repeat("-", 10)))
+			}
+		}
+		r.emitBlock(r.fi(indent, "{{gray}}<< End Additional Progress Reports{{/}}"))
+	}
+
+	highlightedGoroutines := report.HighlightedGoroutines()
+	if len(highlightedGoroutines) > 0 {
+		r.emit("\n")
+		r.emit(r.fi(indent, "{{bold}}{{underline}}Goroutines of Interest{{/}}\n"))
+		r.emitGoroutines(indent, highlightedGoroutines...)
+	}
+
+	otherGoroutines := report.OtherGoroutines()
+	if len(otherGoroutines) > 0 {
+		r.emit("\n")
+		r.emit(r.fi(indent, "{{gray}}{{bold}}{{underline}}Other Goroutines{{/}}\n"))
+		r.emitGoroutines(indent, otherGoroutines...)
+	}
+}
+
+func (r *DefaultReporter) emitGinkgoWriterOutput(indent uint, output string, limit int) {
+	r.emitBlock(r.fi(indent, "{{gray}}Begin Captured GinkgoWriter Output >>{{/}}"))
+	if limit == 0 {
+		r.emitBlock(r.fi(indent+1, "%s", output))
+	} else {
+		lines := strings.Split(output, "\n")
+		if len(lines) <= limit {
+			r.emitBlock(r.fi(indent+1, "%s", output))
+		} else {
+			r.emitBlock(r.fi(indent+1, "{{gray}}...{{/}}"))
+			for _, line := range lines[len(lines)-limit-1:] {
+				r.emitBlock(r.fi(indent+1, "%s", line))
+			}
+		}
+	}
+	r.emitBlock(r.fi(indent, "{{gray}}<< End Captured GinkgoWriter Output{{/}}"))
+}
+
+func (r *DefaultReporter) emitGoroutines(indent uint, goroutines ...types.Goroutine) {
+	for idx, g := range goroutines {
+		color := "{{gray}}"
+		if g.HasHighlights() {
+			color = "{{orange}}"
+		}
+		r.emit(r.fi(indent, color+"goroutine %d [%s]{{/}}\n", g.ID, g.State))
+		for _, fc := range g.Stack {
+			if fc.Highlight {
+				r.emit(r.fi(indent, color+"{{bold}}> %s{{/}}\n", fc.Function))
+				r.emit(r.fi(indent+2, color+"{{bold}}%s:%d{{/}}\n", fc.Filename, fc.Line))
+				r.emitSource(indent+3, fc)
+			} else {
+				r.emit(r.fi(indent+1, "{{gray}}%s{{/}}\n", fc.Function))
+				r.emit(r.fi(indent+2, "{{gray}}%s:%d{{/}}\n", fc.Filename, fc.Line))
+			}
+		}
+
+		if idx+1 < len(goroutines) {
+			r.emit("\n")
+		}
+	}
+}
+
+func (r *DefaultReporter) emitSource(indent uint, fc types.FunctionCall) {
+	lines := fc.Source
+	if len(lines) == 0 {
+		return
+	}
+
+	lTrim := 100000
+	for _, line := range lines {
+		lTrimLine := len(line) - len(strings.TrimLeft(line, " \t"))
+		if lTrimLine < lTrim && len(line) > 0 {
+			lTrim = lTrimLine
+		}
+	}
+	if lTrim == 100000 {
+		lTrim = 0
+	}
+
+	for idx, line := range lines {
+		if len(line) > lTrim {
+			line = line[lTrim:]
+		}
+		if idx == fc.SourceHighlight {
+			r.emit(r.fi(indent, "{{bold}}{{orange}}> %s{{/}}\n", line))
+		} else {
+			r.emit(r.fi(indent, "| %s\n", line))
+		}
+	}
+}
+
 /* Emitting to the writer */
 func (r *DefaultReporter) emit(s string) {
 	if len(s) > 0 {
--- a/vendor/github.com/onsi/ginkgo/v2/reporters/junit_report.go
+++ b/vendor/github.com/onsi/ginkgo/v2/reporters/junit_report.go
@ -171,8 +171,8 @@ func GenerateJUnitReport(report types.Report, dst string) error {
 			Classname: report.SuiteDescription,
 			Status:    spec.State.String(),
 			Time:      spec.RunTime.Seconds(),
-			SystemOut: systemOutForUnstructureReporters(spec),
-			SystemErr: spec.CapturedGinkgoWriterOutput,
+			SystemOut: systemOutForUnstructuredReporters(spec),
+			SystemErr: systemErrForUnstructuredReporters(spec),
 		}
 		suite.Tests += 1

@ -191,28 +191,35 @@ func GenerateJUnitReport(report types.Report, dst string) error {
 			test.Failure = &JUnitFailure{
 				Message:     spec.Failure.Message,
 				Type:        "failed",
-				Description: fmt.Sprintf("%s\n%s", spec.Failure.Location.String(), spec.Failure.Location.FullStackTrace),
+				Description: failureDescriptionForUnstructuredReporters(spec),
+			}
+			suite.Failures += 1
+		case types.SpecStateTimedout:
+			test.Failure = &JUnitFailure{
+				Message:     spec.Failure.Message,
+				Type:        "timedout",
+				Description: failureDescriptionForUnstructuredReporters(spec),
 			}
 			suite.Failures += 1
 		case types.SpecStateInterrupted:
 			test.Error = &JUnitError{
-				Message:     "interrupted",
+				Message:     spec.Failure.Message,
 				Type:        "interrupted",
-				Description: spec.Failure.Message,
+				Description: failureDescriptionForUnstructuredReporters(spec),
 			}
 			suite.Errors += 1
 		case types.SpecStateAborted:
 			test.Failure = &JUnitFailure{
 				Message:     spec.Failure.Message,
 				Type:        "aborted",
-				Description: fmt.Sprintf("%s\n%s", spec.Failure.Location.String(), spec.Failure.Location.FullStackTrace),
+				Description: failureDescriptionForUnstructuredReporters(spec),
 			}
 			suite.Errors += 1
 		case types.SpecStatePanicked:
 			test.Error = &JUnitError{
 				Message:     spec.Failure.ForwardedPanic,
 				Type:        "panicked",
-				Description: fmt.Sprintf("%s\n%s", spec.Failure.Location.String(), spec.Failure.Location.FullStackTrace),
+				Description: failureDescriptionForUnstructuredReporters(spec),
 			}
 			suite.Errors += 1
 		}
@ -278,7 +285,51 @@ func MergeAndCleanupJUnitReports(sources []string, dst string) ([]string, error)
 	return messages, f.Close()
 }

-func systemOutForUnstructureReporters(spec types.SpecReport) string {
+func failureDescriptionForUnstructuredReporters(spec types.SpecReport) string {
+	out := &strings.Builder{}
+	out.WriteString(spec.Failure.Location.String() + "\n")
+	out.WriteString(spec.Failure.Location.FullStackTrace)
+	if !spec.Failure.ProgressReport.IsZero() {
+		out.WriteString("\n")
+		NewDefaultReporter(types.ReporterConfig{NoColor: true}, out).EmitProgressReport(spec.Failure.ProgressReport)
+	}
+	if len(spec.AdditionalFailures) > 0 {
+		out.WriteString("\nThere were additional failures detected after the initial failure:\n")
+		for i, additionalFailure := range spec.AdditionalFailures {
+			NewDefaultReporter(types.ReporterConfig{NoColor: true}, out).EmitFailure(0, additionalFailure.State, additionalFailure.Failure, true)
+			if i < len(spec.AdditionalFailures)-1 {
+				out.WriteString("----------\n")
+			}
+		}
+	}
+	return out.String()
+}
+
+func systemErrForUnstructuredReporters(spec types.SpecReport) string {
+	out := &strings.Builder{}
+	gw := spec.CapturedGinkgoWriterOutput
+	cursor := 0
+	for _, pr := range spec.ProgressReports {
+		if cursor < pr.GinkgoWriterOffset {
+			if pr.GinkgoWriterOffset < len(gw) {
+				out.WriteString(gw[cursor:pr.GinkgoWriterOffset])
+				cursor = pr.GinkgoWriterOffset
+			} else if cursor < len(gw) {
+				out.WriteString(gw[cursor:])
+				cursor = len(gw)
+			}
+		}
+		NewDefaultReporter(types.ReporterConfig{NoColor: true}, out).EmitProgressReport(pr)
+	}
+
+	if cursor < len(gw) {
+		out.WriteString(gw[cursor:])
+	}
+
+	return out.String()
+}
+
+func systemOutForUnstructuredReporters(spec types.SpecReport) string {
 	systemOut := spec.CapturedStdOutErr
 	if len(spec.ReportEntries) > 0 {
 		systemOut += "\nReport Entries:\n"
--- a/vendor/github.com/onsi/ginkgo/v2/reporters/reporter.go
+++ b/vendor/github.com/onsi/ginkgo/v2/reporters/reporter.go
@ -9,11 +9,13 @@ type Reporter interface {
 	WillRun(report types.SpecReport)
 	DidRun(report types.SpecReport)
 	SuiteDidEnd(report types.Report)
+	EmitProgressReport(progressReport types.ProgressReport)
 }

 type NoopReporter struct{}

-func (n NoopReporter) SuiteWillBegin(report types.Report) {}
-func (n NoopReporter) WillRun(report types.SpecReport)    {}
-func (n NoopReporter) DidRun(report types.SpecReport)     {}
-func (n NoopReporter) SuiteDidEnd(report types.Report)    {}
+func (n NoopReporter) SuiteWillBegin(report types.Report)                     {}
+func (n NoopReporter) WillRun(report types.SpecReport)                        {}
+func (n NoopReporter) DidRun(report types.SpecReport)                         {}
+func (n NoopReporter) SuiteDidEnd(report types.Report)                        {}
+func (n NoopReporter) EmitProgressReport(progressReport types.ProgressReport) {}
--- a/vendor/github.com/onsi/ginkgo/v2/reporters/teamcity_report.go
+++ b/vendor/github.com/onsi/ginkgo/v2/reporters/teamcity_report.go
@ -60,20 +60,24 @@ func GenerateTeamcityReport(report types.Report, dst string) error {
 			}
 			fmt.Fprintf(f, "##teamcity[testIgnored name='%s' message='%s']\n", name, tcEscape(message))
 		case types.SpecStateFailed:
-			details := fmt.Sprintf("%s\n%s", spec.Failure.Location.String(), spec.Failure.Location.FullStackTrace)
+			details := failureDescriptionForUnstructuredReporters(spec)
 			fmt.Fprintf(f, "##teamcity[testFailed name='%s' message='failed - %s' details='%s']\n", name, tcEscape(spec.Failure.Message), tcEscape(details))
 		case types.SpecStatePanicked:
-			details := fmt.Sprintf("%s\n%s", spec.Failure.Location.String(), spec.Failure.Location.FullStackTrace)
+			details := failureDescriptionForUnstructuredReporters(spec)
 			fmt.Fprintf(f, "##teamcity[testFailed name='%s' message='panicked - %s' details='%s']\n", name, tcEscape(spec.Failure.ForwardedPanic), tcEscape(details))
+		case types.SpecStateTimedout:
+			details := failureDescriptionForUnstructuredReporters(spec)
+			fmt.Fprintf(f, "##teamcity[testFailed name='%s' message='timedout - %s' details='%s']\n", name, tcEscape(spec.Failure.Message), tcEscape(details))
 		case types.SpecStateInterrupted:
-			fmt.Fprintf(f, "##teamcity[testFailed name='%s' message='interrupted' details='%s']\n", name, tcEscape(spec.Failure.Message))
+			details := failureDescriptionForUnstructuredReporters(spec)
+			fmt.Fprintf(f, "##teamcity[testFailed name='%s' message='interrupted - %s' details='%s']\n", name, tcEscape(spec.Failure.Message), tcEscape(details))
 		case types.SpecStateAborted:
-			details := fmt.Sprintf("%s\n%s", spec.Failure.Location.String(), spec.Failure.Location.FullStackTrace)
+			details := failureDescriptionForUnstructuredReporters(spec)
 			fmt.Fprintf(f, "##teamcity[testFailed name='%s' message='aborted - %s' details='%s']\n", name, tcEscape(spec.Failure.Message), tcEscape(details))
 		}

-		fmt.Fprintf(f, "##teamcity[testStdOut name='%s' out='%s']\n", name, tcEscape(systemOutForUnstructureReporters(spec)))
-		fmt.Fprintf(f, "##teamcity[testStdErr name='%s' out='%s']\n", name, tcEscape(spec.CapturedGinkgoWriterOutput))
+		fmt.Fprintf(f, "##teamcity[testStdOut name='%s' out='%s']\n", name, tcEscape(systemOutForUnstructuredReporters(spec)))
+		fmt.Fprintf(f, "##teamcity[testStdErr name='%s' out='%s']\n", name, tcEscape(systemErrForUnstructuredReporters(spec)))
 		fmt.Fprintf(f, "##teamcity[testFinished name='%s' duration='%d']\n", name, int(spec.RunTime.Seconds()*1000.0))
 	}
 	fmt.Fprintf(f, "##teamcity[testSuiteFinished name='%s']\n", tcEscape(report.SuiteDescription))
--- a/vendor/github.com/onsi/ginkgo/v2/reporting_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/v2/reporting_dsl.go
@ -115,8 +115,10 @@ You cannot nest any other Ginkgo nodes within a ReportAfterSuite node's closure.
 You can learn more about ReportAfterSuite here: https://onsi.github.io/ginkgo/#generating-reports-programmatically
 You can learn more about Ginkgo's reporting infrastructure, including generating reports with the CLI here: https://onsi.github.io/ginkgo/#generating-machine-readable-reports
 */
-func ReportAfterSuite(text string, body func(Report)) bool {
-	return pushNode(internal.NewReportAfterSuiteNode(text, body, types.NewCodeLocation(1)))
+func ReportAfterSuite(text string, body func(Report), args ...interface{}) bool {
+	combinedArgs := []interface{}{body}
+	combinedArgs = append(combinedArgs, args...)
+	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeReportAfterSuite, text, combinedArgs...))
 }

 func registerReportAfterSuiteNodeForAutogeneratedReports(reporterConfig types.ReporterConfig) {
@ -151,7 +153,8 @@ func registerReportAfterSuiteNodeForAutogeneratedReports(reporterConfig types.Re
 	if reporterConfig.TeamcityReport != "" {
 		flags = append(flags, "--teamcity-report")
 	}
-	pushNode(internal.NewReportAfterSuiteNode(
+	pushNode(internal.NewNode(
+		deprecationTracker, types.NodeTypeReportAfterSuite,
 		fmt.Sprintf("Autogenerated ReportAfterSuite for %s", strings.Join(flags, " ")),
 		body,
 		types.NewCustomCodeLocation("autogenerated by Ginkgo"),
--- a/vendor/github.com/onsi/ginkgo/v2/table_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/v2/table_dsl.go
@ -1,6 +1,7 @@
 package ginkgo

 import (
+	"context"
 	"fmt"
 	"reflect"
 	"strings"
@ -89,6 +90,8 @@ Subsequent arguments accept any Ginkgo decorators.  These are filtered out and t

 Each Entry ends up generating an individual Ginkgo It.  The body of the it is the Table Body function with the Entry parameters passed in.

+If you want to generate interruptible specs simply write a Table function that accepts a SpecContext as its first argument.  You can then decorate individual Entrys with the NodeTimeout and SpecTimeout decorators.
+
 You can learn more about Entry here: https://onsi.github.io/ginkgo/#table-specs
 */
 func Entry(description interface{}, args ...interface{}) TableEntry {
@ -119,12 +122,16 @@ You can mark a particular entry as pending with XEntry.  This is equivalent to X
 */
 var XEntry = PEntry

+var contextType = reflect.TypeOf(new(context.Context)).Elem()
+var specContextType = reflect.TypeOf(new(SpecContext)).Elem()
+
 func generateTable(description string, args ...interface{}) {
 	cl := types.NewCodeLocation(2)
 	containerNodeArgs := []interface{}{cl}

 	entries := []TableEntry{}
 	var itBody interface{}
+	var itBodyType reflect.Type

 	var tableLevelEntryDescription interface{}
 	tableLevelEntryDescription = func(args ...interface{}) string {
@ -135,6 +142,10 @@ func generateTable(description string, args ...interface{}) {
 		return "Entry: " + strings.Join(out, ", ")
 	}

+	if len(args) == 1 {
+		exitIfErr(types.GinkgoErrors.MissingParametersForTableFunction(cl))
+	}
+
 	for i, arg := range args {
 		switch t := reflect.TypeOf(arg); {
 		case t == nil:
@ -152,6 +163,7 @@ func generateTable(description string, args ...interface{}) {
 				exitIfErr(types.GinkgoErrors.MultipleEntryBodyFunctionsForTable(cl))
 			}
 			itBody = arg
+			itBodyType = reflect.TypeOf(itBody)
 		default:
 			containerNodeArgs = append(containerNodeArgs, arg)
 		}
@ -164,7 +176,7 @@ func generateTable(description string, args ...interface{}) {
 			var description string
 			switch t := reflect.TypeOf(entry.description); {
 			case t == nil:
-				err = validateParameters(tableLevelEntryDescription, entry.parameters, "Entry Description function", entry.codeLocation)
+				err = validateParameters(tableLevelEntryDescription, entry.parameters, "Entry Description function", entry.codeLocation, false)
 				if err == nil {
 					description = invokeFunction(tableLevelEntryDescription, entry.parameters)[0].String()
 				}
@ -173,7 +185,7 @@ func generateTable(description string, args ...interface{}) {
 			case t == reflect.TypeOf(""):
 				description = entry.description.(string)
 			case t.Kind() == reflect.Func && t.NumOut() == 1 && t.Out(0) == reflect.TypeOf(""):
-				err = validateParameters(entry.description, entry.parameters, "Entry Description function", entry.codeLocation)
+				err = validateParameters(entry.description, entry.parameters, "Entry Description function", entry.codeLocation, false)
 				if err == nil {
 					description = invokeFunction(entry.description, entry.parameters)[0].String()
 				}
@ -181,17 +193,37 @@ func generateTable(description string, args ...interface{}) {
 				err = types.GinkgoErrors.InvalidEntryDescription(entry.codeLocation)
 			}

-			if err == nil {
-				err = validateParameters(itBody, entry.parameters, "Table Body function", entry.codeLocation)
-			}
 			itNodeArgs := []interface{}{entry.codeLocation}
 			itNodeArgs = append(itNodeArgs, entry.decorations...)
-			itNodeArgs = append(itNodeArgs, func() {
-				if err != nil {
-					panic(err)
+
+			hasContext := false
+			if itBodyType.NumIn() > 0. {
+				if itBodyType.In(0).Implements(specContextType) {
+					hasContext = true
+				} else if itBodyType.In(0).Implements(contextType) && (len(entry.parameters) == 0 || !reflect.TypeOf(entry.parameters[0]).Implements(contextType)) {
+					hasContext = true
 				}
-				invokeFunction(itBody, entry.parameters)
-			})
+			}
+
+			if err == nil {
+				err = validateParameters(itBody, entry.parameters, "Table Body function", entry.codeLocation, hasContext)
+			}
+
+			if hasContext {
+				itNodeArgs = append(itNodeArgs, func(c SpecContext) {
+					if err != nil {
+						panic(err)
+					}
+					invokeFunction(itBody, append([]interface{}{c}, entry.parameters...))
+				})
+			} else {
+				itNodeArgs = append(itNodeArgs, func() {
+					if err != nil {
+						panic(err)
+					}
+					invokeFunction(itBody, entry.parameters)
+				})
+			}

 			pushNode(internal.NewNode(deprecationTracker, types.NodeTypeIt, description, itNodeArgs...))
 		}
@ -223,9 +255,14 @@ func invokeFunction(function interface{}, parameters []interface{}) []reflect.Va
 	return reflect.ValueOf(function).Call(inValues)
 }

-func validateParameters(function interface{}, parameters []interface{}, kind string, cl types.CodeLocation) error {
+func validateParameters(function interface{}, parameters []interface{}, kind string, cl types.CodeLocation, hasContext bool) error {
 	funcType := reflect.TypeOf(function)
 	limit := funcType.NumIn()
+	offset := 0
+	if hasContext {
+		limit = limit - 1
+		offset = 1
+	}
 	if funcType.IsVariadic() {
 		limit = limit - 1
 	}
@ -238,13 +275,13 @@ func validateParameters(function interface{}, parameters []interface{}, kind str
 	var i = 0
 	for ; i < limit; i++ {
 		actual := reflect.TypeOf(parameters[i])
-		expected := funcType.In(i)
+		expected := funcType.In(i + offset)
 		if !(actual == nil) && !actual.AssignableTo(expected) {
 			return types.GinkgoErrors.IncorrectParameterTypeToTableFunction(i+1, expected, actual, kind, cl)
 		}
 	}
 	if funcType.IsVariadic() {
-		expected := funcType.In(limit).Elem()
+		expected := funcType.In(limit + offset).Elem()
 		for ; i < len(parameters); i++ {
 			actual := reflect.TypeOf(parameters[i])
 			if !(actual == nil) && !actual.AssignableTo(expected) {
--- a/vendor/github.com/onsi/ginkgo/v2/types/code_location.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/code_location.go
@ -1,5 +1,4 @@
 package types
-
 import (
 	"fmt"
 	"os"
--- a/vendor/github.com/onsi/ginkgo/v2/types/config.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/config.go
@ -28,8 +28,12 @@ type SuiteConfig struct {
 	FlakeAttempts         int
 	EmitSpecProgress      bool
 	DryRun                bool
+	PollProgressAfter     time.Duration
+	PollProgressInterval  time.Duration
 	Timeout               time.Duration
 	OutputInterceptorMode string
+	SourceRoots           []string
+	GracePeriod           time.Duration

 	ParallelProcess int
 	ParallelTotal   int
@ -42,6 +46,7 @@ func NewDefaultSuiteConfig() SuiteConfig {
 		Timeout:         time.Hour,
 		ParallelProcess: 1,
 		ParallelTotal:   1,
+		GracePeriod:     30 * time.Second,
 	}
 }

@ -272,8 +277,16 @@ var SuiteConfigFlags = GinkgoFlags{
 		Usage: "If set, ginkgo will walk the test hierarchy without actually running anything.  Best paired with -v."},
 	{KeyPath: "S.EmitSpecProgress", Name: "progress", SectionKey: "debug",
 		Usage: "If set, ginkgo will emit progress information as each spec runs to the GinkgoWriter."},
+	{KeyPath: "S.PollProgressAfter", Name: "poll-progress-after", SectionKey: "debug", UsageDefaultValue: "0",
+		Usage: "Emit node progress reports periodically if node hasn't completed after this duration."},
+	{KeyPath: "S.PollProgressInterval", Name: "poll-progress-interval", SectionKey: "debug", UsageDefaultValue: "10s",
+		Usage: "The rate at which to emit node progress reports after poll-progress-after has elapsed."},
+	{KeyPath: "S.SourceRoots", Name: "source-root", SectionKey: "debug",
+		Usage: "The location to look for source code when generating progress reports.  You can pass multiple --source-root flags."},
 	{KeyPath: "S.Timeout", Name: "timeout", SectionKey: "debug", UsageDefaultValue: "1h",
 		Usage: "Test suite fails if it does not complete within the specified timeout."},
+	{KeyPath: "S.GracePeriod", Name: "grace-period", SectionKey: "debug", UsageDefaultValue: "30s",
+		Usage: "When interrupted, Ginkgo will wait for GracePeriod for the current running node to exit before moving on to the next one."},
 	{KeyPath: "S.OutputInterceptorMode", Name: "output-interceptor-mode", SectionKey: "debug", UsageArgument: "dup, swap, or none",
 		Usage: "If set, ginkgo will use the specified output interception strategy when running in parallel.  Defaults to dup on unix and swap on windows."},

@ -381,6 +394,10 @@ func VetConfig(flagSet GinkgoFlagSet, suiteConfig SuiteConfig, reporterConfig Re
 		errors = append(errors, GinkgoErrors.DryRunInParallelConfiguration())
 	}

+	if suiteConfig.GracePeriod <= 0 {
+		errors = append(errors, GinkgoErrors.GracePeriodCannotBeZero())
+	}
+
 	if len(suiteConfig.FocusFiles) > 0 {
 		_, err := ParseFileFilters(suiteConfig.FocusFiles)
 		if err != nil {
--- a/vendor/github.com/onsi/ginkgo/v2/types/errors.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/errors.go
@ -189,20 +189,55 @@ func (g ginkgoErrors) UnknownDecorator(cl CodeLocation, nodeType NodeType, decor
 	}
 }

+func (g ginkgoErrors) InvalidBodyTypeForContainer(t reflect.Type, cl CodeLocation, nodeType NodeType) error {
+	return GinkgoError{
+		Heading:      "Invalid Function",
+		Message:      formatter.F(`[%s] node must be passed {{bold}}func(){{/}} - i.e. functions that take nothing and return nothing.  You passed {{bold}}%s{{/}} instead.`, nodeType, t),
+		CodeLocation: cl,
+		DocLink:      "node-decorators-overview",
+	}
+}
+
 func (g ginkgoErrors) InvalidBodyType(t reflect.Type, cl CodeLocation, nodeType NodeType) error {
+	mustGet := "{{bold}}func(){{/}}, {{bold}}func(ctx SpecContext){{/}}, or {{bold}}func(ctx context.Context){{/}}"
+	if nodeType.Is(NodeTypeContainer) {
+		mustGet = "{{bold}}func(){{/}}"
+	}
 	return GinkgoError{
 		Heading: "Invalid Function",
-		Message: formatter.F(`[%s] node must be passed {{bold}}func(){{/}} - i.e. functions that take nothing and return nothing.
+		Message: formatter.F(`[%s] node must be passed `+mustGet+`.
 You passed {{bold}}%s{{/}} instead.`, nodeType, t),
 		CodeLocation: cl,
 		DocLink:      "node-decorators-overview",
 	}
 }

+func (g ginkgoErrors) InvalidBodyTypeForSynchronizedBeforeSuiteProc1(t reflect.Type, cl CodeLocation) error {
+	mustGet := "{{bold}}func() []byte{{/}}, {{bold}}func(ctx SpecContext) []byte{{/}}, or {{bold}}func(ctx context.Context) []byte{{/}}, {{bold}}func(){{/}}, {{bold}}func(ctx SpecContext){{/}}, or {{bold}}func(ctx context.Context){{/}}"
+	return GinkgoError{
+		Heading: "Invalid Function",
+		Message: formatter.F(`[SynchronizedBeforeSuite] node must be passed `+mustGet+` for its first function.
+You passed {{bold}}%s{{/}} instead.`, t),
+		CodeLocation: cl,
+		DocLink:      "node-decorators-overview",
+	}
+}
+
+func (g ginkgoErrors) InvalidBodyTypeForSynchronizedBeforeSuiteAllProcs(t reflect.Type, cl CodeLocation) error {
+	mustGet := "{{bold}}func(){{/}}, {{bold}}func(ctx SpecContext){{/}}, or {{bold}}func(ctx context.Context){{/}}, {{bold}}func([]byte){{/}}, {{bold}}func(ctx SpecContext, []byte){{/}}, or {{bold}}func(ctx context.Context, []byte){{/}}"
+	return GinkgoError{
+		Heading: "Invalid Function",
+		Message: formatter.F(`[SynchronizedBeforeSuite] node must be passed `+mustGet+` for its second function.
+You passed {{bold}}%s{{/}} instead.`, t),
+		CodeLocation: cl,
+		DocLink:      "node-decorators-overview",
+	}
+}
+
 func (g ginkgoErrors) MultipleBodyFunctions(cl CodeLocation, nodeType NodeType) error {
 	return GinkgoError{
 		Heading:      "Multiple Functions",
-		Message:      formatter.F(`[%s] node must be passed a single {{bold}}func(){{/}} - but more than one was passed in.`, nodeType),
+		Message:      formatter.F(`[%s] node must be passed a single function - but more than one was passed in.`, nodeType),
 		CodeLocation: cl,
 		DocLink:      "node-decorators-overview",
 	}
@ -211,12 +246,30 @@ func (g ginkgoErrors) MultipleBodyFunctions(cl CodeLocation, nodeType NodeType)
 func (g ginkgoErrors) MissingBodyFunction(cl CodeLocation, nodeType NodeType) error {
 	return GinkgoError{
 		Heading:      "Missing Functions",
-		Message:      formatter.F(`[%s] node must be passed a single {{bold}}func(){{/}} - but none was passed in.`, nodeType),
+		Message:      formatter.F(`[%s] node must be passed a single function - but none was passed in.`, nodeType),
 		CodeLocation: cl,
 		DocLink:      "node-decorators-overview",
 	}
 }

+func (g ginkgoErrors) InvalidTimeoutOrGracePeriodForNonContextNode(cl CodeLocation, nodeType NodeType) error {
+	return GinkgoError{
+		Heading:      "Invalid NodeTimeout SpecTimeout, or GracePeriod",
+		Message:      formatter.F(`[%s] was passed NodeTimeout, SpecTimeout, or GracePeriod but does not have a callback that accepts a {{bold}}SpecContext{{/}} or {{bold}}context.Context{{/}}.  You must accept a context to enable timeouts and grace periods`, nodeType),
+		CodeLocation: cl,
+		DocLink:      "spec-timeouts-and-interruptible-nodes",
+	}
+}
+
+func (g ginkgoErrors) InvalidTimeoutOrGracePeriodForNonContextCleanupNode(cl CodeLocation) error {
+	return GinkgoError{
+		Heading:      "Invalid NodeTimeout SpecTimeout, or GracePeriod",
+		Message:      formatter.F(`[DeferCleanup] was passed NodeTimeout or GracePeriod but does not have a callback that accepts a {{bold}}SpecContext{{/}} or {{bold}}context.Context{{/}}.  You must accept a context to enable timeouts and grace periods`),
+		CodeLocation: cl,
+		DocLink:      "spec-timeouts-and-interruptible-nodes",
+	}
+}
+
 /* Ordered Container errors */
 func (g ginkgoErrors) InvalidSerialNodeInNonSerialOrderedContainer(cl CodeLocation, nodeType NodeType) error {
 	return GinkgoError{
@ -380,6 +433,15 @@ func (g ginkgoErrors) InvalidEntryDescription(cl CodeLocation) error {
 	}
 }

+func (g ginkgoErrors) MissingParametersForTableFunction(cl CodeLocation) error {
+	return GinkgoError{
+		Heading:      fmt.Sprintf("No parameters have been passed to the Table Function"),
+		Message:      fmt.Sprintf("The Table Function expected at least 1 parameter"),
+		CodeLocation: cl,
+		DocLink:      "table-specs",
+	}
+}
+
 func (g ginkgoErrors) IncorrectParameterTypeForTable(i int, name string, cl CodeLocation) error {
 	return GinkgoError{
 		Heading:      "DescribeTable passed incorrect parameter type",
@ -498,6 +560,13 @@ func (g ginkgoErrors) DryRunInParallelConfiguration() error {
 	}
 }

+func (g ginkgoErrors) GracePeriodCannotBeZero() error {
+	return GinkgoError{
+		Heading: "Ginkgo requires a positive --grace-period.",
+		Message: "Please set --grace-period to a positive duration.  The default is 30s.",
+	}
+}
+
 func (g ginkgoErrors) ConflictingVerbosityConfiguration() error {
 	return GinkgoError{
 		Heading: "Conflicting reporter verbosity settings.",
@ -532,3 +601,12 @@ func (g ginkgoErrors) BothRepeatAndUntilItFails() error {
 		Message: "--until-it-fails directs Ginkgo to rerun specs indefinitely until they fail.  --repeat directs Ginkgo to rerun specs a set number of times.  You can't set both... which would you like?",
 	}
 }
+
+/* Stack-Trace parsing errors */
+
+func (g ginkgoErrors) FailedToParseStackTrace(message string) error {
+	return GinkgoError{
+		Heading: "Failed to Parse Stack Trace",
+		Message: message,
+	}
+}
--- a/vendor/github.com/onsi/ginkgo/v2/types/report_entry.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/report_entry.go
@ -50,7 +50,6 @@ func (rev ReportEntryValue) MarshalJSON() ([]byte, error) {
 	}{
 		Representation: rev.String(),
 	}
-
 	asJSON, err := json.Marshal(rev.raw)
 	if err != nil {
 		return nil, err
@ -98,7 +97,7 @@ type ReportEntry struct {
 	Value ReportEntryValue
 }

-// ColorableStringer is an interface that ReportEntry values can satisfy.  If they do then ColorableStirng() is used to generate their representation.
+// ColorableStringer is an interface that ReportEntry values can satisfy.  If they do then ColorableString() is used to generate their representation.
 type ColorableStringer interface {
 	ColorableString() string
 }
@ -121,6 +120,8 @@ func (entry ReportEntry) GetRawValue() interface{} {
 	return entry.Value.GetRawValue()
 }

+
+
 type ReportEntries []ReportEntry

 func (re ReportEntries) HasVisibility(visibilities ...ReportEntryVisibility) bool {
--- a/vendor/github.com/onsi/ginkgo/v2/types/types.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/types.go
@ -165,6 +165,12 @@ type SpecReport struct {

 	// ReportEntries contains any reports added via `AddReportEntry`
 	ReportEntries ReportEntries
+
+	// ProgressReports contains any progress reports generated during this spec.  These can either be manually triggered, or automatically generated by Ginkgo via the PollProgressAfter() decorator
+	ProgressReports []ProgressReport
+
+	// AdditionalFailures contains any failures that occurred after the initial spec failure.  These typically occur in cleanup nodes after the initial failure and are only emitted when running in verbose mode.
+	AdditionalFailures []AdditionalFailure
 }

 func (report SpecReport) MarshalJSON() ([]byte, error) {
@ -184,9 +190,11 @@ func (report SpecReport) MarshalJSON() ([]byte, error) {
 		ParallelProcess             int
 		Failure                     *Failure `json:",omitempty"`
 		NumAttempts                 int
-		CapturedGinkgoWriterOutput  string        `json:",omitempty"`
-		CapturedStdOutErr           string        `json:",omitempty"`
-		ReportEntries               ReportEntries `json:",omitempty"`
+		CapturedGinkgoWriterOutput  string              `json:",omitempty"`
+		CapturedStdOutErr           string              `json:",omitempty"`
+		ReportEntries               ReportEntries       `json:",omitempty"`
+		ProgressReports             []ProgressReport    `json:",omitempty"`
+		AdditionalFailures          []AdditionalFailure `json:",omitempty"`
 	}{
 		ContainerHierarchyTexts:     report.ContainerHierarchyTexts,
 		ContainerHierarchyLocations: report.ContainerHierarchyLocations,
@ -213,6 +221,12 @@ func (report SpecReport) MarshalJSON() ([]byte, error) {
 	if len(report.ReportEntries) > 0 {
 		out.ReportEntries = report.ReportEntries
 	}
+	if len(report.ProgressReports) > 0 {
+		out.ProgressReports = report.ProgressReports
+	}
+	if len(report.AdditionalFailures) > 0 {
+		out.AdditionalFailures = report.AdditionalFailures
+	}

 	return json.Marshal(out)
 }
@ -379,7 +393,7 @@ type Failure struct {
 	// FailureNodeContext - one of three contexts describing the node in which the failure occurred:
 	// FailureNodeIsLeafNode means the failure occurred in the leaf node of the associated SpecReport. None of the other FailureNode fields will be populated
 	// FailureNodeAtTopLevel means the failure occurred in a non-leaf node that is defined at the top-level of the spec (i.e. not in a container). FailureNodeType and FailureNodeLocation will be populated.
-	// FailureNodeInContainer means the failure occurred in a non-leaf node that is defined within a container.  FailureNodeType, FailureNodeLocaiton, and FailureNodeContainerIndex will be populated.
+	// FailureNodeInContainer means the failure occurred in a non-leaf node that is defined within a container.  FailureNodeType, FailureNodeLocation, and FailureNodeContainerIndex will be populated.
 	//
 	// FailureNodeType will contain the NodeType of the node in which the failure occurred.
 	// FailureNodeLocation will contain the CodeLocation of the node in which the failure occurred.
@ -388,10 +402,13 @@ type Failure struct {
 	FailureNodeType           NodeType
 	FailureNodeLocation       CodeLocation
 	FailureNodeContainerIndex int
+
+	//ProgressReport is populated if the spec was interrupted or timed out
+	ProgressReport ProgressReport
 }

 func (f Failure) IsZero() bool {
-	return f == Failure{}
+	return f.Message == "" && (f.Location == CodeLocation{})
 }

 // FailureNodeContext captures the location context for the node containing the failing line of code
@ -424,6 +441,14 @@ func (fnc FailureNodeContext) MarshalJSON() ([]byte, error) {
 	return fncEnumSupport.MarshJSON(uint(fnc))
 }

+// AdditionalFailure capturs any additional failures that occur after the initial failure of a psec
+// these typically occur in clean up nodes after the spec has failed.
+// We can't simply use Failure as we want to track the SpecState to know what kind of failure this is
+type AdditionalFailure struct {
+	State   SpecState
+	Failure Failure
+}
+
 // SpecState captures the state of a spec
 // To determine if a given `state` represents a failure state, use `state.Is(SpecStateFailureStates)`
 type SpecState uint
@ -438,6 +463,7 @@ const (
 	SpecStateAborted
 	SpecStatePanicked
 	SpecStateInterrupted
+	SpecStateTimedout
 )

 var ssEnumSupport = NewEnumSupport(map[uint]string{
@ -449,6 +475,7 @@ var ssEnumSupport = NewEnumSupport(map[uint]string{
 	uint(SpecStateAborted):     "aborted",
 	uint(SpecStatePanicked):    "panicked",
 	uint(SpecStateInterrupted): "interrupted",
+	uint(SpecStateTimedout):    "timedout",
 })

 func (ss SpecState) String() string {
@ -463,12 +490,113 @@ func (ss SpecState) MarshalJSON() ([]byte, error) {
 	return ssEnumSupport.MarshJSON(uint(ss))
 }

-var SpecStateFailureStates = SpecStateFailed | SpecStateAborted | SpecStatePanicked | SpecStateInterrupted
+var SpecStateFailureStates = SpecStateFailed | SpecStateTimedout | SpecStateAborted | SpecStatePanicked | SpecStateInterrupted

 func (ss SpecState) Is(states SpecState) bool {
 	return ss&states != 0
 }

+// ProgressReport captures the progress of the current spec.  It is, effectively, a structured Ginkgo-aware stack trace
+type ProgressReport struct {
+	Message           string
+	ParallelProcess   int
+	RunningInParallel bool
+
+	Time time.Time
+
+	ContainerHierarchyTexts []string
+	LeafNodeText            string
+	LeafNodeLocation        CodeLocation
+	SpecStartTime           time.Time
+
+	CurrentNodeType      NodeType
+	CurrentNodeText      string
+	CurrentNodeLocation  CodeLocation
+	CurrentNodeStartTime time.Time
+
+	CurrentStepText      string
+	CurrentStepLocation  CodeLocation
+	CurrentStepStartTime time.Time
+
+	AdditionalReports []string
+
+	CapturedGinkgoWriterOutput string `json:",omitempty"`
+	GinkgoWriterOffset         int
+
+	Goroutines []Goroutine
+}
+
+func (pr ProgressReport) IsZero() bool {
+	return pr.CurrentNodeType == NodeTypeInvalid
+}
+
+func (pr ProgressReport) SpecGoroutine() Goroutine {
+	for _, goroutine := range pr.Goroutines {
+		if goroutine.IsSpecGoroutine {
+			return goroutine
+		}
+	}
+	return Goroutine{}
+}
+
+func (pr ProgressReport) HighlightedGoroutines() []Goroutine {
+	out := []Goroutine{}
+	for _, goroutine := range pr.Goroutines {
+		if goroutine.IsSpecGoroutine || !goroutine.HasHighlights() {
+			continue
+		}
+		out = append(out, goroutine)
+	}
+	return out
+}
+
+func (pr ProgressReport) OtherGoroutines() []Goroutine {
+	out := []Goroutine{}
+	for _, goroutine := range pr.Goroutines {
+		if goroutine.IsSpecGoroutine || goroutine.HasHighlights() {
+			continue
+		}
+		out = append(out, goroutine)
+	}
+	return out
+}
+
+func (pr ProgressReport) WithoutCapturedGinkgoWriterOutput() ProgressReport {
+	out := pr
+	out.CapturedGinkgoWriterOutput = ""
+	return out
+}
+
+type Goroutine struct {
+	ID              uint64
+	State           string
+	Stack           []FunctionCall
+	IsSpecGoroutine bool
+}
+
+func (g Goroutine) IsZero() bool {
+	return g.ID == 0
+}
+
+func (g Goroutine) HasHighlights() bool {
+	for _, fc := range g.Stack {
+		if fc.Highlight {
+			return true
+		}
+	}
+
+	return false
+}
+
+type FunctionCall struct {
+	Function        string
+	Filename        string
+	Line            int
+	Highlight       bool     `json:",omitempty"`
+	Source          []string `json:",omitempty"`
+	SourceHighlight int      `json:",omitempty"`
+}
+
 // NodeType captures the type of a given Ginkgo Node
 type NodeType uint

@ -503,6 +631,8 @@ const (

 var NodeTypesForContainerAndIt = NodeTypeContainer | NodeTypeIt
 var NodeTypesForSuiteLevelNodes = NodeTypeBeforeSuite | NodeTypeSynchronizedBeforeSuite | NodeTypeAfterSuite | NodeTypeSynchronizedAfterSuite | NodeTypeReportAfterSuite | NodeTypeCleanupAfterSuite
+var NodeTypesAllowedDuringCleanupInterrupt = NodeTypeAfterEach | NodeTypeJustAfterEach | NodeTypeAfterAll | NodeTypeAfterSuite | NodeTypeSynchronizedAfterSuite | NodeTypeCleanupAfterEach | NodeTypeCleanupAfterAll | NodeTypeCleanupAfterSuite
+var NodeTypesAllowedDuringReportInterrupt = NodeTypeReportBeforeEach | NodeTypeReportAfterEach | NodeTypeReportAfterSuite

 var ntEnumSupport = NewEnumSupport(map[uint]string{
 	uint(NodeTypeInvalid):                 "INVALID NODE TYPE",
@ -521,8 +651,8 @@ var ntEnumSupport = NewEnumSupport(map[uint]string{
 	uint(NodeTypeReportBeforeEach):        "ReportBeforeEach",
 	uint(NodeTypeReportAfterEach):         "ReportAfterEach",
 	uint(NodeTypeReportAfterSuite):        "ReportAfterSuite",
-	uint(NodeTypeCleanupInvalid):          "INVALID CLEANUP NODE",
-	uint(NodeTypeCleanupAfterEach):        "DeferCleanup",
+	uint(NodeTypeCleanupInvalid):          "DeferCleanup",
+	uint(NodeTypeCleanupAfterEach):        "DeferCleanup (Each)",
 	uint(NodeTypeCleanupAfterAll):         "DeferCleanup (All)",
 	uint(NodeTypeCleanupAfterSuite):       "DeferCleanup (Suite)",
 })
--- a/vendor/github.com/onsi/ginkgo/v2/types/version.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/version.go
@ -1,3 +1,3 @@
 package types

-const VERSION = "2.1.6"
+const VERSION = "2.3.1"