return err
			}

			_, err = conn.Do("HSET", target.args.Key, key, data)
		}
		if err != nil {
			return err
		}
	}

	if target.args.Format == event.AccessFormat {
		data, err := json.Marshal([]RedisAccessEvent{{Event: []event.Event{eventData}, EventTime: eventData.EventTime}})
		if err != nil {
			return err
		}

    this.executor = bus.executor();
  }

  /** Dispatches {@code event} to this subscriber using the proper executor. */
  final void dispatchEvent(Object event) {
    executor.execute(
        () -> {
          try {
            invokeSubscriberMethod(event);
          } catch (InvocationTargetException e) {
            bus.handleSubscriberException(e.getCause(), context(event));
          }
        });
  }

  /**

	dataCase1 := []byte(`
<QueueConfiguration>
   <Id>1</Id>
   <Filter></Filter>
   <Queue>arn:minio:sqs:us-east-1:1:webhook</Queue>
   <Event>s3:ObjectAccessed:*</Event>
   <Event>s3:ObjectCreated:*</Event>
   <Event>s3:ObjectRemoved:*</Event>
</QueueConfiguration>`)

	dataCase2 := []byte(`
<QueueConfiguration>
   <Id>1</Id>
    <Filter>
        <S3Key>
            <FilterRule>

                    listener.sessionEnded(event);
                    break;

                case ProjectSkipped:
                    listener.projectSkipped(event);
                    break;
                case ProjectStarted:
                    listener.projectStarted(event);
                    break;
                case ProjectSucceeded:
                    listener.projectSucceeded(event);
                    break;

  @AfterEach
  fun after() {
    listener.assertExhausted()
  }

  @Test
  fun event() {
    server.enqueue(
      MockResponse
        .Builder()
        .body(
          """
          |data: hey
          |
          |
          """.trimMargin(),
        ).setHeader("content-type", "text/event-stream")
        .build(),
    )
    val source = newEventSource()

            logNotificationTarget.flush();
        }
    }

    /**
     * Offers an event to the buffer. If the buffer exceeds the maximum size, the oldest event is dropped.
     *
     * @param event the log notification event to add
     */
    public void offer(final LogNotificationEvent event) {
        int maxBufferSize;
        try {

        // 11
        "id\r".encodeUtf8(),
        // 12
        "id\n".encodeUtf8(),
        // 13
        "event: ".encodeUtf8(),
        // 14
        "event:".encodeUtf8(),
        // 15
        "event\r\n".encodeUtf8(),
        // 16
        "event\r".encodeUtf8(),
        // 17
        "event\n".encodeUtf8(),
        // 18
        "retry: ".encodeUtf8(),
        // 19
        "retry:".encodeUtf8(),

        appender.append(event);

        final List<LogNotificationEvent> events = ComponentUtil.getLogNotificationHelper().drainAll();
        assertEquals(0, events.size());
    }

    @Test
    public void test_append_excludedLogger_logNotificationJob() {

  ) : ConnectionEvent() {
    override fun closes(event: ConnectionEvent): Boolean = event is ConnectStart && call == event.call && route == event.route
  }

  data class ConnectEnd(
    override val timestampNs: Long,
    override val connection: Connection,
    val route: Route,
    val call: Call,
  ) : ConnectionEvent() {

    for item in items:
        yield {"name": item.name, "description": item.description}


@app.get("/items/stream-sse-event", response_class=EventSourceResponse)
async def sse_items_event():
    yield ServerSentEvent(data="hello", event="greeting", id="1")
    yield ServerSentEvent(data={"key": "value"}, event="json-data", id="2")
    yield ServerSentEvent(comment="just a comment")
    yield ServerSentEvent(data="retry-test", retry=5000)