}

	defaultZapLogger := zap.New(defaultLogger, opts...)

	// capture global zap logging and force it through our logger
	_ = zap.ReplaceGlobals(defaultZapLogger)

	// capture standard golang "log" package output and force it through our logger
	_ = zap.RedirectStdLog(defaultZapLogger)

	// capture gRPC logging
	if options.logGRPC {

		&metrics.CounterOpts{
			Subsystem:      subsystem,
			Name:           "rerouted_request_total",
			Help:           "Total number of requests that were proxied to a peer kube apiserver because the local apiserver was not capable of serving it",
			StabilityLevel: metrics.ALPHA,
		},
		[]string{statuscode},
	)
)

func Register() {
	registerMetricsOnce.Do(func() {
		legacyregistry.MustRegister(peerProxiedRequestsTotal)
	})
}

 * </ol>
 *
 * <h3>Starting a pipeline</h3>
 *
 * Start a {@code ClosingFuture} pipeline {@linkplain #submit(ClosingCallable, Executor) from a
 * callable block} that may capture objects for later closing. To start a pipeline from a {@link
 * ListenableFuture} that doesn't create resources that should be closed later, you can use {@link
 * #from(ListenableFuture)} instead.
 *
 * <h3>Derived steps</h3>

            .flatMap(history -> history.load(identity.getUniqueId()))
            .orElse(null);
        R result = delegate.execute(work, new PreviousExecutionContext(context, previousExecutionState));

        // If we did not capture any outputs after execution, remove them from history
        context.getHistory()
            .ifPresent(history -> {
                if (!result.getAfterExecutionOutputState().isPresent()) {

    def userQuestions = Mock(UserQuestions)
    @Subject def buildScanUserInputHandler = new DefaultBuildScanUserInputHandler(userInputHandler)

    def "can ask yes/no question and capture user input '#input'"() {
        given:
        def question = 'Accept license?'

        when:
        def answer = buildScanUserInputHandler.askYesNoQuestion(question)

        then:

class linked_ptr {
 public:
  typedef T element_type;

  // Take over ownership of a raw pointer.  This should happen as soon as
  // possible after the object is created.
  explicit linked_ptr(T* ptr = NULL) { capture(ptr); }
  ~linked_ptr() { depart(); }

  // Copy an existing linked_ptr<>, adding ourselves to the list of references.
  template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); }

        fails 'test'

        then:
        outputContains "Issue1618Test > thisTestShouldBeMarkedAsFailed FAILED"
    }

    @Issue("https://github.com/gradle/gradle/issues/9487")
    def "best effort to capture multi-cause exceptions"() {
        given:
        buildFile << """
            apply plugin: 'java-library'

            ${mavenCentralRepository()}

            dependencies {

            layout.buildDirectory.set(
                layout.projectDirectory.dir(
                    service.map {
                        // intentionally capture the `project` object to force a cc failure
                        // in case this gets serialized
                        it.buildDirFor(project)
                    }
                )
            )
        """

        this.embedded = embedded;
    }

    @Override
    public void verify() {
        if (!supportsVersion() && embedded) {
            throw new UnsupportedFeatureException("capture build output in debug mode with the GradleRunner", targetGradleVersion, TestKitFeature.CAPTURE_BUILD_RESULT_OUTPUT_IN_DEBUG.getSince());
        } else {

            "# Decides between a single digit + spacing (e.g. '8 '), or two digits (e.g. 17)\n" +
            "# This is the value being replaced.\n" +
            "(?:\\d\\s|\\d{2})" +
            "# Capture the tail end of the table\n" +
            "(\\s+\\|)",
            // Replace the value with 11 for consistent testing
            "\$111\$2"
        )