From d5afd917b062fda43dc1d17dc42a30f47e73cb6a Mon Sep 17 00:00:00 2001 From: Kishore Battula Date: Mon, 29 Jun 2020 16:09:27 +0530 Subject: [PATCH 1/5] Added transaction logging --- .../azure/filters/TransactionLogFilter.java | 119 ++++++++++++++++++ .../osdu/azure/logging/AzureLogger.java | 61 +++++++++ .../filters/TransactionLogFilterTest.java | 81 ++++++++++++ .../osdu/azure/logging/AzureLoggerTest.java | 65 ++++++++++ 4 files changed, 326 insertions(+) create mode 100644 src/main/java/org/opengroup/osdu/azure/filters/TransactionLogFilter.java create mode 100644 src/main/java/org/opengroup/osdu/azure/logging/AzureLogger.java create mode 100644 src/test/java/org/opengroup/osdu/azure/filters/TransactionLogFilterTest.java create mode 100644 src/test/java/org/opengroup/osdu/azure/logging/AzureLoggerTest.java diff --git a/src/main/java/org/opengroup/osdu/azure/filters/TransactionLogFilter.java b/src/main/java/org/opengroup/osdu/azure/filters/TransactionLogFilter.java new file mode 100644 index 00000000..82a12ae1 --- /dev/null +++ b/src/main/java/org/opengroup/osdu/azure/filters/TransactionLogFilter.java @@ -0,0 +1,119 @@ +package org.opengroup.osdu.azure.filters; + +import org.opengroup.osdu.azure.logging.AzureLogger; +import org.opengroup.osdu.core.common.model.http.DpsHeaders; +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; +import org.springframework.stereotype.Component; + +import javax.inject.Inject; +import javax.servlet.Filter; +import javax.servlet.FilterChain; +import javax.servlet.ServletException; +import javax.servlet.ServletRequest; +import javax.servlet.ServletResponse; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; + +/** + * For logging start and end of request. + */ +@Component +@ConditionalOnProperty(value = "logging.transaction.enabled", havingValue = "true", matchIfMissing = false) +public final class TransactionLogFilter implements Filter { + private static final String LOGGER_NAME = "TxnLogger"; + private static final List WHITELIST_HEADERS = Arrays.asList( + DpsHeaders.CORRELATION_ID, + DpsHeaders.DATA_PARTITION_ID, + DpsHeaders.CONTENT_TYPE); + private static final String START_LOG_TEMPLATE = "Start Web-API %s %s %s"; + private static final String END_LOG_TEMPLATE = "End Web-API %s %s %s timeTaken:%d"; + + @Inject + private AzureLogger azureLogger; + + /** + * Filter logic. + * @param servletRequest Request object. + * @param servletResponse Response object. + * @param filterChain Filter Chain object. + * @throws IOException + * @throws ServletException + */ + @Override + public void doFilter(final ServletRequest servletRequest, final ServletResponse servletResponse, + final FilterChain filterChain) throws IOException, ServletException { + final HttpServletRequest httpRequest = (HttpServletRequest) servletRequest; + final HttpServletResponse httpResponse = (HttpServletResponse) servletResponse; + logTransactionStart(httpRequest); + final long start = System.currentTimeMillis(); + filterChain.doFilter(servletRequest, servletResponse); + final long timeTaken = System.currentTimeMillis() - start; + logTransactionEnd(httpRequest, httpResponse, timeTaken); + } + + /** + * Logs start of a request. + * @param request Request Object. + */ + private void logTransactionStart(final HttpServletRequest request) { + azureLogger.info(LOGGER_NAME, String.format(START_LOG_TEMPLATE, request.getMethod(), request.getServletPath(), + getRequestHeadersString(request))); + } + + /** + * Logs end of a request. + * @param request Request object. + * @param response Response object. + * @param timeTaken timeTaken in ms taken for request to complete. + */ + private void logTransactionEnd(final HttpServletRequest request, final HttpServletResponse response, + final long timeTaken) { + azureLogger.info(LOGGER_NAME, String.format(END_LOG_TEMPLATE, request.getMethod(), request.getServletPath(), + getResponseHeadersString(response), timeTaken)); + + } + + /** + * To construct string representation of request headers. + * @param request Request Object. + * @return String representation of request headers. + */ + private String getRequestHeadersString(final HttpServletRequest request) { + return getHeadersString(s -> request.getHeader(s)); + } + + /** + * To construct string representation of response headers. + * @param response Response Object. + * @return String representation of response headers. + */ + private String getResponseHeadersString(final HttpServletResponse response) { + return getHeadersString(s -> response.getHeader(s)); + } + + /** + * Construct string representation of headers. + * @param headerGetter Header value supplier + * @return String representation of headers + */ + private String getHeadersString(final Function headerGetter) { + final StringBuilder headers = new StringBuilder(); + for (String headerName: WHITELIST_HEADERS) { + if (headerGetter.apply(headerName) != null) { + headers.append(headerName); + headers.append(":"); + headers.append(headerGetter.apply(headerName)); + headers.append(","); + } + } + + if (headers.length() != 0) { + headers.deleteCharAt(headers.length() - 1); + } + return String.format("Headers: {%s}", headers.toString()); + } +} diff --git a/src/main/java/org/opengroup/osdu/azure/logging/AzureLogger.java b/src/main/java/org/opengroup/osdu/azure/logging/AzureLogger.java new file mode 100644 index 00000000..59290c23 --- /dev/null +++ b/src/main/java/org/opengroup/osdu/azure/logging/AzureLogger.java @@ -0,0 +1,61 @@ +package org.opengroup.osdu.azure.logging; + +import org.opengroup.osdu.core.common.logging.JaxRsDpsLog; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +/** + * A wrapper on {@link JaxRsDpsLog}. + */ +@Component +public class AzureLogger { + @Autowired + private JaxRsDpsLog jaxRsDpsLog; + + /** + * To log info messages. + * @param loggerName Name of the logger. Generally Fully qualified class name is used. e.g className.class + * @param message Message to log + */ + public void info(final String loggerName, final String message) { + jaxRsDpsLog.info(message); + } + + /** + * To log info messages. + * @param loggerName Name of the logger. Generally Fully qualified class name is used. e.g className.class + * @param message Message to log + */ + public void warn(final String loggerName, final String message) { + jaxRsDpsLog.warning(message); + } + + /** + * To log info messages. + * @param loggerName Name of the logger. Generally Fully qualified class name is used. e.g className.class + * @param message Message to log + * @param e exception to log + */ + public void warn(final String loggerName, final String message, final Exception e) { + jaxRsDpsLog.warning(message, e); + } + + /** + * To log info messages. + * @param loggerName Name of the logger. Generally Fully qualified class name is used. e.g className.class + * @param message Message to log + */ + public void error(final String loggerName, final String message) { + jaxRsDpsLog.error(message); + } + + /** + * To log info messages. + * @param loggerName Name of the logger. Generally Fully qualified class name is used. e.g className.class + * @param message Message to log + * @param e exception to log + */ + public void error(final String loggerName, final String message, final Exception e) { + jaxRsDpsLog.error(message, e); + } +} diff --git a/src/test/java/org/opengroup/osdu/azure/filters/TransactionLogFilterTest.java b/src/test/java/org/opengroup/osdu/azure/filters/TransactionLogFilterTest.java new file mode 100644 index 00000000..52946007 --- /dev/null +++ b/src/test/java/org/opengroup/osdu/azure/filters/TransactionLogFilterTest.java @@ -0,0 +1,81 @@ +package org.opengroup.osdu.azure.filters; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.opengroup.osdu.azure.logging.AzureLogger; +import org.opengroup.osdu.core.common.model.http.DpsHeaders; + +import javax.servlet.FilterChain; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +/** + * Tests for {@link TransactionLogFilter} + */ +@ExtendWith(MockitoExtension.class) +public class TransactionLogFilterTest { + @Mock + private HttpServletRequest servletRequest; + @Mock + private HttpServletResponse servletResponse; + @Mock + private FilterChain filterChain; + @Mock + private AzureLogger azureLogger; + + @InjectMocks + private TransactionLogFilter logFilter; + + @BeforeEach + public void setup() { + + } + + @Test + public void testStartAndEndMessagesAreLoggedProperly() throws Exception { + final String startLogMessage = "Start Web-API PUT records Headers: {correlation-id:abc}"; + final String endMessage = "End Web-API PUT records Headers: {correlation-id:abc} timeTaken:"; + when(servletRequest.getMethod()).thenReturn("PUT"); + when(servletRequest.getServletPath()).thenReturn("records"); + when(servletRequest.getHeader(eq(DpsHeaders.CORRELATION_ID))).thenReturn("abc"); + when(servletResponse.getHeader(eq(DpsHeaders.CORRELATION_ID))).thenReturn("abc"); + final ArgumentCaptor logMessageCaptor = ArgumentCaptor.forClass(String.class); + doNothing().when(azureLogger).info(eq("TxnLogger"), logMessageCaptor.capture()); + this.logFilter.doFilter(servletRequest, servletResponse, filterChain); + verify(servletRequest, times(2)).getMethod(); + verify(servletRequest, times(2)).getServletPath(); + verify(servletRequest, times(2)).getHeader(eq(DpsHeaders.CORRELATION_ID)); + verify(servletResponse, times(2)).getHeader(eq(DpsHeaders.CORRELATION_ID)); + assertEquals(2, logMessageCaptor.getAllValues().size()); + assertEquals(startLogMessage, logMessageCaptor.getAllValues().get(0)); + assertEquals(true, logMessageCaptor.getAllValues().get(1).startsWith(endMessage)); + } + + @Test + public void testStartAndEndMessagesAreLoggedProperlyWithNoHeaders() throws Exception { + final String startLogMessage = "Start Web-API PUT records Headers: {}"; + final String endMessage = "End Web-API PUT records Headers: {} timeTaken:"; + when(servletRequest.getMethod()).thenReturn("PUT"); + when(servletRequest.getServletPath()).thenReturn("records"); + final ArgumentCaptor logMessageCaptor = ArgumentCaptor.forClass(String.class); + doNothing().when(azureLogger).info(eq("TxnLogger"), logMessageCaptor.capture()); + this.logFilter.doFilter(servletRequest, servletResponse, filterChain); + verify(servletRequest, times(2)).getMethod(); + verify(servletRequest, times(2)).getServletPath(); + assertEquals(2, logMessageCaptor.getAllValues().size()); + assertEquals(startLogMessage, logMessageCaptor.getAllValues().get(0)); + assertEquals(true, logMessageCaptor.getAllValues().get(1).startsWith(endMessage)); + } +} diff --git a/src/test/java/org/opengroup/osdu/azure/logging/AzureLoggerTest.java b/src/test/java/org/opengroup/osdu/azure/logging/AzureLoggerTest.java new file mode 100644 index 00000000..8d6fc7c1 --- /dev/null +++ b/src/test/java/org/opengroup/osdu/azure/logging/AzureLoggerTest.java @@ -0,0 +1,65 @@ +package org.opengroup.osdu.azure.logging; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.opengroup.osdu.core.common.logging.JaxRsDpsLog; + +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +/** + * Tests for {@link AzureLogger} + */ +@ExtendWith(MockitoExtension.class) +public class AzureLoggerTest { + private static final String LOGGER_NAME = AzureLoggerTest.class.getName(); + private static final String LOG_MESSAGE = "Hello world"; + private static final Exception EXCEPTION = new Exception(); + + @Mock + private JaxRsDpsLog jaxRsDpsLog; + + @InjectMocks + private AzureLogger azureLogger; + + @Test + public void testInfo() { + doNothing().when(jaxRsDpsLog).info(eq(LOG_MESSAGE)); + azureLogger.info(LOGGER_NAME, LOG_MESSAGE); + verify(jaxRsDpsLog, times(1)).info(eq(LOG_MESSAGE)); + } + + @Test + public void testWarn() { + doNothing().when(jaxRsDpsLog).warning(eq(LOG_MESSAGE)); + azureLogger.warn(LOGGER_NAME, LOG_MESSAGE); + verify(jaxRsDpsLog, times(1)).warning(eq(LOG_MESSAGE)); + } + + @Test + public void testWarnWithException() { + doNothing().when(jaxRsDpsLog).warning(eq(LOG_MESSAGE), eq(EXCEPTION)); + azureLogger.warn(LOGGER_NAME, LOG_MESSAGE, EXCEPTION); + verify(jaxRsDpsLog, times(1)).warning(eq(LOG_MESSAGE), eq(EXCEPTION)); + } + + @Test + public void testError() { + doNothing().when(jaxRsDpsLog).error(eq(LOG_MESSAGE)); + azureLogger.error(LOGGER_NAME, LOG_MESSAGE); + verify(jaxRsDpsLog, times(1)).error(eq(LOG_MESSAGE)); + } + + @Test + public void testErrorWithException() { + doNothing().when(jaxRsDpsLog).error(eq(LOG_MESSAGE), eq(EXCEPTION)); + azureLogger.error(LOGGER_NAME, LOG_MESSAGE, EXCEPTION); + verify(jaxRsDpsLog, times(1)).error(eq(LOG_MESSAGE), eq(EXCEPTION)); + } +} -- GitLab From 4606a338a2f00d6996c8c5d2e4b3f93e857ebb28 Mon Sep 17 00:00:00 2001 From: Kishore Battula Date: Thu, 23 Jul 2020 13:28:29 +0530 Subject: [PATCH 2/5] Added Slf4jLogger Implementation --- pom.xml | 8 +- .../azure/filters/TransactionLogFilter.java | 20 +- .../osdu/azure/logging/AzureLogger.java | 61 ------ .../osdu/azure/logging/Slf4JLogger.java | 110 ++++++++++ .../logging/Slf4JLoggerConfiguration.java | 22 ++ .../azure/logging/Slf4jLoggerFactory.java | 20 ++ src/main/resources/log4j2.xml | 9 +- .../filters/TransactionLogFilterTest.java | 17 +- .../osdu/azure/logging/AzureLoggerTest.java | 65 ------ .../azure/logging/Slf4JLoggerFactoryTest.java | 36 ++++ .../osdu/azure/logging/Slf4JLoggerTest.java | 188 ++++++++++++++++++ 11 files changed, 404 insertions(+), 152 deletions(-) delete mode 100644 src/main/java/org/opengroup/osdu/azure/logging/AzureLogger.java create mode 100644 src/main/java/org/opengroup/osdu/azure/logging/Slf4JLogger.java create mode 100644 src/main/java/org/opengroup/osdu/azure/logging/Slf4JLoggerConfiguration.java create mode 100644 src/main/java/org/opengroup/osdu/azure/logging/Slf4jLoggerFactory.java delete mode 100644 src/test/java/org/opengroup/osdu/azure/logging/AzureLoggerTest.java create mode 100644 src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerFactoryTest.java create mode 100644 src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerTest.java diff --git a/pom.xml b/pom.xml index 46b526d6..d308525b 100644 --- a/pom.xml +++ b/pom.xml @@ -79,7 +79,7 @@ org.opengroup.osdu os-core-common - 0.0.13 + 0.3.4 @@ -124,12 +124,6 @@ org.springframework.boot spring-boot-starter-log4j2 2.2.4.RELEASE - - - org.apache.logging.log4j - log4j-slf4j-impl - - com.microsoft.azure diff --git a/src/main/java/org/opengroup/osdu/azure/filters/TransactionLogFilter.java b/src/main/java/org/opengroup/osdu/azure/filters/TransactionLogFilter.java index 82a12ae1..bc25f295 100644 --- a/src/main/java/org/opengroup/osdu/azure/filters/TransactionLogFilter.java +++ b/src/main/java/org/opengroup/osdu/azure/filters/TransactionLogFilter.java @@ -1,11 +1,11 @@ package org.opengroup.osdu.azure.filters; -import org.opengroup.osdu.azure.logging.AzureLogger; +import org.opengroup.osdu.core.common.logging.JaxRsDpsLog; import org.opengroup.osdu.core.common.model.http.DpsHeaders; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.stereotype.Component; -import javax.inject.Inject; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.ServletException; @@ -30,10 +30,10 @@ public final class TransactionLogFilter implements Filter { DpsHeaders.DATA_PARTITION_ID, DpsHeaders.CONTENT_TYPE); private static final String START_LOG_TEMPLATE = "Start Web-API %s %s %s"; - private static final String END_LOG_TEMPLATE = "End Web-API %s %s %s timeTaken:%d"; + private static final String END_LOG_TEMPLATE = "End Web-API %s %s %s status=%d time=%d ms"; - @Inject - private AzureLogger azureLogger; + @Autowired + private JaxRsDpsLog jaxRsDpsLog; /** * Filter logic. @@ -60,7 +60,7 @@ public final class TransactionLogFilter implements Filter { * @param request Request Object. */ private void logTransactionStart(final HttpServletRequest request) { - azureLogger.info(LOGGER_NAME, String.format(START_LOG_TEMPLATE, request.getMethod(), request.getServletPath(), + jaxRsDpsLog.info(LOGGER_NAME, String.format(START_LOG_TEMPLATE, request.getMethod(), request.getServletPath(), getRequestHeadersString(request))); } @@ -72,8 +72,8 @@ public final class TransactionLogFilter implements Filter { */ private void logTransactionEnd(final HttpServletRequest request, final HttpServletResponse response, final long timeTaken) { - azureLogger.info(LOGGER_NAME, String.format(END_LOG_TEMPLATE, request.getMethod(), request.getServletPath(), - getResponseHeadersString(response), timeTaken)); + jaxRsDpsLog.info(LOGGER_NAME, String.format(END_LOG_TEMPLATE, request.getMethod(), request.getServletPath(), + getResponseHeadersString(response), response.getStatus(), timeTaken)); } @@ -83,7 +83,7 @@ public final class TransactionLogFilter implements Filter { * @return String representation of request headers. */ private String getRequestHeadersString(final HttpServletRequest request) { - return getHeadersString(s -> request.getHeader(s)); + return getHeadersString(request::getHeader); } /** @@ -92,7 +92,7 @@ public final class TransactionLogFilter implements Filter { * @return String representation of response headers. */ private String getResponseHeadersString(final HttpServletResponse response) { - return getHeadersString(s -> response.getHeader(s)); + return getHeadersString(response::getHeader); } /** diff --git a/src/main/java/org/opengroup/osdu/azure/logging/AzureLogger.java b/src/main/java/org/opengroup/osdu/azure/logging/AzureLogger.java deleted file mode 100644 index 59290c23..00000000 --- a/src/main/java/org/opengroup/osdu/azure/logging/AzureLogger.java +++ /dev/null @@ -1,61 +0,0 @@ -package org.opengroup.osdu.azure.logging; - -import org.opengroup.osdu.core.common.logging.JaxRsDpsLog; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.stereotype.Component; - -/** - * A wrapper on {@link JaxRsDpsLog}. - */ -@Component -public class AzureLogger { - @Autowired - private JaxRsDpsLog jaxRsDpsLog; - - /** - * To log info messages. - * @param loggerName Name of the logger. Generally Fully qualified class name is used. e.g className.class - * @param message Message to log - */ - public void info(final String loggerName, final String message) { - jaxRsDpsLog.info(message); - } - - /** - * To log info messages. - * @param loggerName Name of the logger. Generally Fully qualified class name is used. e.g className.class - * @param message Message to log - */ - public void warn(final String loggerName, final String message) { - jaxRsDpsLog.warning(message); - } - - /** - * To log info messages. - * @param loggerName Name of the logger. Generally Fully qualified class name is used. e.g className.class - * @param message Message to log - * @param e exception to log - */ - public void warn(final String loggerName, final String message, final Exception e) { - jaxRsDpsLog.warning(message, e); - } - - /** - * To log info messages. - * @param loggerName Name of the logger. Generally Fully qualified class name is used. e.g className.class - * @param message Message to log - */ - public void error(final String loggerName, final String message) { - jaxRsDpsLog.error(message); - } - - /** - * To log info messages. - * @param loggerName Name of the logger. Generally Fully qualified class name is used. e.g className.class - * @param message Message to log - * @param e exception to log - */ - public void error(final String loggerName, final String message, final Exception e) { - jaxRsDpsLog.error(message, e); - } -} diff --git a/src/main/java/org/opengroup/osdu/azure/logging/Slf4JLogger.java b/src/main/java/org/opengroup/osdu/azure/logging/Slf4JLogger.java new file mode 100644 index 00000000..7cbf148e --- /dev/null +++ b/src/main/java/org/opengroup/osdu/azure/logging/Slf4JLogger.java @@ -0,0 +1,110 @@ +package org.opengroup.osdu.azure.logging; + +import org.opengroup.osdu.core.common.logging.ILogger; +import org.opengroup.osdu.core.common.logging.audit.AuditPayload; +import org.opengroup.osdu.core.common.model.http.HeadersToLog; +import org.opengroup.osdu.core.common.model.http.Request; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; +import org.springframework.context.annotation.Primary; +import org.springframework.stereotype.Component; +import java.util.Map; + +/** + * {@link ILogger} implementation with Slf4J Logger. + */ +@Component +@Primary +@ConditionalOnProperty(value = "logging.slf4jlogger.enabled", havingValue = "true", matchIfMissing = false) +public final class Slf4JLogger implements ILogger { + private static final String DEFAULT_LOGGER_NAME = Slf4JLogger.class.getName(); + + @Autowired + private HeadersToLog headersToLog; + + @Autowired + private Slf4jLoggerFactory slf4jLoggerFactory; + + @Override + public void audit(final String logPrefix, final AuditPayload auditPayload, final Map headers) { + this.audit(DEFAULT_LOGGER_NAME, logPrefix, auditPayload, headers); + } + + @Override + public void audit(final String loggerName, final String logPrefix, final AuditPayload payload, final Map headers) { + slf4jLoggerFactory.getLogger(loggerName).info("{} {} {}", logPrefix, payload, + this.headersToLog.createStandardLabelsFromMap(headers)); + } + + @Override + public void request(final String logPrefix, final Request request, final Map headers) { + this.request(DEFAULT_LOGGER_NAME, logPrefix, request, headers); + } + + @Override + public void request(final String loggerName, final String logPrefix, final Request request, final Map headers) { + slf4jLoggerFactory.getLogger(loggerName).info("{} {} {}", logPrefix, request, + this.headersToLog.createStandardLabelsFromMap(headers)); + } + + @Override + public void info(final String logPrefix, final String message, final Map headers) { + this.info(DEFAULT_LOGGER_NAME, logPrefix, message, headers); + } + + @Override + public void info(final String loggerName, final String logPrefix, final String message, final Map headers) { + slf4jLoggerFactory.getLogger(loggerName).info("{} {} {}", logPrefix, message, + this.headersToLog.createStandardLabelsFromMap(headers)); + } + + @Override + public void warning(final String logPrefix, final String message, final Map headers) { + this.warning(DEFAULT_LOGGER_NAME, logPrefix, message, headers); + } + + @Override + public void warning(final String loggerName, final String logPrefix, final String message, final Map headers) { + slf4jLoggerFactory.getLogger(loggerName).warn("{} {} {}", logPrefix, message, + this.headersToLog.createStandardLabelsFromMap(headers)); + } + + @Override + public void warning(final String logPrefix, final String message, final Exception e, final Map headers) { + this.warning(DEFAULT_LOGGER_NAME, logPrefix, message, e, headers); + } + + @Override + public void warning(final String loggerName, final String logPrefix, final String message, final Exception ex, final Map headers) { + slf4jLoggerFactory.getLogger(loggerName).warn("{} {} {}", logPrefix, message, + this.headersToLog.createStandardLabelsFromMap(headers), ex); + } + + @Override + public void error(final String logPrefix, final String message, final Map headers) { + this.error(DEFAULT_LOGGER_NAME, logPrefix, message, headers); + } + + @Override + public void error(final String loggerName, final String logPrefix, final String message, final Map headers) { + slf4jLoggerFactory.getLogger(loggerName).error("{} {} {}", logPrefix, message, + this.headersToLog.createStandardLabelsFromMap(headers)); + } + + @Override + public void error(final String logPrefix, final String message, final Exception e, + final Map headers) { + this.error(DEFAULT_LOGGER_NAME, logPrefix, message, e, headers); + } + + @Override + public void error(final String loggerName, final String logPrefix, final String message, final Exception ex, final Map headers) { + slf4jLoggerFactory.getLogger(loggerName).error("{} {} {}", logPrefix, message, + this.headersToLog.createStandardLabelsFromMap(headers), ex); + } + + @Override + public void close() throws Exception { + // do nothing + } +} diff --git a/src/main/java/org/opengroup/osdu/azure/logging/Slf4JLoggerConfiguration.java b/src/main/java/org/opengroup/osdu/azure/logging/Slf4JLoggerConfiguration.java new file mode 100644 index 00000000..b25606c8 --- /dev/null +++ b/src/main/java/org/opengroup/osdu/azure/logging/Slf4JLoggerConfiguration.java @@ -0,0 +1,22 @@ +package org.opengroup.osdu.azure.logging; + +import org.opengroup.osdu.core.common.model.http.HeadersToLog; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +import java.util.Collections; + +/** + * Creating beans needed for Slf4JLogger. + */ +@Configuration +public class Slf4JLoggerConfiguration { + /** + * Bean for HeadersToLog used in {@link Slf4JLogger}. + * @return {@link HeadersToLog} instance + */ + @Bean + public HeadersToLog headersToLog() { + return new HeadersToLog(Collections.emptyList()); + } +} diff --git a/src/main/java/org/opengroup/osdu/azure/logging/Slf4jLoggerFactory.java b/src/main/java/org/opengroup/osdu/azure/logging/Slf4jLoggerFactory.java new file mode 100644 index 00000000..1a12aa45 --- /dev/null +++ b/src/main/java/org/opengroup/osdu/azure/logging/Slf4jLoggerFactory.java @@ -0,0 +1,20 @@ +package org.opengroup.osdu.azure.logging; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Component; + +/** + * Factory for slf4j logger instances. + */ +@Component +public final class Slf4jLoggerFactory { + /** + * Returns slf4j logger instance based on name. + * @param loggerName name of the logger + * @return {@link Logger} instance + */ + public Logger getLogger(final String loggerName) { + return LoggerFactory.getLogger(loggerName); + } +} diff --git a/src/main/resources/log4j2.xml b/src/main/resources/log4j2.xml index 73989b11..4076cec3 100644 --- a/src/main/resources/log4j2.xml +++ b/src/main/resources/log4j2.xml @@ -23,15 +23,20 @@ - + - + + + + + + \ No newline at end of file diff --git a/src/test/java/org/opengroup/osdu/azure/filters/TransactionLogFilterTest.java b/src/test/java/org/opengroup/osdu/azure/filters/TransactionLogFilterTest.java index 52946007..1559a2f8 100644 --- a/src/test/java/org/opengroup/osdu/azure/filters/TransactionLogFilterTest.java +++ b/src/test/java/org/opengroup/osdu/azure/filters/TransactionLogFilterTest.java @@ -7,7 +7,7 @@ import org.mockito.ArgumentCaptor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import org.opengroup.osdu.azure.logging.AzureLogger; +import org.opengroup.osdu.core.common.logging.JaxRsDpsLog; import org.opengroup.osdu.core.common.model.http.DpsHeaders; import javax.servlet.FilterChain; @@ -26,6 +26,7 @@ import static org.mockito.Mockito.when; */ @ExtendWith(MockitoExtension.class) public class TransactionLogFilterTest { + private static final int STATUS_CODE = 200; @Mock private HttpServletRequest servletRequest; @Mock @@ -33,31 +34,32 @@ public class TransactionLogFilterTest { @Mock private FilterChain filterChain; @Mock - private AzureLogger azureLogger; + private JaxRsDpsLog jaxRsDpsLog; @InjectMocks private TransactionLogFilter logFilter; @BeforeEach public void setup() { - + when(servletResponse.getStatus()).thenReturn(STATUS_CODE); } @Test public void testStartAndEndMessagesAreLoggedProperly() throws Exception { final String startLogMessage = "Start Web-API PUT records Headers: {correlation-id:abc}"; - final String endMessage = "End Web-API PUT records Headers: {correlation-id:abc} timeTaken:"; + final String endMessage = "End Web-API PUT records Headers: {correlation-id:abc} status=200 time="; when(servletRequest.getMethod()).thenReturn("PUT"); when(servletRequest.getServletPath()).thenReturn("records"); when(servletRequest.getHeader(eq(DpsHeaders.CORRELATION_ID))).thenReturn("abc"); when(servletResponse.getHeader(eq(DpsHeaders.CORRELATION_ID))).thenReturn("abc"); final ArgumentCaptor logMessageCaptor = ArgumentCaptor.forClass(String.class); - doNothing().when(azureLogger).info(eq("TxnLogger"), logMessageCaptor.capture()); + doNothing().when(jaxRsDpsLog).info(eq("TxnLogger"), logMessageCaptor.capture()); this.logFilter.doFilter(servletRequest, servletResponse, filterChain); verify(servletRequest, times(2)).getMethod(); verify(servletRequest, times(2)).getServletPath(); verify(servletRequest, times(2)).getHeader(eq(DpsHeaders.CORRELATION_ID)); verify(servletResponse, times(2)).getHeader(eq(DpsHeaders.CORRELATION_ID)); + verify(servletResponse, times(1)).getStatus(); assertEquals(2, logMessageCaptor.getAllValues().size()); assertEquals(startLogMessage, logMessageCaptor.getAllValues().get(0)); assertEquals(true, logMessageCaptor.getAllValues().get(1).startsWith(endMessage)); @@ -66,14 +68,15 @@ public class TransactionLogFilterTest { @Test public void testStartAndEndMessagesAreLoggedProperlyWithNoHeaders() throws Exception { final String startLogMessage = "Start Web-API PUT records Headers: {}"; - final String endMessage = "End Web-API PUT records Headers: {} timeTaken:"; + final String endMessage = "End Web-API PUT records Headers: {} status=200 time="; when(servletRequest.getMethod()).thenReturn("PUT"); when(servletRequest.getServletPath()).thenReturn("records"); final ArgumentCaptor logMessageCaptor = ArgumentCaptor.forClass(String.class); - doNothing().when(azureLogger).info(eq("TxnLogger"), logMessageCaptor.capture()); + doNothing().when(jaxRsDpsLog).info(eq("TxnLogger"), logMessageCaptor.capture()); this.logFilter.doFilter(servletRequest, servletResponse, filterChain); verify(servletRequest, times(2)).getMethod(); verify(servletRequest, times(2)).getServletPath(); + verify(servletResponse, times(1)).getStatus(); assertEquals(2, logMessageCaptor.getAllValues().size()); assertEquals(startLogMessage, logMessageCaptor.getAllValues().get(0)); assertEquals(true, logMessageCaptor.getAllValues().get(1).startsWith(endMessage)); diff --git a/src/test/java/org/opengroup/osdu/azure/logging/AzureLoggerTest.java b/src/test/java/org/opengroup/osdu/azure/logging/AzureLoggerTest.java deleted file mode 100644 index 8d6fc7c1..00000000 --- a/src/test/java/org/opengroup/osdu/azure/logging/AzureLoggerTest.java +++ /dev/null @@ -1,65 +0,0 @@ -package org.opengroup.osdu.azure.logging; - -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; -import org.mockito.junit.jupiter.MockitoExtension; -import org.opengroup.osdu.core.common.logging.JaxRsDpsLog; - -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.doNothing; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; - -/** - * Tests for {@link AzureLogger} - */ -@ExtendWith(MockitoExtension.class) -public class AzureLoggerTest { - private static final String LOGGER_NAME = AzureLoggerTest.class.getName(); - private static final String LOG_MESSAGE = "Hello world"; - private static final Exception EXCEPTION = new Exception(); - - @Mock - private JaxRsDpsLog jaxRsDpsLog; - - @InjectMocks - private AzureLogger azureLogger; - - @Test - public void testInfo() { - doNothing().when(jaxRsDpsLog).info(eq(LOG_MESSAGE)); - azureLogger.info(LOGGER_NAME, LOG_MESSAGE); - verify(jaxRsDpsLog, times(1)).info(eq(LOG_MESSAGE)); - } - - @Test - public void testWarn() { - doNothing().when(jaxRsDpsLog).warning(eq(LOG_MESSAGE)); - azureLogger.warn(LOGGER_NAME, LOG_MESSAGE); - verify(jaxRsDpsLog, times(1)).warning(eq(LOG_MESSAGE)); - } - - @Test - public void testWarnWithException() { - doNothing().when(jaxRsDpsLog).warning(eq(LOG_MESSAGE), eq(EXCEPTION)); - azureLogger.warn(LOGGER_NAME, LOG_MESSAGE, EXCEPTION); - verify(jaxRsDpsLog, times(1)).warning(eq(LOG_MESSAGE), eq(EXCEPTION)); - } - - @Test - public void testError() { - doNothing().when(jaxRsDpsLog).error(eq(LOG_MESSAGE)); - azureLogger.error(LOGGER_NAME, LOG_MESSAGE); - verify(jaxRsDpsLog, times(1)).error(eq(LOG_MESSAGE)); - } - - @Test - public void testErrorWithException() { - doNothing().when(jaxRsDpsLog).error(eq(LOG_MESSAGE), eq(EXCEPTION)); - azureLogger.error(LOGGER_NAME, LOG_MESSAGE, EXCEPTION); - verify(jaxRsDpsLog, times(1)).error(eq(LOG_MESSAGE), eq(EXCEPTION)); - } -} diff --git a/src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerFactoryTest.java b/src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerFactoryTest.java new file mode 100644 index 00000000..05a08982 --- /dev/null +++ b/src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerFactoryTest.java @@ -0,0 +1,36 @@ +package org.opengroup.osdu.azure.logging; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.junit.jupiter.MockitoExtension; +import org.slf4j.Logger; + +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertSame; + +/** + * Contains tests for {@link Slf4jLoggerFactory} + */ +@ExtendWith(MockitoExtension.class) +public class Slf4JLoggerFactoryTest { + private static final String LOGGER_NAME1 = Slf4JLoggerFactoryTest.class.getName(); + private static final String LOGGER_NAME2 = Slf4jLoggerFactory.class.getName(); + + @InjectMocks + private Slf4jLoggerFactory slf4jLoggerFactory; + + @Test + public void testSameLoggerInstanceReturnedWhenCalledWithSameName() { + final Logger logger1 = slf4jLoggerFactory.getLogger(LOGGER_NAME1); + final Logger logger2 = slf4jLoggerFactory.getLogger(LOGGER_NAME1); + assertSame(logger1, logger2, "when called with same name, it should return same instance"); + } + + @Test + public void testDifferentLoggerInstanceReturnedWhenCalledWithDifferentName() { + final Logger logger1 = slf4jLoggerFactory.getLogger(LOGGER_NAME1); + final Logger logger2 = slf4jLoggerFactory.getLogger(LOGGER_NAME2); + assertNotEquals(logger1, logger2, "when called with different names, it should return different instances"); + } +} diff --git a/src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerTest.java b/src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerTest.java new file mode 100644 index 00000000..a2935db2 --- /dev/null +++ b/src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerTest.java @@ -0,0 +1,188 @@ +package org.opengroup.osdu.azure.logging; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.opengroup.osdu.core.common.logging.audit.AuditPayload; +import org.opengroup.osdu.core.common.model.http.HeadersToLog; +import org.opengroup.osdu.core.common.model.http.Request; +import org.slf4j.Logger; + +import java.util.HashMap; +import java.util.Map; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +/** + * Contains tests for {@link Slf4JLogger} + */ +@ExtendWith(MockitoExtension.class) +public class Slf4JLoggerTest { + private static final String LOG_PREFIX = "services.app"; + private static final String DEFAULT_LOGGER_NAME = Slf4JLogger.class.getName(); + private static final String LOGGER_NAME = Slf4JLoggerTest.class.getName(); + private static final String LOG_MESSAGE = "Hello world !"; + + @Mock + private HeadersToLog headersToLog; + + @Mock + private AuditPayload auditPayload; + + @Mock + private Slf4jLoggerFactory slf4jLoggerFactory; + + @Mock + private Request request; + + @Mock + private Logger logger; + + @Mock + private Exception e; + + private final Map headers = new HashMap<>(); + + @InjectMocks + Slf4JLogger slf4JLogger; + + @BeforeEach + public void setup() { + when(slf4jLoggerFactory.getLogger(any())).thenReturn(logger); + when(headersToLog.createStandardLabelsFromMap(eq(headers))).thenReturn(headers); + } + + @Test + public void testAudit() { + doNothing().when(logger).info(eq("{} {} {}"), eq(LOG_PREFIX), eq(auditPayload), eq(headers)); + slf4JLogger.audit(LOG_PREFIX, auditPayload, headers); + verify(logger, times(1)).info(eq("{} {} {}"), eq(LOG_PREFIX), eq(auditPayload), eq(headers)); + verify(slf4jLoggerFactory, times(1)).getLogger(eq(DEFAULT_LOGGER_NAME)); + verify(headersToLog, times(1)).createStandardLabelsFromMap(eq(headers)); + } + + @Test + public void testAuditWithLoggerName() { + doNothing().when(logger).info(eq("{} {} {}"), eq(LOG_PREFIX), eq(auditPayload), eq(headers)); + slf4JLogger.audit(LOGGER_NAME, LOG_PREFIX, auditPayload, headers); + verify(logger, times(1)).info(eq("{} {} {}"), eq(LOG_PREFIX), eq(auditPayload), eq(headers)); + verify(slf4jLoggerFactory, times(1)).getLogger(eq(LOGGER_NAME)); + verify(headersToLog, times(1)).createStandardLabelsFromMap(eq(headers)); + } + + @Test + public void testRequest() { + doNothing().when(logger).info(eq("{} {} {}"), eq(LOG_PREFIX), eq(request), eq(headers)); + slf4JLogger.request(LOG_PREFIX, request, headers); + verify(logger, times(1)).info(eq("{} {} {}"), eq(LOG_PREFIX), eq(request), eq(headers)); + verify(slf4jLoggerFactory, times(1)).getLogger(eq(DEFAULT_LOGGER_NAME)); + verify(headersToLog, times(1)).createStandardLabelsFromMap(eq(headers)); + } + + @Test + public void testRequestWithLoggerName() { + doNothing().when(logger).info(eq("{} {} {}"), eq(LOG_PREFIX), eq(request), eq(headers)); + slf4JLogger.request(LOGGER_NAME, LOG_PREFIX, request, headers); + verify(logger, times(1)).info(eq("{} {} {}"), eq(LOG_PREFIX), eq(request), eq(headers)); + verify(slf4jLoggerFactory, times(1)).getLogger(eq(LOGGER_NAME)); + verify(headersToLog, times(1)).createStandardLabelsFromMap(eq(headers)); + } + + @Test + public void testInfo() { + doNothing().when(logger).info(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers)); + slf4JLogger.info(LOG_PREFIX, LOG_MESSAGE, headers); + verify(logger, times(1)).info(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers)); + verify(slf4jLoggerFactory, times(1)).getLogger(eq(DEFAULT_LOGGER_NAME)); + verify(headersToLog, times(1)).createStandardLabelsFromMap(eq(headers)); + } + + @Test + public void testInfoWithLoggerName() { + doNothing().when(logger).info(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers)); + slf4JLogger.info(LOGGER_NAME, LOG_PREFIX, LOG_MESSAGE, headers); + verify(logger, times(1)).info(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers)); + verify(slf4jLoggerFactory, times(1)).getLogger(eq(LOGGER_NAME)); + verify(headersToLog, times(1)).createStandardLabelsFromMap(eq(headers)); + } + + @Test + public void testWarning() { + doNothing().when(logger).warn(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers)); + slf4JLogger.warning(LOG_PREFIX, LOG_MESSAGE, headers); + verify(logger, times(1)).warn(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers)); + verify(slf4jLoggerFactory, times(1)).getLogger(eq(DEFAULT_LOGGER_NAME)); + verify(headersToLog, times(1)).createStandardLabelsFromMap(eq(headers)); + } + + @Test + public void testWarningWithLoggerName() { + doNothing().when(logger).warn(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers)); + slf4JLogger.warning(LOGGER_NAME, LOG_PREFIX, LOG_MESSAGE, headers); + verify(logger, times(1)).warn(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers)); + verify(slf4jLoggerFactory, times(1)).getLogger(eq(LOGGER_NAME)); + verify(headersToLog, times(1)).createStandardLabelsFromMap(eq(headers)); + } + + @Test + public void testWarningWithException() { + doNothing().when(logger).warn(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers), eq(e)); + slf4JLogger.warning(LOG_PREFIX, LOG_MESSAGE, e, headers); + verify(logger, times(1)).warn(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers), eq(e)); + verify(slf4jLoggerFactory, times(1)).getLogger(eq(DEFAULT_LOGGER_NAME)); + verify(headersToLog, times(1)).createStandardLabelsFromMap(eq(headers)); + } + + @Test + public void testWarningWithExceptionAndLoggerName() { + doNothing().when(logger).warn(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers), eq(e)); + slf4JLogger.warning(LOGGER_NAME, LOG_PREFIX, LOG_MESSAGE, e, headers); + verify(logger, times(1)).warn(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers), eq(e)); + verify(slf4jLoggerFactory, times(1)).getLogger(eq(LOGGER_NAME)); + verify(headersToLog, times(1)).createStandardLabelsFromMap(eq(headers)); + } + + @Test + public void testError() { + doNothing().when(logger).error(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers)); + slf4JLogger.error(LOG_PREFIX, LOG_MESSAGE, headers); + verify(logger, times(1)).error(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers)); + verify(slf4jLoggerFactory, times(1)).getLogger(eq(DEFAULT_LOGGER_NAME)); + verify(headersToLog, times(1)).createStandardLabelsFromMap(eq(headers)); + } + + @Test + public void testErrorWithLoggerName() { + doNothing().when(logger).error(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers)); + slf4JLogger.error(LOGGER_NAME, LOG_PREFIX, LOG_MESSAGE, headers); + verify(logger, times(1)).error(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers)); + verify(slf4jLoggerFactory, times(1)).getLogger(eq(LOGGER_NAME)); + verify(headersToLog, times(1)).createStandardLabelsFromMap(eq(headers)); + } + + @Test + public void testErrorWithException() { + doNothing().when(logger).error(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers), eq(e)); + slf4JLogger.error(LOG_PREFIX, LOG_MESSAGE, e, headers); + verify(logger, times(1)).error(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers), eq(e)); + verify(slf4jLoggerFactory, times(1)).getLogger(eq(DEFAULT_LOGGER_NAME)); + verify(headersToLog, times(1)).createStandardLabelsFromMap(eq(headers)); + } + + @Test + public void testErrorWithExceptionAndLoggerName() { + doNothing().when(logger).error(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers), eq(e)); + slf4JLogger.error(LOGGER_NAME, LOG_PREFIX, LOG_MESSAGE, e, headers); + verify(logger, times(1)).error(eq("{} {} {}"), eq(LOG_PREFIX), eq(LOG_MESSAGE), eq(headers), eq(e)); + verify(slf4jLoggerFactory, times(1)).getLogger(eq(LOGGER_NAME)); + verify(headersToLog, times(1)).createStandardLabelsFromMap(eq(headers)); + } +} -- GitLab From 1103cffed17dc19ec6308cf640626ec1659b8512 Mon Sep 17 00:00:00 2001 From: Kishore Battula Date: Thu, 23 Jul 2020 13:29:46 +0530 Subject: [PATCH 3/5] Incremented pom version to 0.0.11 --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index d308525b..33c4dcd2 100644 --- a/pom.xml +++ b/pom.xml @@ -21,7 +21,7 @@ org.opengroup.osdu core-lib-azure jar - 0.0.10 + 0.0.11 core-lib-azure -- GitLab From 23362df3936baf7d2b647a4280449a9a86f1baa6 Mon Sep 17 00:00:00 2001 From: Kishore Battula Date: Fri, 24 Jul 2020 12:33:08 +0530 Subject: [PATCH 4/5] Added Licence statement --- .../osdu/azure/filters/TransactionLogFilter.java | 14 ++++++++++++++ .../opengroup/osdu/azure/logging/Slf4JLogger.java | 14 ++++++++++++++ .../azure/logging/Slf4JLoggerConfiguration.java | 14 ++++++++++++++ .../osdu/azure/logging/Slf4jLoggerFactory.java | 14 ++++++++++++++ .../azure/filters/TransactionLogFilterTest.java | 14 ++++++++++++++ .../osdu/azure/logging/Slf4JLoggerFactoryTest.java | 14 ++++++++++++++ .../osdu/azure/logging/Slf4JLoggerTest.java | 14 ++++++++++++++ 7 files changed, 98 insertions(+) diff --git a/src/main/java/org/opengroup/osdu/azure/filters/TransactionLogFilter.java b/src/main/java/org/opengroup/osdu/azure/filters/TransactionLogFilter.java index bc25f295..63a43244 100644 --- a/src/main/java/org/opengroup/osdu/azure/filters/TransactionLogFilter.java +++ b/src/main/java/org/opengroup/osdu/azure/filters/TransactionLogFilter.java @@ -1,3 +1,17 @@ +// Copyright © Microsoft Corporation +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + package org.opengroup.osdu.azure.filters; import org.opengroup.osdu.core.common.logging.JaxRsDpsLog; diff --git a/src/main/java/org/opengroup/osdu/azure/logging/Slf4JLogger.java b/src/main/java/org/opengroup/osdu/azure/logging/Slf4JLogger.java index 7cbf148e..26d6296b 100644 --- a/src/main/java/org/opengroup/osdu/azure/logging/Slf4JLogger.java +++ b/src/main/java/org/opengroup/osdu/azure/logging/Slf4JLogger.java @@ -1,3 +1,17 @@ +// Copyright © Microsoft Corporation +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + package org.opengroup.osdu.azure.logging; import org.opengroup.osdu.core.common.logging.ILogger; diff --git a/src/main/java/org/opengroup/osdu/azure/logging/Slf4JLoggerConfiguration.java b/src/main/java/org/opengroup/osdu/azure/logging/Slf4JLoggerConfiguration.java index b25606c8..9d8e0871 100644 --- a/src/main/java/org/opengroup/osdu/azure/logging/Slf4JLoggerConfiguration.java +++ b/src/main/java/org/opengroup/osdu/azure/logging/Slf4JLoggerConfiguration.java @@ -1,3 +1,17 @@ +// Copyright © Microsoft Corporation +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + package org.opengroup.osdu.azure.logging; import org.opengroup.osdu.core.common.model.http.HeadersToLog; diff --git a/src/main/java/org/opengroup/osdu/azure/logging/Slf4jLoggerFactory.java b/src/main/java/org/opengroup/osdu/azure/logging/Slf4jLoggerFactory.java index 1a12aa45..973f173e 100644 --- a/src/main/java/org/opengroup/osdu/azure/logging/Slf4jLoggerFactory.java +++ b/src/main/java/org/opengroup/osdu/azure/logging/Slf4jLoggerFactory.java @@ -1,3 +1,17 @@ +// Copyright © Microsoft Corporation +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + package org.opengroup.osdu.azure.logging; import org.slf4j.Logger; diff --git a/src/test/java/org/opengroup/osdu/azure/filters/TransactionLogFilterTest.java b/src/test/java/org/opengroup/osdu/azure/filters/TransactionLogFilterTest.java index 1559a2f8..acb2c6a8 100644 --- a/src/test/java/org/opengroup/osdu/azure/filters/TransactionLogFilterTest.java +++ b/src/test/java/org/opengroup/osdu/azure/filters/TransactionLogFilterTest.java @@ -1,3 +1,17 @@ +// Copyright © Microsoft Corporation +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + package org.opengroup.osdu.azure.filters; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerFactoryTest.java b/src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerFactoryTest.java index 05a08982..1bdd8376 100644 --- a/src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerFactoryTest.java +++ b/src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerFactoryTest.java @@ -1,3 +1,17 @@ +// Copyright © Microsoft Corporation +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + package org.opengroup.osdu.azure.logging; import org.junit.jupiter.api.Test; diff --git a/src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerTest.java b/src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerTest.java index a2935db2..6bf151a0 100644 --- a/src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerTest.java +++ b/src/test/java/org/opengroup/osdu/azure/logging/Slf4JLoggerTest.java @@ -1,3 +1,17 @@ +// Copyright © Microsoft Corporation +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + package org.opengroup.osdu.azure.logging; import org.junit.jupiter.api.BeforeEach; -- GitLab From 36464f36f12d368d8a69ac3364a071a66e0a5ae3 Mon Sep 17 00:00:00 2001 From: Daniel Scholl Date: Fri, 24 Jul 2020 10:39:13 -0400 Subject: [PATCH 5/5] Update NOTICE --- NOTICE | 1 + 1 file changed, 1 insertion(+) diff --git a/NOTICE b/NOTICE index fe34699f..5196dd9e 100644 --- a/NOTICE +++ b/NOTICE @@ -24,6 +24,7 @@ The following software have components provided under the terms of this license: - Apache Log4j API (from ) - Apache Log4j Core (from ) - Apache Log4j JUL Adapter (from ) +- Apache Log4j SLF4J Binding (from ) - Apache Log4j to SLF4J Adapter (from ) - Asynchronous Http Client (from ) - Asynchronous Http Client Netty Utils (from ) -- GitLab