*/
    long deadline = System.nanoTime() + unit.toNanos(timeout);
    int added = 0;
    while (added < numElements) {
      // we could rely solely on #poll, but #drainTo might be more efficient when there are multiple
      // elements already available (e.g. LinkedBlockingQueue#drainTo locks only once)
      added += q.drainTo(buffer, numElements - added);

     */
    long deadline = System.nanoTime() + unit.toNanos(timeout);
    int added = 0;
    while (added < numElements) {
      // we could rely solely on #poll, but #drainTo might be more efficient when there are multiple
      // elements already available (e.g. LinkedBlockingQueue#drainTo locks only once)
      added += q.drainTo(buffer, numElements - added);

 * is not guaranteed to traverse the elements of the MonitorBasedPriorityBlockingQueue in
 * any particular order. If you need ordered traversal, consider using {@code
 * Arrays.sort(pq.toArray())}. Also, method {@code drainTo} can be used to remove some or
 * all elements in priority order and place them in another collection.
 *
 * <p>Operations on this class make no guarantees about the ordering of elements with equal

   * @throws ClassCastException {@inheritDoc}
   * @throws NullPointerException {@inheritDoc}
   * @throws IllegalArgumentException {@inheritDoc}
   */
  @CanIgnoreReturnValue
  @Override
  public int drainTo(Collection<? super E> c) {
    checkNotNull(c);
    checkArgument(c != this);
    E[] items = this.items;
    Monitor monitor = this.monitor;
    monitor.enter();
    try {
      int i = takeIndex;

   * @throws ClassCastException {@inheritDoc}
   * @throws NullPointerException {@inheritDoc}
   * @throws IllegalArgumentException {@inheritDoc}
   */
  @CanIgnoreReturnValue
  @Override
  public int drainTo(Collection<? super E> c) {
    checkNotNull(c);
    checkArgument(c != this);
    E[] items = this.items;
    Monitor monitor = this.monitor;
    monitor.enter();
    try {
      int i = takeIndex;

                        // Periodically drain
                        if (i % 50 == 49) {
                            List<LogNotificationEvent> drained = helper.drainAll();
                            totalDrained.addAndGet(drained.size());
                        }
                    }
                } catch (InterruptedException e) {

                .offer(new LogNotificationEvent(System.currentTimeMillis(), "WARN", "org.test", "msg2", null));

        // expired() will drain buffer then fail on OpenSearch (not available) but should not throw
        logNotificationTarget.expired();

        // Buffer should be empty after expired() drained it
        List<LogNotificationEvent> remaining = ComponentUtil.getLogNotificationHelper().drainAll();
        assertEquals(0, remaining.size());

HTTP/1 [Response.Body] now automatically drains any unread content upon being
closed, up to a conservative limit, to allow better connection reuse. For most
programs, this change should be a no-op, or result in a performance improvement.
In rare cases, programs that do not benefit from connection reuse might
experience performance degradation if they had been improperly allowing an
excessive amount of idle connections to linger; usually by setting

        queue.offer(event);
        if (size.incrementAndGet() > maxBufferSize) {
            if (queue.poll() != null) {
                size.decrementAndGet();
            }
        }
    }

    /**
     * Drains all events from the buffer and returns them as a list.
     *
     * @return a list of all buffered events
     */
    public List<LogNotificationEvent> drainAll() {

     * list's ordering. It is drained as a batch operation when either the DRAIN_THRESHOLD is
     * crossed or a write occurs on the segment.
     */
    final Queue<ReferenceEntry<K, V>> recencyQueue;

    /**
     * A counter of the number of reads since the last write, used to drain queues on a small
     * fraction of read operations.
     */