feat: sync environment to the native layers

src/Sentry/IScopeObserver.cs

@@ -35,6 +35,11 @@ public interface IScopeObserver
     /// </summary>
     public void SetTrace(SentryId traceId, SpanId parentSpanId);
 
+    /// <summary>
+    /// Sets the environment.
+    /// </summary>
+    public void SetEnvironment(string? environment);
+
     /// <summary>
     /// Adds an attachment.
     /// </summary>

src/Sentry/Internal/ScopeObserver.cs

@@ -95,6 +95,15 @@ public void SetTrace(SentryId traceId, SpanId parentSpanId)
 
     public abstract void SetTraceImpl(SentryId traceId, SpanId parentSpanId);
 
+    public void SetEnvironment(string? environment)
+    {
+        _options.DiagnosticLogger?.Log(SentryLevel.Debug, 
+            "{0} Scope Sync - Setting Environment e:\"{1}\"", null, _name, environment);
+        SetEnvironmentImpl(environment);
+    }
+
+    public abstract void SetEnvironmentImpl(string? environment);
+
     public void AddAttachment(SentryAttachment attachment)
     {
         _options.DiagnosticLogger?.Log(SentryLevel.Debug,

src/Sentry/Platforms/Android/AndroidScopeObserver.cs

@@ -112,6 +112,18 @@ public void SetTrace(SentryId traceId, SpanId parentSpanId)
         }
     }
 
+    public void SetEnvironment(string? environment)
+    {
+        try
+        {
+            // TODO: Missing corresponding scope-level functionality on the Android SDK
+        }
+        finally
+        {
+            _innerObserver?.SetEnvironment(environment);
+        }
+    }
+
     public void AddAttachment(SentryAttachment attachment)
     {
         try

src/Sentry/Platforms/Cocoa/CocoaScopeObserver.cs

@@ -120,6 +120,18 @@ public void SetTrace(SentryId traceId, SpanId parentSpanId)
         }
     }
 
+    public void SetEnvironment(string? environment)
+    {
+        try
+        {
+            SentryCocoaSdk.ConfigureScope(scope => scope.SetEnvironment(environment));
+        }
+        finally
+        {
+            _innerObserver?.SetEnvironment(environment);
+        }
+    }
+
     public void AddAttachment(SentryAttachment attachment)
     {
         try

src/Sentry/Platforms/Native/CFunctions.cs

@@ -251,6 +251,9 @@ internal static string GetCacheDirectory(SentryOptions options)
     [DllImport("sentry-native")]
     internal static extern void sentry_set_trace(string traceId, string parentSpanId);
 
+    [DllImport("sentry-native")]
+    internal static extern void sentry_set_environment(string? environment);
+
     internal static Dictionary<long, DebugImage> LoadDebugImages(IDiagnosticLogger? logger)
     {
         // It only makes sense to load them once because they're cached on the native side anyway. We could force

src/Sentry/Platforms/Native/NativeScopeObserver.cs

@@ -43,6 +43,9 @@ public override void SetUserImpl(SentryUser user)
     public override void SetTraceImpl(SentryId traceId, SpanId parentSpanId) =>
         C.sentry_set_trace(traceId.ToString(), parentSpanId.ToString());
 
+    public override void SetEnvironmentImpl(string? environment) =>
+        C.sentry_set_environment(environment);
+
     public override void AddAttachmentImpl(SentryAttachment attachment)
     {
         // TODO: Missing corresponding functionality on the Native SDK

src/Sentry/Scope.cs

@@ -144,8 +144,25 @@ public SentryUser User
     /// <inheritdoc />
     public string? Distribution { get; set; }
 
+    private string? _environment;
+
     /// <inheritdoc />
-    public string? Environment { get; set; }
+    public string? Environment
+    {
+        get => _environment;
+        set
+        {
+            if (_environment != value)
+            {
+                _environment = value;
+                if (Options.EnableScopeSync &&
+                    Options.ScopeObserver is { } observer)
+                {
+                    observer.SetEnvironment(value);
+                }
+            }
+        }
+    }
 
     // TransactionName is kept for legacy purposes because
     // SentryEvent still makes use of it.

test/Sentry.Tests/ScopeTests.cs

@@ -696,6 +696,69 @@
         observer.Received(expectedCount).AddBreadcrumb(Arg.Is(breadcrumb));
     }
 
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void SetEnvironment_ObserverExist_ObserverSetsEnvironmentIfEnabled(bool observerEnable)
+    {
+        // Arrange
+        var observer = Substitute.For<IScopeObserver>();
+        var scope = new Scope(new SentryOptions
+        {
+            ScopeObserver = observer,
+            EnableScopeSync = observerEnable
+        });
+        var expectedEnvironment = "staging";
+        var expectedCount = observerEnable ? 1 : 0;
+
+        // Act
+        scope.Environment = expectedEnvironment;
+
+        // Assert
+        observer.Received(expectedCount).SetEnvironment(Arg.Is(expectedEnvironment));
+    }
+
+    [Fact]
+    public void SetEnvironment_Null_ObserverClearsEnvironment()
+    {
+        // Arrange
+        var observer = Substitute.For<IScopeObserver>();
+        var scope = new Scope(new SentryOptions
+        {
+            ScopeObserver = observer,
+            EnableScopeSync = true
+        })
+        {
+            Environment = "staging"
+        };
+        observer.ClearReceivedCalls();
+
+        // Act
+        scope.Environment = null;
+
+        // Assert
+        observer.Received(1).SetEnvironment(Arg.Is((string?)null));
+    }
+
+    [Fact]
+    public void SetEnvironment_SameValue_ObserverNotifiedOnce()
+    {
+        // Arrange
+        var observer = Substitute.For<IScopeObserver>();
+        var scope = new Scope(new SentryOptions
+        {
+            ScopeObserver = observer,
+            EnableScopeSync = true
+        });
+
+        // Act
+        scope.Environment = "staging";
+        scope.Environment = "staging";
+
+        // Assert
+        observer.Received(1).SetEnvironment(Arg.Is("staging"));
+    }
+
     [Fact]
     public void Filtered_tags_are_not_set()
     {