Initial commit for exposing iOS native before send & crashed last run

samples/Sentry.Samples.Ios/AppDelegate.cs

@@ -28,6 +28,17 @@ public override bool FinishedLaunching(UIApplication application, NSDictionary l
             options.Native.EnableAppHangTracking = true;
 
             options.CacheDirectoryPath = Path.GetTempPath();
+
+            options.Native.BeforeSend = e =>
+            {
+                e.SetTag("dotnet-iOS-Native-Before", "Hello World");
+                return e;
+            };
+
+            options.Native.CrashedLastRun = e =>
+            {
+                Console.WriteLine(e);
+            };
         });
 
         // create a new window instance based on the screen size

samples/Sentry.Samples.Ios/Sentry.Samples.Ios.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0-ios18.0</TargetFramework>
+    <TargetFramework>net9.0-ios</TargetFramework>
     <OutputType>Exe</OutputType>
     <Nullable>enable</Nullable>
     <ImplicitUsings>true</ImplicitUsings>

src/Sentry.Bindings.Cocoa/ApiDefinitions.cs

@@ -2454,6 +2454,12 @@ interface PrivateSentrySDKOnly
     [Static]
     [Export ("breadcrumbWithDictionary:")]
     SentryBreadcrumb BreadcrumbWithDictionary (NSDictionary dictionary);
+
+
+    // +(SentryEnvelope * _Nonnull)envelopeWithData:(NSData * _Nonnull)data;
+    [Static]
+    [Export ("envelopeWithData:")]
+    SentryEnvelope EnvelopeWithData (NSData data);
 }
 
 // @interface SentryId : NSObject

src/Sentry.Bindings.Cocoa/PrivateApiDefinitions.cs

@@ -30,3 +30,13 @@ interface SentrySession
 interface SentryTracer
 {
 }
+
+[Internal]
+[DisableDefaultCtor]
+[BaseType (typeof(NSObject))]
+interface SentryEnvelope
+{
+    // @property (nonatomic, readonly, strong) NSArray<SentryEnvelopeItem *> *items;
+    [Export("items")]
+    NSArray Items { get; }
+}

src/Sentry/Platforms/Cocoa/Extensions/SentryEventExtensions.cs

@@ -1,45 +1,46 @@
-// using Sentry.Extensibility;
-// using Sentry.Protocol.Envelopes;
-//
-// namespace Sentry.Cocoa.Extensions;
-//
-// internal static class SentryEventExtensions
-// {
-//     /*
-//      * These methods map between a SentryEvent and it's Cocoa counterpart by serializing as JSON into memory on one side,
-//      * then deserializing back to an object on the other side.  It is not expected to be performant, as this code is only
-//      * used when a BeforeSend option is set, and then only when an event is captured by the Cocoa SDK (which should be
-//      * relatively rare).
-//      *
-//      * This approach avoids having to write to/from methods for the entire object graph.  However, it's also important to
-//      * recognize that there's not necessarily a one-to-one mapping available on all objects (even through serialization)
-//      * between the two SDKs, so some optional details may be lost when roundtripping.  That's generally OK, as this is
-//      * still better than nothing.  If a specific part of the object graph becomes important to roundtrip, we can consider
-//      * updating the objects on either side.
-//      */
-//
-//     public static SentryEvent ToSentryEvent(this CocoaSdk.SentryEvent sentryEvent, SentryCocoaSdkOptions nativeOptions)
-//     {
-//         using var stream = sentryEvent.ToJsonStream()!;
-//         //stream.Seek(0, SeekOrigin.Begin); ??
-//
-//         using var json = JsonDocument.Parse(stream);
-//         var exception = sentryEvent.Error == null ? null : new NSErrorException(sentryEvent.Error);
-//         return SentryEvent.FromJson(json.RootElement, exception);
-//     }
-//
-//     public static CocoaSdk.SentryEvent ToCocoaSentryEvent(this SentryEvent sentryEvent, SentryOptions options, SentryCocoaSdkOptions nativeOptions)
-//     {
-//         var envelope = Envelope.FromEvent(sentryEvent);
-//
-//         using var stream = new MemoryStream();
-//         envelope.Serialize(stream, options.DiagnosticLogger);
-//         stream.Seek(0, SeekOrigin.Begin);
-//
-//         using var data = NSData.FromStream(stream)!;
-//         var cocoaEnvelope = CocoaSdk.PrivateSentrySDKOnly.EnvelopeWithData(data);
-//
-//         var cocoaEvent = (CocoaSdk.SentryEvent) cocoaEnvelope.Items[0];
-//         return cocoaEvent;
-//     }
-// }
+using Sentry.Extensibility;
+using Sentry.Protocol.Envelopes;
+
+namespace Sentry.Cocoa.Extensions;
+
+internal static class SentryEventExtensions
+{
+    /*
+     * These methods map between a SentryEvent and it's Cocoa counterpart by serializing as JSON into memory on one side,
+     * then deserializing back to an object on the other side.  It is not expected to be performant, as this code is only
+     * used when a BeforeSend option is set, and then only when an event is captured by the Cocoa SDK (which should be
+     * relatively rare).
+     *
+     * This approach avoids having to write to/from methods for the entire object graph.  However, it's also important to
+     * recognize that there's not necessarily a one-to-one mapping available on all objects (even through serialization)
+     * between the two SDKs, so some optional details may be lost when roundtripping.  That's generally OK, as this is
+     * still better than nothing.  If a specific part of the object graph becomes important to roundtrip, we can consider
+     * updating the objects on either side.
+     */
+
+    public static SentryEvent ToSentryEvent(this CocoaSdk.SentryEvent sentryEvent, SentryCocoaSdkOptions nativeOptions)
+    {
+        using var stream = sentryEvent.ToJsonStream()!;
+        //stream.Seek(0, SeekOrigin.Begin); ??
+
+        using var json = JsonDocument.Parse(stream);
+        var exception = sentryEvent.Error == null ? null : new NSErrorException(sentryEvent.Error);
+        var ev = SentryEvent.FromJson(json.RootElement, exception);
+        return ev;
+    }
+
+    public static CocoaSdk.SentryEvent ToCocoaSentryEvent(this SentryEvent sentryEvent, SentryOptions options, SentryCocoaSdkOptions nativeOptions)
+    {
+        var envelope = Envelope.FromEvent(sentryEvent);
+
+        using var stream = new MemoryStream();
+        envelope.Serialize(stream, options.DiagnosticLogger);
+        stream.Seek(0, SeekOrigin.Begin);
+
+        using var data = NSData.FromStream(stream)!;
+        var cocoaEnvelope = CocoaSdk.PrivateSentrySDKOnly.EnvelopeWithData(data);
+
+        var cocoaEvent = (CocoaSdk.SentryEvent) cocoaEnvelope.Items.GetItem<CocoaSdk.SentryEvent>(0);
+        return cocoaEvent;
+    }
+}

