logger.debug("While recursing: " + e.getMessage(), e);
            result.addCircularDependencyException(e);
        } catch (OverConstrainedVersionException e) {
            logger.debug("While recursing: " + e.getMessage(), e);
            result.addVersionRangeViolation(e);
        } catch (ArtifactResolutionException e) {
            logger.debug("While recursing: " + e.getMessage(), e);

private
fun IntegrationTest.addDebugProperties() {
    if (project.daemonDebuggingIsEnabled) {
        systemProperties["org.gradle.integtest.debug"] = "true"
        testLogging.showStandardStreams = true
    }
    if (project.launcherDebuggingIsEnabled) {
        systemProperties["org.gradle.integtest.launcher.debug"] = "true"
        testLogging.showStandardStreams = true
    }
}

                    extensionPlugins.add(plugin);
                }
            }
        }

        if (extensionPlugins.isEmpty()) {
            if (logger.isDebugEnabled()) {
                logger.debug("Extension realms for project " + model.getId() + ": (none)");
            }

            return new ProjectRealmCache.CacheRecord(null, null);
        }

        List<ClassRealm> extensionRealms = new ArrayList<>();

                if (!shouldExecute) {
                    if (status.isHalted()) {
                        logger.debug("Skipping step {} because the build is halted", step);
                    } else if (status.isBlackListed(step.project)) {
                        logger.debug("Skipping step {} because the project is blacklisted", step);
                    } else if (TEARDOWN.equals(step.name)) {

  cancel-in-progress: false

env:
  # Set the DEVELOCITY_ACCESS_KEY so that a Build Scan is generated
  DEVELOCITY_ACCESS_KEY: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
  # Enable debug for the `gradle-build-action` cache operations
  GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true

permissions: {}

jobs:
  build:
    name: "Compile All"
    permissions:
      contents: read

```sh
podman run -it \
    --name opa \
    --publish 8181:8181 \
    docker.io/openpolicyagent/opa:0.40.0-rootless \
       run --server \
           --log-format=json-pretty \
           --log-level=debug \
           --set=decision_logs.console=true
```

### 2. Create a sample OPA Policy

In another terminal, create a policy that allows root user all access and for all other users denies `PutObject`:

```sh

        this.metadataReader = metadataReader;
    }

    @Override
    public PluginPrefixResult resolve(PluginPrefixRequest request) throws NoPluginFoundForPrefixException {
        logger.debug("Resolving plugin prefix {} from {}", request.getPrefix(), request.getPluginGroups());

        Model pom = request.getPom();
        Build build = pom != null ? pom.getBuild() : null;

		defer func() {
			if rec := recover(); rec == logger.ErrCritical { // handle
				stack := debug.Stack()
				logger.Error("critical: \"%s %s\": %v\n%s", r.Method, r.URL, rec, string(stack))
				writeErrorResponse(r.Context(), w, errorCodes.ToAPIErr(ErrInternalError), r.URL)
				return
			} else if rec != nil {
				stack := debug.Stack()
				logger.Error("panic: \"%s %s\": %v\n%s", r.Method, r.URL, rec, string(stack))

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package grid

import (
	"context"
	"errors"
	"fmt"
	"io"
	"net"
	"net/http"
	"runtime/debug"
	"strings"
	"time"

	"github.com/gobwas/ws"
	"github.com/gobwas/ws/wsutil"
	"github.com/google/uuid"
	"github.com/minio/madmin-go/v3"
	"github.com/minio/minio/internal/deadlineconn"

    /**
     * Furnish access to the standard Maven logging mechanism which is managed in this base class.
     *
     * @return a log4j-like logger object which allows plugins to create messages at levels of <code>"debug"</code>,
     * <code>"info"</code>, <code>"warn"</code>, and <code>"error"</code>.
     * @deprecated Use SLF4J directly
     */
    @Deprecated
    Log getLog();