diff options
Diffstat (limited to 'javatests/com/google/gerrit/server/logging/TraceContextTest.java')
-rw-r--r-- | javatests/com/google/gerrit/server/logging/TraceContextTest.java | 264 |
1 files changed, 264 insertions, 0 deletions
diff --git a/javatests/com/google/gerrit/server/logging/TraceContextTest.java b/javatests/com/google/gerrit/server/logging/TraceContextTest.java new file mode 100644 index 0000000000..044d2378e3 --- /dev/null +++ b/javatests/com/google/gerrit/server/logging/TraceContextTest.java @@ -0,0 +1,264 @@ +// Copyright (C) 2018 The Android Open Source Project +// +// 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 com.google.gerrit.server.logging; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.gerrit.server.logging.TraceContext.TraceIdConsumer; +import java.util.Map; +import java.util.SortedMap; +import java.util.SortedSet; +import org.junit.After; +import org.junit.Test; + +public class TraceContextTest { + @After + public void cleanup() { + LoggingContext.getInstance().clearTags(); + LoggingContext.getInstance().forceLogging(false); + } + + @Test + public void openContext() { + assertTags(ImmutableMap.of()); + try (TraceContext traceContext = TraceContext.open().addTag("foo", "bar")) { + assertTags(ImmutableMap.of("foo", ImmutableSet.of("bar"))); + } + assertTags(ImmutableMap.of()); + } + + @Test + public void openNestedContexts() { + assertTags(ImmutableMap.of()); + try (TraceContext traceContext = TraceContext.open().addTag("foo", "bar")) { + assertTags(ImmutableMap.of("foo", ImmutableSet.of("bar"))); + + try (TraceContext traceContext2 = TraceContext.open().addTag("abc", "xyz")) { + assertTags(ImmutableMap.of("abc", ImmutableSet.of("xyz"), "foo", ImmutableSet.of("bar"))); + } + + assertTags(ImmutableMap.of("foo", ImmutableSet.of("bar"))); + } + assertTags(ImmutableMap.of()); + } + + @Test + public void openNestedContextsWithSameTagName() { + assertTags(ImmutableMap.of()); + try (TraceContext traceContext = TraceContext.open().addTag("foo", "bar")) { + assertTags(ImmutableMap.of("foo", ImmutableSet.of("bar"))); + + try (TraceContext traceContext2 = TraceContext.open().addTag("foo", "baz")) { + assertTags(ImmutableMap.of("foo", ImmutableSet.of("bar", "baz"))); + } + + assertTags(ImmutableMap.of("foo", ImmutableSet.of("bar"))); + } + assertTags(ImmutableMap.of()); + } + + @Test + public void openNestedContextsWithSameTagNameAndValue() { + assertTags(ImmutableMap.of()); + try (TraceContext traceContext = TraceContext.open().addTag("foo", "bar")) { + assertTags(ImmutableMap.of("foo", ImmutableSet.of("bar"))); + + try (TraceContext traceContext2 = TraceContext.open().addTag("foo", "bar")) { + assertTags(ImmutableMap.of("foo", ImmutableSet.of("bar"))); + } + + assertTags(ImmutableMap.of("foo", ImmutableSet.of("bar"))); + } + assertTags(ImmutableMap.of()); + } + + @Test + public void openContextWithRequestId() { + assertTags(ImmutableMap.of()); + try (TraceContext traceContext = TraceContext.open().addTag(RequestId.Type.RECEIVE_ID, "foo")) { + assertTags(ImmutableMap.of("RECEIVE_ID", ImmutableSet.of("foo"))); + } + assertTags(ImmutableMap.of()); + } + + @Test + public void addTag() { + assertTags(ImmutableMap.of()); + try (TraceContext traceContext = TraceContext.open().addTag("foo", "bar")) { + assertTags(ImmutableMap.of("foo", ImmutableSet.of("bar"))); + + traceContext.addTag("foo", "baz"); + traceContext.addTag("bar", "baz"); + assertTags( + ImmutableMap.of("foo", ImmutableSet.of("bar", "baz"), "bar", ImmutableSet.of("baz"))); + } + assertTags(ImmutableMap.of()); + } + + @Test + public void openContextWithForceLogging() { + assertForceLogging(false); + try (TraceContext traceContext = TraceContext.open().forceLogging()) { + assertForceLogging(true); + } + assertForceLogging(false); + } + + @Test + public void openNestedContextsWithForceLogging() { + assertForceLogging(false); + try (TraceContext traceContext = TraceContext.open().forceLogging()) { + assertForceLogging(true); + + try (TraceContext traceContext2 = TraceContext.open()) { + // force logging is still enabled since outer trace context forced logging + assertForceLogging(true); + + try (TraceContext traceContext3 = TraceContext.open().forceLogging()) { + assertForceLogging(true); + } + + assertForceLogging(true); + } + + assertForceLogging(true); + } + assertForceLogging(false); + } + + @Test + public void forceLogging() { + assertForceLogging(false); + try (TraceContext traceContext = TraceContext.open()) { + assertForceLogging(false); + + traceContext.forceLogging(); + assertForceLogging(true); + + traceContext.forceLogging(); + assertForceLogging(true); + } + assertForceLogging(false); + } + + @Test + public void newTrace() { + TestTraceIdConsumer traceIdConsumer = new TestTraceIdConsumer(); + try (TraceContext traceContext = TraceContext.newTrace(true, null, traceIdConsumer)) { + assertForceLogging(true); + assertThat(LoggingContext.getInstance().getTagsAsMap().keySet()) + .containsExactly(RequestId.Type.TRACE_ID.name()); + } + assertThat(traceIdConsumer.tagName).isEqualTo(RequestId.Type.TRACE_ID.name()); + assertThat(traceIdConsumer.traceId).isNotNull(); + } + + @Test + public void newTraceWithProvidedTraceId() { + TestTraceIdConsumer traceIdConsumer = new TestTraceIdConsumer(); + String traceId = "foo"; + try (TraceContext traceContext = TraceContext.newTrace(true, traceId, traceIdConsumer)) { + assertForceLogging(true); + assertTags(ImmutableMap.of(RequestId.Type.TRACE_ID.name(), ImmutableSet.of(traceId))); + } + assertThat(traceIdConsumer.tagName).isEqualTo(RequestId.Type.TRACE_ID.name()); + assertThat(traceIdConsumer.traceId).isEqualTo(traceId); + } + + @Test + public void newTraceDisabled() { + TestTraceIdConsumer traceIdConsumer = new TestTraceIdConsumer(); + try (TraceContext traceContext = TraceContext.newTrace(false, null, traceIdConsumer)) { + assertForceLogging(false); + assertTags(ImmutableMap.of()); + } + assertThat(traceIdConsumer.tagName).isNull(); + assertThat(traceIdConsumer.traceId).isNull(); + } + + @Test + public void newTraceDisabledWithProvidedTraceId() { + TestTraceIdConsumer traceIdConsumer = new TestTraceIdConsumer(); + try (TraceContext traceContext = TraceContext.newTrace(false, "foo", traceIdConsumer)) { + assertForceLogging(false); + assertTags(ImmutableMap.of()); + } + assertThat(traceIdConsumer.tagName).isNull(); + assertThat(traceIdConsumer.traceId).isNull(); + } + + @Test + public void onlyOneTraceId() { + TestTraceIdConsumer traceIdConsumer1 = new TestTraceIdConsumer(); + try (TraceContext traceContext1 = TraceContext.newTrace(true, null, traceIdConsumer1)) { + String expectedTraceId = traceIdConsumer1.traceId; + assertThat(expectedTraceId).isNotNull(); + + TestTraceIdConsumer traceIdConsumer2 = new TestTraceIdConsumer(); + try (TraceContext traceContext2 = TraceContext.newTrace(true, null, traceIdConsumer2)) { + assertForceLogging(true); + assertTags( + ImmutableMap.of(RequestId.Type.TRACE_ID.name(), ImmutableSet.of(expectedTraceId))); + } + assertThat(traceIdConsumer2.tagName).isEqualTo(RequestId.Type.TRACE_ID.name()); + assertThat(traceIdConsumer2.traceId).isEqualTo(expectedTraceId); + } + } + + @Test + public void multipleTraceIdsIfTraceIdProvided() { + String traceId1 = "foo"; + try (TraceContext traceContext1 = + TraceContext.newTrace(true, traceId1, (tagName, traceId) -> {})) { + TestTraceIdConsumer traceIdConsumer = new TestTraceIdConsumer(); + String traceId2 = "bar"; + try (TraceContext traceContext2 = TraceContext.newTrace(true, traceId2, traceIdConsumer)) { + assertForceLogging(true); + assertTags( + ImmutableMap.of(RequestId.Type.TRACE_ID.name(), ImmutableSet.of(traceId1, traceId2))); + } + assertThat(traceIdConsumer.tagName).isEqualTo(RequestId.Type.TRACE_ID.name()); + assertThat(traceIdConsumer.traceId).isEqualTo(traceId2); + } + } + + private void assertTags(ImmutableMap<String, ImmutableSet<String>> expectedTagMap) { + SortedMap<String, SortedSet<Object>> actualTagMap = + LoggingContext.getInstance().getTags().asMap(); + assertThat(actualTagMap.keySet()).containsExactlyElementsIn(expectedTagMap.keySet()); + for (Map.Entry<String, ImmutableSet<String>> expectedEntry : expectedTagMap.entrySet()) { + assertThat(actualTagMap.get(expectedEntry.getKey())) + .containsExactlyElementsIn(expectedEntry.getValue()); + } + } + + private void assertForceLogging(boolean expected) { + assertThat(LoggingContext.getInstance().shouldForceLogging(null, null, false)) + .isEqualTo(expected); + } + + private static class TestTraceIdConsumer implements TraceIdConsumer { + String tagName; + String traceId; + + @Override + public void accept(String tagName, String traceId) { + this.tagName = tagName; + this.traceId = traceId; + } + } +} |