Add event to RuntimeEventSource for AppContext switches (#57303)

Fixes #56142

src/libraries/System.Private.CoreLib/src/System/AppContext.AnyOS.cs

@@ -1,7 +1,10 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.Tracing;
 using System.IO;
 using System.Reflection;
 
@@ -30,5 +33,52 @@ private static string GetBaseDirectoryCore()
 
  return directory;
  }
+
+ internal static void LogSwitchValues(RuntimeEventSource ev)
+ {
+ if (s_switches is not null)
+ {
+ lock (s_switches)
+ {
+ foreach (KeyValuePair<string, bool> kvp in s_switches)
+ {
+ // Convert bool to int because it's cheaper to log (no boxing)
+ ev.LogAppContextSwitch(kvp.Key, kvp.Value ? 1 : 0);
+ }
+ }
+ }
+
+ if (s_dataStore is not null)
+ {
+ lock (s_dataStore)
+ {
+ if (s_switches is not null)
+ {
+ lock (s_switches)
+ {
+ LogDataStore(ev, s_switches);
+ }
+ }
+ else
+ {
+ LogDataStore(ev, null);
+ }
+
+ static void LogDataStore(RuntimeEventSource ev, Dictionary<string, bool>? switches)
+ {
+ Debug.Assert(s_dataStore is not null);
+ foreach (KeyValuePair<string, object?> kvp in s_dataStore)
+ {
+ if (kvp.Value is string s &&
+ bool.TryParse(s, out bool isEnabled) &&
+ switches?.ContainsKey(kvp.Key) != true)
+ {
+ ev.LogAppContextSwitch(kvp.Key, isEnabled ? 1 : 0);
+ }
+ }
+ }
+ }
+ }
+ }
  }
 }

src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/RuntimeEventSource.cs

@@ -14,6 +14,11 @@ internal sealed partial class RuntimeEventSource : EventSource
  {
  internal const string EventSourceName = "System.Runtime";
 
+ public static class Keywords
+ {
+ public const EventKeywords AppContext = (EventKeywords)0x1;
+ }
+
  private static RuntimeEventSource? s_RuntimeEventSource;
  private PollingCounter? _gcHeapSizeCounter;
  private IncrementingPollingCounter? _gen0GCCounter;
@@ -50,6 +55,17 @@ public static void Initialize()
  // as you can't make a constructor partial.
  private RuntimeEventSource(int _) { }
 
+ private enum EventId : int
+ {
+ AppContextSwitch = 1
+ }
+
+ [Event((int)EventId.AppContextSwitch, Level = EventLevel.Informational, Keywords = Keywords.AppContext)]
+ internal void LogAppContextSwitch(string switchName, int value)
+ {
+ base.WriteEvent((int)EventId.AppContextSwitch, switchName, value);
+ }
+
  protected override void OnEventCommand(EventCommandEventArgs command)
  {
  if (command.Command == EventCommand.Enable)
@@ -87,6 +103,8 @@ protected override void OnEventCommand(EventCommandEventArgs command)
  _ilBytesJittedCounter ??= new PollingCounter("il-bytes-jitted", this, () => System.Runtime.JitInfo.GetCompiledILBytes()) { DisplayName = "IL Bytes Jitted", DisplayUnits = "B" };
  _methodsJittedCounter ??= new PollingCounter("methods-jitted-count", this, () => System.Runtime.JitInfo.GetCompiledMethodCount()) { DisplayName = "Number of Methods Jitted" };
  _jitTimeCounter ??= new IncrementingPollingCounter("time-in-jit", this, () => System.Runtime.JitInfo.GetCompilationTime().TotalMilliseconds) { DisplayName = "Time spent in JIT", DisplayUnits = "ms", DisplayRateTimeScale = new TimeSpan(0, 0, 1) };
+
+ AppContext.LogSwitchValues(this);
  }
 
  }

src/tests/tracing/eventcounter/runtimecounters.cs

@@ -54,7 +54,9 @@ protected override void OnEventSourceCreated(EventSource source)
  {
  Dictionary<string, string> refreshInterval = new Dictionary<string, string>();
  refreshInterval.Add("EventCounterIntervalSec", "1");
- EnableEvents(source, EventLevel.Informational, (EventKeywords)(-1), refreshInterval);
+ EnableEvents(source, EventLevel.Informational,
+ (EventKeywords)(-1 & (~1 /* RuntimeEventSource.Keywords.AppContext */)),
+ refreshInterval);
  }
  }
 
