terms) {
+ this.terms = Collections.unmodifiableList(new ArrayList<>(terms));
+ }
+
+ @Override
+ public boolean equals(final Object other) {
+ if (this == other) {
+ return true;
+ }
+ if (other == null || getClass() != other.getClass()) {
+ return false;
+ }
+ final KeyValueCollectionBehavior that = (KeyValueCollectionBehavior) other;
+ return mode == that.mode && terms.equals(that.terms);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(mode, terms);
+ }
+}
diff --git a/sentry/src/main/java/io/sentry/MainEventProcessor.java b/sentry/src/main/java/io/sentry/MainEventProcessor.java
index d84c9e47be8..d72783cfe9c 100644
--- a/sentry/src/main/java/io/sentry/MainEventProcessor.java
+++ b/sentry/src/main/java/io/sentry/MainEventProcessor.java
@@ -206,7 +206,7 @@ private void mergeUser(final @NotNull SentryBaseEvent event) {
user = new User();
event.setUser(user);
}
- if (user.getIpAddress() == null && options.isSendDefaultPii()) {
+ if (user.getIpAddress() == null && options.getDataCollectionResolver().isUserInfo()) {
user.setIpAddress(IpAddressUtils.DEFAULT_IP_ADDRESS);
}
}
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index d7a16d4ee23..690d5e535ce 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -347,6 +347,11 @@ public class SentryOptions {
/** whether to send personal identifiable information along with events */
private boolean sendDefaultPii = false;
+ private @NotNull DataCollection dataCollection = new DataCollection(false);
+
+ private final @NotNull DataCollectionResolver dataCollectionResolver =
+ new DataCollectionResolver(this);
+
/** SSLSocketFactory for self-signed certificate trust * */
private @Nullable SSLSocketFactory sslSocketFactory;
@@ -1751,6 +1756,33 @@ public void setSendDefaultPii(boolean sendDefaultPii) {
this.sendDefaultPii = sendDefaultPii;
}
+ /**
+ * Returns the configuration for data that the SDK collects automatically.
+ *
+ * The returned object is always present. Accessing it does not configure data collection, but
+ * setting one of its options does.
+ */
+ public @NotNull DataCollection getDataCollection() {
+ return dataCollection;
+ }
+
+ /**
+ * Replaces the configuration for data that the SDK collects automatically.
+ *
+ *
Passing an empty {@link DataCollection} opts into the documented data-collection defaults.
+ */
+ public void setDataCollection(final @NotNull DataCollection dataCollection) {
+ if (dataCollection != null) {
+ this.dataCollection = dataCollection;
+ }
+ }
+
+ /** Returns the Data Collection policy resolver used by SDK integrations. */
+ @ApiStatus.Internal
+ public @NotNull DataCollectionResolver getDataCollectionResolver() {
+ return dataCollectionResolver;
+ }
+
/**
* Adds a Scope observer
*
@@ -3712,6 +3744,9 @@ public void merge(final @NotNull ExternalOptions options) {
if (options.isSendDefaultPii() != null) {
setSendDefaultPii(options.isSendDefaultPii());
}
+ if (options.getDataCollection() != null) {
+ mergeDataCollection(options.getDataCollection());
+ }
if (options.isCaptureOpenTelemetryEvents() != null) {
setCaptureOpenTelemetryEvents(options.isCaptureOpenTelemetryEvents());
}
@@ -3777,6 +3812,40 @@ public void merge(final @NotNull ExternalOptions options) {
}
}
+ private void mergeDataCollection(final @NotNull DataCollection externalDataCollection) {
+ if (externalDataCollection.getUserInfo() != null) {
+ dataCollection.setUserInfo(externalDataCollection.getUserInfo());
+ }
+ if (externalDataCollection.getHttpBodies() != null) {
+ dataCollection.setHttpBodies(externalDataCollection.getHttpBodies());
+ }
+ if (externalDataCollection.getCookies() != null) {
+ dataCollection.setCookies(externalDataCollection.getCookies());
+ }
+ if (externalDataCollection.getHttpHeaders().getRequest() != null) {
+ dataCollection
+ .getHttpHeaders()
+ .setRequest(externalDataCollection.getHttpHeaders().getRequest());
+ }
+ if (externalDataCollection.getHttpHeaders().getResponse() != null) {
+ dataCollection
+ .getHttpHeaders()
+ .setResponse(externalDataCollection.getHttpHeaders().getResponse());
+ }
+ if (externalDataCollection.getUrlQueryParams() != null) {
+ dataCollection.setUrlQueryParams(externalDataCollection.getUrlQueryParams());
+ }
+ if (externalDataCollection.getGraphql().getDocument() != null) {
+ dataCollection.getGraphql().setDocument(externalDataCollection.getGraphql().getDocument());
+ }
+ if (externalDataCollection.getGraphql().getVariables() != null) {
+ dataCollection.getGraphql().setVariables(externalDataCollection.getGraphql().getVariables());
+ }
+ if (externalDataCollection.getDatabaseQueryData() != null) {
+ dataCollection.setDatabaseQueryData(externalDataCollection.getDatabaseQueryData());
+ }
+ }
+
private @NotNull SdkVersion createSdkVersion() {
final String version = BuildConfig.VERSION_NAME;
final SdkVersion sdkVersion = new SdkVersion(BuildConfig.SENTRY_JAVA_SDK_NAME, version);
diff --git a/sentry/src/main/java/io/sentry/TraceContext.java b/sentry/src/main/java/io/sentry/TraceContext.java
index b10954f5285..1bb5508f85b 100644
--- a/sentry/src/main/java/io/sentry/TraceContext.java
+++ b/sentry/src/main/java/io/sentry/TraceContext.java
@@ -1,7 +1,6 @@
package io.sentry;
import io.sentry.protocol.SentryId;
-import io.sentry.protocol.User;
import io.sentry.vendor.gson.stream.JsonToken;
import java.io.IOException;
import java.util.Map;
@@ -81,16 +80,6 @@ public final class TraceContext implements JsonUnknown, JsonSerializable {
this.sampleRand = sampleRand;
}
- @SuppressWarnings("UnusedMethod")
- private static @Nullable String getUserId(
- final @NotNull SentryOptions options, final @Nullable User user) {
- if (options.isSendDefaultPii() && user != null) {
- return user.getId();
- }
-
- return null;
- }
-
public @NotNull SentryId getTraceId() {
return traceId;
}
diff --git a/sentry/src/main/java/io/sentry/util/CookieUtils.java b/sentry/src/main/java/io/sentry/util/CookieUtils.java
new file mode 100644
index 00000000000..935f98aaf1a
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/CookieUtils.java
@@ -0,0 +1,291 @@
+package io.sentry.util;
+
+import static io.sentry.util.UrlUtils.SENSITIVE_DATA_SUBSTITUTE;
+
+import io.sentry.KeyValueCollectionBehavior;
+import io.sentry.SentryOptions;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Locale;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@ApiStatus.Internal
+public final class CookieUtils {
+
+ public static final String COOKIE_HEADER_NAME = "Cookie";
+
+ private static final List SECURITY_COOKIES =
+ Arrays.asList(
+ "JSESSIONID",
+ "JSESSIONIDSSO",
+ "JSSOSESSIONID",
+ "SESSIONID",
+ "SID",
+ "CSRFTOKEN",
+ "XSRF-TOKEN");
+
+ public static @Nullable List filterCookiesFromHeader(
+ final @Nullable Enumeration headers,
+ final @NotNull KeyValueCollectionBehavior behavior,
+ final @Nullable List additionalSensitiveCookieNames) {
+ return headers == null
+ ? null
+ : filterCookiesFromHeader(
+ Collections.list(headers), behavior, additionalSensitiveCookieNames);
+ }
+
+ public static @Nullable List filterCookiesFromHeader(
+ final @Nullable List headers,
+ final @NotNull KeyValueCollectionBehavior behavior,
+ final @Nullable List additionalSensitiveCookieNames) {
+ if (headers == null || behavior.getMode() == KeyValueCollectionBehavior.Mode.OFF) {
+ return null;
+ }
+
+ final @NotNull List filteredHeaders = new ArrayList<>();
+ for (final String header : headers) {
+ final @Nullable String filteredHeader =
+ filterCookies(header, behavior, additionalSensitiveCookieNames);
+ if (filteredHeader != null) {
+ filteredHeaders.add(filteredHeader);
+ }
+ }
+ return filteredHeaders;
+ }
+
+ public static @Nullable String filterCookies(
+ final @Nullable String cookies, final @NotNull SentryOptions options) {
+ if (!options.getDataCollectionResolver().isDataCollectionConfigured()) {
+ return options.isSendDefaultPii() ? cookies : null;
+ }
+ return filterCookies(cookies, options.getDataCollectionResolver().getCookies(), null);
+ }
+
+ public static @Nullable String filterCookies(
+ final @Nullable String cookies,
+ final @NotNull KeyValueCollectionBehavior behavior,
+ final @Nullable List additionalSensitiveCookieNames) {
+ if (cookies == null || behavior.getMode() == KeyValueCollectionBehavior.Mode.OFF) {
+ return null;
+ }
+
+ final @NotNull String[] cookieValues = cookies.split(";", -1);
+ final @NotNull StringBuilder filteredCookies = new StringBuilder();
+ for (int i = 0; i < cookieValues.length; i++) {
+ if (i > 0) {
+ filteredCookies.append(';');
+ }
+ filteredCookies.append(
+ filterCookie(cookieValues[i], behavior, additionalSensitiveCookieNames));
+ }
+ return filteredCookies.toString();
+ }
+
+ public static @Nullable String filterSetCookie(
+ final @Nullable String cookie, final @NotNull SentryOptions options) {
+ if (!options.getDataCollectionResolver().isDataCollectionConfigured()) {
+ return options.isSendDefaultPii() ? cookie : null;
+ }
+ return filterSetCookie(cookie, options.getDataCollectionResolver().getCookies());
+ }
+
+ public static @Nullable String filterSetCookie(
+ final @Nullable String cookie, final @NotNull KeyValueCollectionBehavior behavior) {
+ if (cookie == null || behavior.getMode() == KeyValueCollectionBehavior.Mode.OFF) {
+ return null;
+ }
+
+ final int attributesSeparator = cookie.indexOf(';');
+ final @NotNull String cookieValue =
+ attributesSeparator < 0 ? cookie : cookie.substring(0, attributesSeparator);
+ if (!isValidCookiePair(cookieValue)) {
+ return SENSITIVE_DATA_SUBSTITUTE;
+ }
+ final @NotNull String attributes =
+ attributesSeparator < 0 ? "" : cookie.substring(attributesSeparator);
+ return filterCookie(cookieValue, behavior, null) + attributes;
+ }
+
+ private static @NotNull String filterCookie(
+ final @NotNull String cookie,
+ final @NotNull KeyValueCollectionBehavior behavior,
+ final @Nullable List additionalSensitiveCookieNames) {
+ if (cookie.trim().isEmpty()) {
+ return cookie;
+ }
+
+ if (!isValidCookiePair(cookie)) {
+ return SENSITIVE_DATA_SUBSTITUTE;
+ }
+
+ final int separator = cookie.indexOf('=');
+ final @NotNull String name = cookie.substring(0, separator);
+ final @NotNull String normalizedName = name.trim();
+ final boolean sensitive =
+ HttpUtils.containsSensitiveDataKey(normalizedName)
+ || isSecurityCookie(normalizedName, additionalSensitiveCookieNames);
+ final boolean matchesTerm = HttpUtils.containsTerm(normalizedName, behavior.getTerms());
+ final boolean shouldFilter =
+ sensitive
+ || (behavior.getMode() == KeyValueCollectionBehavior.Mode.DENY_LIST && matchesTerm)
+ || (behavior.getMode() == KeyValueCollectionBehavior.Mode.ALLOW_LIST && !matchesTerm);
+
+ if (shouldFilter) {
+ return name + "=" + SENSITIVE_DATA_SUBSTITUTE;
+ }
+ return cookie;
+ }
+
+ private static boolean isValidCookiePair(final @NotNull String cookie) {
+ final @NotNull String cookiePair = cookie.trim();
+ final int separator = cookiePair.indexOf('=');
+ if (separator <= 0 || !isValidCookieName(cookiePair.substring(0, separator))) {
+ return false;
+ }
+
+ final @NotNull String value = cookiePair.substring(separator + 1);
+ int start = 0;
+ int end = value.length();
+ if (!value.isEmpty() && value.charAt(0) == '"') {
+ if (value.length() < 2 || value.charAt(value.length() - 1) != '"') {
+ return false;
+ }
+ start++;
+ end--;
+ }
+
+ for (int i = start; i < end; i++) {
+ if (!isCookieOctet(value.charAt(i))) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private static boolean isValidCookieName(final @NotNull String name) {
+ for (int i = 0; i < name.length(); i++) {
+ if (!isCookieNameCharacter(name.charAt(i))) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private static boolean isCookieNameCharacter(final char value) {
+ if ((value >= 'a' && value <= 'z')
+ || (value >= 'A' && value <= 'Z')
+ || (value >= '0' && value <= '9')) {
+ return true;
+ }
+
+ switch (value) {
+ case '!':
+ case '#':
+ case '$':
+ case '%':
+ case '&':
+ case '\'':
+ case '*':
+ case '+':
+ case '-':
+ case '.':
+ case '^':
+ case '_':
+ case '`':
+ case '|':
+ case '~':
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ private static boolean isCookieOctet(final char value) {
+ return value == 0x21
+ || (value >= 0x23 && value <= 0x2B)
+ || (value >= 0x2D && value <= 0x3A)
+ || (value >= 0x3C && value <= 0x5B)
+ || (value >= 0x5D && value <= 0x7E);
+ }
+
+ public static @Nullable List filterOutSecurityCookiesFromHeader(
+ final @Nullable Enumeration headers,
+ final @Nullable String headerName,
+ final @Nullable List additionalCookieNamesToFilter) {
+ if (headers == null) {
+ return null;
+ }
+
+ return filterOutSecurityCookiesFromHeader(
+ Collections.list(headers), headerName, additionalCookieNamesToFilter);
+ }
+
+ public static @Nullable List filterOutSecurityCookiesFromHeader(
+ final @Nullable List headers,
+ final @Nullable String headerName,
+ final @Nullable List additionalCookieNamesToFilter) {
+ if (headers == null) {
+ return null;
+ }
+
+ if (headerName != null && !COOKIE_HEADER_NAME.equalsIgnoreCase(headerName)) {
+ return headers;
+ }
+
+ final @NotNull ArrayList filteredHeaders = new ArrayList<>();
+ for (final String header : headers) {
+ filteredHeaders.add(filterOutSecurityCookies(header, additionalCookieNamesToFilter));
+ }
+ return filteredHeaders;
+ }
+
+ public static @Nullable String filterOutSecurityCookies(
+ final @Nullable String cookieString,
+ final @Nullable List additionalCookieNamesToFilter) {
+ if (cookieString == null) {
+ return null;
+ }
+
+ final @NotNull String[] cookies = cookieString.split(";", -1);
+ final @NotNull StringBuilder filteredCookieString = new StringBuilder();
+ boolean isFirst = true;
+ for (String cookie : cookies) {
+ if (!isFirst) {
+ filteredCookieString.append(";");
+ }
+
+ final @NotNull String[] cookieParts = cookie.split("=", -1);
+ final @NotNull String cookieName = cookieParts[0];
+ if (isSecurityCookie(cookieName.trim(), additionalCookieNamesToFilter)) {
+ filteredCookieString.append(cookieName + "=" + SENSITIVE_DATA_SUBSTITUTE);
+ } else {
+ filteredCookieString.append(cookie);
+ }
+ isFirst = false;
+ }
+ return filteredCookieString.toString();
+ }
+
+ public static boolean isSecurityCookie(
+ final @NotNull String cookieName,
+ final @Nullable List additionalCookieNamesToFilter) {
+ final @NotNull String cookieNameToSearchFor = cookieName.toUpperCase(Locale.ROOT);
+ if (SECURITY_COOKIES.contains(cookieNameToSearchFor)) {
+ return true;
+ }
+
+ if (additionalCookieNamesToFilter != null) {
+ for (String additionalCookieName : additionalCookieNamesToFilter) {
+ if (additionalCookieName.toUpperCase(Locale.ROOT).equals(cookieNameToSearchFor)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+}
diff --git a/sentry/src/main/java/io/sentry/util/GraphqlUtils.java b/sentry/src/main/java/io/sentry/util/GraphqlUtils.java
new file mode 100644
index 00000000000..faffc98afa5
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/GraphqlUtils.java
@@ -0,0 +1,79 @@
+package io.sentry.util;
+
+import io.sentry.DataCollectionResolver;
+import io.sentry.JsonObjectReader;
+import io.sentry.SentryLevel;
+import io.sentry.SentryOptions;
+import java.io.IOException;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@ApiStatus.Internal
+public final class GraphqlUtils {
+
+ private GraphqlUtils() {}
+
+ public static @Nullable String filterRequestBody(
+ final @NotNull String body, final @NotNull SentryOptions options) {
+ final @NotNull DataCollectionResolver resolver = options.getDataCollectionResolver();
+ final boolean includeDocument = resolver.isGraphqlDocumentWithLegacyAlways();
+ final boolean includeVariables = resolver.isGraphqlVariablesWithLegacyAlways();
+
+ if (includeDocument && includeVariables) {
+ return body;
+ }
+ if (!includeDocument && !includeVariables) {
+ return null;
+ }
+
+ try (JsonObjectReader reader = new JsonObjectReader(new StringReader(body))) {
+ final @Nullable Object value = reader.nextObjectOrNull();
+ final @NotNull Object filtered;
+ if (value instanceof Map) {
+ @SuppressWarnings("unchecked")
+ final @NotNull Map requestBody = (Map) value;
+ filtered = filterRequest(requestBody, includeDocument, includeVariables);
+ } else if (value instanceof List) {
+ final @NotNull List> filteredBatch = new ArrayList<>();
+ for (final @Nullable Object item : (List) value) {
+ if (!(item instanceof Map)) {
+ return null;
+ }
+ @SuppressWarnings("unchecked")
+ final @NotNull Map requestBody = (Map) item;
+ filteredBatch.add(filterRequest(requestBody, includeDocument, includeVariables));
+ }
+ filtered = filteredBatch;
+ } else {
+ return null;
+ }
+ final @NotNull StringWriter writer = new StringWriter();
+ options.getSerializer().serialize(filtered, writer);
+ return writer.toString();
+ } catch (IOException | NumberFormatException e) {
+ options.getLogger().log(SentryLevel.ERROR, "Failed to filter GraphQL request body.", e);
+ return null;
+ }
+ }
+
+ private static @NotNull Map filterRequest(
+ final @NotNull Map request,
+ final boolean includeDocument,
+ final boolean includeVariables) {
+ final @NotNull Map filtered = new LinkedHashMap<>(request);
+ if (!includeDocument) {
+ filtered.remove("query");
+ }
+ if (!includeVariables) {
+ filtered.remove("variables");
+ }
+ return filtered;
+ }
+}
diff --git a/sentry/src/main/java/io/sentry/util/HttpUtils.java b/sentry/src/main/java/io/sentry/util/HttpUtils.java
index 399ba7013fe..59ed67eb9f8 100644
--- a/sentry/src/main/java/io/sentry/util/HttpUtils.java
+++ b/sentry/src/main/java/io/sentry/util/HttpUtils.java
@@ -3,12 +3,14 @@
import static io.sentry.util.UrlUtils.SENSITIVE_DATA_SUBSTITUTE;
import io.sentry.HttpStatusCodeRange;
-import java.util.ArrayList;
+import io.sentry.KeyValueCollectionBehavior;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
import java.util.Arrays;
-import java.util.Collections;
-import java.util.Enumeration;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
+import java.util.Map;
import org.jetbrains.annotations.ApiStatus;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -16,8 +18,6 @@
@ApiStatus.Internal
public final class HttpUtils {
- public static final String COOKIE_HEADER_NAME = "Cookie";
-
private static final List SENSITIVE_HEADERS =
Arrays.asList(
"X-FORWARDED-FOR",
@@ -33,15 +33,25 @@ public final class HttpUtils {
"X-CSRFTOKEN",
"X-XSRF-TOKEN");
- private static final List SECURITY_COOKIES =
+ private static final List SENSITIVE_DATA_KEYS =
Arrays.asList(
- "JSESSIONID",
- "JSESSIONIDSSO",
- "JSSOSESSIONID",
- "SESSIONID",
- "SID",
- "CSRFTOKEN",
- "XSRF-TOKEN");
+ "auth",
+ "token",
+ "secret",
+ "password",
+ "passwd",
+ "pwd",
+ "key",
+ "jwt",
+ "bearer",
+ "sso",
+ "saml",
+ "csrf",
+ "xsrf",
+ "credentials",
+ "session",
+ "sid",
+ "identity");
private static final HttpStatusCodeRange CLIENT_ERROR_STATUS_CODES =
new HttpStatusCodeRange(400, 499);
@@ -53,88 +63,89 @@ public static boolean containsSensitiveHeader(final @NotNull String header) {
return SENSITIVE_HEADERS.contains(header.toUpperCase(Locale.ROOT));
}
- public static @Nullable List filterOutSecurityCookiesFromHeader(
- final @Nullable Enumeration headers,
- final @Nullable String headerName,
- final @Nullable List additionalCookieNamesToFilter) {
- if (headers == null) {
+ public static @Nullable String filterQueryParams(
+ final @Nullable String query, final @NotNull KeyValueCollectionBehavior behavior) {
+ if (query == null || behavior.getMode() == KeyValueCollectionBehavior.Mode.OFF) {
return null;
}
- return filterOutSecurityCookiesFromHeader(
- Collections.list(headers), headerName, additionalCookieNamesToFilter);
- }
+ final @NotNull StringBuilder filteredQuery = new StringBuilder();
+ final @NotNull String[] params = query.split("&", -1);
+ for (int i = 0; i < params.length; i++) {
+ if (i > 0) {
+ filteredQuery.append('&');
+ }
- public static @Nullable List filterOutSecurityCookiesFromHeader(
- final @Nullable List headers,
- final @Nullable String headerName,
- final @Nullable List additionalCookieNamesToFilter) {
- if (headers == null) {
- return null;
+ final @NotNull String param = params[i];
+ final int separator = param.indexOf('=');
+ final @NotNull String name = separator < 0 ? param : param.substring(0, separator);
+ final @NotNull String decodedName = decodeQueryParamName(name);
+ final boolean sensitive = containsTerm(decodedName, SENSITIVE_DATA_KEYS);
+ final boolean matchesTerm = containsTerm(decodedName, behavior.getTerms());
+ final boolean shouldFilter =
+ sensitive
+ || (behavior.getMode() == KeyValueCollectionBehavior.Mode.DENY_LIST && matchesTerm)
+ || (behavior.getMode() == KeyValueCollectionBehavior.Mode.ALLOW_LIST && !matchesTerm);
+
+ filteredQuery.append(name);
+ if (shouldFilter) {
+ filteredQuery.append('=').append(SENSITIVE_DATA_SUBSTITUTE);
+ } else if (separator >= 0) {
+ filteredQuery.append(param.substring(separator));
+ }
}
+ return filteredQuery.toString();
+ }
- if (headerName != null && !"Cookie".equalsIgnoreCase(headerName)) {
- return headers;
+ public static @NotNull Map filterHeaders(
+ final @NotNull Map headers,
+ final @NotNull KeyValueCollectionBehavior behavior) {
+ final @NotNull Map filteredHeaders = new LinkedHashMap<>();
+ if (behavior.getMode() == KeyValueCollectionBehavior.Mode.OFF) {
+ return filteredHeaders;
}
- final @NotNull ArrayList filteredHeaders = new ArrayList<>();
-
- for (final String header : headers) {
- filteredHeaders.add(
- HttpUtils.filterOutSecurityCookies(header, additionalCookieNamesToFilter));
+ for (final Map.Entry header : headers.entrySet()) {
+ final @NotNull String name = header.getKey();
+ final boolean sensitive =
+ containsTerm(name, SENSITIVE_DATA_KEYS)
+ || "Cookie".equalsIgnoreCase(name)
+ || "Set-Cookie".equalsIgnoreCase(name);
+ if (sensitive) {
+ filteredHeaders.put(name, SENSITIVE_DATA_SUBSTITUTE);
+ } else {
+ final boolean matchesTerm = containsTerm(name, behavior.getTerms());
+ final boolean shouldFilter =
+ behavior.getMode() == KeyValueCollectionBehavior.Mode.DENY_LIST
+ ? matchesTerm
+ : !matchesTerm;
+ filteredHeaders.put(name, shouldFilter ? SENSITIVE_DATA_SUBSTITUTE : header.getValue());
+ }
}
-
return filteredHeaders;
}
- public static @Nullable String filterOutSecurityCookies(
- final @Nullable String cookieString,
- final @Nullable List additionalCookieNamesToFilter) {
- if (cookieString == null) {
- return null;
- }
+ private static @NotNull String decodeQueryParamName(final @NotNull String name) {
try {
- final @NotNull String[] cookies = cookieString.split(";", -1);
- final @NotNull StringBuilder filteredCookieString = new StringBuilder();
- boolean isFirst = true;
-
- for (String cookie : cookies) {
- if (!isFirst) {
- filteredCookieString.append(";");
- }
-
- final @NotNull String[] cookieParts = cookie.split("=", -1);
- final @NotNull String cookieName = cookieParts[0];
- if (isSecurityCookie(cookieName.trim(), additionalCookieNamesToFilter)) {
- filteredCookieString.append(cookieName + "=" + SENSITIVE_DATA_SUBSTITUTE);
- } else {
- filteredCookieString.append(cookie);
- }
- isFirst = false;
- }
-
- return filteredCookieString.toString();
- } catch (Throwable t) {
- return null;
+ return URLDecoder.decode(name, "UTF-8");
+ } catch (IllegalArgumentException | UnsupportedEncodingException ignored) {
+ return name;
}
}
- public static boolean isSecurityCookie(
- final @NotNull String cookieName,
- final @Nullable List additionalCookieNamesToFilter) {
- final @NotNull String cookieNameToSearchFor = cookieName.toUpperCase(Locale.ROOT);
- if (SECURITY_COOKIES.contains(cookieNameToSearchFor)) {
- return true;
- }
+ static boolean containsSensitiveDataKey(final @NotNull String key) {
+ return containsTerm(key, SENSITIVE_DATA_KEYS);
+ }
- if (additionalCookieNamesToFilter != null) {
- for (String additionalCookieName : additionalCookieNamesToFilter) {
- if (additionalCookieName.toUpperCase(Locale.ROOT).equals(cookieNameToSearchFor)) {
- return true;
- }
+ static boolean containsTerm(final @NotNull String key, final @NotNull List terms) {
+ final @NotNull String normalizedKey = key.toLowerCase(Locale.ROOT);
+ for (final String term : terms) {
+ if (term != null
+ && !term.isEmpty()
+ && normalizedKey.contains(term.toLowerCase(Locale.ROOT))) {
+ return true;
}
}
-
return false;
}
diff --git a/sentry/src/main/java/io/sentry/util/UrlUtils.java b/sentry/src/main/java/io/sentry/util/UrlUtils.java
index 6c70cea0495..289a80a17fd 100644
--- a/sentry/src/main/java/io/sentry/util/UrlUtils.java
+++ b/sentry/src/main/java/io/sentry/util/UrlUtils.java
@@ -1,5 +1,6 @@
package io.sentry.util;
+import io.sentry.DataCollectionResolver;
import io.sentry.ISpan;
import io.sentry.SpanDataConvention;
import io.sentry.protocol.Request;
@@ -18,6 +19,11 @@ public final class UrlUtils {
}
public static @NotNull UrlDetails parse(final @NotNull String url) {
+ return parse(url, null);
+ }
+
+ public static @NotNull UrlDetails parse(
+ final @NotNull String url, final @Nullable DataCollectionResolver resolver) {
try {
URI uri = new URI(url);
if (uri.isAbsolute() && !isValidAbsoluteUrl(uri)) {
@@ -28,7 +34,9 @@ public final class UrlUtils {
uri.getScheme() == null ? "" : (uri.getScheme() + "://");
final @NotNull String authority = uri.getRawAuthority() == null ? "" : uri.getRawAuthority();
final @NotNull String path = uri.getRawPath() == null ? "" : uri.getRawPath();
- final @Nullable String query = uri.getRawQuery();
+ final @Nullable String rawQuery = uri.getRawQuery();
+ final @Nullable String query =
+ resolver == null ? rawQuery : filterQueryParams(rawQuery, resolver);
final @Nullable String fragment = uri.getRawFragment();
final @NotNull String filteredUrl = schemeAndSeparator + filterUserInfo(authority) + path;
@@ -39,7 +47,19 @@ public final class UrlUtils {
}
}
+ public static @Nullable String filterQueryParams(
+ final @Nullable String query, final @NotNull DataCollectionResolver resolver) {
+ return resolver.isDataCollectionConfigured()
+ ? HttpUtils.filterQueryParams(query, resolver.getUrlQueryParams())
+ : query;
+ }
+
private static boolean isValidAbsoluteUrl(final @NotNull URI uri) {
+ final @Nullable String scheme = uri.getScheme();
+ if ("ws".equalsIgnoreCase(scheme) || "wss".equalsIgnoreCase(scheme)) {
+ return !uri.isOpaque() && uri.getRawAuthority() != null && !uri.getRawAuthority().isEmpty();
+ }
+
try {
uri.toURL();
} catch (Exception e) {
diff --git a/sentry/src/test/java/io/sentry/DataCollectionResolverTest.kt b/sentry/src/test/java/io/sentry/DataCollectionResolverTest.kt
new file mode 100644
index 00000000000..25082d7f875
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/DataCollectionResolverTest.kt
@@ -0,0 +1,368 @@
+package io.sentry
+
+import com.google.common.truth.Truth.assertThat
+import kotlin.test.Test
+
+class DataCollectionResolverTest {
+ @Test
+ fun `one resolver is reused per options instance`() {
+ val options = SentryOptions()
+
+ assertThat(options.dataCollectionResolver).isSameInstanceAs(options.dataCollectionResolver)
+ }
+
+ @Test
+ fun `each options instance owns its resolver`() {
+ val first = SentryOptions()
+ val second = SentryOptions()
+
+ assertThat(first.dataCollectionResolver).isNotSameInstanceAs(second.dataCollectionResolver)
+ }
+
+ @Test
+ fun `data collection configured reflects namespace explicitness`() {
+ val options = SentryOptions()
+
+ assertThat(options.dataCollectionResolver.isDataCollectionConfigured).isFalse()
+
+ options.dataCollection.urlQueryParams = KeyValueCollectionBehavior.denyList()
+
+ assertThat(options.dataCollectionResolver.isDataCollectionConfigured).isTrue()
+ }
+
+ @Test
+ fun `user info falls back to sendDefaultPii when unset`() {
+ val options = SentryOptions()
+
+ assertThat(options.dataCollectionResolver.isUserInfo).isFalse()
+
+ options.isSendDefaultPii = true
+
+ assertThat(options.dataCollectionResolver.isUserInfo).isTrue()
+ }
+
+ @Test
+ fun `user info uses configured Data Collection value`() {
+ val options = SentryOptions().apply { isSendDefaultPii = true }
+
+ options.dataCollection.setUserInfo(false)
+
+ assertThat(options.dataCollectionResolver.isUserInfo).isFalse()
+
+ options.isSendDefaultPii = false
+ options.dataCollection.setUserInfo(true)
+
+ assertThat(options.dataCollectionResolver.isUserInfo).isTrue()
+ }
+
+ @Test
+ fun `omitted booleans use data collection defaults once namespace is explicit`() {
+ val options = SentryOptions().apply { isSendDefaultPii = false }
+
+ options.dataCollection.cookies = KeyValueCollectionBehavior.off()
+
+ assertThat(options.dataCollectionResolver.isUserInfo).isTrue()
+ assertThat(options.dataCollectionResolver.isDatabaseQueryData).isTrue()
+ assertThat(options.dataCollectionResolver.isGraphqlDocument).isTrue()
+ assertThat(options.dataCollectionResolver.isGraphqlVariables).isTrue()
+ }
+
+ @Test
+ fun `database query data uses sendDefaultPii when Data Collection is absent`() {
+ val options = SentryOptions()
+
+ assertThat(options.dataCollectionResolver.isDatabaseQueryData).isFalse()
+
+ options.isSendDefaultPii = true
+
+ assertThat(options.dataCollectionResolver.isDatabaseQueryData).isTrue()
+ }
+
+ @Test
+ fun `database query data uses configured Data Collection value`() {
+ val options = SentryOptions().apply { isSendDefaultPii = true }
+
+ options.dataCollection.setDatabaseQueryData(false)
+
+ assertThat(options.dataCollectionResolver.isDatabaseQueryData).isFalse()
+
+ options.isSendDefaultPii = false
+ options.dataCollection.setDatabaseQueryData(true)
+
+ assertThat(options.dataCollectionResolver.isDatabaseQueryData).isTrue()
+ }
+
+ @Test
+ fun `GraphQL document uses sendDefaultPii when Data Collection is absent`() {
+ val options = SentryOptions()
+
+ assertThat(options.dataCollectionResolver.isGraphqlDocument).isFalse()
+
+ options.isSendDefaultPii = true
+
+ assertThat(options.dataCollectionResolver.isGraphqlDocument).isTrue()
+ }
+
+ @Test
+ fun `GraphQL document uses configured Data Collection value`() {
+ val options = SentryOptions().apply { isSendDefaultPii = true }
+
+ options.dataCollection.graphql.setDocument(false)
+
+ assertThat(options.dataCollectionResolver.isGraphqlDocument).isFalse()
+
+ options.isSendDefaultPii = false
+ options.dataCollection.graphql.setDocument(true)
+
+ assertThat(options.dataCollectionResolver.isGraphqlDocument).isTrue()
+ }
+
+ @Test
+ fun `GraphQL variables use sendDefaultPii when Data Collection is absent`() {
+ val options = SentryOptions()
+
+ assertThat(options.dataCollectionResolver.isGraphqlVariables).isFalse()
+
+ options.isSendDefaultPii = true
+
+ assertThat(options.dataCollectionResolver.isGraphqlVariables).isTrue()
+ }
+
+ @Test
+ fun `GraphQL variables use configured Data Collection value`() {
+ val options = SentryOptions().apply { isSendDefaultPii = true }
+
+ options.dataCollection.graphql.setVariables(false)
+
+ assertThat(options.dataCollectionResolver.isGraphqlVariables).isFalse()
+
+ options.isSendDefaultPii = false
+ options.dataCollection.graphql.setVariables(true)
+
+ assertThat(options.dataCollectionResolver.isGraphqlVariables).isTrue()
+ }
+
+ @Test
+ fun `GraphQL legacy body variants preserve the legacy size gate when namespace is absent`() {
+ val options =
+ SentryOptions().apply {
+ isSendDefaultPii = true
+ maxRequestBodySize = SentryOptions.RequestSize.NONE
+ }
+
+ assertThat(options.dataCollectionResolver.isGraphqlDocumentWithLegacyBodyGate).isFalse()
+ assertThat(options.dataCollectionResolver.isGraphqlVariablesWithLegacyBodyGate).isFalse()
+
+ options.maxRequestBodySize = SentryOptions.RequestSize.SMALL
+
+ assertThat(options.dataCollectionResolver.isGraphqlDocumentWithLegacyBodyGate).isTrue()
+ assertThat(options.dataCollectionResolver.isGraphqlVariablesWithLegacyBodyGate).isTrue()
+ }
+
+ @Test
+ fun `outgoing response legacy body variant preserves the legacy size gate`() {
+ val options =
+ SentryOptions().apply {
+ isSendDefaultPii = true
+ maxRequestBodySize = SentryOptions.RequestSize.NONE
+ }
+
+ assertThat(options.dataCollectionResolver.isOutgoingResponseBodyWithLegacyBodyGate).isFalse()
+
+ options.maxRequestBodySize = SentryOptions.RequestSize.SMALL
+
+ assertThat(options.dataCollectionResolver.isOutgoingResponseBodyWithLegacyBodyGate).isTrue()
+ }
+
+ @Test
+ fun `outgoing response legacy body variant uses data collection when namespace is explicit`() {
+ val options =
+ SentryOptions().apply {
+ isSendDefaultPii = false
+ maxRequestBodySize = SentryOptions.RequestSize.NONE
+ dataCollection.graphql.setDocument(true)
+ }
+
+ assertThat(options.dataCollectionResolver.isOutgoingResponseBodyWithLegacyBodyGate).isTrue()
+
+ options.dataCollection.httpBodies = emptySet()
+
+ assertThat(options.dataCollectionResolver.isOutgoingResponseBodyWithLegacyBodyGate).isFalse()
+ }
+
+ @Test
+ fun `GraphQL legacy body variants ignore the size option when namespace is explicit`() {
+ val options =
+ SentryOptions().apply {
+ isSendDefaultPii = false
+ maxRequestBodySize = SentryOptions.RequestSize.NONE
+ dataCollection.graphql.setDocument(true)
+ dataCollection.graphql.setVariables(true)
+ }
+
+ assertThat(options.dataCollectionResolver.isGraphqlDocumentWithLegacyBodyGate).isTrue()
+ assertThat(options.dataCollectionResolver.isGraphqlVariablesWithLegacyBodyGate).isTrue()
+ }
+
+ @Test
+ fun `GraphQL document legacy always variant preserves collection when namespace is absent`() {
+ val options = SentryOptions().apply { isSendDefaultPii = false }
+
+ assertThat(options.dataCollectionResolver.isGraphqlDocumentWithLegacyAlways).isTrue()
+
+ options.dataCollection.graphql.setDocument(false)
+
+ assertThat(options.dataCollectionResolver.isGraphqlDocumentWithLegacyAlways).isFalse()
+ }
+
+ @Test
+ fun `GraphQL variables legacy always variant preserves collection when namespace is absent`() {
+ val options = SentryOptions().apply { isSendDefaultPii = false }
+
+ assertThat(options.dataCollectionResolver.isGraphqlVariablesWithLegacyAlways).isTrue()
+
+ options.dataCollection.graphql.setVariables(false)
+
+ assertThat(options.dataCollectionResolver.isGraphqlVariablesWithLegacyAlways).isFalse()
+ }
+
+ @Test
+ fun `cookies are off when unset and sendDefaultPii is false`() {
+ val options = SentryOptions()
+
+ assertThat(options.dataCollectionResolver.cookies).isEqualTo(KeyValueCollectionBehavior.off())
+ }
+
+ @Test
+ fun `mutating one fallback key-value behavior does not affect other getters`() {
+ val resolver = SentryOptions().apply { dataCollection.setUserInfo(true) }.dataCollectionResolver
+
+ resolver.cookies.terms = listOf("custom-cookie")
+
+ assertThat(resolver.urlQueryParams.terms).doesNotContain("custom-cookie")
+ assertThat(resolver.httpRequestHeaders.terms).doesNotContain("custom-cookie")
+ assertThat(resolver.httpResponseHeaders.terms).doesNotContain("custom-cookie")
+ }
+
+ @Test
+ fun `cookies use default deny list when unset and sendDefaultPii is true`() {
+ val options = SentryOptions().apply { isSendDefaultPii = true }
+
+ assertThat(options.dataCollectionResolver.cookies)
+ .isEqualTo(KeyValueCollectionBehavior.denyList())
+ }
+
+ @Test
+ fun `cookies use default deny list when namespace is explicit`() {
+ val options = SentryOptions().apply { isSendDefaultPii = false }
+
+ options.dataCollection.setUserInfo(false)
+
+ assertThat(options.dataCollectionResolver.cookies)
+ .isEqualTo(KeyValueCollectionBehavior.denyList())
+ }
+
+ @Test
+ fun `cookies use configured Data Collection behavior`() {
+ val options = SentryOptions().apply { isSendDefaultPii = false }
+ val behavior = KeyValueCollectionBehavior.allowList("language", "theme")
+
+ options.dataCollection.cookies = behavior
+
+ assertThat(options.dataCollectionResolver.cookies).isEqualTo(behavior)
+ }
+
+ @Test
+ fun `URL query params use default deny list when unset`() {
+ val options = SentryOptions()
+
+ assertThat(options.dataCollectionResolver.urlQueryParams)
+ .isEqualTo(KeyValueCollectionBehavior.denyList())
+ }
+
+ @Test
+ fun `URL query params use configured Data Collection behavior`() {
+ val options = SentryOptions()
+ val behavior = KeyValueCollectionBehavior.allowList("language", "theme")
+
+ options.dataCollection.urlQueryParams = behavior
+
+ assertThat(options.dataCollectionResolver.urlQueryParams).isEqualTo(behavior)
+ }
+
+ @Test
+ fun `HTTP request headers use default deny list when unset`() {
+ val options = SentryOptions()
+
+ assertThat(options.dataCollectionResolver.httpRequestHeaders)
+ .isEqualTo(KeyValueCollectionBehavior.denyList())
+ }
+
+ @Test
+ fun `HTTP request headers use configured Data Collection behavior`() {
+ val options = SentryOptions()
+ val behavior = KeyValueCollectionBehavior.allowList("content-type")
+
+ options.dataCollection.httpHeaders.request = behavior
+
+ assertThat(options.dataCollectionResolver.httpRequestHeaders).isEqualTo(behavior)
+ }
+
+ @Test
+ fun `HTTP response headers use default deny list when unset`() {
+ val options = SentryOptions()
+
+ assertThat(options.dataCollectionResolver.httpResponseHeaders)
+ .isEqualTo(KeyValueCollectionBehavior.denyList())
+ }
+
+ @Test
+ fun `HTTP response headers use configured Data Collection behavior`() {
+ val options = SentryOptions()
+ val behavior = KeyValueCollectionBehavior.off()
+
+ options.dataCollection.httpHeaders.response = behavior
+
+ assertThat(options.dataCollectionResolver.httpResponseHeaders).isEqualTo(behavior)
+ }
+
+ @Test
+ fun `HTTP bodies preserve direction-specific legacy fallbacks when data collection is absent`() {
+ val options = SentryOptions()
+
+ assertThat(options.dataCollectionResolver.isIncomingRequestBody).isFalse()
+ assertThat(options.dataCollectionResolver.isOutgoingRequestBody).isTrue()
+ assertThat(options.dataCollectionResolver.isIncomingResponseBody).isTrue()
+ assertThat(options.dataCollectionResolver.isOutgoingResponseBody).isFalse()
+
+ options.isSendDefaultPii = true
+
+ assertThat(options.dataCollectionResolver.isIncomingRequestBody).isTrue()
+ assertThat(options.dataCollectionResolver.isOutgoingRequestBody).isTrue()
+ assertThat(options.dataCollectionResolver.isIncomingResponseBody).isTrue()
+ assertThat(options.dataCollectionResolver.isOutgoingResponseBody).isTrue()
+ }
+
+ @Test
+ fun `explicit empty data collection enables every HTTP body direction`() {
+ val options = SentryOptions().apply { dataCollection = DataCollection() }
+
+ assertThat(options.dataCollectionResolver.isIncomingRequestBody).isTrue()
+ assertThat(options.dataCollectionResolver.isOutgoingRequestBody).isTrue()
+ assertThat(options.dataCollectionResolver.isIncomingResponseBody).isTrue()
+ assertThat(options.dataCollectionResolver.isOutgoingResponseBody).isTrue()
+ }
+
+ @Test
+ fun `explicit HTTP body set controls every direction`() {
+ val options = SentryOptions().apply { isSendDefaultPii = true }
+
+ options.dataCollection.httpBodies =
+ setOf(HttpBodyType.INCOMING_REQUEST, HttpBodyType.OUTGOING_RESPONSE)
+
+ assertThat(options.dataCollectionResolver.isIncomingRequestBody).isTrue()
+ assertThat(options.dataCollectionResolver.isOutgoingRequestBody).isFalse()
+ assertThat(options.dataCollectionResolver.isIncomingResponseBody).isFalse()
+ assertThat(options.dataCollectionResolver.isOutgoingResponseBody).isTrue()
+ }
+}
diff --git a/sentry/src/test/java/io/sentry/DataCollectionTest.kt b/sentry/src/test/java/io/sentry/DataCollectionTest.kt
new file mode 100644
index 00000000000..54366a8e136
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/DataCollectionTest.kt
@@ -0,0 +1,103 @@
+package io.sentry
+
+import com.google.common.truth.Truth.assertThat
+import kotlin.test.Test
+import kotlin.test.assertFailsWith
+
+class DataCollectionTest {
+ @Test
+ fun `public constructor forces Data Collection for empty configuration`() {
+ val dataCollection = DataCollection()
+
+ assertThat(dataCollection.userInfo).isNull()
+ assertThat(dataCollection.cookies).isNull()
+ assertThat(dataCollection.urlQueryParams).isNull()
+ assertThat(dataCollection.httpBodies).isNull()
+ assertThat(dataCollection.databaseQueryData).isNull()
+ assertThat(dataCollection.httpHeaders.request).isNull()
+ assertThat(dataCollection.httpHeaders.response).isNull()
+ assertThat(dataCollection.graphql.document).isNull()
+ assertThat(dataCollection.graphql.variables).isNull()
+ assertThat(dataCollection.isExplicitlyConfigured()).isTrue()
+ }
+
+ @Test
+ fun `SDK-owned configuration does not force Data Collection`() {
+ val dataCollection = DataCollection(false)
+
+ assertThat(dataCollection.isExplicitlyConfigured()).isFalse()
+ }
+
+ @Test
+ fun `nested override makes SDK-owned configuration explicit`() {
+ val dataCollection = DataCollection(false)
+
+ dataCollection.graphql.setVariables(false)
+
+ assertThat(dataCollection.isExplicitlyConfigured()).isTrue()
+ }
+
+ @Test
+ fun `explicit false is distinct from unset`() {
+ val dataCollection = DataCollection(false)
+
+ dataCollection.setUserInfo(false)
+
+ assertThat(dataCollection.userInfo).isFalse()
+ assertThat(dataCollection.isExplicitlyConfigured()).isTrue()
+ }
+
+ @Test
+ fun `empty HTTP body set is distinct from unset`() {
+ val dataCollection = DataCollection(false)
+
+ dataCollection.setHttpBodies(emptySet())
+
+ assertThat(dataCollection.httpBodies).isEmpty()
+ assertThat(dataCollection.isExplicitlyConfigured()).isTrue()
+ }
+
+ @Test
+ fun `HTTP body set is copied and immutable`() {
+ val bodies = mutableSetOf(HttpBodyType.INCOMING_REQUEST)
+ val dataCollection = DataCollection()
+
+ dataCollection.setHttpBodies(bodies)
+ bodies += HttpBodyType.OUTGOING_REQUEST
+
+ assertThat(dataCollection.httpBodies).containsExactly(HttpBodyType.INCOMING_REQUEST)
+ assertFailsWith {
+ dataCollection.httpBodies!!.add(HttpBodyType.OUTGOING_REQUEST)
+ }
+ }
+
+ @Test
+ fun `database query data false is distinct from unset`() {
+ val dataCollection = DataCollection(false)
+
+ dataCollection.setDatabaseQueryData(false)
+
+ assertThat(dataCollection.databaseQueryData).isFalse()
+ assertThat(dataCollection.isExplicitlyConfigured()).isTrue()
+ }
+
+ @Test
+ fun `nested HTTP header override marks configuration explicit`() {
+ val dataCollection = DataCollection(false)
+ val behavior = KeyValueCollectionBehavior.denyList("authorization")
+
+ dataCollection.httpHeaders.setRequest(behavior)
+
+ assertThat(dataCollection.isExplicitlyConfigured()).isTrue()
+ }
+
+ @Test
+ fun `nested GraphQL false marks configuration explicit`() {
+ val dataCollection = DataCollection(false)
+
+ dataCollection.graphql.setVariables(false)
+
+ assertThat(dataCollection.graphql.variables).isFalse()
+ assertThat(dataCollection.isExplicitlyConfigured()).isTrue()
+ }
+}
diff --git a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
index fee707d31f3..b4b800d589d 100644
--- a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
@@ -1,9 +1,11 @@
package io.sentry
+import com.google.common.truth.Truth.assertThat
import io.sentry.config.PropertiesProviderFactory
import java.lang.RuntimeException
import kotlin.test.Test
import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
import kotlin.test.assertFalse
import kotlin.test.assertNotNull
import kotlin.test.assertNull
@@ -15,6 +17,98 @@ import org.mockito.kotlin.mock
import org.mockito.kotlin.verify
class ExternalOptionsTest {
+ @Test
+ fun `does not create data collection when external properties are absent`() {
+ withPropertiesFile { assertThat(it.dataCollection).isNull() }
+ }
+
+ @Test
+ fun `creates data collection using external properties`() {
+ withPropertiesFile(
+ listOf(
+ "data-collection.user-info=false",
+ "data-collection.http-bodies=incoming_request,outgoing_response",
+ "data-collection.cookies.mode=deny_list",
+ "data-collection.cookies.terms=authorization,session",
+ "data-collection.http-headers.request.mode=allow_list",
+ "data-collection.http-headers.request.terms=x-request-id,content-type",
+ "data-collection.http-headers.response.mode=off",
+ "data-collection.url-query-params.terms=search",
+ "data-collection.graphql.document=false",
+ "data-collection.graphql.variables=true",
+ "data-collection.database-query-data=false",
+ )
+ ) { options ->
+ val dataCollection = options.dataCollection
+
+ assertThat(dataCollection).isNotNull()
+ assertThat(dataCollection!!.userInfo).isFalse()
+ assertThat(dataCollection.httpBodies)
+ .containsExactly(HttpBodyType.INCOMING_REQUEST, HttpBodyType.OUTGOING_RESPONSE)
+ assertThat(dataCollection.cookies)
+ .isEqualTo(KeyValueCollectionBehavior.denyList("authorization", "session"))
+ assertThat(dataCollection.httpHeaders.request)
+ .isEqualTo(KeyValueCollectionBehavior.allowList("x-request-id", "content-type"))
+ assertThat(dataCollection.httpHeaders.response).isEqualTo(KeyValueCollectionBehavior.off())
+ assertThat(dataCollection.urlQueryParams)
+ .isEqualTo(KeyValueCollectionBehavior.denyList("search"))
+ assertThat(dataCollection.graphql.document).isFalse()
+ assertThat(dataCollection.graphql.variables).isTrue()
+ assertThat(dataCollection.databaseQueryData).isFalse()
+ }
+ }
+
+ @Test
+ fun `empty HTTP bodies externally disables body collection`() {
+ withPropertiesFile("data-collection.http-bodies=") { options ->
+ assertThat(options.dataCollection).isNotNull()
+ assertThat(options.dataCollection!!.httpBodies).isEmpty()
+ }
+ }
+
+ @Test
+ fun `invalid HTTP body type fails external parsing`() {
+ assertFailsWith {
+ withPropertiesFile("data-collection.http-bodies=invalid") {}
+ }
+ }
+
+ @Test
+ fun `invalid collection mode fails external parsing`() {
+ assertFailsWith {
+ withPropertiesFile("data-collection.cookies.mode=invalid") {}
+ }
+ }
+
+ @Test
+ fun `data collection booleans use default external parsing`() {
+ withPropertiesFile(
+ listOf(
+ "data-collection.user-info=invalid",
+ "data-collection.graphql.document=invalid",
+ "data-collection.graphql.variables=invalid",
+ "data-collection.database-query-data=invalid",
+ )
+ ) { options ->
+ assertThat(options.dataCollection!!.userInfo).isFalse()
+ assertThat(options.dataCollection!!.graphql.document).isFalse()
+ assertThat(options.dataCollection!!.graphql.variables).isFalse()
+ assertThat(options.dataCollection!!.databaseQueryData).isFalse()
+ }
+ }
+
+ @Test
+ fun `external data collection takes precedence over external send default PII`() {
+ withPropertiesFile(listOf("send-default-pii=false", "data-collection.cookies.mode=off")) {
+ externalOptions ->
+ val options = SentryOptions().apply { merge(externalOptions) }
+
+ assertThat(options.isSendDefaultPii).isFalse()
+ assertThat(options.dataCollectionResolver.isUserInfo).isTrue()
+ assertThat(options.dataCollectionResolver.cookies).isEqualTo(KeyValueCollectionBehavior.off())
+ }
+ }
+
@Test
fun `creates options with proxy using external properties`() {
withPropertiesFile(
diff --git a/sentry/src/test/java/io/sentry/KeyValueCollectionBehaviorTest.kt b/sentry/src/test/java/io/sentry/KeyValueCollectionBehaviorTest.kt
new file mode 100644
index 00000000000..09cd92f4fce
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/KeyValueCollectionBehaviorTest.kt
@@ -0,0 +1,70 @@
+package io.sentry
+
+import com.google.common.truth.Truth.assertThat
+import kotlin.test.Test
+
+class KeyValueCollectionBehaviorTest {
+ @Test
+ fun `default constructor uses deny list with no terms`() {
+ val behavior = KeyValueCollectionBehavior()
+
+ assertThat(behavior.mode).isEqualTo(KeyValueCollectionBehavior.Mode.DENY_LIST)
+ assertThat(behavior.terms).isEmpty()
+ }
+
+ @Test
+ fun `setters update mode and defensively copy terms`() {
+ val terms = mutableListOf("token")
+ val behavior = KeyValueCollectionBehavior()
+
+ behavior.mode = KeyValueCollectionBehavior.Mode.ALLOW_LIST
+ behavior.terms = terms
+ terms[0] = "password"
+
+ assertThat(behavior.mode).isEqualTo(KeyValueCollectionBehavior.Mode.ALLOW_LIST)
+ assertThat(behavior.terms).containsExactly("token")
+ }
+
+ @Test
+ fun `off has no terms`() {
+ val behavior = KeyValueCollectionBehavior.off()
+
+ assertThat(behavior.mode).isEqualTo(KeyValueCollectionBehavior.Mode.OFF)
+ assertThat(behavior.terms).isEmpty()
+ }
+
+ @Test
+ fun `deny list stores terms in order`() {
+ val behavior = KeyValueCollectionBehavior.denyList("token", "session")
+
+ assertThat(behavior.mode).isEqualTo(KeyValueCollectionBehavior.Mode.DENY_LIST)
+ assertThat(behavior.terms).containsExactly("token", "session").inOrder()
+ }
+
+ @Test
+ fun `allow list can be empty`() {
+ val behavior = KeyValueCollectionBehavior.allowList()
+
+ assertThat(behavior.mode).isEqualTo(KeyValueCollectionBehavior.Mode.ALLOW_LIST)
+ assertThat(behavior.terms).isEmpty()
+ }
+
+ @Test
+ fun `terms are copied and immutable`() {
+ val terms = arrayOf("token")
+ val behavior = KeyValueCollectionBehavior.denyList(*terms)
+
+ terms[0] = "password"
+
+ assertThat(behavior.terms).containsExactly("token")
+ }
+
+ @Test
+ fun `equal behaviors have equal hash codes`() {
+ val first = KeyValueCollectionBehavior.allowList("language", "theme")
+ val second = KeyValueCollectionBehavior.allowList("language", "theme")
+
+ assertThat(first).isEqualTo(second)
+ assertThat(first.hashCode()).isEqualTo(second.hashCode())
+ }
+}
diff --git a/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt b/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt
index fe5c835c90f..643b850e86e 100644
--- a/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt
+++ b/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt
@@ -1,5 +1,6 @@
package io.sentry
+import com.google.common.truth.Truth.assertThat
import io.sentry.hints.AbnormalExit
import io.sentry.hints.ApplyScopeData
import io.sentry.protocol.DebugMeta
@@ -321,6 +322,39 @@ class MainEventProcessorTest {
assertNotNull(event.user) { assertNull(it.ipAddress) }
}
+ @Test
+ fun `when user info is disabled, do not enrich ip address if sendDefaultPii is true`() {
+ fixture.sentryOptions.dataCollection.setUserInfo(false)
+ val sut = fixture.getSut(sendDefaultPii = true)
+ val event = SentryEvent()
+
+ sut.process(event, Hint())
+
+ assertThat(event.user?.ipAddress).isNull()
+ }
+
+ @Test
+ fun `when user info is enabled, enrich ip address if sendDefaultPii is false`() {
+ fixture.sentryOptions.dataCollection.setUserInfo(true)
+ val sut = fixture.getSut(sendDefaultPii = false)
+ val event = SentryEvent()
+
+ sut.process(event, Hint())
+
+ assertThat(event.user?.ipAddress).isEqualTo("{{auto}}")
+ }
+
+ @Test
+ fun `when another data collection setting is configured, omitted user info uses its default`() {
+ fixture.sentryOptions.dataCollection.cookies = KeyValueCollectionBehavior.off()
+ val sut = fixture.getSut(sendDefaultPii = false)
+ val event = SentryEvent()
+
+ sut.process(event, Hint())
+
+ assertThat(event.user?.ipAddress).isEqualTo("{{auto}}")
+ }
+
@Test
fun `when event has ip address set, keeps original ip address`() {
val sut = fixture.getSut(sendDefaultPii = true)
diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
index 64482b5d5d0..1416fb00830 100644
--- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
@@ -1,5 +1,6 @@
package io.sentry
+import com.google.common.truth.Truth.assertThat
import io.sentry.SentryOptions.RequestSize
import io.sentry.logger.ILoggerBatchProcessorFactory
import io.sentry.util.StringUtils
@@ -20,6 +21,148 @@ import org.mockito.kotlin.mock
import org.mockito.kotlin.verify
class SentryOptionsTest {
+ @Test
+ fun `data collection is always present without being explicitly configured`() {
+ val options = SentryOptions()
+
+ assertThat(options.dataCollection).isNotNull()
+ assertThat(options.dataCollection.isExplicitlyConfigured()).isFalse()
+ }
+
+ @Test
+ fun `data collection getter returns the same instance`() {
+ val options = SentryOptions()
+
+ assertThat(options.dataCollection).isSameInstanceAs(options.dataCollection)
+ assertThat(options.dataCollection.isExplicitlyConfigured()).isFalse()
+ }
+
+ @Test
+ fun `setting a data collection override marks it explicitly configured`() {
+ val options = SentryOptions()
+
+ options.dataCollection.setUserInfo(false)
+
+ assertThat(options.dataCollection.userInfo).isFalse()
+ assertThat(options.dataCollection.isExplicitlyConfigured()).isTrue()
+ }
+
+ @Test
+ fun `setting an empty data collection marks it explicitly configured`() {
+ val options = SentryOptions()
+
+ options.dataCollection = DataCollection()
+
+ assertThat(options.dataCollection.isExplicitlyConfigured()).isTrue()
+ }
+
+ @Test
+ fun `setting data collection replaces the default instance`() {
+ val options = SentryOptions()
+ val dataCollection = DataCollection().apply { setUserInfo(false) }
+
+ options.dataCollection = dataCollection
+
+ assertThat(options.dataCollection).isSameInstanceAs(dataCollection)
+ assertThat(options.dataCollection.userInfo).isFalse()
+ }
+
+ @Test
+ fun `setting null data collection preserves the current instance`() {
+ val options = SentryOptions()
+ val dataCollection = DataCollection().apply { setUserInfo(false) }
+ options.dataCollection = dataCollection
+
+ SentryOptions::class
+ .java
+ .getMethod("setDataCollection", DataCollection::class.java)
+ .invoke(options, null)
+
+ assertThat(options.dataCollection).isSameInstanceAs(dataCollection)
+ assertThat(options.dataCollection.userInfo).isFalse()
+ }
+
+ @Test
+ fun `merging absent external data collection preserves legacy mode`() {
+ val options = SentryOptions()
+
+ options.merge(ExternalOptions())
+
+ assertThat(options.dataCollection.isExplicitlyConfigured()).isFalse()
+ }
+
+ @Test
+ fun `merging external data collection applies only configured values`() {
+ val options =
+ SentryOptions().apply {
+ dataCollection.setUserInfo(false)
+ dataCollection.cookies = KeyValueCollectionBehavior.allowList("safe")
+ }
+ val externalOptions =
+ ExternalOptions().apply {
+ dataCollection = DataCollection().apply { graphql.setVariables(false) }
+ }
+
+ options.merge(externalOptions)
+
+ assertThat(options.dataCollection.userInfo).isFalse()
+ assertThat(options.dataCollection.cookies)
+ .isEqualTo(KeyValueCollectionBehavior.allowList("safe"))
+ assertThat(options.dataCollection.graphql.variables).isFalse()
+ }
+
+ @Test
+ fun `merging external data collection applies every supported value`() {
+ val externalDataCollection =
+ DataCollection().apply {
+ setUserInfo(false)
+ httpBodies = setOf(HttpBodyType.INCOMING_REQUEST, HttpBodyType.OUTGOING_RESPONSE)
+ cookies = KeyValueCollectionBehavior.denyList("cookie")
+ httpHeaders.request = KeyValueCollectionBehavior.allowList("request")
+ httpHeaders.response = KeyValueCollectionBehavior.off()
+ urlQueryParams = KeyValueCollectionBehavior.denyList("query")
+ graphql.setDocument(false)
+ graphql.setVariables(false)
+ setDatabaseQueryData(false)
+ }
+ val options = SentryOptions()
+
+ options.merge(ExternalOptions().apply { dataCollection = externalDataCollection })
+
+ assertThat(options.dataCollection.userInfo).isFalse()
+ assertThat(options.dataCollection.httpBodies)
+ .containsExactly(HttpBodyType.INCOMING_REQUEST, HttpBodyType.OUTGOING_RESPONSE)
+ assertThat(options.dataCollection.cookies)
+ .isEqualTo(KeyValueCollectionBehavior.denyList("cookie"))
+ assertThat(options.dataCollection.httpHeaders.request)
+ .isEqualTo(KeyValueCollectionBehavior.allowList("request"))
+ assertThat(options.dataCollection.httpHeaders.response)
+ .isEqualTo(KeyValueCollectionBehavior.off())
+ assertThat(options.dataCollection.urlQueryParams)
+ .isEqualTo(KeyValueCollectionBehavior.denyList("query"))
+ assertThat(options.dataCollection.graphql.document).isFalse()
+ assertThat(options.dataCollection.graphql.variables).isFalse()
+ assertThat(options.dataCollection.databaseQueryData).isFalse()
+ }
+
+ @Test
+ fun `external data collection takes precedence over send default PII`() {
+ val externalOptions =
+ ExternalOptions().apply {
+ isSendDefaultPii = false
+ dataCollection = DataCollection().apply { cookies = KeyValueCollectionBehavior.off() }
+ }
+ val options = SentryOptions()
+
+ options.merge(externalOptions)
+
+ assertThat(options.isSendDefaultPii).isFalse()
+ assertThat(options.dataCollection.isExplicitlyConfigured()).isTrue()
+ assertThat(options.dataCollectionResolver.isUserInfo).isTrue()
+ assertThat(options.dataCollectionResolver.isDatabaseQueryData).isTrue()
+ assertThat(options.dataCollectionResolver.cookies).isEqualTo(KeyValueCollectionBehavior.off())
+ }
+
@Test
fun `when options is initialized, logger is not null`() {
assertNotNull(SentryOptions().logger)
diff --git a/sentry/src/test/java/io/sentry/util/CookieUtilsTest.kt b/sentry/src/test/java/io/sentry/util/CookieUtilsTest.kt
new file mode 100644
index 00000000000..0c000d31e41
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/util/CookieUtilsTest.kt
@@ -0,0 +1,424 @@
+package io.sentry.util
+
+import com.google.common.truth.Truth.assertThat
+import io.sentry.KeyValueCollectionBehavior
+import io.sentry.SentryOptions
+import java.util.Enumeration
+import java.util.StringTokenizer
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+
+class CookieUtilsTest {
+ @Test
+ fun `options cookie filters omit cookies in legacy mode without default pii`() {
+ val options = SentryOptions()
+
+ assertThat(CookieUtils.filterCookies("sessionId=secret", options)).isNull()
+ assertThat(CookieUtils.filterSetCookie("sessionId=secret; Path=/", options)).isNull()
+ }
+
+ @Test
+ fun `options cookie filters preserve cookies in legacy mode with default pii`() {
+ val options = SentryOptions().apply { isSendDefaultPii = true }
+
+ assertThat(CookieUtils.filterCookies("sessionId=secret", options)).isEqualTo("sessionId=secret")
+ assertThat(CookieUtils.filterSetCookie("sessionId=secret; Path=/", options))
+ .isEqualTo("sessionId=secret; Path=/")
+ }
+
+ @Test
+ fun `options cookie filters apply configured policy`() {
+ val options =
+ SentryOptions().apply {
+ dataCollection.cookies = KeyValueCollectionBehavior.denyList("customer")
+ }
+
+ assertThat(CookieUtils.filterCookies("theme=dark; customerId=123", options))
+ .isEqualTo("theme=dark; customerId=[Filtered]")
+ assertThat(CookieUtils.filterSetCookie("customerId=123; Path=/", options))
+ .isEqualTo("customerId=[Filtered]; Path=/")
+ }
+
+ @Test
+ fun `options cookie filters honor explicitly disabled collection`() {
+ val options =
+ SentryOptions().apply {
+ isSendDefaultPii = true
+ dataCollection.cookies = KeyValueCollectionBehavior.off()
+ }
+
+ assertThat(CookieUtils.filterCookies("theme=dark", options)).isNull()
+ assertThat(CookieUtils.filterSetCookie("theme=dark; Path=/", options)).isNull()
+ }
+
+ @Test
+ fun `cookie filter disables collection in off mode`() {
+ assertThat(
+ CookieUtils.filterCookies(
+ "name=value",
+ KeyValueCollectionBehavior.off(),
+ emptyList(),
+ )
+ )
+ .isNull()
+ }
+
+ @Test
+ fun `cookie deny list filters built-in configured and integration sensitive names`() {
+ assertThat(
+ CookieUtils.filterCookies(
+ "name=value; sessionId=secret; customerId=123; frameworkSession=456",
+ KeyValueCollectionBehavior.denyList("customer"),
+ listOf("frameworkSession"),
+ )
+ )
+ .isEqualTo(
+ "name=value; sessionId=[Filtered]; customerId=[Filtered]; frameworkSession=[Filtered]"
+ )
+ }
+
+ @Test
+ fun `cookie allow list only retains allowed non-sensitive values`() {
+ assertThat(
+ CookieUtils.filterCookies(
+ "theme=dark; sessionId=secret; language=en",
+ KeyValueCollectionBehavior.allowList("theme", "session"),
+ emptyList(),
+ )
+ )
+ .isEqualTo("theme=dark; sessionId=[Filtered]; language=[Filtered]")
+ }
+
+ @Test
+ fun `cookie filter preserves empty and padded base64 values`() {
+ assertThat(
+ CookieUtils.filterCookies(
+ "empty=; data=YWJjZA==",
+ KeyValueCollectionBehavior.denyList(),
+ emptyList(),
+ )
+ )
+ .isEqualTo("empty=; data=YWJjZA==")
+ }
+
+ @Test
+ fun `cookie filter uses only the first equals separator`() {
+ assertThat(
+ CookieUtils.filterCookies(
+ "theme=dark=contrast; token=abc=123",
+ KeyValueCollectionBehavior.denyList(),
+ emptyList(),
+ )
+ )
+ .isEqualTo("theme=dark=contrast; token=[Filtered]")
+ }
+
+ @Test
+ fun `cookie filter replaces malformed pairs without discarding valid pairs`() {
+ assertThat(
+ CookieUtils.filterCookies(
+ "theme=dark; opaque; =secret; empty=; sessionId=secret",
+ KeyValueCollectionBehavior.denyList(),
+ emptyList(),
+ )
+ )
+ .isEqualTo("theme=dark;[Filtered];[Filtered]; empty=; sessionId=[Filtered]")
+ }
+
+ @Test
+ fun `cookie filter replaces comma-separated malformed cookies`() {
+ assertThat(
+ CookieUtils.filterCookies(
+ "theme=dark, sessionId=secret",
+ KeyValueCollectionBehavior.denyList(),
+ emptyList(),
+ )
+ )
+ .isEqualTo("[Filtered]")
+ }
+
+ @Test
+ fun `cookie filter replaces space-separated malformed cookies`() {
+ assertThat(
+ CookieUtils.filterCookies(
+ "theme=dark sessionId=secret",
+ KeyValueCollectionBehavior.denyList(),
+ emptyList(),
+ )
+ )
+ .isEqualTo("[Filtered]")
+ }
+
+ @Test
+ fun `cookie filter preserves valid names and values`() {
+ val cookies =
+ "plain=abc123; empty=; base64=YWJjZA==; quoted=\"dark\"; quoted-empty=\"\"; encoded=hello%2Fworld; !#\$%&'*+-.^_`|~=!#\$%&'()*+-./:<=>?@[]^_`{|}~"
+
+ assertThat(
+ CookieUtils.filterCookies(
+ cookies,
+ KeyValueCollectionBehavior.denyList(),
+ emptyList(),
+ )
+ )
+ .isEqualTo(cookies)
+ }
+
+ @Test
+ fun `cookie filter preserves trailing whitespace after a cookie pair`() {
+ assertThat(
+ CookieUtils.filterCookies(
+ "theme=dark ",
+ KeyValueCollectionBehavior.denyList(),
+ emptyList(),
+ )
+ )
+ .isEqualTo("theme=dark ")
+ }
+
+ @Test
+ fun `cookie filter preserves trailing blank cookie segments`() {
+ assertThat(
+ CookieUtils.filterCookies(
+ "theme=dark;",
+ KeyValueCollectionBehavior.denyList(),
+ emptyList(),
+ )
+ )
+ .isEqualTo("theme=dark;")
+ assertThat(
+ CookieUtils.filterCookies(
+ "theme=dark; ",
+ KeyValueCollectionBehavior.denyList(),
+ emptyList(),
+ )
+ )
+ .isEqualTo("theme=dark; ")
+ }
+
+ @Test
+ fun `cookie filter replaces comma-separated malformed cookies in quoted values`() {
+ assertThat(
+ CookieUtils.filterCookies(
+ "theme=\"dark, sessionId=secret\"",
+ KeyValueCollectionBehavior.denyList(),
+ emptyList(),
+ )
+ )
+ .isEqualTo("[Filtered]")
+ }
+
+ @Test
+ fun `cookie filter replaces space-separated malformed cookies in quoted values`() {
+ assertThat(
+ CookieUtils.filterCookies(
+ "theme=\"dark sessionId=secret\"",
+ KeyValueCollectionBehavior.denyList(),
+ emptyList(),
+ )
+ )
+ .isEqualTo("[Filtered]")
+ }
+
+ @Test
+ fun `cookie allow list never exposes malformed pairs`() {
+ assertThat(
+ CookieUtils.filterCookies(
+ "theme=dark; opaque; =secret",
+ KeyValueCollectionBehavior.allowList("theme", "opaque"),
+ emptyList(),
+ )
+ )
+ .isEqualTo("theme=dark;[Filtered];[Filtered]")
+ }
+
+ @Test
+ fun `set cookie filter preserves attributes`() {
+ assertThat(
+ CookieUtils.filterSetCookie(
+ "sessionId=secret; Path=/; HttpOnly; SameSite=Lax",
+ KeyValueCollectionBehavior.denyList(),
+ )
+ )
+ .isEqualTo("sessionId=[Filtered]; Path=/; HttpOnly; SameSite=Lax")
+ }
+
+ @Test
+ fun `set cookie filter preserves empty and padded base64 values`() {
+ assertThat(
+ CookieUtils.filterSetCookie(
+ "data=YWJjZA==; Expires=Wed, 09 Jun 2021 10:18:14 GMT; Max-Age=3600; Domain=example.com; Path=/; Secure; HttpOnly; SameSite=Lax",
+ KeyValueCollectionBehavior.denyList(),
+ )
+ )
+ .isEqualTo(
+ "data=YWJjZA==; Expires=Wed, 09 Jun 2021 10:18:14 GMT; Max-Age=3600; Domain=example.com; Path=/; Secure; HttpOnly; SameSite=Lax"
+ )
+ assertThat(
+ CookieUtils.filterSetCookie(
+ "empty=; Path=/",
+ KeyValueCollectionBehavior.denyList(),
+ )
+ )
+ .isEqualTo("empty=; Path=/")
+ }
+
+ @Test
+ fun `set cookie allow list retains allowed non-sensitive value and attributes`() {
+ assertThat(
+ CookieUtils.filterSetCookie(
+ "theme=dark; Path=/; Secure",
+ KeyValueCollectionBehavior.allowList("theme"),
+ )
+ )
+ .isEqualTo("theme=dark; Path=/; Secure")
+ }
+
+ @Test
+ fun `set cookie filter replaces malformed cookie pair and discards attributes`() {
+ assertThat(
+ CookieUtils.filterSetCookie(
+ "opaque; Path=/; HttpOnly",
+ KeyValueCollectionBehavior.denyList(),
+ )
+ )
+ .isEqualTo("[Filtered]")
+ assertThat(
+ CookieUtils.filterSetCookie(
+ "=secret; Path=/; HttpOnly",
+ KeyValueCollectionBehavior.denyList(),
+ )
+ )
+ .isEqualTo("[Filtered]")
+ }
+
+ @Test
+ fun `set cookie allow list never exposes malformed cookie pair`() {
+ assertThat(
+ CookieUtils.filterSetCookie(
+ "opaque; Path=/; HttpOnly",
+ KeyValueCollectionBehavior.allowList("opaque"),
+ )
+ )
+ .isEqualTo("[Filtered]")
+ }
+
+ @Test
+ fun `set cookie filter disables collection in off mode`() {
+ assertThat(
+ CookieUtils.filterSetCookie(
+ "theme=dark; Path=/",
+ KeyValueCollectionBehavior.off(),
+ )
+ )
+ .isNull()
+ }
+
+ @Test
+ fun `cookie header filter processes every header value`() {
+ assertThat(
+ CookieUtils.filterCookiesFromHeader(
+ listOf("theme=dark; SID=secret", "language=en"),
+ KeyValueCollectionBehavior.denyList(),
+ emptyList(),
+ )
+ )
+ .containsExactly("theme=dark; SID=[Filtered]", "language=en")
+ .inOrder()
+ }
+
+ @Test
+ fun `cookie header filter skips null header values`() {
+ assertThat(
+ CookieUtils.filterCookiesFromHeader(
+ java.util.Arrays.asList("theme=dark", null),
+ KeyValueCollectionBehavior.denyList(),
+ emptyList(),
+ )
+ )
+ .containsExactly("theme=dark")
+ }
+
+ @Test
+ fun `null enumeration returns null when filtering security cookies from headers`() {
+ val enumeration: Enumeration? = null
+ val headers = CookieUtils.filterOutSecurityCookiesFromHeader(enumeration, "Cookie", emptyList())
+
+ assertNull(headers)
+ }
+
+ @Test
+ fun `null list returns null when filtering security cookies from headers`() {
+ val list: List? = null
+ val headers = CookieUtils.filterOutSecurityCookiesFromHeader(list, "Cookie", emptyList())
+
+ assertNull(headers)
+ }
+
+ @Test
+ fun `enumeration works when filtering security cookies from headers`() {
+ val enumeration: Enumeration? =
+ StringTokenizer(
+ "Cookie_2=value2; Cookie_3=value3; JSESSIONID=123456789; mysessioncookiename=1F54D793F432FEE4CFC6A3FAED6D062F|Cookie_1=value1; SID=987654312",
+ "|",
+ )
+ as Enumeration
+ val headers =
+ CookieUtils.filterOutSecurityCookiesFromHeader(
+ enumeration,
+ "Cookie",
+ listOf("mysessioncookiename"),
+ )
+
+ assertNotNull(headers)
+ assertEquals(2, headers.size)
+ assertEquals(
+ "Cookie_2=value2; Cookie_3=value3; JSESSIONID=[Filtered]; mysessioncookiename=[Filtered]",
+ headers!![0],
+ )
+ assertEquals("Cookie_1=value1; SID=[Filtered]", headers!![1])
+ }
+
+ @Test
+ fun `list works when filtering security cookies from headers`() {
+ val list: List? =
+ listOf(
+ "Cookie_2=value2; Cookie_3=value3; JSESSIONID=123456789; mysessioncookiename=1F54D793F432FEE4CFC6A3FAED6D062F",
+ "Cookie_1=value1; SID=987654312",
+ )
+ val headers =
+ CookieUtils.filterOutSecurityCookiesFromHeader(list, "Cookie", listOf("mysessioncookiename"))
+
+ assertNotNull(headers)
+ assertEquals(2, headers.size)
+ assertEquals(
+ "Cookie_2=value2; Cookie_3=value3; JSESSIONID=[Filtered]; mysessioncookiename=[Filtered]",
+ headers!![0],
+ )
+ assertEquals("Cookie_1=value1; SID=[Filtered]", headers!![1])
+ }
+
+ @Test
+ fun `filtering security cookies from header works for corrupted string`() {
+ val list: List? = listOf("Cookie_1=value1;; SID=; JSESSIONID; =")
+ val headers =
+ CookieUtils.filterOutSecurityCookiesFromHeader(list, "Cookie", listOf("mysessioncookiename"))
+
+ assertNotNull(headers)
+ assertEquals(1, headers.size)
+ assertEquals("Cookie_1=value1;; SID=[Filtered]; JSESSIONID=[Filtered]; =", headers!![0])
+ }
+
+ @Test
+ fun `filtering security cookies from header works for null string`() {
+ val list: List? = listOf(null)
+ val headers =
+ CookieUtils.filterOutSecurityCookiesFromHeader(list, "Cookie", listOf("mysessioncookiename"))
+
+ assertNotNull(headers)
+ assertEquals(1, headers.size)
+ assertEquals(null, headers!![0])
+ }
+}
diff --git a/sentry/src/test/java/io/sentry/util/GraphqlUtilsTest.kt b/sentry/src/test/java/io/sentry/util/GraphqlUtilsTest.kt
new file mode 100644
index 00000000000..d5cc325baef
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/util/GraphqlUtilsTest.kt
@@ -0,0 +1,100 @@
+package io.sentry.util
+
+import com.google.common.truth.Truth.assertThat
+import io.sentry.JsonObjectReader
+import io.sentry.SentryOptions
+import java.io.StringReader
+import kotlin.test.Test
+
+class GraphqlUtilsTest {
+ @Test
+ fun `filters document from a GraphQL request body`() {
+ val options = SentryOptions().also { it.dataCollection.graphql.setDocument(false) }
+
+ val result = GraphqlUtils.filterRequestBody(REQUEST_BODY, options)
+
+ JsonObjectReader(StringReader(result)).use { reader ->
+ @Suppress("UNCHECKED_CAST") val body = reader.nextObjectOrNull() as Map
+ assertThat(body).containsEntry("operationName", "GetUser")
+ assertThat(body).containsEntry("variables", mapOf("id" to "123"))
+ assertThat(body).doesNotContainKey("query")
+ }
+ }
+
+ @Test
+ fun `filters variables from a GraphQL request body`() {
+ val options = SentryOptions().also { it.dataCollection.graphql.setVariables(false) }
+
+ val result = GraphqlUtils.filterRequestBody(REQUEST_BODY, options)
+
+ JsonObjectReader(StringReader(result)).use { reader ->
+ @Suppress("UNCHECKED_CAST") val body = reader.nextObjectOrNull() as Map
+ assertThat(body).containsEntry("operationName", "GetUser")
+ assertThat(body).containsEntry("query", "query { viewer { name } }")
+ assertThat(body).doesNotContainKey("variables")
+ }
+ }
+
+ @Test
+ fun `filters documents from a batched GraphQL request body`() {
+ val options = SentryOptions().also { it.dataCollection.graphql.setDocument(false) }
+
+ val result = GraphqlUtils.filterRequestBody(BATCH_REQUEST_BODY, options)
+
+ assertThat(result).isNotNull()
+ JsonObjectReader(StringReader(result)).use { reader ->
+ @Suppress("UNCHECKED_CAST") val body = reader.nextObjectOrNull() as List>
+ assertThat(body).hasSize(2)
+ assertThat(body[0]).containsEntry("operationName", "GetUser")
+ assertThat(body[0]).containsEntry("variables", mapOf("id" to "123"))
+ assertThat(body[0]).doesNotContainKey("query")
+ assertThat(body[1]).containsEntry("operationName", "GetTeam")
+ assertThat(body[1]).containsEntry("variables", mapOf("slug" to "sdk"))
+ assertThat(body[1]).doesNotContainKey("query")
+ }
+ }
+
+ @Test
+ fun `filters variables from a batched GraphQL request body`() {
+ val options = SentryOptions().also { it.dataCollection.graphql.setVariables(false) }
+
+ val result = GraphqlUtils.filterRequestBody(BATCH_REQUEST_BODY, options)
+
+ assertThat(result).isNotNull()
+ JsonObjectReader(StringReader(result)).use { reader ->
+ @Suppress("UNCHECKED_CAST") val body = reader.nextObjectOrNull() as List>
+ assertThat(body).hasSize(2)
+ assertThat(body[0]).containsEntry("operationName", "GetUser")
+ assertThat(body[0]).containsEntry("query", "query { viewer { name } }")
+ assertThat(body[0]).doesNotContainKey("variables")
+ assertThat(body[1]).containsEntry("operationName", "GetTeam")
+ assertThat(body[1]).containsEntry("query", "query { team { name } }")
+ assertThat(body[1]).doesNotContainKey("variables")
+ }
+ }
+
+ @Test
+ fun `returns null for a batched GraphQL request body containing a non-object entry`() {
+ val options = SentryOptions().also { it.dataCollection.graphql.setDocument(false) }
+
+ val result = GraphqlUtils.filterRequestBody("""[$REQUEST_BODY,"unexpected"]""", options)
+
+ assertThat(result).isNull()
+ }
+
+ @Test
+ fun `returns null for a GraphQL request body containing a malformed unicode escape`() {
+ val options = SentryOptions().also { it.dataCollection.graphql.setDocument(false) }
+
+ val result = GraphqlUtils.filterRequestBody("""{"query":"\u12G4"}""", options)
+
+ assertThat(result).isNull()
+ }
+
+ private companion object {
+ const val REQUEST_BODY =
+ """{"operationName":"GetUser","variables":{"id":"123"},"query":"query { viewer { name } }"}"""
+ const val BATCH_REQUEST_BODY =
+ """[{"operationName":"GetUser","variables":{"id":"123"},"query":"query { viewer { name } }"},{"operationName":"GetTeam","variables":{"slug":"sdk"},"query":"query { team { name } }"}]"""
+ }
+}
diff --git a/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt b/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt
index 6d7815888e5..624f94a2ef0 100644
--- a/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt
+++ b/sentry/src/test/java/io/sentry/util/HttpUtilsTest.kt
@@ -1,91 +1,116 @@
package io.sentry.util
-import java.util.Enumeration
-import java.util.StringTokenizer
+import com.google.common.truth.Truth.assertThat
+import io.sentry.KeyValueCollectionBehavior
import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertNotNull
-import kotlin.test.assertNull
class HttpUtilsTest {
@Test
- fun `null enumeration returns null when filtering security cookies from headers`() {
- val enumeration: Enumeration? = null
- val headers = HttpUtils.filterOutSecurityCookiesFromHeader(enumeration, "Cookie", emptyList())
-
- assertNull(headers)
+ fun `query parameter filter disables collection in off mode`() {
+ assertThat(HttpUtils.filterQueryParams("name=value", KeyValueCollectionBehavior.off())).isNull()
}
@Test
- fun `null list returns null when filtering security cookies from headers`() {
- val list: List