getsentry · denrase · Sep 21, 2021 · Sep 15, 2021 · Sep 21, 2021
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
@@ -769,12 +769,27 @@ public final class io/sentry/SentryEnvelope {
 	public fun getItems ()Ljava/lang/Iterable;
 }
 
-public final class io/sentry/SentryEnvelopeHeader {
+public final class io/sentry/SentryEnvelopeHeader : io/sentry/JsonSerializable, io/sentry/JsonUnknown {
 	public fun <init> ()V
 	public fun <init> (Lio/sentry/protocol/SentryId;)V
 	public fun <init> (Lio/sentry/protocol/SentryId;Lio/sentry/protocol/SdkVersion;)V
 	public fun getEventId ()Lio/sentry/protocol/SentryId;
 	public fun getSdkVersion ()Lio/sentry/protocol/SdkVersion;
+	public fun getUnknown ()Ljava/util/Map;
+	public fun serialize (Lio/sentry/JsonObjectWriter;Lio/sentry/ILogger;)V
+	public fun setUnknown (Ljava/util/Map;)V
+}
+
+public final class io/sentry/SentryEnvelopeHeader$Deserializer : io/sentry/JsonDeserializer {
+	public fun <init> ()V
+	public fun deserialize (Lio/sentry/JsonObjectReader;Lio/sentry/ILogger;)Lio/sentry/SentryEnvelopeHeader;
+	public synthetic fun deserialize (Lio/sentry/JsonObjectReader;Lio/sentry/ILogger;)Ljava/lang/Object;
+}
+
+public final class io/sentry/SentryEnvelopeHeader$JsonKeys {
+	public static final field EVENT_ID Ljava/lang/String;
+	public static final field SDK Ljava/lang/String;
+	public fun <init> ()V
 }
 
 public final class io/sentry/SentryEnvelopeHeaderAdapter : com/google/gson/TypeAdapter {
@@ -796,12 +811,31 @@ public final class io/sentry/SentryEnvelopeItem {
 	public fun getTransaction (Lio/sentry/ISerializer;)Lio/sentry/protocol/SentryTransaction;
 }
 
-public final class io/sentry/SentryEnvelopeItemHeader {
+public final class io/sentry/SentryEnvelopeItemHeader : io/sentry/JsonSerializable, io/sentry/JsonUnknown {
+	public fun <init> (Lio/sentry/SentryItemType;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
 	public fun getAttachmentType ()Ljava/lang/String;
 	public fun getContentType ()Ljava/lang/String;
 	public fun getFileName ()Ljava/lang/String;
 	public fun getLength ()I
 	public fun getType ()Lio/sentry/SentryItemType;
+	public fun getUnknown ()Ljava/util/Map;
+	public fun serialize (Lio/sentry/JsonObjectWriter;Lio/sentry/ILogger;)V
+	public fun setUnknown (Ljava/util/Map;)V
+}
+
+public final class io/sentry/SentryEnvelopeItemHeader$Deserializer : io/sentry/JsonDeserializer {
+	public fun <init> ()V
+	public fun deserialize (Lio/sentry/JsonObjectReader;Lio/sentry/ILogger;)Lio/sentry/SentryEnvelopeItemHeader;
+	public synthetic fun deserialize (Lio/sentry/JsonObjectReader;Lio/sentry/ILogger;)Ljava/lang/Object;
+}
+
+public final class io/sentry/SentryEnvelopeItemHeader$JsonKeys {
+	public static final field ATTACHMENT_TYPE Ljava/lang/String;
+	public static final field CONTENT_TYPE Ljava/lang/String;
+	public static final field FILENAME Ljava/lang/String;
+	public static final field LENGTH Ljava/lang/String;
+	public static final field TYPE Ljava/lang/String;
+	public fun <init> ()V
 }
 
 public final class io/sentry/SentryEnvelopeItemHeaderAdapter : com/google/gson/TypeAdapter {
@@ -865,7 +899,7 @@ public final class io/sentry/SentryEvent$JsonKeys {
 	public fun <init> ()V
 }
 
-public final class io/sentry/SentryItemType : java/lang/Enum {
+public final class io/sentry/SentryItemType : java/lang/Enum, io/sentry/JsonSerializable {
 	public static final field Attachment Lio/sentry/SentryItemType;
 	public static final field Event Lio/sentry/SentryItemType;
 	public static final field Session Lio/sentry/SentryItemType;
@@ -874,7 +908,9 @@ public final class io/sentry/SentryItemType : java/lang/Enum {
 	public static final field UserFeedback Lio/sentry/SentryItemType;
 	public fun getItemType ()Ljava/lang/String;
 	public static fun resolve (Ljava/lang/Object;)Lio/sentry/SentryItemType;
+	public fun serialize (Lio/sentry/JsonObjectWriter;Lio/sentry/ILogger;)V
 	public static fun valueOf (Ljava/lang/String;)Lio/sentry/SentryItemType;
+	public static fun valueOfLabel (Ljava/lang/String;)Lio/sentry/SentryItemType;
 	public static fun values ()[Lio/sentry/SentryItemType;
 }
 

diff --git a/sentry/src/main/java/io/sentry/SentryEnvelopeHeader.java b/sentry/src/main/java/io/sentry/SentryEnvelopeHeader.java
@@ -2,17 +2,24 @@
 
 import io.sentry.protocol.SdkVersion;
 import io.sentry.protocol.SentryId;
+import io.sentry.vendor.gson.stream.JsonToken;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
 import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 @ApiStatus.Internal
-public final class SentryEnvelopeHeader {
+public final class SentryEnvelopeHeader implements JsonSerializable, JsonUnknown {
   // Event Id must be set if the envelope holds an event, or an item that is related to the event
   // (e.g: attachments, user feedback)
   private final @Nullable SentryId eventId;
 
   private final @Nullable SdkVersion sdkVersion;
 
+  private @Nullable Map<String, Object> unknown;
+
   public SentryEnvelopeHeader(
       final @Nullable SentryId eventId, final @Nullable SdkVersion sdkVersion) {
     this.eventId = eventId;
@@ -34,4 +41,78 @@ public SentryEnvelopeHeader() {
   public @Nullable SdkVersion getSdkVersion() {
     return sdkVersion;
   }
+
+  // JsonSerializable
+
+  public static final class JsonKeys {
+    public static final String EVENT_ID = "event_id";
+    public static final String SDK = "sdk";
+  }
+
+  @Override
+  public void serialize(@NotNull JsonObjectWriter writer, @NotNull ILogger logger)
+      throws IOException {
+    writer.beginObject();
+    if (eventId != null) {
+      writer.name(JsonKeys.EVENT_ID).value(logger, eventId);
+    }
+    if (sdkVersion != null) {
+      writer.name(JsonKeys.SDK).value(logger, sdkVersion);
+    }
+    if (unknown != null) {
+      for (String key : unknown.keySet()) {
+        Object value = unknown.get(key);
+        writer.name(key);
+        writer.value(logger, value);
+      }
+    }
+    writer.endObject();
+  }
+
+  public static final class Deserializer implements JsonDeserializer<SentryEnvelopeHeader> {
+    @Override
+    public @NotNull SentryEnvelopeHeader deserialize(
+        @NotNull JsonObjectReader reader, @NotNull ILogger logger) throws Exception {
+      reader.beginObject();
+
+      SentryId eventId = null;
+      SdkVersion sdkVersion = null;
+      Map<String, Object> unknown = null;
+
+      while (reader.peek() == JsonToken.NAME) {
+        final String nextName = reader.nextName();
+        switch (nextName) {
+          case JsonKeys.EVENT_ID:
+            eventId = new SentryId.Deserializer().deserialize(reader, logger);
+            break;
+          case JsonKeys.SDK:
+            sdkVersion = new SdkVersion.Deserializer().deserialize(reader, logger);
+            break;
+          default:
+            if (unknown == null) {
+              unknown = new HashMap<>();
+            }
+            reader.nextUnknown(logger, unknown, nextName);
+            break;
+        }
+      }
+      SentryEnvelopeHeader sentryEnvelopeHeader = new SentryEnvelopeHeader(eventId, sdkVersion);
+      sentryEnvelopeHeader.setUnknown(unknown);
+      reader.endObject();
+      return sentryEnvelopeHeader;
+    }
+  }
+
+  // JsonUnknown
+
+  @Nullable
+  @Override
+  public Map<String, Object> getUnknown() {
+    return unknown;
+  }
+
+  @Override
+  public void setUnknown(@Nullable Map<String, Object> unknown) {
+    this.unknown = unknown;
+  }
 }
diff --git a/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java b/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
@@ -1,13 +1,17 @@
 package io.sentry;
 
 import io.sentry.util.Objects;
+import io.sentry.vendor.gson.stream.JsonToken;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.concurrent.Callable;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 @ApiStatus.Internal
-public final class SentryEnvelopeItemHeader {
+public final class SentryEnvelopeItemHeader implements JsonSerializable, JsonUnknown {
 
   private final @Nullable String contentType;
   private final @Nullable String fileName;
@@ -16,6 +20,8 @@ public final class SentryEnvelopeItemHeader {
   @Nullable private final Callable<Integer> getLength;
   private final @Nullable String attachmentType;
 
+  private @Nullable Map<String, Object> unknown;
+
   public @NotNull SentryItemType getType() {
     return type;
   }
@@ -39,7 +45,8 @@ public int getLength() {
     return fileName;
   }
 
-  SentryEnvelopeItemHeader(
+  @ApiStatus.Internal
+  public SentryEnvelopeItemHeader(
       final @NotNull SentryItemType type,
       int length,
       final @Nullable String contentType,
@@ -83,4 +90,110 @@ public int getLength() {
   public @Nullable String getAttachmentType() {
     return attachmentType;
   }
+
+  // JsonSerializable
+
+  public static final class JsonKeys {
+    public static final String CONTENT_TYPE = "content_type";
+    public static final String FILENAME = "filename";
+    public static final String TYPE = "type";
+    public static final String ATTACHMENT_TYPE = "attachment_type";
+    public static final String LENGTH = "length";
+  }
+
+  @Override
+  public void serialize(@NotNull JsonObjectWriter writer, @NotNull ILogger logger)
+      throws IOException {
+    writer.beginObject();
+    if (contentType != null) {
+      writer.name(JsonKeys.CONTENT_TYPE).value(contentType);
+    }
+    if (fileName != null) {
+      writer.name(JsonKeys.FILENAME).value(fileName);
+    }
+    writer.name(JsonKeys.TYPE).value(logger, type);
+    if (attachmentType != null) {
+      writer.name(JsonKeys.ATTACHMENT_TYPE).value(attachmentType);
+    }
+    writer.name(JsonKeys.LENGTH).value(length);
+    if (unknown != null) {
+      for (String key : unknown.keySet()) {
+        Object value = unknown.get(key);
+        writer.name(key);
+        writer.value(logger, value);
+      }
+    }
+    writer.endObject();
+  }
+
+  public static final class Deserializer implements JsonDeserializer<SentryEnvelopeItemHeader> {
+    @Override
+    public @NotNull SentryEnvelopeItemHeader deserialize(
+        @NotNull JsonObjectReader reader, @NotNull ILogger logger) throws Exception {
+      reader.beginObject();
+
+      String contentType = null;
+      String fileName = null;
+      SentryItemType type = null;
+      int length = 0;
+      String attachmentType = null;
+      Map<String, Object> unknown = null;
+
+      while (reader.peek() == JsonToken.NAME) {
+        final String nextName = reader.nextName();
+        switch (nextName) {
+          case JsonKeys.CONTENT_TYPE:
+            contentType = reader.nextStringOrNull();
+            break;
+          case JsonKeys.FILENAME:
+            fileName = reader.nextStringOrNull();
+            break;
+          case JsonKeys.TYPE:
+            type = new SentryItemType.Deserializer().deserialize(reader, logger);
+            break;
+          case JsonKeys.LENGTH:
+            length = reader.nextInt();
+            break;
+          case JsonKeys.ATTACHMENT_TYPE:
+            attachmentType = reader.nextStringOrNull();
+            break;
+          default:
+            if (unknown == null) {
+              unknown = new HashMap<>();
+            }
+            reader.nextUnknown(logger, unknown, nextName);
+            break;
+        }
+      }
+      if (type == null) {
+        throw missingRequiredFieldException(JsonKeys.TYPE, logger);
+      }
+      SentryEnvelopeItemHeader sentryEnvelopeItemHeader =
+          new SentryEnvelopeItemHeader(type, length, contentType, fileName, attachmentType);
+      sentryEnvelopeItemHeader.setUnknown(unknown);
+      reader.endObject();
+      return sentryEnvelopeItemHeader;
+    }
+
+    @SuppressWarnings("SameParameterValue")
+    private Exception missingRequiredFieldException(String field, ILogger logger) {
+      String message = "Missing required field \"" + field + "\"";
+      Exception exception = new IllegalStateException(message);
+      logger.log(SentryLevel.ERROR, message, exception);
+      return exception;
+    }
+  }
+
+  // JsonUnknown
+
+  @Nullable
+  @Override
+  public Map<String, Object> getUnknown() {
+    return unknown;
+  }
+
+  @Override
+  public void setUnknown(@Nullable Map<String, Object> unknown) {
+    this.unknown = unknown;
+  }
 }
diff --git a/sentry/src/main/java/io/sentry/SentryItemType.java b/sentry/src/main/java/io/sentry/SentryItemType.java
@@ -1,10 +1,13 @@
 package io.sentry;
 
 import io.sentry.protocol.SentryTransaction;
+import java.io.IOException;
+import java.util.Locale;
 import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
 
 @ApiStatus.Internal
-public enum SentryItemType {
+public enum SentryItemType implements JsonSerializable {
   Session("session"),
   Event("event"), // DataCategory.Error
   UserFeedback("user_report"), // Sentry backend still uses user_report
@@ -33,4 +36,28 @@ public static SentryItemType resolve(Object item) {
   public String getItemType() {
     return itemType;
   }
+
+  public static @NotNull SentryItemType valueOfLabel(String itemType) {
+    for (SentryItemType sentryItemType : values()) {
+      if (sentryItemType.itemType.equals(itemType)) {
+        return sentryItemType;
+      }
+    }
+    return Unknown;
+  }
+
+  @Override
+  public void serialize(@NotNull JsonObjectWriter writer, @NotNull ILogger logger)
+      throws IOException {
+    writer.value(itemType);
+  }
+
+  static final class Deserializer implements JsonDeserializer<SentryItemType> {
+
+    @Override
+    public @NotNull SentryItemType deserialize(
+        @NotNull JsonObjectReader reader, @NotNull ILogger logger) throws Exception {
+      return SentryItemType.valueOfLabel(reader.nextString().toLowerCase(Locale.ROOT));
+    }
+  }
 }