Add replay envelopes

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

@@ -260,12 +260,9 @@ private void setSideLoadedInfo(final @NotNull SentryBaseEvent event) {
 
   @Override
   public @NotNull SentryReplayEvent process(
-    final @NotNull SentryReplayEvent event, final @NotNull Hint hint) {
+      final @NotNull SentryReplayEvent event, final @NotNull Hint hint) {
     final boolean applyScopeData = shouldApplyScopeData(event, hint);
     if (applyScopeData) {
-      // we only set memory data if it's not a hard crash, when it's a hard crash the event is
-      // enriched on restart, so non static data might be wrong, eg lowMemory or availMem will
-      // be different if the App. crashes because of OOM.
       processNonCachedEvent(event, hint);
     }
 

sentry/src/main/java/io/sentry/Hint.java

@@ -27,11 +27,10 @@ public final class Hint {
 
   private final @NotNull Map<String, Object> internalStorage = new HashMap<String, Object>();
   private final @NotNull List<Attachment> attachments = new ArrayList<>();
-  private final @NotNull List<ReplayRecording> replayRecordings = new ArrayList<>();
   private @Nullable Attachment screenshot = null;
   private @Nullable Attachment viewHierarchy = null;
-
   private @Nullable Attachment threadDump = null;
+  private @Nullable ReplayRecording replayRecording = null;
 
   public static @NotNull Hint withAttachment(@Nullable Attachment attachment) {
     @NotNull final Hint hint = new Hint();
@@ -71,12 +70,6 @@ public synchronized void remove(@NotNull String name) {
     internalStorage.remove(name);
   }
 
-  public void addReplayRecording(final @Nullable ReplayRecording recording) {
-    if (recording != null) {
-      replayRecordings.add(recording);
-    }
-  }
-
   public void addAttachment(@Nullable Attachment attachment) {
     if (attachment != null) {
       attachments.add(attachment);
@@ -93,10 +86,6 @@ public void addAttachments(@Nullable List<Attachment> attachments) {
     return new ArrayList<>(attachments);
   }
 
-  public @NotNull List<ReplayRecording> getReplayRecordings() {
-    return new ArrayList<>(replayRecordings);
-  }
-
   public void replaceAttachments(@Nullable List<Attachment> attachments) {
     clearAttachments();
     addAttachments(attachments);
@@ -106,10 +95,6 @@ public void clearAttachments() {
     attachments.clear();
   }
 
-  public void clearReplayRecordings() {
-    replayRecordings.clear();
-  }
-
   /**
    * Clears all attributes added via {@link #set(String, Object)} Note: SDK internal attributes are
    * being kept. This is useful to avoid leaking any objects (e.g. Android activities) being
@@ -151,6 +136,15 @@ public void setThreadDump(final @Nullable Attachment threadDump) {
     return threadDump;
   }
 
+  @Nullable
+  public ReplayRecording getReplayRecording() {
+    return replayRecording;
+  }
+
+  public void setReplayRecording(final @Nullable ReplayRecording replayRecording) {
+    this.replayRecording = replayRecording;
+  }
+
   private boolean isCastablePrimitive(@Nullable Object hintValue, @NotNull Class<?> clazz) {
     Class<?> nonPrimitiveClass = PRIMITIVE_MAPPINGS.get(clazz.getCanonicalName());
     return hintValue != null

sentry/src/main/java/io/sentry/Hub.java

@@ -922,14 +922,14 @@ private IScope buildLocalScope(
 
   @Override
   public @NotNull SentryId captureReplay(
-    final @NotNull SentryReplayEvent replay, final @Nullable Hint hint) {
+      final @NotNull SentryReplayEvent replay, final @Nullable Hint hint) {
     SentryId sentryId = SentryId.EMPTY_ID;
     if (!isEnabled()) {
       options
-        .getLogger()
-        .log(
-          SentryLevel.WARNING,
-          "Instance is disabled and this 'captureReplay' call is a no-op.");
+          .getLogger()
+          .log(
+              SentryLevel.WARNING,
+              "Instance is disabled and this 'captureReplay' call is a no-op.");
     } else {
       try {
         StackItem item = stack.peek();

sentry/src/main/java/io/sentry/HubAdapter.java

@@ -264,7 +264,7 @@ public void reportFullyDisplayed() {
 
   @Override
   public @NotNull SentryId captureReplay(
-    final @NotNull SentryReplayEvent replay, final @Nullable Hint hint) {
+      final @NotNull SentryReplayEvent replay, final @Nullable Hint hint) {
     return Sentry.getCurrentHub().captureReplay(replay, hint);
   }
 

sentry/src/main/java/io/sentry/ISentryClient.java

@@ -147,7 +147,8 @@ public interface ISentryClient {
     return captureException(throwable, scope, null);
   }
 
-  @NotNull SentryId captureReplayEvent(
+  @NotNull
+  SentryId captureReplayEvent(
       @NotNull SentryReplayEvent event, @Nullable IScope scope, @Nullable Hint hint);
 
   /**

sentry/src/main/java/io/sentry/JsonObjectWriter.java

@@ -52,7 +52,8 @@ public JsonObjectWriter value(final @Nullable String value) throws IOException {
     return this;
   }
 
-  @Override public ObjectWriter jsonValue(@Nullable String value) throws IOException {
+  @Override
+  public ObjectWriter jsonValue(@Nullable String value) throws IOException {
     jsonWriter.jsonValue(value);
     return this;
   }

sentry/src/main/java/io/sentry/JsonSerializer.java

@@ -31,6 +31,7 @@
 import io.sentry.protocol.ViewHierarchyNode;
 import io.sentry.rrweb.RRWebEventType;
 import io.sentry.rrweb.RRWebMetaEvent;
+import io.sentry.rrweb.RRWebVideoEvent;
 import io.sentry.util.Objects;
 import java.io.BufferedOutputStream;
 import java.io.BufferedWriter;
@@ -93,6 +94,7 @@ public JsonSerializer(@NotNull SentryOptions options) {
     deserializersByClass.put(Request.class, new Request.Deserializer());
     deserializersByClass.put(RRWebEventType.class, new RRWebEventType.Deserializer());
     deserializersByClass.put(RRWebMetaEvent.class, new RRWebMetaEvent.Deserializer());
+    deserializersByClass.put(RRWebVideoEvent.class, new RRWebVideoEvent.Deserializer());
     deserializersByClass.put(SdkInfo.class, new SdkInfo.Deserializer());
     deserializersByClass.put(SdkVersion.class, new SdkVersion.Deserializer());
     deserializersByClass.put(SentryEnvelopeHeader.class, new SentryEnvelopeHeader.Deserializer());

sentry/src/main/java/io/sentry/MainEventProcessor.java

@@ -152,13 +152,16 @@ private void processNonCachedEvent(final @NotNull SentryBaseEvent event) {
   @Override
   public @NotNull SentryReplayEvent process(@NotNull SentryReplayEvent event, @NotNull Hint hint) {
     setCommons(event);
-    setDebugMeta(event);
+    // TODO: maybe later it's needed to deobfuscate something (e.g. view hierarchy), for now the
+    // TODO: protocol does not support it
+    // setDebugMeta(event);
 
     if (shouldApplyScopeData(event, hint)) {
       processNonCachedEvent(event);
     }
     return event;
   }
+
   private void setCommons(final @NotNull SentryBaseEvent event) {
     setPlatform(event);
   }

sentry/src/main/java/io/sentry/NoOpSentryClient.java

@@ -63,8 +63,8 @@ public SentryId captureEnvelope(@NotNull SentryEnvelope envelope, @Nullable Hint
   }
 
   @Override
-  public @NotNull SentryId captureReplayEvent(@NotNull SentryReplayEvent event,
-    @Nullable IScope scope, @Nullable Hint hint) {
+  public @NotNull SentryId captureReplayEvent(
+      @NotNull SentryReplayEvent event, @Nullable IScope scope, @Nullable Hint hint) {
     return SentryId.EMPTY_ID;
   }
 

sentry/src/main/java/io/sentry/ObjectWriter.java

@@ -16,6 +16,7 @@ public interface ObjectWriter {
   ObjectWriter name(final @NotNull String name) throws IOException;
 
   ObjectWriter value(final @Nullable String value) throws IOException;
+
   ObjectWriter jsonValue(final @Nullable String value) throws IOException;
 
   ObjectWriter nullValue() throws IOException;

sentry/src/main/java/io/sentry/ReplayRecording.java

@@ -52,15 +52,6 @@ public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger
       }
     }
     writer.endObject();
-
-    // session replay recording format
-    // {"segment_id":0}\n{json-serialized-gzipped-rrweb-protocol}
-
-    writer.jsonValue("\n");
-
-    if (payload != null) {
-      writer.value(logger, payload);
-    }
   }
 
   @Override

sentry/src/main/java/io/sentry/Sentry.java

@@ -1027,7 +1027,7 @@ public interface OptionsConfiguration<T extends SentryOptions> {
   }
 
   public static void captureReplay(
-    final @NotNull SentryReplayEvent replay, final @Nullable Hint hint) {
+      final @NotNull SentryReplayEvent replay, final @Nullable Hint hint) {
     getCurrentHub().captureReplay(replay, hint);
   }
 }

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

@@ -248,7 +248,7 @@ private boolean shouldApplyScopeData(final @NotNull CheckIn event, final @NotNul
 
   @Override
   public @NotNull SentryId captureReplayEvent(
-    @NotNull SentryReplayEvent event, final @Nullable IScope scope, @Nullable Hint hint) {
+      @NotNull SentryReplayEvent event, final @Nullable IScope scope, @Nullable Hint hint) {
     Objects.requireNonNull(event, "SessionReplay is required.");
 
     if (hint == null) {
@@ -262,8 +262,8 @@ private boolean shouldApplyScopeData(final @NotNull CheckIn event, final @NotNul
     options.getLogger().log(SentryLevel.DEBUG, "Capturing session replay: %s", event.getEventId());
 
     SentryId sentryId = SentryId.EMPTY_ID;
-    if (event.getReplayId() != null) {
-      sentryId = event.getReplayId();
+    if (event.getEventId() != null) {
+      sentryId = event.getEventId();
     }
 
     event = processReplayEvent(event, hint, options.getEventProcessors());
@@ -274,15 +274,22 @@ private boolean shouldApplyScopeData(final @NotNull CheckIn event, final @NotNul
     }
 
     try {
-      final SentryEnvelope envelope =
-        buildEnvelope(event, hint.getReplayRecordings());
+      @Nullable TraceContext traceContext = null;
+      if (scope != null) {
+        final @Nullable ITransaction transaction = scope.getTransaction();
+        if (transaction != null) {
+          traceContext = transaction.traceContext();
+        } else {
+          final @NotNull PropagationContext propagationContext =
+              TracingUtils.maybeUpdateBaggage(scope, options);
+          traceContext = propagationContext.traceContext();
+        }
+      }
+
+      final SentryEnvelope envelope = buildEnvelope(event, hint.getReplayRecording(), traceContext);
 
       hint.clear();
-      if (envelope != null) {
-        transport.send(envelope, hint);
-      } else {
-        sentryId = SentryId.EMPTY_ID;
-      }
+      transport.send(envelope, hint);
     } catch (IOException e) {
       options.getLogger().log(SentryLevel.WARNING, e, "Capturing event %s failed.", sentryId);
 
@@ -566,38 +573,22 @@ public void captureUserFeedback(final @NotNull UserFeedback userFeedback) {
     return new SentryEnvelope(envelopeHeader, envelopeItems);
   }
 
-  private @Nullable SentryEnvelope buildEnvelope(
-    final @Nullable SentryReplayEvent event,
-    final @Nullable List<ReplayRecording> replayRecordings
-  ) {
-    SentryId sentryId = null;
+  private @NotNull SentryEnvelope buildEnvelope(
+      final @NotNull SentryReplayEvent event,
+      final @Nullable ReplayRecording replayRecording,
+      final @Nullable TraceContext traceContext) {
     final List<SentryEnvelopeItem> envelopeItems = new ArrayList<>();
 
-    if (event != null) {
-      final SentryEnvelopeItem eventItem =
-        SentryEnvelopeItem.fromEvent(options.getSerializer(), event);
-      envelopeItems.add(eventItem);
-      sentryId = event.getEventId();
-    }
-
-    if (replayRecordings != null) {
-      for (final ReplayRecording replayRecording : replayRecordings) {
-        final SentryEnvelopeItem replayItem =
-          SentryEnvelopeItem.fromReplayRecording(
-            options.getSerializer(), options.getLogger(), replayRecording);
-        envelopeItems.add(replayItem);
-      }
-    }
+    final SentryEnvelopeItem replayItem =
+        SentryEnvelopeItem.fromReplay(
+            options.getSerializer(), options.getLogger(), event, replayRecording);
+    envelopeItems.add(replayItem);
+    final SentryId sentryId = event.getEventId();
 
+    final SentryEnvelopeHeader envelopeHeader =
+        new SentryEnvelopeHeader(sentryId, options.getSdkVersion(), traceContext);
 
-    if (!envelopeItems.isEmpty()) {
-      final SentryEnvelopeHeader envelopeHeader =
-        new SentryEnvelopeHeader(sentryId, options.getSdkVersion());
-
-      return new SentryEnvelope(envelopeHeader, envelopeItems);
-    }
-
-    return null;
+    return new SentryEnvelope(envelopeHeader, envelopeItems);
   }
 
   /**
@@ -921,6 +912,47 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
     return checkIn;
   }
 
+  private @NotNull SentryReplayEvent applyScope(
+      final @NotNull SentryReplayEvent replayEvent, final @Nullable IScope scope) {
+    // no breadcrumbs and extras for replay events
+    if (scope != null) {
+      if (replayEvent.getRequest() == null) {
+        replayEvent.setRequest(scope.getRequest());
+      }
+      if (replayEvent.getUser() == null) {
+        replayEvent.setUser(scope.getUser());
+      }
+      if (replayEvent.getTags() == null) {
+        replayEvent.setTags(new HashMap<>(scope.getTags()));
+      } else {
+        for (Map.Entry<String, String> item : scope.getTags().entrySet()) {
+          if (!replayEvent.getTags().containsKey(item.getKey())) {
+            replayEvent.getTags().put(item.getKey(), item.getValue());
+          }
+        }
+      }
+      final Contexts contexts = replayEvent.getContexts();
+      for (Map.Entry<String, Object> entry : new Contexts(scope.getContexts()).entrySet()) {
+        if (!contexts.containsKey(entry.getKey())) {
+          contexts.put(entry.getKey(), entry.getValue());
+        }
+      }
+
+      // Set trace data from active span to connect replays with transactions
+      final ISpan span = scope.getSpan();
+      if (replayEvent.getContexts().getTrace() == null) {
+        if (span == null) {
+          replayEvent
+              .getContexts()
+              .setTrace(TransactionContext.fromPropagationContext(scope.getPropagationContext()));
+        } else {
+          replayEvent.getContexts().setTrace(span.getSpanContext());
+        }
+      }
+    }
+    return replayEvent;
+  }
+
   private <T extends SentryBaseEvent> @NotNull T applyScope(
       final @NotNull T sentryBaseEvent, final @Nullable IScope scope) {
     if (scope != null) {