#30 Log viewer: newest entries are not displayed for max result size < size.

Kai Reinhard

11.05.2019 725b302f0272875f961b132e9c963378c11e8365

#30 Log viewer: newest entries are not displayed for max result size < size.

 borgbutler-server/src/main/java/de/micromata/borgbutler/server/logging/FiFoBuffer.java

New file
@@ -0,0 +1,38 @@
package de.micromata.borgbutler.server.logging;

import java.util.ArrayList;
import java.util.Iterator;

public class FiFoBuffer<T> {
    private ArrayList<T> list;
    private int maxSize;

    public FiFoBuffer(int maxSize) {
        this.maxSize = maxSize;
        list = new ArrayList<>(maxSize);
    }

    public void add(T element) {
        synchronized (list) {
            if (list.size() >= maxSize) {
                Iterator<T> it = list.iterator();
                it.next();
                it.remove();
            }
            list.add(element);
        }
    }

    public T get(int index) {
        synchronized (list) {
            if (index <= 0 || index >= list.size()) {
                return null;
            }
            return list.get(index);
        }
    }

    public int getSize() {
        return list.size();
    }
}

 borgbutler-server/src/main/java/de/micromata/borgbutler/server/logging/Log4jMemoryAppender.java

@@ -1,6 +1,5 @@
package de.micromata.borgbutler.server.logging;

import org.apache.commons.collections4.queue.CircularFifoQueue;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.spi.LoggingEvent;
@@ -34,7 +33,7 @@

    }

    CircularFifoQueue<LoggingEventData> queue = new CircularFifoQueue<>(QUEUE_SIZE);
    FiFoBuffer<LoggingEventData> queue = new FiFoBuffer<>(QUEUE_SIZE);

    @Override
    protected void append(LoggingEvent event) {
@@ -63,51 +62,64 @@
        }
        int counter = 0;
        //I18n i18n = CoreI18n.getDefault().get(locale);
        for (LoggingEventData event : queue) {
            if (!event.getLevel().matches(filter.getThreshold())) {
                continue;
        if (filter.isAscendingOrder()) {
            for (int i = 0; i < queue.getSize(); i++) {
                LoggingEventData resultEvent = getResultEvent(filter, queue.get(i), locale);
                if (resultEvent == null) continue;
                result.add(resultEvent);
                if (++counter > maxSize) break;
            }
            if (filter.getLastReceivedLogOrderNumber() != null) {
                if (event.getOrderNumber() <= filter.getLastReceivedLogOrderNumber()) {
                    continue;
                }
        } else {
            for (int i = queue.getSize(); i >= 0; i--) {
                LoggingEventData resultEvent = getResultEvent(filter, queue.get(i), locale);
                if (resultEvent == null) continue;
                result.add(resultEvent);
                if (++counter > maxSize) break;
            }
            String logString = null;
            String message = event.getMessage();
            boolean localizedMessage = false;
        }
        return result;
    }

    private LoggingEventData getResultEvent(LogFilter filter, LoggingEventData event, Locale locale) {
        if (event == null) {
            return null;
        }
        if (!event.getLevel().matches(filter.getThreshold())) {
            return null;
        }
        if (filter.getLastReceivedLogOrderNumber() != null) {
            if (event.getOrderNumber() <= filter.getLastReceivedLogOrderNumber()) {
                return null;
            }
        }
        String logString = null;
        String message = event.getMessage();
        boolean localizedMessage = false;
            /*if (message != null && message.startsWith("i18n=")) {
                I18nLogEntry i18nLogEntry = I18nLogEntry.parse(message);
                message = i18n.formatMessage(i18nLogEntry.getI18nKey(), (Object[])i18nLogEntry.getArgs());
                localizedMessage = true;
            }*/

            if (StringUtils.isNotBlank(filter.getSearch())) {
                StringBuilder sb = new StringBuilder();
                sb.append(event.getLogDate());
                append(sb, event.getLevel(), true);
                append(sb, message, true);
                append(sb, event.getJavaClass(), true);
                append(sb, event.getStackTrace(), filter.isShowStackTraces());
                logString = sb.toString();
            }
            if (logString == null || matches(logString, filter.getSearch())) {
                LoggingEventData resultEvent = event;
                if (localizedMessage) {
                    // Need a clone
                    resultEvent = event.clone();
                    resultEvent.setMessage(message);
                }
                if (filter.isAscendingOrder()) {
                    result.add(resultEvent);
                } else {
                    result.add(0, resultEvent);
                }
                if (counter++ > maxSize) {
                    break;
                }
            }
        if (StringUtils.isNotBlank(filter.getSearch())) {
            StringBuilder sb = new StringBuilder();
            sb.append(event.getLogDate());
            append(sb, event.getLevel(), true);
            append(sb, message, true);
            append(sb, event.getJavaClass(), true);
            append(sb, event.getStackTrace(), filter.isShowStackTraces());
            logString = sb.toString();
        }
        return result;
        if (logString == null || matches(logString, filter.getSearch())) {
            LoggingEventData resultEvent = event;
            if (localizedMessage) {
                // Need a clone
                resultEvent = event.clone();
                resultEvent.setMessage(message);
            }
            return resultEvent;
        }
        return null;
    }

    private void append(StringBuilder sb, Object value, boolean append) {

 borgbutler-server/src/test/java/de/micromata/borgbutler/server/logging/FiFoBufferTest.java

New file
@@ -0,0 +1,67 @@
package de.micromata.borgbutler.server.logging;

import org.junit.Assert;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;

public class FiFoBufferTest {
    private FiFoBuffer<Long> fiFoBuffer;
    private Long counter = 0L;
    private ArrayList<Thread> threads = new ArrayList<>();

    @Test
    void test() {
        fiFoBuffer = new FiFoBuffer<>(1000);
        for (int i = 0; i < 10; i++) {
            startProducerThread();
            startConsumerThread(i % 2 == 0);
        }
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException ex) {

            }
        }
        Assert.assertEquals(100000, counter.longValue());
    }

    private void startProducerThread() {
        Thread thread = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    long value;
                    synchronized (threads) {
                        value = ++counter;
                    }
                    fiFoBuffer.add(value);
                }
            }
        };
        thread.start();
        threads.add(thread);
    }

    private void startConsumerThread(boolean ascending) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    if (ascending) {
                        for (int j = 0; j < fiFoBuffer.getSize(); j++) {
                            fiFoBuffer.get(j);
                        }
                    } else {
                        for (int j = fiFoBuffer.getSize(); j >= 0; j--) {
                            fiFoBuffer.get(j);
                        }
                    }
                }
            }
        };
        thread.start();
        threads.add(thread);
    }
}