fix: SentryClient overrides event with default data (#751)

Resolves #736

Author: bruno-garcia

sentry/src/main/java/io/sentry/SentryClient.java

@@ -148,32 +148,53 @@ public void sendEvent(Event event) {
      * @param eventBuilder {@link EventBuilder} to send to Sentry.
      */
     public void sendEvent(EventBuilder eventBuilder) {
-        if (!Util.isNullOrEmpty(release)) {
+        Event event = buildEvent(eventBuilder);
+        sendEvent(event);
+    }
+
+    /**
+     * Adds the SentryClient data into the builder without overriding existent data and builds the event.
+     * @param eventBuilder The event builder to potentially modify and to build the event.
+     * @return The event.
+     */
+    Event buildEvent(EventBuilder eventBuilder) {
+        Event workingEvent = eventBuilder.getEvent();
+
+        if (!Util.isNullOrEmpty(release) && workingEvent.getRelease() == null) {
             eventBuilder.withRelease(release.trim());
             if (!Util.isNullOrEmpty(dist)) {
                 eventBuilder.withDist(dist.trim());
             }
         }
 
-        if (!Util.isNullOrEmpty(environment)) {
+        if (!Util.isNullOrEmpty(environment) && workingEvent.getEnvironment() == null) {
             eventBuilder.withEnvironment(environment.trim());
         }
 
-        if (!Util.isNullOrEmpty(serverName)) {
+        if (!Util.isNullOrEmpty(serverName) && workingEvent.getServerName() == null) {
             eventBuilder.withServerName(serverName.trim());
         }
 
         for (Map.Entry<String, String> tagEntry : tags.entrySet()) {
-            eventBuilder.withTag(tagEntry.getKey(), tagEntry.getValue());
+            Map<String, String> workingTags = workingEvent.getTags();
+            String currentValue = workingTags.put(tagEntry.getKey(), tagEntry.getValue());
+            // Default tags should not override event-specific tags:
+            if (currentValue != null) {
+                workingTags.put(tagEntry.getKey(), currentValue);
+            }
         }
 
         for (Map.Entry<String, Object> extraEntry : extra.entrySet()) {
-            eventBuilder.withExtra(extraEntry.getKey(), extraEntry.getValue());
+            Map<String, Object> workingExtra = workingEvent.getExtra();
+            Object currentValue = workingExtra.put(extraEntry.getKey(), extraEntry.getValue());
+            // Default extra should not override event-specific extra:
+            if (currentValue != null) {
+                workingExtra.put(extraEntry.getKey(), currentValue);
+            }
         }
 
         runBuilderHelpers(eventBuilder);
-        Event event = eventBuilder.build();
-        sendEvent(event);
+        return eventBuilder.build();
     }
 
     /**

sentry/src/test/java/io/sentry/SentryClientTest.java

@@ -233,4 +233,123 @@ public boolean shouldSend(Event event) {
             assertThat(called.get(), is(true));
         }};
     }
+
+    @Test
+    public void testDefaultTagDoesntOverrideEvent() {
+        final String key = "key";
+        final String expectedValue = "expected";
+        sentryClient.addTag(key, "default");
+        EventBuilder eventBuilder = new EventBuilder();
+        eventBuilder.withTag(key, expectedValue);
+
+        Event event = sentryClient.buildEvent(eventBuilder);
+
+        assertThat(event.getTags().get(key), equalTo(expectedValue));
+    }
+
+    @Test
+    public void testDefaultTagSetToEvent() {
+        final String key = "key";
+        final String expectedValue = "expected";
+        sentryClient.addTag(key, expectedValue);
+        EventBuilder eventBuilder = new EventBuilder();
+
+        Event event = sentryClient.buildEvent(eventBuilder);
+
+        assertThat(event.getTags().get(key), equalTo(expectedValue));
+    }
+
+    @Test
+    public void testDefaultExtraDoesntOverrideEvent() {
+        final String key = "key";
+        final Object expectedValue = "expected";
+        sentryClient.addExtra(key, (Object)"default");
+        EventBuilder eventBuilder = new EventBuilder();
+        eventBuilder.withExtra(key, expectedValue);
+
+        Event event = sentryClient.buildEvent(eventBuilder);
+
+        assertThat(event.getExtra().get(key), equalTo(expectedValue));
+    }
+
+    @Test
+    public void testDefaultExtraSetToEvent() {
+        final String key = "key";
+        final Object expectedValue = "expected";
+        sentryClient.addExtra(key, expectedValue);
+        EventBuilder eventBuilder = new EventBuilder();
+
+        Event event = sentryClient.buildEvent(eventBuilder);
+
+        assertThat(event.getExtra().get(key), equalTo(expectedValue));
+    }
+
+    @Test
+    public void testDefaultReleaseDoesntOverrideEvent() {
+        final String expectedValue = "release";
+        sentryClient.setRelease("default");
+        EventBuilder eventBuilder = new EventBuilder();
+        eventBuilder.withRelease(expectedValue);
+
+        Event event = sentryClient.buildEvent(eventBuilder);
+
+        assertThat(event.getRelease(), equalTo(expectedValue));
+    }
+
+    @Test
+    public void testDefaultReleaseSetToEvent() {
+        final String expectedValue = "release";
+        sentryClient.setRelease(expectedValue);
+        EventBuilder eventBuilder = new EventBuilder();
+
+        Event event = sentryClient.buildEvent(eventBuilder);
+
+        assertThat(event.getRelease(), equalTo(expectedValue));
+    }
+
+    @Test
+    public void testDefaultEnvironmentDoesntOverrideEvent() {
+        final String expectedValue = "env";
+        sentryClient.setEnvironment("default");
+        EventBuilder eventBuilder = new EventBuilder();
+        eventBuilder.withEnvironment(expectedValue);
+
+        Event event = sentryClient.buildEvent(eventBuilder);
+
+        assertThat(event.getEnvironment(), equalTo(expectedValue));
+    }
+
+    @Test
+    public void testDefaultEnvironmentSetToEvent() {
+        final String expectedValue = "env";
+        sentryClient.setEnvironment(expectedValue);
+        EventBuilder eventBuilder = new EventBuilder();
+
+        Event event = sentryClient.buildEvent(eventBuilder);
+
+        assertThat(event.getEnvironment(), equalTo(expectedValue));
+    }
+
+    @Test
+    public void testDefaultServerNameDoesntOverrideEvent() {
+        final String expectedValue = "srv";
+        sentryClient.setServerName("default");
+        EventBuilder eventBuilder = new EventBuilder();
+        eventBuilder.withServerName(expectedValue);
+
+        Event event = sentryClient.buildEvent(eventBuilder);
+
+        assertThat(event.getServerName(), equalTo(expectedValue));
+    }
+
+    @Test
+    public void testDefaultServerNameSetToEvent() {
+        final String expectedValue = "srv";
+        sentryClient.setServerName(expectedValue);
+        EventBuilder eventBuilder = new EventBuilder();
+
+        Event event = sentryClient.buildEvent(eventBuilder);
+
+        assertThat(event.getServerName(), equalTo(expectedValue));
+    }
 }