[Exporter.Geneva] Refactor ConsoleCommand utility class (#2654)

Author: xiang17

opentelemetry-dotnet-contrib.sln

@@ -357,10 +357,12 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OpenTelemetry.Contrib.Share
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Shared", "Shared", "{70CA77D4-5D7F-4D70-A6B5-8AAC07A8EA3C}"
 	ProjectSection(SolutionItems) = preProject
+		test\Shared\ConsoleCommand.cs = test\Shared\ConsoleCommand.cs
 		test\Shared\CustomTextMapPropagator.cs = test\Shared\CustomTextMapPropagator.cs
 		test\Shared\EnabledOnDockerPlatformTheoryAttribute.cs = test\Shared\EnabledOnDockerPlatformTheoryAttribute.cs
 		test\Shared\EventSourceTestHelper.cs = test\Shared\EventSourceTestHelper.cs
 		test\Shared\InMemoryEventListener.cs = test\Shared\InMemoryEventListener.cs
+		test\Shared\PerfTracepointListener.cs = test\Shared\PerfTracepointListener.cs
 		test\Shared\PlatformHelpers.cs = test\Shared\PlatformHelpers.cs
 		test\Shared\SkipUnlessEnvVarFoundFactAttribute.cs = test\Shared\SkipUnlessEnvVarFoundFactAttribute.cs
 		test\Shared\SkipUnlessEnvVarFoundTheoryAttribute.cs = test\Shared\SkipUnlessEnvVarFoundTheoryAttribute.cs

test/OpenTelemetry.Exporter.Geneva.Tests/OpenTelemetry.Exporter.Geneva.Tests.csproj

@@ -23,6 +23,8 @@
   </ItemGroup>
 
   <ItemGroup>
+    <Compile Include="$(RepoRoot)\test\Shared\ConsoleCommand.cs" Link="Includes\ConsoleCommand.cs" />
+    <Compile Include="$(RepoRoot)\test\Shared\PerfTracepointListener.cs" Link="Includes\PerfTracepointListener.cs" />
     <Compile Include="$(RepoRoot)\test\Shared\PlatformHelpers.cs" Link="Includes\PlatformHelpers.cs" />
   </ItemGroup>
 

test/OpenTelemetry.Exporter.Geneva.Tests/UnixUserEventsDataTransportTests.cs

@@ -3,11 +3,10 @@
 
 #if NET6_0_OR_GREATER
 
-using System.Diagnostics;
 using System.Globalization;
-using System.Text.RegularExpressions;
 using Microsoft.LinuxTracepoints.Provider;
 using OpenTelemetry.Exporter.Geneva.Transports;
+using OpenTelemetry.Tests;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -246,231 +245,6 @@ private static void EnsureUserEventsEnabled()
             throw new NotSupportedException("Kernel does not support user_events. Verify your distribution/kernel supports user_events: https://docs.kernel.org/trace/user_events.html.");
         }
     }
