From 0f776240e7ec80cc47f60612b0edbde6e01e424a Mon Sep 17 00:00:00 2001 From: Raviraj Joshi Date: Sat, 7 Sep 2019 14:54:11 -0700 Subject: [PATCH 01/23] Adding Sanitizer interface and implementation --- .../java/com/uber/m3/tally/ScopeBuilder.java | 14 +++ .../java/com/uber/m3/tally/ScopeImpl.java | 68 +++++------ .../uber/m3/tally/sanitizers/Sanitize.java | 34 ++++++ .../m3/tally/sanitizers/SanitizeRange.java | 47 ++++++++ .../uber/m3/tally/sanitizers/Sanitizer.java | 48 ++++++++ .../m3/tally/sanitizers/SanitizerBuilder.java | 87 ++++++++++++++ .../m3/tally/sanitizers/SanitizerImpl.java | 67 +++++++++++ .../m3/tally/sanitizers/ValidCharacters.java | 109 ++++++++++++++++++ .../java/com/uber/m3/tally/ScopeImplTest.java | 75 ++++++------ .../tally/sanitizers/SanitizeRangeTest.java | 40 +++++++ .../m3/tally/sanitizers/SanitizerTest.java | 108 +++++++++++++++++ .../com/uber/m3/tally/m3/M3Sanitizer.java | 50 ++++++++ .../com/uber/m3/tally/m3/M3SanitizerTest.java | 45 ++++++++ 13 files changed, 725 insertions(+), 67 deletions(-) create mode 100644 core/src/main/java/com/uber/m3/tally/sanitizers/Sanitize.java create mode 100644 core/src/main/java/com/uber/m3/tally/sanitizers/SanitizeRange.java create mode 100644 core/src/main/java/com/uber/m3/tally/sanitizers/Sanitizer.java create mode 100644 core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerBuilder.java create mode 100644 core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java create mode 100644 core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java create mode 100644 core/src/test/java/com/uber/m3/tally/sanitizers/SanitizeRangeTest.java create mode 100644 core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java create mode 100644 m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java create mode 100644 m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java diff --git a/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java b/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java index 08cdd3f..ee8e8b0 100644 --- a/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java +++ b/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java @@ -20,6 +20,8 @@ package com.uber.m3.tally; +import com.uber.m3.tally.sanitizers.Sanitizer; +import com.uber.m3.tally.sanitizers.SanitizerBuilder; import com.uber.m3.util.Duration; import com.uber.m3.util.ImmutableMap; @@ -55,6 +57,7 @@ public class ScopeBuilder { protected String separator = DEFAULT_SEPARATOR; protected ImmutableMap tags; protected Buckets defaultBuckets = DEFAULT_SCOPE_BUCKETS; + protected Sanitizer sanitizer = new SanitizerBuilder().build(); private ScheduledExecutorService scheduler; private ScopeImpl.Registry registry; @@ -128,6 +131,17 @@ public ScopeBuilder defaultBuckets(Buckets defaultBuckets) { return this; } + /** + * Update the sanitizer. + * + * @param sanitizer value to update to + * @return Builder with new param updated + */ + public ScopeBuilder sanitizer(Sanitizer sanitizer) { + this.sanitizer = sanitizer; + return this; + } + // Private build method - clients should rely on `reportEvery` to create root scopes, and // a root scope's `tagged` and `subScope` functions to create subscopes. ScopeImpl build() { diff --git a/core/src/main/java/com/uber/m3/tally/ScopeImpl.java b/core/src/main/java/com/uber/m3/tally/ScopeImpl.java index da0a6d8..1928b37 100644 --- a/core/src/main/java/com/uber/m3/tally/ScopeImpl.java +++ b/core/src/main/java/com/uber/m3/tally/ScopeImpl.java @@ -205,12 +205,12 @@ public Snapshot snapshot() { String id = keyForPrefixedStringMap(name, tags); snap.counters().put( - id, - new CounterSnapshotImpl( - name, - tags, - counter.getValue().snapshot() - ) + id, + new CounterSnapshotImpl( + name, + tags, + counter.getValue().snapshot() + ) ); } @@ -220,12 +220,12 @@ public Snapshot snapshot() { String id = keyForPrefixedStringMap(name, tags); snap.gauges().put( - id, - new GaugeSnapshotImpl( - name, - tags, - gauge.getValue().snapshot() - ) + id, + new GaugeSnapshotImpl( + name, + tags, + gauge.getValue().snapshot() + ) ); } @@ -235,12 +235,12 @@ public Snapshot snapshot() { String id = keyForPrefixedStringMap(name, tags); snap.timers().put( - id, - new TimerSnapshotImpl( - name, - tags, - timer.getValue().snapshot() - ) + id, + new TimerSnapshotImpl( + name, + tags, + timer.getValue().snapshot() + ) ); } @@ -250,13 +250,13 @@ public Snapshot snapshot() { String id = keyForPrefixedStringMap(name, tags); snap.histograms().put( - id, - new HistogramSnapshotImpl( - name, - tags, - histogram.getValue().snapshotValues(), - histogram.getValue().snapshotDurations() - ) + id, + new HistogramSnapshotImpl( + name, + tags, + histogram.getValue().snapshotValues(), + histogram.getValue().snapshotDurations() + ) ); } } @@ -281,14 +281,14 @@ private Scope subScopeHelper(String prefix, Map tags) { String key = keyForPrefixedStringMap(prefix, mergedTags); return registry.subscopes.computeIfAbsent( - key, - (k) -> new ScopeBuilder(scheduler, registry) - .reporter(reporter) - .prefix(prefix) - .separator(separator) - .tags(mergedTags) - .defaultBuckets(defaultBuckets) - .build() + key, + (k) -> new ScopeBuilder(scheduler, registry) + .reporter(reporter) + .prefix(prefix) + .separator(separator) + .tags(mergedTags) + .defaultBuckets(defaultBuckets) + .build() ); } @@ -334,4 +334,4 @@ private void reportUncaughtException(Exception uncaughtException) { static class Registry { Map subscopes = new ConcurrentHashMap<>(); } -} +} \ No newline at end of file diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/Sanitize.java b/core/src/main/java/com/uber/m3/tally/sanitizers/Sanitize.java new file mode 100644 index 0000000..bcb5f53 --- /dev/null +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/Sanitize.java @@ -0,0 +1,34 @@ +// Copyright (c) 2020 Uber Technologies, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package com.uber.m3.tally.sanitizers; + +/** + * Sanitize returns a sanitized version of the input string value. + */ +public interface Sanitize { + + /** + * Sanitize the input string value. + * @param value input string value + * @return sanitized string value + */ + String sanitize(String value); +} diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizeRange.java b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizeRange.java new file mode 100644 index 0000000..0b6b841 --- /dev/null +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizeRange.java @@ -0,0 +1,47 @@ +// Copyright (c) 2020 Uber Technologies, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package com.uber.m3.tally.sanitizers; + +/** + * SanitizeRange is a range of characters (inclusive on both ends). + */ +public class SanitizeRange { + + private final char low; + private final char high; + + private SanitizeRange(char low, char high) { + this.low = low; + this.high = high; + } + + public static SanitizeRange of(char low, char high) { + return new SanitizeRange(low, high); + } + + char low() { + return low; + } + + char high() { + return high; + } +} diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/Sanitizer.java b/core/src/main/java/com/uber/m3/tally/sanitizers/Sanitizer.java new file mode 100644 index 0000000..731b784 --- /dev/null +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/Sanitizer.java @@ -0,0 +1,48 @@ +// Copyright (c) 2020 Uber Technologies, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package com.uber.m3.tally.sanitizers; + +/** + * SanitizerImpl sanitizes the provided input based on the function executed. + */ +public interface Sanitizer { + + /** + * Name sanitizes the provided 'name' string. + * @param name the name string + * @return the sanitized name + */ + String name(String name); + + /** + * Key sanitizes the provided 'key' string. + * @param key the key string + * @return the sanitized key + */ + String key(String key); + + /** + * Value sanitizes the provided 'value' string. + * @param value the value string + * @return the sanitized value + */ + String value(String value); +} diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerBuilder.java b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerBuilder.java new file mode 100644 index 0000000..27ed255 --- /dev/null +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerBuilder.java @@ -0,0 +1,87 @@ +// Copyright (c) 2020 Uber Technologies, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package com.uber.m3.tally.sanitizers; + +/** + * The SanitizerBuilder returns a Sanitizer for the name, key and value. By + * default, the name, key and value sanitize functions returns all the input + * untouched. Custom name, key or value Sanitize functions or ValidCharacters + * can be provided to override their default behaviour. + */ +public class SanitizerBuilder { + + private Sanitize nameSanitizer = value -> value; + private Sanitize keySanitizer = value -> value; + private Sanitize valueSanitizer = value -> value; + + private char repChar = ValidCharacters.DEFAULT_REPLACEMENT_CHARACTER; + private ValidCharacters nameCharacters; + private ValidCharacters keyCharacters; + private ValidCharacters valueCharacters; + + public SanitizerBuilder withNameSanitizer(Sanitize nameSanitizer) { + this.nameSanitizer = nameSanitizer; + return this; + } + + public SanitizerBuilder withKeySanitizer(Sanitize keySanitizer) { + this.keySanitizer = keySanitizer; + return this; + } + + public SanitizerBuilder withValueSanitizer(Sanitize valueSanitizer) { + this.valueSanitizer = valueSanitizer; + return this; + } + + public SanitizerBuilder withReplacementCharacter(char repChar) { + this.repChar = repChar; + return this; + } + + public SanitizerBuilder withNameCharacters(ValidCharacters nameCharacters) { + this.nameCharacters = nameCharacters; + return this; + } + + public SanitizerBuilder withKeyCharacters(ValidCharacters keyCharacters) { + this.keyCharacters = keyCharacters; + return this; + } + + public SanitizerBuilder withValueCharacters(ValidCharacters valueCharacters) { + this.valueCharacters = valueCharacters; + return this; + } + + public Sanitizer build() { + if (nameCharacters != null) { + nameSanitizer = nameCharacters.sanitize(repChar); + } + if (keyCharacters != null) { + keySanitizer = keyCharacters.sanitize(repChar); + } + if (valueCharacters != null) { + valueSanitizer = valueCharacters.sanitize(repChar); + } + return new SanitizerImpl(nameSanitizer, keySanitizer, valueSanitizer); + } +} diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java new file mode 100644 index 0000000..75f53c5 --- /dev/null +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java @@ -0,0 +1,67 @@ +// Copyright (c) 2020 Uber Technologies, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package com.uber.m3.tally.sanitizers; + +/** + * SanitizerImpl sanitizes the provided input based on the function executed. + */ +class SanitizerImpl implements Sanitizer { + + private final Sanitize nameSanitizer; + private final Sanitize keySanitizer; + private final Sanitize valueSanitizer; + + SanitizerImpl(Sanitize nameSanitizer, Sanitize keySanitizer, Sanitize valueSanitizer) { + this.nameSanitizer = nameSanitizer; + this.keySanitizer = keySanitizer; + this.valueSanitizer = valueSanitizer; + } + + /** + * Name sanitizes the provided 'name' string. + * @param name the name string + * @return the sanitized name + */ + @Override + public String name(String name) { + return this.nameSanitizer.sanitize(name); + } + + /** + * Key sanitizes the provided 'key' string. + * @param key the key string + * @return the sanitized key + */ + @Override + public String key(String key) { + return this.keySanitizer.sanitize(key); + } + + /** + * Value sanitizes the provided 'value' string. + * @param value the value string + * @return the sanitized value + */ + @Override + public String value(String value) { + return this.valueSanitizer.sanitize(value); + } +} diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java new file mode 100644 index 0000000..4e00104 --- /dev/null +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java @@ -0,0 +1,109 @@ +// Copyright (c) 2017 Uber Technologies, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package com.uber.m3.tally.sanitizers; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +/** + * ValidCharacters is a collection of valid characters. + */ +public class ValidCharacters { + + /** + * DEFAULT_REPLACEMENT_CHARACTER is the default character used for replacements. + */ + public static char DEFAULT_REPLACEMENT_CHARACTER = '_'; + + /** + * ALPHANUMERIC_RANGE is the range of alphanumeric characters. + */ + public static final List ALPHANUMERIC_RANGE = + Arrays.asList( + SanitizeRange.of('a', 'z'), + SanitizeRange.of('A', 'Z'), + SanitizeRange.of('0', '9')); + + /** + * UNDERSCORE_CHARACTERS contains the underscore character. + */ + public static final List UNDERSCORE_CHARACTERS = Collections.singletonList('_'); + + /** + * UNDERSCORE_DASH_CHARACTERS contains the underscore and dash characters. + */ + public static final List UNDERSCORE_DASH_CHARACTERS = Arrays.asList('_', '-'); + + /** + * UNDERSCORE_DASH_DOT_CHARACTERS contains the underscore, dash and dot characters. + */ + public static final List UNDERSCORE_DASH_DOT_CHARACTERS = Arrays.asList('_', '-', '.'); + + private final List ranges; + private final List characters; + + private ValidCharacters(List ranges, List characters) { + this.ranges = ranges != null ? ranges : Collections.emptyList(); + this.characters = characters != null ? characters : Collections.emptyList(); + } + + public static ValidCharacters of(List ranges, List characters) { + return new ValidCharacters(ranges, characters); + } + + Sanitize sanitize(char repChar) { + return value -> { + StringBuilder buffer = null; + + for (int i = 0; i < value.length(); i++) { + char ch = value.charAt(i); + + // first check if the provided character is valid + boolean validCurr = + ranges.stream().anyMatch(range -> ch >= range.low() && ch <= range.high()) + || characters.stream().anyMatch(character -> character.equals(ch)); + + // if it's valid, we can optimize allocations by avoiding copying + if (validCurr) { + if (buffer != null) { + buffer.append(ch); + } + continue; + } + + // the character is invalid, and the buffer has not been initialized + // so we initialize the buffer and back-fill. + if (buffer == null) { + buffer = new StringBuilder(value.length()); + buffer.append(value, 0, i); + } + + // write the replacement character + buffer.append(repChar); + } + + // return input un-touched if the buffer has not been initialized + // otherwise, return the newly constructed buffer string + return buffer == null ? value : buffer.toString(); + }; + } +} diff --git a/core/src/test/java/com/uber/m3/tally/ScopeImplTest.java b/core/src/test/java/com/uber/m3/tally/ScopeImplTest.java index d5dbd28..4266437 100644 --- a/core/src/test/java/com/uber/m3/tally/ScopeImplTest.java +++ b/core/src/test/java/com/uber/m3/tally/ScopeImplTest.java @@ -20,19 +20,17 @@ package com.uber.m3.tally; +import com.uber.m3.util.Duration; +import com.uber.m3.util.ImmutableMap; +import org.junit.Test; + import java.lang.Thread.UncaughtExceptionHandler; import java.util.HashMap; import java.util.Map; import java.util.concurrent.atomic.AtomicInteger; -import org.junit.Test; - -import com.uber.m3.util.Duration; -import com.uber.m3.util.ImmutableMap; - import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; public class ScopeImplTest { private static final double EPSILON = 1e-10; @@ -54,21 +52,21 @@ public void metricCreation() { Counter sameCounter = scope.counter("new-counter"); // Should be the same Counter object and not a new instance - assertTrue(counter == sameCounter); + assertEquals(counter, sameCounter); Gauge gauge = scope.gauge("new-gauge"); assertNotNull(gauge); Gauge sameGauge = scope.gauge("new-gauge"); // Should be the same Gauge object and not a new instance - assertTrue(gauge == sameGauge); + assertEquals(gauge, sameGauge); Timer timer = scope.timer("new-timer"); assertNotNull(timer); Timer sameTimer = scope.timer("new-timer"); // Should be the same Timer object and not a new instance - assertTrue(timer == sameTimer); + assertEquals(timer, sameTimer); Histogram histogram = scope.histogram( "new-histogram", @@ -85,7 +83,7 @@ public void metricCreation() { Histogram sameHistogram = scope.histogram("new-histogram", null); // Should be the same Histogram object and not a new instance - assertTrue(histogram == sameHistogram); + assertEquals(histogram, sameHistogram); } @Test @@ -158,9 +156,9 @@ public void subscopes() { ImmutableMap additionalTags = new ImmutableMap.Builder(2) - .put("new_key", "new_val") - .put("baz", "quz") - .build(); + .put("new_key", "new_val") + .put("baz", "quz") + .build(); Scope taggedSubscope = rootScope.tagged(additionalTags); Timer taggedTimer = taggedSubscope.timer("tagged_timer"); taggedTimer.record(Duration.ofSeconds(6)); @@ -187,9 +185,9 @@ public void subscopes() { assertEquals("tagged_timer", timer.getName()); ImmutableMap expectedTags = new ImmutableMap.Builder(4) - .putAll(tags) - .putAll(additionalTags) - .build(); + .putAll(tags) + .putAll(additionalTags) + .build(); assertEquals(expectedTags, timer.getTags()); } @@ -229,24 +227,29 @@ public void snapshot() { Map counters = snapshot.counters(); assertEquals(1, counters.size()); assertEquals("snapshot-counter", counters.get("snapshot-counter+").name()); - assertEquals(null, counters.get("snapshot-counter+").tags()); + assertNotNull(counters.get("snapshot-counter+").tags()); + assertEquals(0, counters.get("snapshot-counter+").tags().size()); Map gauges = snapshot.gauges(); assertEquals(3, gauges.size()); assertEquals("snapshot-gauge", gauges.get("snapshot-gauge+").name()); - assertEquals(null, gauges.get("snapshot-gauge+").tags()); + assertNotNull(gauges.get("snapshot-gauge+").tags()); + assertEquals(0, gauges.get("snapshot-gauge+").tags().size()); assertEquals(120, gauges.get("snapshot-gauge+").value(), EPSILON); assertEquals("snapshot-gauge2", gauges.get("snapshot-gauge2+").name()); - assertEquals(null, gauges.get("snapshot-gauge2+").tags()); + assertNotNull(gauges.get("snapshot-gauge2+").tags()); + assertEquals(0, gauges.get("snapshot-gauge2+").tags().size()); assertEquals(220, gauges.get("snapshot-gauge2+").value(), EPSILON); assertEquals("snapshot-gauge3", gauges.get("snapshot-gauge3+").name()); - assertEquals(null, gauges.get("snapshot-gauge3+").tags()); + assertNotNull(gauges.get("snapshot-gauge3+").tags()); + assertEquals(0, gauges.get("snapshot-gauge3+").tags().size()); assertEquals(320, gauges.get("snapshot-gauge3+").value(), EPSILON); Map timers = snapshot.timers(); assertEquals(1, timers.size()); assertEquals("snapshot-timer", timers.get("snapshot-timer+").name()); - assertEquals(null, timers.get("snapshot-timer+").tags()); + assertNotNull(timers.get("snapshot-timer+").tags()); + assertEquals(0, timers.get("snapshot-timer+").tags().size()); } @Test(expected = IllegalArgumentException.class) @@ -265,12 +268,10 @@ public void uncaughtException(Thread t, Throwable e) { } }; - Scope scope = new RootScopeBuilder() + try (Scope scope = new RootScopeBuilder() .reporter(reporter) - .reportEvery(Duration.ofMillis(REPORT_INTERVAL_MILLIS), - uncaughtExceptionHandler); + .reportEvery(Duration.ofMillis(REPORT_INTERVAL_MILLIS), uncaughtExceptionHandler)) { - try { scope.counter("hi").inc(1); Thread.sleep(SLEEP_MILLIS); @@ -283,8 +284,6 @@ public void uncaughtException(Thread t, Throwable e) { assertEquals(2, uncaghtExceptionReported.get()); assertEquals(2, reporter.getNumberOfReportedMetrics()); - } finally { - scope.close(); } } @@ -314,17 +313,27 @@ public void reportTimer(String name, Map tags, Duration interval } @Override - public void reportHistogramValueSamples(String name, Map tags, - Buckets buckets, double bucketLowerBound, - double bucketUpperBound, long samples) { + public void reportHistogramValueSamples( + String name, + Map tags, + Buckets buckets, + double bucketLowerBound, + double bucketUpperBound, + long samples + ) { reported.incrementAndGet(); throw new RuntimeException(); } @Override - public void reportHistogramDurationSamples(String name, Map tags, - Buckets buckets, Duration bucketLowerBound, - Duration bucketUpperBound, long samples) { + public void reportHistogramDurationSamples( + String name, + Map tags, + Buckets buckets, + Duration bucketLowerBound, + Duration bucketUpperBound, + long samples + ) { reported.incrementAndGet(); throw new RuntimeException(); } diff --git a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizeRangeTest.java b/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizeRangeTest.java new file mode 100644 index 0000000..3745edc --- /dev/null +++ b/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizeRangeTest.java @@ -0,0 +1,40 @@ +// Copyright (c) 2017 Uber Technologies, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package com.uber.m3.tally.sanitizers; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +public class SanitizeRangeTest { + + private static final char LOW = 'a'; + private static final char HIGH = 'z'; + + @Test + public void sanitizeRange() { + SanitizeRange range = SanitizeRange.of(LOW, HIGH); + assertNotNull(range); + assertEquals(LOW, range.low()); + assertEquals(HIGH, range.high()); + } +} diff --git a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java b/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java new file mode 100644 index 0000000..ed7825e --- /dev/null +++ b/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java @@ -0,0 +1,108 @@ +// Copyright (c) 2017 Uber Technologies, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package com.uber.m3.tally.sanitizers; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class SanitizerTest { + + private static final String NAME = "!@#$%^&*()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; + private static final String KEY = "!@#$%^&*()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; + private static final String VALUE = "!@#$%^&*()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; + private static final String SANITIZED_NAME_1 = "sanitized-name"; + private static final String SANITIZED_KEY_1 = "sanitized-key"; + private static final String SANITIZED_VALUE_1 = "sanitized-value"; + private static final String SANITIZED_NAME_2 = "__________abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890___"; + private static final String SANITIZED_KEY_2 = "__________abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-_"; + private static final String SANITIZED_VALUE_2 = "__________abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; + private static final String SANITIZED_NAME_3 = "@@@@@@@@@@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_@@"; + private static final String SANITIZED_KEY_3 = "@@@@@@@@@@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-@"; + private static final String SANITIZED_VALUE_3 = "@@@@@@@@@@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; + private static final char REPLACEMENT_CHAR = '@'; + + @Test + public void noopSanitizer() { + Sanitizer sanitizer = new SanitizerBuilder().build(); + assertEquals(NAME, sanitizer.name(NAME)); + assertEquals(KEY, sanitizer.key(KEY)); + assertEquals(VALUE, sanitizer.value(VALUE)); + } + + @Test + public void withSanitizers() { + Sanitizer sanitizer = + new SanitizerBuilder() + .withNameSanitizer(value -> SANITIZED_NAME_1) + .withKeySanitizer(value -> SANITIZED_KEY_1) + .withValueSanitizer(value -> SANITIZED_VALUE_1) + .build(); + assertEquals(SANITIZED_NAME_1, sanitizer.name(NAME)); + assertEquals(SANITIZED_KEY_1, sanitizer.key(KEY)); + assertEquals(SANITIZED_VALUE_1, sanitizer.value(VALUE)); + } + + @Test + public void withValidCharactersAndDefaultRepChar() { + Sanitizer sanitizer = + new SanitizerBuilder() + .withNameCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_CHARACTERS)) + .withKeyCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) + .withValueCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) + .build(); + assertEquals(SANITIZED_NAME_2, sanitizer.name(NAME)); + assertEquals(SANITIZED_KEY_2, sanitizer.key(KEY)); + assertEquals(SANITIZED_VALUE_2, sanitizer.value(VALUE)); + } + + @Test + public void withValidCharactersAndRepChar() { + Sanitizer sanitizer = + new SanitizerBuilder() + .withReplacementCharacter(REPLACEMENT_CHAR) + .withNameCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_CHARACTERS)) + .withKeyCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) + .withValueCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) + .build(); + assertEquals(SANITIZED_NAME_3, sanitizer.name(NAME)); + assertEquals(SANITIZED_KEY_3, sanitizer.key(KEY)); + assertEquals(SANITIZED_VALUE_3, sanitizer.value(VALUE)); + } +} diff --git a/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java b/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java new file mode 100644 index 0000000..fbba346 --- /dev/null +++ b/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java @@ -0,0 +1,50 @@ +// Copyright (c) 2017 Uber Technologies, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package com.uber.m3.tally.m3; + +import com.uber.m3.tally.sanitizers.Sanitizer; +import com.uber.m3.tally.sanitizers.SanitizerBuilder; +import com.uber.m3.tally.sanitizers.ValidCharacters; + +public class M3Sanitizer { + + /** + * Creates the default M3 sanitizer. + * @return default M3 sanitizer + */ + public static Sanitizer create() { + return new SanitizerBuilder() + .withReplacementCharacter(ValidCharacters.DEFAULT_REPLACEMENT_CHARACTER) + .withNameCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) + .withKeyCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) + .withValueCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) + .build(); + } +} diff --git a/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java b/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java new file mode 100644 index 0000000..abfd933 --- /dev/null +++ b/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java @@ -0,0 +1,45 @@ +// Copyright (c) 2017 Uber Technologies, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package com.uber.m3.tally.m3; + +import com.uber.m3.tally.sanitizers.Sanitizer; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class M3SanitizerTest { + + private static final String NAME = "!@#$%^&*()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; + private static final String KEY = "!@#$%^&*()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; + private static final String VALUE = "!@#$%^&*()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; + private static final String SANITIZED_NAME = "__________abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; + private static final String SANITIZED_KEY = "__________abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-_"; + private static final String SANITIZED_VALUE = "__________abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; + + @Test + public void m3Sanitizer() { + Sanitizer sanitizer = M3Sanitizer.create(); + assertNotNull(sanitizer); + assertEquals(SANITIZED_NAME, sanitizer.name(NAME)); + assertEquals(SANITIZED_KEY, sanitizer.key(KEY)); + assertEquals(SANITIZED_VALUE, sanitizer.value(VALUE)); + } +} From afa6c6dbda135a6f0efffc7eb0a5bbf073aa988a Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Wed, 7 Apr 2021 18:27:35 -0700 Subject: [PATCH 02/23] address comments to avoid copy --- .../java/com/uber/m3/tally/ScopeImpl.java | 30 ++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-) diff --git a/core/src/main/java/com/uber/m3/tally/ScopeImpl.java b/core/src/main/java/com/uber/m3/tally/ScopeImpl.java index 1928b37..a8f59d2 100644 --- a/core/src/main/java/com/uber/m3/tally/ScopeImpl.java +++ b/core/src/main/java/com/uber/m3/tally/ScopeImpl.java @@ -20,6 +20,7 @@ package com.uber.m3.tally; +import com.uber.m3.tally.sanitizers.Sanitizer; import com.uber.m3.util.ImmutableMap; import javax.annotation.Nullable; @@ -41,6 +42,7 @@ class ScopeImpl implements Scope { private String separator; private ImmutableMap tags; private Buckets defaultBuckets; + private Sanitizer sanitizer; private ScheduledExecutorService scheduler; private Registry registry; @@ -57,6 +59,7 @@ class ScopeImpl implements Scope { ScopeImpl(ScheduledExecutorService scheduler, Registry registry, ScopeBuilder builder) { this.scheduler = scheduler; this.registry = registry; + this.sanitizer = builder.sanitizer; this.reporter = builder.reporter; this.prefix = builder.prefix; @@ -67,6 +70,7 @@ class ScopeImpl implements Scope { @Override public Counter counter(String name) { + name = sanitizer.name(name); return counters.computeIfAbsent(name, ignored -> // NOTE: This will called at most once new CounterImpl(this, fullyQualifiedName(name)) @@ -75,6 +79,7 @@ public Counter counter(String name) { @Override public Gauge gauge(String name) { + name = sanitizer.name(name); return gauges.computeIfAbsent(name, ignored -> // NOTE: This will called at most once new GaugeImpl(this, fullyQualifiedName(name))); @@ -82,6 +87,7 @@ public Gauge gauge(String name) { @Override public Timer timer(String name) { + name = sanitizer.name(name); // Timers report directly to the {@code StatsReporter}, and therefore not added to reporting queue // i.e. they are not buffered return timers.computeIfAbsent(name, ignored -> new TimerImpl(fullyQualifiedName(name), tags, reporter)); @@ -89,6 +95,7 @@ public Timer timer(String name) { @Override public Histogram histogram(String name, @Nullable Buckets buckets) { + name = sanitizer.name(name); return histograms.computeIfAbsent(name, ignored -> // NOTE: This will called at most once new HistogramImpl( @@ -103,11 +110,12 @@ public Histogram histogram(String name, @Nullable Buckets buckets) { @Override public Scope tagged(Map tags) { - return subScopeHelper(prefix, tags); + return subScopeHelper(prefix, sanitizeTags(tags)); } @Override public Scope subScope(String name) { + name = sanitizer.name(name); return subScopeHelper(fullyQualifiedName(name), null); } @@ -136,6 +144,25 @@ public void close() { } } + private Map sanitizeTags(Map tags) { + boolean hasChange = false; + for (Map.Entry kv : tags.entrySet()) { + if(!sanitizer.key(kv.getKey()).equals(kv.getKey()) || !sanitizer.value(kv.getValue()).equals(kv.getValue())){ + hasChange = true; + break; + } + } + if(!hasChange){ + return tags; + } + + ImmutableMap.Builder builder = new ImmutableMap.Builder<>(); + if (tags != null) { + tags.forEach((key, value) -> builder.put(sanitizer.key(key), sanitizer.value(value))); + } + return builder.build(); + } + void addToReportingQueue(T metric) { reportingQueue.add(metric); } @@ -287,6 +314,7 @@ private Scope subScopeHelper(String prefix, Map tags) { .prefix(prefix) .separator(separator) .tags(mergedTags) + .sanitizer(sanitizer) .defaultBuckets(defaultBuckets) .build() ); From a772d579a793186c563a8a81ffb350213451c625 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Wed, 7 Apr 2021 18:34:35 -0700 Subject: [PATCH 03/23] rename and comment --- .../java/com/uber/m3/tally/ScopeBuilder.java | 6 ++-- .../java/com/uber/m3/tally/ScopeImpl.java | 18 +++++------ .../m3/tally/sanitizers/SanitizerBuilder.java | 14 ++++---- .../m3/tally/sanitizers/SanitizerImpl.java | 16 +++++----- .../{Sanitizer.java => ScopeSanitizer.java} | 17 +++++----- .../{Sanitize.java => StringSanitizer.java} | 5 +-- .../m3/tally/sanitizers/ValidCharacters.java | 2 +- .../m3/tally/sanitizers/SanitizerTest.java | 32 +++++++++---------- .../com/uber/m3/tally/m3/M3Sanitizer.java | 4 +-- .../com/uber/m3/tally/m3/M3SanitizerTest.java | 10 +++--- 10 files changed, 63 insertions(+), 61 deletions(-) rename core/src/main/java/com/uber/m3/tally/sanitizers/{Sanitizer.java => ScopeSanitizer.java} (76%) rename core/src/main/java/com/uber/m3/tally/sanitizers/{Sanitize.java => StringSanitizer.java} (88%) diff --git a/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java b/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java index ee8e8b0..77b25e7 100644 --- a/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java +++ b/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java @@ -20,7 +20,7 @@ package com.uber.m3.tally; -import com.uber.m3.tally.sanitizers.Sanitizer; +import com.uber.m3.tally.sanitizers.ScopeSanitizer; import com.uber.m3.tally.sanitizers.SanitizerBuilder; import com.uber.m3.util.Duration; import com.uber.m3.util.ImmutableMap; @@ -57,7 +57,7 @@ public class ScopeBuilder { protected String separator = DEFAULT_SEPARATOR; protected ImmutableMap tags; protected Buckets defaultBuckets = DEFAULT_SCOPE_BUCKETS; - protected Sanitizer sanitizer = new SanitizerBuilder().build(); + protected ScopeSanitizer sanitizer = new SanitizerBuilder().build(); private ScheduledExecutorService scheduler; private ScopeImpl.Registry registry; @@ -137,7 +137,7 @@ public ScopeBuilder defaultBuckets(Buckets defaultBuckets) { * @param sanitizer value to update to * @return Builder with new param updated */ - public ScopeBuilder sanitizer(Sanitizer sanitizer) { + public ScopeBuilder sanitizer(ScopeSanitizer sanitizer) { this.sanitizer = sanitizer; return this; } diff --git a/core/src/main/java/com/uber/m3/tally/ScopeImpl.java b/core/src/main/java/com/uber/m3/tally/ScopeImpl.java index a8f59d2..ce2fa65 100644 --- a/core/src/main/java/com/uber/m3/tally/ScopeImpl.java +++ b/core/src/main/java/com/uber/m3/tally/ScopeImpl.java @@ -20,7 +20,7 @@ package com.uber.m3.tally; -import com.uber.m3.tally.sanitizers.Sanitizer; +import com.uber.m3.tally.sanitizers.ScopeSanitizer; import com.uber.m3.util.ImmutableMap; import javax.annotation.Nullable; @@ -42,7 +42,7 @@ class ScopeImpl implements Scope { private String separator; private ImmutableMap tags; private Buckets defaultBuckets; - private Sanitizer sanitizer; + private ScopeSanitizer sanitizer; private ScheduledExecutorService scheduler; private Registry registry; @@ -70,7 +70,7 @@ class ScopeImpl implements Scope { @Override public Counter counter(String name) { - name = sanitizer.name(name); + name = sanitizer.sanitizeName(name); return counters.computeIfAbsent(name, ignored -> // NOTE: This will called at most once new CounterImpl(this, fullyQualifiedName(name)) @@ -79,7 +79,7 @@ public Counter counter(String name) { @Override public Gauge gauge(String name) { - name = sanitizer.name(name); + name = sanitizer.sanitizeName(name); return gauges.computeIfAbsent(name, ignored -> // NOTE: This will called at most once new GaugeImpl(this, fullyQualifiedName(name))); @@ -87,7 +87,7 @@ public Gauge gauge(String name) { @Override public Timer timer(String name) { - name = sanitizer.name(name); + name = sanitizer.sanitizeName(name); // Timers report directly to the {@code StatsReporter}, and therefore not added to reporting queue // i.e. they are not buffered return timers.computeIfAbsent(name, ignored -> new TimerImpl(fullyQualifiedName(name), tags, reporter)); @@ -95,7 +95,7 @@ public Timer timer(String name) { @Override public Histogram histogram(String name, @Nullable Buckets buckets) { - name = sanitizer.name(name); + name = sanitizer.sanitizeName(name); return histograms.computeIfAbsent(name, ignored -> // NOTE: This will called at most once new HistogramImpl( @@ -115,7 +115,7 @@ public Scope tagged(Map tags) { @Override public Scope subScope(String name) { - name = sanitizer.name(name); + name = sanitizer.sanitizeName(name); return subScopeHelper(fullyQualifiedName(name), null); } @@ -147,7 +147,7 @@ public void close() { private Map sanitizeTags(Map tags) { boolean hasChange = false; for (Map.Entry kv : tags.entrySet()) { - if(!sanitizer.key(kv.getKey()).equals(kv.getKey()) || !sanitizer.value(kv.getValue()).equals(kv.getValue())){ + if(!sanitizer.sanitizeKey(kv.getKey()).equals(kv.getKey()) || !sanitizer.sanitizeValue(kv.getValue()).equals(kv.getValue())){ hasChange = true; break; } @@ -158,7 +158,7 @@ private Map sanitizeTags(Map tags) { ImmutableMap.Builder builder = new ImmutableMap.Builder<>(); if (tags != null) { - tags.forEach((key, value) -> builder.put(sanitizer.key(key), sanitizer.value(value))); + tags.forEach((key, value) -> builder.put(sanitizer.sanitizeKey(key), sanitizer.sanitizeValue(value))); } return builder.build(); } diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerBuilder.java b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerBuilder.java index 27ed255..14340bf 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerBuilder.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerBuilder.java @@ -28,26 +28,26 @@ */ public class SanitizerBuilder { - private Sanitize nameSanitizer = value -> value; - private Sanitize keySanitizer = value -> value; - private Sanitize valueSanitizer = value -> value; + private StringSanitizer nameSanitizer = value -> value; + private StringSanitizer keySanitizer = value -> value; + private StringSanitizer valueSanitizer = value -> value; private char repChar = ValidCharacters.DEFAULT_REPLACEMENT_CHARACTER; private ValidCharacters nameCharacters; private ValidCharacters keyCharacters; private ValidCharacters valueCharacters; - public SanitizerBuilder withNameSanitizer(Sanitize nameSanitizer) { + public SanitizerBuilder withNameSanitizer(StringSanitizer nameSanitizer) { this.nameSanitizer = nameSanitizer; return this; } - public SanitizerBuilder withKeySanitizer(Sanitize keySanitizer) { + public SanitizerBuilder withKeySanitizer(StringSanitizer keySanitizer) { this.keySanitizer = keySanitizer; return this; } - public SanitizerBuilder withValueSanitizer(Sanitize valueSanitizer) { + public SanitizerBuilder withValueSanitizer(StringSanitizer valueSanitizer) { this.valueSanitizer = valueSanitizer; return this; } @@ -72,7 +72,7 @@ public SanitizerBuilder withValueCharacters(ValidCharacters valueCharacters) { return this; } - public Sanitizer build() { + public ScopeSanitizer build() { if (nameCharacters != null) { nameSanitizer = nameCharacters.sanitize(repChar); } diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java index 75f53c5..d41fa28 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java @@ -23,13 +23,13 @@ /** * SanitizerImpl sanitizes the provided input based on the function executed. */ -class SanitizerImpl implements Sanitizer { +class SanitizerImpl implements ScopeSanitizer { - private final Sanitize nameSanitizer; - private final Sanitize keySanitizer; - private final Sanitize valueSanitizer; + private final StringSanitizer nameSanitizer; + private final StringSanitizer keySanitizer; + private final StringSanitizer valueSanitizer; - SanitizerImpl(Sanitize nameSanitizer, Sanitize keySanitizer, Sanitize valueSanitizer) { + SanitizerImpl(StringSanitizer nameSanitizer, StringSanitizer keySanitizer, StringSanitizer valueSanitizer) { this.nameSanitizer = nameSanitizer; this.keySanitizer = keySanitizer; this.valueSanitizer = valueSanitizer; @@ -41,7 +41,7 @@ class SanitizerImpl implements Sanitizer { * @return the sanitized name */ @Override - public String name(String name) { + public String sanitizeName(String name) { return this.nameSanitizer.sanitize(name); } @@ -51,7 +51,7 @@ public String name(String name) { * @return the sanitized key */ @Override - public String key(String key) { + public String sanitizeKey(String key) { return this.keySanitizer.sanitize(key); } @@ -61,7 +61,7 @@ public String key(String key) { * @return the sanitized value */ @Override - public String value(String value) { + public String sanitizeValue(String value) { return this.valueSanitizer.sanitize(value); } } diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/Sanitizer.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizer.java similarity index 76% rename from core/src/main/java/com/uber/m3/tally/sanitizers/Sanitizer.java rename to core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizer.java index 731b784..1bd7198 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/Sanitizer.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizer.java @@ -21,28 +21,29 @@ package com.uber.m3.tally.sanitizers; /** - * SanitizerImpl sanitizes the provided input based on the function executed. + * SanitizerImpl sanitizes scope properties: name, key and value + * for counter/timer/histogram/gauge/tags/etc */ -public interface Sanitizer { +public interface ScopeSanitizer { /** - * Name sanitizes the provided 'name' string. + * Name sanitizes the provided 'name' of counter/timer/histogram/gauge/etc * @param name the name string * @return the sanitized name */ - String name(String name); + String sanitizeName(String name); /** - * Key sanitizes the provided 'key' string. + * Key sanitizes the provided 'key' of a tag * @param key the key string * @return the sanitized key */ - String key(String key); + String sanitizeKey(String key); /** - * Value sanitizes the provided 'value' string. + * Value sanitizes the provided 'value' of a tag * @param value the value string * @return the sanitized value */ - String value(String value); + String sanitizeValue(String value); } diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/Sanitize.java b/core/src/main/java/com/uber/m3/tally/sanitizers/StringSanitizer.java similarity index 88% rename from core/src/main/java/com/uber/m3/tally/sanitizers/Sanitize.java rename to core/src/main/java/com/uber/m3/tally/sanitizers/StringSanitizer.java index bcb5f53..04a4861 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/Sanitize.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/StringSanitizer.java @@ -21,9 +21,10 @@ package com.uber.m3.tally.sanitizers; /** - * Sanitize returns a sanitized version of the input string value. + * StringSanitizer is to sanitize strings + * It has a Sanitize method which returns a sanitized version of the input string value. */ -public interface Sanitize { +public interface StringSanitizer { /** * Sanitize the input string value. diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java index 4e00104..291353a 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java @@ -70,7 +70,7 @@ public static ValidCharacters of(List ranges, List cha return new ValidCharacters(ranges, characters); } - Sanitize sanitize(char repChar) { + StringSanitizer sanitize(char repChar) { return value -> { StringBuilder buffer = null; diff --git a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java b/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java index ed7825e..69f2807 100644 --- a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java +++ b/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java @@ -42,28 +42,28 @@ public class SanitizerTest { @Test public void noopSanitizer() { - Sanitizer sanitizer = new SanitizerBuilder().build(); - assertEquals(NAME, sanitizer.name(NAME)); - assertEquals(KEY, sanitizer.key(KEY)); - assertEquals(VALUE, sanitizer.value(VALUE)); + ScopeSanitizer sanitizer = new SanitizerBuilder().build(); + assertEquals(NAME, sanitizer.sanitizeName(NAME)); + assertEquals(KEY, sanitizer.sanitizeKey(KEY)); + assertEquals(VALUE, sanitizer.sanitizeValue(VALUE)); } @Test public void withSanitizers() { - Sanitizer sanitizer = + ScopeSanitizer sanitizer = new SanitizerBuilder() .withNameSanitizer(value -> SANITIZED_NAME_1) .withKeySanitizer(value -> SANITIZED_KEY_1) .withValueSanitizer(value -> SANITIZED_VALUE_1) .build(); - assertEquals(SANITIZED_NAME_1, sanitizer.name(NAME)); - assertEquals(SANITIZED_KEY_1, sanitizer.key(KEY)); - assertEquals(SANITIZED_VALUE_1, sanitizer.value(VALUE)); + assertEquals(SANITIZED_NAME_1, sanitizer.sanitizeName(NAME)); + assertEquals(SANITIZED_KEY_1, sanitizer.sanitizeKey(KEY)); + assertEquals(SANITIZED_VALUE_1, sanitizer.sanitizeValue(VALUE)); } @Test public void withValidCharactersAndDefaultRepChar() { - Sanitizer sanitizer = + ScopeSanitizer sanitizer = new SanitizerBuilder() .withNameCharacters( ValidCharacters.of( @@ -78,14 +78,14 @@ public void withValidCharactersAndDefaultRepChar() { ValidCharacters.ALPHANUMERIC_RANGE, ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) .build(); - assertEquals(SANITIZED_NAME_2, sanitizer.name(NAME)); - assertEquals(SANITIZED_KEY_2, sanitizer.key(KEY)); - assertEquals(SANITIZED_VALUE_2, sanitizer.value(VALUE)); + assertEquals(SANITIZED_NAME_2, sanitizer.sanitizeName(NAME)); + assertEquals(SANITIZED_KEY_2, sanitizer.sanitizeKey(KEY)); + assertEquals(SANITIZED_VALUE_2, sanitizer.sanitizeValue(VALUE)); } @Test public void withValidCharactersAndRepChar() { - Sanitizer sanitizer = + ScopeSanitizer sanitizer = new SanitizerBuilder() .withReplacementCharacter(REPLACEMENT_CHAR) .withNameCharacters( @@ -101,8 +101,8 @@ public void withValidCharactersAndRepChar() { ValidCharacters.ALPHANUMERIC_RANGE, ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) .build(); - assertEquals(SANITIZED_NAME_3, sanitizer.name(NAME)); - assertEquals(SANITIZED_KEY_3, sanitizer.key(KEY)); - assertEquals(SANITIZED_VALUE_3, sanitizer.value(VALUE)); + assertEquals(SANITIZED_NAME_3, sanitizer.sanitizeName(NAME)); + assertEquals(SANITIZED_KEY_3, sanitizer.sanitizeKey(KEY)); + assertEquals(SANITIZED_VALUE_3, sanitizer.sanitizeValue(VALUE)); } } diff --git a/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java b/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java index fbba346..fa97c13 100644 --- a/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java +++ b/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java @@ -20,7 +20,7 @@ package com.uber.m3.tally.m3; -import com.uber.m3.tally.sanitizers.Sanitizer; +import com.uber.m3.tally.sanitizers.ScopeSanitizer; import com.uber.m3.tally.sanitizers.SanitizerBuilder; import com.uber.m3.tally.sanitizers.ValidCharacters; @@ -30,7 +30,7 @@ public class M3Sanitizer { * Creates the default M3 sanitizer. * @return default M3 sanitizer */ - public static Sanitizer create() { + public static ScopeSanitizer create() { return new SanitizerBuilder() .withReplacementCharacter(ValidCharacters.DEFAULT_REPLACEMENT_CHARACTER) .withNameCharacters( diff --git a/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java b/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java index abfd933..c9bf1ab 100644 --- a/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java +++ b/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java @@ -20,7 +20,7 @@ package com.uber.m3.tally.m3; -import com.uber.m3.tally.sanitizers.Sanitizer; +import com.uber.m3.tally.sanitizers.ScopeSanitizer; import org.junit.Test; import static org.junit.Assert.*; @@ -36,10 +36,10 @@ public class M3SanitizerTest { @Test public void m3Sanitizer() { - Sanitizer sanitizer = M3Sanitizer.create(); + ScopeSanitizer sanitizer = M3Sanitizer.create(); assertNotNull(sanitizer); - assertEquals(SANITIZED_NAME, sanitizer.name(NAME)); - assertEquals(SANITIZED_KEY, sanitizer.key(KEY)); - assertEquals(SANITIZED_VALUE, sanitizer.value(VALUE)); + assertEquals(SANITIZED_NAME, sanitizer.sanitizeName(NAME)); + assertEquals(SANITIZED_KEY, sanitizer.sanitizeKey(KEY)); + assertEquals(SANITIZED_VALUE, sanitizer.sanitizeValue(VALUE)); } } From a188eeef10a063c8b9b7abd49fb75f63a868614a Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Wed, 7 Apr 2021 18:43:19 -0700 Subject: [PATCH 04/23] fix error --- .../java/com/uber/m3/tally/ScopeImpl.java | 26 +++++++++---------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/core/src/main/java/com/uber/m3/tally/ScopeImpl.java b/core/src/main/java/com/uber/m3/tally/ScopeImpl.java index ce2fa65..5f55204 100644 --- a/core/src/main/java/com/uber/m3/tally/ScopeImpl.java +++ b/core/src/main/java/com/uber/m3/tally/ScopeImpl.java @@ -70,37 +70,37 @@ class ScopeImpl implements Scope { @Override public Counter counter(String name) { - name = sanitizer.sanitizeName(name); - return counters.computeIfAbsent(name, ignored -> + final String finalName = sanitizer.sanitizeName(name); + return counters.computeIfAbsent(finalName, ignored -> // NOTE: This will called at most once - new CounterImpl(this, fullyQualifiedName(name)) + new CounterImpl(this, fullyQualifiedName(finalName)) ); } @Override public Gauge gauge(String name) { - name = sanitizer.sanitizeName(name); - return gauges.computeIfAbsent(name, ignored -> + final String finalName = sanitizer.sanitizeName(name); + return gauges.computeIfAbsent(finalName, ignored -> // NOTE: This will called at most once - new GaugeImpl(this, fullyQualifiedName(name))); + new GaugeImpl(this, fullyQualifiedName(finalName))); } @Override public Timer timer(String name) { - name = sanitizer.sanitizeName(name); + final String finalName = sanitizer.sanitizeName(name); // Timers report directly to the {@code StatsReporter}, and therefore not added to reporting queue // i.e. they are not buffered - return timers.computeIfAbsent(name, ignored -> new TimerImpl(fullyQualifiedName(name), tags, reporter)); + return timers.computeIfAbsent(finalName, ignored -> new TimerImpl(fullyQualifiedName(finalName), tags, reporter)); } @Override public Histogram histogram(String name, @Nullable Buckets buckets) { - name = sanitizer.sanitizeName(name); - return histograms.computeIfAbsent(name, ignored -> + final String finalName = sanitizer.sanitizeName(name); + return histograms.computeIfAbsent(finalName, ignored -> // NOTE: This will called at most once new HistogramImpl( this, - fullyQualifiedName(name), + fullyQualifiedName(finalName), tags, Optional.ofNullable(buckets) .orElse(defaultBuckets) @@ -115,8 +115,8 @@ public Scope tagged(Map tags) { @Override public Scope subScope(String name) { - name = sanitizer.sanitizeName(name); - return subScopeHelper(fullyQualifiedName(name), null); + final String finalName = sanitizer.sanitizeName(name); + return subScopeHelper(fullyQualifiedName(finalName), null); } @Override From fc8f1aace97dcdc7e950bb0e134d95457803c461 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Wed, 7 Apr 2021 18:44:16 -0700 Subject: [PATCH 05/23] rename --- .../java/com/uber/m3/tally/ScopeBuilder.java | 4 ++-- ...erBuilder.java => ScopeSanitizerBuilder.java} | 16 ++++++++-------- .../uber/m3/tally/sanitizers/SanitizerTest.java | 8 ++++---- .../java/com/uber/m3/tally/m3/M3Sanitizer.java | 4 ++-- 4 files changed, 16 insertions(+), 16 deletions(-) rename core/src/main/java/com/uber/m3/tally/sanitizers/{SanitizerBuilder.java => ScopeSanitizerBuilder.java} (81%) diff --git a/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java b/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java index 77b25e7..aebd334 100644 --- a/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java +++ b/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java @@ -21,7 +21,7 @@ package com.uber.m3.tally; import com.uber.m3.tally.sanitizers.ScopeSanitizer; -import com.uber.m3.tally.sanitizers.SanitizerBuilder; +import com.uber.m3.tally.sanitizers.ScopeSanitizerBuilder; import com.uber.m3.util.Duration; import com.uber.m3.util.ImmutableMap; @@ -57,7 +57,7 @@ public class ScopeBuilder { protected String separator = DEFAULT_SEPARATOR; protected ImmutableMap tags; protected Buckets defaultBuckets = DEFAULT_SCOPE_BUCKETS; - protected ScopeSanitizer sanitizer = new SanitizerBuilder().build(); + protected ScopeSanitizer sanitizer = new ScopeSanitizerBuilder().build(); private ScheduledExecutorService scheduler; private ScopeImpl.Registry registry; diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerBuilder.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java similarity index 81% rename from core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerBuilder.java rename to core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java index 14340bf..73c0e65 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerBuilder.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java @@ -26,7 +26,7 @@ * untouched. Custom name, key or value Sanitize functions or ValidCharacters * can be provided to override their default behaviour. */ -public class SanitizerBuilder { +public class ScopeSanitizerBuilder { private StringSanitizer nameSanitizer = value -> value; private StringSanitizer keySanitizer = value -> value; @@ -37,37 +37,37 @@ public class SanitizerBuilder { private ValidCharacters keyCharacters; private ValidCharacters valueCharacters; - public SanitizerBuilder withNameSanitizer(StringSanitizer nameSanitizer) { + public ScopeSanitizerBuilder withNameSanitizer(StringSanitizer nameSanitizer) { this.nameSanitizer = nameSanitizer; return this; } - public SanitizerBuilder withKeySanitizer(StringSanitizer keySanitizer) { + public ScopeSanitizerBuilder withKeySanitizer(StringSanitizer keySanitizer) { this.keySanitizer = keySanitizer; return this; } - public SanitizerBuilder withValueSanitizer(StringSanitizer valueSanitizer) { + public ScopeSanitizerBuilder withValueSanitizer(StringSanitizer valueSanitizer) { this.valueSanitizer = valueSanitizer; return this; } - public SanitizerBuilder withReplacementCharacter(char repChar) { + public ScopeSanitizerBuilder withReplacementCharacter(char repChar) { this.repChar = repChar; return this; } - public SanitizerBuilder withNameCharacters(ValidCharacters nameCharacters) { + public ScopeSanitizerBuilder withNameCharacters(ValidCharacters nameCharacters) { this.nameCharacters = nameCharacters; return this; } - public SanitizerBuilder withKeyCharacters(ValidCharacters keyCharacters) { + public ScopeSanitizerBuilder withKeyCharacters(ValidCharacters keyCharacters) { this.keyCharacters = keyCharacters; return this; } - public SanitizerBuilder withValueCharacters(ValidCharacters valueCharacters) { + public ScopeSanitizerBuilder withValueCharacters(ValidCharacters valueCharacters) { this.valueCharacters = valueCharacters; return this; } diff --git a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java b/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java index 69f2807..4b8b456 100644 --- a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java +++ b/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java @@ -42,7 +42,7 @@ public class SanitizerTest { @Test public void noopSanitizer() { - ScopeSanitizer sanitizer = new SanitizerBuilder().build(); + ScopeSanitizer sanitizer = new ScopeSanitizerBuilder().build(); assertEquals(NAME, sanitizer.sanitizeName(NAME)); assertEquals(KEY, sanitizer.sanitizeKey(KEY)); assertEquals(VALUE, sanitizer.sanitizeValue(VALUE)); @@ -51,7 +51,7 @@ public void noopSanitizer() { @Test public void withSanitizers() { ScopeSanitizer sanitizer = - new SanitizerBuilder() + new ScopeSanitizerBuilder() .withNameSanitizer(value -> SANITIZED_NAME_1) .withKeySanitizer(value -> SANITIZED_KEY_1) .withValueSanitizer(value -> SANITIZED_VALUE_1) @@ -64,7 +64,7 @@ public void withSanitizers() { @Test public void withValidCharactersAndDefaultRepChar() { ScopeSanitizer sanitizer = - new SanitizerBuilder() + new ScopeSanitizerBuilder() .withNameCharacters( ValidCharacters.of( ValidCharacters.ALPHANUMERIC_RANGE, @@ -86,7 +86,7 @@ public void withValidCharactersAndDefaultRepChar() { @Test public void withValidCharactersAndRepChar() { ScopeSanitizer sanitizer = - new SanitizerBuilder() + new ScopeSanitizerBuilder() .withReplacementCharacter(REPLACEMENT_CHAR) .withNameCharacters( ValidCharacters.of( diff --git a/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java b/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java index fa97c13..5b6d956 100644 --- a/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java +++ b/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java @@ -21,7 +21,7 @@ package com.uber.m3.tally.m3; import com.uber.m3.tally.sanitizers.ScopeSanitizer; -import com.uber.m3.tally.sanitizers.SanitizerBuilder; +import com.uber.m3.tally.sanitizers.ScopeSanitizerBuilder; import com.uber.m3.tally.sanitizers.ValidCharacters; public class M3Sanitizer { @@ -31,7 +31,7 @@ public class M3Sanitizer { * @return default M3 sanitizer */ public static ScopeSanitizer create() { - return new SanitizerBuilder() + return new ScopeSanitizerBuilder() .withReplacementCharacter(ValidCharacters.DEFAULT_REPLACEMENT_CHARACTER) .withNameCharacters( ValidCharacters.of( From edc0a4e4bacc7e298e4f5f6d1a70e8673eae43bd Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Sat, 10 Apr 2021 11:35:42 -0700 Subject: [PATCH 06/23] fix test --- .../java/com/uber/m3/tally/ScopeImplTest.java | 75 ++++++++----------- 1 file changed, 33 insertions(+), 42 deletions(-) diff --git a/core/src/test/java/com/uber/m3/tally/ScopeImplTest.java b/core/src/test/java/com/uber/m3/tally/ScopeImplTest.java index 4266437..d5dbd28 100644 --- a/core/src/test/java/com/uber/m3/tally/ScopeImplTest.java +++ b/core/src/test/java/com/uber/m3/tally/ScopeImplTest.java @@ -20,17 +20,19 @@ package com.uber.m3.tally; -import com.uber.m3.util.Duration; -import com.uber.m3.util.ImmutableMap; -import org.junit.Test; - import java.lang.Thread.UncaughtExceptionHandler; import java.util.HashMap; import java.util.Map; import java.util.concurrent.atomic.AtomicInteger; +import org.junit.Test; + +import com.uber.m3.util.Duration; +import com.uber.m3.util.ImmutableMap; + import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; public class ScopeImplTest { private static final double EPSILON = 1e-10; @@ -52,21 +54,21 @@ public void metricCreation() { Counter sameCounter = scope.counter("new-counter"); // Should be the same Counter object and not a new instance - assertEquals(counter, sameCounter); + assertTrue(counter == sameCounter); Gauge gauge = scope.gauge("new-gauge"); assertNotNull(gauge); Gauge sameGauge = scope.gauge("new-gauge"); // Should be the same Gauge object and not a new instance - assertEquals(gauge, sameGauge); + assertTrue(gauge == sameGauge); Timer timer = scope.timer("new-timer"); assertNotNull(timer); Timer sameTimer = scope.timer("new-timer"); // Should be the same Timer object and not a new instance - assertEquals(timer, sameTimer); + assertTrue(timer == sameTimer); Histogram histogram = scope.histogram( "new-histogram", @@ -83,7 +85,7 @@ public void metricCreation() { Histogram sameHistogram = scope.histogram("new-histogram", null); // Should be the same Histogram object and not a new instance - assertEquals(histogram, sameHistogram); + assertTrue(histogram == sameHistogram); } @Test @@ -156,9 +158,9 @@ public void subscopes() { ImmutableMap additionalTags = new ImmutableMap.Builder(2) - .put("new_key", "new_val") - .put("baz", "quz") - .build(); + .put("new_key", "new_val") + .put("baz", "quz") + .build(); Scope taggedSubscope = rootScope.tagged(additionalTags); Timer taggedTimer = taggedSubscope.timer("tagged_timer"); taggedTimer.record(Duration.ofSeconds(6)); @@ -185,9 +187,9 @@ public void subscopes() { assertEquals("tagged_timer", timer.getName()); ImmutableMap expectedTags = new ImmutableMap.Builder(4) - .putAll(tags) - .putAll(additionalTags) - .build(); + .putAll(tags) + .putAll(additionalTags) + .build(); assertEquals(expectedTags, timer.getTags()); } @@ -227,29 +229,24 @@ public void snapshot() { Map counters = snapshot.counters(); assertEquals(1, counters.size()); assertEquals("snapshot-counter", counters.get("snapshot-counter+").name()); - assertNotNull(counters.get("snapshot-counter+").tags()); - assertEquals(0, counters.get("snapshot-counter+").tags().size()); + assertEquals(null, counters.get("snapshot-counter+").tags()); Map gauges = snapshot.gauges(); assertEquals(3, gauges.size()); assertEquals("snapshot-gauge", gauges.get("snapshot-gauge+").name()); - assertNotNull(gauges.get("snapshot-gauge+").tags()); - assertEquals(0, gauges.get("snapshot-gauge+").tags().size()); + assertEquals(null, gauges.get("snapshot-gauge+").tags()); assertEquals(120, gauges.get("snapshot-gauge+").value(), EPSILON); assertEquals("snapshot-gauge2", gauges.get("snapshot-gauge2+").name()); - assertNotNull(gauges.get("snapshot-gauge2+").tags()); - assertEquals(0, gauges.get("snapshot-gauge2+").tags().size()); + assertEquals(null, gauges.get("snapshot-gauge2+").tags()); assertEquals(220, gauges.get("snapshot-gauge2+").value(), EPSILON); assertEquals("snapshot-gauge3", gauges.get("snapshot-gauge3+").name()); - assertNotNull(gauges.get("snapshot-gauge3+").tags()); - assertEquals(0, gauges.get("snapshot-gauge3+").tags().size()); + assertEquals(null, gauges.get("snapshot-gauge3+").tags()); assertEquals(320, gauges.get("snapshot-gauge3+").value(), EPSILON); Map timers = snapshot.timers(); assertEquals(1, timers.size()); assertEquals("snapshot-timer", timers.get("snapshot-timer+").name()); - assertNotNull(timers.get("snapshot-timer+").tags()); - assertEquals(0, timers.get("snapshot-timer+").tags().size()); + assertEquals(null, timers.get("snapshot-timer+").tags()); } @Test(expected = IllegalArgumentException.class) @@ -268,10 +265,12 @@ public void uncaughtException(Thread t, Throwable e) { } }; - try (Scope scope = new RootScopeBuilder() + Scope scope = new RootScopeBuilder() .reporter(reporter) - .reportEvery(Duration.ofMillis(REPORT_INTERVAL_MILLIS), uncaughtExceptionHandler)) { + .reportEvery(Duration.ofMillis(REPORT_INTERVAL_MILLIS), + uncaughtExceptionHandler); + try { scope.counter("hi").inc(1); Thread.sleep(SLEEP_MILLIS); @@ -284,6 +283,8 @@ public void uncaughtException(Thread t, Throwable e) { assertEquals(2, uncaghtExceptionReported.get()); assertEquals(2, reporter.getNumberOfReportedMetrics()); + } finally { + scope.close(); } } @@ -313,27 +314,17 @@ public void reportTimer(String name, Map tags, Duration interval } @Override - public void reportHistogramValueSamples( - String name, - Map tags, - Buckets buckets, - double bucketLowerBound, - double bucketUpperBound, - long samples - ) { + public void reportHistogramValueSamples(String name, Map tags, + Buckets buckets, double bucketLowerBound, + double bucketUpperBound, long samples) { reported.incrementAndGet(); throw new RuntimeException(); } @Override - public void reportHistogramDurationSamples( - String name, - Map tags, - Buckets buckets, - Duration bucketLowerBound, - Duration bucketUpperBound, - long samples - ) { + public void reportHistogramDurationSamples(String name, Map tags, + Buckets buckets, Duration bucketLowerBound, + Duration bucketUpperBound, long samples) { reported.incrementAndGet(); throw new RuntimeException(); } From d8fdac934563617aa6b3c85da306f28a3135d857 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Sat, 10 Apr 2021 11:46:04 -0700 Subject: [PATCH 07/23] fix style --- .../java/com/uber/m3/tally/ScopeImpl.java | 26 ++++++++++--------- 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/core/src/main/java/com/uber/m3/tally/ScopeImpl.java b/core/src/main/java/com/uber/m3/tally/ScopeImpl.java index 5f55204..c472d66 100644 --- a/core/src/main/java/com/uber/m3/tally/ScopeImpl.java +++ b/core/src/main/java/com/uber/m3/tally/ScopeImpl.java @@ -147,12 +147,12 @@ public void close() { private Map sanitizeTags(Map tags) { boolean hasChange = false; for (Map.Entry kv : tags.entrySet()) { - if(!sanitizer.sanitizeKey(kv.getKey()).equals(kv.getKey()) || !sanitizer.sanitizeValue(kv.getValue()).equals(kv.getValue())){ + if (!sanitizer.sanitizeKey(kv.getKey()).equals(kv.getKey()) || !sanitizer.sanitizeValue(kv.getValue()).equals(kv.getValue())) { hasChange = true; break; } } - if(!hasChange){ + if (!hasChange) { return tags; } @@ -169,6 +169,7 @@ void addToReportingQueue(T metric) { /** * Reports using the specified reporter. + * * @param reporter the reporter to report */ void report(StatsReporter reporter) { @@ -220,6 +221,7 @@ String fullyQualifiedName(String name) { /** * Returns a {@link Snapshot} of this {@link Scope}. + * * @return a {@link Snapshot} of this {@link Scope} */ public Snapshot snapshot() { @@ -308,15 +310,15 @@ private Scope subScopeHelper(String prefix, Map tags) { String key = keyForPrefixedStringMap(prefix, mergedTags); return registry.subscopes.computeIfAbsent( - key, - (k) -> new ScopeBuilder(scheduler, registry) - .reporter(reporter) - .prefix(prefix) - .separator(separator) - .tags(mergedTags) - .sanitizer(sanitizer) - .defaultBuckets(defaultBuckets) - .build() + key, + (k) -> new ScopeBuilder(scheduler, registry) + .reporter(reporter) + .prefix(prefix) + .separator(separator) + .tags(mergedTags) + .sanitizer(sanitizer) + .defaultBuckets(defaultBuckets) + .build() ); } @@ -362,4 +364,4 @@ private void reportUncaughtException(Exception uncaughtException) { static class Registry { Map subscopes = new ConcurrentHashMap<>(); } -} \ No newline at end of file +} From 45243d8b5389bb0f0c21f2cc67a4e9b9b3f64a7c Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Thu, 15 Apr 2021 22:27:49 -0700 Subject: [PATCH 08/23] adderss comments --- .../main/java/com/uber/m3/tally/ScopeImpl.java | 4 ++-- .../{SanitizeRange.java => CharRange.java} | 13 ++++++++----- .../uber/m3/tally/sanitizers/SanitizerImpl.java | 4 ++-- .../uber/m3/tally/sanitizers/ScopeSanitizer.java | 4 ++-- .../m3/tally/sanitizers/ValidCharacters.java | 14 +++++++------- .../m3/tally/sanitizers/SanitizeRangeTest.java | 2 +- .../uber/m3/tally/sanitizers/SanitizerTest.java | 16 ++++++++-------- .../com/uber/m3/tally/m3/M3SanitizerTest.java | 4 ++-- 8 files changed, 32 insertions(+), 29 deletions(-) rename core/src/main/java/com/uber/m3/tally/sanitizers/{SanitizeRange.java => CharRange.java} (80%) diff --git a/core/src/main/java/com/uber/m3/tally/ScopeImpl.java b/core/src/main/java/com/uber/m3/tally/ScopeImpl.java index c472d66..146b0b2 100644 --- a/core/src/main/java/com/uber/m3/tally/ScopeImpl.java +++ b/core/src/main/java/com/uber/m3/tally/ScopeImpl.java @@ -147,7 +147,7 @@ public void close() { private Map sanitizeTags(Map tags) { boolean hasChange = false; for (Map.Entry kv : tags.entrySet()) { - if (!sanitizer.sanitizeKey(kv.getKey()).equals(kv.getKey()) || !sanitizer.sanitizeValue(kv.getValue()).equals(kv.getValue())) { + if (!sanitizer.sanitizeTagKey(kv.getKey()).equals(kv.getKey()) || !sanitizer.sanitizeTagValue(kv.getValue()).equals(kv.getValue())) { hasChange = true; break; } @@ -158,7 +158,7 @@ private Map sanitizeTags(Map tags) { ImmutableMap.Builder builder = new ImmutableMap.Builder<>(); if (tags != null) { - tags.forEach((key, value) -> builder.put(sanitizer.sanitizeKey(key), sanitizer.sanitizeValue(value))); + tags.forEach((key, value) -> builder.put(sanitizer.sanitizeTagKey(key), sanitizer.sanitizeTagValue(value))); } return builder.build(); } diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizeRange.java b/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java similarity index 80% rename from core/src/main/java/com/uber/m3/tally/sanitizers/SanitizeRange.java rename to core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java index 0b6b841..03476ee 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizeRange.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java @@ -21,20 +21,23 @@ package com.uber.m3.tally.sanitizers; /** - * SanitizeRange is a range of characters (inclusive on both ends). + * CharRange is a range of characters (inclusive on both ends). */ -public class SanitizeRange { +public class CharRange { private final char low; private final char high; - private SanitizeRange(char low, char high) { + private CharRange(char low, char high) { + if (low > high){ + throw new RuntimeException("invalid CharRange"); + } this.low = low; this.high = high; } - public static SanitizeRange of(char low, char high) { - return new SanitizeRange(low, high); + public static CharRange of(char low, char high) { + return new CharRange(low, high); } char low() { diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java index d41fa28..3542926 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java @@ -51,7 +51,7 @@ public String sanitizeName(String name) { * @return the sanitized key */ @Override - public String sanitizeKey(String key) { + public String sanitizeTagKey(String key) { return this.keySanitizer.sanitize(key); } @@ -61,7 +61,7 @@ public String sanitizeKey(String key) { * @return the sanitized value */ @Override - public String sanitizeValue(String value) { + public String sanitizeTagValue(String value) { return this.valueSanitizer.sanitize(value); } } diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizer.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizer.java index 1bd7198..85624c8 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizer.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizer.java @@ -38,12 +38,12 @@ public interface ScopeSanitizer { * @param key the key string * @return the sanitized key */ - String sanitizeKey(String key); + String sanitizeTagKey(String key); /** * Value sanitizes the provided 'value' of a tag * @param value the value string * @return the sanitized value */ - String sanitizeValue(String value); + String sanitizeTagValue(String value); } diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java index 291353a..c830eae 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java @@ -37,11 +37,11 @@ public class ValidCharacters { /** * ALPHANUMERIC_RANGE is the range of alphanumeric characters. */ - public static final List ALPHANUMERIC_RANGE = + public static final List ALPHANUMERIC_RANGE = Arrays.asList( - SanitizeRange.of('a', 'z'), - SanitizeRange.of('A', 'Z'), - SanitizeRange.of('0', '9')); + CharRange.of('a', 'z'), + CharRange.of('A', 'Z'), + CharRange.of('0', '9')); /** * UNDERSCORE_CHARACTERS contains the underscore character. @@ -58,15 +58,15 @@ public class ValidCharacters { */ public static final List UNDERSCORE_DASH_DOT_CHARACTERS = Arrays.asList('_', '-', '.'); - private final List ranges; + private final List ranges; private final List characters; - private ValidCharacters(List ranges, List characters) { + private ValidCharacters(List ranges, List characters) { this.ranges = ranges != null ? ranges : Collections.emptyList(); this.characters = characters != null ? characters : Collections.emptyList(); } - public static ValidCharacters of(List ranges, List characters) { + public static ValidCharacters of(List ranges, List characters) { return new ValidCharacters(ranges, characters); } diff --git a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizeRangeTest.java b/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizeRangeTest.java index 3745edc..109e2e6 100644 --- a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizeRangeTest.java +++ b/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizeRangeTest.java @@ -32,7 +32,7 @@ public class SanitizeRangeTest { @Test public void sanitizeRange() { - SanitizeRange range = SanitizeRange.of(LOW, HIGH); + CharRange range = CharRange.of(LOW, HIGH); assertNotNull(range); assertEquals(LOW, range.low()); assertEquals(HIGH, range.high()); diff --git a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java b/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java index 4b8b456..3d84ef7 100644 --- a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java +++ b/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java @@ -44,8 +44,8 @@ public class SanitizerTest { public void noopSanitizer() { ScopeSanitizer sanitizer = new ScopeSanitizerBuilder().build(); assertEquals(NAME, sanitizer.sanitizeName(NAME)); - assertEquals(KEY, sanitizer.sanitizeKey(KEY)); - assertEquals(VALUE, sanitizer.sanitizeValue(VALUE)); + assertEquals(KEY, sanitizer.sanitizeTagKey(KEY)); + assertEquals(VALUE, sanitizer.sanitizeTagValue(VALUE)); } @Test @@ -57,8 +57,8 @@ public void withSanitizers() { .withValueSanitizer(value -> SANITIZED_VALUE_1) .build(); assertEquals(SANITIZED_NAME_1, sanitizer.sanitizeName(NAME)); - assertEquals(SANITIZED_KEY_1, sanitizer.sanitizeKey(KEY)); - assertEquals(SANITIZED_VALUE_1, sanitizer.sanitizeValue(VALUE)); + assertEquals(SANITIZED_KEY_1, sanitizer.sanitizeTagKey(KEY)); + assertEquals(SANITIZED_VALUE_1, sanitizer.sanitizeTagValue(VALUE)); } @Test @@ -79,8 +79,8 @@ public void withValidCharactersAndDefaultRepChar() { ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) .build(); assertEquals(SANITIZED_NAME_2, sanitizer.sanitizeName(NAME)); - assertEquals(SANITIZED_KEY_2, sanitizer.sanitizeKey(KEY)); - assertEquals(SANITIZED_VALUE_2, sanitizer.sanitizeValue(VALUE)); + assertEquals(SANITIZED_KEY_2, sanitizer.sanitizeTagKey(KEY)); + assertEquals(SANITIZED_VALUE_2, sanitizer.sanitizeTagValue(VALUE)); } @Test @@ -102,7 +102,7 @@ public void withValidCharactersAndRepChar() { ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) .build(); assertEquals(SANITIZED_NAME_3, sanitizer.sanitizeName(NAME)); - assertEquals(SANITIZED_KEY_3, sanitizer.sanitizeKey(KEY)); - assertEquals(SANITIZED_VALUE_3, sanitizer.sanitizeValue(VALUE)); + assertEquals(SANITIZED_KEY_3, sanitizer.sanitizeTagKey(KEY)); + assertEquals(SANITIZED_VALUE_3, sanitizer.sanitizeTagValue(VALUE)); } } diff --git a/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java b/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java index c9bf1ab..397db41 100644 --- a/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java +++ b/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java @@ -39,7 +39,7 @@ public void m3Sanitizer() { ScopeSanitizer sanitizer = M3Sanitizer.create(); assertNotNull(sanitizer); assertEquals(SANITIZED_NAME, sanitizer.sanitizeName(NAME)); - assertEquals(SANITIZED_KEY, sanitizer.sanitizeKey(KEY)); - assertEquals(SANITIZED_VALUE, sanitizer.sanitizeValue(VALUE)); + assertEquals(SANITIZED_KEY, sanitizer.sanitizeTagKey(KEY)); + assertEquals(SANITIZED_VALUE, sanitizer.sanitizeTagValue(VALUE)); } } From a27e6d361b8a18f23a84414226d6f71765184d6f Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Thu, 15 Apr 2021 22:35:10 -0700 Subject: [PATCH 09/23] Use Function interface --- .../m3/tally/sanitizers/SanitizerImpl.java | 16 +++++---- .../sanitizers/ScopeSanitizerBuilder.java | 20 ++++++----- .../m3/tally/sanitizers/StringSanitizer.java | 35 ------------------- .../m3/tally/sanitizers/ValidCharacters.java | 3 +- 4 files changed, 22 insertions(+), 52 deletions(-) delete mode 100644 core/src/main/java/com/uber/m3/tally/sanitizers/StringSanitizer.java diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java index 3542926..5d9b6cc 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java @@ -20,16 +20,18 @@ package com.uber.m3.tally.sanitizers; +import java.util.function.Function; + /** * SanitizerImpl sanitizes the provided input based on the function executed. */ class SanitizerImpl implements ScopeSanitizer { - private final StringSanitizer nameSanitizer; - private final StringSanitizer keySanitizer; - private final StringSanitizer valueSanitizer; + private final Function nameSanitizer; + private final Function keySanitizer; + private final Function valueSanitizer; - SanitizerImpl(StringSanitizer nameSanitizer, StringSanitizer keySanitizer, StringSanitizer valueSanitizer) { + SanitizerImpl(Function nameSanitizer, Function keySanitizer, Function valueSanitizer) { this.nameSanitizer = nameSanitizer; this.keySanitizer = keySanitizer; this.valueSanitizer = valueSanitizer; @@ -42,7 +44,7 @@ class SanitizerImpl implements ScopeSanitizer { */ @Override public String sanitizeName(String name) { - return this.nameSanitizer.sanitize(name); + return this.nameSanitizer.apply(name); } /** @@ -52,7 +54,7 @@ public String sanitizeName(String name) { */ @Override public String sanitizeTagKey(String key) { - return this.keySanitizer.sanitize(key); + return this.keySanitizer.apply(key); } /** @@ -62,6 +64,6 @@ public String sanitizeTagKey(String key) { */ @Override public String sanitizeTagValue(String value) { - return this.valueSanitizer.sanitize(value); + return this.valueSanitizer.apply(value); } } diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java index 73c0e65..f6e6e80 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java @@ -20,6 +20,8 @@ package com.uber.m3.tally.sanitizers; +import java.util.function.Function; + /** * The SanitizerBuilder returns a Sanitizer for the name, key and value. By * default, the name, key and value sanitize functions returns all the input @@ -28,26 +30,26 @@ */ public class ScopeSanitizerBuilder { - private StringSanitizer nameSanitizer = value -> value; - private StringSanitizer keySanitizer = value -> value; - private StringSanitizer valueSanitizer = value -> value; + private Function nameSanitizer = value -> value; + private Function keySanitizer = value -> value; + private Function valueSanitizer = value -> value; private char repChar = ValidCharacters.DEFAULT_REPLACEMENT_CHARACTER; private ValidCharacters nameCharacters; private ValidCharacters keyCharacters; private ValidCharacters valueCharacters; - public ScopeSanitizerBuilder withNameSanitizer(StringSanitizer nameSanitizer) { + public ScopeSanitizerBuilder withNameSanitizer(Function nameSanitizer) { this.nameSanitizer = nameSanitizer; return this; } - public ScopeSanitizerBuilder withKeySanitizer(StringSanitizer keySanitizer) { + public ScopeSanitizerBuilder withKeySanitizer(Function keySanitizer) { this.keySanitizer = keySanitizer; return this; } - public ScopeSanitizerBuilder withValueSanitizer(StringSanitizer valueSanitizer) { + public ScopeSanitizerBuilder withValueSanitizer(Function valueSanitizer) { this.valueSanitizer = valueSanitizer; return this; } @@ -74,13 +76,13 @@ public ScopeSanitizerBuilder withValueCharacters(ValidCharacters valueCharacters public ScopeSanitizer build() { if (nameCharacters != null) { - nameSanitizer = nameCharacters.sanitize(repChar); + nameSanitizer = nameCharacters.sanitizeStringFunc(repChar); } if (keyCharacters != null) { - keySanitizer = keyCharacters.sanitize(repChar); + keySanitizer = keyCharacters.sanitizeStringFunc(repChar); } if (valueCharacters != null) { - valueSanitizer = valueCharacters.sanitize(repChar); + valueSanitizer = valueCharacters.sanitizeStringFunc(repChar); } return new SanitizerImpl(nameSanitizer, keySanitizer, valueSanitizer); } diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/StringSanitizer.java b/core/src/main/java/com/uber/m3/tally/sanitizers/StringSanitizer.java deleted file mode 100644 index 04a4861..0000000 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/StringSanitizer.java +++ /dev/null @@ -1,35 +0,0 @@ -// Copyright (c) 2020 Uber Technologies, Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -package com.uber.m3.tally.sanitizers; - -/** - * StringSanitizer is to sanitize strings - * It has a Sanitize method which returns a sanitized version of the input string value. - */ -public interface StringSanitizer { - - /** - * Sanitize the input string value. - * @param value input string value - * @return sanitized string value - */ - String sanitize(String value); -} diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java index c830eae..2918db2 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java @@ -23,6 +23,7 @@ import java.util.Arrays; import java.util.Collections; import java.util.List; +import java.util.function.Function; /** * ValidCharacters is a collection of valid characters. @@ -70,7 +71,7 @@ public static ValidCharacters of(List ranges, List charact return new ValidCharacters(ranges, characters); } - StringSanitizer sanitize(char repChar) { + Function sanitizeStringFunc(char repChar) { return value -> { StringBuilder buffer = null; From 5aa1dc54305e98a5342a9198d1ddfd99bcfbd906 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Thu, 15 Apr 2021 22:40:02 -0700 Subject: [PATCH 10/23] fix style --- core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java b/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java index 03476ee..c338484 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java @@ -29,7 +29,7 @@ public class CharRange { private final char high; private CharRange(char low, char high) { - if (low > high){ + if (low > high) { throw new RuntimeException("invalid CharRange"); } this.low = low; From 1b941ffe6a55f72c45a0996069b63e4438ae4f11 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Thu, 22 Apr 2021 10:16:33 -0700 Subject: [PATCH 11/23] address comments --- .../src/main/java/com/uber/m3/tally/ScopeImpl.java | 9 ++++++--- .../com/uber/m3/tally/sanitizers/CharRange.java | 2 +- .../uber/m3/tally/sanitizers/SanitizerImpl.java | 14 +++++++------- .../m3/tally/sanitizers/ScopeSanitizerBuilder.java | 6 +++--- 4 files changed, 17 insertions(+), 14 deletions(-) diff --git a/core/src/main/java/com/uber/m3/tally/ScopeImpl.java b/core/src/main/java/com/uber/m3/tally/ScopeImpl.java index 146b0b2..abb855b 100644 --- a/core/src/main/java/com/uber/m3/tally/ScopeImpl.java +++ b/core/src/main/java/com/uber/m3/tally/ScopeImpl.java @@ -145,6 +145,10 @@ public void close() { } private Map sanitizeTags(Map tags) { + if (tags == null) { + return null; + } + boolean hasChange = false; for (Map.Entry kv : tags.entrySet()) { if (!sanitizer.sanitizeTagKey(kv.getKey()).equals(kv.getKey()) || !sanitizer.sanitizeTagValue(kv.getValue()).equals(kv.getValue())) { @@ -157,9 +161,8 @@ private Map sanitizeTags(Map tags) { } ImmutableMap.Builder builder = new ImmutableMap.Builder<>(); - if (tags != null) { - tags.forEach((key, value) -> builder.put(sanitizer.sanitizeTagKey(key), sanitizer.sanitizeTagValue(value))); - } + tags.forEach((key, value) -> builder.put(sanitizer.sanitizeTagKey(key), sanitizer.sanitizeTagValue(value))); + return builder.build(); } diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java b/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java index c338484..97ff5e0 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java @@ -30,7 +30,7 @@ public class CharRange { private CharRange(char low, char high) { if (low > high) { - throw new RuntimeException("invalid CharRange"); + throw new IllegalArgumentException("invalid CharRange"); } this.low = low; this.high = high; diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java index 5d9b6cc..253d226 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java @@ -28,13 +28,13 @@ class SanitizerImpl implements ScopeSanitizer { private final Function nameSanitizer; - private final Function keySanitizer; - private final Function valueSanitizer; + private final Function tagKeySanitizer; + private final Function tagValueSanitizer; - SanitizerImpl(Function nameSanitizer, Function keySanitizer, Function valueSanitizer) { + SanitizerImpl(Function nameSanitizer, Function tagKeySanitizer, Function tagValueSanitizer) { this.nameSanitizer = nameSanitizer; - this.keySanitizer = keySanitizer; - this.valueSanitizer = valueSanitizer; + this.tagKeySanitizer = tagKeySanitizer; + this.tagValueSanitizer = tagValueSanitizer; } /** @@ -54,7 +54,7 @@ public String sanitizeName(String name) { */ @Override public String sanitizeTagKey(String key) { - return this.keySanitizer.apply(key); + return this.tagKeySanitizer.apply(key); } /** @@ -64,6 +64,6 @@ public String sanitizeTagKey(String key) { */ @Override public String sanitizeTagValue(String value) { - return this.valueSanitizer.apply(value); + return this.tagValueSanitizer.apply(value); } } diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java index f6e6e80..e52ca88 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java @@ -30,9 +30,9 @@ */ public class ScopeSanitizerBuilder { - private Function nameSanitizer = value -> value; - private Function keySanitizer = value -> value; - private Function valueSanitizer = value -> value; + private Function nameSanitizer = Function.identity(); + private Function keySanitizer = Function.identity(); + private Function valueSanitizer = Function.identity(); private char repChar = ValidCharacters.DEFAULT_REPLACEMENT_CHARACTER; private ValidCharacters nameCharacters; From 6e4f04a0777e2fdccdc4b195b9f04edc6128fb38 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Thu, 22 Apr 2021 10:21:18 -0700 Subject: [PATCH 12/23] NoopSanitizer --- .../java/com/uber/m3/tally/ScopeBuilder.java | 4 +- .../m3/tally/sanitizers/NoopSanitizer.java | 42 +++++++++++++++++++ 2 files changed, 44 insertions(+), 2 deletions(-) create mode 100644 core/src/main/java/com/uber/m3/tally/sanitizers/NoopSanitizer.java diff --git a/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java b/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java index aebd334..f617d9a 100644 --- a/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java +++ b/core/src/main/java/com/uber/m3/tally/ScopeBuilder.java @@ -20,8 +20,8 @@ package com.uber.m3.tally; +import com.uber.m3.tally.sanitizers.NoopSanitizer; import com.uber.m3.tally.sanitizers.ScopeSanitizer; -import com.uber.m3.tally.sanitizers.ScopeSanitizerBuilder; import com.uber.m3.util.Duration; import com.uber.m3.util.ImmutableMap; @@ -57,7 +57,7 @@ public class ScopeBuilder { protected String separator = DEFAULT_SEPARATOR; protected ImmutableMap tags; protected Buckets defaultBuckets = DEFAULT_SCOPE_BUCKETS; - protected ScopeSanitizer sanitizer = new ScopeSanitizerBuilder().build(); + protected ScopeSanitizer sanitizer = new NoopSanitizer(); private ScheduledExecutorService scheduler; private ScopeImpl.Registry registry; diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/NoopSanitizer.java b/core/src/main/java/com/uber/m3/tally/sanitizers/NoopSanitizer.java new file mode 100644 index 0000000..01f07eb --- /dev/null +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/NoopSanitizer.java @@ -0,0 +1,42 @@ +// Copyright (c) 2020 Uber Technologies, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package com.uber.m3.tally.sanitizers; + +/** + * NoopSanitizer will do nothing + */ +public class NoopSanitizer implements ScopeSanitizer { + + @Override + public String sanitizeName(String name) { + return name; + } + + @Override + public String sanitizeTagKey(String key) { + return key; + } + + @Override + public String sanitizeTagValue(String value) { + return value; + } +} From 5328ba1910e3a3104c099d05ab93cc7bf636dada Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Thu, 22 Apr 2021 11:03:37 -0700 Subject: [PATCH 13/23] adress commeents --- .../sanitizers/ScopeSanitizerBuilder.java | 81 +++++++++++++------ .../m3/tally/sanitizers/SanitizerTest.java | 16 ++-- .../com/uber/m3/tally/m3/M3Sanitizer.java | 6 +- 3 files changed, 66 insertions(+), 37 deletions(-) diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java index e52ca88..9fd307d 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java @@ -30,60 +30,89 @@ */ public class ScopeSanitizerBuilder { - private Function nameSanitizer = Function.identity(); - private Function keySanitizer = Function.identity(); - private Function valueSanitizer = Function.identity(); + private Function nameSanitizer; + private Function tagKeySanitizer; + private Function tagValueSanitizer; - private char repChar = ValidCharacters.DEFAULT_REPLACEMENT_CHARACTER; - private ValidCharacters nameCharacters; - private ValidCharacters keyCharacters; - private ValidCharacters valueCharacters; + private char replacementChar = ValidCharacters.DEFAULT_REPLACEMENT_CHARACTER; + private ValidCharacters nameValidCharacters; + private ValidCharacters tagKeyValidCharacters; + private ValidCharacters tagValueValidCharacters; public ScopeSanitizerBuilder withNameSanitizer(Function nameSanitizer) { + if (nameValidCharacters != null) { + throw new IllegalArgumentException("only one of them can be provided: nameValidCharacters, nameSanitizer"); + } this.nameSanitizer = nameSanitizer; return this; } - public ScopeSanitizerBuilder withKeySanitizer(Function keySanitizer) { - this.keySanitizer = keySanitizer; + public ScopeSanitizerBuilder withTagKeySanitizer(Function tagKeySanitizer) { + if (tagKeyValidCharacters != null) { + throw new IllegalArgumentException("only one of them can be provided: tagKeyValidCharacters, tagKeySanitizer"); + } + this.tagKeySanitizer = tagKeySanitizer; return this; } - public ScopeSanitizerBuilder withValueSanitizer(Function valueSanitizer) { - this.valueSanitizer = valueSanitizer; + public ScopeSanitizerBuilder withTagValueSanitizer(Function tagValueSanitizer) { + if (tagValueValidCharacters != null) { + throw new IllegalArgumentException("only one of them can be provided: tagValueValidCharacters, tagValueSanitizer"); + } + this.tagValueSanitizer = tagValueSanitizer; return this; } - public ScopeSanitizerBuilder withReplacementCharacter(char repChar) { - this.repChar = repChar; + public ScopeSanitizerBuilder withReplacementCharacter(char replacementChar) { + this.replacementChar = replacementChar; return this; } - public ScopeSanitizerBuilder withNameCharacters(ValidCharacters nameCharacters) { - this.nameCharacters = nameCharacters; + public ScopeSanitizerBuilder withNameValidCharacters(ValidCharacters validCharacters) { + if(this.nameSanitizer != null){ + throw new IllegalArgumentException("only one of them can be provided: nameValidCharacters, nameSanitizer"); + } + this.nameValidCharacters = validCharacters; return this; } - public ScopeSanitizerBuilder withKeyCharacters(ValidCharacters keyCharacters) { - this.keyCharacters = keyCharacters; + public ScopeSanitizerBuilder withTagKeyValidCharacters(ValidCharacters validCharacters) { + if(this.tagKeySanitizer != null){ + throw new IllegalArgumentException("only one of them can be provided: tagKeyValidCharacters, tagKeySanitizer"); + } + this.tagKeyValidCharacters = validCharacters; return this; } - public ScopeSanitizerBuilder withValueCharacters(ValidCharacters valueCharacters) { - this.valueCharacters = valueCharacters; + public ScopeSanitizerBuilder withTagValueValidCharacters(ValidCharacters validCharacters) { + if(this.tagValueSanitizer != null){ + throw new IllegalArgumentException("only one of them can be provided: tagValueValidCharacters, tagValueSanitizer"); + } + this.tagValueValidCharacters = validCharacters; return this; } public ScopeSanitizer build() { - if (nameCharacters != null) { - nameSanitizer = nameCharacters.sanitizeStringFunc(repChar); + if(nameSanitizer == null){ + nameSanitizer = Function.identity(); } - if (keyCharacters != null) { - keySanitizer = keyCharacters.sanitizeStringFunc(repChar); + if (nameValidCharacters != null) { + nameSanitizer = nameValidCharacters.sanitizeStringFunc(replacementChar); + } + + if (tagKeySanitizer == null){ + tagKeySanitizer = Function.identity(); + } + if (tagKeyValidCharacters != null) { + tagKeySanitizer = tagKeyValidCharacters.sanitizeStringFunc(replacementChar); + } + + if (tagValueSanitizer == null){ + tagValueSanitizer = Function.identity(); } - if (valueCharacters != null) { - valueSanitizer = valueCharacters.sanitizeStringFunc(repChar); + if (tagValueValidCharacters != null) { + tagValueSanitizer = tagValueValidCharacters.sanitizeStringFunc(replacementChar); } - return new SanitizerImpl(nameSanitizer, keySanitizer, valueSanitizer); + return new SanitizerImpl(nameSanitizer, tagKeySanitizer, tagValueSanitizer); } } diff --git a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java b/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java index 3d84ef7..c810880 100644 --- a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java +++ b/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java @@ -53,8 +53,8 @@ public void withSanitizers() { ScopeSanitizer sanitizer = new ScopeSanitizerBuilder() .withNameSanitizer(value -> SANITIZED_NAME_1) - .withKeySanitizer(value -> SANITIZED_KEY_1) - .withValueSanitizer(value -> SANITIZED_VALUE_1) + .withTagKeySanitizer(value -> SANITIZED_KEY_1) + .withTagValueSanitizer(value -> SANITIZED_VALUE_1) .build(); assertEquals(SANITIZED_NAME_1, sanitizer.sanitizeName(NAME)); assertEquals(SANITIZED_KEY_1, sanitizer.sanitizeTagKey(KEY)); @@ -65,15 +65,15 @@ public void withSanitizers() { public void withValidCharactersAndDefaultRepChar() { ScopeSanitizer sanitizer = new ScopeSanitizerBuilder() - .withNameCharacters( + .withNameValidCharacters( ValidCharacters.of( ValidCharacters.ALPHANUMERIC_RANGE, ValidCharacters.UNDERSCORE_CHARACTERS)) - .withKeyCharacters( + .withTagKeyValidCharacters( ValidCharacters.of( ValidCharacters.ALPHANUMERIC_RANGE, ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) - .withValueCharacters( + .withTagValueValidCharacters( ValidCharacters.of( ValidCharacters.ALPHANUMERIC_RANGE, ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) @@ -88,15 +88,15 @@ public void withValidCharactersAndRepChar() { ScopeSanitizer sanitizer = new ScopeSanitizerBuilder() .withReplacementCharacter(REPLACEMENT_CHAR) - .withNameCharacters( + .withNameValidCharacters( ValidCharacters.of( ValidCharacters.ALPHANUMERIC_RANGE, ValidCharacters.UNDERSCORE_CHARACTERS)) - .withKeyCharacters( + .withTagKeyValidCharacters( ValidCharacters.of( ValidCharacters.ALPHANUMERIC_RANGE, ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) - .withValueCharacters( + .withTagValueValidCharacters( ValidCharacters.of( ValidCharacters.ALPHANUMERIC_RANGE, ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) diff --git a/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java b/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java index 5b6d956..5c346ec 100644 --- a/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java +++ b/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java @@ -33,15 +33,15 @@ public class M3Sanitizer { public static ScopeSanitizer create() { return new ScopeSanitizerBuilder() .withReplacementCharacter(ValidCharacters.DEFAULT_REPLACEMENT_CHARACTER) - .withNameCharacters( + .withNameValidCharacters( ValidCharacters.of( ValidCharacters.ALPHANUMERIC_RANGE, ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) - .withKeyCharacters( + .withTagKeyValidCharacters( ValidCharacters.of( ValidCharacters.ALPHANUMERIC_RANGE, ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) - .withValueCharacters( + .withTagValueValidCharacters( ValidCharacters.of( ValidCharacters.ALPHANUMERIC_RANGE, ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) From 5cb9f0f17cb9bb15b741b1a94a09b9359095c4b4 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Thu, 22 Apr 2021 11:41:31 -0700 Subject: [PATCH 14/23] address comments for validCharacters --- .../uber/m3/tally/sanitizers/CharRange.java | 6 +- .../m3/tally/sanitizers/NoopSanitizer.java | 2 +- .../m3/tally/sanitizers/SanitizerImpl.java | 2 +- .../m3/tally/sanitizers/ScopeSanitizer.java | 2 +- .../sanitizers/ScopeSanitizerBuilder.java | 2 +- .../m3/tally/sanitizers/ValidCharacters.java | 76 +++++++++++-------- 6 files changed, 55 insertions(+), 35 deletions(-) diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java b/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java index 97ff5e0..03a1635 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java @@ -1,4 +1,4 @@ -// Copyright (c) 2020 Uber Technologies, Inc. +// Copyright (c) 2021 Uber Technologies, Inc. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal @@ -47,4 +47,8 @@ char low() { char high() { return high; } + + public boolean isWithinRange(char ch){ + return (ch >= low) && (ch <= high); + } } diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/NoopSanitizer.java b/core/src/main/java/com/uber/m3/tally/sanitizers/NoopSanitizer.java index 01f07eb..ca026aa 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/NoopSanitizer.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/NoopSanitizer.java @@ -1,4 +1,4 @@ -// Copyright (c) 2020 Uber Technologies, Inc. +// Copyright (c) 2021 Uber Technologies, Inc. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java index 253d226..4505601 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java @@ -1,4 +1,4 @@ -// Copyright (c) 2020 Uber Technologies, Inc. +// Copyright (c) 2021 Uber Technologies, Inc. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizer.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizer.java index 85624c8..dd0d4e8 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizer.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizer.java @@ -1,4 +1,4 @@ -// Copyright (c) 2020 Uber Technologies, Inc. +// Copyright (c) 2021 Uber Technologies, Inc. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java index 9fd307d..e3a48e6 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java @@ -1,4 +1,4 @@ -// Copyright (c) 2020 Uber Technologies, Inc. +// Copyright (c) 2021 Uber Technologies, Inc. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java index 2918db2..c92a69e 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java @@ -1,4 +1,4 @@ -// Copyright (c) 2017 Uber Technologies, Inc. +// Copyright (c) 2021 Uber Technologies, Inc. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal @@ -22,7 +22,8 @@ import java.util.Arrays; import java.util.Collections; -import java.util.List; +import java.util.HashSet; +import java.util.Set; import java.util.function.Function; /** @@ -38,73 +39,88 @@ public class ValidCharacters { /** * ALPHANUMERIC_RANGE is the range of alphanumeric characters. */ - public static final List ALPHANUMERIC_RANGE = - Arrays.asList( + public static final Set ALPHANUMERIC_RANGE = + new HashSet<>(Arrays.asList( CharRange.of('a', 'z'), CharRange.of('A', 'Z'), - CharRange.of('0', '9')); + CharRange.of('0', '9'))); /** * UNDERSCORE_CHARACTERS contains the underscore character. */ - public static final List UNDERSCORE_CHARACTERS = Collections.singletonList('_'); + public static final Set UNDERSCORE_CHARACTERS = Collections.singleton('_'); /** * UNDERSCORE_DASH_CHARACTERS contains the underscore and dash characters. */ - public static final List UNDERSCORE_DASH_CHARACTERS = Arrays.asList('_', '-'); + public static final Set UNDERSCORE_DASH_CHARACTERS = new HashSet<>(Arrays.asList('_', '-')); /** * UNDERSCORE_DASH_DOT_CHARACTERS contains the underscore, dash and dot characters. */ - public static final List UNDERSCORE_DASH_DOT_CHARACTERS = Arrays.asList('_', '-', '.'); + public static final Set UNDERSCORE_DASH_DOT_CHARACTERS = new HashSet<>(Arrays.asList('_', '-', '.')); - private final List ranges; - private final List characters; + private final Set validRanges; + private final Set validCharacters; - private ValidCharacters(List ranges, List characters) { - this.ranges = ranges != null ? ranges : Collections.emptyList(); - this.characters = characters != null ? characters : Collections.emptyList(); + private ValidCharacters(Set validRanges, Set validCharacters) { + this.validRanges = (validRanges != null) ? validRanges : Collections.emptySet(); + this.validCharacters = (validCharacters != null) ? validCharacters : Collections.emptySet(); } - public static ValidCharacters of(List ranges, List characters) { + /** + * returns an instance of ValidCharacters + * @param ranges + * @param characters + * @return + */ + public static ValidCharacters of(Set ranges, Set characters) { return new ValidCharacters(ranges, characters); } - Function sanitizeStringFunc(char repChar) { - return value -> { - StringBuilder buffer = null; + /** + * returns if a char is valid + * a char is valid if it's within range of any range of validRanges or within validCharacters + * @param ch + * @return + */ + private boolean isValid(char ch){ + return validRanges.stream().anyMatch(range -> (range.isWithinRange(ch))) + || validCharacters.contains(ch); + } + + Function sanitizeStringFunc(char replaceChar) { + return input -> { + StringBuilder output = null; - for (int i = 0; i < value.length(); i++) { - char ch = value.charAt(i); + for (int i = 0; i < input.length(); i++) { + char currChar = input.charAt(i); // first check if the provided character is valid - boolean validCurr = - ranges.stream().anyMatch(range -> ch >= range.low() && ch <= range.high()) - || characters.stream().anyMatch(character -> character.equals(ch)); + boolean isCurrValid = isValid(currChar); // if it's valid, we can optimize allocations by avoiding copying - if (validCurr) { - if (buffer != null) { - buffer.append(ch); + if (isCurrValid) { + if (output != null) { + output.append(currChar); } continue; } // the character is invalid, and the buffer has not been initialized // so we initialize the buffer and back-fill. - if (buffer == null) { - buffer = new StringBuilder(value.length()); - buffer.append(value, 0, i); + if (output == null) { + output = new StringBuilder(input.length()); + output.append(input, 0, i); } // write the replacement character - buffer.append(repChar); + output.append(replaceChar); } // return input un-touched if the buffer has not been initialized // otherwise, return the newly constructed buffer string - return buffer == null ? value : buffer.toString(); + return (output == null) ? input : output.toString(); }; } } From 3e341165f5e96eb9f81b373a85fe155b7c2cb665 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Thu, 22 Apr 2021 11:44:54 -0700 Subject: [PATCH 15/23] address comments for unit tests --- ...itizeRangeTest.java => CharRangeTest.java} | 29 ++++++++++++++----- 1 file changed, 22 insertions(+), 7 deletions(-) rename core/src/test/java/com/uber/m3/tally/sanitizers/{SanitizeRangeTest.java => CharRangeTest.java} (64%) diff --git a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizeRangeTest.java b/core/src/test/java/com/uber/m3/tally/sanitizers/CharRangeTest.java similarity index 64% rename from core/src/test/java/com/uber/m3/tally/sanitizers/SanitizeRangeTest.java rename to core/src/test/java/com/uber/m3/tally/sanitizers/CharRangeTest.java index 109e2e6..6fe52e1 100644 --- a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizeRangeTest.java +++ b/core/src/test/java/com/uber/m3/tally/sanitizers/CharRangeTest.java @@ -24,17 +24,32 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; -public class SanitizeRangeTest { - - private static final char LOW = 'a'; - private static final char HIGH = 'z'; +public class CharRangeTest { @Test public void sanitizeRange() { - CharRange range = CharRange.of(LOW, HIGH); + CharRange range = CharRange.of('a', 'z'); assertNotNull(range); - assertEquals(LOW, range.low()); - assertEquals(HIGH, range.high()); + assertEquals('a', range.low()); + assertEquals('z', range.high()); + assertTrue(range.isWithinRange('a')); + assertTrue(range.isWithinRange('z')); + assertTrue(range.isWithinRange('b')); + } + + @Test + public void sanitizeRangeSameLowHigh() { + CharRange range = CharRange.of('a', 'a'); + assertNotNull(range); + assertEquals('a', range.low()); + assertEquals('a', range.high()); + assertTrue(range.isWithinRange('a')); + } + + @Test(expected = IllegalArgumentException.class) + public void sanitizeRangeWrongLowHigh() { + CharRange range = CharRange.of('b', 'a'); } } From dde5ff40081ee16f7176cb8f9862db0f668a0a4b Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Thu, 22 Apr 2021 11:47:00 -0700 Subject: [PATCH 16/23] use UNDERSCORE_DASH_CHARACTERS --- m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java | 4 ++-- m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java b/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java index 5c346ec..2a9725f 100644 --- a/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java +++ b/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java @@ -36,7 +36,7 @@ public static ScopeSanitizer create() { .withNameValidCharacters( ValidCharacters.of( ValidCharacters.ALPHANUMERIC_RANGE, - ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) + ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) .withTagKeyValidCharacters( ValidCharacters.of( ValidCharacters.ALPHANUMERIC_RANGE, @@ -44,7 +44,7 @@ public static ScopeSanitizer create() { .withTagValueValidCharacters( ValidCharacters.of( ValidCharacters.ALPHANUMERIC_RANGE, - ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) + ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) .build(); } } diff --git a/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java b/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java index 397db41..5e0b125 100644 --- a/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java +++ b/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java @@ -30,9 +30,9 @@ public class M3SanitizerTest { private static final String NAME = "!@#$%^&*()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; private static final String KEY = "!@#$%^&*()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; private static final String VALUE = "!@#$%^&*()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; - private static final String SANITIZED_NAME = "__________abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; + private static final String SANITIZED_NAME = "__________abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-_"; private static final String SANITIZED_KEY = "__________abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-_"; - private static final String SANITIZED_VALUE = "__________abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; + private static final String SANITIZED_VALUE = "__________abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-_"; @Test public void m3Sanitizer() { From fbbf111432f56110469c0ace5650f01b46a42978 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Thu, 22 Apr 2021 11:49:32 -0700 Subject: [PATCH 17/23] fix format --- .../uber/m3/tally/sanitizers/CharRange.java | 2 +- .../m3/tally/sanitizers/SanitizerImpl.java | 3 ++ .../sanitizers/ScopeSanitizerBuilder.java | 12 ++++---- .../m3/tally/sanitizers/ValidCharacters.java | 12 ++++---- .../com/uber/m3/tally/m3/M3Sanitizer.java | 29 ++++++++++--------- 5 files changed, 32 insertions(+), 26 deletions(-) diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java b/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java index 03a1635..0dd1ffd 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/CharRange.java @@ -48,7 +48,7 @@ char high() { return high; } - public boolean isWithinRange(char ch){ + public boolean isWithinRange(char ch) { return (ch >= low) && (ch <= high); } } diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java index 4505601..240c296 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/SanitizerImpl.java @@ -39,6 +39,7 @@ class SanitizerImpl implements ScopeSanitizer { /** * Name sanitizes the provided 'name' string. + * * @param name the name string * @return the sanitized name */ @@ -49,6 +50,7 @@ public String sanitizeName(String name) { /** * Key sanitizes the provided 'key' string. + * * @param key the key string * @return the sanitized key */ @@ -59,6 +61,7 @@ public String sanitizeTagKey(String key) { /** * Value sanitizes the provided 'value' string. + * * @param value the value string * @return the sanitized value */ diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java index e3a48e6..b0fdd5f 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ScopeSanitizerBuilder.java @@ -69,7 +69,7 @@ public ScopeSanitizerBuilder withReplacementCharacter(char replacementChar) { } public ScopeSanitizerBuilder withNameValidCharacters(ValidCharacters validCharacters) { - if(this.nameSanitizer != null){ + if (this.nameSanitizer != null) { throw new IllegalArgumentException("only one of them can be provided: nameValidCharacters, nameSanitizer"); } this.nameValidCharacters = validCharacters; @@ -77,7 +77,7 @@ public ScopeSanitizerBuilder withNameValidCharacters(ValidCharacters validCharac } public ScopeSanitizerBuilder withTagKeyValidCharacters(ValidCharacters validCharacters) { - if(this.tagKeySanitizer != null){ + if (this.tagKeySanitizer != null) { throw new IllegalArgumentException("only one of them can be provided: tagKeyValidCharacters, tagKeySanitizer"); } this.tagKeyValidCharacters = validCharacters; @@ -85,7 +85,7 @@ public ScopeSanitizerBuilder withTagKeyValidCharacters(ValidCharacters validChar } public ScopeSanitizerBuilder withTagValueValidCharacters(ValidCharacters validCharacters) { - if(this.tagValueSanitizer != null){ + if (this.tagValueSanitizer != null) { throw new IllegalArgumentException("only one of them can be provided: tagValueValidCharacters, tagValueSanitizer"); } this.tagValueValidCharacters = validCharacters; @@ -93,21 +93,21 @@ public ScopeSanitizerBuilder withTagValueValidCharacters(ValidCharacters validCh } public ScopeSanitizer build() { - if(nameSanitizer == null){ + if (nameSanitizer == null) { nameSanitizer = Function.identity(); } if (nameValidCharacters != null) { nameSanitizer = nameValidCharacters.sanitizeStringFunc(replacementChar); } - if (tagKeySanitizer == null){ + if (tagKeySanitizer == null) { tagKeySanitizer = Function.identity(); } if (tagKeyValidCharacters != null) { tagKeySanitizer = tagKeyValidCharacters.sanitizeStringFunc(replacementChar); } - if (tagValueSanitizer == null){ + if (tagValueSanitizer == null) { tagValueSanitizer = Function.identity(); } if (tagValueValidCharacters != null) { diff --git a/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java b/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java index c92a69e..b22cfd7 100644 --- a/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java +++ b/core/src/main/java/com/uber/m3/tally/sanitizers/ValidCharacters.java @@ -41,9 +41,9 @@ public class ValidCharacters { */ public static final Set ALPHANUMERIC_RANGE = new HashSet<>(Arrays.asList( - CharRange.of('a', 'z'), - CharRange.of('A', 'Z'), - CharRange.of('0', '9'))); + CharRange.of('a', 'z'), + CharRange.of('A', 'Z'), + CharRange.of('0', '9'))); /** * UNDERSCORE_CHARACTERS contains the underscore character. @@ -70,6 +70,7 @@ private ValidCharacters(Set validRanges, Set validCharacte /** * returns an instance of ValidCharacters + * * @param ranges * @param characters * @return @@ -81,11 +82,12 @@ public static ValidCharacters of(Set ranges, Set character /** * returns if a char is valid * a char is valid if it's within range of any range of validRanges or within validCharacters + * * @param ch * @return */ - private boolean isValid(char ch){ - return validRanges.stream().anyMatch(range -> (range.isWithinRange(ch))) + private boolean isValid(char ch) { + return validRanges.stream().anyMatch(range -> (range.isWithinRange(ch))) || validCharacters.contains(ch); } diff --git a/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java b/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java index 2a9725f..98214b1 100644 --- a/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java +++ b/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java @@ -28,23 +28,24 @@ public class M3Sanitizer { /** * Creates the default M3 sanitizer. + * * @return default M3 sanitizer */ public static ScopeSanitizer create() { return new ScopeSanitizerBuilder() - .withReplacementCharacter(ValidCharacters.DEFAULT_REPLACEMENT_CHARACTER) - .withNameValidCharacters( - ValidCharacters.of( - ValidCharacters.ALPHANUMERIC_RANGE, - ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) - .withTagKeyValidCharacters( - ValidCharacters.of( - ValidCharacters.ALPHANUMERIC_RANGE, - ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) - .withTagValueValidCharacters( - ValidCharacters.of( - ValidCharacters.ALPHANUMERIC_RANGE, - ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) - .build(); + .withReplacementCharacter(ValidCharacters.DEFAULT_REPLACEMENT_CHARACTER) + .withNameValidCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) + .withTagKeyValidCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) + .withTagValueValidCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) + .build(); } } From f1d8f25f6b4398d129e27ea60055d50321b31894 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Thu, 22 Apr 2021 11:56:25 -0700 Subject: [PATCH 18/23] more tests --- ...tizerTest.java => ScopeSanitizerTest.java} | 114 ++++++++++++------ 1 file changed, 80 insertions(+), 34 deletions(-) rename core/src/test/java/com/uber/m3/tally/sanitizers/{SanitizerTest.java => ScopeSanitizerTest.java} (52%) diff --git a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java b/core/src/test/java/com/uber/m3/tally/sanitizers/ScopeSanitizerTest.java similarity index 52% rename from core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java rename to core/src/test/java/com/uber/m3/tally/sanitizers/ScopeSanitizerTest.java index c810880..c91de8d 100644 --- a/core/src/test/java/com/uber/m3/tally/sanitizers/SanitizerTest.java +++ b/core/src/test/java/com/uber/m3/tally/sanitizers/ScopeSanitizerTest.java @@ -22,9 +22,11 @@ import org.junit.Test; +import java.util.function.Function; + import static org.junit.Assert.assertEquals; -public class SanitizerTest { +public class ScopeSanitizerTest { private static final String NAME = "!@#$%^&*()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; private static final String KEY = "!@#$%^&*()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_-."; @@ -41,21 +43,29 @@ public class SanitizerTest { private static final char REPLACEMENT_CHAR = '@'; @Test - public void noopSanitizer() { + public void builderNoopSanitizer() { ScopeSanitizer sanitizer = new ScopeSanitizerBuilder().build(); assertEquals(NAME, sanitizer.sanitizeName(NAME)); assertEquals(KEY, sanitizer.sanitizeTagKey(KEY)); assertEquals(VALUE, sanitizer.sanitizeTagValue(VALUE)); } + @Test + public void noopSanitizer() { + ScopeSanitizer sanitizer = new NoopSanitizer(); + assertEquals(NAME, sanitizer.sanitizeName(NAME)); + assertEquals(KEY, sanitizer.sanitizeTagKey(KEY)); + assertEquals(VALUE, sanitizer.sanitizeTagValue(VALUE)); + } + @Test public void withSanitizers() { ScopeSanitizer sanitizer = - new ScopeSanitizerBuilder() - .withNameSanitizer(value -> SANITIZED_NAME_1) - .withTagKeySanitizer(value -> SANITIZED_KEY_1) - .withTagValueSanitizer(value -> SANITIZED_VALUE_1) - .build(); + new ScopeSanitizerBuilder() + .withNameSanitizer(value -> SANITIZED_NAME_1) + .withTagKeySanitizer(value -> SANITIZED_KEY_1) + .withTagValueSanitizer(value -> SANITIZED_VALUE_1) + .build(); assertEquals(SANITIZED_NAME_1, sanitizer.sanitizeName(NAME)); assertEquals(SANITIZED_KEY_1, sanitizer.sanitizeTagKey(KEY)); assertEquals(SANITIZED_VALUE_1, sanitizer.sanitizeTagValue(VALUE)); @@ -64,20 +74,20 @@ public void withSanitizers() { @Test public void withValidCharactersAndDefaultRepChar() { ScopeSanitizer sanitizer = - new ScopeSanitizerBuilder() - .withNameValidCharacters( - ValidCharacters.of( - ValidCharacters.ALPHANUMERIC_RANGE, - ValidCharacters.UNDERSCORE_CHARACTERS)) - .withTagKeyValidCharacters( - ValidCharacters.of( - ValidCharacters.ALPHANUMERIC_RANGE, - ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) - .withTagValueValidCharacters( - ValidCharacters.of( - ValidCharacters.ALPHANUMERIC_RANGE, - ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) - .build(); + new ScopeSanitizerBuilder() + .withNameValidCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_CHARACTERS)) + .withTagKeyValidCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) + .withTagValueValidCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) + .build(); assertEquals(SANITIZED_NAME_2, sanitizer.sanitizeName(NAME)); assertEquals(SANITIZED_KEY_2, sanitizer.sanitizeTagKey(KEY)); assertEquals(SANITIZED_VALUE_2, sanitizer.sanitizeTagValue(VALUE)); @@ -86,23 +96,59 @@ public void withValidCharactersAndDefaultRepChar() { @Test public void withValidCharactersAndRepChar() { ScopeSanitizer sanitizer = - new ScopeSanitizerBuilder() + new ScopeSanitizerBuilder() + .withReplacementCharacter(REPLACEMENT_CHAR) + .withNameValidCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_CHARACTERS)) + .withTagKeyValidCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) + .withTagValueValidCharacters( + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) + .build(); + assertEquals(SANITIZED_NAME_3, sanitizer.sanitizeName(NAME)); + assertEquals(SANITIZED_KEY_3, sanitizer.sanitizeTagKey(KEY)); + assertEquals(SANITIZED_VALUE_3, sanitizer.sanitizeTagValue(VALUE)); + } + + @Test(expected = IllegalArgumentException.class) + public void invalidBuilderConflictNameSanitizer() { + new ScopeSanitizerBuilder() .withReplacementCharacter(REPLACEMENT_CHAR) .withNameValidCharacters( - ValidCharacters.of( - ValidCharacters.ALPHANUMERIC_RANGE, - ValidCharacters.UNDERSCORE_CHARACTERS)) + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_CHARACTERS)) + .withNameSanitizer(Function.identity()) + .build(); + } + + @Test(expected = IllegalArgumentException.class) + public void invalidBuilderConflictTagKeySanitizer() { + new ScopeSanitizerBuilder() + .withReplacementCharacter(REPLACEMENT_CHAR) .withTagKeyValidCharacters( - ValidCharacters.of( - ValidCharacters.ALPHANUMERIC_RANGE, - ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) + .withTagKeySanitizer(Function.identity()) + .build(); + } + + @Test(expected = IllegalArgumentException.class) + public void invalidBuilderConflictTagValueSanitizer() { + new ScopeSanitizerBuilder() + .withReplacementCharacter(REPLACEMENT_CHAR) .withTagValueValidCharacters( - ValidCharacters.of( - ValidCharacters.ALPHANUMERIC_RANGE, - ValidCharacters.UNDERSCORE_DASH_DOT_CHARACTERS)) + ValidCharacters.of( + ValidCharacters.ALPHANUMERIC_RANGE, + ValidCharacters.UNDERSCORE_DASH_CHARACTERS)) + .withTagValueSanitizer(Function.identity()) .build(); - assertEquals(SANITIZED_NAME_3, sanitizer.sanitizeName(NAME)); - assertEquals(SANITIZED_KEY_3, sanitizer.sanitizeTagKey(KEY)); - assertEquals(SANITIZED_VALUE_3, sanitizer.sanitizeTagValue(VALUE)); } } From bb561ecf9f7c6f4a1b169ef5775e28ba679d3ae2 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Thu, 22 Apr 2021 11:59:55 -0700 Subject: [PATCH 19/23] more fix for copyright --- .../java/com/uber/m3/tally/sanitizers/CharRangeTest.java | 2 +- .../com/uber/m3/tally/sanitizers/ScopeSanitizerTest.java | 2 +- m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java | 2 +- m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java | 5 +++-- 4 files changed, 6 insertions(+), 5 deletions(-) diff --git a/core/src/test/java/com/uber/m3/tally/sanitizers/CharRangeTest.java b/core/src/test/java/com/uber/m3/tally/sanitizers/CharRangeTest.java index 6fe52e1..09ade2a 100644 --- a/core/src/test/java/com/uber/m3/tally/sanitizers/CharRangeTest.java +++ b/core/src/test/java/com/uber/m3/tally/sanitizers/CharRangeTest.java @@ -1,4 +1,4 @@ -// Copyright (c) 2017 Uber Technologies, Inc. +// Copyright (c) 2021 Uber Technologies, Inc. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal diff --git a/core/src/test/java/com/uber/m3/tally/sanitizers/ScopeSanitizerTest.java b/core/src/test/java/com/uber/m3/tally/sanitizers/ScopeSanitizerTest.java index c91de8d..6712ebc 100644 --- a/core/src/test/java/com/uber/m3/tally/sanitizers/ScopeSanitizerTest.java +++ b/core/src/test/java/com/uber/m3/tally/sanitizers/ScopeSanitizerTest.java @@ -1,4 +1,4 @@ -// Copyright (c) 2017 Uber Technologies, Inc. +// Copyright (c) 2021 Uber Technologies, Inc. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal diff --git a/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java b/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java index 98214b1..57e15e6 100644 --- a/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java +++ b/m3/src/main/java/com/uber/m3/tally/m3/M3Sanitizer.java @@ -1,4 +1,4 @@ -// Copyright (c) 2017 Uber Technologies, Inc. +// Copyright (c) 2021 Uber Technologies, Inc. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal diff --git a/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java b/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java index 5e0b125..b54d8d8 100644 --- a/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java +++ b/m3/src/test/java/com/uber/m3/tally/m3/M3SanitizerTest.java @@ -1,4 +1,4 @@ -// Copyright (c) 2017 Uber Technologies, Inc. +// Copyright (c) 2021 Uber Technologies, Inc. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal @@ -23,7 +23,8 @@ import com.uber.m3.tally.sanitizers.ScopeSanitizer; import org.junit.Test; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; public class M3SanitizerTest { From 315c5593915ccabcb57da2827ed0cbfef840b5b8 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Fri, 23 Apr 2021 11:57:15 -0700 Subject: [PATCH 20/23] Bench with sanitizer add benchmark code --- core/benchmark-tests.txt | 2 + .../com/uber/m3/tally/ScopeImplBenchmark.java | 86 +++++++++++++------ 2 files changed, 60 insertions(+), 28 deletions(-) create mode 100644 core/benchmark-tests.txt diff --git a/core/benchmark-tests.txt b/core/benchmark-tests.txt new file mode 100644 index 0000000..921adda --- /dev/null +++ b/core/benchmark-tests.txt @@ -0,0 +1,2 @@ +Benchmark Mode Cnt Score Error Units +ScopeImplBenchmark.sanitizingDashBenchmark thrpt 10 52.541 ± 1.127 ops/ms diff --git a/core/src/jmh/java/com/uber/m3/tally/ScopeImplBenchmark.java b/core/src/jmh/java/com/uber/m3/tally/ScopeImplBenchmark.java index 5844536..5cb1aee 100644 --- a/core/src/jmh/java/com/uber/m3/tally/ScopeImplBenchmark.java +++ b/core/src/jmh/java/com/uber/m3/tally/ScopeImplBenchmark.java @@ -20,6 +20,8 @@ package com.uber.m3.tally; +import com.uber.m3.tally.sanitizers.ScopeSanitizerBuilder; +import com.uber.m3.tally.sanitizers.ValidCharacters; import com.uber.m3.util.Duration; import com.uber.m3.util.ImmutableMap; import org.openjdk.jmh.annotations.Benchmark; @@ -36,59 +38,87 @@ @BenchmarkMode(Mode.Throughput) @OutputTimeUnit(TimeUnit.MILLISECONDS) -@Fork(value = 2, jvmArgsAppend = { "-server", "-XX:+UseG1GC" }) +@Fork(value = 2, jvmArgsAppend = {"-server", "-XX:+UseG1GC"}) public class ScopeImplBenchmark { private static final DurationBuckets EXPONENTIAL_BUCKETS = DurationBuckets.linear(Duration.ofMillis(1), Duration.ofMillis(10), 128); private static final String[] COUNTER_NAMES = { - "first-counter", - "second-counter", - "third-counter", - "fourth-counter", - "fifth-counter", + "first-counter", + "second-counter", + "third-counter", + "fourth-counter", + "fifth-counter", }; private static final String[] GAUGE_NAMES = { - "first-gauge", - "second-gauge", - "third-gauge", - "fourth-gauge", - "fifth-gauge", + "first-gauge", + "second-gauge", + "third-gauge", + "fourth-gauge", + "fifth-gauge", }; private static final String[] HISTOGRAM_NAMES = { - "first-histogram", - "second-histogram", - "third-histogram", - "fourth-histogram", - "fifth-histogram", + "first-histogram", + "second-histogram", + "third-histogram", + "fourth-histogram", + "fifth-histogram", }; @Benchmark public void scopeReportingBenchmark(BenchmarkState state) { - state.scope.reportLoopIteration(); + state.reportingBenchmarkScope.reportLoopIteration(); + } + + @Benchmark + public void recordingWithSanitizingDashBenchmark(BenchmarkState state) { + state.recordTestMetrics(state.sanitizingBenchmarkScope); + } + + @Benchmark + public void recordingBenchmark(BenchmarkState state) { + state.recordTestMetrics(state.recordingBenchmarkScope); } @State(org.openjdk.jmh.annotations.Scope.Benchmark) public static class BenchmarkState { - private ScopeImpl scope; + private ScopeImpl reportingBenchmarkScope; + private ScopeImpl sanitizingBenchmarkScope; + private ScopeImpl recordingBenchmarkScope; @Setup public void setup() { - this.scope = - (ScopeImpl) new RootScopeBuilder() - .reporter(new TestStatsReporter()) - .tags( - ImmutableMap.of( - "service", "some-service", - "application", "some-application", - "instance", "some-instance" - ) + final ScopeBuilder scopeBuilder = new RootScopeBuilder() + .reporter(new TestStatsReporter()) + .tags( + ImmutableMap.of( + "service", "some-service", + "application", "some-application", + "instance", "some-instance" ) + ); + + this.reportingBenchmarkScope = + (ScopeImpl) scopeBuilder.reportEvery(Duration.MAX_VALUE); + + this.recordTestMetrics(this.reportingBenchmarkScope); + + this.recordingBenchmarkScope = (ScopeImpl) scopeBuilder.reportEvery(Duration.MAX_VALUE); + this.sanitizingBenchmarkScope = + (ScopeImpl) scopeBuilder.sanitizer( + new ScopeSanitizerBuilder() + .withNameValidCharacters(ValidCharacters.of(null, ValidCharacters.UNDERSCORE_CHARACTERS)) + .withTagKeyValidCharacters(ValidCharacters.of(null, ValidCharacters.UNDERSCORE_CHARACTERS)) + .withTagValueValidCharacters(ValidCharacters.of(null, ValidCharacters.UNDERSCORE_CHARACTERS)) + .build() + ) .reportEvery(Duration.MAX_VALUE); + } + public void recordTestMetrics(final ScopeImpl scope) { for (String counterName : COUNTER_NAMES) { scope.counter(counterName).inc(1); } @@ -112,7 +142,7 @@ public void setup() { @TearDown public void teardown() { - scope.close(); + reportingBenchmarkScope.close(); } } From d0c33f8d7f3665c1f07fbaca1e69c234d671c090 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Fri, 23 Apr 2021 14:54:25 -0700 Subject: [PATCH 21/23] close at teardown --- core/src/jmh/java/com/uber/m3/tally/ScopeImplBenchmark.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/core/src/jmh/java/com/uber/m3/tally/ScopeImplBenchmark.java b/core/src/jmh/java/com/uber/m3/tally/ScopeImplBenchmark.java index 5cb1aee..2417ae4 100644 --- a/core/src/jmh/java/com/uber/m3/tally/ScopeImplBenchmark.java +++ b/core/src/jmh/java/com/uber/m3/tally/ScopeImplBenchmark.java @@ -143,6 +143,8 @@ public void recordTestMetrics(final ScopeImpl scope) { @TearDown public void teardown() { reportingBenchmarkScope.close(); + recordingBenchmarkScope.close(); + sanitizingBenchmarkScope.close(); } } From 08ed2d5e9b73eee44b60324b63baa55007804b81 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Fri, 23 Apr 2021 15:22:56 -0700 Subject: [PATCH 22/23] add bench results --- core/benchmark-tests.txt | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/core/benchmark-tests.txt b/core/benchmark-tests.txt index 921adda..fe9eff5 100644 --- a/core/benchmark-tests.txt +++ b/core/benchmark-tests.txt @@ -1,2 +1,4 @@ -Benchmark Mode Cnt Score Error Units -ScopeImplBenchmark.sanitizingDashBenchmark thrpt 10 52.541 ± 1.127 ops/ms +Benchmark Mode Cnt Score Error Units +ScopeImplBenchmark.recordingBenchmark thrpt 10 74.819 ± 4.573 ops/ms +ScopeImplBenchmark.recordingWithSanitizingDashBenchmark thrpt 10 49.256 ± 9.474 ops/ms +ScopeImplBenchmark.scopeReportingBenchmark thrpt 10 39066.800 ± 262.844 ops/ms From 8b09947d54205958a1228f564aa6b8eb5915e0c2 Mon Sep 17 00:00:00 2001 From: Quanzheng Long Date: Fri, 23 Apr 2021 15:26:56 -0700 Subject: [PATCH 23/23] fix style --- .../com/uber/m3/tally/ScopeImplBenchmark.java | 73 +++++++++---------- 1 file changed, 33 insertions(+), 40 deletions(-) diff --git a/core/src/jmh/java/com/uber/m3/tally/ScopeImplBenchmark.java b/core/src/jmh/java/com/uber/m3/tally/ScopeImplBenchmark.java index 2417ae4..3c916c3 100644 --- a/core/src/jmh/java/com/uber/m3/tally/ScopeImplBenchmark.java +++ b/core/src/jmh/java/com/uber/m3/tally/ScopeImplBenchmark.java @@ -24,14 +24,7 @@ import com.uber.m3.tally.sanitizers.ValidCharacters; import com.uber.m3.util.Duration; import com.uber.m3.util.ImmutableMap; -import org.openjdk.jmh.annotations.Benchmark; -import org.openjdk.jmh.annotations.BenchmarkMode; -import org.openjdk.jmh.annotations.Fork; -import org.openjdk.jmh.annotations.Mode; -import org.openjdk.jmh.annotations.OutputTimeUnit; -import org.openjdk.jmh.annotations.Setup; -import org.openjdk.jmh.annotations.State; -import org.openjdk.jmh.annotations.TearDown; +import org.openjdk.jmh.annotations.*; import java.util.Random; import java.util.concurrent.TimeUnit; @@ -44,27 +37,27 @@ public class ScopeImplBenchmark { private static final DurationBuckets EXPONENTIAL_BUCKETS = DurationBuckets.linear(Duration.ofMillis(1), Duration.ofMillis(10), 128); private static final String[] COUNTER_NAMES = { - "first-counter", - "second-counter", - "third-counter", - "fourth-counter", - "fifth-counter", + "first-counter", + "second-counter", + "third-counter", + "fourth-counter", + "fifth-counter", }; private static final String[] GAUGE_NAMES = { - "first-gauge", - "second-gauge", - "third-gauge", - "fourth-gauge", - "fifth-gauge", + "first-gauge", + "second-gauge", + "third-gauge", + "fourth-gauge", + "fifth-gauge", }; private static final String[] HISTOGRAM_NAMES = { - "first-histogram", - "second-histogram", - "third-histogram", - "fourth-histogram", - "fifth-histogram", + "first-histogram", + "second-histogram", + "third-histogram", + "fourth-histogram", + "fifth-histogram", }; @Benchmark @@ -92,30 +85,30 @@ public static class BenchmarkState { @Setup public void setup() { final ScopeBuilder scopeBuilder = new RootScopeBuilder() - .reporter(new TestStatsReporter()) - .tags( - ImmutableMap.of( - "service", "some-service", - "application", "some-application", - "instance", "some-instance" - ) - ); + .reporter(new TestStatsReporter()) + .tags( + ImmutableMap.of( + "service", "some-service", + "application", "some-application", + "instance", "some-instance" + ) + ); this.reportingBenchmarkScope = - (ScopeImpl) scopeBuilder.reportEvery(Duration.MAX_VALUE); + (ScopeImpl) scopeBuilder.reportEvery(Duration.MAX_VALUE); this.recordTestMetrics(this.reportingBenchmarkScope); this.recordingBenchmarkScope = (ScopeImpl) scopeBuilder.reportEvery(Duration.MAX_VALUE); this.sanitizingBenchmarkScope = - (ScopeImpl) scopeBuilder.sanitizer( - new ScopeSanitizerBuilder() - .withNameValidCharacters(ValidCharacters.of(null, ValidCharacters.UNDERSCORE_CHARACTERS)) - .withTagKeyValidCharacters(ValidCharacters.of(null, ValidCharacters.UNDERSCORE_CHARACTERS)) - .withTagValueValidCharacters(ValidCharacters.of(null, ValidCharacters.UNDERSCORE_CHARACTERS)) - .build() - ) - .reportEvery(Duration.MAX_VALUE); + (ScopeImpl) scopeBuilder.sanitizer( + new ScopeSanitizerBuilder() + .withNameValidCharacters(ValidCharacters.of(null, ValidCharacters.UNDERSCORE_CHARACTERS)) + .withTagKeyValidCharacters(ValidCharacters.of(null, ValidCharacters.UNDERSCORE_CHARACTERS)) + .withTagValueValidCharacters(ValidCharacters.of(null, ValidCharacters.UNDERSCORE_CHARACTERS)) + .build() + ) + .reportEvery(Duration.MAX_VALUE); } public void recordTestMetrics(final ScopeImpl scope) {