@@ -100,7 +102,7 @@ public static int Main(string[] args)
  // Create an EventListener.
  using (RuntimeCounterListener myListener = new RuntimeCounterListener())
  {
- Thread.Sleep(3000); 
+ Thread.Sleep(3000);
  if (myListener.Verify())
  {
  Console.WriteLine("Test passed");

src/tests/tracing/runtimeeventsource/NativeRuntimeEventSourceTest.cs

@@ -0,0 +1,114 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.IO;
+using System.Diagnostics.Tracing;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using Tracing.Tests.Common;
+
+namespace Tracing.Tests
+{
+ public sealed class NativeRuntimeEventSourceTest
+ {
+ static int Main(string[] args)
+ {
+ SimpleEventListener.EnableKeywords = (EventKeywords)0;
+ using (SimpleEventListener noEventsListener = new SimpleEventListener("NoEvents"))
+ {
+ // Create an EventListener.
+ SimpleEventListener.EnableKeywords = (EventKeywords)0x4c14fccbd;
+ using (SimpleEventListener listener = new SimpleEventListener("Simple"))
+ {
+ // Trigger the allocator task.
+ System.Threading.Tasks.Task.Run(new Action(Allocator));
+
+ // Wait for events.
+ Thread.Sleep(1000);
+
+ // Generate some GC events.
+ GC.Collect(2, GCCollectionMode.Forced);
+
+ // Wait for more events.
+ Thread.Sleep(1000);
+
+ // Ensure that we've seen some events.
+ Assert.True("listener.EventCount > 0", listener.EventCount > 0);
+ }
+
+ // Generate some more GC events.
+ GC.Collect(2, GCCollectionMode.Forced);
+
+ // Ensure that we've seen no events.
+ Assert.True("noEventsListener.EventCount == 0", noEventsListener.EventCount == 0);
+ }
+
+ return 100;
+ }
+
+ private static void Allocator()
+ {
+ while (true)
+ {
+ for(int i=0; i<1000; i++)
+ GC.KeepAlive(new object());
+
+ Thread.Sleep(10);
+ }
+ }
+ }
+
+ internal sealed class SimpleEventListener : EventListener
+ {
+ private string m_name;
+
+ // Keep track of the set of keywords to be enabled.
+ public static EventKeywords EnableKeywords
+ {
+ get;
+ set;
+ }
+
+ public SimpleEventListener(string name)
+ {
+ m_name = name;
+ }
+
+ public int EventCount { get; private set; } = 0;
+
+ protected override void OnEventSourceCreated(EventSource eventSource)
+ {
+ if (eventSource.Name.Equals("Microsoft-Windows-DotNETRuntime"))
+ {
+ if (EnableKeywords != 0)
+ {
+ // Enable events.
+ EnableEvents(eventSource, EventLevel.Verbose, EnableKeywords);
+ }
+ else
+ {
+ // Enable the provider, but not any keywords, so we should get no events as long as no rundown occurs.
+ EnableEvents(eventSource, EventLevel.Critical, EnableKeywords);
+ }
+ }
+ }
+
+ protected override void OnEventWritten(EventWrittenEventArgs eventData)
+ {
+ Console.WriteLine($"[{m_name}] ThreadID = {eventData.OSThreadId} ID = {eventData.EventId} Name = {eventData.EventName}");
+ Console.WriteLine($"TimeStamp: {eventData.TimeStamp.ToLocalTime()}");
+ Console.WriteLine($"LocalTime: {DateTime.Now}");
+ Console.WriteLine($"Difference: {DateTime.UtcNow - eventData.TimeStamp}");
+ Assert.True("eventData.TimeStamp <= DateTime.UtcNow", eventData.TimeStamp <= DateTime.UtcNow);
+ for (int i = 0; i < eventData.Payload.Count; i++)
+ {
+ string payloadString = eventData.Payload[i] != null ? eventData.Payload[i].ToString() : string.Empty;
+ Console.WriteLine($"\tName = \"{eventData.PayloadNames[i]}\" Value = \"{payloadString}\"");
+ }
+ Console.WriteLine("\n");
+
+ EventCount++;
+ }
+ }
+}