.withProjectDir(file('plugin-build'))
            .forwardOutput()

        if (pluginPublishGradleVersion.startsWith("6")) {
            // Writing build operation traces is broken with Gradle 6.
            buildRunner.withoutBuildOperationTracing()
        }

        buildRunner.build()

        and: 'a build consuming it'
        settingsFile << """

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Trace stack table and acquisition.

package runtime

import (
	"internal/abi"
	"internal/goarch"
	"unsafe"
)

// traceTypeTable maps stack traces (arrays of PC's) to unique uint32 ids.
// It is lock-free for reading.
type traceTypeTable struct {
	tab traceMap
}

/**
 * This script is used to process a DEBUG log of gradle and
 * generates an output directory with the traces of merged
 * exclude rules and application of exclude rules during a
 * build.
 */
import groovy.json.JsonOutput
import groovy.json.JsonSlurper

File logFile = new File(args[0])
File processedDirectory = findProcessedDirectory()
File excludesDir = new File(processedDirectory, "exclusions")

John Howard <******@****.***> 1682564684 -0700

}

// List of some generic middlewares which are applied for all incoming requests.
var globalMiddlewares = []mux.MiddlewareFunc{
	// set x-amz-request-id header and others
	addCustomHeadersMiddleware,
	// The generic tracer needs to be the first middleware to catch all requests
	// returned early by any other middleware (but after the middleware that
	// sets the amz request id).
	httpTracerMiddleware,

        1 * userCodeContext.current() >> Mock(UserCodeApplicationContext.Application) {
            getSource() >> currentSource
        }
    }

    void assertIsCallerStackTrace(List<StackTraceElement> trace) {
        assert trace.any { it.className == DefaultProblemDiagnosticsFactoryTest.name }
    }

		}
	}

	// Acquire tracer for writing for the duration of this call.
	//
	// There's a lot of state manipulation performed with shortcuts
	// but we need to make sure the tracer can only observe the
	// start and end states to maintain a coherent model and avoid
	// emitting an event for every single transition.
	trace := traceAcquire()

	if locked {

		t.Run(name, func(t *testing.T) {
			if !d.IsDir() && !strings.HasPrefix(name, ".") && (strings.HasSuffix(name, ".src") || strings.HasSuffix(name, ".go2")) {
				mode := DeclarationErrors | AllErrors
				if *traceErrs {
					mode |= Trace
				}
				checkErrors(t, filepath.Join(testdata, name), nil, mode, true)
			}
		})
	}

// isn't granular enough to get useful information out of a trace in
// many cases.
//
// This makes absolute values of timestamp diffs smaller, and so they are
// encoded in fewer bytes.
//
// The target resolution in all cases is 64 nanoseconds.
// This is based on the fact that fundamentally the execution tracer won't emit
// events more frequently than roughly every 200 ns or so, because that's roughly

		ctx, span := tracing.Start(context.Background(), "Call Audit Events webhook",
			attribute.String("name", b.name),
			attribute.Int("event-count", len(list.Items)),
		)
		// Only log audit webhook traces that exceed a 25ms per object limit plus a 50ms
		// request overhead allowance. The high per object limit used here is primarily to
		// allow enough time for the serialization/deserialization of audit events, which