iOS native profiling

benchmarks/Sentry.Benchmarks/ProfilingBenchmarks.cs

@@ -25,7 +25,7 @@ public void StartProfiler()
     public void StopProfiler()
     {
         _profiler?.Finish();
-        _profiler?.CollectAsync(new Transaction("", "")).Wait();
+        (_profiler as SamplingTransactionProfiler)?.CollectAsync(new Transaction("", "")).Wait();
         _profiler = null;
         _factory.Dispose();
         _factory = null;
@@ -55,7 +55,7 @@ public long Transaction(int runtimeMs, bool collect)
         var transaction = new Transaction(tt);
         if (collect)
         {
-            var collectTask = tt.TransactionProfiler.CollectAsync(transaction);
+            var collectTask = (tt.TransactionProfiler as SamplingTransactionProfiler).CollectAsync(transaction);
             collectTask.Wait();
         }
         return result;

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,14 @@ public void Finish()
     }
 
     /// <inheritdoc />
-    public async Task<ProfileInfo> CollectAsync(Transaction transaction)
+    public Protocol.Envelopes.ISerializable Collect(Transaction transaction)
+        => Protocol.Envelopes.AsyncJsonSerializable.CreateFrom(CollectAsync(transaction));
+
+    internal async Task<ProfileInfo> CollectAsync(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.Profiling/SentryProfiling.cs

@@ -10,6 +10,8 @@ public class ProfilingIntegration : ISdkIntegration
     /// <inheritdoc/>
     public void Register(IHub hub, SentryOptions options)
     {
-        options.TransactionProfilerFactory = SamplingTransactionProfilerFactory.Create(options);
+        if (options.IsProfilingEnabled) {
+            options.TransactionProfilerFactory = SamplingTransactionProfilerFactory.Create(options);
+        }
     }
 }

src/Sentry/BindableSentryOptions.cs

@@ -40,6 +40,7 @@ internal partial class BindableSentryOptions
     public bool? EnableTracing { get; set; }
     public double? TracesSampleRate { get; set; }
     public List<string>? TracePropagationTargets { get; set; }
+    public double? ProfilesSampleRate { get; set; }
     public StackTraceMode? StackTraceMode { get; set; }
     public long? MaxAttachmentSize { get; set; }
     public StartupTimeDetectionMode? DetectStartupTime { get; set; }
@@ -82,6 +83,7 @@ public void ApplyTo(SentryOptions options)
         options.DefaultTags = DefaultTags ?? options.DefaultTags;
         options.EnableTracing = EnableTracing ?? options.EnableTracing;
         options.TracesSampleRate = TracesSampleRate ?? options.TracesSampleRate;
+        options.ProfilesSampleRate = ProfilesSampleRate ?? options.ProfilesSampleRate;
         options.TracePropagationTargets = TracePropagationTargets?.Select(s => new SubstringOrRegexPattern(s)).ToList() ?? options.TracePropagationTargets;
         options.StackTraceMode = StackTraceMode ?? options.StackTraceMode;
         options.MaxAttachmentSize = MaxAttachmentSize ?? options.MaxAttachmentSize;

src/Sentry/Internal/Hub.cs

@@ -154,7 +154,9 @@ internal ITransactionTracer StartTransaction(
                 transaction.SampleRate = sampleRate;
             }
 
-            if (transaction.IsSampled is true && _options.TransactionProfilerFactory is { } profilerFactory)
+            if (transaction.IsSampled is true &&
+                _options.TransactionProfilerFactory is { } profilerFactory &&
+                _randomValuesFactory.NextBool(_options.ProfilesSampleRate ?? 0.0))
             {
                 // TODO cancellation token based on Hub being closed?
                 transaction.TransactionProfiler = profilerFactory.Start(transaction, CancellationToken.None);
@@ -200,7 +202,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();
         }
@@ -528,11 +530,11 @@ public void Dispose()
 #elif ANDROID
             // TODO
 #elif NET8_0_OR_GREATER
-            if (AotHelper.IsNativeAot)
-            {
-                _options?.LogDebug("Closing native SDK");
-                SentrySdk.CloseNativeSdk();
-            }
+        if (AotHelper.IsNativeAot)
+        {
+            _options?.LogDebug("Closing native SDK");
+            SentrySdk.CloseNativeSdk();
+        }
 #endif
     }
 

src/Sentry/Internal/ITransactionProfiler.cs

@@ -23,8 +23,7 @@ internal interface ITransactionProfiler
     /// </summary>
     void Finish();
 
-    /// <summary>
-    /// Process and collect the profile.
-    /// </summary>
-    Task<ProfileInfo> CollectAsync(Transaction transaction);
+    /// <summary>Process and collect the profile.</summary>
+    /// <returns>The collected profile.</returns>
+    ISerializable 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/Internal/SerializableExtensions.cs

@@ -1,7 +1,6 @@
 using Sentry.Extensibility;
 using Sentry.Infrastructure;
 using Sentry.Protocol.Envelopes;
