Add StackHasher (fork/copy from Logstash)

Author: rob-bygrave

src/main/java/io/avaje/logback/encoder/StackHasher.java

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2013-2023 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.avaje.logback.encoder;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+/**
+ * Utility class that generates a hash from any Java {@link Throwable error}
+ *
+ * @author Pierre Smeyers
+ */
+public final class StackHasher {
+
+    private final StackElementFilter filter;
+
+    /**
+     * Constructs a {@link StackHasher} with the given filter.
+     *
+     * @param filter filter
+     */
+    public StackHasher(StackElementFilter filter) {
+        this.filter = filter;
+    }
+
+    /**
+     * Constructs a {@link StackHasher} using {@link StackElementFilter#withSourceInfo()} filter
+     */
+    public StackHasher() {
+        this(StackElementFilter.withSourceInfo());
+    }
+
+    /**
+     * Generates a Hexadecimal hash for the given error stack.
+     * <p>
+     * Two errors with the same stack hash are most probably same errors.
+     *
+     * @param error the error to generate a hash from
+     * @return the generated hexadecimal hash
+     */
+    public String hexHash(Throwable error) {
+        // compute topmost error hash, but don't queue the complete hashes chain
+        return toHex(hash(error, null));
+    }
+
+    /**
+     * Generates and returns Hexadecimal hashes for the error stack and each ancestor {@link Throwable#getCause() cause}.
+     * <p>
+     * The first queue element is the stack hash for the topmost error, the next one (if any) is it's direct
+     * {@link Throwable#getCause() cause} hash, and so on...
+     *
+     * @param error the error to generate a hash from
+     * @return a Dequeue with hashes
+     */
+    public Deque<String> hexHashes(Throwable error) {
+        Deque<String> hexHashes = new ArrayDeque<String>();
+        hash(error, hexHashes);
+        return hexHashes;
+    }
+
+    /**
+     * Generates a hash (int) of the given error stack.
+     * <p>
+     * Two errors with the same stack hash are most probably same errors.
+     *
+     * @param error the error to generate a hash from
+     * @param hexHashes
+     * @return the generated hexadecimal hash
+     */
+    int hash(Throwable error, Deque<String> hexHashes) {
+        int hash = 0;
+
+        // compute parent error hash
+        if (error.getCause() != null && error.getCause() != error) {
+            // has parent error
+            hash = hash(error.getCause(), hexHashes);
+        }
+
+        // then this error hash
+        // hash error classname
+        hash = 31 * hash + error.getClass().getName().hashCode();
+        // hash stacktrace
+        for (StackTraceElement element : error.getStackTrace()) {
+            if (filter.accept(element)) {
+                hash = 31 * hash + hash(element);
+            }
+        }
+
+        // push hexadecimal representation of hash
+        if (hexHashes != null) {
+            hexHashes.push(toHex(hash));
+        }
+
+        return hash;
+    }
+
+    String toHex(int hash) {
+        return String.format("%08x", hash);
+    }
+
+    int hash(StackTraceElement element) {
+        int result = element.getClassName().hashCode();
+        result = 31 * result + element.getMethodName().hashCode();
+        // let's assume filename is not necessary
+        result = 31 * result + element.getLineNumber();
+        return result;
+    }
+}

src/test/java/io/avaje/logback/encoder/StackHasherTest.java

@@ -0,0 +1,147 @@
+/*
+ * Copyright 2013-2023 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.avaje.logback.encoder;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Deque;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+public class StackHasherTest {
+
+    private static class StackTraceElementGenerator {
+        public static void generateSingle() {
+            oneSingle();
+        }
+
+        public static void oneSingle() {
+            twoSingle();
+        }
+
+        private static void twoSingle() {
+            threeSingle();
+        }
+
+        private static void threeSingle() {
+            four();
+        }
+
+        private static void four() {
+            five();
+        }
+
+        private static void five() {
+            six();
+        }
+
+        private static void six() {
+            seven();
+        }
+
+        private static void seven() {
+            eight();
+        }
+
+        private static void eight() {
+            throw new RuntimeException("message");
+        }
+
+        public static void generateCausedBy() {
+            oneCausedBy();
+        }
+
+        private static void oneCausedBy() {
+            twoCausedBy();
+        }
+
+        private static void twoCausedBy() {
+            try {
+                threeSingle();
+            } catch (RuntimeException e) {
+                throw new RuntimeException("wrapper", e);
+            }
+        }
+    }
+
+    @Test
+    public void one_hash_should_be_generated() {
+        try {
+            StackTraceElementGenerator.generateSingle();
+            fail("Exception must have been thrown");
+        } catch (RuntimeException e) {
+            // GIVEN
+            StackHasher hasher = new StackHasher();
+
+            // WHEN
+            Deque<String> hashes = hasher.hexHashes(e);
+
+            // THEN
+            assertThat(hashes).hasSize(1);
+        }
+    }
+
+    @Test
+    public void two_hashes_should_be_generated() {
+        try {
+            StackTraceElementGenerator.generateCausedBy();
+            fail("Exception must have been thrown");
+        } catch (RuntimeException e) {
+            // GIVEN
+            StackHasher hasher = new StackHasher();
+
+            // WHEN
+            Deque<String> hashes = hasher.hexHashes(e);
+
+            // THEN
+            assertThat(hashes).hasSize(2);
+        }
+    }
+    private static class OnlyFromStackTraceElementGeneratorFilter implements StackElementFilter {
+        @Override
+        public boolean accept(StackTraceElement element) {
+            return element.getClassName().equals(StackTraceElementGenerator.class.getName());
+        }
+    }
+
+    /**
+     * Warning: computes expected hash based on StackTraceElementGenerator elements
+     *
+     * do not change methods name, line or it will break the test
+     */
+    @Test
+    public void expected_hash_should_be_generated() {
+        try {
+            StackTraceElementGenerator.generateSingle();
+            fail("Exception must have been thrown");
+        } catch (RuntimeException e) {
+            // GIVEN
+            StackHasher hasher = new StackHasher(new OnlyFromStackTraceElementGeneratorFilter());
+
+            // WHEN
+            Deque<String> hashes = hasher.hexHashes(e);
+
+            // THEN
+            assertThat(hashes)
+                .hasSize(1)
+                .first().isEqualTo("86983bb4");
+
+          String hash = hasher.hexHash(e);
+          assertThat(hash).isEqualTo("86983bb4");
+        }
+    }
+}