updated decorator implementation

Author: doppleware

Helpers/Attributes/ActivitiesAttributesAttribute.cs

@@ -0,0 +1,65 @@
+namespace OpenTelemetry.Instrumentation.Digma.Helpers.Attributes;
+
+/// <summary>
+/// An Attribute 
+/// </summary>
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = false)]
+public class ActivitiesAttributesAttribute : Attribute
+{
+    public IDictionary<string, string> Attributes { get; }
+    /// <summary>
+    /// Define a set of attributes that will be included with every Activity
+    /// created by the TracingDecorator for this object
+    /// Example usage:
+    /// 
+    /// ActivitiesAttribute("some_attribute:some_value", "someother_attribute, "some_other_value")
+    /// 
+    /// </summary>
+    /// <param name="extraAttributes">A set of attributes defined as "key:value"</param>
+    public ActivitiesAttributesAttribute(params string[] extraAttributes)
+    {
+        Attributes =TraceAttributesInputsFormat.ActivityAttributesStringsToDictionary(extraAttributes);
+
+    }
+}
+
+internal static class TraceAttributesInputsFormat
+{
+    internal static IDictionary<string, string> ActivityAttributesStringsToDictionary(params string[] attributes)
+    {
+        if (!attributes.Any())
+        {
+            return new Dictionary<string, string>();
+        }
+        var attributeFragements = attributes
+            .Select(x => x.Split(":")).ToArray();
+        
+        EnsureAttributeSyntax(attributes, attributeFragements);
+
+        EnsureUniqueKeys(attributes, attributeFragements);
+
+        return attributeFragements.ToDictionary(x => x[0], x => x[1]);
+        
+    }
+
+    private static void EnsureUniqueKeys(string[] attributes, string[][] attributeFragements)
+    {
+        var attributeKeys = attributeFragements.Select(x => x[0]).ToArray();
+        if (attributeKeys.Length != attributeKeys.Distinct().ToArray().Length)
+        {
+            throw new ArgumentException($"Attribute keys must be unique. Provided value was: " +
+                                        $"{String.Join(',', attributes)}");
+        }
+    }
+
+    private static void EnsureAttributeSyntax(string[] attributes, string[][] attributeFragements)
+    {
+        var illegalFragments = attributeFragements.Where(x => x.Length != 2);
+        if (illegalFragments.Any())
+        {
+            throw new ArgumentException(
+                $"Illegal attribute values provided in value:{attributes}" +
+                " The correct syntax is \"key:value\"");
+        }
+    }
+}

Helpers/Attributes/NoActivityAttribute.cs

@@ -0,0 +1,7 @@
+namespace OpenTelemetry.Instrumentation.Digma.Helpers.Attributes;
+
+[AttributeUsage(AttributeTargets.Method, Inherited = false)]
+public class NoActivityAttribute : Attribute
+{
+    
+}

Helpers/Attributes/TraceActivityAttribute.cs

@@ -0,0 +1,15 @@
+namespace OpenTelemetry.Instrumentation.Digma.Helpers.Attributes;
+
+
+[AttributeUsage(AttributeTargets.Method, Inherited = false)]
+public class TraceActivityAttribute : Attribute
+{
+    public string? Name { get; }
+    public bool RecordExceptions { get; }
+    
+    public TraceActivityAttribute(string? name=null, bool recordExceptions=true)
+    {
+        Name = name;
+        RecordExceptions = recordExceptions;
+    }
+}

Helpers/SpanNamingSchema.cs

@@ -0,0 +1,24 @@
+using System.Reflection;
+
+namespace OpenTelemetry.Instrumentation.Digma.Helpers;
+
+public interface ISpanNamingSchema
+{
+    public string GetSpanName(Type classType, MethodInfo method);
+}
+
+public class MethodFullNameSchema : ISpanNamingSchema
+{
+    public string GetSpanName(Type classType, MethodInfo method)
+    {
+        return $"{classType.FullName}.{method.Name}";
+    }
+}
+
+public class ClassAndMethodNameSchema : ISpanNamingSchema
+{
+    public string GetSpanName(Type classType, MethodInfo method)
+    {
+        return $"{classType.Name}.{method.Name}";
+    }
+}

Helpers/TracingDecorator.cs

@@ -0,0 +1,86 @@
+using System.Diagnostics;
+using System.Reflection;
+using OpenTelemetry.Instrumentation.Digma.Helpers.Attributes;
+using OpenTelemetry.Trace;
+
+namespace OpenTelemetry.Instrumentation.Digma.Helpers;
+
+public class TraceDecorator<TDecorated> : DispatchProxy where TDecorated : class
+{
+    
+    private ActivitySource _activity;
+    private TDecorated _decorated;
+    private ISpanNamingSchema _namingSchema = new MethodFullNameSchema();
+    private bool _decorateAllMethods = true;
+
+    /// <summary>
+    /// Creates a new TraceDecorator instance wrapping the specific object and implementing the TDecorated interface 
+    /// </summary>
+    /// <param name="decorated"></param>
+    /// <param name="spanNamingSchema"></param>
+    /// <param name="decorateAllMethods"></param>
+    /// <returns></returns>
+    public static TDecorated Create(TDecorated decorated, ISpanNamingSchema? spanNamingSchema=null, 
+                                    bool decorateAllMethods=true)
+    {
+        object proxy = Create<TDecorated, TraceDecorator<TDecorated>>()!;
+        ((TraceDecorator<TDecorated>)proxy!).SetParameters(decorated, spanNamingSchema,decorateAllMethods);
+
+        return (TDecorated)proxy;
+    }
+
+    private void SetParameters(TDecorated decorated, ISpanNamingSchema? spanNamingSchema, bool decorateAllMethods)
+    {
+        _decorated = decorated;
+        _activity = new(_decorated!.GetType().FullName!);
+        _decorateAllMethods = decorateAllMethods;
+        if (spanNamingSchema != null)
+        {
+            _namingSchema = spanNamingSchema;
+        }
+    }
+    private object? InvokeDecoratedExecution(MethodInfo? targetMethod, object?[]? args)
+    {
+        var result = targetMethod.Invoke(_decorated, args);
+        return result;
+    }
+
+    private object? WrapWithRecordException(Activity activity, Func<object?> invocation)
+    {
+        try
+        {
+            var result = invocation();
+            return result;
+        }
+        catch (Exception e)
+        {
+            activity.RecordException(e);
+            throw;
+        }
+    }
+
+    
+    protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
+    {
+        var noActivityAttribute = targetMethod.GetCustomAttribute<NoActivityAttribute>(false);
+        var activityAttribute = targetMethod.GetCustomAttribute<TraceActivityAttribute>(false);
+
+        if (noActivityAttribute == null || (!_decorateAllMethods && activityAttribute==null))
+        {
+            var defaultSpanName = _namingSchema.GetSpanName(_decorated!.GetType(), targetMethod);
+            using var activity = _activity.StartActivity(activityAttribute?.Name ?? defaultSpanName);
+            if (activityAttribute?.RecordExceptions==false)
+            {
+                return InvokeDecoratedExecution(targetMethod, args);
+            }
+          
+            return WrapWithRecordException(activity, () => InvokeDecoratedExecution(targetMethod, args));
+
+        }
+       
+        return InvokeDecoratedExecution(targetMethod, args);
+
+    }
+    
+
+}