-
-    private sealed class ConsoleCommand : IDisposable
-    {
-        private readonly Process process;
-        private readonly List<string> output = [];
-        private readonly List<string> errors = [];
-
-        private ConsoleCommand(
-            string command,
-            string arguments,
-            Action<string>? onOutputReceived,
-            Action<string>? onErrorReceived)
-        {
-            Console.WriteLine($"{command} {arguments}");
-
-            var process = new Process
-            {
-                StartInfo = new()
-                {
-                    FileName = command,
-                    Arguments = arguments,
-                    RedirectStandardOutput = true,
-                    RedirectStandardError = true,
-                    RedirectStandardInput = false,
-                },
-            };
-
-            process.OutputDataReceived += (sender, args) =>
-            {
-                if (!string.IsNullOrEmpty(args.Data))
-                {
-                    this.output.Add(args.Data);
-                    Console.WriteLine($"{command} {arguments} [OUT] {args.Data}");
-
-                    onOutputReceived?.Invoke(args.Data);
-                }
-            };
-
-            process.ErrorDataReceived += (sender, args) =>
-            {
-                if (!string.IsNullOrEmpty(args.Data))
-                {
-                    this.errors.Add(args.Data);
-                    Console.WriteLine($"[ERR] {args.Data}");
-
-                    onErrorReceived?.Invoke(args.Data);
-                }
-            };
-
-            process.Start();
-
-            process.BeginOutputReadLine();
-            process.BeginErrorReadLine();
-
-            this.process = process;
-        }
-
-        public IEnumerable<string> Output => this.output;
-
-        public IEnumerable<string> Errors => this.errors;
-
-        public static IEnumerable<string> Run(
-            string command,
-            string arguments)
-        {
-            Run(command, arguments, out _, out var errors);
-
-            return errors;
-        }
-
-        public static void Run(
-            string command,
-            string arguments,
-            out IEnumerable<string> output,
-            out IEnumerable<string> errors)
-        {
-            var consoleCommand = new ConsoleCommand(command, arguments, onOutputReceived: null, onErrorReceived: null);
-            consoleCommand.Dispose();
-
-            output = consoleCommand.Output;
-            errors = consoleCommand.Errors;
-        }
-
-        public static ConsoleCommand Start(
-            string command,
-            string arguments,
-            Action<string>? onOutputReceived = null,
-            Action<string>? onErrorReceived = null)
-            => new(command, arguments, onOutputReceived, onErrorReceived);
-
-        public void Kill()
-        {
-            this.process.Kill();
-        }
-
-        public void Dispose()
-        {
-            this.process.WaitForExit();
-
-            this.process.CancelOutputRead();
-            this.process.CancelErrorRead();
-
-            this.process.Dispose();
-        }
-    }
-
-    // Warning: Do NOT use this class/design to listen/read user_events in prod.
-    // It is a hack to workaround lack of decent bits for listening. Hopefully
-    // this can be removed if/when
-    // https://github.com/microsoft/LinuxTracepoints-Net/ has listening bits or
-    // dotnet/runtime supports user_events (both reading & writing) directly.
-    private sealed class PerfTracepointListener : IDisposable
-    {
-        private readonly string name;
-        private readonly PerfTracepoint tracepoint;
-        private readonly ConsoleCommand catCommand;
-        private readonly Regex eventRegex = new("(\\w+?)=([\\w\\(\\) .,-]*)( |$)", RegexOptions.Compiled);
-
-        public PerfTracepointListener(string name, string nameArgs)
-        {
-            this.name = name;
-
-            this.tracepoint = new PerfTracepoint(nameArgs);
-
-            // EACCES (13): Permission denied
-            if (this.tracepoint.RegisterResult == 13)
-            {
-                throw new UnauthorizedAccessException($"Tracepoint could not be registered: '{this.tracepoint.RegisterResult}'. Permission denied.");
-            }
-
-            if (this.tracepoint.RegisterResult != 0)
-            {
-                throw new NotSupportedException($"Tracepoint could not be registered: '{this.tracepoint.RegisterResult}'");
-            }
-
-            this.catCommand = ConsoleCommand.Start("cat", "/sys/kernel/debug/tracing/trace_pipe", onOutputReceived: this.OnCatOutputReceived);
-            if (this.catCommand.Errors.Any())
-            {
-                throw new InvalidOperationException($"Could not read '{name}' tracepoints");
-            }
-        }
-
-        public List<Dictionary<string, string>> Events { get; } = [];
-
-        public bool IsEnabled()
-        {
-            ConsoleCommand.Run(
-                "cat",
-                $"/sys/kernel/tracing/events/user_events/{this.name}/enable",
-                out var output,
-                out var errors);
-
-            return errors.Any() || output.Count() != 1
-                ? throw new InvalidOperationException($"Could not determine if '{this.name}' tracepoint is enabled")
-                : output.First() != "0";
-        }
-
-        public void Enable()
-        {
-            var errors = ConsoleCommand.Run("sh", @$"-c ""echo '1' > /sys/kernel/tracing/events/user_events/{this.name}/enable""");
-
-            if (errors.Any())
-            {
-                throw new InvalidOperationException($"Could not enable '{this.name}' tracepoint");
-            }
-        }
-
-        public void Disable()
-        {
-            var errors = ConsoleCommand.Run("sh", @$"-c ""echo '0' > /sys/kernel/tracing/events/user_events/{this.name}/enable""");
-
-            if (errors.Any())
-            {
-                throw new InvalidOperationException($"Could not disable '{this.name}' tracepoint");
-            }
-        }
-
-        public void Dispose()
-        {
-            try
-            {
-                if (this.catCommand != null)
-                {
-                    if (this.catCommand.Errors.Any())
-                    {
-                        throw new InvalidOperationException($"Could not read '{this.name}' tracepoints");
-                    }
-
-                    this.catCommand.Kill();
-                    this.catCommand.Dispose();
-                }
-            }
-            finally
-            {
-                this.tracepoint.Dispose();
-            }
-        }
-
-        private void OnCatOutputReceived(string output)
-        {
-            var name = $": {this.name}:";
-
-            var startingPosition = output.IndexOf(name, StringComparison.Ordinal);
-            if (startingPosition < 0)
-            {
-                return;
-            }
-
-            startingPosition += name.Length;
-
-            var matches = this.eventRegex.Matches(output, startingPosition);
-
-            if (matches.Count > 0)
-            {
-                Dictionary<string, string> eventData = new(matches.Count);
-
-                foreach (Match match in matches)
-                {
-                    eventData[match.Groups[1].Value] = match.Groups[2].Value;
-                }
-
-                this.Events.Add(eventData);
-            }
-        }
-    }
 }
 
 #endif

