Performance Feature

sentry/src/main/java/io/sentry/DiagnosticLogger.java

@@ -29,6 +29,7 @@ public DiagnosticLogger(final @NotNull SentryOptions options, final @Nullable IL
    * @param level The SentryLevel to test against.
    * @return True if a log message would be recorded for the level. Otherwise false.
    */
+  @Override
   public boolean isEnabled(final @Nullable SentryLevel level) {
     final SentryLevel diagLevel = options.getDiagnosticLevel();
     if (level == null) {

sentry/src/main/java/io/sentry/GsonSerializer.java

@@ -13,8 +13,14 @@
 import io.sentry.adapters.SentryIdSerializerAdapter;
 import io.sentry.adapters.SentryLevelDeserializerAdapter;
 import io.sentry.adapters.SentryLevelSerializerAdapter;
+import io.sentry.adapters.SpanIdDeserializerAdapter;
+import io.sentry.adapters.SpanIdSerializerAdapter;
+import io.sentry.adapters.SpanStatusDeserializerAdapter;
+import io.sentry.adapters.SpanStatusSerializerAdapter;
 import io.sentry.adapters.TimeZoneDeserializerAdapter;
 import io.sentry.adapters.TimeZoneSerializerAdapter;
+import io.sentry.adapters.TransactionContextsDeserializerAdapter;
+import io.sentry.adapters.TransactionContextsSerializerAdapter;
 import io.sentry.protocol.Contexts;
 import io.sentry.protocol.Device;
 import io.sentry.protocol.SentryId;
@@ -90,6 +96,14 @@ Device.DeviceOrientation.class, new OrientationDeserializerAdapter(logger))
         .registerTypeAdapter(SentryEnvelopeHeader.class, new SentryEnvelopeHeaderAdapter())
         .registerTypeAdapter(SentryEnvelopeItemHeader.class, new SentryEnvelopeItemHeaderAdapter())
         .registerTypeAdapter(Session.class, new SessionAdapter(logger))
+        .registerTypeAdapter(SpanId.class, new SpanIdDeserializerAdapter(logger))
+        .registerTypeAdapter(SpanId.class, new SpanIdSerializerAdapter(logger))
+        .registerTypeAdapter(SpanStatus.class, new SpanStatusDeserializerAdapter(logger))
+        .registerTypeAdapter(SpanStatus.class, new SpanStatusSerializerAdapter(logger))
+        .registerTypeAdapter(
+            TransactionContexts.class, new TransactionContextsSerializerAdapter(logger))
+        .registerTypeAdapter(
+            TransactionContexts.class, new TransactionContextsDeserializerAdapter(logger))
         .create();
   }
 
@@ -119,6 +133,13 @@ Device.DeviceOrientation.class, new OrientationDeserializerAdapter(logger))
     return gson.fromJson(reader, Session.class);
   }
 
+  @Override
+  public Transaction deserializeTransaction(Reader reader) {
+    Objects.requireNonNull(reader, "The Reader object is required.");
+
+    return gson.fromJson(reader, Transaction.class);
+  }
+
   /**
    * Deserialize a SentryEnvelope from a InputStream (Envelope+JSON)
    *
@@ -136,37 +157,17 @@ Device.DeviceOrientation.class, new OrientationDeserializerAdapter(logger))
     }
   }
 
-  /**
-   * Serialize a SentryEvent to a stream Writer (JSON)
-   *
-   * @param event the SentryEvent
-   * @param writer the Writer
-   * @throws IOException an IOException
-   */
   @Override
-  public void serialize(final @NotNull SentryEvent event, final @NotNull Writer writer)
+  public <T> void serialize(final @NotNull T entity, final @NotNull Writer writer)
       throws IOException {
-    Objects.requireNonNull(event, "The SentryEvent object is required.");
+    Objects.requireNonNull(entity, "The entity is required.");
     Objects.requireNonNull(writer, "The Writer object is required.");
 
-    gson.toJson(event, SentryEvent.class, writer);
-    writer.flush();
-  }
-
-  /**
-   * Serialize a Session to a stream Writer (JSON)
-   *
-   * @param session the Session
-   * @param writer the Writer
-   * @throws IOException an IOException
-   */
-  @Override
-  public void serialize(final @NotNull Session session, final @NotNull Writer writer)
-      throws IOException {
-    Objects.requireNonNull(session, "The Session object is required.");
-    Objects.requireNonNull(writer, "The Writer object is required.");
+    if (logger.isEnabled(SentryLevel.DEBUG)) {
+      logger.log(SentryLevel.DEBUG, "Serializing object: %s", gson.toJson(entity));
+    }
+    gson.toJson(entity, entity.getClass(), writer);
 
-    gson.toJson(session, Session.class, writer);
     writer.flush();
   }
 

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

