diff --git a/OpenTelemetry.sln b/OpenTelemetry.sln
index b1bbdcad109..fe44303d234 100644
--- a/OpenTelemetry.sln
+++ b/OpenTelemetry.sln
@@ -275,7 +275,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Shared", "Shared", "{A49299
 		src\Shared\SpanAttributeConstants.cs = src\Shared\SpanAttributeConstants.cs
 		src\Shared\SpanHelper.cs = src\Shared\SpanHelper.cs
 		src\Shared\StatusHelper.cs = src\Shared\StatusHelper.cs
-		src\Shared\TagAndValueTransformer.cs = src\Shared\TagAndValueTransformer.cs
 		src\Shared\TagTransformer.cs = src\Shared\TagTransformer.cs
 		src\Shared\TagTransformerJsonHelper.cs = src\Shared\TagTransformerJsonHelper.cs
 	EndProjectSection
diff --git a/src/OpenTelemetry.Exporter.Console/ConsoleActivityExporter.cs b/src/OpenTelemetry.Exporter.Console/ConsoleActivityExporter.cs
index c87a184d7ec..8c13ffed242 100644
--- a/src/OpenTelemetry.Exporter.Console/ConsoleActivityExporter.cs
+++ b/src/OpenTelemetry.Exporter.Console/ConsoleActivityExporter.cs
@@ -56,7 +56,7 @@ public override ExportResult Export(in Batch<Activity> batch)
                         continue;
                     }
 
-                    if (ConsoleTagTransformer.Instance.TryTransformTag(tag, out var result))
+                    if (this.TagTransformer.TryTransformTag(tag, out var result))
                     {
                         this.WriteLine($"    {result}");
                     }