src/Sentry/Platforms/Cocoa/SentryOptions.cs

@@ -236,6 +236,16 @@ public void AddInAppInclude(string prefix)
             InAppIncludes ??= new List<string>();
             InAppIncludes.Add(prefix);
         }
+
+        /// <summary>
+        /// Sets native BeforeSend callback
+        /// </summary>
+        public Func<SentryEvent, SentryEvent>? BeforeSend { get; set; }
+
+        /// <summary>
+        /// Sets native OnCrashedLastRun callback
+        /// </summary>
+        public Action<SentryEvent>? CrashedLastRun { get; set; }
     }
 
     // We actually add the profiling integration automatically in InitSentryCocoaSdk().

src/Sentry/Platforms/Cocoa/SentrySdk.cs

@@ -35,6 +35,7 @@ private static void InitSentryCocoaSdk(SentryOptions options)
         nativeOptions.SendDefaultPii = options.SendDefaultPii;
         nativeOptions.SessionTrackingIntervalMillis = (nuint)options.AutoSessionTrackingInterval.TotalMilliseconds;
 
+        // nativeOptions.BeforeSend
         if (options.Environment is { } environment)
         {
             nativeOptions.Environment = environment;
@@ -88,27 +89,44 @@ private static void InitSentryCocoaSdk(SentryOptions options)
 
         // TODO: Finish SentryEventExtensions to enable these
 
-        // if (options.Native.EnableBeforeSend && options.BeforeSend is { } beforeSend)
-        // {
-        //     nativeOptions.BeforeSend = evt =>
-        //     {
-        //         var sentryEvent = evt.ToSentryEvent(nativeOptions);
-        //         var result = beforeSend(sentryEvent)?.ToCocoaSentryEvent(options, nativeOptions);
-        //
-        //         // Note: Nullable result is allowed but delegate is generated incorrectly
-        //         // See https://github.com/xamarin/xamarin-macios/issues/15299#issuecomment-1201863294
-        //         return result!;
-        //     };
-        // }
-
-        // if (options.Native.OnCrashedLastRun is { } onCrashedLastRun)
-        // {
-        //     nativeOptions.OnCrashedLastRun = evt =>
-        //     {
-        //         var sentryEvent = evt.ToSentryEvent(nativeOptions);
-        //         onCrashedLastRun(sentryEvent);
-        //     };
-        // }
+        if (options.Native.BeforeSend is { } beforeSend)
+        {
+            nativeOptions.BeforeSend = evt =>
+            {
+                // because we delegate to user code, we need to protect anything that could happen in this event
+                try
+                {
+                    var sentryEvent = evt.ToSentryEvent(nativeOptions);
+                    var result = beforeSend(sentryEvent)?.ToCocoaSentryEvent(options, nativeOptions);
+
+                    // Note: Nullable result is allowed but delegate is generated incorrectly
+                    // See https://github.com/xamarin/xamarin-macios/issues/15299#issuecomment-1201863294
+                    return result!;
+                }
+                catch (Exception ex)
+                {
+                    options.LogError(ex, "Before Send Error");
+                    return evt;
+                }
+            };
+        }
+
+        if (options.Native.CrashedLastRun is { } onCrashedLastRun)
+        {
+            nativeOptions.OnCrashedLastRun = evt =>
+            {
+                // because we delegate to user code, we need to protect anything that could happen in this event
+                try
+                {
+                    var sentryEvent = evt.ToSentryEvent(nativeOptions);
+                    onCrashedLastRun(sentryEvent);
+                }
+                catch (Exception ex)
+                {
+                    options.LogError(ex, "Crashed Last Run Error");
+                }
+            };
+        }
 
         // These options are from Cocoa's SentryOptions
         nativeOptions.AttachScreenshot = options.Native.AttachScreenshot;