Add nullability annotations to sentry module.

buildSrc/src/main/java/Config.kt

@@ -101,6 +101,7 @@ object Config {
         val mockitoInline = "org.mockito:mockito-inline:3.8.0"
         val awaitility = "org.awaitility:awaitility-kotlin:4.0.3"
         val mockWebserver = "com.squareup.okhttp3:mockwebserver:4.9.0"
+        val jsonUnit = "net.javacrumbs.json-unit:json-unit:2.11.1"
     }
 
     object QualityPlugins {
@@ -143,6 +144,7 @@ object Config {
         val nopenChecker = "com.jakewharton.nopen:nopen-checker:$nopenVersion"
         val errorprone = "com.google.errorprone:error_prone_core:2.5.1"
         val errorProneJavac8 = "com.google.errorprone:javac:9+181-r4173-1"
+        val errorProneNullAway = "com.uber.nullaway:nullaway:0.9.1"
     }
 
     object NativePlugins {

sentry-android-core/src/main/java/io/sentry/android/core/AndroidLogger.java

@@ -11,7 +11,10 @@ final class AndroidLogger implements ILogger {
 
   @SuppressWarnings("AnnotateFormatMethod")
   @Override
-  public void log(SentryLevel level, String message, Object... args) {
+  public void log(
+      final @Nullable SentryLevel level,
+      final @Nullable String message,
+      final @Nullable Object... args) {
     Log.println(toLogcatLevel(level), tag, String.format(message, args));
   }
 

sentry-android-core/src/test/java/io/sentry/android/core/DefaultAndroidEventProcessorTest.kt

@@ -106,8 +106,12 @@ class DefaultAndroidEventProcessorTest {
 
         assertNotNull(sut.process(SentryEvent(), null)) {
             assertNotNull(it.contexts.app)
-            assertEquals("test", it.debugMeta.images[0].uuid)
             assertNotNull(it.dist)
+            assertNotNull(it.debugMeta) { debugMeta ->
+                assertNotNull(debugMeta.images) { images ->
+                    assertEquals("test", images[0].uuid)
+                }
+            }
         }
     }
 
@@ -129,7 +133,11 @@ class DefaultAndroidEventProcessorTest {
         }
 
         assertNotNull(sut.process(event, null)) {
-            assertEquals("test", it.debugMeta.images[0].uuid)
+            assertNotNull(it.debugMeta) { debugMeta ->
+                assertNotNull(debugMeta.images) { images ->
+                    assertEquals("test", images[0].uuid)
+                }
+            }
         }
     }
 
@@ -148,8 +156,12 @@ class DefaultAndroidEventProcessorTest {
         }
 
         assertNotNull(sut.process(event, null)) {
-            assertEquals("abc", it.debugMeta.images.first().uuid)
-            assertEquals("test", it.debugMeta.images.last().uuid)
+            assertNotNull(it.debugMeta) { debugMeta ->
+                assertNotNull(debugMeta.images) { images ->
+                    assertEquals("abc", images.first().uuid)
+                    assertEquals("test", images.last().uuid)
+                }
+            }
         }
     }
 
@@ -165,7 +177,9 @@ class DefaultAndroidEventProcessorTest {
         }
 
         assertNotNull(sut.process(event, null)) {
-            assertTrue(it.threads.first().isCurrent)
+            assertNotNull(it.threads) { threads ->
+                assertTrue(threads.first().isCurrent == true)
+            }
         }
     }
 
@@ -180,7 +194,9 @@ class DefaultAndroidEventProcessorTest {
         }
 
         assertNotNull(sut.process(event, null)) {
-            assertFalse(it.threads.first().isCurrent)
+            assertNotNull(it.threads) { threads ->
+                assertFalse(threads.first().isCurrent == true)
+            }
         }
     }
 

sentry-android-timber/src/test/java/io/sentry/android/timber/SentryTimberTreeTest.kt

@@ -12,6 +12,7 @@ import io.sentry.getExc
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
 import timber.log.Timber
@@ -165,7 +166,9 @@ class SentryTimberTreeTest {
         val sut = fixture.getSut()
         sut.e("message")
         verify(fixture.hub).captureEvent(check {
-            assertEquals("message", it.message.formatted)
+            assertNotNull(it.message) { message ->
+                assertEquals("message", message.formatted)
+            }
         })
     }
 

sentry-apache-http-client-5/src/main/java/io/sentry/transport/apache/ApacheHttpClientTransport.java

@@ -25,6 +25,7 @@
 import org.apache.hc.core5.io.CloseMode;
 import org.apache.hc.core5.util.TimeValue;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * {@link ITransport} implementation that executes request asynchronously in a non-blocking manner