test/Shared/ConsoleCommand.cs

@@ -0,0 +1,111 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Diagnostics;
+
+namespace OpenTelemetry.Tests;
+
+internal sealed class ConsoleCommand : IDisposable
+{
+    private readonly Process process;
+    private readonly List<string> output = [];
+    private readonly List<string> errors = [];
+
+    private ConsoleCommand(
+        string command,
+        string arguments,
+        Action<string>? onOutputReceived,
+        Action<string>? onErrorReceived)
+    {
+        Console.WriteLine($"{command} {arguments}");
+
+        var process = new Process
+        {
+            StartInfo = new()
+            {
+                FileName = command,
+                Arguments = arguments,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                RedirectStandardInput = false,
+            },
+        };
+
+        process.OutputDataReceived += (sender, args) =>
+        {
+            if (!string.IsNullOrEmpty(args.Data))
+            {
+                this.output.Add(args.Data);
+                Console.WriteLine($"{command} {arguments} [OUT] {args.Data}");
+
+                onOutputReceived?.Invoke(args.Data);
+            }
+        };
+
+        process.ErrorDataReceived += (sender, args) =>
+        {
+            if (!string.IsNullOrEmpty(args.Data))
+            {
+                this.errors.Add(args.Data);
+                Console.WriteLine($"[ERR] {args.Data}");
+
+                onErrorReceived?.Invoke(args.Data);
+            }
+        };
+
+        process.Start();
+
+        process.BeginOutputReadLine();
+        process.BeginErrorReadLine();
+
+        this.process = process;
+    }
+
+    public IEnumerable<string> Output => this.output;
+
+    public IEnumerable<string> Errors => this.errors;
+
+    public static IEnumerable<string> Run(
+        string command,
+        string arguments)
+    {
+        Run(command, arguments, out _, out var errors);
+
+        return errors;
+    }
+
+    public static void Run(
+        string command,
+        string arguments,
+        out IEnumerable<string> output,
+        out IEnumerable<string> errors)
+    {
+        var consoleCommand = new ConsoleCommand(command, arguments, onOutputReceived: null, onErrorReceived: null);
+        consoleCommand.Dispose();
+
+        output = consoleCommand.Output;
+        errors = consoleCommand.Errors;
+    }
+
+    public static ConsoleCommand Start(
+        string command,
+        string arguments,
+        Action<string>? onOutputReceived = null,
+        Action<string>? onErrorReceived = null)
+        => new(command, arguments, onOutputReceived, onErrorReceived);
+
+    public void Kill()
+    {
+        this.process.Kill();
+    }
+
+    public void Dispose()
+    {
+        this.process.WaitForExit();
+
+        this.process.CancelOutputRead();
+        this.process.CancelErrorRead();
+
+        this.process.Dispose();
+    }
+}