Skip to content

Add support for multiple Markers attached to a single LoggingEvent #840

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Aug 16, 2022
Merged

Add support for multiple Markers attached to a single LoggingEvent #840

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
18 changes: 17 additions & 1 deletion src/main/java/net/logstash/logback/composite/loggingevent/LogstashMarkersJsonProvider.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,11 +17,13 @@

import java.io.IOException;
import java.util.Iterator;
import java.util.List;

import net.logstash.logback.composite.AbstractJsonProvider;
import net.logstash.logback.composite.JsonProvider;
import net.logstash.logback.marker.LogstashMarker;
import net.logstash.logback.marker.Markers;
import net.logstash.logback.util.LogbackUtils;

import ch.qos.logback.classic.spi.ILoggingEvent;
import com.fasterxml.jackson.core.JsonGenerator;
Expand All @@ -33,9 +35,23 @@
*/
public class LogstashMarkersJsonProvider extends AbstractJsonProvider<ILoggingEvent> {

@SuppressWarnings("deprecation")
@Override
public void writeTo(JsonGenerator generator, ILoggingEvent event) throws IOException {
writeLogstashMarkerIfNecessary(generator, event.getMarker());
if (LogbackUtils.isVersion13()) {
writeLogstashMarkerIfNecessary(generator, event.getMarkerList());
}
else {
writeLogstashMarkerIfNecessary(generator, event.getMarker());
}
}

private void writeLogstashMarkerIfNecessary(JsonGenerator generator, List<Marker> markers) throws IOException {
if (markers != null) {
for (Marker marker: markers) {
writeLogstashMarkerIfNecessary(generator, marker);
}
}
}

private void writeLogstashMarkerIfNecessary(JsonGenerator generator, Marker marker) throws IOException {
Expand Down
50 changes: 32 additions & 18 deletions src/main/java/net/logstash/logback/composite/loggingevent/TagsJsonProvider.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,11 +17,13 @@

import java.io.IOException;
import java.util.Iterator;
import java.util.List;

import net.logstash.logback.composite.AbstractFieldJsonProvider;
import net.logstash.logback.composite.FieldNamesAware;
import net.logstash.logback.fieldnames.LogstashFieldNames;
import net.logstash.logback.marker.LogstashMarker;
import net.logstash.logback.util.LogbackUtils;

import ch.qos.logback.classic.spi.ILoggingEvent;
import com.fasterxml.jackson.core.JsonGenerator;
Expand All @@ -41,40 +43,52 @@ public TagsJsonProvider() {
setFieldName(FIELD_TAGS);
}

@SuppressWarnings("deprecation")
@Override
public void writeTo(JsonGenerator generator, ILoggingEvent event) throws IOException {
/*
* Don't write the tags field unless we actually have a tag to write.
*/
boolean hasWrittenStart = false;

final Marker marker = event.getMarker();

if (marker != null) {
hasWrittenStart = writeTagIfNecessary(generator, hasWrittenStart, marker);
if (LogbackUtils.isVersion13()) {
hasWrittenStart = writeTagIfNecessary(generator, hasWrittenStart, event.getMarkerList());
}
else {
hasWrittenStart = writeTagIfNecessary(generator, hasWrittenStart, event.getMarker());
}

if (hasWrittenStart) {
generator.writeEndArray();
}
}

@SuppressWarnings("deprecation")
private boolean writeTagIfNecessary(JsonGenerator generator, boolean hasWrittenStart, final Marker marker) throws IOException {
if (!LogstashMarkersJsonProvider.isLogstashMarker(marker)) {

if (!hasWrittenStart) {
generator.writeArrayFieldStart(getFieldName());
hasWrittenStart = true;
private boolean writeTagIfNecessary(JsonGenerator generator, boolean hasWrittenStart, final List<Marker> markers) throws IOException {
if (markers != null) {
for (Marker marker: markers) {
hasWrittenStart |= writeTagIfNecessary(generator, hasWrittenStart, marker);
}
generator.writeString(marker.getName());
}
if (marker.hasReferences()) {

for (Iterator<?> i = marker.iterator(); i.hasNext();) {
Marker next = (Marker) i.next();

hasWrittenStart |= writeTagIfNecessary(generator, hasWrittenStart, next);

return hasWrittenStart;
}

private boolean writeTagIfNecessary(JsonGenerator generator, boolean hasWrittenStart, final Marker marker) throws IOException {
if (marker != null) {
if (!LogstashMarkersJsonProvider.isLogstashMarker(marker)) {
if (!hasWrittenStart) {
generator.writeArrayFieldStart(getFieldName());
hasWrittenStart = true;
}
generator.writeString(marker.getName());
}

if (marker.hasReferences()) {
for (Iterator<?> i = marker.iterator(); i.hasNext();) {
Marker next = (Marker) i.next();

hasWrittenStart |= writeTagIfNecessary(generator, hasWrittenStart, next);
}
}
}
return hasWrittenStart;
Expand Down
116 changes: 100 additions & 16 deletions ...est/java/net/logstash/logback/composite/loggingevent/LogstashMarkersJsonProviderTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,51 +15,135 @@
*/
package net.logstash.logback.composite.loggingevent;

import static org.assertj.core.api.Assertions.assertThatCode;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.io.IOException;
import java.util.Collections;

import net.logstash.logback.marker.LogstashMarker;
import net.logstash.logback.util.LogbackUtils;

import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.classic.spi.LoggingEvent;
import com.fasterxml.jackson.core.JsonGenerator;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.slf4j.Marker;
import org.slf4j.MarkerFactory;

@ExtendWith(MockitoExtension.class)
public class LogstashMarkersJsonProviderTest {

private LogstashMarkersJsonProvider provider = new LogstashMarkersJsonProvider();

@Mock
private JsonGenerator generator;

@Mock
private ILoggingEvent event;
private LogstashMarkersJsonProvider provider = new LogstashMarkersJsonProvider();
private int markerCount;

@Mock
private LogstashMarker outerMarker;


@Test
public void noMarkers() throws IOException {
LoggingEvent event = createEvent();
assertThatCode(() -> provider.writeTo(generator, event)).doesNotThrowAnyException();
}


/*
*
*/
@Test
public void singleMarker() throws IOException {

// event:
// * basic1 -> marker1 -> marker11
// -> basic12 -> marker121
// -> marker2


Marker basic1 = createBasicMarker();
LogstashMarker marker1 = createLogstashMarker(); basic1.add(marker1);
LogstashMarker marker11 = createLogstashMarker(); marker1.add(marker11);
Marker basic12 = createBasicMarker(); marker11.add(basic12);
LogstashMarker marker121 = createLogstashMarker(); basic12.add(marker121);

LoggingEvent event = createEvent(basic1);

provider.writeTo(generator, event);

verify(marker1).writeTo(generator);
verify(marker11).writeTo(generator);
verify(marker121).writeTo(generator);
}

@Mock
private LogstashMarker innerMarker;

@Test
public void test() throws IOException {
public void multipleMarkers() throws IOException {
Assumptions.assumeTrue(LogbackUtils::isVersion13);

when(outerMarker.hasReferences()).thenReturn(true);
when(outerMarker.iterator()).thenReturn(Collections.<Marker>singleton(innerMarker).iterator());
// event:
// * basic1 -> marker1
// * marker2

when(event.getMarker()).thenReturn(outerMarker);

Marker basic1 = createBasicMarker();
LogstashMarker marker1 = createLogstashMarker(); basic1.add(marker1);
LogstashMarker marker2 = createLogstashMarker();

LoggingEvent event = createEvent(basic1, marker2);

provider.writeTo(generator, event);

verify(outerMarker).writeTo(generator);
verify(innerMarker).writeTo(generator);
verify(marker1).writeTo(generator);
verify(marker2).writeTo(generator);
}



// -- Utility methods -------------------------------------------------------------------------

private Marker createBasicMarker() {
return MarkerFactory.getDetachedMarker(Integer.toString(this.markerCount++));
}

private LogstashMarker createLogstashMarker() {
return spy(new TestLogstashMarker(Integer.toString(this.markerCount++)));
}

@SuppressWarnings("deprecation")
private LoggingEvent createEvent(Marker...markers) {
LoggingEvent event = spy(new LoggingEvent());

if (markers != null && markers.length > 0) {
if (LogbackUtils.isVersion13()) {
for (Marker marker: markers) {
event.addMarker(marker);
}
}
else {
if (markers.length > 1) {
throw new IllegalStateException("Logback 1.2 supports only one Marker per event");
}
when(event.getMarker()).thenReturn(markers[0]);
}
}

return event;
}

@SuppressWarnings("serial")
private static class TestLogstashMarker extends LogstashMarker {
TestLogstashMarker(String name) {
super(name);
}

@Override
public void writeTo(JsonGenerator generator) throws IOException {
// noop
}
}
}
Loading