Rename filters to redacted keys for spec compliance (#236)

Author: richardelms

bugsnag/src/main/java/com/bugsnag/Bugsnag.java

@@ -228,16 +228,16 @@ public void setEndpoint(String endpoint) {
     }
 
     /**
-     * Set which keys should be filtered when sending metaData to Bugsnag.
+     * Set which keys should be redacted when sending metaData to Bugsnag.
      * Use this when you want to ensure sensitive information, such as passwords
      * or credit card information is stripped from metaData you send to Bugsnag.
      * Any keys in metaData which contain these strings will be marked as
-     * [FILTERED] when send to Bugsnag.
+     * [REDACTED] when send to Bugsnag.
      *
-     * @param filters a list of String keys to filter from metaData
+     * @param redactedKeys a list of String keys to redact from metaData
      */
-    public void setFilters(String... filters) {
-        config.filters = filters;
+    public void setRedactedKeys(String... redactedKeys) {
+        config.redactedKeys = redactedKeys;
     }
 
     /**

bugsnag/src/main/java/com/bugsnag/BugsnagAppender.java

@@ -48,8 +48,8 @@ public class BugsnagAppender extends UnsynchronizedAppenderBase<ILoggingEvent> {
     /** Bugsnag error server endpoint. */
     private String endpoint;
 
-    /** Property names that should be filtered out before sending to Bugsnag servers. */
-    private Set<String> filteredProperties = new HashSet<String>();
+    /** Property names that should be redacted before sending to Bugsnag servers. */
+    private Set<String> redactedKeys = new HashSet<String>();
 
     /** Exception classes to be ignored. */
     private Set<String> ignoredClasses = new HashSet<String>();
@@ -254,8 +254,8 @@ private Bugsnag createBugsnag() {
             bugsnag.setTimeout(timeout);
         }
 
-        if (filteredProperties.size() > 0) {
-            bugsnag.setFilters(filteredProperties.toArray(new String[0]));
+        if (redactedKeys.size() > 0) {
+            bugsnag.setRedactedKeys(redactedKeys.toArray(new String[0]));
         }
 
         bugsnag.setIgnoreClasses(ignoredClasses.toArray(new String[0]));
@@ -374,24 +374,24 @@ public void setEndpoint(String endpoint) {
     }
 
     /**
-     * @see Bugsnag#setFilters(String...)
+     * @see Bugsnag#setRedactedKeys(String...)
      */
-    public void setFilteredProperty(String filter) {
-        this.filteredProperties.add(filter);
+    public void setRedactedKey(String key) {
+        this.redactedKeys.add(key);
 
         if (bugsnag != null) {
-            bugsnag.setFilters(this.filteredProperties.toArray(new String[0]));
+            bugsnag.setRedactedKeys(this.redactedKeys.toArray(new String[0]));
         }
     }
 
     /**
-     * @see Bugsnag#setFilters(String...)
+     * @see Bugsnag#setRedactedKeys(String...)
      */
-    public void setFilteredProperties(String filters) {
-        this.filteredProperties.addAll(split(filters));
+    public void setRedactedKeys(String key) {
+        this.redactedKeys.addAll(split(key));
 
         if (bugsnag != null) {
-            bugsnag.setFilters(this.filteredProperties.toArray(new String[0]));
+            bugsnag.setRedactedKeys(this.redactedKeys.toArray(new String[0]));
         }
     }
 

bugsnag/src/main/java/com/bugsnag/Configuration.java

@@ -36,7 +36,7 @@ public class Configuration {
     public Delivery delivery;
     public EndpointConfiguration endpointConfiguration;
     public Delivery sessionDelivery;
-    public String[] filters = new String[]{"password", "secret", "Authorization", "Cookie"};
+    public String[] redactedKeys = new String[]{"password", "secret", "Authorization", "Cookie"};
     public String[] ignoreClasses;
     public String[] notifyReleaseStages = null;
     public String[] projectPackages;

bugsnag/src/main/java/com/bugsnag/util/FilteredMap.java renamed to bugsnag/src/main/java/com/bugsnag/RedactedMap.java

@@ -1,24 +1,24 @@
-package com.bugsnag.util;
+package com.bugsnag;
 
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 
 /**
- * Decorates a map by replacing values of filtered keys.
+ * Decorates a map by replacing values of redacted keys.
  */
-public class FilteredMap implements Map<String, Object> {
+class RedactedMap implements Map<String, Object> {
 
-    private static final String FILTERED_PLACEHOLDER = "[FILTERED]";
+    private static final String REDACTED_PLACEHOLDER = "[REDACTED]";
 
-    private final Map<String, Object> filteredCopy;
-    private final Collection<String> keyFilters = new ArrayList<String>();
+    private final Map<String, Object> redactedCopy;
+    private final Collection<String> redactedKeys = new HashSet<>();
 
-    public FilteredMap(Map<String, Object> map, Collection<String> keyFilters) {
-        this.keyFilters.addAll(keyFilters);
-        this.filteredCopy = createCopy(map);
+    RedactedMap(Map<String, Object> map, Collection<String> redactedKeys) {
+        this.redactedKeys.addAll(redactedKeys);
+        this.redactedCopy = createCopy(map);
     }
 
     private Map<String, Object> createCopy(Map<? extends String, ?> map) {
@@ -36,84 +36,87 @@ private Map<String, Object> createCopy(Map<? extends String, ?> map) {
 
     @Override
     public int size() {
-        return filteredCopy.size();
+        return redactedCopy.size();
     }
 
     @Override
     public boolean isEmpty() {
-        return filteredCopy.isEmpty();
+        return redactedCopy.isEmpty();
     }
 
     @Override
     public boolean containsKey(Object key) {
-        return filteredCopy.containsKey(key);
+        return redactedCopy.containsKey(key);
     }
 
     @Override
     public boolean containsValue(Object value) {
-        return filteredCopy.containsValue(value);
+        return redactedCopy.containsValue(value);
     }
 
     @Override
     public Object get(Object key) {
-        return filteredCopy.get(key);
+        return redactedCopy.get(key);
     }
 
     @Override
     public Object put(String key, Object value) {
         if (value == null) {
-            return filteredCopy.put(key, null);
+            return redactedCopy.put(key, null);
         }
         Object transformedValue = transformEntry(key, value);
-        return filteredCopy.put(key, transformedValue);
+        return redactedCopy.put(key, transformedValue);
     }
 
     @Override
     public Object remove(Object key) {
-        return filteredCopy.remove(key);
+        return redactedCopy.remove(key);
     }
 
     @Override
     public void putAll(Map<? extends String, ?> mapValues) {
         Map<String, Object> copy = createCopy(mapValues);
-        filteredCopy.putAll(copy);
+        redactedCopy.putAll(copy);
     }
 
     @Override
     public void clear() {
-        filteredCopy.clear();
+        redactedCopy.clear();
     }
 
     @Override
     public Set<String> keySet() {
-        return filteredCopy.keySet();
+        return redactedCopy.keySet();
     }
 
     @Override
     public Collection<Object> values() {
-        return filteredCopy.values();
+        return redactedCopy.values();
     }
 
     @Override
     public Set<Entry<String, Object>> entrySet() {
-        return filteredCopy.entrySet();
+        return redactedCopy.entrySet();
     }
 
     @SuppressWarnings("unchecked")
     private Object transformEntry(Object key, Object value) {
         if (value instanceof Map) {
-            return new FilteredMap((Map<String, Object>) value, keyFilters);
+            return new RedactedMap((Map<String, Object>) value, redactedKeys);
         }
-        return shouldFilterKey((String) key) ? FILTERED_PLACEHOLDER : value;
+        return shouldRedactKey((String) key) ? REDACTED_PLACEHOLDER : value;
     }
 
-    private boolean shouldFilterKey(String key) {
-        if (keyFilters == null || key == null) {
+    private boolean shouldRedactKey(String key) {
+        if (key == null) {
             return false;
         }
-
-        for (String filter : keyFilters) {
-            if (key.contains(filter)) {
+        // Check for common keys first before looping through all
+        if (redactedKeys.contains(key)) {
+            return true;
+        }
+        for (String redactedKey : redactedKeys) {
+            if (key.contains(redactedKey)) {
                 return true;
             }
         }

bugsnag/src/main/java/com/bugsnag/Report.java

@@ -2,13 +2,11 @@
 
 import com.bugsnag.serialization.Expose;
 
-import com.bugsnag.util.FilteredMap;
-
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 public class Report {
 
@@ -126,7 +124,7 @@ public Map<String, String> getUser() {
 
     @Expose
     public Map<String, Object> getMetaData() {
-        return new FilteredMap(diagnostics.metaData, Arrays.asList(config.filters));
+        return new RedactedMap(diagnostics.metaData, Set.of(config.redactedKeys));
     }
 
     @Expose

bugsnag/src/test/java/com/bugsnag/AppenderTest.java

@@ -144,10 +144,10 @@ public void testBugsnagConfig() {
         assertEquals("gradleTask", config.appType);
         assertFalse(config.shouldAutoCaptureSessions());
 
-        assertEquals(2, config.filters.length);
-        ArrayList<String> filters = new ArrayList<String>(Arrays.asList(config.filters));
-        assertTrue(filters.contains("password"));
-        assertTrue(filters.contains("credit_card_number"));
+        assertEquals(2, config.redactedKeys.length);
+        ArrayList<String> redactedKeys = new ArrayList<String>(Arrays.asList(config.redactedKeys));
+        assertTrue(redactedKeys.contains("password"));
+        assertTrue(redactedKeys.contains("credit_card_number"));
 
         assertEquals(2, config.ignoreClasses.length);
         ArrayList<String> ignoreClasses
@@ -274,15 +274,15 @@ public void testAppType() {
     }
 
     @Test
-    public void testFilters() {
+    public void testRedactedKeys() {
 
-        // Add some meta data which should be filtered by key name
+        // Add some metadata which should be redacted by key name
         Bugsnag.addThreadMetaData("myTab", "password", "password value");
         Bugsnag.addThreadMetaData("myTab", "credit_card_number", "card number");
-        Bugsnag.addThreadMetaData("myTab", "mysecret", "not filtered");
+        Bugsnag.addThreadMetaData("myTab", "mysecret", "not redacted");
 
         // Send a log message
-        LOGGER.warn("Exception with filtered meta data", new RuntimeException("test"));
+        LOGGER.warn("Exception with redacted meta data", new RuntimeException("test"));
 
         // Check that a report was sent to Bugsnag
         assertEquals(1, delivery.getNotifications().size());
@@ -291,9 +291,9 @@ public void testFilters() {
         assertTrue(notification.getEvents().get(0).getMetaData().containsKey("myTab"));
         Map<String, Object> myTab = getMetaDataMap(notification, "myTab");
 
-        assertEquals("[FILTERED]", myTab.get("password"));
-        assertEquals("[FILTERED]", myTab.get("credit_card_number"));
-        assertEquals("not filtered", myTab.get("mysecret"));
+        assertEquals("[REDACTED]", myTab.get("password"));
+        assertEquals("[REDACTED]", myTab.get("credit_card_number"));
+        assertEquals("not redacted", myTab.get("mysecret"));
     }
 
     @Test
@@ -316,7 +316,7 @@ public void beforeNotify(Report report) {
         });
 
         // Send a log message
-        LOGGER.warn("Exception with filtered meta data", new RuntimeException("test"));
+        LOGGER.warn("Exception with redacted meta data", new RuntimeException("test"));
 
         // Check that a report was sent to Bugsnag
         assertEquals(1, delivery.getNotifications().size());
@@ -412,7 +412,7 @@ private SessionTracker getSessionTracker(Bugsnag bugsnag) {
     }
 
     /**
-     * Gets a hashmap key from the meta data in a notification
+     * Gets a hashmap key from the metadata in a notification
      *
      * @param notification The notification
      * @param key The key to get

bugsnag/src/test/java/com/bugsnag/BugsnagTest.java

@@ -164,8 +164,8 @@ public void close() {
     }
 
     @Test
-    public void testFilters() {
-        bugsnag.setFilters("testfilter1", "testfilter2");
+    public void testRedactedKeys() {
+        bugsnag.setRedactedKeys("testredact1", "testredact2");
         bugsnag.setDelivery(new Delivery() {
             @SuppressWarnings("unchecked")
             @Override
@@ -175,10 +175,10 @@ public void deliver(Serializer serializer, Object object, Map<String, String> he
                         (Map<String, Object>) report.getMetaData().get("firsttab");
                 final Map<String, Object> secondTab =
                         (Map<String, Object>) report.getMetaData().get("secondtab");
-                assertEquals("[FILTERED]", firstTab.get("testfilter1"));
-                assertEquals("[FILTERED]", firstTab.get("testfilter2"));
-                assertEquals("secretpassword", firstTab.get("testfilter3"));
-                assertEquals("[FILTERED]", secondTab.get("testfilter1"));
+                assertEquals("[REDACTED]", firstTab.get("testredact1"));
+                assertEquals("[REDACTED]", firstTab.get("testredact2"));
+                assertEquals("secretpassword", firstTab.get("testredact3"));
+                assertEquals("[REDACTED]", secondTab.get("testredact1"));
             }
 
             @Override
@@ -188,16 +188,16 @@ public void close() {
         assertTrue(bugsnag.notify(new Throwable(), new Callback() {
             @Override
             public void beforeNotify(Report report) {
-                report.addToTab("firsttab", "testfilter1", "secretpassword");
-                report.addToTab("firsttab", "testfilter2", "secretpassword");
-                report.addToTab("firsttab", "testfilter3", "secretpassword");
-                report.addToTab("secondtab", "testfilter1", "secretpassword");
+                report.addToTab("firsttab", "testredact1", "secretpassword");
+                report.addToTab("firsttab", "testredact2", "secretpassword");
+                report.addToTab("firsttab", "testredact3", "secretpassword");
+                report.addToTab("secondtab", "testredact1", "secretpassword");
             }
         }));
     }
 
     @Test
-    public void testFilterHeaders() {
+    public void testRedactHeaders() {
         bugsnag.setDelivery(new Delivery() {
             @SuppressWarnings("unchecked")
             @Override
@@ -209,9 +209,9 @@ public void deliver(Serializer serializer, Object object, Map<String, String> he
                 Map<String, Object> headersMap =
                         (Map<String, Object>) requestTab.get("headers");
 
-                assertEquals("[FILTERED]", headersMap.get("Authorization"));
+                assertEquals("[REDACTED]", headersMap.get("Authorization"));
                 assertEquals("User:Password", headersMap.get("authorization"));
-                assertEquals("[FILTERED]", headersMap.get("Cookie"));
+                assertEquals("[REDACTED]", headersMap.get("Cookie"));
                 assertEquals("123456ABCDEF", headersMap.get("cookie"));
             }
 

bugsnag/src/test/java/com/bugsnag/JakartaServletCallbackTest.java

@@ -100,10 +100,10 @@ public void testRequestMetadataAdded() {
         assertEquals("some-data-1,some-data-2", headers.get("X-Custom-Header"));
 
         // Make sure that actual Authorization header value is not in the report
-        assertEquals("[FILTERED]", headers.get("Authorization"));
+        assertEquals("[REDACTED]", headers.get("Authorization"));
 
         // Make sure that actual cookies are not in the report
-        assertEquals("[FILTERED]", headers.get("Cookie"));
+        assertEquals("[REDACTED]", headers.get("Cookie"));
 
         assertTrue(request.containsKey("params"));
         Map<String, String[]> params = (Map<String, String[]>) request.get("params");