ch.qos.logback.core.spi.DeferredProcessingAware Java Examples

AbstractBufferedJedisWriter(JedisClient client,
        Function<DeferredProcessingAware, String> messageCreator,
        String redisKey,
        int maxBufferItems,
        long flushBufferIntervalMillis) {
    log = LoggerFactory.getLogger(getClass());

    this.messageCreator = messageCreator;
    this.client = client;
    this.redisKey = redisKey;
    this.maxBufferItems = maxBufferItems;
    this.flushBufferIntervalMillis = flushBufferIntervalMillis;
    shutdown = false;
    bufferedEvents = new LinkedBlockingQueue<>();
    lastFlushEpochMillis = new AtomicLong(System.currentTimeMillis());

    bufferFlusher = createThread(this::flushPeriodically, getClass().getSimpleName(), true);
    bufferFlusher.start();
}
 

@Test
public void published_messages_are_sent() throws InterruptedException {
    JedisClientProvider clientProvider = mock(JedisClientProvider.class);
    when(clientProvider.getJedisClient()).thenReturn(Optional.of(redisSender));
    final JedisClient jedisClient = new JedisClient(clientProvider, 1, 0L);

    try (BufferedJedisPublisher publisher = new BufferedJedisPublisher(jedisClient, MESSAGE_CREATOR, CHANNEL, 1, BUFFER_FLUSH_MILLIS)) {
        final CountDownLatch receiverStarted = new CountDownLatch(1);
        final CountDownLatch messagesReceived = new CountDownLatch(EVENTS.size());
        final ValueReceiver valueReceiver = new ValueReceiver(redisSubscriber, receiverStarted, messagesReceived);

        final Thread receiverThread = new Thread(valueReceiver);
        receiverThread.start();
        receiverStarted.await();

        final Set<String> sentMessages = new HashSet<>(EVENTS.size());
        for (DeferredProcessingAware event : EVENTS) {
            publisher.append(event);
            sentMessages.add(MESSAGE_CREATOR.apply(event));
        }
        messagesReceived.await(5 * BUFFER_FLUSH_MILLIS, TimeUnit.MILLISECONDS);
        valueReceiver.unsubscribe();

        assertThat(valueReceiver.receivedMessages, is(equalTo(sentMessages)));
    }
}
 

@Before
public void setup() {
    MockitoAnnotations.initMocks(this);
    when(messageCreator.apply(Matchers.any())).thenAnswer(invocation -> String.valueOf(invocation.getArgumentAt(0, DeferredProcessingAware.class)));
    final Optional<Pipeline> defaultPipeline = Optional.of(pipeline);
    when(client.getPipeline()).thenReturn(defaultPipeline);

    writer = new BufferedJedisRPusher(client, messageCreator, KEY, DEFAULT_QUEUE_ITEMS, DEFAULT_BATCH_WAIT_MILLIS);
}
 

@Test
public void dont_send_on_too_many_failures() throws InterruptedException {
    when(pipeline.publish(anyString(), anyString())).thenThrow(new JedisConnectionException(""));
    for (int i = 0; i < DEFAULT_BUFFER_ITEMS; i++) {
        writer.append(mock(DeferredProcessingAware.class));
    }
    verify(client, times(2)).getPipeline();
    verify(client, times(2)).reconnect();
    verify(pipeline, times(2)).publish(anyString(), anyString());
    verify(pipeline, times(0)).sync();
}
 

@Test
public void send_on_second_try_due_to_exception_on_first_publish() throws InterruptedException {
    when(pipeline.publish(anyString(), anyString())).thenThrow(new JedisConnectionException("")).thenReturn(null);
    for (int i = 0; i < DEFAULT_BUFFER_ITEMS; i++) {
        writer.append(mock(DeferredProcessingAware.class));
    }
    final int expectedPublishCalls = 1 + DEFAULT_BUFFER_ITEMS; // one failed, then for each buffer item
    verify(client, times(2)).getPipeline();
    verify(client).reconnect();
    verify(pipeline, times(expectedPublishCalls)).publish(anyString(), anyString());
    verify(pipeline, times(1)).sync();
}
 