@@ -454,9 +454,7 @@ public void pushScope() {
     if (!isEnabled()) {
       options
           .getLogger()
-          .log(
-              SentryLevel.WARNING,
-              "Instance is disabled and this 'pushScope' call is a no-op.");
+          .log(SentryLevel.WARNING, "Instance is disabled and this 'pushScope' call is a no-op.");
     } else {
       final StackItem item = stack.peek();
       if (item != null) {
@@ -523,7 +521,9 @@ public void configureScope(final @NotNull ScopeCallback callback) {
     if (!isEnabled()) {
       options
           .getLogger()
-          .log(SentryLevel.WARNING, "Instance is disabled and this 'configureScope' call is a no-op.");
+          .log(
+              SentryLevel.WARNING,
+              "Instance is disabled and this 'configureScope' call is a no-op.");
     } else {
       final StackItem item = stack.peek();
       if (item != null) {
@@ -601,4 +601,57 @@ public void flush(long timeoutMillis) {
     }
     return clone;
   }
+
+  @Override
+  public SentryId captureTransaction(Transaction transaction, Object hint) {
+    SentryId sentryId = SentryId.EMPTY_ID;
+    if (!isEnabled()) {
+      options
+          .getLogger()
+          .log(
+              SentryLevel.WARNING,
+              "Instance is disabled and this 'captureTransaction' call is a no-op.");
+    } else if (transaction == null) {
+      options
+          .getLogger()
+          .log(SentryLevel.WARNING, "captureTransaction called with null parameter.");
+    } else {
+      try {
+        final StackItem item = stack.peek();
+        if (item != null) {
+          sentryId = item.client.captureTransaction(transaction, item.scope, hint);
+        } else {
+          options.getLogger().log(SentryLevel.FATAL, "Stack peek was null when captureTransaction");
+        }
+      } catch (Exception e) {
+        options
+            .getLogger()
+            .log(
+                SentryLevel.ERROR,
+                "Error while capturing event with id: " + transaction.getEventId(),
+                e);
+      }
+    }
+    this.lastEventId = sentryId;
+    return sentryId;
+  }
+
+  @Override
+  public @Nullable Transaction startTransaction(TransactionContexts transactionContexts) {
+    Transaction transaction = null;
+    if (!isEnabled()) {
+      options
+          .getLogger()
+          .log(SentryLevel.WARNING, "Instance is disabled and this 'setExtra' call is a no-op.");
+    } else {
+      final StackItem item = stack.peek();
+      if (item != null) {
+        transaction = new Transaction(transactionContexts);
+        item.scope.setTx(transaction);
+      } else {
+        options.getLogger().log(SentryLevel.FATAL, "Stack peek was null when setExtra");
+      }
+    }
+    return transaction;
+  }
 }

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

@@ -146,4 +146,14 @@ public void flush(long timeoutMillis) {
   public IHub clone() {
     return Sentry.getCurrentHub().clone();
   }
+
+  @Override
+  public SentryId captureTransaction(Transaction transaction, Object hint) {
+    return Sentry.captureTransaction(transaction, hint);
+  }
+
+  @Override
+  public Transaction startTransaction(TransactionContexts transactionContexts) {
+    return Sentry.startTransaction(transactionContexts);
+  }
 }

sentry/src/main/java/io/sentry/IHub.java

@@ -249,4 +249,21 @@ default void addBreadcrumb(@NotNull String message, @NotNull String category) {
    * @return the cloned Hub
    */
   IHub clone();
+
+  /**
+   * Captures the transaction and enqueues it for sending to Sentry server.
+   *
+   * @param transaction the transaction
+   * @param hint the hint
+   * @return transaction's id
+   */
+  SentryId captureTransaction(Transaction transaction, Object hint);
+
+  /**
+   * Creates a Transaction bound to the current hub and returns the instance.
+   *
+   * @param transactionContexts the transaction contexts
+   * @return created transaction
+   */
+  Transaction startTransaction(TransactionContexts transactionContexts);
 }

sentry/src/main/java/io/sentry/ILogger.java

@@ -1,5 +1,7 @@
 package io.sentry;
 
+import org.jetbrains.annotations.Nullable;
+
 /** Sentry SDK internal logging interface. */
 public interface ILogger {
 
@@ -30,4 +32,14 @@ public interface ILogger {
    * @param args the formatting arguments
    */
   void log(SentryLevel level, Throwable throwable, String message, Object... args);
+
+  /**
+   * Whether this logger is enabled for the specified SentryLevel.
+   *
+   * @param level The SentryLevel to test against.
+   * @return True if a log message would be recorded for the level. Otherwise false.
+   */
+  default boolean isEnabled(final @Nullable SentryLevel level) {
+    return true;
+  }
 }

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

@@ -178,4 +178,10 @@ default void captureSession(Session session) {
   default SentryId captureEnvelope(SentryEnvelope envelope) {
     return captureEnvelope(envelope, null);
   }
+
+  SentryId captureTransaction(Transaction transaction, Scope scope, Object hint);
+
+  default SentryId captureTransaction(Transaction transaction) {
+    return captureTransaction(transaction, null, null);
+  }
 }

sentry/src/main/java/io/sentry/ISerializer.java

@@ -11,11 +11,11 @@ public interface ISerializer {
 
   Session deserializeSession(Reader reader);
 
-  SentryEnvelope deserializeEnvelope(InputStream inputStream);
+  Transaction deserializeTransaction(Reader reader);
 
-  void serialize(SentryEvent event, Writer writer) throws IOException;
+  SentryEnvelope deserializeEnvelope(InputStream inputStream);
 
-  void serialize(Session session, Writer writer) throws IOException;
+  <T> void serialize(T entity, Writer writer) throws IOException;
 
   void serialize(SentryEnvelope envelope, Writer writer) throws Exception;
 

sentry/src/main/java/io/sentry/NoOpHub.java

@@ -106,4 +106,14 @@ public void flush(long timeoutMillis) {}
   public IHub clone() {
     return instance;
   }
+
+  @Override
+  public SentryId captureTransaction(Transaction transaction, Object hint) {
+    return SentryId.EMPTY_ID;
+  }
+
+  @Override
+  public Transaction startTransaction(TransactionContexts transactionContexts) {
+    return null;
+  }
 }

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

@@ -36,4 +36,9 @@ public void captureSession(Session session, @Nullable Object hint) {}
   public SentryId captureEnvelope(SentryEnvelope envelope, @Nullable Object hint) {
     return SentryId.EMPTY_ID;
   }
+
+  @Override
+  public SentryId captureTransaction(Transaction transaction, Scope scope, Object hint) {
+    return SentryId.EMPTY_ID;
+  }
 }

sentry/src/main/java/io/sentry/NoOpSerializer.java

@@ -28,15 +28,17 @@ public Session deserializeSession(Reader reader) {
   }
 
   @Override
-  public SentryEnvelope deserializeEnvelope(InputStream inputStream) {
+  public Transaction deserializeTransaction(Reader reader) {
     return null;
   }
 
   @Override
-  public void serialize(SentryEvent event, Writer writer) {}
+  public SentryEnvelope deserializeEnvelope(InputStream inputStream) {
+    return null;
+  }
 
   @Override
-  public void serialize(Session session, Writer writer) throws IOException {}
+  public <T> void serialize(T entity, Writer writer) throws IOException {}
 
   @Override
   public void serialize(SentryEnvelope envelope, Writer outputStream) throws Exception {}

sentry/src/main/java/io/sentry/Scope.java

@@ -22,6 +22,9 @@ public final class Scope implements Cloneable {
   /** Scope's transaction */
   private @Nullable String transaction;
 
+  /** Scope's {@link Transaction}. */
+  private @Nullable Transaction tx;
+
   /** Scope's user */
   private @Nullable User user;
 
@@ -100,6 +103,14 @@ public void setTransaction(@Nullable String transaction) {
     this.transaction = transaction;
   }
 
+  public Transaction getTx() {
+    return tx;
+  }
+
+  public void setTx(Transaction tx) {
+    this.tx = tx;
+  }
+
   /**
    * Returns the Scope's user
    *
@@ -448,6 +459,9 @@ public void removeContexts(final @NotNull String key) {
 
     clone.contexts = contexts.clone();
 
+    final Transaction txRef = tx;
+    clone.tx = txRef != null ? txRef.clone() : null;
+
     return clone;
   }
 

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

@@ -484,6 +484,27 @@ public static void endSession() {
     getCurrentHub().endSession();
   }
 
+  /**
+   * Captures the transaction and enqueues it for sending to Sentry server.
+   *
+   * @param transaction the transaction
+   * @param hint the hint
+   * @return transaction's id
+   */
+  public static SentryId captureTransaction(Transaction transaction, Object hint) {
+    return getCurrentHub().captureTransaction(transaction, hint);
+  }
+
+  /**
+   * Creates a Transaction bound to the current hub and returns the instance.
+   *
+   * @param transactionContexts the transaction contexts
+   * @return created transaction
+   */
+  public static Transaction startTransaction(TransactionContexts transactionContexts) {
+    return getCurrentHub().startTransaction(transactionContexts);
+  }
+
   /**
    * Configuration options callback
    *