iOS native profiling

samples/Sentry.Samples.Ios/AppDelegate.cs

@@ -16,6 +16,7 @@ public override bool FinishedLaunching(UIApplication application, NSDictionary l
         {
             o.Debug = true;
             o.Dsn = "https://eb18e953812b41c3aeb042e666fd3b5c@o447951.ingest.sentry.io/5428537";
+            o.TracesSampleRate = 1.0;
         });
 
         // create a new window instance based on the screen size
@@ -50,6 +51,43 @@ public override bool FinishedLaunching(UIApplication application, NSDictionary l
         // throw new Exception("Test Unhandled Managed Exception");
         // SentrySdk.CauseCrash(CrashType.Native);
 
+        {
+            var tx = SentrySdk.StartTransaction("app", "run");
+            var count = 10;
+            for (var i = 0; i < count; i++)
+            {
+                FindPrimeNumber(100000);
+            }
+
+            tx.Finish();
+        }
+
         return true;
     }
+
+    private static long FindPrimeNumber(int n)
+    {
+        int count = 0;
+        long a = 2;
+        while (count < n)
+        {
+            long b = 2;
+            int prime = 1;// to check if found a prime
+            while (b * b <= a)
+            {
+                if (a % b == 0)
+                {
+                    prime = 0;
+                    break;
+                }
+                b++;
+            }
+            if (prime > 0)
+            {
+                count++;
+            }
+            a++;
+        }
+        return (--a);
+    }
 }

src/Sentry.Profiling/SamplingTransactionProfiler.cs

@@ -96,11 +96,11 @@
     }
 
     /// <inheritdoc />