-using ISerializable = Sentry.Protocol.Envelopes.ISerializable;
 
 namespace Sentry.Internal;
 

src/Sentry/Platforms/Cocoa/CocoaProfiler.cs

@@ -0,0 +1,54 @@
+using Sentry.Extensibility;
+using Sentry.Internal;
+using Sentry.Protocol;
+using Sentry.Cocoa.Extensions;
+using Sentry.Cocoa.Facades;
+
+namespace Sentry.Cocoa;
+
+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 ISerializable Collect(Transaction transaction)
+    {
+        // TODO change return type of CocoaSDKs CollectProfileBetween to NSMutableDictionary
+        var payload = SentryCocoaHybridSdk.CollectProfileBetween(_starTimeNs, _endTimeNs, _cocoaTraceId)?.MutableCopy() as NSMutableDictionary;
+        _options.LogDebug("Trace {0} profile payload collected", _traceId);
+
+        ArgumentNullException.ThrowIfNull(payload, "profile payload");
+        payload["timestamp"] = transaction.StartTimestamp.ToString("o", CultureInfo.InvariantCulture).ToNSString();
+
+        var payloadTx = payload["transaction"]?.MutableCopy() as NSMutableDictionary;
+        ArgumentNullException.ThrowIfNull(payloadTx, "profile payload transaction");
+        payloadTx["id"] = transaction.EventId.ToString().ToNSString();
+        payloadTx["trace_id"] = _traceId.ToString().ToNSString();
+        payloadTx["name"] = transaction.Name.ToNSString();
+        payload["transaction"] = payloadTx;
+        return new SerializableNSObject(payload);
+    }
+}

src/Sentry/Platforms/Cocoa/CocoaProfilerFactory.cs

@@ -0,0 +1,26 @@
+using Sentry.Internal;
+using Sentry.Cocoa.Extensions;
+
+namespace Sentry.Cocoa;
+
+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/Cocoa/Extensions/CocoaExtensions.cs

@@ -8,6 +8,8 @@ internal static class CocoaExtensions
 
     public static NSDate ToNSDate(this DateTimeOffset timestamp) => (NSDate)timestamp.UtcDateTime;
 
+    public static NSString ToNSString(this string str) => new NSString(str);
+
     public static string? ToJsonString(this NSObject? obj, IDiagnosticLogger? logger = null)
     {
         using var data = obj.ToJsonData(logger);

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

@@ -0,0 +1,33 @@
+using Sentry.Extensibility;
+using Sentry.Internal;
+
+namespace Sentry.Cocoa.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);
+        using var dataStream = data.AsStream();
+        dataStream.CopyTo(stream);
+    }
+}

src/Sentry/Platforms/Cocoa/SentrySdk.cs

@@ -96,7 +96,7 @@ private static void InitSentryCocoaSdk(SentryOptions options)
 
         // TODO: Finish SentryEventExtensions to enable these
 
-        // if (options.Native.EnableCocoaSdkBeforeSend && options.BeforeSend is { } beforeSend)
+        // if (options.Native.EnableBeforeSend && options.BeforeSend is { } beforeSend)
         // {
         //     nativeOptions.BeforeSend = evt =>
         //     {
@@ -188,6 +188,10 @@ private static void InitSentryCocoaSdk(SentryOptions options)
         options.EnableScopeSync = true;
         options.ScopeObserver = new CocoaScopeObserver(options);
 
+        if (options.IsProfilingEnabled) {
+            options.TransactionProfilerFactory = new CocoaProfilerFactory(options);
+        }
+
         // TODO: Pause/Resume
     }
 

src/Sentry/Protocol/Envelopes/Envelope.cs

@@ -313,8 +313,8 @@ 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)));
+            // Profiler.Collect() may throw in which case the EnvelopeItem won't serialize.
+            items.Add(EnvelopeItem.FromProfileInfo(profiler.Collect(transaction)));
         }
 
         return new Envelope(eventId, header, items);

src/Sentry/Protocol/Envelopes/EnvelopeItem.cs

@@ -224,14 +224,14 @@ 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(ISerializable source)
     {
         var header = new Dictionary<string, object?>(1, StringComparer.Ordinal)
         {
             [TypeKey] = TypeValueProfile
         };
 
-        return new EnvelopeItem(header, AsyncJsonSerializable.CreateFrom(source));
+        return new EnvelopeItem(header, source);
     }
 
     /// <summary>

src/Sentry/Sentry.csproj

@@ -95,6 +95,10 @@
     <None Include="buildTransitive\Sentry.targets" Pack="true" PackagePath="build\Sentry.targets" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Using Include="Sentry.Protocol.Envelopes.ISerializable" Alias="ISerializable" />
+  </ItemGroup>
+
   <!-- Download the Sentry CLI during the restore phase. -->
   <Target Name="DownloadSentryCLI" BeforeTargets="CollectPackageReferences" Condition="'$(SentryCLIDirectory)' != ''">