@Test
public void send_on_second_try_due_to_no_pipline_on_first_try() throws InterruptedException {
    when(client.getPipeline()).thenReturn(Optional.empty()).thenReturn(Optional.of(pipeline));
    for (int i = 0; i < DEFAULT_BUFFER_ITEMS; i++) {
        writer.append(mock(DeferredProcessingAware.class));
    }
    verify(client, times(2)).getPipeline();
    verify(client).reconnect();
    verify(pipeline, times(DEFAULT_BUFFER_ITEMS)).publish(anyString(), anyString());
    verify(pipeline, times(1)).sync();
}
 

@Test
public void send_on_full_queue() throws InterruptedException {
    int batchFullEvents = 5;
    for (int i = 0; i < DEFAULT_BUFFER_ITEMS * batchFullEvents; i++) {
        writer.append(mock(DeferredProcessingAware.class));
    }
    final int expectedPublishCalls = DEFAULT_BUFFER_ITEMS * batchFullEvents; // one per item
    verify(pipeline, times(expectedPublishCalls)).publish(anyString(), anyString());
    verify(pipeline, times(batchFullEvents)).sync();
}
 

@Before
public void setup() {
    MockitoAnnotations.initMocks(this);
    when(messageCreator.apply(Matchers.any())).thenAnswer(invocation -> String.valueOf(invocation.getArgumentAt(0, DeferredProcessingAware.class)));
    final Optional<Pipeline> defaultPipeline = Optional.of(pipeline);
    when(client.getPipeline()).thenReturn(defaultPipeline);

    writer = new BufferedJedisPublisher(client, messageCreator, KEY, DEFAULT_BUFFER_ITEMS, DEFAULT_BATCH_WAIT_MILLIS);
}
 

@Test
public void dont_send_on_too_many_failures() throws InterruptedException {
    when(pipeline.rpush(anyString(), anyVararg())).thenThrow(new JedisConnectionException(""));
    for (int i = 0; i < DEFAULT_QUEUE_ITEMS; i++) {
        writer.append(mock(DeferredProcessingAware.class));
    }
    verify(client, times(2)).getPipeline();
    verify(client, times(2)).reconnect();
    verify(pipeline, times(2)).rpush(anyString(), anyVararg());
    verify(pipeline, times(0)).sync();
}
 

@Test
public void send_on_second_try_due_to_exception_on_first_rpush() throws InterruptedException {
    when(pipeline.rpush(anyString(), anyVararg())).thenThrow(new JedisConnectionException("")).thenReturn(null);
    for (int i = 0; i < DEFAULT_QUEUE_ITEMS; i++) {
        writer.append(mock(DeferredProcessingAware.class));
    }
    verify(client, times(2)).getPipeline();
    verify(client).reconnect();
    verify(pipeline, times(2)).rpush(anyString(), anyVararg());
    verify(pipeline, times(1)).sync();
}
 

@Test
public void send_on_second_try_due_to_no_pipline_on_first_try() throws InterruptedException {
    when(client.getPipeline()).thenReturn(Optional.empty()).thenReturn(Optional.of(pipeline));
    for (int i = 0; i < DEFAULT_QUEUE_ITEMS; i++) {
        writer.append(mock(DeferredProcessingAware.class));
    }
    verify(client, times(2)).getPipeline();
    verify(client).reconnect();
    verify(pipeline, times(1)).rpush(anyString(), anyVararg());
    verify(pipeline, times(1)).sync();
}
 

@Test
public void send_on_full_queue() throws InterruptedException {
    int batchFullEvents = 5;
    for (int i = 0; i < DEFAULT_QUEUE_ITEMS * batchFullEvents; i++) {
        writer.append(mock(DeferredProcessingAware.class));
    }
    verify(pipeline, times(batchFullEvents)).rpush(anyString(), anyVararg());
    verify(pipeline, times(batchFullEvents)).sync();
}
 