-    public async Task<ProfileInfo> CollectAsync(Transaction transaction)
+    public async object Collect(Transaction transaction)
     {
         if (!_stopped)
         {
-            throw new InvalidOperationException("Profiler.CollectAsync() called before Finish()");
+            throw new InvalidOperationException("Profiler.Collect() called before Finish()");
         }
 
         // Wait for the last sample (<= _endTimeMs), or at most 1 second. The timeout shouldn't happen because

src/Sentry/Internal/Hub.cs

@@ -154,6 +154,7 @@ internal ITransactionTracer StartTransaction(
                 transaction.SampleRate = sampleRate;
             }
 
+            // TODO profileSampleRate
             if (transaction.IsSampled is true && _options.TransactionProfilerFactory is { } profilerFactory)
             {
                 // TODO cancellation token based on Hub being closed?
@@ -200,7 +201,7 @@ public SentryTraceHeader GetTraceHeader()
 
     public BaggageHeader GetBaggage()
     {
-        if (GetSpan() is TransactionTracer { DynamicSamplingContext: { IsEmpty: false } dsc } )
+        if (GetSpan() is TransactionTracer { DynamicSamplingContext: { IsEmpty: false } dsc })
         {
             return dsc.ToBaggageHeader();
         }

src/Sentry/Internal/ITransactionProfiler.cs

@@ -26,5 +26,6 @@ internal interface ITransactionProfiler
     /// <summary>
     /// Process and collect the profile.
     /// </summary>
-    Task<ProfileInfo> CollectAsync(Transaction transaction);
+    /// <returns>The collected profile. See EnvelopeItem.FromProfileInfo() for supported return types.</returns>
+    object Collect(Transaction transaction);
 }

src/Sentry/Internal/SentryStopwatch.cs

@@ -8,6 +8,7 @@ internal struct SentryStopwatch
 {
     private static readonly double StopwatchTicksPerTimeSpanTick =
         (double)Stopwatch.Frequency / TimeSpan.TicksPerSecond;
+    private static readonly double StopwatchTicksPerNs = (double)Stopwatch.Frequency / 1000000000.0;
 
     private long _startTimestamp;
     private DateTimeOffset _startDateTimeOffset;
@@ -21,14 +22,15 @@ internal struct SentryStopwatch
     public DateTimeOffset StartDateTimeOffset => _startDateTimeOffset;
     public DateTimeOffset CurrentDateTimeOffset => _startDateTimeOffset + Elapsed;
 
+    private long Diff() => Stopwatch.GetTimestamp() - _startTimestamp;
+
     public TimeSpan Elapsed
     {
-        get
-        {
-            var now = Stopwatch.GetTimestamp();
-            var diff = now - _startTimestamp;
-            var ticks = (long)(diff / StopwatchTicksPerTimeSpanTick);
-            return TimeSpan.FromTicks(ticks);
-        }
+        get => TimeSpan.FromTicks((long)(Diff() / StopwatchTicksPerTimeSpanTick));
+    }
+
+    public ulong ElapsedNanoseconds
+    {
+        get => (ulong)(Diff() / StopwatchTicksPerNs);
     }
 }

src/Sentry/Platforms/iOS/CocoaProfiler.cs

@@ -0,0 +1,45 @@
+using Sentry.Extensibility;
+using Sentry.Internal;
+using Sentry.Protocol;
+using Sentry.iOS.Extensions;
+using Sentry.iOS.Facades;
+
+namespace Sentry.iOS;
+
+internal class CocoaProfiler : ITransactionProfiler
+{
+    private readonly SentryOptions _options;
+    private readonly SentryId _traceId;
+    private readonly CocoaSdk.SentryId _cocoaTraceId;
+    private readonly ulong _starTimeNs;
+    private ulong _endTimeNs;
+    private readonly SentryStopwatch _stopwatch = SentryStopwatch.StartNew();
+
+    public CocoaProfiler(SentryOptions options, ulong starTimeNs, SentryId traceId, CocoaSdk.SentryId cocoaTraceId)
+    {
+        _options = options;
+        _starTimeNs = starTimeNs;
+        _traceId = traceId;
+        _cocoaTraceId = cocoaTraceId;
+        _options.LogDebug("Trace {0} profile start timestamp: {1} ns", _traceId, _starTimeNs);
+    }
+
+    /// <inheritdoc />
+    public void Finish()
+    {
+        if (_endTimeNs == 0)
+        {
+            _endTimeNs = _starTimeNs + (ulong)_stopwatch.ElapsedNanoseconds;
+            _options.LogDebug("Trace {0} profile end timestamp: {1} ns", _traceId, _endTimeNs);
+        }
+    }
+
+    public object Collect(Transaction transaction)
+    {
+        var payload = SentryCocoaHybridSdk.CollectProfileBetween(_starTimeNs, _endTimeNs, _cocoaTraceId);
+        ArgumentNullException.ThrowIfNull(payload, "profile payload");
+
+        _options.LogDebug("Trace {0} profile payload collected", _traceId);
+        return new SerializableNSObject(payload);
+    }
+}

src/Sentry/Platforms/iOS/CocoaProfilerFactory.cs

@@ -0,0 +1,26 @@
+using Sentry.Internal;
+using Sentry.iOS.Extensions;
+
+namespace Sentry.iOS;
+
+internal class CocoaProfilerFactory : ITransactionProfilerFactory
+{
+    private readonly SentryOptions _options;
+
+    internal CocoaProfilerFactory(SentryOptions options)
+    {
+        _options = options;
+    }
+
+    /// <inheritdoc />
+    public ITransactionProfiler? Start(ITransactionTracer tracer, CancellationToken cancellationToken)
+    {
+        var traceId = tracer.TraceId.ToCocoaSentryId();
+        var startTime = SentryCocoaHybridSdk.StartProfilerForTrace(traceId);
+        if (startTime == 0)
+        {
+            return null;
+        }
+        return new CocoaProfiler(_options, startTime, tracer.TraceId, traceId);
+    }
+}

src/Sentry/Platforms/iOS/Facades/SerializableNSObject.cs

@@ -0,0 +1,33 @@
+using Sentry.Extensibility;
+using Sentry.Internal;
+using ISerializable = Sentry.Protocol.Envelopes.ISerializable;
+
+namespace Sentry.iOS.Facades;
+
+internal class SerializableNSObject : ISerializable
+{
+    private readonly NSObject _value;
+
+    public SerializableNSObject(NSObject value)
+    {
+        _value = value;
+    }
+
+    public Task SerializeAsync(Stream stream, IDiagnosticLogger? logger, CancellationToken cancellationToken = default)
+        => Task.Run(() => Serialize(stream, logger)); // TODO do we need a better implementation?
+
+    public void Serialize(Stream stream, IDiagnosticLogger? logger) {
+        // For types that implement Sentry Cocoa's SentrySerializable protocol (interface),
+        // We should call that first, and then serialize the result to JSON later.
+        var obj = _value is CocoaSdk.ISentrySerializable serializable
+            ? serializable.Serialize()
+            : _value;
+
+        // Now we will use Apple's JSON Serialization functions.
+        // See https://developer.apple.com/documentation/foundation/nsjsonserialization
+        // TODO can we pipe NSOutputStream directly? It can be passed as a second argument
+        // TODO how do we check if the error happened? Is it non-null? Then we can rethrow as NSErrorException?
+        var data = NSJsonSerialization.Serialize(obj, 0, out NSError error);
+        data.AsStream().CopyTo(stream);
+    }
+}

src/Sentry/Platforms/iOS/SentrySdk.cs

@@ -187,6 +187,7 @@ private static void InitSentryCocoaSdk(SentryOptions options)
         options.CrashedLastRun = () => SentryCocoaSdk.CrashedLastRun;
         options.EnableScopeSync = true;
         options.ScopeObserver = new IosScopeObserver(options);
+        options.TransactionProfilerFactory = new CocoaProfilerFactory(options);
 
         // TODO: Pause/Resume
     }

src/Sentry/Protocol/Envelopes/Envelope.cs

@@ -314,7 +314,7 @@ public static Envelope FromTransaction(Transaction transaction)
         if (transaction.TransactionProfiler is { } profiler)
         {
             // Profiler.CollectAsync() may throw in which case the EnvelopeItem won't serialize.
-            items.Add(EnvelopeItem.FromProfileInfo(profiler.CollectAsync(transaction)));
+            items.Add(EnvelopeItem.FromProfileInfo(profiler.Collect(transaction)));
         }
 
         return new Envelope(eventId, header, items);

src/Sentry/Protocol/Envelopes/EnvelopeItem.cs

@@ -224,14 +224,21 @@ public static EnvelopeItem FromTransaction(Transaction transaction)
     /// <summary>
     /// Creates an <see cref="EnvelopeItem"/> from <paramref name="source"/>.
     /// </summary>
-    internal static EnvelopeItem FromProfileInfo(Task<ProfileInfo> source)
+    internal static EnvelopeItem FromProfileInfo(object source)
     {
         var header = new Dictionary<string, object?>(1, StringComparer.Ordinal)
         {
             [TypeKey] = TypeValueProfile
         };
 
-        return new EnvelopeItem(header, AsyncJsonSerializable.CreateFrom(source));
+        ISerializable payload = source switch
+        {
+            ISerializable serializable => serializable,
+            Task<IJsonSerializable> task => AsyncJsonSerializable.CreateFrom(task),
+            _ => throw new ArgumentException("Unsupported profile info source type.", nameof(source))
+        };
+
+        return new EnvelopeItem(header, payload);
     }
 
     /// <summary>