Add LogCat integration to Android via an EventProcessor

CHANGELOG.md

@@ -5,6 +5,7 @@
 ### Features
 
 - Native crash reporting on NativeAOT published apps (Windows, Linux, macOS). ([#2887](https://github.com/getsentry/sentry-dotnet/pull/2887))
+- Added Android LogCat collection to the core `Sentry` SDK, configurable via `SentryOptions.LogCatIntegration` when targeting `net7.0-android` or later. ([#2926](https://github.com/getsentry/sentry-dotnet/pull/2926))
 
 ### API breaking Changes
 

src/Sentry/Platforms/Android/BindableSentryOptions.cs

@@ -1,4 +1,6 @@
 // ReSharper disable once CheckNamespace
+using Sentry.Android;
+
 namespace Sentry;
 
 internal partial class BindableSentryOptions
@@ -33,6 +35,7 @@ public class AndroidOptions
         public TimeSpan? ReadTimeout { get; set; }
         public bool? EnableAndroidSdkTracing { get; set; }
         public bool? EnableAndroidSdkBeforeSend { get; set; }
+        public LogCatIntegrationType? LogCatIntegration { get; set; }
 
         public void ApplyTo(SentryOptions.AndroidOptions options)
         {
@@ -59,6 +62,7 @@ public void ApplyTo(SentryOptions.AndroidOptions options)
             options.ReadTimeout = ReadTimeout ?? options.ReadTimeout;
             options.EnableAndroidSdkTracing = EnableAndroidSdkTracing ?? options.EnableAndroidSdkTracing;
             options.EnableAndroidSdkBeforeSend = EnableAndroidSdkBeforeSend ?? options.EnableAndroidSdkBeforeSend;
+            options.LogCatIntegration = LogCatIntegration ?? options.LogCatIntegration;
         }
     }
 }

src/Sentry/Platforms/Android/LogCatAttachmentEventProcessor.cs

@@ -0,0 +1,96 @@
+using Sentry.Extensibility;
+using Runtime = Java.Lang.Runtime;
+using Android.Content;
+using Application = Android.App.Application;
+
+namespace Sentry.Android;
+
+internal class LogCatAttachmentEventProcessor : ISentryEventProcessorWithHint
+{
+    private static bool SendLogcatLogs = true;
+    private readonly LogCatIntegrationType _logCatIntegrationType;
+    private readonly IDiagnosticLogger? _diagnosticLogger;
+
+    public LogCatAttachmentEventProcessor(LogCatIntegrationType logCatIntegrationType, IDiagnosticLogger? diagnosticLogger)
+    {
+        _logCatIntegrationType = logCatIntegrationType;
+        _diagnosticLogger = diagnosticLogger;
+    }
+
+    public SentryEvent Process(SentryEvent @event, Hint hint)
+    {
+        // If sending has failed once, we have to disable this feature to prevent infinite loops and to allow the SDK to work otherwise
+        if (!SendLogcatLogs)
+        {
+            return @event;
+        }
+
+        // The logcat command only works on Android API 23 and above
+        if (!OperatingSystem.IsAndroidVersionAtLeast(23))
+        {
+            SendLogcatLogs = false;
+            return @event;
+        }
+
+        try
+        {
+            if (_logCatIntegrationType != LogCatIntegrationType.All && (@event.SentryExceptions?.Any() ?? false))
+            {
+                return @event;
+            }
+
+            var filesDir = Application.Context.FilesDir;
+            if (filesDir == null)
+            {
+                _diagnosticLogger?.LogWarning("Failed to get files directory");
+                return @event;
+            }
+
+            // Only send logcat logs if the event is unhandled if the integration is set to Unhandled
+            if (_logCatIntegrationType == LogCatIntegrationType.Unhandled)
+            {
+                if (!@event.HasTerminalException())
+                {
+                    return @event;
+                }
+            }
+
+            // We run the logcat command via the runtime
+            var process = Runtime.GetRuntime()?.Exec("logcat -t 1000 *:I");
+
+            // Strangely enough, process.InputStream is the *output* of the command
+            if (process?.InputStream is null)
+            {
+                return @event;
+            }
+
+            // We write the logcat logs to a file so we can attach it
+            using var output = Application.Context.OpenFileOutput("sentry_logcat.txt", FileCreationMode.Private);
+            if (output is null)
+            {
+                return @event;
+            }
+
+            process.InputStream.CopyTo(output);
+            process.WaitFor();
+
+            hint.AddAttachment(filesDir!.Path + "/sentry_logcat.txt", AttachmentType.Default, "text/logcat");
+
+            return @event;
+        }
+        catch (Exception e) // Catch all exceptions to prevent crashing the app during logging
+        {
+            // Disable the feature if it fails once
+            SendLogcatLogs = false;
+
+            // Log the failure to Sentry
+            _diagnosticLogger?.LogError(e, "Failed to send logcat logs");
+            return @event;
+        }
+    }
+
+    public SentryEvent Process(SentryEvent @event)
+    {
+        return Process(@event, new Hint());
+    }
+}

src/Sentry/Platforms/Android/LogCatIntegrationType.cs

@@ -0,0 +1,28 @@
+namespace Sentry.Android;
+
+/// <summary>
+/// Configures when to attach LogCat logs to events.
+/// </summary>
+public enum LogCatIntegrationType
+{
+    /// <summary>
+    /// The LogCat integration is disabled.
+    /// </summary>
+    None,
+    /// <summary>
+    /// LogCat logs are attached to events only when the event is unhandled.
+    /// </summary>
+    Unhandled,
+
+    /// <summary>
+    /// LogCat logs are attached to events with an exception.
+    /// </summary>
+    Errors,
+
+    /// <summary>
+    /// LogCat logs are attached to all events.
+    /// Use caution when enabling, as this may result in a lot of data being sent to Sentry
+    /// and performance issues if the SDK generates a lot of events.
+    /// </summary>
+    All
+}

src/Sentry/Platforms/Android/SentryOptions.cs

@@ -1,3 +1,5 @@
+using Sentry.Android;
+
 // ReSharper disable once CheckNamespace
 namespace Sentry;
 
@@ -196,6 +198,12 @@ internal AndroidOptions(SentryOptions options)
         /// </summary>
         public TimeSpan ReadTimeout { get; set; } = TimeSpan.FromSeconds(5);
 
+        /// <summary>
+        /// Gets or sets whether when LogCat logs are attached to events.
+        /// The default is <see cref="LogCatIntegrationType.Unhandled"/>
+        /// </summary>
+        public LogCatIntegrationType LogCatIntegration { get; set; } = LogCatIntegrationType.Unhandled;
+
 
         // ---------- Other ----------
 

src/Sentry/Platforms/Android/SentrySdk.cs

@@ -3,6 +3,7 @@
 using Sentry.Android;
 using Sentry.Android.Callbacks;
 using Sentry.Android.Extensions;
+using Sentry.Internal;
 using Sentry.JavaSdk.Android.Core;
 
 // Don't let the Sentry Android SDK auto-init, as we do that manually in SentrySdk.Init
@@ -187,6 +188,10 @@ private static void InitSentryAndroidSdk(SentryOptions options)
 
         // Set options for the managed SDK that depend on the Android SDK. (The user will not be able to modify these.)
         options.AddEventProcessor(new AndroidEventProcessor(androidOptions!));
+        if (options.Android.LogCatIntegration != LogCatIntegrationType.None)
+        {
+            options.AddEventProcessor(new LogCatAttachmentEventProcessor(options.Android.LogCatIntegration, options.DiagnosticLogger));
+        }
         options.CrashedLastRun = () => JavaSdk.Sentry.IsCrashedLastRun()?.BooleanValue() is true;
         options.EnableScopeSync = true;
         options.ScopeObserver = new AndroidScopeObserver(options);