Hubs/Scopes Merge 22 - Combine global, isolation and current scope

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

@@ -118,7 +118,7 @@ class InternalSentrySdkTest {
 
     @Test
     fun `current scope returns obj when hub is active`() {
-        Sentry.setCurrentHub(
+        Sentry.setCurrentScopes(
             Hub(
                 SentryOptions().apply {
                     dsn = "https://key@uri/1234567"
@@ -131,7 +131,7 @@ class InternalSentrySdkTest {
 
     @Test
     fun `current scope returns a copy of the scope`() {
-        Sentry.setCurrentHub(
+        Sentry.setCurrentScopes(
             Hub(
                 SentryOptions().apply {
                     dsn = "https://key@uri/1234567"

sentry/src/main/java/io/sentry/Breadcrumb.java

@@ -17,7 +17,7 @@
 import org.jetbrains.annotations.Nullable;
 
 /** Series of application events */
-public final class Breadcrumb implements JsonUnknown, JsonSerializable {
+public final class Breadcrumb implements JsonUnknown, JsonSerializable, Comparable<Breadcrumb> {
 
   /** A timestamp representing when the breadcrumb occurred. */
   private final @NotNull Date timestamp;
@@ -660,6 +660,12 @@ public void setUnknown(@Nullable Map<String, Object> unknown) {
     this.unknown = unknown;
   }
 
+  @Override
+  @SuppressWarnings("JavaUtilDate")
+  public int compareTo(@NotNull Breadcrumb o) {
+    return timestamp.compareTo(o.timestamp);
+  }
+
   public static final class JsonKeys {
     public static final String TIMESTAMP = "timestamp";
     public static final String MESSAGE = "message";

sentry/src/main/java/io/sentry/CombinedContextsView.java

@@ -0,0 +1,214 @@
+package io.sentry;
+
+import io.sentry.protocol.App;
+import io.sentry.protocol.Browser;
+import io.sentry.protocol.Contexts;
+import io.sentry.protocol.Device;
+import io.sentry.protocol.Gpu;
+import io.sentry.protocol.OperatingSystem;
+import io.sentry.protocol.Response;
+import io.sentry.protocol.SentryRuntime;
+import io.sentry.util.HintUtils;
+import java.io.IOException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public final class CombinedContextsView extends Contexts {
+
+  private static final long serialVersionUID = 3585992094653318439L;
+  private final @NotNull Contexts globalContexts;
+  private final @NotNull Contexts isolationContexts;
+  private final @NotNull Contexts currentContexts;
+
+  private final @NotNull ScopeType defaultScopeType;
+
+  public CombinedContextsView(
+      final @NotNull Contexts globalContexts,
+      final @NotNull Contexts isolationContexts,
+      final @NotNull Contexts currentContexts,
+      final @NotNull ScopeType defaultScopeType) {
+    this.globalContexts = globalContexts;
+    this.isolationContexts = isolationContexts;
+    this.currentContexts = currentContexts;
+    this.defaultScopeType = defaultScopeType;
+  }
+
+  @Override
+  public @Nullable SpanContext getTrace() {
+    final @Nullable SpanContext current = currentContexts.getTrace();
+    if (current != null) {
+      return current;
+    }
+    final @Nullable SpanContext isolation = isolationContexts.getTrace();
+    if (isolation != null) {
+      return isolation;
+    }
+    return globalContexts.getTrace();
+  }
+
+  @Override
+  public void setTrace(@Nullable SpanContext traceContext) {
+    getDefaultContexts().setTrace(traceContext);
+  }
+
+  private Contexts getDefaultContexts() {
+    switch (defaultScopeType) {
+      case CURRENT:
+        return currentContexts;
+      case ISOLATION:
+        return isolationContexts;
+      case GLOBAL:
+        return globalContexts;
+      default:
+        return currentContexts;
+    }
+  }
+
+  @Override
+  public @Nullable App getApp() {
+    final @Nullable App current = currentContexts.getApp();
+    if (current != null) {
+      return current;
+    }
+    final @Nullable App isolation = isolationContexts.getApp();
+    if (isolation != null) {
+      return isolation;
+    }
+    return globalContexts.getApp();
+  }
+
+  @Override
+  public void setApp(@NotNull App app) {
+    getDefaultContexts().setApp(app);
+  }
+
+  @Override
+  public @Nullable Browser getBrowser() {
+    final @Nullable Browser current = currentContexts.getBrowser();
+    if (current != null) {
+      return current;
+    }
+    final @Nullable Browser isolation = isolationContexts.getBrowser();
+    if (isolation != null) {
+      return isolation;
+    }
+    return globalContexts.getBrowser();
+  }
+
+  @Override
+  public void setBrowser(@NotNull Browser browser) {
+    getDefaultContexts().setBrowser(browser);
+  }
+
+  @Override
+  public @Nullable Device getDevice() {
+    final @Nullable Device current = currentContexts.getDevice();
+    if (current != null) {
+      return current;
+    }
+    final @Nullable Device isolation = isolationContexts.getDevice();
+    if (isolation != null) {
+      return isolation;
+    }
+    return globalContexts.getDevice();
+  }
+
+  @Override
+  public void setDevice(@NotNull Device device) {
+    getDefaultContexts().setDevice(device);
+  }
+
+  @Override
+  public @Nullable OperatingSystem getOperatingSystem() {
+    final @Nullable OperatingSystem current = currentContexts.getOperatingSystem();
+    if (current != null) {
+      return current;
+    }
+    final @Nullable OperatingSystem isolation = isolationContexts.getOperatingSystem();
+    if (isolation != null) {
+      return isolation;
+    }
+    return globalContexts.getOperatingSystem();
+  }
+
+  @Override
+  public void setOperatingSystem(@NotNull OperatingSystem operatingSystem) {
+    getDefaultContexts().setOperatingSystem(operatingSystem);
+  }
+
+  @Override
+  public @Nullable SentryRuntime getRuntime() {
+    final @Nullable SentryRuntime current = currentContexts.getRuntime();
+    if (current != null) {
+      return current;
+    }
+    final @Nullable SentryRuntime isolation = isolationContexts.getRuntime();
+    if (isolation != null) {
+      return isolation;
+    }
+    return globalContexts.getRuntime();
+  }
+
+  @Override
+  public void setRuntime(@NotNull SentryRuntime runtime) {
+    getDefaultContexts().setRuntime(runtime);
+  }
+
+  @Override
+  public @Nullable Gpu getGpu() {
+    final @Nullable Gpu current = currentContexts.getGpu();
+    if (current != null) {
+      return current;
+    }
+    final @Nullable Gpu isolation = isolationContexts.getGpu();
+    if (isolation != null) {
+      return isolation;
+    }
+    return globalContexts.getGpu();
+  }
+
+  @Override
+  public void setGpu(@NotNull Gpu gpu) {
+    getDefaultContexts().setGpu(gpu);
+  }
+
+  @Override
+  public @Nullable Response getResponse() {
+    final @Nullable Response current = currentContexts.getResponse();
+    if (current != null) {
+      return current;
+    }
+    final @Nullable Response isolation = isolationContexts.getResponse();
+    if (isolation != null) {
+      return isolation;
+    }
+    return globalContexts.getResponse();
+  }
+
+  @Override
+  public void withResponse(HintUtils.SentryConsumer<Response> callback) {
+    if (currentContexts.getResponse() != null) {
+      currentContexts.withResponse(callback);
+    } else if (isolationContexts.getResponse() != null) {
+      isolationContexts.withResponse(callback);
+    } else if (globalContexts.getResponse() != null) {
+      globalContexts.withResponse(callback);
+    } else {
+      getDefaultContexts().withResponse(callback);
+    }
+  }
+
+  @Override
+  public void setResponse(@NotNull Response response) {
+    getDefaultContexts().setResponse(response);
+  }
+
+  @Override
+  public void serialize(@NotNull ObjectWriter writer, @NotNull ILogger logger) throws IOException {
+    final @NotNull Contexts allContexts = new Contexts();
+    allContexts.putAll(globalContexts);
+    allContexts.putAll(isolationContexts);
+    allContexts.putAll(currentContexts);
+    allContexts.serialize(writer, logger);
+  }
+}