Implement process and instance isolation

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+### Features
+
+- Implement process and instance isolation so that multiple instances of the Sentry SDK can be instantiated inside the same process when using the Caching Transport ([#4498](https://github.com/getsentry/sentry-dotnet/pull/4498))
 ### BREAKING CHANGES
 
 - Spans and Transactions now implement `IDisposable` so that they can be used with `using` statements/declarations that will automatically finish the span with a status of OK when it passes out of scope, if it has not already been finished, to be consistent with `Activity` classes when using OpenTelemetry ([#4627](https://github.com/getsentry/sentry-dotnet/pull/4627))

src/Sentry/GlobalSessionManager.cs

@@ -33,10 +33,7 @@ public GlobalSessionManager(
         _clock = clock ?? SystemClock.Clock;
         _persistedSessionProvider = persistedSessionProvider
                                     ?? (filePath => Json.Load(_options.FileSystem, filePath, PersistedSessionUpdate.FromJson));
-
-        // TODO: session file should really be process-isolated, but we
-        // don't have a proper mechanism for that right now.
-        _persistenceDirectoryPath = options.TryGetDsnSpecificCacheDirectoryPath();
+        _persistenceDirectoryPath = options.GetIsolatedCacheDirectoryPath();
     }
 
     // Take pause timestamp directly instead of referencing _lastPauseTimestamp to avoid

src/Sentry/Internal/CacheDirectoryCoordinator.cs

@@ -0,0 +1,146 @@
+using Sentry.Extensibility;
+using Sentry.Internal.Extensions;
+
+namespace Sentry.Internal;
+
+internal class CacheDirectoryCoordinator : IDisposable
+{
+    private readonly IDiagnosticLogger? _logger;
+    private readonly IFileSystem _fileSystem;
+    private readonly Lock _lock = new();
+
+    private Stream? _lockStream;
+    private readonly string _lockFilePath;
+
+    private volatile bool _acquired;
+    private volatile bool _disposed;
+
+    public CacheDirectoryCoordinator(string cacheDir, IDiagnosticLogger? logger, IFileSystem fileSystem)
+    {
+        _logger = logger;
+        _fileSystem = fileSystem;
+        // Note this creates a lock file in the cache directory's parent directory... not in the cache directory itself
+        _lockFilePath = $"{cacheDir}.lock";
+    }
+
+    public bool TryAcquire()
+    {
+        if (_acquired)
+        {
+            return true;
+        }
+
+        lock (_lock)
+        {
+            if (_acquired)
+            {
+                return true;
+            }
+
+            if (_disposed)
+            {
+                return false;
+            }
+
+            try
+            {
+                var baseDir = Path.GetDirectoryName(_lockFilePath);
+                if (!string.IsNullOrWhiteSpace(baseDir))
+                {
+                    _fileSystem.CreateDirectory(baseDir);
+                }
+                _acquired = _fileSystem.TryCreateLockFile(_lockFilePath, out _lockStream);
+                return _acquired;
+            }
+            catch (Exception ex)
+            {
+                _logger?.LogDebug("Unable to acquire cache directory lock", ex);
+            }
+            finally
+            {
+                if (!_acquired && _lockStream is not null)
+                {
+                    try
+                    { _lockStream.Dispose(); }
+                    catch
+                    {
+                        // Ignore
+                    }
+                    _lockStream = null;
+                }
+            }
+
+            return false;
+        }
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        lock (_lock)
+        {
+            _disposed = true;
+
+            if (_acquired)
+            {
+                try
+                {
+                    _lockStream?.Close();
+                }
+                catch (Exception ex)
+                {
+                    _logger?.LogError("Error releasing the cache directory file lock.", ex);
+                }
+            }
+
+            try
+            {
+                _lockStream?.Dispose();
+            }
+            catch (Exception ex)
+            {
+                _logger?.LogError("Error disposing cache lock stream.", ex);
+            }
+            _lockStream = null;
+        }
+    }
+}
+
+internal static class CacheDirectoryHelper
+{
+    public const string IsolatedCacheDirectoryPrefix = "isolated_";
+
+    internal static string? GetBaseCacheDirectoryPath(this SentryOptions options) =>
+        string.IsNullOrWhiteSpace(options.CacheDirectoryPath)
+            ? null
+            : Path.Combine(options.CacheDirectoryPath, "Sentry");
+
+    internal static string? GetIsolatedFolderName(this SentryOptions options)
+    {
+        var stringBuilder = new StringBuilder(IsolatedCacheDirectoryPrefix);
+#if IOS || ANDROID
+        // On iOS or Android the app is already sandboxed, so there's no risk of sending data to another Sentry's DSN.
+        // However, users may still initiate the SDK multiple times within the process, so we need an InitCounter
+        stringBuilder.Append(options.InitCounter.Count);
+#else
+        if (string.IsNullOrWhiteSpace(options.Dsn))
+        {
+            return null;
+        }
+        var processId = options.ProcessIdResolver.Invoke() ?? 0;
+        stringBuilder.AppendJoin('_', options.Dsn.GetHashString(), processId.ToString(),
+            options.InitCounter.Count.ToString());
+#endif
+        return stringBuilder.ToString();
+    }
+
+    internal static string? GetIsolatedCacheDirectoryPath(this SentryOptions options) =>
+        GetBaseCacheDirectoryPath(options) is not { } baseCacheDir
+        || GetIsolatedFolderName(options) is not { } isolatedFolderName
+            ? null
+            : Path.Combine(baseCacheDir, isolatedFolderName);
+}

src/Sentry/Internal/FileSystemBase.cs

@@ -2,6 +2,9 @@ namespace Sentry.Internal;
 
 internal abstract class FileSystemBase : IFileSystem
 {
+    public IEnumerable<string> EnumerateDirectories(string path, string searchPattern) =>
+        Directory.EnumerateDirectories(path, searchPattern);
+
     public IEnumerable<string> EnumerateFiles(string path) => Directory.EnumerateFiles(path);
 
     public IEnumerable<string> EnumerateFiles(string path, string searchPattern) =>
@@ -23,6 +26,7 @@ public IEnumerable<string> EnumerateFiles(string path, string searchPattern, Sea
     public abstract bool CreateDirectory(string path);
     public abstract bool DeleteDirectory(string path, bool recursive = false);
     public abstract bool CreateFileForWriting(string path, out Stream fileStream);
+    public abstract bool TryCreateLockFile(string path, out Stream fileStream);
     public abstract bool WriteAllTextToFile(string path, string contents);
     public abstract bool MoveFile(string sourceFileName, string destFileName, bool overwrite = false);
     public abstract bool DeleteFile(string path);