locusworks/app-logger
3
0 Fork 0
Code Issues Pull Requests Releases 5 Wiki Activity

Feature/jdk upgrade #17

Merged
iparenteau merged 4 commits from feature/jdk-upgrade into develop 2026-09-02 14:16:18 -05:00
Conversation 0 Commits 4 Files Changed 16
+608 -374
16 changed files with 608 additions and 374 deletions
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Jenkinsfile
Vendored
+83 -170
View File
@@ -1,186 +1,99 @@
#!groovy pipeline {
agent any
// Required Jenkins plugins: options {
// https://wiki.jenkins-ci.org/display/JENKINS/Timestamper buildDiscarder(logRotator(numToKeepStr: '5'))
// https://wiki.jenkins-ci.org/display/JENKINS/Static+Code+Analysis+Plug-ins disableConcurrentBuilds()
// https://wiki.jenkins-ci.org/display/JENKINS/Checkstyle+Plugin ? skipDefaultCheckout(true)
// https://wiki.jenkins-ci.org/display/JENKINS/FindBugs+Plugin timestamps()
// https://wiki.jenkins-ci.org/display/JENKINS/PMD+Plugin ?
// https://wiki.jenkins-ci.org/display/JENKINS/DRY+Plugin ?
// https://wiki.jenkins-ci.org/display/JENKINS/Task+Scanner+Plugin
// https://wiki.jenkins-ci.org/display/JENKINS/Javadoc+Plugin
// https://wiki.jenkins-ci.org/display/JENKINS/JaCoCo+Plugin ?
init()
def branch_name
def branch_name_base
def build_number
def build_url
def git_commit
def job_name
def tag
def version
def build_type
def display_name
def init() {
// Keep the 5 most recent builds
properties([[$class: 'BuildDiscarderProperty', strategy: [$class: 'LogRotator', numToKeepStr: '5']]])
build_number = env.BUILD_NUMBER
build_url = env.BUILD_URL
job_name = "${env.JOB_NAME}"
branch_name = env.BRANCH_NAME
branch_name_docker = branch_name.replaceAll(/\//,'.')
persist = "/var/lib/jenkins/PERSIST/${branch_name_docker}"
// execute the branch type specific pipeline code
try {
if (branch_name.indexOf('release/')==0) build_type='release'
if (branch_name.indexOf('feature/')==0) build_type='feature'
if (branch_name.indexOf('develop')==0) build_type='develop'
if (branch_name.indexOf('hotfix')==0) build_type='hotfix'
if (branch_name.indexOf('bugfix')==0) build_type='bugfix'
if (branch_name.indexOf('master')==0) build_type='master'
// common pipeline elements
node() {
Initialize()
SetVersion(build_type)
print_vars() // after SetVersion - all variables now defined
set_result('INPROGRESS')
Build() // builds database via flyway migration
} }
if (branch_name.indexOf('develop')==0) { stages {
node() { stage('Checkout') {
Deploy(); steps {
}
} else if (branch_name.indexOf('release/')==0) {
node() {
Deploy();
}
}
node() {
set_result('SUCCESS')
}
} catch (err) {
node() {
set_result('FAILURE')
}
throw err
}
}
def Build() {
stage ('build') {
mvn "install -DskipTests=true -Dbuild.revision=${git_commit}"
step([$class: 'ArtifactArchiver', artifacts: '**/target/*.jar', fingerprint: true])
}
}
def Initialize() {
stage ('initialize') {
// get new code
checkout scm checkout scm
git_commit = getSha1()
} }
}
def Deploy() {
stage ('deploy') {
mvn "deploy -DskipTests=true -Dbuild.number=${build_number} -Dbuild.revision=${git_commit}"
} }
}
def getSha1() {
sha1 = sh(script: 'git rev-parse HEAD', returnStdout: true).trim()
echo "sha1 is ${sha1}"
return sha1
}
def mvn(args) {
withMaven(
maven: 'maven-3.6.1',
globalMavenSettingsConfig: 'locusworks-settings'
) {
sh "mvn ${args}"
stage('Set version') {
steps {
script {
String branch = env.BRANCH_NAME
if (!branch) {
error('BRANCH_NAME is unavailable; this pipeline must run as a multibranch job')
} }
}
def mvn_initial(args) { env.DEPLOY_BUILD = 'false'
mvn(args)
}
def set_result(status) { def releaseMatch = branch =~ /^release\/(\d+\.\d+\.\d+)$/
if ( status == 'SUCCESS' ) { if (releaseMatch.matches()) {
currentBuild.result = status env.BUILD_VERSION = "${releaseMatch[0][1]}.${env.BUILD_NUMBER}-RELEASE"
notify_bitbucket('SUCCESSFUL') env.DEPLOY_BUILD = 'true'
} else if ( status == 'FAILURE' ) { } else if (branch == 'develop') {
currentBuild.result = status env.BUILD_VERSION = "develop.${env.BUILD_NUMBER}-SNAPSHOT"
notify_bitbucket('FAILED') env.DEPLOY_BUILD = 'true'
} else if ( status == 'INPROGRESS' ) {
notify_bitbucket('INPROGRESS')
} else { } else {
error ("unknown status") String safeBranch = branch.replaceAll(/[^A-Za-z0-9._-]/, '-')
env.BUILD_VERSION = "0.0.${env.BUILD_NUMBER}-${safeBranch}-SNAPSHOT"
}
currentBuild.displayName = env.BUILD_VERSION
} }
// save in persistence file for access the status page withMaven(maven: 'maven-3.9.16', globalMavenSettingsConfig: 'locusworks-settings') {
// make sure the directory exists first sh 'mvn -B org.codehaus.mojo:versions-maven-plugin:2.21.0:set -DgenerateBackupPoms=false -DnewVersion="$BUILD_VERSION"'
sh "mkdir -p $persist && echo $status > $persist/build.result" }
} }
}
def notify_bitbucket(state) {
} stage('Prepare OWASP cache') {
steps {
def print_vars() { lock(resource: 'owasp-nvd-cache') {
echo "build_number = ${build_number}" withMaven(maven: 'maven-3.9.16', globalMavenSettingsConfig: 'locusworks-settings') {
echo "build_url = ${build_url}" sh 'mkdir -p "$HOME/.cache/dependency-check"'
echo "job_name = ${job_name}" sh 'mvn -B org.owasp:dependency-check-maven:13.0.0:update-only -DdataDirectory="$HOME/.cache/dependency-check"'
echo "branch_name = ${branch_name}" }
echo "branch_name_base = ${branch_name_base}" }
echo "build_type = ${build_type}" }
echo "display_name = ${currentBuild.displayName}" }
echo "version = ${version}"
echo "git_commit = ${git_commit}" stage('Build and test') {
steps {
} withMaven(maven: 'maven-3.9.16', globalMavenSettingsConfig: 'locusworks-settings') {
sh 'mvn -B clean verify -DdataDirectory="$HOME/.cache/dependency-check" -DautoUpdate=false -Dbuild.revision="$GIT_COMMIT"'
def SetVersion( v ) { }
stage ('set version') { }
echo "set version ${v}" post {
branch_name_base = (branch_name =~ /([^\/]+$)/)[0][0] always {
if ( v == 'release' ) { junit allowEmptyResults: true, testResults: '**/target/surefire-reports/*.xml'
// for release branches, where the branch is named "release/1.2.3", }
// derive the version and display name derive from the numeric suffix and append the build number success {
// 3.2.1.100 archiveArtifacts artifacts: '**/target/*.jar', fingerprint: true
version = branch_name_base + "." + build_number + "-RELEASE"; archiveArtifacts artifacts: '**/target/site/jacoco/**', fingerprint: true
//version = branch_name.substring('release/'.length()) + "." + build_number }
currentBuild.displayName = version }
} else if (v == 'develop') { }
version = branch_name_base + "." + build_number + "-SNAPSHOT";
currentBuild.displayName = version stage('Deploy') {
} else { when {
// for all other branches the version number is 0 with an appended build number expression { env.DEPLOY_BUILD == 'true' }
// and for the display name use the jenkins default #n and add the branch name }
// #101 - feature/user/foo steps {
//version = '0.' + build_number withMaven(maven: 'maven-3.9.16', globalMavenSettingsConfig: 'locusworks-settings') {
version = branch_name_base + "." + build_number sh 'mvn -B deploy -DskipTests -Ddependency-check.skip=true -Dbuild.number="$BUILD_NUMBER" -Dbuild.revision="$GIT_COMMIT"'
currentBuild.displayName = "#" + build_number + " - " + branch_name_base }
}
}
}
post {
success {
echo "Published build ${env.BUILD_VERSION} successfully"
}
failure {
echo "Build ${env.BUILD_VERSION ?: env.BUILD_NUMBER} failed"
}
cleanup {
deleteDir()
} }
display_name = currentBuild.displayName
mvn_initial "versions:set -DnewVersion=${version}"
} }
} }
return this
bitbucket-pipelines.yml
-14
View File
@@ -1,14 +0,0 @@
# This is a sample build configuration for Java (Maven).
# Check our guides at https://confluence.atlassian.com/x/zd-5Mw for more examples.
# Only use spaces to indent your .yml configuration.
# -----
# You can specify a custom docker image from Docker Hub as your build environment.
image: maven:3.3.9
pipelines:
default:
- step:
caches:
- maven
script: # Modify the commands below to build your repository.
- mvn -B verify # -B batch mode makes Maven less verbose
pom.xml
+73 -32
View File
@@ -17,28 +17,70 @@
</organization> </organization>
<properties> <properties>
<main.basedir>${project.basedir}</main.basedir> <slf4j.version>2.0.18</slf4j.version>
<maven.compiler.source>1.8</maven.compiler.source> <junit.version>5.14.4</junit.version>
<maven.compiler.target>1.8</maven.compiler.target> <mockito.version>5.23.0</mockito.version>
<log4j.version>2.19.0</log4j.version> <jacoco.version>0.8.15</jacoco.version>
<slf4j.version>2.0.1</slf4j.version> <maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<nexus.repo>https://nexus.locusworks.net</nexus.repo> <nexus.repo>https://nexus.locusworks.net</nexus.repo>
</properties> </properties>
<build> <build>
<plugins> <plugins>
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>${jacoco.version}</version>
<executions>
<execution>
<goals>
<goal>prepare-agent</goal>
</goals>
</execution>
<execution>
<id>report</id>
<phase>verify</phase>
<goals>
<goal>report</goal>
</goals>
</execution>
<execution>
<id>coverage-check</id>
<phase>verify</phase>
<goals>
<goal>check</goal>
</goals>
<configuration>
<rules>
<rule>
<element>BUNDLE</element>
<limits>
<limit>
<counter>LINE</counter>
<value>COVEREDRATIO</value>
<minimum>0.75</minimum>
</limit>
</limits>
</rule>
</rules>
</configuration>
</execution>
</executions>
</plugin>
<plugin> <plugin>
<groupId>org.apache.maven.plugins</groupId> <groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId> <artifactId>maven-surefire-plugin</artifactId>
<version>3.0.0-M7</version> <version>3.5.6</version>
<configuration> <configuration>
<forkMode>always</forkMode> <argLine>@{argLine} -javaagent:${settings.localRepository}/org/mockito/mockito-core/${mockito.version}/mockito-core-${mockito.version}.jar</argLine>
</configuration> </configuration>
</plugin> </plugin>
<plugin> <plugin>
<groupId>org.apache.maven.plugins</groupId> <groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId> <artifactId>maven-compiler-plugin</artifactId>
<version>3.10.1</version> <version>3.15.0</version>
<configuration> <configuration>
<source>${maven.compiler.source}</source> <source>${maven.compiler.source}</source>
<target>${maven.compiler.target}</target> <target>${maven.compiler.target}</target>
@@ -51,7 +93,14 @@
<plugin> <plugin>
<groupId>org.owasp</groupId> <groupId>org.owasp</groupId>
<artifactId>dependency-check-maven</artifactId> <artifactId>dependency-check-maven</artifactId>
<version>7.2.0</version> <version>13.0.0</version>
<configuration>
<skipProvidedScope>true</skipProvidedScope>
<skipTestScope>true</skipTestScope>
<failOnError>true</failOnError>
<versionCheckEnabled>true</versionCheckEnabled>
<nvdApiKey>e2eb1036-9b5b-4df9-95e7-0888be947011</nvdApiKey>
</configuration>
<executions> <executions>
<execution> <execution>
<goals> <goals>
@@ -63,7 +112,7 @@
<plugin> <plugin>
<groupId>org.apache.maven.plugins</groupId> <groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-enforcer-plugin</artifactId> <artifactId>maven-enforcer-plugin</artifactId>
<version>3.1.0</version> <version>3.6.3</version>
<executions> <executions>
<execution> <execution>
<id>enforce</id> <id>enforce</id>
@@ -82,27 +131,6 @@
</build> </build>
<dependencies> <dependencies>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j-impl</artifactId>
<version>${log4j.version}</version>
<exclusions>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency> <dependency>
<groupId>org.slf4j</groupId> <groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId> <artifactId>slf4j-api</artifactId>
@@ -110,8 +138,21 @@
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.slf4j</groupId> <groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId> <artifactId>slf4j-simple</artifactId>
<version>${slf4j.version}</version> <version>${slf4j.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>${mockito.version}</version>
<scope>test</scope>
</dependency> </dependency>
</dependencies> </dependencies>
src/main/java/net/locusworks/logger/ApplicationLogger.java
+96 -53
View File
@@ -5,6 +5,8 @@ import java.util.Map;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.slf4j.Marker; import org.slf4j.Marker;
import org.slf4j.helpers.FormattingTuple;
import org.slf4j.helpers.MessageFormatter;
/** /**
* Logger implementation to use across applications. Extends slf4j logger to work with other logging applications * Logger implementation to use across applications. Extends slf4j logger to work with other logging applications
@@ -13,9 +15,9 @@ import org.slf4j.Marker;
*/ */
public class ApplicationLogger implements org.slf4j.Logger { public class ApplicationLogger implements org.slf4j.Logger {
protected static final String DEFAULT_FORMAT = "%s"; protected static final String DEFAULT_FORMAT = "{}";
private static final Logger logger = LoggerFactory.getLogger(ApplicationLogger.class); private final Logger logger;
private final String name; private final String name;
@@ -42,8 +44,13 @@ public class ApplicationLogger implements org.slf4j.Logger {
* @param level level of logging to set the logger to * @param level level of logging to set the logger to
*/ */
protected ApplicationLogger(String name, LogLevel level) { protected ApplicationLogger(String name, LogLevel level) {
this(name, level, LoggerFactory.getLogger(name));
}
ApplicationLogger(String name, LogLevel level, Logger logger) {
this.name = name; this.name = name;
this.level = level; this.level = level;
this.logger = logger;
} }
/** /**
@@ -105,7 +112,7 @@ public class ApplicationLogger implements org.slf4j.Logger {
@Override @Override
public boolean isTraceEnabled() { public boolean isTraceEnabled() {
return this.level.log(LogLevel.TRACE); return enabled(LogLevel.TRACE) && logger.isTraceEnabled();
} }
@Override @Override
@@ -130,42 +137,42 @@ public class ApplicationLogger implements org.slf4j.Logger {
@Override @Override
public void trace(String msg, Throwable t) { public void trace(String msg, Throwable t) {
trace("%s%n%s", msg, getStackTrace(t.getStackTrace())); log(LogLevel.TRACE, msg, t);
} }
@Override @Override
public boolean isTraceEnabled(Marker marker) { public boolean isTraceEnabled(Marker marker) {
return isTraceEnabled(); return enabled(LogLevel.TRACE) && logger.isTraceEnabled(marker);
} }
@Override @Override
public void trace(Marker marker, String msg) { public void trace(Marker marker, String msg) {
trace(msg); markerLog(LogLevel.TRACE, marker, msg);
} }
@Override @Override
public void trace(Marker marker, String format, Object arg) { public void trace(Marker marker, String format, Object arg) {
trace(format, arg); markerLog(LogLevel.TRACE, marker, format, arg);
} }
@Override @Override
public void trace(Marker marker, String format, Object arg1, Object arg2) { public void trace(Marker marker, String format, Object arg1, Object arg2) {
trace(format, arg1, arg2); markerLog(LogLevel.TRACE, marker, format, arg1, arg2);
} }
@Override @Override
public void trace(Marker marker, String format, Object... argArray) { public void trace(Marker marker, String format, Object... argArray) {
trace(format, argArray); markerLog(LogLevel.TRACE, marker, format, argArray);
} }
@Override @Override
public void trace(Marker marker, String msg, Throwable t) { public void trace(Marker marker, String msg, Throwable t) {
trace(msg, t); markerLog(LogLevel.TRACE, marker, msg, t);
} }
@Override @Override
public boolean isDebugEnabled() { public boolean isDebugEnabled() {
return this.level.log(LogLevel.DEBUG); return enabled(LogLevel.DEBUG) && logger.isDebugEnabled();
} }
@Override @Override
@@ -190,42 +197,42 @@ public class ApplicationLogger implements org.slf4j.Logger {
@Override @Override
public void debug(String msg, Throwable t) { public void debug(String msg, Throwable t) {
debug("%s%n%s", msg, getStackTrace(t.getStackTrace())); log(LogLevel.DEBUG, msg, t);
} }
@Override @Override
public boolean isDebugEnabled(Marker marker) { public boolean isDebugEnabled(Marker marker) {
return isDebugEnabled(); return enabled(LogLevel.DEBUG) && logger.isDebugEnabled(marker);
} }
@Override @Override
public void debug(Marker marker, String msg) { public void debug(Marker marker, String msg) {
debug(msg); markerLog(LogLevel.DEBUG, marker, msg);
} }
@Override @Override
public void debug(Marker marker, String format, Object arg) { public void debug(Marker marker, String format, Object arg) {
debug(format, arg); markerLog(LogLevel.DEBUG, marker, format, arg);
} }
@Override @Override
public void debug(Marker marker, String format, Object arg1, Object arg2) { public void debug(Marker marker, String format, Object arg1, Object arg2) {
debug(format, arg1, arg2); markerLog(LogLevel.DEBUG, marker, format, arg1, arg2);
} }
@Override @Override
public void debug(Marker marker, String format, Object... arguments) { public void debug(Marker marker, String format, Object... arguments) {
debug(format, arguments); markerLog(LogLevel.DEBUG, marker, format, arguments);
} }
@Override @Override
public void debug(Marker marker, String msg, Throwable t) { public void debug(Marker marker, String msg, Throwable t) {
debug(msg, t); markerLog(LogLevel.DEBUG, marker, msg, t);
} }
@Override @Override
public boolean isInfoEnabled() { public boolean isInfoEnabled() {
return this.level.log(LogLevel.INFO); return enabled(LogLevel.INFO) && logger.isInfoEnabled();
} }
@Override @Override
@@ -250,7 +257,7 @@ public class ApplicationLogger implements org.slf4j.Logger {
@Override @Override
public void info(String msg, Throwable t) { public void info(String msg, Throwable t) {
info("%s%n%s", msg, getStackTrace(t.getStackTrace())); log(LogLevel.INFO, msg, t);
} }
/** /**
@@ -283,37 +290,37 @@ public class ApplicationLogger implements org.slf4j.Logger {
@Override @Override
public boolean isInfoEnabled(Marker marker) { public boolean isInfoEnabled(Marker marker) {
return isInfoEnabled(); return enabled(LogLevel.INFO) && logger.isInfoEnabled(marker);
} }
@Override @Override
public void info(Marker marker, String msg) { public void info(Marker marker, String msg) {
info(msg); markerLog(LogLevel.INFO, marker, msg);
} }
@Override @Override
public void info(Marker marker, String format, Object arg) { public void info(Marker marker, String format, Object arg) {
info(format, arg); markerLog(LogLevel.INFO, marker, format, arg);
} }
@Override @Override
public void info(Marker marker, String format, Object arg1, Object arg2) { public void info(Marker marker, String format, Object arg1, Object arg2) {
info(format, arg1, arg2); markerLog(LogLevel.INFO, marker, format, arg1, arg2);
} }
@Override @Override
public void info(Marker marker, String format, Object... arguments) { public void info(Marker marker, String format, Object... arguments) {
info(format, arguments); markerLog(LogLevel.INFO, marker, format, arguments);
} }
@Override @Override
public void info(Marker marker, String msg, Throwable t) { public void info(Marker marker, String msg, Throwable t) {
info(msg, t); markerLog(LogLevel.INFO, marker, msg, t);
} }
@Override @Override
public boolean isWarnEnabled() { public boolean isWarnEnabled() {
return this.level.log(LogLevel.WARN); return enabled(LogLevel.WARN) && logger.isWarnEnabled();
} }
@Override @Override
@@ -338,37 +345,37 @@ public class ApplicationLogger implements org.slf4j.Logger {
@Override @Override
public void warn(String msg, Throwable t) { public void warn(String msg, Throwable t) {
warn("%s%n%s", msg, getStackTrace(t.getStackTrace())); log(LogLevel.WARN, msg, t);
} }
@Override @Override
public boolean isWarnEnabled(Marker marker) { public boolean isWarnEnabled(Marker marker) {
return isWarnEnabled(); return enabled(LogLevel.WARN) && logger.isWarnEnabled(marker);
} }
@Override @Override
public void warn(Marker marker, String msg) { public void warn(Marker marker, String msg) {
warn(msg); markerLog(LogLevel.WARN, marker, msg);
} }
@Override @Override
public void warn(Marker marker, String format, Object arg) { public void warn(Marker marker, String format, Object arg) {
warn(format, arg); markerLog(LogLevel.WARN, marker, format, arg);
} }
@Override @Override
public void warn(Marker marker, String format, Object arg1, Object arg2) { public void warn(Marker marker, String format, Object arg1, Object arg2) {
warn(format, arg1, arg2); markerLog(LogLevel.WARN, marker, format, arg1, arg2);
} }
@Override @Override
public void warn(Marker marker, String format, Object... arguments) { public void warn(Marker marker, String format, Object... arguments) {
warn(format, arguments); markerLog(LogLevel.WARN, marker, format, arguments);
} }
@Override @Override
public void warn(Marker marker, String msg, Throwable t) { public void warn(Marker marker, String msg, Throwable t) {
warn(msg, t); markerLog(LogLevel.WARN, marker, msg, t);
} }
/** /**
@@ -400,7 +407,7 @@ public class ApplicationLogger implements org.slf4j.Logger {
@Override @Override
public boolean isErrorEnabled() { public boolean isErrorEnabled() {
return this.level.log(LogLevel.ERROR); return enabled(LogLevel.ERROR) && logger.isErrorEnabled();
} }
@Override @Override
@@ -429,7 +436,7 @@ public class ApplicationLogger implements org.slf4j.Logger {
@Override @Override
public void error(String msg, Throwable t) { public void error(String msg, Throwable t) {
error("%s%n%s", msg, getStackTrace(t.getStackTrace())); log(LogLevel.ERROR, msg, t);
} }
/** /**
@@ -448,7 +455,7 @@ public class ApplicationLogger implements org.slf4j.Logger {
* @param e throwable error to log * @param e throwable error to log
*/ */
public void error(Map<String, String> values, StringBuilder sb, Throwable e) { public void error(Map<String, String> values, StringBuilder sb, Throwable e) {
error(values, null, sb); error(values, null, sb, e);
} }
/** /**
@@ -469,40 +476,37 @@ public class ApplicationLogger implements org.slf4j.Logger {
* @param e Throwable error to log * @param e Throwable error to log
*/ */
public void error(Map<String, String> values, String valueFormat, StringBuilder sb, Throwable e) { public void error(Map<String, String> values, String valueFormat, StringBuilder sb, Throwable e) {
msgHelper(LogLevel.ERROR, values, valueFormat, sb); log(LogLevel.ERROR, formatValues(values, valueFormat, sb), e);
if (e != null) {
msgHelper(LogLevel.ERROR,"", e);
}
} }
@Override @Override
public boolean isErrorEnabled(Marker marker) { public boolean isErrorEnabled(Marker marker) {
return isErrorEnabled(); return enabled(LogLevel.ERROR) && logger.isErrorEnabled(marker);
} }
@Override @Override
public void error(Marker marker, String msg) { public void error(Marker marker, String msg) {
error(msg); markerLog(LogLevel.ERROR, marker, msg);
} }
@Override @Override
public void error(Marker marker, String format, Object arg) { public void error(Marker marker, String format, Object arg) {
error(format, arg); markerLog(LogLevel.ERROR, marker, format, arg);
} }
@Override @Override
public void error(Marker marker, String format, Object arg1, Object arg2) { public void error(Marker marker, String format, Object arg1, Object arg2) {
error(format, arg1, arg2); markerLog(LogLevel.ERROR, marker, format, arg1, arg2);
} }
@Override @Override
public void error(Marker marker, String format, Object... arguments) { public void error(Marker marker, String format, Object... arguments) {
error(format, arguments); markerLog(LogLevel.ERROR, marker, format, arguments);
} }
@Override @Override
public void error(Marker marker, String msg, Throwable t) { public void error(Marker marker, String msg, Throwable t) {
error(msg, t); markerLog(LogLevel.ERROR, marker, msg, t);
} }
/** /**
@@ -537,6 +541,42 @@ public class ApplicationLogger implements org.slf4j.Logger {
} }
} }
private boolean enabled(LogLevel messageLevel) {
LogLevel current = this.level;
return current != null && current != LogLevel.OFF && messageLevel.toInt() >= current.toInt();
}
protected void log(LogLevel level, String message, Throwable throwable) {
if (level == null || this.level == null || level.toInt() < this.level.toInt()) return;
switch (level) {
case ALL:
case TRACE: logger.trace(message, throwable); break;
case DEBUG: logger.debug(message, throwable); break;
case INFO: logger.info(message, throwable); break;
case WARN: logger.warn(message, throwable); break;
case ERROR:
case FATAL: logger.error(message, throwable); break;
case OFF:
default: break;
}
}
private void markerLog(LogLevel level, Marker marker, String message, Object... arguments) {
if (level == null || this.level == null || level.toInt() < this.level.toInt()) return;
FormattingTuple tuple = MessageFormatter.arrayFormat(message, arguments);
switch (level) {
case ALL:
case TRACE: logger.trace(marker, tuple.getMessage(), tuple.getThrowable()); break;
case DEBUG: logger.debug(marker, tuple.getMessage(), tuple.getThrowable()); break;
case INFO: logger.info(marker, tuple.getMessage(), tuple.getThrowable()); break;
case WARN: logger.warn(marker, tuple.getMessage(), tuple.getThrowable()); break;
case ERROR:
case FATAL: logger.error(marker, tuple.getMessage(), tuple.getThrowable()); break;
case OFF:
default: break;
}
}
/** /**
* Print the exception stack trace to a string * Print the exception stack trace to a string
* @param e Exception to print the stack trace * @param e Exception to print the stack trace
@@ -567,11 +607,13 @@ public class ApplicationLogger implements org.slf4j.Logger {
* @param sb String builder to append messages to * @param sb String builder to append messages to
*/ */
private void msgHelper(LogLevel level, Map<String, String> values, String valueFormat, StringBuilder sb) { private void msgHelper(LogLevel level, Map<String, String> values, String valueFormat, StringBuilder sb) {
log(level, formatValues(values, valueFormat, sb));
if (sb == null) {
sb = new StringBuilder();
} }
private String formatValues(Map<String, String> values, String valueFormat, StringBuilder sb) {
if (values == null) throw new IllegalArgumentException("values must not be null");
if (sb == null) sb = new StringBuilder();
if (valueFormat == null || valueFormat.trim().isEmpty()) { if (valueFormat == null || valueFormat.trim().isEmpty()) {
int longest = 0; int longest = 0;
for (String key : values.keySet()) { for (String key : values.keySet()) {
@@ -590,7 +632,7 @@ public class ApplicationLogger implements org.slf4j.Logger {
.map(entry -> String.format(format, entry.getKey(), entry.getValue())) .map(entry -> String.format(format, entry.getKey(), entry.getValue()))
.forEach(builder::append); .forEach(builder::append);
log(level, builder.toString()); return builder.toString();
} }
/** /**
@@ -600,7 +642,8 @@ public class ApplicationLogger implements org.slf4j.Logger {
* @param args Arguments to use in the string format * @param args Arguments to use in the string format
*/ */
private void msgHelper(LogLevel level, String format, Object...args) { private void msgHelper(LogLevel level, String format, Object...args) {
log(level, String.format(format, args)); FormattingTuple tuple = MessageFormatter.arrayFormat(format, args);
log(level, tuple.getMessage(), tuple.getThrowable());
} }
/** /**
@@ -620,6 +663,6 @@ public class ApplicationLogger implements org.slf4j.Logger {
* @return the formatted string * @return the formatted string
*/ */
private String format(String message, LogLevel level) { private String format(String message, LogLevel level) {
return String.format("th%06d [%-5s] [%s] %s", Thread.currentThread().getId(), level, this.name, message); return String.format("th%06d [%-5s] [%s] %s", Thread.currentThread().threadId(), level, this.name, message);
} }
} }
src/main/java/net/locusworks/logger/ApplicationLoggerFactory.java
+9 -10
View File
@@ -2,7 +2,7 @@ package net.locusworks.logger;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.TreeMap; import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors; import java.util.stream.Collectors;
/*** /***
@@ -12,9 +12,9 @@ import java.util.stream.Collectors;
* @date 02/15/2018 * @date 02/15/2018
*/ */
public class ApplicationLoggerFactory { public class ApplicationLoggerFactory {
private static Map<String, ApplicationLogger> loggers = new TreeMap<>(); private static final Map<String, ApplicationLogger> loggers = new ConcurrentHashMap<>();
private static LogLevel DEFAULT_LEVEL = LogLevel.ALL; private static volatile LogLevel defaultLevel = LogLevel.ALL;
private static ApplicationLoggerInitializer initializer; private static volatile ApplicationLoggerInitializer initializer;
/** /**
* Need to get the log level from the properties file. * Need to get the log level from the properties file.
@@ -24,7 +24,8 @@ public class ApplicationLoggerFactory {
*/ */
public static void init(ApplicationLoggerInitializer init) { public static void init(ApplicationLoggerInitializer init) {
initializer = init; initializer = init;
DEFAULT_LEVEL = initializer == null ? LogLevel.INFO : initializer.initialize(); LogLevel initializedLevel = initializer == null ? LogLevel.INFO : initializer.initialize();
defaultLevel = initializedLevel == null ? LogLevel.INFO : initializedLevel;
loadLoggers(); loadLoggers();
} }
@@ -60,7 +61,7 @@ public class ApplicationLoggerFactory {
* @return * @return
*/ */
private static LogLevel getDefaultLevel() { private static LogLevel getDefaultLevel() {
return DEFAULT_LEVEL; return defaultLevel;
} }
/** /**
@@ -70,10 +71,8 @@ public class ApplicationLoggerFactory {
* @return the logger represented by the given name * @return the logger represented by the given name
*/ */
public static ApplicationLogger getLogger(String name, LogLevel level) { public static ApplicationLogger getLogger(String name, LogLevel level) {
if (!loggers.containsKey(name)) { ApplicationLogger logger = loggers.computeIfAbsent(name,
loggers.put(name, new ApplicationLogger(name, level)); loggerName -> new ApplicationLogger(loggerName, level == null ? getDefaultLevel() : level));
}
ApplicationLogger logger = loggers.get(name);
if (initializer != null) { if (initializer != null) {
initializer.postGetLogger(logger.getName(), logger.getLogLevel().toName()); initializer.postGetLogger(logger.getName(), logger.getLogLevel().toName());
} }
src/main/java/net/locusworks/logger/LineLoggingOutputStream.java
+60
View File
@@ -0,0 +1,60 @@
package net.locusworks.logger;
import static java.nio.charset.StandardCharsets.UTF_8;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.function.Consumer;
/** Buffers redirected output so each complete UTF-8 line becomes one log event. */
final class LineLoggingOutputStream extends OutputStream {
private final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
private final Consumer<String> sink;
LineLoggingOutputStream(Consumer<String> sink) {
this.sink = sink;
}
@Override
public synchronized void write(int value) {
if (value == '\n') {
emit();
} else {
buffer.write(value);
}
}
@Override
public synchronized void write(byte[] bytes, int offset, int length) {
int end = offset + length;
int start = offset;
for (int index = offset; index < end; index++) {
if (bytes[index] == '\n') {
buffer.write(bytes, start, index - start);
emit();
start = index + 1;
}
}
buffer.write(bytes, start, end - start);
}
@Override
public synchronized void flush() {
if (buffer.size() > 0) emit();
}
@Override
public void close() throws IOException {
flush();
super.close();
}
private void emit() {
byte[] bytes = buffer.toByteArray();
buffer.reset();
int length = bytes.length;
if (length > 0 && bytes[length - 1] == '\r') length--;
sink.accept(new String(bytes, 0, length, UTF_8));
}
}
src/main/java/net/locusworks/logger/LogLevel.java
+6 -5
View File
@@ -16,10 +16,10 @@ public enum LogLevel {
TRACE(1, "TRACE"), TRACE(1, "TRACE"),
ALL(0, "ALL"); ALL(0, "ALL");
private Integer intLevel; private final int intLevel;
private String levelName; private final String levelName;
private LogLevel(Integer intLevel, String levelName) { LogLevel(int intLevel, String levelName) {
this.intLevel = intLevel; this.intLevel = intLevel;
this.levelName = levelName; this.levelName = levelName;
} }
@@ -41,7 +41,7 @@ public enum LogLevel {
* Get the integer representation of the log level * Get the integer representation of the log level
* @return intLevel * @return intLevel
*/ */
public Integer toInt() { public int toInt() {
return this.intLevel; return this.intLevel;
} }
@@ -64,7 +64,7 @@ public enum LogLevel {
*/ */
public static LogLevel getEnum(Integer level) { public static LogLevel getEnum(Integer level) {
for (LogLevel l : values()) { for (LogLevel l : values()) {
if (l.toInt().equals(level)) { if (level != null && l.toInt() == level) {
return l; return l;
} }
} }
@@ -77,6 +77,7 @@ public enum LogLevel {
* @return the log level for the name or null if it cant be found * @return the log level for the name or null if it cant be found
*/ */
public static LogLevel getEnum(String levelName) { public static LogLevel getEnum(String levelName) {
if (levelName == null) return null;
for (LogLevel l : values()) { for (LogLevel l : values()) {
if (l.toName().equalsIgnoreCase(levelName)) { if (l.toName().equalsIgnoreCase(levelName)) {
return l; return l;
src/main/java/net/locusworks/logger/SystemDebugLogger.java
+1 -22
View File
@@ -1,36 +1,15 @@
package net.locusworks.logger; package net.locusworks.logger;
import static java.nio.charset.StandardCharsets.UTF_8;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream; import java.io.PrintStream;
@ApplicationLoggerInfo(name="System.Debug", defaultLevel=LogLevel.DEBUG) @ApplicationLoggerInfo(name="System.Debug", defaultLevel=LogLevel.DEBUG)
public class SystemDebugLogger extends PrintStream { public class SystemDebugLogger extends PrintStream {
private ApplicationLogger logger;
public SystemDebugLogger() { public SystemDebugLogger() {
this(ApplicationLoggerFactory.getLogger(SystemDebugLogger.class)); this(ApplicationLoggerFactory.getLogger(SystemDebugLogger.class));
} }
public SystemDebugLogger(ApplicationLogger logger) { public SystemDebugLogger(ApplicationLogger logger) {
super(new ByteArrayOutputStream()); super(new LineLoggingOutputStream(logger::debug), true);
this.logger = logger;
}
@Override
public void write(byte[] b) {
logger.debug(new String(b, UTF_8));
}
@Override
public void write(byte[] b, int off, int len) {
logger.debug(new String(b, off, len, UTF_8));
}
@Override
public void write(int b) {
write(new byte[] { (byte)b });
} }
} }
src/main/java/net/locusworks/logger/SystemErrLogger.java
+1 -22
View File
@@ -1,36 +1,15 @@
package net.locusworks.logger; package net.locusworks.logger;
import static java.nio.charset.StandardCharsets.UTF_8;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream; import java.io.PrintStream;
@ApplicationLoggerInfo(name="System.Err", defaultLevel=LogLevel.ERROR) @ApplicationLoggerInfo(name="System.Err", defaultLevel=LogLevel.ERROR)
public class SystemErrLogger extends PrintStream { public class SystemErrLogger extends PrintStream {
private ApplicationLogger logger;
public SystemErrLogger() { public SystemErrLogger() {
this(ApplicationLoggerFactory.getLogger(SystemErrLogger.class)); this(ApplicationLoggerFactory.getLogger(SystemErrLogger.class));
} }
public SystemErrLogger(ApplicationLogger logger) { public SystemErrLogger(ApplicationLogger logger) {
super(new ByteArrayOutputStream()); super(new LineLoggingOutputStream(logger::error), true);
this.logger = logger;
}
@Override
public void write(byte[] b) {
logger.error(new String(b, UTF_8));
}
@Override
public void write(byte[] b, int off, int len) {
logger.error(new String(b, off, len, UTF_8));
}
@Override
public void write(int b) {
write(new byte[] { (byte)b });
} }
} }
src/main/java/net/locusworks/logger/SystemOutLogger.java
+1 -22
View File
@@ -1,36 +1,15 @@
package net.locusworks.logger; package net.locusworks.logger;
import static java.nio.charset.StandardCharsets.UTF_8;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream; import java.io.PrintStream;
@ApplicationLoggerInfo(name="System.Out", defaultLevel=LogLevel.OFF) @ApplicationLoggerInfo(name="System.Out", defaultLevel=LogLevel.OFF)
public class SystemOutLogger extends PrintStream { public class SystemOutLogger extends PrintStream {
private ApplicationLogger logger;
public SystemOutLogger() { public SystemOutLogger() {
this(ApplicationLoggerFactory.getLogger(SystemOutLogger.class)); this(ApplicationLoggerFactory.getLogger(SystemOutLogger.class));
} }
public SystemOutLogger(ApplicationLogger logger) { public SystemOutLogger(ApplicationLogger logger) {
super(new ByteArrayOutputStream()); super(new LineLoggingOutputStream(logger::info), true);
this.logger = logger;
}
@Override
public void write(byte[] b) {
logger.info(new String(b, UTF_8));
}
@Override
public void write(byte[] b, int off, int len) {
logger.info(new String(b, off, len, UTF_8));
}
@Override
public void write(int b) {
write(new byte[] { (byte)b });
} }
} }
src/main/resources/log4j.xml
-24
View File
@@ -1,24 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
<Appenders>
<Console name="ConsoleAppender" target="SYSTEM_OUT">
<PatternLayout pattern="%d{dd-MMM-yyyy HH:mm:ss.SSS} %m%n" />
</Console>
<RollingFile name="application" fileName="application.log"
filePattern="$${date:yyyy-MM}/${name}-%d{yyyy-MM-dd}-%i.log.gz">
<PatternLayout>
<pattern>%d{dd-MMM-yyyy HH:mm:ss.SSS} %m%n</pattern>
</PatternLayout>
<Policies>
<TimeBasedTriggeringPolicy />
<SizeBasedTriggeringPolicy size="10 MB" />
</Policies>
</RollingFile>
</Appenders>
<Loggers>
<Root level="INFO">
<AppenderRef ref="ConsoleAppender" />
<AppenderRef ref="application" />
</Root>
</Loggers>
</Configuration>
src/test/java/net/locusworks/logger/ApplicationLoggerDelegationTest.java
+101
View File
@@ -0,0 +1,101 @@
package net.locusworks.logger;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.contains;
import static org.mockito.ArgumentMatchers.same;
import static org.mockito.Mockito.*;
import java.util.LinkedHashMap;
import java.util.Map;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.Marker;
class ApplicationLoggerDelegationTest {
@Test
void delegatesFormattingMarkersAndThrowablesAtEveryLevel() {
Logger delegate = mock(Logger.class);
Marker marker = mock(Marker.class);
RuntimeException failure = new RuntimeException("boom");
when(delegate.getName()).thenReturn("test");
when(delegate.isTraceEnabled()).thenReturn(true);
when(delegate.isDebugEnabled()).thenReturn(true);
when(delegate.isInfoEnabled()).thenReturn(true);
when(delegate.isWarnEnabled()).thenReturn(true);
when(delegate.isErrorEnabled()).thenReturn(true);
when(delegate.isTraceEnabled(marker)).thenReturn(true);
when(delegate.isDebugEnabled(marker)).thenReturn(true);
when(delegate.isInfoEnabled(marker)).thenReturn(true);
when(delegate.isWarnEnabled(marker)).thenReturn(true);
when(delegate.isErrorEnabled(marker)).thenReturn(true);
ApplicationLogger logger = new ApplicationLogger("test", LogLevel.ALL, delegate);
assertEquals("test", logger.getName());
assertTrue(logger.isTraceEnabled());
assertTrue(logger.isDebugEnabled(marker));
assertTrue(logger.isInfoEnabled());
assertTrue(logger.isWarnEnabled(marker));
assertTrue(logger.isErrorEnabled());
logger.trace("trace {}", 1);
logger.trace("trace {} {}", 1, 2);
logger.trace("trace {}", new Object[] {1});
logger.trace("trace failure", failure);
logger.debug("debug {}", 1);
logger.debug("debug {} {}", 1, 2);
logger.debug("debug {}", new Object[] {1});
logger.debug("debug failure", failure);
logger.info("info {}", 1);
logger.info("info {} {}", 1, 2);
logger.info("info {}", new Object[] {1});
logger.info("info failure", failure);
logger.warn("warn {}", 1);
logger.warn("warn {} {}", 1, 2);
logger.warn("warn {}", new Object[] {1});
logger.warn("warn failure", failure);
logger.error("error {}", 1);
logger.error("error {} {}", 1, 2);
logger.error("error {}", new Object[] {1});
logger.error("error failure", failure);
logger.error(failure);
logger.trace(marker, "trace {}", 1);
logger.trace(marker, "trace {} {}", 1, 2);
logger.trace(marker, "trace", new Object[0]);
logger.trace(marker, "trace failure", failure);
logger.debug(marker, "debug {}", 1);
logger.debug(marker, "debug {} {}", 1, 2);
logger.debug(marker, "debug", new Object[0]);
logger.debug(marker, "debug failure", failure);
logger.info(marker, "info {}", 1);
logger.info(marker, "info {} {}", 1, 2);
logger.info(marker, "info", new Object[0]);
logger.info(marker, "info failure", failure);
logger.warn(marker, "warn {}", 1);
logger.warn(marker, "warn {} {}", 1, 2);
logger.warn(marker, "warn", new Object[0]);
logger.warn(marker, "warn failure", failure);
logger.error(marker, "error {}", 1);
logger.error(marker, "error {} {}", 1, 2);
logger.error(marker, "error", new Object[0]);
logger.error(marker, "error failure", failure);
Map<String, String> values = new LinkedHashMap<>();
values.put("a", "one");
values.put("long", "two");
logger.info(values);
logger.warn(values, new StringBuilder("prefix"));
logger.error(values, "%s=%s", new StringBuilder(), failure);
verify(delegate, atLeastOnce()).info(contains("info 1"), org.mockito.ArgumentMatchers.isNull(Throwable.class));
verify(delegate).error("error failure", failure);
verify(delegate).error(marker, "error failure", failure);
verify(delegate).error(contains("a=one"), same(failure));
logger.setLogLevel(LogLevel.OFF);
assertEquals(LogLevel.OFF, logger.getLogLevel());
assertFalse(logger.isErrorEnabled());
logger.error("not logged");
verify(delegate, never()).error(contains("not logged"));
}
}
src/test/java/net/locusworks/logger/ApplicationLoggerFactoryTest.java
+51
View File
@@ -0,0 +1,51 @@
package net.locusworks.logger;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.mockito.ArgumentMatchers.anyMap;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.List;
import org.junit.jupiter.api.Test;
class ApplicationLoggerFactoryTest {
@ApplicationLoggerInfo(name = "annotated-name", defaultLevel = LogLevel.WARN)
private static final class AnnotatedType { }
@Test
void initializesLoadsConfiguresAndSavesLoggers() {
ApplicationLoggerInitializer initializer = mock(ApplicationLoggerInitializer.class);
when(initializer.initialize()).thenReturn(LogLevel.DEBUG);
ApplicationLoggerFactory.init(initializer);
verify(initializer).loadLoggers();
ApplicationLogger annotated = ApplicationLoggerFactory.getLogger(AnnotatedType.class);
assertEquals("annotated-name", annotated.getName());
assertEquals(LogLevel.WARN, annotated.getLogLevel());
verify(initializer).postGetLogger("annotated-name", "WARN");
ApplicationLoggerFactory.setLogLevels(List.of(new ApplicationLoggerFactory.LoggerInfo("annotated-name", "ERROR")));
assertEquals(LogLevel.ERROR, annotated.getLogLevel());
ApplicationLogger added = new ApplicationLogger("added-test", LogLevel.INFO);
ApplicationLoggerFactory.addLogger(added);
assertSame(added, ApplicationLoggerFactory.getLogger("added-test"));
ApplicationLoggerFactory.addLoggers(List.of(new ApplicationLoggerFactory.LoggerInfo("list-test", "TRACE")));
assertEquals(LogLevel.TRACE, ApplicationLoggerFactory.getLogger("list-test").getLogLevel());
ApplicationLoggerFactory.saveLogLevels();
verify(initializer).saveLogLevels(anyMap());
ApplicationLoggerFactory.loadLoggers(null);
ApplicationLoggerFactory.saveLogLevels(null);
}
@Test
void loggerInfoSupportsBeanAccess() {
ApplicationLoggerFactory.LoggerInfo info = new ApplicationLoggerFactory.LoggerInfo();
info.setLogger("logger");
info.setLevel("INFO");
assertEquals("logger", info.getLogger());
assertEquals("INFO", info.getLevel());
}
}
src/test/java/net/locusworks/logger/ApplicationLoggerTest.java
+65
View File
@@ -0,0 +1,65 @@
package net.locusworks.logger;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;
import org.junit.jupiter.api.Test;
class ApplicationLoggerTest {
@Test
void filtersMessagesBelowConfiguredLevel() {
ApplicationLogger logger = new ApplicationLogger("level-test", LogLevel.INFO);
assertTrue(logger.isInfoEnabled());
assertFalse(logger.isDebugEnabled());
}
@Test
void factoryReturnsOneInstanceUnderConcurrency() {
List<ApplicationLogger> results = IntStream.range(0, 100).parallel()
.mapToObj(i -> ApplicationLoggerFactory.getLogger("concurrent-test"))
.toList();
results.forEach(logger -> assertSame(results.get(0), logger));
}
@Test
void supportsSlf4jFormattingAndPreservesThrowable() throws Exception {
PrintStream original = System.err;
ByteArrayOutputStream output = new ByteArrayOutputStream();
try (PrintStream capture = new PrintStream(output, true, UTF_8)) {
System.setErr(capture);
ApplicationLogger logger = new ApplicationLogger("format-test", LogLevel.INFO);
IllegalStateException failure = new IllegalStateException("failure-detail");
logger.info("Hello {}", "world");
logger.error("Operation failed", failure);
} finally {
System.setErr(original);
}
String logged = output.toString(UTF_8);
assertTrue(logged.contains("Hello world"));
assertTrue(logged.contains("IllegalStateException: failure-detail"));
}
@Test
void systemStreamBuffersUtf8ByLine() {
CapturingLogger logger = new CapturingLogger();
try (PrintStream stream = new SystemOutLogger(logger)) {
byte[] text = "héllo\nsecond\n".getBytes(UTF_8);
for (byte value : text) stream.write(value);
}
assertEquals(List.of("héllo", "second"), logger.messages);
}
private static final class CapturingLogger extends ApplicationLogger {
private final List<String> messages = new ArrayList<>();
private CapturingLogger() { super("capture", LogLevel.ALL); }
@Override public void info(String message) { messages.add(message); }
}
}
src/test/java/net/locusworks/logger/LogLevelTest.java
+26
View File
@@ -0,0 +1,26 @@
package net.locusworks.logger;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
class LogLevelTest {
@Test
void convertsNamesAndNumbers() {
for (LogLevel level : LogLevel.values()) {
assertEquals(level, LogLevel.getEnum(level.toInt()));
assertEquals(level, LogLevel.getEnum(level.toName().toLowerCase()));
assertEquals(level.toName(), level.toString());
}
assertNull(LogLevel.getEnum(99));
assertNull(LogLevel.getEnum((Integer) null));
assertNull(LogLevel.getEnum("unknown"));
assertNull(LogLevel.getEnum((String) null));
}
@Test
void comparesSeverityAndHandlesNull() {
assertTrue(LogLevel.INFO.log(LogLevel.DEBUG));
assertFalse(LogLevel.DEBUG.log(LogLevel.INFO));
assertFalse(LogLevel.INFO.log(null));
}
}
src/test/java/net/locusworks/logger/SystemLoggerTest.java
+35
View File
@@ -0,0 +1,35 @@
package net.locusworks.logger;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import java.io.PrintStream;
import org.junit.jupiter.api.Test;
class SystemLoggerTest {
@Test
void routesCompleteLinesToTheirConfiguredLevels() {
ApplicationLogger logger = mock(ApplicationLogger.class);
try (PrintStream out = new SystemOutLogger(logger);
PrintStream err = new SystemErrLogger(logger);
PrintStream debug = new SystemDebugLogger(logger)) {
out.print("out\r\n");
err.print("err\n");
debug.print("debug");
debug.flush();
}
verify(logger).info("out");
verify(logger).error("err");
verify(logger).debug("debug");
}
@Test
void preservesUtf8SplitAcrossIndividualWrites() {
ApplicationLogger logger = mock(ApplicationLogger.class);
try (PrintStream out = new SystemOutLogger(logger)) {
for (byte value : "h\u00e9llo\n".getBytes(UTF_8)) out.write(value);
}
verify(logger).info("h\u00e9llo");
}
}