fix additional AOT errors (Azure#49665)

Author: Timothy Mothra

sdk/monitor/Azure.Monitor.OpenTelemetry.LiveMetrics/src/Customizations/Models/DocumentIngress.cs

@@ -1,9 +1,12 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using System.Diagnostics.CodeAnalysis;
+
 namespace Azure.Monitor.OpenTelemetry.LiveMetrics.Models
 {
     /// <summary> Additional properties used to calculate metrics. </summary>
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)]
     internal partial class DocumentIngress
     {
         public bool Extension_IsSuccess { get; set; }

sdk/monitor/Azure.Monitor.OpenTelemetry.LiveMetrics/src/Internals/Filtering/CollectionConfiguration.cs

@@ -118,16 +118,17 @@ private void UpdateAllErrorsWithKeyValue(CollectionConfigurationError[] errors,
 
         public string ETag => info.ETag;
 
-        private static void AddMetric<DocumentIngress>(
+        private static void AddMetric<TTelemetry>(
           DerivedMetricInfo metricInfo,
-          List<DerivedMetric<DocumentIngress>> metrics,
+          List<DerivedMetric<TTelemetry>> metrics,
           out CollectionConfigurationError[] errors)
+          where TTelemetry : DocumentIngress
         {
             errors = Array.Empty<CollectionConfigurationError>();
 
             try
             {
-                metrics.Add(new DerivedMetric<DocumentIngress>(metricInfo, out errors));
+                metrics.Add(new DerivedMetric<TTelemetry>(metricInfo, out errors));
             }
             catch (System.Exception e)
             {

sdk/monitor/Azure.Monitor.OpenTelemetry.LiveMetrics/src/Internals/Filtering/DerivedMetric.cs

@@ -16,7 +16,7 @@ namespace Azure.Monitor.OpenTelemetry.LiveMetrics.Internals.Filtering
     /// which defines which field to use as a value, and an aggregation which dictates the algorithm of arriving at
     /// a single reportable value within a second.
     /// </summary>
-    internal class DerivedMetric<TTelemetry>
+    internal class DerivedMetric<TTelemetry> where TTelemetry : DocumentIngress
     {
         private const string ProjectionCount = "Count()";
 

sdk/monitor/Azure.Monitor.OpenTelemetry.LiveMetrics/src/Internals/Filtering/DocumentStream.cs

@@ -92,6 +92,7 @@ private static bool CheckFilters<TTelemetry>(
             List<FilterConjunctionGroup<TTelemetry>> filterGroups,
             TTelemetry document,
             out CollectionConfigurationError[] errors)
+            where TTelemetry : DocumentIngress
         {
             var errorList = new List<CollectionConfigurationError>();
             bool leastOneConjunctionGroupPassed = false;
@@ -121,6 +122,7 @@ private static bool CheckFilters<TTelemetry>(
         }
 
         private static bool CheckFiltersGeneric<TTelemetry>(TTelemetry document, FilterConjunctionGroup<TTelemetry> filterGroup, List<CollectionConfigurationError> errorList)
+            where TTelemetry : DocumentIngress
         {
             bool filterPassed = false;
 

sdk/monitor/Azure.Monitor.OpenTelemetry.LiveMetrics/src/Internals/Filtering/Filter.cs

@@ -19,7 +19,7 @@ namespace Azure.Monitor.OpenTelemetry.LiveMetrics.Internals.Filtering
     /// The filter's configuration (condition) is specified in a <see cref="FilterInfo"/> DTO.
     /// </summary>
     /// <typeparam name="TTelemetry">Type of telemetry documents.</typeparam>
-    internal class Filter<TTelemetry>
+    internal class Filter<TTelemetry> where TTelemetry : DocumentIngress
     {
         private const string FieldNameCustomDimensionsPrefix = "CustomDimensions.";
 
@@ -56,15 +56,15 @@ internal class Filter<TTelemetry>
             new[] { typeof(string), typeof(NumberStyles), typeof(IFormatProvider), typeof(double).MakeByRefType() });
 
         private static readonly MethodInfo ListStringTryGetValueMethodInfo =
-            GetMethodInfo<IList<KeyValuePairString>, string, string>((list, key) => Filter<int>.TryGetString(list, key));
+            GetMethodInfo<IList<KeyValuePairString>, string, string>((list, key) => TryGetString(list, key));
 
         private static readonly MethodInfo DictionaryStringDoubleTryGetValueMethodInfo = typeof(IDictionary<string, double>).GetMethod("TryGetValue");
 
         private static readonly MethodInfo ListKeyValuePairStringScanMethodInfo =
-            GetMethodInfo<IList<KeyValuePairString>, string, bool>((list, searchValue) => Filter<int>.ScanList(list, searchValue));
+            GetMethodInfo<IList<KeyValuePairString>, string, bool>((list, searchValue) => ScanList(list, searchValue));
 
         private static readonly MethodInfo DictionaryStringDoubleScanMethodInfo =
-           GetMethodInfo<IDictionary<string, double>, string, bool>((dict, searchValue) => Filter<int>.ScanDictionary(dict, searchValue));
+           GetMethodInfo<IDictionary<string, double>, string, bool>((dict, searchValue) => ScanDictionary(dict, searchValue));
 
         private static readonly ConstantExpression DoubleDefaultNumberStyles = Expression.Constant(NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite | NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands | NumberStyles.AllowExponent);
         private static readonly ConstantExpression InvariantCulture = Expression.Constant(CultureInfo.InvariantCulture);
@@ -218,12 +218,35 @@ public override string ToString()
             return info?.ToString() ?? string.Empty;
         }
 
-        internal static Expression ProduceFieldExpression(ParameterExpression documentExpression, string fieldName, FieldNameType fieldNameType)
+        [UnconditionalSuppressMessage("AOT", "IL2075", Justification = "The DocumentIngress class and its derived classes have DynamicallyAccessedMembers attribute applied to preserve public properties.")]
+        internal static Expression ProduceFieldExpression(
+            ParameterExpression documentExpression,
+            string fieldName,
+            FieldNameType fieldNameType)
         {
             switch (fieldNameType)
             {
                 case FieldNameType.FieldName:
-                    return fieldName.Split(FieldNameTrainSeparator).Aggregate<string, Expression>(documentExpression, Expression.Property);
+                    Expression current = documentExpression;
+                    string[] propertyNames = fieldName.Split(FieldNameTrainSeparator);
+
+                    foreach (string propertyName in propertyNames)
+                    {
+                        Type currentType = current.Type;
+                        PropertyInfo propertyInfo = currentType.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public);
+
+                        if (propertyInfo == null)
+                        {
+                            throw new ArgumentOutOfRangeException(
+                                nameof(fieldName),
+                                $"Property '{propertyName}' not found on type '{currentType.FullName}'");
+                        }
+
+                        current = Expression.Property(current, propertyInfo);
+                    }
+
+                    return current;
+
                 case FieldNameType.CustomMetricName:
                     string customMetricName = fieldName.Substring(
                         FieldNameCustomMetricsPrefix.Length,
@@ -276,21 +299,47 @@ internal static Type GetFieldType(string fieldName, out FieldNameType fieldNameT
             return GetPropertyTypeFromFieldName(fieldName);
         }
 
-        private static Expression CreateListAccessExpression(ParameterExpression documentExpression, string listName, MethodInfo tryGetValueMethodInfo, Type valueType, string keyValue)
+        [UnconditionalSuppressMessage("AOT", "IL2075", Justification = "The DocumentIngress class and its derived classes have DynamicallyAccessedMembers attribute applied to preserve public properties.")]
+        private static Expression CreateListAccessExpression(
+            ParameterExpression documentExpression,
+            string listName,
+            MethodInfo tryGetValueMethodInfo,
+            Type valueType,
+            string keyValue)
         {
+            // Get the PropertyInfo directly to avoid string-based property access
+            PropertyInfo listProperty = documentExpression.Type.GetProperty(listName, BindingFlags.Instance | BindingFlags.Public);
+            if (listProperty == null)
+            {
+                throw new ArgumentException($"Property '{listName}' not found on type '{documentExpression.Type.FullName}'", nameof(listName));
+            }
+
             // return Filter<int>.TryGetString(document.listName, keyValue)
-            MemberExpression properties = Expression.Property(documentExpression, listName);
+            MemberExpression properties = Expression.Property(documentExpression, listProperty);
             return Expression.Call(tryGetValueMethodInfo, properties, Expression.Constant(keyValue));
         }
 
-        private static Expression CreateDictionaryAccessExpression(ParameterExpression documentExpression, string dictionaryName, MethodInfo tryGetValueMethodInfo, Type valueType, string keyValue)
+        [UnconditionalSuppressMessage("AOT", "IL2075", Justification = "The DocumentIngress class and its derived classes have DynamicallyAccessedMembers attribute applied to preserve public properties.")]
+        private static Expression CreateDictionaryAccessExpression(
+            ParameterExpression documentExpression,
+            string dictionaryName,
+            MethodInfo tryGetValueMethodInfo,
+            Type valueType,
+            string keyValue)
         {
+            // Get the PropertyInfo directly to avoid string-based property access
+            PropertyInfo dictionaryProperty = documentExpression.Type.GetProperty(dictionaryName, BindingFlags.Instance | BindingFlags.Public);
+            if (dictionaryProperty == null)
+            {
+                throw new ArgumentException($"Property '{dictionaryName}' not found on type '{documentExpression.Type.FullName}'", nameof(dictionaryName));
+            }
+
             // valueType value;
             // document.dictionaryName.TryGetValue(keyValue, out value)
             // return value;
             ParameterExpression valueVariable = Expression.Variable(valueType);
 
-            MemberExpression properties = Expression.Property(documentExpression, dictionaryName);
+            MemberExpression properties = Expression.Property(documentExpression, dictionaryProperty);
             MethodCallExpression tryGetValueCall = Expression.Call(properties, tryGetValueMethodInfo, Expression.Constant(keyValue), valueVariable);
 
             // a block will "return" its last expression

sdk/monitor/Azure.Monitor.OpenTelemetry.LiveMetrics/src/Internals/Filtering/FilterConjunctionGroup.cs

@@ -11,7 +11,7 @@ namespace Azure.Monitor.OpenTelemetry.LiveMetrics.Internals.Filtering
     /// <summary>
     /// Defines an AND group of filters.
     /// </summary>
-    internal class FilterConjunctionGroup<TTelemetry>
+    internal class FilterConjunctionGroup<TTelemetry> where TTelemetry : DocumentIngress
     {
         private readonly FilterConjunctionGroupInfo info;
 

sdk/monitor/Azure.Monitor.OpenTelemetry.LiveMetrics/src/Internals/LiveMetricsClientManager.MetricsCollection.cs

@@ -225,6 +225,7 @@ private void ApplyFilters<TTelemetry>(
             TTelemetry telemetry,
             out CollectionConfigurationError[] filteringErrors,
             ref string projectionError)
+            where TTelemetry : DocumentIngress
         {
             filteringErrors = Array.Empty<CollectionConfigurationError>();