feat: implement dynamic & static tags (#16)

* implement dynamic tags
* implement static tags
* reuse bits from upstream for profile_id implementation
* fix github actions, add new actions for managed helper

Author: korniltsev

.github/workflows/build_linux.yml renamed to .github/workflows/build_linux_profiler.yml

@@ -1,13 +1,13 @@
-name: Build linux
+name: Build linux profiler
 
 on:
   push:
-    branches: [master]
+    branches: [main]
   pull_request:
-    branches: [master]
+    branches: [main]
 
 jobs:
-  build-linux:
+  build-linux-profiler:
     runs-on: ubuntu-latest
     steps:
       -
@@ -22,7 +22,7 @@ jobs:
           tags: test-image:latest
           push: false
           file: ./Pyroscope.Dockerfile
-      - name: Build profiler
+      - name: Build linux profiler
         uses: addnab/docker-run-action@v3
         with:
           image: test-image:latest

.github/workflows/build_managed_helper.yml

@@ -0,0 +1,22 @@
+name: Build managed helper
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build-managed-helper:
+    runs-on: ubuntu-latest
+    steps:
+      -
+        name: Checkout
+        uses: actions/checkout@v2
+        with:
+          submodules: 'true'
+      - uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: '6.0'
+      - run: dotnet build -c Release
+        working-directory: Pyroscope

.github/workflows/tag_linux.yml

@@ -1,12 +1,12 @@
-name: Release linux
+name: Release linux profiler
 
 on:
   push:
     tags:
       - v0.**-pyroscope
 
 jobs:
-  release-linux:
+  release-linux-profiler:
     runs-on: ubuntu-latest
     steps:
       -

.github/workflows/tag_managed_helper.yml

@@ -0,0 +1,33 @@
+name: Release managed helper
+
+on:
+  push:
+    tags:
+      - v0.**-pyroscope
+
+jobs:
+  release-managed-helper:
+    runs-on: ubuntu-latest
+    steps:
+      -
+        name: Checkout
+        uses: actions/checkout@v2
+        with:
+          submodules: 'true'
+      - uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: '6.0'
+      - run: dotnet build -c Release
+        working-directory: Pyroscope
+      - name: Publish the package to nuget.org
+        run: dotnet nuget push Pyroscope/bin/Release/*.nupkg -k $NUGET_AUTH_TOKEN -s https://api.nuget.org/v3/index.json
+        working-directory: Pyroscope
+        env:
+          NUGET_AUTH_TOKEN: ${{ secrets.NUGET_API_KEY }}
+      - name: Release
+        uses: softprops/action-gh-release@v1
+        if: startsWith(github.ref, 'refs/tags/')
+        with:
+          files: |
+            ./Pyroscope/Pyroscope/bin/Release/net6.0/Pyroscope.dll
+            ./Pyroscope/Pyroscope/bin/Release/Pyroscope*.nupkg

Pyroscope/Pyroscope.sln

@@ -0,0 +1,16 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Pyroscope", "Pyroscope\Pyroscope.csproj", "{7DA9EFD3-9B8D-4DF4-A1D1-108D43B53BBD}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{7DA9EFD3-9B8D-4DF4-A1D1-108D43B53BBD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7DA9EFD3-9B8D-4DF4-A1D1-108D43B53BBD}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7DA9EFD3-9B8D-4DF4-A1D1-108D43B53BBD}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7DA9EFD3-9B8D-4DF4-A1D1-108D43B53BBD}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal

Pyroscope/Pyroscope/ContextTracker.cs

@@ -0,0 +1,136 @@
+// <copyright file="ContextTracker.cs" company="Datadog">
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
+// </copyright>
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Pyroscope
+{
+    internal class ContextTracker 
+    {
+        
+
+        private readonly ProfilerStatus _status;
+        
+        
+        /// <summary>
+        /// _traceContextPtr points to a structure with this layout
+        /// The structure is as follow:
+        /// offset size(bytes)
+        ///                    |--------------------|
+        ///   0        8       |     WriteGuard     |    // 8-byte for the alignment
+        ///                    |--------------------|
+        ///   8        8       | Local Root Span Id |
+        ///                    |--------------------|
+        ///   16       8       |       Span Id      |
+        ///                    |--------------------|
+        /// This allows us to inform the profiler sampling thread when we are writing or not the data
+        /// and avoid torn read/write (Using memory barriers).
+        /// We take advantage of this layout in SpanContext.Write
+        /// </summary>
+        private readonly ThreadLocal<IntPtr> _traceContextPtr;
+
+        
+        public ContextTracker(ProfilerStatus status)
+        {
+            _status = status;
+            _traceContextPtr = new ThreadLocal<IntPtr>();
+        }
+
+        public bool IsEnabled
+        {
+            get
+            {
+                return _status.IsProfilerReady;
+            }
+        }
+
+        public void Set(ulong localRootSpanId, ulong spanId)
+        {
+            WriteToNative(new SpanContext(localRootSpanId, spanId));
+        }
+
+
+        public void Reset()
+        {
+            WriteToNative(SpanContext.Zero);
+        }
+
+        private void EnsureIsInitialized()
+        {
+            if (_traceContextPtr.IsValueCreated)
+            {
+                return;
+            }
+
+            try
+            {
+                _traceContextPtr.Value = NativeInterop.GetTraceContextNativePointer();
+            }
+            catch (Exception)
+            {
+                _traceContextPtr.Value = IntPtr.Zero;
+            }
+        }
+
+        private void WriteToNative(in SpanContext ctx)
+        {
+            if (!IsEnabled)
+            {
+                return;
+            }
+
+            EnsureIsInitialized();
+
+            var ctxPtr = _traceContextPtr.Value;
+
+            if (ctxPtr == IntPtr.Zero)
+            {
+                return;
+            }
+
+            try
+            {
+                ctx.Write(ctxPtr);
+            }
+            catch (Exception)
+            {
+                
+            }
+        }
+
+        // See the description and the layout depicted above
+        private readonly struct SpanContext
+        {
+            public static readonly SpanContext Zero = new(0, 0);
+
+            public readonly ulong LocalRootSpanId;
+            public readonly ulong SpanId;
+
+            public SpanContext(ulong localRootSpanId, ulong spanId)
+            {
+                LocalRootSpanId = localRootSpanId;
+                SpanId = spanId;
+            }
+
+            [MethodImpl(MethodImplOptions.NoInlining)]
+            public void Write(IntPtr ptr)
+            {
+                // Set the WriteGuard
+                Marshal.WriteInt64(ptr, 1);
+                Thread.MemoryBarrier();
+
+                // Using WriteInt64 to write 2 long values is ~8x faster than using Marshal.StructureToPtr
+                // For the offset, we follow the layout depicted above
+                Marshal.WriteInt64(ptr + 8, (long)LocalRootSpanId);
+                // Marshal.WriteInt64(ptr + 16, (long)SpanId);
+
+                // Reset the WriteGuard
+                Thread.MemoryBarrier();
+                Marshal.WriteInt64(ptr, 0);
+            }
+        }
+    }
+}

Pyroscope/Pyroscope/EnvironmentHelpers.cs

@@ -0,0 +1,57 @@
+// <copyright file="EnvironmentHelpers.cs" company="Datadog">
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
+// </copyright>
+
+namespace Pyroscope
+{
+    /// <summary>
+    /// Helpers to access environment variables
+    /// </summary>
+    internal static class EnvironmentHelpers
+    {
+
+
+        /// <summary>
+        /// Safe wrapper around Environment.GetEnvironmentVariable
+        /// </summary>
+        /// <param name="key">Name of the environment variable to fetch</param>
+        /// <param name="defaultValue">Value to return in case of error</param>
+        /// <returns>The value of the environment variable, or the default value if an error occured</returns>
+        public static string? GetEnvironmentVariable(string key, string? defaultValue = null)
+        {
+            var keys = new List<string>();
+            keys.Add(key);
+            if (key.StartsWith("DD_"))
+            {
+                var baseName = key.Substring(3);
+                keys.Add(baseName);
+                keys.Add("PYROSCOPE_" + baseName);
+            }
+
+            var error = false;
+            for (var i = 0; i < keys.Count; i++)
+            {
+                try
+                {
+                    var val = Environment.GetEnvironmentVariable(keys[i]);
+                    if (val != null)
+                    {
+                        return val;
+                    }
+                }
+                catch (Exception)
+                {
+                    error = true;
+                }
+            }
+            if (error)
+            {
+                return defaultValue;
+            }
+            return null;
+        }
+
+       
+    }
+}

Pyroscope/Pyroscope/LabelSet.cs

@@ -0,0 +1,59 @@
+namespace Pyroscope;
+
+public class LabelSet
+{
+    private readonly Dictionary<string, string> _labels;
+    internal readonly LabelSet? Previous;
+
+    public static readonly LabelSet Empty = new(new Dictionary<string, string>());
+
+    private LabelSet(Dictionary<string, string> labels)
+    {
+        _labels = labels;
+        Previous = null;
+    }
+
+
+    private LabelSet(LabelSet previous, Dictionary<string, string> labels)
+    {
+        _labels = labels;
+        Previous = previous;
+    }
+
+    public void Activate()
+    {
+        Profiler.Instance.ClearDynamicTags();
+        foreach (var (key, value) in _labels)
+        {
+            Profiler.Instance.SetDynamicTag(key, value);
+        }
+    }
+
+    public Builder BuildUpon()
+    {
+        return new Builder(this);
+    }
+
+    public class Builder
+    {
+        private readonly LabelSet _prev;
+        private readonly Dictionary<string, string> _labels;
+
+        public Builder(LabelSet prev)
+        {
+            _prev = prev;
+            _labels = new Dictionary<string, string>(_prev._labels);
+        }
+
+        public Builder Add(string k, string v)
+        {
+            _labels[k] = v;
+            return this;
+        }
+
+        public LabelSet Build()
+        {
+            return new LabelSet(_prev, _labels);
+        }
+    }
+}

Pyroscope/Pyroscope/LabelsWrapper.cs

@@ -0,0 +1,24 @@
+namespace Pyroscope;
+
+public static class LabelsWrapper
+{
+    public static void Do(LabelSet labels, Action a)
+    {
+        try
+        {
+            labels.Activate();
+            a.Invoke();
+        }
+        finally
+        {
+            if (labels.Previous == null)
+            {
+                Profiler.Instance.ClearDynamicTags();
+            }
+            else
+            {
+                labels.Previous.Activate();
+            }
+        }
+    }
+}