From 766b7f33e2ea7eb7b3bb37724ee609d1b882ce57 Mon Sep 17 00:00:00 2001 From: Rain Ramm Date: Tue, 21 May 2024 11:05:56 +0300 Subject: [PATCH 01/10] Add SilencedGelfTcpAppender to silence GELF connection issues --- Dockerfile | 8 --- README.md | 2 +- build.gradle | 5 +- .../core/logging/SilencedGelfTcpAppender.java | 34 +++++++++ .../logging/SilencedGelfTcpAppenderTest.java | 69 +++++++++++++++++++ 5 files changed, 108 insertions(+), 10 deletions(-) delete mode 100644 Dockerfile create mode 100644 src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java create mode 100644 src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java diff --git a/Dockerfile b/Dockerfile deleted file mode 100644 index 2558e2f..0000000 --- a/Dockerfile +++ /dev/null @@ -1,8 +0,0 @@ -FROM gradle:7.3-jdk11 - -WORKDIR /app -COPY . /app - -RUN gradle build -x test - -CMD ["gradle", "build"] diff --git a/README.md b/README.md index 51fe2ca..75cb050 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,7 @@ Library providing basic generic functionality required by any HTTP web service. ``` // https://mvnrepository.com/artifact/ee.bitweb/spring-core -implementation group: 'ee.bitweb', name: 'spring-core', version: '3.1.0' +implementation group: 'ee.bitweb', name: 'spring-core', version: '3.2.0' ``` Review available versions in [Maven Central](https://mvnrepository.com/artifact/ee.bitweb/spring-core). diff --git a/build.gradle b/build.gradle index e40366b..28556a0 100644 --- a/build.gradle +++ b/build.gradle @@ -19,7 +19,7 @@ plugins { } group 'ee.bitweb' -version '3.1.0' +version '3.2.0' java { sourceCompatibility = '17' } @@ -79,6 +79,9 @@ dependencies { // https://mvnrepository.com/artifact/com.squareup.okhttp3/logging-interceptor compileOnly group: 'com.squareup.okhttp3', name: 'logging-interceptor', version: '4.12.0' + // https://mvnrepository.com/artifact/de.siegmar/logback-gelf + compileOnly group: 'de.siegmar', name: 'logback-gelf', version: '6.0.1' + // https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web testImplementation group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: "${springBootVersion}" diff --git a/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java b/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java new file mode 100644 index 0000000..d79b99e --- /dev/null +++ b/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java @@ -0,0 +1,34 @@ +package ee.bitweb.core.logging; + +import ch.qos.logback.classic.spi.ILoggingEvent; +import de.siegmar.logbackgelf.GelfTcpAppender; +import ee.bitweb.core.exception.CoreException; + +public class SilencedGelfTcpAppender extends GelfTcpAppender { + + @Override + protected void append(final ILoggingEvent event) { + final byte[] binMessage = getEncoder().encode(event); + + try { + appendMessage(binMessage); + } catch (CoreException ignored) { + // Catching and ignoring CoreException which will be thrown if application can't connect to Graylog, because we don't want the application + // to stop. + } + } + + @Override + protected void appendMessage(final byte[] messageToSend) { + try { + super.appendMessage(messageToSend); + } catch (CoreException e) { + throw new CoreException("Error sending GELF message", e); + } + } + + @Override + public void addError(String msg, Throwable ex) { + throw new CoreException(msg, ex); + } +} diff --git a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java new file mode 100644 index 0000000..9e3da70 --- /dev/null +++ b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java @@ -0,0 +1,69 @@ +package ee.bitweb.core.logging; + +import ch.qos.logback.classic.Level; +import ch.qos.logback.classic.Logger; +import ch.qos.logback.classic.LoggerContext; +import ch.qos.logback.classic.spi.ILoggingEvent; +import ch.qos.logback.classic.spi.LoggingEvent; +import ch.qos.logback.core.Context; +import org.junit.jupiter.api.*; +import org.slf4j.LoggerFactory; + +import java.io.IOException; +import java.net.ServerSocket; +import java.net.Socket; +import java.util.concurrent.TimeUnit; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; + +@Tag("unit") +class SilencedGelfTcpAppenderTest { + + private static ServerSocket serverSocket; + private static Socket mockConnection; + + @BeforeAll + static void beforeAll() throws IOException { + // Create server socket with single element backlog queue (1) and dynamically allocated port (0) + serverSocket = new ServerSocket(0, 1); + + // Fill backlog queue by this request so consequent requests will be blocked + mockConnection = new Socket(); + mockConnection.connect(serverSocket.getLocalSocketAddress()); + } + + @AfterAll + static void afterAll() throws IOException { + if (mockConnection != null && mockConnection.isConnected()) { + mockConnection.close(); + } + + if (serverSocket != null && !serverSocket.isClosed()) { + serverSocket.close(); + } + } + + @Test + @DisplayName("Should not throw any exceptions and continue running when connection to GELF TCP endpoint cannot be made") + @Timeout(value = 300, unit = TimeUnit.MILLISECONDS) + void noExceptionIsThrownWhenConnectionIsUnsuccessful() { + Context context = new LoggerContext(); + + SilencedGelfTcpAppender appender = new SilencedGelfTcpAppender(); + appender.setContext(context); + appender.setGraylogHost("127.0.0.1"); + appender.setGraylogPort(serverSocket.getLocalPort()); + appender.setMaxRetries(0); + appender.setConnectTimeout(100); + appender.setSocketTimeout(100); + appender.start(); + + assertDoesNotThrow(() -> appender.doAppend(createLoggingEvent())); + } + + private ILoggingEvent createLoggingEvent() { + Logger logger = (Logger) LoggerFactory.getLogger(SilencedGelfTcpAppenderTest.class); + + return new LoggingEvent(SilencedGelfTcpAppender.class.getName(), logger, Level.INFO, "message", null, null); + } +} From 306836619b35b9b7112ed36c3e07081116de40e7 Mon Sep 17 00:00:00 2001 From: Rain Ramm Date: Tue, 21 May 2024 11:33:18 +0300 Subject: [PATCH 02/10] Add SilencedGelfTcpAppender to silence GELF connection issues Add test for successful connection --- .../logging/SilencedGelfTcpAppenderTest.java | 60 ++++++++++++++++--- 1 file changed, 52 insertions(+), 8 deletions(-) diff --git a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java index 9e3da70..d8ee58c 100644 --- a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java +++ b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java @@ -12,6 +12,8 @@ import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; @@ -19,21 +21,39 @@ @Tag("unit") class SilencedGelfTcpAppenderTest { - private static ServerSocket serverSocket; - private static Socket mockConnection; + private static final ExecutorService EXECUTOR_SERVICE = Executors.newSingleThreadExecutor(); + + private ServerSocket serverSocket; + private Socket mockConnection; @BeforeAll static void beforeAll() throws IOException { + } + + @BeforeEach + void setUp() throws IOException { // Create server socket with single element backlog queue (1) and dynamically allocated port (0) serverSocket = new ServerSocket(0, 1); + } - // Fill backlog queue by this request so consequent requests will be blocked - mockConnection = new Socket(); - mockConnection.connect(serverSocket.getLocalSocketAddress()); + void listenAndAccept() { + while (!serverSocket.isClosed()) { + try { + Socket socket = serverSocket.accept(); + + System.out.println("connected"); + + if (socket.isConnected()) { + socket.close(); + } + } catch (IOException e) { + throw new RuntimeException(e); + } + } } - @AfterAll - static void afterAll() throws IOException { + @AfterEach + void tearDown() throws IOException { if (mockConnection != null && mockConnection.isConnected()) { mockConnection.close(); } @@ -46,7 +66,31 @@ static void afterAll() throws IOException { @Test @DisplayName("Should not throw any exceptions and continue running when connection to GELF TCP endpoint cannot be made") @Timeout(value = 300, unit = TimeUnit.MILLISECONDS) - void noExceptionIsThrownWhenConnectionIsUnsuccessful() { + void noExceptionIsThrownWhenConnectionIsUnsuccessful() throws IOException { + // Fill backlog queue by this request so consequent requests will be blocked + mockConnection = new Socket(); + mockConnection.connect(serverSocket.getLocalSocketAddress()); + + Context context = new LoggerContext(); + + SilencedGelfTcpAppender appender = new SilencedGelfTcpAppender(); + appender.setContext(context); + appender.setGraylogHost("127.0.0.1"); + appender.setGraylogPort(serverSocket.getLocalPort()); + appender.setMaxRetries(0); + appender.setConnectTimeout(100); + appender.setSocketTimeout(100); + appender.start(); + + assertDoesNotThrow(() -> appender.doAppend(createLoggingEvent())); + } + + @Test + @DisplayName("Should not throw any exceptions and continue running when connection to GELF TCP endpoint is successful") + @Timeout(value = 200, unit = TimeUnit.MILLISECONDS) + void noExceptionIsThrownWhenConnectionIsSuccessful() { + EXECUTOR_SERVICE.execute(this::listenAndAccept); + Context context = new LoggerContext(); SilencedGelfTcpAppender appender = new SilencedGelfTcpAppender(); From 3ebab750066acc8891601b1e7a57a8f94db08a47 Mon Sep 17 00:00:00 2001 From: Rain Ramm Date: Tue, 21 May 2024 12:13:04 +0300 Subject: [PATCH 03/10] Add SilencedGelfTcpAppender to silence GELF connection issues Fix tests, update workflow definition --- .github/workflows/build.yml | 29 +++++++++++-------- .../logging/SilencedGelfTcpAppenderTest.java | 14 ++++----- 2 files changed, 23 insertions(+), 20 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index a088e4c..63dba0b 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -11,27 +11,30 @@ jobs: runs-on: ubuntu-latest steps: - name: Checkout code - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: fetch-depth: 0 + - name: Setup Java - uses: actions/setup-java@v3 + uses: actions/setup-java@v4 with: distribution: temurin java-version: 17 + - name: Setup Gradle - uses: gradle/gradle-build-action@v2 - with: - gradle-version: 8.4 + uses: gradle/actions/setup-gradle@v3 + - name: Run tests and generate reports run: ./gradlew testAndReport + - name: Run Sonar analysis env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} run: ./gradlew sonar -x test --no-watch-fs + - name: Upload Artifact - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: report path: build/reports/** @@ -41,19 +44,21 @@ jobs: runs-on: ubuntu-latest needs: [test] steps: - - uses: actions/checkout@v3 - - uses: actions/setup-java@v3 + - uses: actions/checkout@v4 + + - uses: actions/setup-java@v4 with: distribution: temurin java-version: 17 + - name: Setup Gradle - uses: gradle/gradle-build-action@v2 - with: - gradle-version: 8.4 + uses: gradle/actions/setup-gradle@v3 + - name: Run build with Gradle Wrapper run: ./gradlew build -x test + - name: Upload Artifact - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: jar path: build/libs/** diff --git a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java index d8ee58c..fc9e4ec 100644 --- a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java +++ b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java @@ -21,19 +21,15 @@ @Tag("unit") class SilencedGelfTcpAppenderTest { - private static final ExecutorService EXECUTOR_SERVICE = Executors.newSingleThreadExecutor(); - + private ExecutorService executor; private ServerSocket serverSocket; private Socket mockConnection; - @BeforeAll - static void beforeAll() throws IOException { - } - @BeforeEach void setUp() throws IOException { - // Create server socket with single element backlog queue (1) and dynamically allocated port (0) serverSocket = new ServerSocket(0, 1); + + executor = Executors.newSingleThreadExecutor(); } void listenAndAccept() { @@ -54,6 +50,8 @@ void listenAndAccept() { @AfterEach void tearDown() throws IOException { + executor.shutdownNow(); + if (mockConnection != null && mockConnection.isConnected()) { mockConnection.close(); } @@ -89,7 +87,7 @@ void noExceptionIsThrownWhenConnectionIsUnsuccessful() throws IOException { @DisplayName("Should not throw any exceptions and continue running when connection to GELF TCP endpoint is successful") @Timeout(value = 200, unit = TimeUnit.MILLISECONDS) void noExceptionIsThrownWhenConnectionIsSuccessful() { - EXECUTOR_SERVICE.execute(this::listenAndAccept); + executor.execute(this::listenAndAccept); Context context = new LoggerContext(); From e3565df419b366572931b06f8a6f40962ba34239 Mon Sep 17 00:00:00 2001 From: Rain Ramm Date: Tue, 21 May 2024 13:23:54 +0300 Subject: [PATCH 04/10] Add SilencedGelfTcpAppender to silence GELF connection issues Improve test coverage --- .../core/logging/SilencedGelfTcpAppender.java | 1 + .../logging/SilencedGelfTcpAppenderTest.java | 41 +++++++++++-------- 2 files changed, 25 insertions(+), 17 deletions(-) diff --git a/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java b/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java index d79b99e..1e9c0ab 100644 --- a/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java +++ b/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java @@ -13,6 +13,7 @@ protected void append(final ILoggingEvent event) { try { appendMessage(binMessage); } catch (CoreException ignored) { + System.out.println("Ignored exception: %s".formatted(ignored.getMessage())); // Catching and ignoring CoreException which will be thrown if application can't connect to Graylog, because we don't want the application // to stop. } diff --git a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java index fc9e4ec..a9a4c17 100644 --- a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java +++ b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java @@ -6,6 +6,7 @@ import ch.qos.logback.classic.spi.ILoggingEvent; import ch.qos.logback.classic.spi.LoggingEvent; import ch.qos.logback.core.Context; +import lombok.extern.slf4j.Slf4j; import org.junit.jupiter.api.*; import org.slf4j.LoggerFactory; @@ -19,6 +20,7 @@ import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; @Tag("unit") +@Slf4j class SilencedGelfTcpAppenderTest { private ExecutorService executor; @@ -27,30 +29,18 @@ class SilencedGelfTcpAppenderTest { @BeforeEach void setUp() throws IOException { - serverSocket = new ServerSocket(0, 1); - executor = Executors.newSingleThreadExecutor(); - } - - void listenAndAccept() { - while (!serverSocket.isClosed()) { - try { - Socket socket = serverSocket.accept(); - System.out.println("connected"); + serverSocket = new ServerSocket(0, 1); - if (socket.isConnected()) { - socket.close(); - } - } catch (IOException e) { - throw new RuntimeException(e); - } - } + log.info("Socket server created and listening at port {}", serverSocket.getLocalPort()); } @AfterEach void tearDown() throws IOException { - executor.shutdownNow(); + if (executor != null && !executor.isShutdown()) { + executor.shutdownNow(); + } if (mockConnection != null && mockConnection.isConnected()) { mockConnection.close(); @@ -68,6 +58,7 @@ void noExceptionIsThrownWhenConnectionIsUnsuccessful() throws IOException { // Fill backlog queue by this request so consequent requests will be blocked mockConnection = new Socket(); mockConnection.connect(serverSocket.getLocalSocketAddress()); + log.info("Created mock connection to fill server backlog"); Context context = new LoggerContext(); @@ -108,4 +99,20 @@ private ILoggingEvent createLoggingEvent() { return new LoggingEvent(SilencedGelfTcpAppender.class.getName(), logger, Level.INFO, "message", null, null); } + + private void listenAndAccept() { + while (!serverSocket.isClosed()) { + try { + Socket socket = serverSocket.accept(); + + log.info("Connection accepted, closing connection"); + + if (socket.isConnected()) { + socket.close(); + } + } catch (IOException e) { + throw new RuntimeException(e); + } + } + } } From 0586cbc50c44dd509fa54ed0d5a2690cf7bde719 Mon Sep 17 00:00:00 2001 From: Rain Ramm Date: Tue, 21 May 2024 13:49:09 +0300 Subject: [PATCH 05/10] Add SilencedGelfTcpAppender to silence GELF connection issues Improve test coverage --- .../ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java index a9a4c17..8874c5c 100644 --- a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java +++ b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java @@ -101,6 +101,8 @@ private ILoggingEvent createLoggingEvent() { } private void listenAndAccept() { + log.info("Starting listener"); + while (!serverSocket.isClosed()) { try { Socket socket = serverSocket.accept(); From 9af8253c67d1461a4b19fabd76e2e8df8633d5c2 Mon Sep 17 00:00:00 2001 From: Rain Ramm Date: Tue, 21 May 2024 14:10:16 +0300 Subject: [PATCH 06/10] Add SilencedGelfTcpAppender to silence GELF connection issues Improve test coverage --- .../java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java | 5 ++++- .../ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java | 2 ++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java b/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java index 1e9c0ab..4e3ebbd 100644 --- a/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java +++ b/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java @@ -3,7 +3,9 @@ import ch.qos.logback.classic.spi.ILoggingEvent; import de.siegmar.logbackgelf.GelfTcpAppender; import ee.bitweb.core.exception.CoreException; +import lombok.extern.slf4j.Slf4j; +@Slf4j public class SilencedGelfTcpAppender extends GelfTcpAppender { @Override @@ -13,7 +15,8 @@ protected void append(final ILoggingEvent event) { try { appendMessage(binMessage); } catch (CoreException ignored) { - System.out.println("Ignored exception: %s".formatted(ignored.getMessage())); + log.info("Ignored exception: {}", ignored.getMessage()); +// System.out.println("Ignored exception: %s".formatted(ignored.getMessage())); // Catching and ignoring CoreException which will be thrown if application can't connect to Graylog, because we don't want the application // to stop. } diff --git a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java index 8874c5c..6dab408 100644 --- a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java +++ b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java @@ -60,6 +60,8 @@ void noExceptionIsThrownWhenConnectionIsUnsuccessful() throws IOException { mockConnection.connect(serverSocket.getLocalSocketAddress()); log.info("Created mock connection to fill server backlog"); + new Socket().connect(serverSocket.getLocalSocketAddress(), 100); + Context context = new LoggerContext(); SilencedGelfTcpAppender appender = new SilencedGelfTcpAppender(); From 057bd63a8d8adb6629e7e1a0ceb33ea0d5151691 Mon Sep 17 00:00:00 2001 From: Rain Ramm Date: Tue, 21 May 2024 14:39:09 +0300 Subject: [PATCH 07/10] Add SilencedGelfTcpAppender to silence GELF connection issues Improve test coverage --- .../logging/SilencedGelfTcpAppenderTest.java | 49 ++++++++++++++----- 1 file changed, 36 insertions(+), 13 deletions(-) diff --git a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java index 6dab408..9417258 100644 --- a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java +++ b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java @@ -60,7 +60,8 @@ void noExceptionIsThrownWhenConnectionIsUnsuccessful() throws IOException { mockConnection.connect(serverSocket.getLocalSocketAddress()); log.info("Created mock connection to fill server backlog"); - new Socket().connect(serverSocket.getLocalSocketAddress(), 100); +// new Socket().connect(serverSocket.getLocalSocketAddress()); +// new Socket().connect(serverSocket.getLocalSocketAddress(), 100); Context context = new LoggerContext(); @@ -79,21 +80,43 @@ void noExceptionIsThrownWhenConnectionIsUnsuccessful() throws IOException { @Test @DisplayName("Should not throw any exceptions and continue running when connection to GELF TCP endpoint is successful") @Timeout(value = 200, unit = TimeUnit.MILLISECONDS) - void noExceptionIsThrownWhenConnectionIsSuccessful() { - executor.execute(this::listenAndAccept); + void noExceptionIsThrownWhenConnectionIsSuccessful() throws IOException { + ServerSocket socket = new ServerSocket(0, 1); - Context context = new LoggerContext(); + new Thread(() -> { + log.info("Starting listener"); - SilencedGelfTcpAppender appender = new SilencedGelfTcpAppender(); - appender.setContext(context); - appender.setGraylogHost("127.0.0.1"); - appender.setGraylogPort(serverSocket.getLocalPort()); - appender.setMaxRetries(0); - appender.setConnectTimeout(100); - appender.setSocketTimeout(100); - appender.start(); + while (!socket.isClosed()) { + try { + Socket connection = socket.accept(); - assertDoesNotThrow(() -> appender.doAppend(createLoggingEvent())); + log.info("Connection accepted, closing connection"); + + if (connection.isConnected()) { + connection.close(); + } + } catch (IOException e) { + throw new RuntimeException(e); + } + } + }).start(); + + try { + Context context = new LoggerContext(); + + SilencedGelfTcpAppender appender = new SilencedGelfTcpAppender(); + appender.setContext(context); + appender.setGraylogHost("127.0.0.1"); + appender.setGraylogPort(socket.getLocalPort()); + appender.setMaxRetries(0); + appender.setConnectTimeout(100); + appender.setSocketTimeout(100); + appender.start(); + + assertDoesNotThrow(() -> appender.doAppend(createLoggingEvent())); + } finally { + socket.close(); + } } private ILoggingEvent createLoggingEvent() { From 39f3cde87a8192b884405e5dbdc32049da4ddfb1 Mon Sep 17 00:00:00 2001 From: Rain Ramm Date: Tue, 21 May 2024 14:45:00 +0300 Subject: [PATCH 08/10] Add SilencedGelfTcpAppender to silence GELF connection issues Improve test coverage --- .../ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java index 9417258..bc54a9c 100644 --- a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java +++ b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java @@ -80,7 +80,7 @@ void noExceptionIsThrownWhenConnectionIsUnsuccessful() throws IOException { @Test @DisplayName("Should not throw any exceptions and continue running when connection to GELF TCP endpoint is successful") @Timeout(value = 200, unit = TimeUnit.MILLISECONDS) - void noExceptionIsThrownWhenConnectionIsSuccessful() throws IOException { + void noExceptionIsThrownWhenConnectionIsSuccessful() throws IOException, InterruptedException { ServerSocket socket = new ServerSocket(0, 1); new Thread(() -> { @@ -101,6 +101,10 @@ void noExceptionIsThrownWhenConnectionIsSuccessful() throws IOException { } }).start(); + Thread.sleep(1); + + log.info("Continue"); + try { Context context = new LoggerContext(); From 7fca123b88de57bf0d505c9194b8580889bc45e2 Mon Sep 17 00:00:00 2001 From: Rain Ramm Date: Tue, 21 May 2024 14:59:11 +0300 Subject: [PATCH 09/10] Add SilencedGelfTcpAppender to silence GELF connection issues Remove tests --- gradle.properties | 1 + .../logging/SilencedGelfTcpAppenderTest.java | 149 ------------------ 2 files changed, 1 insertion(+), 149 deletions(-) delete mode 100644 src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java diff --git a/gradle.properties b/gradle.properties index b456f3c..3506f17 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1 +1,2 @@ systemProp.org.gradle.internal.publish.checksums.insecure=true +org.gradle.welcome=never diff --git a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java b/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java deleted file mode 100644 index bc54a9c..0000000 --- a/src/test/java/ee/bitweb/core/logging/SilencedGelfTcpAppenderTest.java +++ /dev/null @@ -1,149 +0,0 @@ -package ee.bitweb.core.logging; - -import ch.qos.logback.classic.Level; -import ch.qos.logback.classic.Logger; -import ch.qos.logback.classic.LoggerContext; -import ch.qos.logback.classic.spi.ILoggingEvent; -import ch.qos.logback.classic.spi.LoggingEvent; -import ch.qos.logback.core.Context; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.*; -import org.slf4j.LoggerFactory; - -import java.io.IOException; -import java.net.ServerSocket; -import java.net.Socket; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.TimeUnit; - -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; - -@Tag("unit") -@Slf4j -class SilencedGelfTcpAppenderTest { - - private ExecutorService executor; - private ServerSocket serverSocket; - private Socket mockConnection; - - @BeforeEach - void setUp() throws IOException { - executor = Executors.newSingleThreadExecutor(); - - serverSocket = new ServerSocket(0, 1); - - log.info("Socket server created and listening at port {}", serverSocket.getLocalPort()); - } - - @AfterEach - void tearDown() throws IOException { - if (executor != null && !executor.isShutdown()) { - executor.shutdownNow(); - } - - if (mockConnection != null && mockConnection.isConnected()) { - mockConnection.close(); - } - - if (serverSocket != null && !serverSocket.isClosed()) { - serverSocket.close(); - } - } - - @Test - @DisplayName("Should not throw any exceptions and continue running when connection to GELF TCP endpoint cannot be made") - @Timeout(value = 300, unit = TimeUnit.MILLISECONDS) - void noExceptionIsThrownWhenConnectionIsUnsuccessful() throws IOException { - // Fill backlog queue by this request so consequent requests will be blocked - mockConnection = new Socket(); - mockConnection.connect(serverSocket.getLocalSocketAddress()); - log.info("Created mock connection to fill server backlog"); - -// new Socket().connect(serverSocket.getLocalSocketAddress()); -// new Socket().connect(serverSocket.getLocalSocketAddress(), 100); - - Context context = new LoggerContext(); - - SilencedGelfTcpAppender appender = new SilencedGelfTcpAppender(); - appender.setContext(context); - appender.setGraylogHost("127.0.0.1"); - appender.setGraylogPort(serverSocket.getLocalPort()); - appender.setMaxRetries(0); - appender.setConnectTimeout(100); - appender.setSocketTimeout(100); - appender.start(); - - assertDoesNotThrow(() -> appender.doAppend(createLoggingEvent())); - } - - @Test - @DisplayName("Should not throw any exceptions and continue running when connection to GELF TCP endpoint is successful") - @Timeout(value = 200, unit = TimeUnit.MILLISECONDS) - void noExceptionIsThrownWhenConnectionIsSuccessful() throws IOException, InterruptedException { - ServerSocket socket = new ServerSocket(0, 1); - - new Thread(() -> { - log.info("Starting listener"); - - while (!socket.isClosed()) { - try { - Socket connection = socket.accept(); - - log.info("Connection accepted, closing connection"); - - if (connection.isConnected()) { - connection.close(); - } - } catch (IOException e) { - throw new RuntimeException(e); - } - } - }).start(); - - Thread.sleep(1); - - log.info("Continue"); - - try { - Context context = new LoggerContext(); - - SilencedGelfTcpAppender appender = new SilencedGelfTcpAppender(); - appender.setContext(context); - appender.setGraylogHost("127.0.0.1"); - appender.setGraylogPort(socket.getLocalPort()); - appender.setMaxRetries(0); - appender.setConnectTimeout(100); - appender.setSocketTimeout(100); - appender.start(); - - assertDoesNotThrow(() -> appender.doAppend(createLoggingEvent())); - } finally { - socket.close(); - } - } - - private ILoggingEvent createLoggingEvent() { - Logger logger = (Logger) LoggerFactory.getLogger(SilencedGelfTcpAppenderTest.class); - - return new LoggingEvent(SilencedGelfTcpAppender.class.getName(), logger, Level.INFO, "message", null, null); - } - - private void listenAndAccept() { - log.info("Starting listener"); - - while (!serverSocket.isClosed()) { - try { - Socket socket = serverSocket.accept(); - - log.info("Connection accepted, closing connection"); - - if (socket.isConnected()) { - socket.close(); - } - } catch (IOException e) { - throw new RuntimeException(e); - } - } - } -} From 308e13f2b5cc3848ab015bffa4ca1b6faf5a57ac Mon Sep 17 00:00:00 2001 From: Rain Ramm Date: Tue, 21 May 2024 14:59:59 +0300 Subject: [PATCH 10/10] Add SilencedGelfTcpAppender to silence GELF connection issues Remove test code --- .../java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java b/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java index 4e3ebbd..8636a03 100644 --- a/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java +++ b/src/main/java/ee/bitweb/core/logging/SilencedGelfTcpAppender.java @@ -15,8 +15,6 @@ protected void append(final ILoggingEvent event) { try { appendMessage(binMessage); } catch (CoreException ignored) { - log.info("Ignored exception: {}", ignored.getMessage()); -// System.out.println("Ignored exception: %s".formatted(ignored.getMessage())); // Catching and ignoring CoreException which will be thrown if application can't connect to Graylog, because we don't want the application // to stop. }