@@ -88,7 +88,7 @@ public override ExportResult Export(in Batch<Activity> batch)
                     this.WriteLine($"    {activityEvent.Name} [{activityEvent.Timestamp}]");
                     foreach (ref readonly var attribute in activityEvent.EnumerateTagObjects())
                     {
-                        if (ConsoleTagTransformer.Instance.TryTransformTag(attribute, out var result))
+                        if (this.TagTransformer.TryTransformTag(attribute, out var result))
                         {
                             this.WriteLine($"        {result}");
                         }
@@ -104,7 +104,7 @@ public override ExportResult Export(in Batch<Activity> batch)
                     this.WriteLine($"    {activityLink.Context.TraceId} {activityLink.Context.SpanId}");
                     foreach (ref readonly var attribute in activityLink.EnumerateTagObjects())
                     {
-                        if (ConsoleTagTransformer.Instance.TryTransformTag(attribute, out var result))
+                        if (this.TagTransformer.TryTransformTag(attribute, out var result))
                         {
                             this.WriteLine($"        {result}");
                         }
@@ -118,7 +118,7 @@ public override ExportResult Export(in Batch<Activity> batch)
                 this.WriteLine("Resource associated with Activity:");
                 foreach (var resourceAttribute in resource.Attributes)
                 {
-                    if (ConsoleTagTransformer.Instance.TryTransformTag(resourceAttribute, out var result))
+                    if (this.TagTransformer.TryTransformTag(resourceAttribute, out var result))
                     {
                         this.WriteLine($"    {result}");
                     }
diff --git a/src/OpenTelemetry.Exporter.Console/ConsoleExporter.cs b/src/OpenTelemetry.Exporter.Console/ConsoleExporter.cs
index 4806670a009..55df14f783f 100644
--- a/src/OpenTelemetry.Exporter.Console/ConsoleExporter.cs
+++ b/src/OpenTelemetry.Exporter.Console/ConsoleExporter.cs
@@ -11,12 +11,12 @@ public abstract class ConsoleExporter<T> : BaseExporter<T>
     protected ConsoleExporter(ConsoleExporterOptions options)
     {
         this.options = options ?? new ConsoleExporterOptions();
-        ConsoleTagTransformer.LogUnsupportedAttributeType = (string tagValueType, string tagKey) =>
-        {
-            this.WriteLine($"Unsupported attribute type {tagValueType} for {tagKey}.");
-        };
+
+        this.TagTransformer = new ConsoleTagTransformer(this.OnUnsupportedTagDropped);
     }
 
+    internal ConsoleTagTransformer TagTransformer { get; }
+
     protected void WriteLine(string message)
     {
         if (this.options.Targets.HasFlag(ConsoleExporterOutputTargets.Console))
@@ -29,4 +29,11 @@ protected void WriteLine(string message)
             System.Diagnostics.Trace.WriteLine(message);
         }
     }
+
+    private void OnUnsupportedTagDropped(
+        string tagKey,
+        string tagValueTypeFullName)
+    {
+        this.WriteLine($"Unsupported attribute value type '{tagValueTypeFullName}' for '{tagKey}'.");
+    }
 }
diff --git a/src/OpenTelemetry.Exporter.Console/ConsoleLogRecordExporter.cs b/src/OpenTelemetry.Exporter.Console/ConsoleLogRecordExporter.cs
index 1baf208c811..3dff6a9bea0 100644
--- a/src/OpenTelemetry.Exporter.Console/ConsoleLogRecordExporter.cs
+++ b/src/OpenTelemetry.Exporter.Console/ConsoleLogRecordExporter.cs
@@ -93,7 +93,7 @@ public override ExportResult Export(in Batch<LogRecord> batch)
                         ? new KeyValuePair<string, object>("OriginalFormat (a.k.a Body)", logRecord.Attributes[i].Value)
                         : logRecord.Attributes[i];
 
-                    if (ConsoleTagTransformer.Instance.TryTransformTag(valueToTransform, out var result))
+                    if (this.TagTransformer.TryTransformTag(valueToTransform, out var result))
                     {
                         this.WriteLine($"{string.Empty,-4}{result}");
                     }
@@ -127,7 +127,7 @@ void ProcessScope(LogRecordScope scope, ConsoleLogRecordExporter exporter)
 
                 foreach (KeyValuePair<string, object> scopeItem in scope)
                 {
-                    if (ConsoleTagTransformer.Instance.TryTransformTag(scopeItem, out var result))
+                    if (this.TagTransformer.TryTransformTag(scopeItem, out var result))
                     {
                         exporter.WriteLine($"[Scope.{scopeDepth}]:{result}");
                     }
@@ -140,7 +140,7 @@ void ProcessScope(LogRecordScope scope, ConsoleLogRecordExporter exporter)
                 this.WriteLine("\nResource associated with LogRecord:");
                 foreach (var resourceAttribute in resource.Attributes)
                 {
-                    if (ConsoleTagTransformer.Instance.TryTransformTag(resourceAttribute, out var result))
+                    if (this.TagTransformer.TryTransformTag(resourceAttribute, out var result))
                     {
                         this.WriteLine(result);
                     }
diff --git a/src/OpenTelemetry.Exporter.Console/ConsoleMetricExporter.cs b/src/OpenTelemetry.Exporter.Console/ConsoleMetricExporter.cs
index f3f4b0ba5f9..b8e770c24ff 100644
--- a/src/OpenTelemetry.Exporter.Console/ConsoleMetricExporter.cs
+++ b/src/OpenTelemetry.Exporter.Console/ConsoleMetricExporter.cs
@@ -27,7 +27,7 @@ public override ExportResult Export(in Batch<Metric> batch)
                 this.WriteLine("Resource associated with Metric:");
                 foreach (var resourceAttribute in this.resource.Attributes)
                 {
-                    if (ConsoleTagTransformer.Instance.TryTransformTag(resourceAttribute, out var result))
+                    if (this.TagTransformer.TryTransformTag(resourceAttribute, out var result))
                     {
                         this.WriteLine($"    {result}");
                     }
@@ -67,7 +67,7 @@ public override ExportResult Export(in Batch<Metric> batch)
                 foreach (var meterTag in metric.MeterTags)
                 {
                     this.WriteLine("\tMeter Tags:");
-                    if (ConsoleTagTransformer.Instance.TryTransformTag(meterTag, out var result))
+                    if (this.TagTransformer.TryTransformTag(meterTag, out var result))
                     {
                         this.WriteLine($"\t\t{result}");
                     }
@@ -80,7 +80,7 @@ public override ExportResult Export(in Batch<Metric> batch)
                 StringBuilder tagsBuilder = new StringBuilder();
                 foreach (var tag in metricPoint.Tags)
                 {
-                    if (ConsoleTagTransformer.Instance.TryTransformTag(tag, out var result))
+                    if (this.TagTransformer.TryTransformTag(tag, out var result))
                     {
                         tagsBuilder.Append(result);
                         tagsBuilder.Append(' ');
@@ -216,7 +216,7 @@ public override ExportResult Export(in Batch<Metric> batch)
                         bool appendedTagString = false;
                         foreach (var tag in exemplar.FilteredTags)
                         {
-                            if (ConsoleTagTransformer.Instance.TryTransformTag(tag, out var result))
+                            if (this.TagTransformer.TryTransformTag(tag, out var result))
                             {
                                 if (!appendedTagString)
                                 {
diff --git a/src/OpenTelemetry.Exporter.Console/ConsoleTagTransformer.cs b/src/OpenTelemetry.Exporter.Console/Implementation/ConsoleTagTransformer.cs
similarity index 60%
rename from src/OpenTelemetry.Exporter.Console/ConsoleTagTransformer.cs
rename to src/OpenTelemetry.Exporter.Console/Implementation/ConsoleTagTransformer.cs
index 308d2da6e1e..57ace36b352 100644
--- a/src/OpenTelemetry.Exporter.Console/ConsoleTagTransformer.cs
+++ b/src/OpenTelemetry.Exporter.Console/Implementation/ConsoleTagTransformer.cs
@@ -1,17 +1,23 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
+#nullable enable
+
+using System.Diagnostics;
 using OpenTelemetry.Internal;
 
 namespace OpenTelemetry.Exporter;
 
 internal sealed class ConsoleTagTransformer : TagTransformer<string>
 {
-    private ConsoleTagTransformer()
+    private readonly Action<string, string> onUnsupportedTagDropped;
+
+    public ConsoleTagTransformer(Action<string, string> onUnsupportedTagDropped)
     {
-    }
+        Debug.Assert(onUnsupportedTagDropped != null, "onUnsupportedTagDropped was null");
 
-    public static ConsoleTagTransformer Instance { get; } = new();
+        this.onUnsupportedTagDropped = onUnsupportedTagDropped!;
+    }
 
     protected override string TransformIntegralTag(string key, long value) => $"{key}: {value}";
 
@@ -23,4 +29,11 @@ private ConsoleTagTransformer()
 
     protected override string TransformArrayTag(string key, Array array)
         => this.TransformStringTag(key, TagTransformerJsonHelper.JsonSerializeArrayTag(array));
+
+    protected override void OnUnsupportedTagDropped(
+        string tagKey,
+        string tagValueTypeFullName)
+    {
+        this.onUnsupportedTagDropped(tagKey, tagValueTypeFullName);
+    }
 }
diff --git a/src/OpenTelemetry.Exporter.Console/OpenTelemetry.Exporter.Console.csproj b/src/OpenTelemetry.Exporter.Console/OpenTelemetry.Exporter.Console.csproj
index 46fec7d5e99..f7b33738c30 100644
--- a/src/OpenTelemetry.Exporter.Console/OpenTelemetry.Exporter.Console.csproj
+++ b/src/OpenTelemetry.Exporter.Console/OpenTelemetry.Exporter.Console.csproj
@@ -34,6 +34,7 @@
     <Compile Include="$(RepoRoot)\src\Shared\Guard.cs" Link="Includes\Guard.cs" RequiresExposedExperimentalFeatures="true" />
     <Compile Include="$(RepoRoot)\src\Shared\DiagnosticDefinitions.cs" Link="Includes\DiagnosticDefinitions.cs" RequiresExposedExperimentalFeatures="true" />
     <Compile Include="$(RepoRoot)\src\Shared\ExceptionExtensions.cs" Link="Includes\ExceptionExtensions.cs" RequiresExposedExperimentalFeatures="true" />
+    <Compile Include="$(RepoRoot)\src\Shared\Shims\NullableAttributes.cs" Link="Includes\Shims\NullableAttributes.cs" RequiresExposedExperimentalFeatures="true" />
     <Compile Include="$(RepoRoot)\src\Shared\SpanAttributeConstants.cs" Link="Includes\SpanAttributeConstants.cs" RequiresExposedExperimentalFeatures="true" />
   </ItemGroup>
 
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/ActivityExtensions.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/ActivityExtensions.cs
index c99f0c2abde..688ccafbc5b 100644
--- a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/ActivityExtensions.cs
+++ b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/ActivityExtensions.cs
@@ -237,7 +237,7 @@ private static Span.Types.Link ToOtlpLink(in ActivityLink activityLink, SdkLimit
         int maxTags = sdkLimitOptions.SpanLinkAttributeCountLimit ?? int.MaxValue;
         foreach (ref readonly var tag in activityLink.EnumerateTagObjects())
         {
-            if (OtlpKeyValueTransformer.Instance.TryTransformTag(tag, out var attribute, sdkLimitOptions.AttributeValueLengthLimit))
+            if (OtlpTagTransformer.Instance.TryTransformTag(tag, out var attribute, sdkLimitOptions.AttributeValueLengthLimit))
             {
                 if (otlpLink.Attributes.Count < maxTags)
                 {
@@ -265,7 +265,7 @@ private static Span.Types.Event ToOtlpEvent(in ActivityEvent activityEvent, SdkL
         int maxTags = sdkLimitOptions.SpanEventAttributeCountLimit ?? int.MaxValue;
         foreach (ref readonly var tag in activityEvent.EnumerateTagObjects())
         {
-            if (OtlpKeyValueTransformer.Instance.TryTransformTag(tag, out var attribute, sdkLimitOptions.AttributeValueLengthLimit))
+            if (OtlpTagTransformer.Instance.TryTransformTag(tag, out var attribute, sdkLimitOptions.AttributeValueLengthLimit))
             {
                 if (otlpEvent.Attributes.Count < maxTags)
                 {
@@ -322,7 +322,7 @@ public void EnumerateTags(Activity activity, int maxTags)
                         continue;
                 }
 
-                if (OtlpKeyValueTransformer.Instance.TryTransformTag(tag, out var attribute, this.SdkLimitOptions.AttributeValueLengthLimit))
+                if (OtlpTagTransformer.Instance.TryTransformTag(tag, out var attribute, this.SdkLimitOptions.AttributeValueLengthLimit))
                 {
                     if (this.Span.Attributes.Count < maxTags)
                     {
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/MetricItemExtensions.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/MetricItemExtensions.cs
index fb9266cb613..00336045576 100644
--- a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/MetricItemExtensions.cs
+++ b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/MetricItemExtensions.cs
@@ -416,7 +416,7 @@ internal static OtlpMetrics.Exemplar ToOtlpExemplar<T>(T value, in Metrics.Exemp
 
         foreach (var tag in exemplar.FilteredTags)
         {
-            if (OtlpKeyValueTransformer.Instance.TryTransformTag(tag, out var result))
+            if (OtlpTagTransformer.Instance.TryTransformTag(tag, out var result))
             {
                 otlpExemplar.FilteredAttributes.Add(result);
             }
@@ -429,7 +429,7 @@ private static void AddAttributes(ReadOnlyTagCollection tags, RepeatedField<Otlp
     {
         foreach (var tag in tags)
         {
-            if (OtlpKeyValueTransformer.Instance.TryTransformTag(tag, out var result))
+            if (OtlpTagTransformer.Instance.TryTransformTag(tag, out var result))
             {
                 attributes.Add(result);
             }
@@ -440,7 +440,7 @@ private static void AddScopeAttributes(IEnumerable<KeyValuePair<string, object>>
     {
         foreach (var tag in meterTags)
         {
-            if (OtlpKeyValueTransformer.Instance.TryTransformTag(tag, out var result))
+            if (OtlpTagTransformer.Instance.TryTransformTag(tag, out var result))
             {
                 attributes.Add(result);
             }
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/OtlpKeyValueTransformer.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/OtlpKeyValueTransformer.cs
deleted file mode 100644
index 3f82c37573e..00000000000
--- a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/OtlpKeyValueTransformer.cs
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright The OpenTelemetry Authors
-// SPDX-License-Identifier: Apache-2.0
-
-using OpenTelemetry.Internal;
-using OtlpCommon = OpenTelemetry.Proto.Common.V1;
-
-namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation;
-
-internal sealed class OtlpKeyValueTransformer : TagAndValueTransformer<OtlpCommon.KeyValue, OtlpCommon.AnyValue>
-{
-    private OtlpKeyValueTransformer()
-    {
-    }
-
-    public static OtlpKeyValueTransformer Instance { get; } = new();
-
-    protected override OtlpCommon.KeyValue TransformIntegralTag(string key, long value)
-    {
-        return new OtlpCommon.KeyValue { Key = key, Value = this.TransformIntegralValue(value) };
-    }
-
-    protected override OtlpCommon.KeyValue TransformFloatingPointTag(string key, double value)
-    {
-        return new OtlpCommon.KeyValue { Key = key, Value = this.TransformFloatingPointValue(value) };
-    }
-
-    protected override OtlpCommon.KeyValue TransformBooleanTag(string key, bool value)
-    {
-        return new OtlpCommon.KeyValue { Key = key, Value = this.TransformBooleanValue(value) };
-    }
-
-    protected override OtlpCommon.KeyValue TransformStringTag(string key, string value)
-    {
-        return new OtlpCommon.KeyValue { Key = key, Value = this.TransformStringValue(value) };
-    }
-
-    protected override OtlpCommon.KeyValue TransformArrayTag(string key, Array array)
-    {
-        return new OtlpCommon.KeyValue { Key = key, Value = this.TransformArrayValue(array) };
-    }
-
-    protected override OtlpCommon.AnyValue TransformIntegralValue(long value)
-    {
-        return new OtlpCommon.AnyValue { IntValue = value };
-    }
-
-    protected override OtlpCommon.AnyValue TransformFloatingPointValue(double value)
-    {
-        return new OtlpCommon.AnyValue { DoubleValue = value };
-    }
-
-    protected override OtlpCommon.AnyValue TransformBooleanValue(bool value)
-    {
-        return new OtlpCommon.AnyValue { BoolValue = value };
-    }
-
-    protected override OtlpCommon.AnyValue TransformStringValue(string value)
-    {
-        return new OtlpCommon.AnyValue { StringValue = value };
-    }
-
-    protected override OtlpCommon.AnyValue TransformArrayValue(Array array)
-    {
-        var arrayValue = new OtlpCommon.ArrayValue();
-
-        foreach (var item in array)
-        {
-            try
-            {
-                var value = item != null ? this.TransformValue(item) : new OtlpCommon.AnyValue();
-                arrayValue.Values.Add(value);
-            }
-            catch
-            {
-                return null;
-            }
-        }
-
-        return new OtlpCommon.AnyValue { ArrayValue = arrayValue };
-    }
-}
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/OtlpLogRecordTransformer.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/OtlpLogRecordTransformer.cs
index 97be1c2d9f6..1071a2bf18e 100644
--- a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/OtlpLogRecordTransformer.cs
+++ b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/OtlpLogRecordTransformer.cs
@@ -166,7 +166,7 @@ internal OtlpLogs.LogRecord ToOtlpLog(LogRecord logRecord)
                     {
                         otlpLogRecord.Body = new OtlpCommon.AnyValue { StringValue = attribute.Value as string };
                     }
-                    else if (OtlpKeyValueTransformer.Instance.TryTransformTag(attribute, out var result, attributeValueLengthLimit))
+                    else if (OtlpTagTransformer.Instance.TryTransformTag(attribute, out var result, attributeValueLengthLimit))
                     {
                         AddAttribute(otlpLogRecord, result, attributeCountLimit);
                     }
@@ -224,7 +224,7 @@ void ProcessScope(LogRecordScope scope, OtlpLogs.LogRecord otlpLog)
                     }
                     else
                     {
-                        if (OtlpKeyValueTransformer.Instance.TryTransformTag(scopeItem, out var result, attributeValueLengthLimit))
+                        if (OtlpTagTransformer.Instance.TryTransformTag(scopeItem, out var result, attributeValueLengthLimit))
                         {
                             AddAttribute(otlpLog, result, attributeCountLimit);
                         }
@@ -257,7 +257,7 @@ private static void AddAttribute(OtlpLogs.LogRecord logRecord, OtlpCommon.KeyVal
     private static void AddStringAttribute(OtlpLogs.LogRecord logRecord, string key, string value, int? maxValueLength, int maxAttributeCount)
     {
         var attributeItem = new KeyValuePair<string, object>(key, value);
-        if (OtlpKeyValueTransformer.Instance.TryTransformTag(attributeItem, out var result, maxValueLength))
+        if (OtlpTagTransformer.Instance.TryTransformTag(attributeItem, out var result, maxValueLength))
         {
             AddAttribute(logRecord, result, maxAttributeCount);
         }
@@ -267,7 +267,7 @@ private static void AddStringAttribute(OtlpLogs.LogRecord logRecord, string key,
     private static void AddIntAttribute(OtlpLogs.LogRecord logRecord, string key, int value, int maxAttributeCount)
     {
         var attributeItem = new KeyValuePair<string, object>(key, value);
-        if (OtlpKeyValueTransformer.Instance.TryTransformTag(attributeItem, out var result))
+        if (OtlpTagTransformer.Instance.TryTransformTag(attributeItem, out var result))
         {
             AddAttribute(logRecord, result, maxAttributeCount);
         }
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/OtlpTagTransformer.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/OtlpTagTransformer.cs
new file mode 100644
index 00000000000..386653d8fbf
--- /dev/null
+++ b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/OtlpTagTransformer.cs
@@ -0,0 +1,118 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#nullable enable
+
+using System.Diagnostics;
+using OpenTelemetry.Internal;
+using OtlpCommon = OpenTelemetry.Proto.Common.V1;
+
+namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation;
+
+internal sealed class OtlpTagTransformer : TagTransformer<OtlpCommon.KeyValue>
+{
+    private OtlpTagTransformer()
+    {
+    }
+
+    public static OtlpTagTransformer Instance { get; } = new();
+
+    protected override OtlpCommon.KeyValue TransformIntegralTag(string key, long value)
+    {
+        return new OtlpCommon.KeyValue { Key = key, Value = ToAnyValue(value) };
+    }
+
+    protected override OtlpCommon.KeyValue TransformFloatingPointTag(string key, double value)
+    {
+        return new OtlpCommon.KeyValue { Key = key, Value = ToAnyValue(value) };
+    }
+
+    protected override OtlpCommon.KeyValue TransformBooleanTag(string key, bool value)
+    {
+        return new OtlpCommon.KeyValue { Key = key, Value = ToAnyValue(value) };
+    }
+
+    protected override OtlpCommon.KeyValue TransformStringTag(string key, string value)
+    {
+        return new OtlpCommon.KeyValue { Key = key, Value = ToAnyValue(value) };
+    }
+
+    protected override OtlpCommon.KeyValue TransformArrayTag(string key, Array array)
+    {
+        var arrayValue = new OtlpCommon.ArrayValue();
+
+        foreach (var item in array)
+        {
+            arrayValue.Values.Add(ToAnyValue(item));
+        }
+
+        return new OtlpCommon.KeyValue { Key = key, Value = new OtlpCommon.AnyValue { ArrayValue = arrayValue } };
+    }
+
+    protected override void OnUnsupportedTagDropped(
+        string tagKey,
+        string tagValueTypeFullName)
+    {
+        OpenTelemetryProtocolExporterEventSource.Log.UnsupportedAttributeType(
+            tagValueTypeFullName,
+            tagKey);
+    }
+
+    private static OtlpCommon.AnyValue ToAnyValue(long value)
+        => new() { IntValue = value };
+
+    private static OtlpCommon.AnyValue ToAnyValue(double value)
+       => new() { DoubleValue = value };
+
+    private static OtlpCommon.AnyValue ToAnyValue(bool value)
+        => new() { BoolValue = value };
+
+    private static OtlpCommon.AnyValue ToAnyValue(string value)
+        => new() { StringValue = value };
+
+    private static OtlpCommon.AnyValue ToAnyValue(object? value)
+    {
+        if (value == null)
+        {
+            return new();
+        }
+
+        return value switch
+        {
+            char => ToAnyValue(Convert.ToString(value)!),
+            string s =>
+                /* Note: No need to call TruncateString here. That is taken care of
+                 in base class via ConvertToStringArrayThenTransformArrayTag */
+                ToAnyValue(s),
+            bool b => ToAnyValue(b),
+            byte b => ToAnyValue(b),
+            sbyte b => ToAnyValue(b),
+            short s => ToAnyValue(s),
+            ushort s => ToAnyValue(s),
+            int i => ToAnyValue(i),
+            uint i => ToAnyValue(i),
+            long l => ToAnyValue(l),
+            float f => ToAnyValue(f),
+            double d => ToAnyValue(d),
+            _ => DefaultCase(value),
+        };
+
+        static OtlpCommon.AnyValue DefaultCase(object value)
+        {
+            // Note: This should never be executed. In the base class the
+            // default case in TransformArrayTagInternal converts everything
+            // not explicitly supported to strings
+
+            Debug.Fail("Default case executed");
+
+            var stringValue = Convert.ToString(value);
+
+            if (stringValue == null)
+            {
+                return new();
+            }
+
+            return ToAnyValue(stringValue);
+        }
+    }
+}
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/ResourceExtensions.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/ResourceExtensions.cs
index 77c01c368ae..46158813ef6 100644
--- a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/ResourceExtensions.cs
+++ b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/ResourceExtensions.cs
@@ -15,7 +15,7 @@ public static OtlpResource.Resource ToOtlpResource(this Resource resource)
 
         foreach (KeyValuePair<string, object> attribute in resource.Attributes)
         {
-            if (OtlpKeyValueTransformer.Instance.TryTransformTag(attribute, out var result))
+            if (OtlpTagTransformer.Instance.TryTransformTag(attribute, out var result))
             {
                 processResource.Attributes.Add(result);
             }
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OpenTelemetry.Exporter.OpenTelemetryProtocol.csproj b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OpenTelemetry.Exporter.OpenTelemetryProtocol.csproj
index f4de3db506a..8f89cb12514 100644
--- a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OpenTelemetry.Exporter.OpenTelemetryProtocol.csproj
+++ b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OpenTelemetry.Exporter.OpenTelemetryProtocol.csproj
@@ -28,7 +28,6 @@
   <ItemGroup>
     <Compile Include="$(RepoRoot)\src\Shared\PeriodicExportingMetricReaderHelper.cs" Link="Includes\PeriodicExportingMetricReaderHelper.cs" />
     <Compile Include="$(RepoRoot)\src\Shared\PeerServiceResolver.cs" Link="Includes\PeerServiceResolver.cs" />
-    <Compile Include="$(RepoRoot)\src\Shared\TagAndValueTransformer.cs" Link="Includes\TagAndValueTransformer.cs" />
     <Compile Include="$(RepoRoot)\src\Shared\TagTransformer.cs" Link="Includes\TagTransformer.cs" />
 
     <!-- Note: When '$(ExposeExperimentalFeatures)' == 'false' these links are
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpLogExporter.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpLogExporter.cs
index 7daa94cc703..aa16ef7eb64 100644
--- a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpLogExporter.cs
+++ b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpLogExporter.cs
@@ -50,13 +50,10 @@ internal OtlpLogExporter(
         Debug.Assert(sdkLimitOptions != null, "sdkLimitOptions was null");
         Debug.Assert(experimentalOptions != null, "experimentalOptions was null");
 
-        // Each of the Otlp exporters: Traces, Metrics, and Logs set the same value for `OtlpKeyValueTransformer.LogUnsupportedAttributeType`
-        // and `ConfigurationExtensions.LogInvalidEnvironmentVariable` so it should be fine even if these exporters are used together.
-        OtlpKeyValueTransformer.LogUnsupportedAttributeType = (string tagValueType, string tagKey) =>
-        {
-            OpenTelemetryProtocolExporterEventSource.Log.UnsupportedAttributeType(tagValueType, tagKey);
-        };
-
+        // Each of the Otlp exporters: Traces, Metrics, and Logs set the same
+        // value for
+        // `OpenTelemetryConfigurationExtensions.LogInvalidEnvironmentVariable`
+        // so it should be fine even if these exporters are used together.
         OpenTelemetryConfigurationExtensions.LogInvalidEnvironmentVariable = OpenTelemetryProtocolExporterEventSource.Log.InvalidEnvironmentVariable;
 
         this.transmissionHandler = transmissionHandler ?? exporterOptions.GetLogsExportTransmissionHandler(experimentalOptions!);
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpMetricExporter.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpMetricExporter.cs
index 25aefeb740c..8890de1e096 100644
--- a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpMetricExporter.cs
+++ b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpMetricExporter.cs
@@ -40,13 +40,10 @@ internal OtlpMetricExporter(
         ExperimentalOptions experimentalOptions,
         OtlpExporterTransmissionHandler<OtlpCollector.ExportMetricsServiceRequest> transmissionHandler = null)
     {
-        // Each of the Otlp exporters: Traces, Metrics, and Logs set the same value for `OtlpKeyValueTransformer.LogUnsupportedAttributeType`
-        // and `ConfigurationExtensions.LogInvalidEnvironmentVariable` so it should be fine even if these exporters are used together.
-        OtlpKeyValueTransformer.LogUnsupportedAttributeType = (string tagValueType, string tagKey) =>
-        {
-            OpenTelemetryProtocolExporterEventSource.Log.UnsupportedAttributeType(tagValueType, tagKey);
-        };
-
+        // Each of the Otlp exporters: Traces, Metrics, and Logs set the same
+        // value for
+        // `OpenTelemetryConfigurationExtensions.LogInvalidEnvironmentVariable`
+        // so it should be fine even if these exporters are used together.
         OpenTelemetryConfigurationExtensions.LogInvalidEnvironmentVariable = OpenTelemetryProtocolExporterEventSource.Log.InvalidEnvironmentVariable;
 
         this.transmissionHandler = transmissionHandler ?? options.GetMetricsExportTransmissionHandler(experimentalOptions);
diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpTraceExporter.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpTraceExporter.cs
index d92640fe288..8186302221d 100644
--- a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpTraceExporter.cs
+++ b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpTraceExporter.cs
@@ -48,8 +48,10 @@ internal OtlpTraceExporter(
 
         this.sdkLimitOptions = sdkLimitOptions;
 
-        OtlpKeyValueTransformer.LogUnsupportedAttributeType = OpenTelemetryProtocolExporterEventSource.Log.UnsupportedAttributeType;
-
+        // Each of the Otlp exporters: Traces, Metrics, and Logs set the same
+        // value for
+        // `OpenTelemetryConfigurationExtensions.LogInvalidEnvironmentVariable`
+        // so it should be fine even if these exporters are used together.
         OpenTelemetryConfigurationExtensions.LogInvalidEnvironmentVariable = OpenTelemetryProtocolExporterEventSource.Log.InvalidEnvironmentVariable;
 
         this.transmissionHandler = transmissionHandler ?? exporterOptions.GetTraceExportTransmissionHandler(experimentalOptions);
diff --git a/src/OpenTelemetry.Exporter.Zipkin/Implementation/ZipkinTagTransformer.cs b/src/OpenTelemetry.Exporter.Zipkin/Implementation/ZipkinTagTransformer.cs
index 95ec122bcf9..ac8b686e5dc 100644
--- a/src/OpenTelemetry.Exporter.Zipkin/Implementation/ZipkinTagTransformer.cs
+++ b/src/OpenTelemetry.Exporter.Zipkin/Implementation/ZipkinTagTransformer.cs
@@ -1,6 +1,8 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
+#nullable enable
+
 using OpenTelemetry.Internal;
 
 namespace OpenTelemetry.Exporter.Zipkin.Implementation;
@@ -23,4 +25,13 @@ private ZipkinTagTransformer()
 
     protected override string TransformArrayTag(string key, Array array)
         => this.TransformStringTag(key, TagTransformerJsonHelper.JsonSerializeArrayTag(array));
+
+    protected override void OnUnsupportedTagDropped(
+        string tagKey,
+        string tagValueTypeFullName)
+    {
+        ZipkinExporterEventSource.Log.UnsupportedAttributeType(
+            tagValueTypeFullName,
+            tagKey);
+    }
 }
diff --git a/src/OpenTelemetry.Exporter.Zipkin/OpenTelemetry.Exporter.Zipkin.csproj b/src/OpenTelemetry.Exporter.Zipkin/OpenTelemetry.Exporter.Zipkin.csproj
index 72e7986982c..d3418763073 100644
--- a/src/OpenTelemetry.Exporter.Zipkin/OpenTelemetry.Exporter.Zipkin.csproj
+++ b/src/OpenTelemetry.Exporter.Zipkin/OpenTelemetry.Exporter.Zipkin.csproj
@@ -20,6 +20,7 @@
     <Compile Include="$(RepoRoot)\src\Shared\Options\*.cs" Link="Includes\Options\%(Filename).cs" />
     <Compile Include="$(RepoRoot)\src\Shared\PeerServiceResolver.cs" Link="Includes\PeerServiceResolver.cs" />
     <Compile Include="$(RepoRoot)\src\Shared\SemanticConventions.cs" Link="Includes\SemanticConventions.cs" />
+    <Compile Include="$(RepoRoot)\src\Shared\Shims\NullableAttributes.cs" Link="Includes\Shims\NullableAttributes.cs" />
     <Compile Include="$(RepoRoot)\src\Shared\SpanAttributeConstants.cs" Link="Includes\SpanAttributeConstants.cs" />
     <Compile Include="$(RepoRoot)\src\Shared\StatusHelper.cs" Link="Includes\StatusHelper.cs" />
     <Compile Include="$(RepoRoot)\src\Shared\TagTransformer.cs" Link="Includes\TagTransformer.cs" />
diff --git a/src/OpenTelemetry.Exporter.Zipkin/ZipkinExporter.cs b/src/OpenTelemetry.Exporter.Zipkin/ZipkinExporter.cs
index 36873bb7888..2938c4d9413 100644
--- a/src/OpenTelemetry.Exporter.Zipkin/ZipkinExporter.cs
+++ b/src/OpenTelemetry.Exporter.Zipkin/ZipkinExporter.cs
@@ -39,11 +39,6 @@ public ZipkinExporter(ZipkinExporterOptions options, HttpClient client = null)
         this.maxPayloadSizeInBytes = (!options.MaxPayloadSizeInBytes.HasValue || options.MaxPayloadSizeInBytes <= 0) ? ZipkinExporterOptions.DefaultMaxPayloadSizeInBytes : options.MaxPayloadSizeInBytes.Value;
         this.httpClient = client ?? options.HttpClientFactory?.Invoke() ?? throw new InvalidOperationException("ZipkinExporter was missing HttpClientFactory or it returned null.");
 
-        ZipkinTagTransformer.LogUnsupportedAttributeType = (string tagValueType, string tagKey) =>
-        {
-            ZipkinExporterEventSource.Log.UnsupportedAttributeType(tagValueType, tagKey);
-        };
-
         OpenTelemetryConfigurationExtensions.LogInvalidEnvironmentVariable = ZipkinExporterEventSource.Log.InvalidEnvironmentVariable;
     }
 
diff --git a/src/Shared/Shims/NullableAttributes.cs b/src/Shared/Shims/NullableAttributes.cs
index c471bbe6134..72d877e3dae 100644
--- a/src/Shared/Shims/NullableAttributes.cs
+++ b/src/Shared/Shims/NullableAttributes.cs
@@ -34,5 +34,13 @@ internal sealed class NotNullWhenAttribute : Attribute
         /// <summary>Gets the return value condition.</summary>
         public bool ReturnValue { get; }
     }
+
+    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
+    internal sealed class NotNullIfNotNullAttribute : Attribute
+    {
+        public NotNullIfNotNullAttribute(string parameterName) => ParameterName = parameterName;
+
+        public string ParameterName { get; }
+    }
 }
 #endif
diff --git a/src/Shared/TagAndValueTransformer.cs b/src/Shared/TagAndValueTransformer.cs
deleted file mode 100644
index 32ac24da674..00000000000
--- a/src/Shared/TagAndValueTransformer.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright The OpenTelemetry Authors
-// SPDX-License-Identifier: Apache-2.0
-
-using System.Diagnostics;
-
-namespace OpenTelemetry.Internal;
-
-internal abstract class TagAndValueTransformer<T, TValue> : TagTransformer<T>
-{
-    protected TValue TransformValue(object value)
-    {
-        Debug.Assert(value != null, $"{nameof(value)} was null");
-
-        switch (value)
-        {
-            case char:
-            case string:
-                return this.TransformStringValue(Convert.ToString(value));
-            case bool b:
-                return this.TransformBooleanValue(b);
-            case byte:
-            case sbyte:
-            case short:
-            case ushort:
-            case int:
-            case uint:
-            case long:
-                return this.TransformIntegralValue(Convert.ToInt64(value));
-            case float:
-            case double:
-                return this.TransformFloatingPointValue(Convert.ToDouble(value));
-            default:
-                // This could throw an exception. The caller is expected to handle.
-                return this.TransformStringValue(value.ToString());
-        }
-    }
-
-    protected abstract TValue TransformIntegralValue(long value);
-
-    protected abstract TValue TransformFloatingPointValue(double value);
-
-    protected abstract TValue TransformBooleanValue(bool value);
-
-    protected abstract TValue TransformStringValue(string value);
-
-    protected abstract TValue TransformArrayValue(Array value);
-}
diff --git a/src/Shared/TagTransformer.cs b/src/Shared/TagTransformer.cs
index 0c778691599..0d98f076b5c 100644
--- a/src/Shared/TagTransformer.cs
+++ b/src/Shared/TagTransformer.cs
@@ -1,13 +1,24 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
+#nullable enable
+
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+
 namespace OpenTelemetry.Internal;
 
 internal abstract class TagTransformer<T>
+    where T : notnull
 {
-    public static Action<string, string> LogUnsupportedAttributeType = null;
+    protected TagTransformer()
+    {
+    }
 
-    public bool TryTransformTag(KeyValuePair<string, object> tag, out T result, int? maxLength = null)
+    public bool TryTransformTag(
+        KeyValuePair<string, object> tag,
+        [NotNullWhen(true)] out T? result,
+        int? tagValueMaxLength = null)
     {
         if (tag.Value == null)
         {
@@ -19,7 +30,7 @@ public bool TryTransformTag(KeyValuePair<string, object> tag, out T result, int?
         {
             case char:
             case string:
-                result = this.TransformStringTag(tag.Key, TruncateString(Convert.ToString(tag.Value), maxLength));
+                result = this.TransformStringTag(tag.Key, TruncateString(Convert.ToString(tag.Value)!, tagValueMaxLength));
                 break;
             case bool b:
                 result = this.TransformBooleanTag(tag.Key, b);
@@ -40,16 +51,14 @@ public bool TryTransformTag(KeyValuePair<string, object> tag, out T result, int?
             case Array array:
                 try
                 {
-                    result = this.TransformArrayTagInternal(tag.Key, array, maxLength);
+                    result = this.TransformArrayTagInternal(tag.Key, array, tagValueMaxLength);
                 }
                 catch
                 {
                     // If an exception is thrown when calling ToString
                     // on any element of the array, then the entire array value
                     // is ignored.
-                    LogUnsupportedAttributeType?.Invoke(tag.Value.GetType().ToString(), tag.Key);
-                    result = default;
-                    return false;
+                    return this.LogUnsupportedTagTypeAndReturnDefault(tag.Key, tag.Value, out result);
                 }
 
                 break;
@@ -63,14 +72,18 @@ public bool TryTransformTag(KeyValuePair<string, object> tag, out T result, int?
             default:
                 try
                 {
-                    result = this.TransformStringTag(tag.Key, TruncateString(tag.Value.ToString(), maxLength));
+                    var stringValue = TruncateString(Convert.ToString(tag.Value), tagValueMaxLength);
+                    if (stringValue == null)
+                    {
+                        return this.LogUnsupportedTagTypeAndReturnDefault(tag.Key, tag.Value, out result);
+                    }
+
+                    result = this.TransformStringTag(tag.Key, stringValue);
                 }
                 catch
                 {
                     // If ToString throws an exception then the tag is ignored.
-                    LogUnsupportedAttributeType?.Invoke(tag.Value.GetType().ToString(), tag.Key);
-                    result = default;
-                    return false;
+                    return this.LogUnsupportedTagTypeAndReturnDefault(tag.Key, tag.Value, out result);
                 }
 
                 break;
@@ -89,51 +102,107 @@ public bool TryTransformTag(KeyValuePair<string, object> tag, out T result, int?
 
     protected abstract T TransformArrayTag(string key, Array array);
 
-    private static string TruncateString(string value, int? maxLength)
+    protected abstract void OnUnsupportedTagDropped(
+        string tagKey,
+        string tagValueTypeFullName);
+
+    [return: NotNullIfNotNull(nameof(value))]
+    private static string? TruncateString(string? value, int? maxLength)
     {
         return maxLength.HasValue && value?.Length > maxLength
             ? value.Substring(0, maxLength.Value)
             : value;
     }
 
-    private T TransformArrayTagInternal(string key, Array array, int? maxStringValueLength)
+    private T TransformArrayTagInternal(string key, Array array, int? tagValueMaxLength)
     {
         // This switch ensures the values of the resultant array-valued tag are of the same type.
         return array switch
         {
             char[] => this.TransformArrayTag(key, array),
-            string[] => this.ConvertToStringArrayThenTransformArrayTag(key, array, maxStringValueLength),
+            string[] => this.ConvertToStringArrayThenTransformArrayTag(key, array, tagValueMaxLength),
             bool[] => this.TransformArrayTag(key, array),
             byte[] => this.TransformArrayTag(key, array),
             sbyte[] => this.TransformArrayTag(key, array),
             short[] => this.TransformArrayTag(key, array),
             ushort[] => this.TransformArrayTag(key, array),
+#if NETFRAMEWORK
+            int[] => this.TransformArrayTagIntNetFramework(key, array, tagValueMaxLength),
+#else
             int[] => this.TransformArrayTag(key, array),
+#endif
             uint[] => this.TransformArrayTag(key, array),
+#if NETFRAMEWORK
+            long[] => this.TransformArrayTagLongNetFramework(key, array, tagValueMaxLength),
+#else
             long[] => this.TransformArrayTag(key, array),
+#endif
             float[] => this.TransformArrayTag(key, array),
             double[] => this.TransformArrayTag(key, array),
-            _ => this.ConvertToStringArrayThenTransformArrayTag(key, array, maxStringValueLength),
+            _ => this.ConvertToStringArrayThenTransformArrayTag(key, array, tagValueMaxLength),
         };
     }
 
-    private T ConvertToStringArrayThenTransformArrayTag(string key, Array array, int? maxStringValueLength)
+#if NETFRAMEWORK
+    private T TransformArrayTagIntNetFramework(string key, Array array, int? tagValueMaxLength)
+    {
+        // Note: On .NET Framework x86 nint[] & nuint[] fall into int[] case
+
+        var arrayType = array.GetType();
+        if (arrayType == typeof(nint[])
+            || arrayType == typeof(nuint[]))
+        {
+            return this.ConvertToStringArrayThenTransformArrayTag(key, array, tagValueMaxLength);
+        }
+
+        return this.TransformArrayTag(key, array);
+    }
+
+    private T TransformArrayTagLongNetFramework(string key, Array array, int? tagValueMaxLength)
+    {
+        // Note: On .NET Framework x64 nint[] & nuint[] fall into long[] case
+
+        var arrayType = array.GetType();
+        if (arrayType == typeof(nint[])
+            || arrayType == typeof(nuint[]))
+        {
+            return this.ConvertToStringArrayThenTransformArrayTag(key, array, tagValueMaxLength);
+        }
+
+        return this.TransformArrayTag(key, array);
+    }
+#endif
+
+    private T ConvertToStringArrayThenTransformArrayTag(string key, Array array, int? tagValueMaxLength)
     {
-        string[] stringArray;
+        string?[] stringArray;
 
-        if (array is string[] arrayAsStringArray && (!maxStringValueLength.HasValue || !arrayAsStringArray.Any(s => s?.Length > maxStringValueLength)))
+        if (array is string?[] arrayAsStringArray
+            && (!tagValueMaxLength.HasValue || !arrayAsStringArray.Any(s => s?.Length > tagValueMaxLength)))
         {
             stringArray = arrayAsStringArray;
         }
         else
         {
-            stringArray = new string[array.Length];
+            stringArray = new string?[array.Length];
             for (var i = 0; i < array.Length; ++i)
             {
-                stringArray[i] = TruncateString(array.GetValue(i)?.ToString(), maxStringValueLength);
+                var item = array.GetValue(i);
+                stringArray[i] = item == null
+                    ? null
+                    : TruncateString(Convert.ToString(item), tagValueMaxLength);
             }
         }
 
         return this.TransformArrayTag(key, stringArray);
     }
+
+    private bool LogUnsupportedTagTypeAndReturnDefault(string key, object value, out T? result)
+    {
+        Debug.Assert(value != null, "value was null");
+
+        this.OnUnsupportedTagDropped(key, value!.GetType().ToString());
+        result = default;
+        return false;
+    }
 }
diff --git a/test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/OtlpAttributeTests.cs b/test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/OtlpAttributeTests.cs
index 7d5fce165e5..0cc42ca0f47 100644
--- a/test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/OtlpAttributeTests.cs
+++ b/test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/OtlpAttributeTests.cs
@@ -13,19 +13,19 @@ public class OtlpAttributeTests
     public void NullValueAttribute()
     {
         var kvp = new KeyValuePair<string, object>("key", null);
-        Assert.False(OtlpKeyValueTransformer.Instance.TryTransformTag(kvp, out var _));
+        Assert.False(OtlpTagTransformer.Instance.TryTransformTag(kvp, out var _));
     }
 
     [Fact]
     public void EmptyArrays()
     {
         var kvp = new KeyValuePair<string, object>("key", Array.Empty<int>());
-        Assert.True(OtlpKeyValueTransformer.Instance.TryTransformTag(kvp, out var attribute));
+        Assert.True(OtlpTagTransformer.Instance.TryTransformTag(kvp, out var attribute));
         Assert.Equal(OtlpCommon.AnyValue.ValueOneofCase.ArrayValue, attribute.Value.ValueCase);
         Assert.Empty(attribute.Value.ArrayValue.Values);
 
         kvp = new KeyValuePair<string, object>("key", Array.Empty<object>());
-        Assert.True(OtlpKeyValueTransformer.Instance.TryTransformTag(kvp, out attribute));
+        Assert.True(OtlpTagTransformer.Instance.TryTransformTag(kvp, out attribute));
         Assert.Equal(OtlpCommon.AnyValue.ValueOneofCase.ArrayValue, attribute.Value.ValueCase);
         Assert.Empty(attribute.Value.ArrayValue.Values);
     }
@@ -48,7 +48,7 @@ public void EmptyArrays()
     public void IntegralTypesSupported(object value)
     {
         var kvp = new KeyValuePair<string, object>("key", value);
-        Assert.True(OtlpKeyValueTransformer.Instance.TryTransformTag(kvp, out var attribute));
+        Assert.True(OtlpTagTransformer.Instance.TryTransformTag(kvp, out var attribute));
 
         switch (value)
         {
@@ -77,7 +77,7 @@ public void IntegralTypesSupported(object value)
     public void FloatingPointTypesSupported(object value)
     {
         var kvp = new KeyValuePair<string, object>("key", value);
-        Assert.True(OtlpKeyValueTransformer.Instance.TryTransformTag(kvp, out var attribute));
+        Assert.True(OtlpTagTransformer.Instance.TryTransformTag(kvp, out var attribute));
 
         switch (value)
         {
@@ -104,7 +104,7 @@ public void FloatingPointTypesSupported(object value)
     public void BooleanTypeSupported(object value)
     {
         var kvp = new KeyValuePair<string, object>("key", value);
-        Assert.True(OtlpKeyValueTransformer.Instance.TryTransformTag(kvp, out var attribute));
+        Assert.True(OtlpTagTransformer.Instance.TryTransformTag(kvp, out var attribute));
 
         switch (value)
         {
@@ -131,7 +131,7 @@ public void BooleanTypeSupported(object value)
     public void StringTypesSupported(object value)
     {
         var kvp = new KeyValuePair<string, object>("key", value);
-        Assert.True(OtlpKeyValueTransformer.Instance.TryTransformTag(kvp, out var attribute));
+        Assert.True(OtlpTagTransformer.Instance.TryTransformTag(kvp, out var attribute));
         Assert.Equal(OtlpCommon.AnyValue.ValueOneofCase.StringValue, attribute.Value.ValueCase);
         Assert.Equal(Convert.ToString(value), attribute.Value.StringValue);
     }
@@ -143,12 +143,12 @@ public void StringArrayTypesSupported()
         var stringArray = new string[] { "a", "b", "c", string.Empty, null };
 
         var kvp = new KeyValuePair<string, object>("key", charArray);
-        Assert.True(OtlpKeyValueTransformer.Instance.TryTransformTag(kvp, out var attribute));
+        Assert.True(OtlpTagTransformer.Instance.TryTransformTag(kvp, out var attribute));
         Assert.Equal(OtlpCommon.AnyValue.ValueOneofCase.ArrayValue, attribute.Value.ValueCase);
         Assert.Equal(charArray.Select(x => x.ToString()), attribute.Value.ArrayValue.Values.Select(x => x.StringValue));
 
         kvp = new KeyValuePair<string, object>("key", stringArray);
-        Assert.True(OtlpKeyValueTransformer.Instance.TryTransformTag(kvp, out attribute));
+        Assert.True(OtlpTagTransformer.Instance.TryTransformTag(kvp, out attribute));
         Assert.Equal(OtlpCommon.AnyValue.ValueOneofCase.ArrayValue, attribute.Value.ValueCase);
 
         for (var i = 0; i < stringArray.Length; ++i)
@@ -188,7 +188,7 @@ public void ToStringIsCalledForAllOtherTypes()
         foreach (var value in testValues)
         {
             var kvp = new KeyValuePair<string, object>("key", value);
-            Assert.True(OtlpKeyValueTransformer.Instance.TryTransformTag(kvp, out var attribute));
+            Assert.True(OtlpTagTransformer.Instance.TryTransformTag(kvp, out var attribute));
             Assert.Equal(OtlpCommon.AnyValue.ValueOneofCase.StringValue, attribute.Value.ValueCase);
             Assert.Equal(value.ToString(), attribute.Value.StringValue);
         }
@@ -196,7 +196,7 @@ public void ToStringIsCalledForAllOtherTypes()
         foreach (var value in testArrayValues)
         {
             var kvp = new KeyValuePair<string, object>("key", value);
-            Assert.True(OtlpKeyValueTransformer.Instance.TryTransformTag(kvp, out var attribute));
+            Assert.True(OtlpTagTransformer.Instance.TryTransformTag(kvp, out var attribute));
             Assert.Equal(OtlpCommon.AnyValue.ValueOneofCase.ArrayValue, attribute.Value.ValueCase);
 
             var array = value as Array;
@@ -220,10 +220,10 @@ public void ToStringIsCalledForAllOtherTypes()
     public void ExceptionInToStringIsCaught()
     {
         var kvp = new KeyValuePair<string, object>("key", new MyToStringMethodThrowsAnException());
-        Assert.False(OtlpKeyValueTransformer.Instance.TryTransformTag(kvp, out var _));
+        Assert.False(OtlpTagTransformer.Instance.TryTransformTag(kvp, out var _));
 
         kvp = new KeyValuePair<string, object>("key", new object[] { 1, false, new MyToStringMethodThrowsAnException() });
-        Assert.False(OtlpKeyValueTransformer.Instance.TryTransformTag(kvp, out var _));
+        Assert.False(OtlpTagTransformer.Instance.TryTransformTag(kvp, out var _));
     }
 
     private class MyToStringMethodThrowsAnException