@Override
public void writeTo(JsonGenerator generator, DeferredProcessingAware deferredProcessingAware) throws IOException {
    generator.writeFieldName("service");
    generator.writeString(serviceName);
    generator.writeFieldName("service-version");
    generator.writeString(serviceVersion);
    generator.writeFieldName("service-id");
    generator.writeString(serviceInstanceId);
}
 

BufferedJedisPublisher(JedisClient client,
        Function<DeferredProcessingAware, String> messageCreator,
        String redisKey,
        int maxBufferItems,
        long flushBufferIntervalMillis) {
    super(client, messageCreator, redisKey, maxBufferItems, flushBufferIntervalMillis);
}
 

BufferedJedisRPusher(JedisClient client,
        Function<DeferredProcessingAware, String> messageCreator,
        String redisKey,
        int maxBufferItems,
        long flushBufferIntervalMillis) {
    super(client, messageCreator, redisKey, maxBufferItems, flushBufferIntervalMillis);
}
 

@SuppressWarnings("squid:S2095") // rule=resource should be closed: JedisClient is closed when writer is shut down
public AbstractBufferedJedisWriter createJedisWriter(JedisWriterConfiguration writerConfiguration) {
    final RedisConnectionConfig connectionConfig = writerConfiguration.getConnectionConfig();
    final Method method = connectionConfig.getMethod();
    if (method == null) {
        throw getUnsupportedWriterTypeException(null);
    }
    final Encoder<DeferredProcessingAware> encoder = writerConfiguration.getEncoder();
    final Function<DeferredProcessingAware, String> messageCreator = event -> new String(encoder.encode(event), StandardCharsets.UTF_8);

    final JedisClientProvider clientProvider = new JedisClientProvider(jedisPoolFactory, writerConfiguration.getConnectionConfig());
    final JedisClient client = new JedisClient(clientProvider,
            writerConfiguration.getMaxInitializeTries(),
            writerConfiguration.getRetryInitializeIntervalMillis());

    switch (method) {
        case RPUSH:
            return new BufferedJedisRPusher(client,
                    messageCreator,
                    connectionConfig.getKey(),
                    writerConfiguration.getMaxBufferedMessages(),
                    writerConfiguration.getFlushBufferIntervalMillis());
        case PUBLISH:
            return new BufferedJedisPublisher(client,
                    messageCreator,
                    connectionConfig.getKey(),
                    writerConfiguration.getMaxBufferedMessages(),
                    writerConfiguration.getFlushBufferIntervalMillis());
        default:
            throw getUnsupportedWriterTypeException(method.name());
    }
}
 

private void flushBuffer() {
    try {
        final List<DeferredProcessingAware> toPush = new ArrayList<>(bufferedEvents.size());
        bufferedEvents.drainTo(toPush);
        final String[] values = toPush.stream().map(messageCreator).toArray(String[]::new);
        for (int i = 1; i <= SEND_EVENT_TRIES; i++) {
            if (sendValuesToRedis(values)) {
                return;
            }
        }
        log.warn("unable to send events to redis: {}", Arrays.asList(values));
    } finally {
        lastFlushEpochMillis.set(System.currentTimeMillis());
    }
}
 

public void append(DeferredProcessingAware event) {
    if (event != null && !bufferedEvents.offer(event)) {
        final String encodedEvent = messageCreator.apply(event);
        log.warn("unable to add event {} to buffer", encodedEvent);
    }
    if (maxBatchSizeReached() || maxBatchWaitTimeReached()) {
        flushBuffer();
    }
}
 

public void setEncoder(Encoder<DeferredProcessingAware> encoder) {
    this.encoder = encoder;
}
 

@Override
protected void append(DeferredProcessingAware event) {
    writer.append(event);
}
 

private <T extends DeferredProcessingAware> AbstractFieldJsonProvider<T> withName(String name,
                                                                                  AbstractFieldJsonProvider<T> provider) {
    provider.setFieldName(name);
    return provider;
}