an internal rewrite of our event code to fix problems where events were lost or unbalanced.

 *  Fix: Don't leak a connection when a call is canceled immediately preceding the `onFailure()`
    callback.

 *  Fix: Apply call timeouts when connecting duplex calls, web sockets, and server-sent events.
    Once the streams are established no further timeout is enforced.

    bus.register(catcher);

    // We post the event, but our Executor will not deliver it until instructed.
    bus.post(EVENT);

    List<String> events = catcher.getEvents();
    assertTrue("No events should be delivered synchronously.", events.isEmpty());

    // Now we find the task in our Executor and explicitly activate it.
    List<Runnable> tasks = executor.getTasks();

          maxSize = 50L * 1024L * 1024L // 50 MiB
      ))
      .build()
```

## EventListener events

Cache Events are exposed via the EventListener API.  Typical scenarios are below.

### Cache Hit

In the ideal scenario the cache can fulfill the request without any conditional call to the network.
This will skip the normal events such as DNS, connecting to the network, and downloading the response body.

MinIO supports persistent event store. The persistent store will backup events if MySQL connection goes offline and then replays the stored events when the broken connection comes back up. The event store can be configured by setting a directory path in `queue_dir` field, and the maximum number of events, which can be stored in a `queue_dir`, in `queue_limit` field. For example, `queue_dir` can be set to `/home/events` and `queue_limit` can be set to `1000`. By default, the `queue_limit` is set...

        List<LogNotificationEvent> events = new ArrayList<>();
        events.add(new LogNotificationEvent(base, "ERROR", "org.test.A", "first", null));
        events.add(new LogNotificationEvent(base + 1000, "WARN", "org.test.B", "second", null));
        events.add(new LogNotificationEvent(base + 2000, "ERROR", "org.test.C", "third", null));

        String details = testableJob.testFormatDetails(events);

        final List<LogNotificationEvent> events = ComponentUtil.getLogNotificationHelper().drainAll();
        assertEquals(1, events.size());
        assertEquals("ERROR", events.get(0).getLevel());
        assertEquals("org.codelibs.fess.test", events.get(0).getLoggerName());
        assertEquals("test error message", events.get(0).getMessage());
        assertNull(events.get(0).getThrowable());
    }

    @Test

 * #enqueue enqueueing} and then {@linkplain #dispatch dispatching} events.
 *
 * <p>The API of this class is designed to make it easy to achieve the following properties
 *
 * <ul>
 *   <li>Multiple events for the same listener are never dispatched concurrently.
 *   <li>Events for the different listeners are dispatched concurrently.
 *   <li>All events for a given listener dispatch on the provided executor.

        assertEquals(1, events.size());
        assertEquals("start:intent:Analyzing...", events.get(0));

        // Test onPhaseComplete
        callback.onPhaseComplete(ChatPhaseCallback.PHASE_INTENT);
        assertEquals(2, events.size());
        assertEquals("complete:intent", events.get(1));

        // Test onChunk
        callback.onChunk("test content", false);
        assertEquals(3, events.size());

import java.util.concurrent.ConcurrentLinkedQueue;

/**
 * Handler for dispatching events to subscribers, providing different event ordering guarantees that
 * make sense for different situations.
 *
 * <p><b>Note:</b> The dispatcher is orthogonal to the subscriber's {@code Executor}. The dispatcher
 * controls the order in which events are dispatched, while the executor controls how (i.e. on which

						// This is a MinIO only extension.
						event.Action = DeleteAllVersionsAction
					}
					events = append(events, event)
				}
			}

			if obj.TransitionStatus != TransitionComplete {
				if due, ok := rule.Transition.NextDue(obj); ok && (now.IsZero() || now.After(due)) {
					events = append(events, Event{
						Action:       TransitionAction,
						RuleID:       rule.ID,
						Due:          due,