@Inject
    public LoggerUsageTask(ExecOperations execOperations) {
        this.execOperations = execOperations;
        setDescription("Runs LoggerUsageCheck on output directories of all source sets");
    }

    @TaskAction
    public void runLoggerUsageTask() {
        LoggedExec.javaexec(execOperations, spec -> {
            spec.getMainClass().set("org.elasticsearch.test.loggerusage.ESLoggerUsageChecker");

  + Create minimal diffs - disable on save actions like reformat source code or organize imports.
    If you feel the source code should be reformatted, create a separate PR for this change.
  + Check for unnecessary whitespace with `git diff --check` before committing.
+ Make sure you have added the necessary tests (JUnit/[Core IT tests][core-it]) for your changes.

  fun delegate(): ResponseBody = delegate

  override fun contentType(): MediaType? = delegate.contentType()

  override fun contentLength(): Long = delegate.contentLength()

  override fun source(): BufferedSource = delegate.source()

  override fun toString(): String = javaClass.simpleName + "(" + delegate.toString() + ")"

  init {
    requireNotNull(delegate) { "delegate == null" }
    this.delegate = delegate
  }

        return new String(c);
    }

    /**
     * Converts a byte array to a hexadecimal string representation.
     *
     * @param src the source byte array to convert
     * @param srcIndex the starting index in the source array
     * @param size the number of bytes to convert from the source array
     * @return a hexadecimal string representation of the byte array
     */

          logger.log("<-- END HTTP (unreadable body)")
        } else {
          val source = responseBody.source()
          source.request(Long.MAX_VALUE) // Buffer the entire body.

          val totalMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs)

          var buffer = source.buffer

          var gzippedLength: Long? = null

```

### 4.1 Monitoring transition events

`s3:ObjectTransition:Complete` and `s3:ObjectTransition:Failed` events can be used to monitor transition events between the source cluster and transition tier. To watch lifecycle events, you can enable bucket notification on the source bucket with `mc event add`  and specify `--event ilm` flag.

Note that transition event notification is a MinIO extension.

## Explore Further

			"user":   user,
			"cmd":    s.Method,
			"param":  s.Filepath,
			"source": source,
		},
	}
}

func (m *sftpMetrics) log(s *sftp.Request, user string) func(sz int64, err error) {
	startTime := time.Now()
	source := getSource(2)
	return func(sz int64, err error) {
		globalTrace.Publish(sftpTrace(s, startTime, source, user, err, sz))
	}
}

      for (int j = 0; j < i; j++) {
        Map<Integer, @Nullable Integer> source = new TreeMap<>();
        for (int k = 0; k < i; k++) {
          source.put(k, k);
        }
        source.put(j, null);
        assertThrows(
            NullPointerException.class,
            () -> ImmutableSortedMap.copyOf((Map<Integer, Integer>) source));
      }
    }
  }

  public void testNullValuesInCopyOfEntries() {

  /**
   * Creates (but does not start) a new stopwatch using {@link System#nanoTime} as its time source.
   *
   * @since 15.0
   */
  public static Stopwatch createUnstarted() {
    return new Stopwatch();
  }

  /**
   * Creates (but does not start) a new stopwatch, using the specified time source.
   *
   * @since 15.0
   */
  public static Stopwatch createUnstarted(Ticker ticker) {

    deflatedBytes.writeInt(OCTETS_TO_ADD_BEFORE_INFLATION)

    val totalBytesToRead = inflater.bytesRead + deflatedBytes.size

    // We cannot read all, as the source does not close.
    // Instead, we ensure that all bytes from source have been processed by inflater.
    do {
      inflaterSource.readOrInflate(buffer, Long.MAX_VALUE)
    } while (inflater.bytesRead < totalBytesToRead && !inflater.finished())