@@ -62,7 +63,8 @@ public ApacheHttpClientTransport(
 
   @Override
   @SuppressWarnings("FutureReturnValueIgnored")
-  public void send(SentryEnvelope envelope, Object hint) throws IOException {
+  public void send(final @NotNull SentryEnvelope envelope, final @Nullable Object hint)
+      throws IOException {
     if (isSchedulingAllowed()) {
       final SentryEnvelope filteredEnvelope = rateLimiter.filter(envelope, hint);
 

sentry-apache-http-client-5/src/main/java/io/sentry/transport/apache/ApacheHttpClientTransportFactory.java

@@ -32,7 +32,7 @@ public ApacheHttpClientTransportFactory(final @NotNull TimeValue connectionTimeT
   }
 
   @Override
-  public ITransport create(
+  public @NotNull ITransport create(
       final @NotNull SentryOptions options, final @NotNull RequestDetails requestDetails) {
     Objects.requireNonNull(options, "options is required");
     Objects.requireNonNull(requestDetails, "requestDetails is required");

sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt

@@ -80,9 +80,11 @@ class SentryHandlerTest {
 
         await.untilAsserted {
             verify(fixture.transport).send(checkEvent { event ->
-                assertEquals("testing message conversion 1, 2", event.message.formatted)
-                assertEquals("testing message conversion {0}, {1}", event.message.message)
-                assertEquals(listOf("1", "2"), event.message.params)
+                assertNotNull(event.message) { message ->
+                    assertEquals("testing message conversion 1, 2", message.formatted)
+                    assertEquals("testing message conversion {0}, {1}", message.message)
+                    assertEquals(listOf("1", "2"), message.params)
+                }
                 assertEquals("jul.SentryHandlerTest", event.logger)
             }, anyOrNull())
         }
@@ -95,9 +97,11 @@ class SentryHandlerTest {
 
         await.untilAsserted {
             verify(fixture.transport).send(checkEvent { event ->
-                assertEquals("testing message conversion 1, 2", event.message.formatted)
-                assertEquals("testing message conversion {0}, {1}", event.message.message)
-                assertEquals(listOf("1", "2"), event.message.params)
+                assertNotNull(event.message) { message ->
+                    assertEquals("testing message conversion 1, 2", message.formatted)
+                    assertEquals("testing message conversion {0}, {1}", message.message)
+                    assertEquals(listOf("1", "2"), message.params)
+                }
                 assertEquals("jul.SentryHandlerTest", event.logger)
             }, anyOrNull())
         }
@@ -205,16 +209,18 @@ class SentryHandlerTest {
 
         await.untilAsserted {
             verify(fixture.transport).send(checkEvent { event ->
-                assertEquals(2, event.breadcrumbs.size)
-                val breadcrumb = event.breadcrumbs[0]
-                val breadcrumbTime = Instant.ofEpochMilli(event.timestamp.time)
-                    .atZone(ZoneId.of("UTC"))
-                    .toLocalDateTime()
-                assertTrue { breadcrumbTime.plusSeconds(1).isAfter(utcTime) }
-                assertTrue { breadcrumbTime.minusSeconds(1).isBefore(utcTime) }
-                assertEquals("this should be a breadcrumb #1", breadcrumb.message)
-                assertEquals("jul.SentryHandlerTest", breadcrumb.category)
-                assertEquals(SentryLevel.DEBUG, breadcrumb.level)
+                assertNotNull(event.breadcrumbs) { breadcrumbs ->
+                    assertEquals(2, breadcrumbs.size)
+                    val breadcrumb = breadcrumbs[0]
+                    val breadcrumbTime = Instant.ofEpochMilli(event.timestamp.time)
+                        .atZone(ZoneId.of("UTC"))
+                        .toLocalDateTime()
+                    assertTrue { breadcrumbTime.plusSeconds(1).isAfter(utcTime) }
+                    assertTrue { breadcrumbTime.minusSeconds(1).isBefore(utcTime) }
+                    assertEquals("this should be a breadcrumb #1", breadcrumb.message)
+                    assertEquals("jul.SentryHandlerTest", breadcrumb.category)
+                    assertEquals(SentryLevel.DEBUG, breadcrumb.level)
+                }
             }, anyOrNull())
         }
     }
@@ -229,8 +235,10 @@ class SentryHandlerTest {
 
         await.untilAsserted {
             verify(fixture.transport).send(checkEvent { event ->
-                assertEquals(1, event.breadcrumbs.size)
-                assertEquals("this should be a breadcrumb", event.breadcrumbs[0].message)
+                assertNotNull(event.breadcrumbs) { breadcrumbs ->
+                    assertEquals(1, breadcrumbs.size)
+                    assertEquals("this should be a breadcrumb", breadcrumbs[0].message)
+                }
             }, anyOrNull())
         }
     }
@@ -246,9 +254,11 @@ class SentryHandlerTest {
 
         await.untilAsserted {
             verify(fixture.transport).send(checkEvent { event ->
-                assertEquals(2, event.breadcrumbs.size)
-                assertEquals("this should be a breadcrumb", event.breadcrumbs[0].message)
-                assertEquals("this should not be sent as the event but be a breadcrumb", event.breadcrumbs[1].message)
+                assertNotNull(event.breadcrumbs) { breadcrumbs ->
+                    assertEquals(2, breadcrumbs.size)
+                    assertEquals("this should be a breadcrumb", breadcrumbs[0].message)
+                    assertEquals("this should not be sent as the event but be a breadcrumb", breadcrumbs[1].message)
+                }
             }, anyOrNull())
         }
     }

sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt

@@ -103,9 +103,11 @@ class SentryAppenderTest {
 
         await.untilAsserted {
             verify(fixture.transport).send(checkEvent { event ->
-                assertEquals("testing message conversion 1, 2", event.message.formatted)
-                assertEquals("testing message conversion {}, {}", event.message.message)
-                assertEquals(listOf("1", "2"), event.message.params)
+                assertNotNull(event.message) { message ->
+                    assertEquals("testing message conversion 1, 2", message.formatted)
+                    assertEquals("testing message conversion {}, {}", message.message)
+                    assertEquals(listOf("1", "2"), message.params)
+                }
                 assertEquals("io.sentry.log4j2.SentryAppenderTest", event.logger)
             }, anyOrNull())
         }
@@ -270,16 +272,18 @@ class SentryAppenderTest {
 
         await.untilAsserted {
             verify(fixture.transport).send(checkEvent { event ->
-                assertEquals(2, event.breadcrumbs.size)
-                val breadcrumb = event.breadcrumbs[0]
-                val breadcrumbTime = Instant.ofEpochMilli(event.timestamp.time)
-                    .atZone(fixture.utcTimeZone)
-                    .toLocalDateTime()
-                assertTrue { breadcrumbTime.plusSeconds(1).isAfter(utcTime) }
-                assertTrue { breadcrumbTime.minusSeconds(1).isBefore(utcTime) }
-                assertEquals("this should be a breadcrumb #1", breadcrumb.message)
-                assertEquals("io.sentry.log4j2.SentryAppenderTest", breadcrumb.category)
-                assertEquals(SentryLevel.DEBUG, breadcrumb.level)
+                assertNotNull(event.breadcrumbs) { breadcrumbs ->
+                    assertEquals(2, breadcrumbs.size)
+                    val breadcrumb = breadcrumbs[0]
+                    val breadcrumbTime = Instant.ofEpochMilli(event.timestamp.time)
+                        .atZone(fixture.utcTimeZone)
+                        .toLocalDateTime()
+                    assertTrue { breadcrumbTime.plusSeconds(1).isAfter(utcTime) }
+                    assertTrue { breadcrumbTime.minusSeconds(1).isBefore(utcTime) }
+                    assertEquals("this should be a breadcrumb #1", breadcrumb.message)
+                    assertEquals("io.sentry.log4j2.SentryAppenderTest", breadcrumb.category)
+                    assertEquals(SentryLevel.DEBUG, breadcrumb.level)
+                }
             }, anyOrNull())
         }
     }
@@ -294,8 +298,10 @@ class SentryAppenderTest {
 
         await.untilAsserted {
             verify(fixture.transport).send(checkEvent { event ->
-                assertEquals(1, event.breadcrumbs.size)
-                assertEquals("this should be a breadcrumb", event.breadcrumbs[0].message)
+                assertNotNull(event.breadcrumbs) { breadcrumbs ->
+                    assertEquals(1, breadcrumbs.size)
+                    assertEquals("this should be a breadcrumb", breadcrumbs[0].message)
+                }
             }, anyOrNull())
         }
     }
@@ -311,9 +317,11 @@ class SentryAppenderTest {
 
         await.untilAsserted {
             verify(fixture.transport).send(checkEvent { event ->
-                assertEquals(2, event.breadcrumbs.size)
-                assertEquals("this should be a breadcrumb", event.breadcrumbs[0].message)
-                assertEquals("this should not be sent as the event but be a breadcrumb", event.breadcrumbs[1].message)
+                assertNotNull(event.breadcrumbs) { breadcrumbs ->
+                    assertEquals(2, breadcrumbs.size)
+                    assertEquals("this should be a breadcrumb", breadcrumbs[0].message)
+                    assertEquals("this should not be sent as the event but be a breadcrumb", breadcrumbs[1].message)
+                }
             }, anyOrNull())
         }
     }

sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt

@@ -93,9 +93,11 @@ class SentryAppenderTest {
 
         await.untilAsserted {
             verify(fixture.transport).send(checkEvent { event ->
-                assertEquals("testing message conversion 1, 2", event.message.formatted)
-                assertEquals("testing message conversion {}, {}", event.message.message)
-                assertEquals(listOf("1", "2"), event.message.params)
+                assertNotNull(event.message) { message ->
+                    assertEquals("testing message conversion 1, 2", message.formatted)
+                    assertEquals("testing message conversion {}, {}", message.message)
+                    assertEquals(listOf("1", "2"), message.params)
+                }
                 assertEquals("io.sentry.logback.SentryAppenderTest", event.logger)
             }, anyOrNull())
         }
@@ -262,16 +264,18 @@ class SentryAppenderTest {
 
         await.untilAsserted {
             verify(fixture.transport).send(checkEvent { event ->
-                assertEquals(2, event.breadcrumbs.size)
-                val breadcrumb = event.breadcrumbs[0]
-                val breadcrumbTime = Instant.ofEpochMilli(event.timestamp.time)
-                    .atZone(fixture.utcTimeZone)
-                    .toLocalDateTime()
-                assertTrue { breadcrumbTime.plusSeconds(1).isAfter(utcTime) }
-                assertTrue { breadcrumbTime.minusSeconds(1).isBefore(utcTime) }
-                assertEquals("this should be a breadcrumb #1", breadcrumb.message)
-                assertEquals("io.sentry.logback.SentryAppenderTest", breadcrumb.category)
-                assertEquals(SentryLevel.DEBUG, breadcrumb.level)
+                assertNotNull(event.breadcrumbs) { breadcrumbs ->
+                    assertEquals(2, breadcrumbs.size)
+                    val breadcrumb = breadcrumbs[0]
+                    val breadcrumbTime = Instant.ofEpochMilli(event.timestamp.time)
+                        .atZone(fixture.utcTimeZone)
+                        .toLocalDateTime()
+                    assertTrue { breadcrumbTime.plusSeconds(1).isAfter(utcTime) }
+                    assertTrue { breadcrumbTime.minusSeconds(1).isBefore(utcTime) }
+                    assertEquals("this should be a breadcrumb #1", breadcrumb.message)
+                    assertEquals("io.sentry.logback.SentryAppenderTest", breadcrumb.category)
+                    assertEquals(SentryLevel.DEBUG, breadcrumb.level)
+                }
             }, anyOrNull())
         }
     }
@@ -286,8 +290,10 @@ class SentryAppenderTest {
 
         await.untilAsserted {
             verify(fixture.transport).send(checkEvent { event ->
-                assertEquals(1, event.breadcrumbs.size)
-                assertEquals("this should be a breadcrumb", event.breadcrumbs[0].message)
+                assertNotNull(event.breadcrumbs) { breadcrumbs ->
+                    assertEquals(1, breadcrumbs.size)
+                    assertEquals("this should be a breadcrumb", breadcrumbs[0].message)
+                }
             }, anyOrNull())
         }
     }
@@ -303,9 +309,11 @@ class SentryAppenderTest {
 
         await.untilAsserted {
             verify(fixture.transport).send(checkEvent { event ->
-                assertEquals(2, event.breadcrumbs.size)
-                assertEquals("this should be a breadcrumb", event.breadcrumbs[0].message)
-                assertEquals("this should not be sent as the event but be a breadcrumb", event.breadcrumbs[1].message)
+                assertNotNull(event.breadcrumbs) { breadcrumbs ->
+                    assertEquals(2, breadcrumbs.size)
+                    assertEquals("this should be a breadcrumb", breadcrumbs[0].message)
+                    assertEquals("this should not be sent as the event but be a breadcrumb", breadcrumbs[1].message)
+                }
             }, anyOrNull())
         }
     }

sentry-servlet/src/test/kotlin/io/sentry/servlet/SentryRequestHttpServletRequestProcessorTest.kt

@@ -91,12 +91,14 @@ class SentryRequestHttpServletRequestProcessorTest {
 
         eventProcessor.process(event, null)
 
-        assertNotNull(event.request) {
-            assertFalse(it.headers.containsKey("X-FORWARDED-FOR"))
-            assertFalse(it.headers.containsKey("Authorization"))
-            assertFalse(it.headers.containsKey("authorization"))
-            assertFalse(it.headers.containsKey("Cookies"))
-            assertTrue(it.headers.containsKey("some-header"))
+        assertNotNull(event.request) { request ->
+            assertNotNull(request.headers) {
+                assertFalse(it.containsKey("X-FORWARDED-FOR"))
+                assertFalse(it.containsKey("Authorization"))
+                assertFalse(it.containsKey("authorization"))
+                assertFalse(it.containsKey("Cookies"))
+                assertTrue(it.containsKey("some-header"))
+            }
         }
     }
 }