Update OpenTelemetry.Exporter.InMemory to use file scoped namespaces (#4683)

Author: jarosal

src/OpenTelemetry.Exporter.InMemory/InMemoryExporter.cs

@@ -14,67 +14,66 @@
 // limitations under the License.
 // </copyright>
 
-namespace OpenTelemetry.Exporter
+namespace OpenTelemetry.Exporter;
+
+public class InMemoryExporter<T> : BaseExporter<T>
+    where T : class
 {
-    public class InMemoryExporter<T> : BaseExporter<T>
-        where T : class
+    private readonly ICollection<T> exportedItems;
+    private readonly ExportFunc onExport;
+    private bool disposed;
+    private string disposedStackTrace;
+
+    public InMemoryExporter(ICollection<T> exportedItems)
     {
-        private readonly ICollection<T> exportedItems;
-        private readonly ExportFunc onExport;
-        private bool disposed;
-        private string disposedStackTrace;
+        this.exportedItems = exportedItems;
+        this.onExport = this.DefaultExport;
+    }
 
-        public InMemoryExporter(ICollection<T> exportedItems)
-        {
-            this.exportedItems = exportedItems;
-            this.onExport = this.DefaultExport;
-        }
+    internal InMemoryExporter(ExportFunc exportFunc)
+    {
+        this.onExport = exportFunc;
+    }
+
+    internal delegate ExportResult ExportFunc(in Batch<T> batch);
 
-        internal InMemoryExporter(ExportFunc exportFunc)
+    public override ExportResult Export(in Batch<T> batch)
+    {
+        if (this.disposed)
         {
-            this.onExport = exportFunc;
+            // Note: In-memory exporter is designed for testing purposes so this error is strategic to surface lifecycle management bugs during development.
+            throw new ObjectDisposedException(
+                this.GetType().Name,
+                $"The in-memory exporter is still being invoked after it has been disposed. This could be the result of invalid lifecycle management of the OpenTelemetry .NET SDK. Dispose was called on the following stack trace:{Environment.NewLine}{this.disposedStackTrace}");
         }
 
-        internal delegate ExportResult ExportFunc(in Batch<T> batch);
+        return this.onExport(batch);
+    }
 
-        public override ExportResult Export(in Batch<T> batch)
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (!this.disposed)
         {
-            if (this.disposed)
-            {
-                // Note: In-memory exporter is designed for testing purposes so this error is strategic to surface lifecycle management bugs during development.
-                throw new ObjectDisposedException(
-                    this.GetType().Name,
-                    $"The in-memory exporter is still being invoked after it has been disposed. This could be the result of invalid lifecycle management of the OpenTelemetry .NET SDK. Dispose was called on the following stack trace:{Environment.NewLine}{this.disposedStackTrace}");
-            }
-
-            return this.onExport(batch);
+            this.disposedStackTrace = Environment.StackTrace;
+            this.disposed = true;
         }
 
-        /// <inheritdoc/>
-        protected override void Dispose(bool disposing)
-        {
-            if (!this.disposed)
-            {
-                this.disposedStackTrace = Environment.StackTrace;
-                this.disposed = true;
-            }
+        base.Dispose(disposing);
+    }
 
-            base.Dispose(disposing);
+    private ExportResult DefaultExport(in Batch<T> batch)
+    {
+        if (this.exportedItems == null)
+        {
+            return ExportResult.Failure;
         }
 
-        private ExportResult DefaultExport(in Batch<T> batch)
+        foreach (var data in batch)
         {
-            if (this.exportedItems == null)
-            {
-                return ExportResult.Failure;
-            }
-
-            foreach (var data in batch)
-            {
-                this.exportedItems.Add(data);
-            }
-
-            return ExportResult.Success;
+            this.exportedItems.Add(data);
         }
+
+        return ExportResult.Success;
     }
 }

src/OpenTelemetry.Exporter.InMemory/InMemoryExporterHelperExtensions.cs

@@ -18,22 +18,21 @@
 using OpenTelemetry.Exporter;
 using OpenTelemetry.Internal;
 
-namespace OpenTelemetry.Trace
+namespace OpenTelemetry.Trace;
+
+public static class InMemoryExporterHelperExtensions
 {
-    public static class InMemoryExporterHelperExtensions
+    /// <summary>
+    /// Adds InMemory exporter to the TracerProvider.
+    /// </summary>
+    /// <param name="builder"><see cref="TracerProviderBuilder"/> builder to use.</param>
+    /// <param name="exportedItems">Collection which will be populated with the exported <see cref="Activity"/>.</param>
+    /// <returns>The instance of <see cref="TracerProviderBuilder"/> to chain the calls.</returns>
+    public static TracerProviderBuilder AddInMemoryExporter(this TracerProviderBuilder builder, ICollection<Activity> exportedItems)
     {
-        /// <summary>
-        /// Adds InMemory exporter to the TracerProvider.
-        /// </summary>
-        /// <param name="builder"><see cref="TracerProviderBuilder"/> builder to use.</param>
-        /// <param name="exportedItems">Collection which will be populated with the exported <see cref="Activity"/>.</param>
-        /// <returns>The instance of <see cref="TracerProviderBuilder"/> to chain the calls.</returns>
-        public static TracerProviderBuilder AddInMemoryExporter(this TracerProviderBuilder builder, ICollection<Activity> exportedItems)
-        {
-            Guard.ThrowIfNull(builder);
-            Guard.ThrowIfNull(exportedItems);
+        Guard.ThrowIfNull(builder);
+        Guard.ThrowIfNull(exportedItems);
 
-            return builder.AddProcessor(new SimpleActivityExportProcessor(new InMemoryExporter<Activity>(exportedItems)));
-        }
+        return builder.AddProcessor(new SimpleActivityExportProcessor(new InMemoryExporter<Activity>(exportedItems)));
     }
 }

src/OpenTelemetry.Exporter.InMemory/InMemoryExporterLoggingExtensions.cs

@@ -17,63 +17,62 @@
 using OpenTelemetry.Exporter;
 using OpenTelemetry.Internal;
 
-namespace OpenTelemetry.Logs
+namespace OpenTelemetry.Logs;
+
+public static class InMemoryExporterLoggingExtensions
 {
-    public static class InMemoryExporterLoggingExtensions
+    /// <summary>
+    /// Adds InMemory exporter to the OpenTelemetryLoggerOptions.
+    /// </summary>
+    /// <param name="loggerOptions"><see cref="OpenTelemetryLoggerOptions"/> options to use.</param>
+    /// <param name="exportedItems">Collection which will be populated with the exported <see cref="LogRecord"/>.</param>
+    /// <returns>The supplied instance of <see cref="OpenTelemetryLoggerOptions"/> to chain the calls.</returns>
+    /// todo: [Obsolete("Call LoggerProviderBuilder.AddInMemoryExporter instead this method will be removed in a future version.")]
+    public static OpenTelemetryLoggerOptions AddInMemoryExporter(
+        this OpenTelemetryLoggerOptions loggerOptions,
+        ICollection<LogRecord> exportedItems)
     {
-        /// <summary>
-        /// Adds InMemory exporter to the OpenTelemetryLoggerOptions.
-        /// </summary>
-        /// <param name="loggerOptions"><see cref="OpenTelemetryLoggerOptions"/> options to use.</param>
-        /// <param name="exportedItems">Collection which will be populated with the exported <see cref="LogRecord"/>.</param>
-        /// <returns>The supplied instance of <see cref="OpenTelemetryLoggerOptions"/> to chain the calls.</returns>
-        /// todo: [Obsolete("Call LoggerProviderBuilder.AddInMemoryExporter instead this method will be removed in a future version.")]
-        public static OpenTelemetryLoggerOptions AddInMemoryExporter(
-            this OpenTelemetryLoggerOptions loggerOptions,
-            ICollection<LogRecord> exportedItems)
-        {
-            Guard.ThrowIfNull(loggerOptions);
-            Guard.ThrowIfNull(exportedItems);
+        Guard.ThrowIfNull(loggerOptions);
+        Guard.ThrowIfNull(exportedItems);
 
-            var logExporter = BuildExporter(exportedItems);
+        var logExporter = BuildExporter(exportedItems);
 
-            return loggerOptions.AddProcessor(
-                new SimpleLogRecordExportProcessor(logExporter));
-        }
+        return loggerOptions.AddProcessor(
+            new SimpleLogRecordExportProcessor(logExporter));
+    }
 
-        /// <summary>
-        /// Adds InMemory exporter to the LoggerProviderBuilder.
-        /// </summary>
-        /// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
-        /// <param name="exportedItems">Collection which will be populated with the exported <see cref="LogRecord"/>.</param>
-        /// <returns>The supplied instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
-        public static LoggerProviderBuilder AddInMemoryExporter(
-            this LoggerProviderBuilder loggerProviderBuilder,
-            ICollection<LogRecord> exportedItems)
-        {
-            Guard.ThrowIfNull(loggerProviderBuilder);
-            Guard.ThrowIfNull(exportedItems);
+    /// <summary>
+    /// Adds InMemory exporter to the LoggerProviderBuilder.
+    /// </summary>
+    /// <param name="loggerProviderBuilder"><see cref="LoggerProviderBuilder"/>.</param>
+    /// <param name="exportedItems">Collection which will be populated with the exported <see cref="LogRecord"/>.</param>
+    /// <returns>The supplied instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
+    public static LoggerProviderBuilder AddInMemoryExporter(
+        this LoggerProviderBuilder loggerProviderBuilder,
+        ICollection<LogRecord> exportedItems)
+    {
+        Guard.ThrowIfNull(loggerProviderBuilder);
+        Guard.ThrowIfNull(exportedItems);
 
-            var logExporter = BuildExporter(exportedItems);
+        var logExporter = BuildExporter(exportedItems);
 
-            return loggerProviderBuilder.AddProcessor(
-                new SimpleLogRecordExportProcessor(logExporter));
-        }
+        return loggerProviderBuilder.AddProcessor(
+            new SimpleLogRecordExportProcessor(logExporter));
+    }
 
-        private static InMemoryExporter<LogRecord> BuildExporter(ICollection<LogRecord> exportedItems)
-        {
-            return new InMemoryExporter<LogRecord>(
-                exportFunc: (in Batch<LogRecord> batch) => ExportLogRecord(in batch, exportedItems));
-        }
+    private static InMemoryExporter<LogRecord> BuildExporter(ICollection<LogRecord> exportedItems)
+    {
+        return new InMemoryExporter<LogRecord>(
+            exportFunc: (in Batch<LogRecord> batch) => ExportLogRecord(in batch, exportedItems));
+    }
 
-        private static ExportResult ExportLogRecord(in Batch<LogRecord> batch, ICollection<LogRecord> exportedItems)
+    private static ExportResult ExportLogRecord(in Batch<LogRecord> batch, ICollection<LogRecord> exportedItems)
+    {
+        foreach (var log in batch)
         {
-            foreach (var log in batch)
-            {
-                exportedItems.Add(log.Copy());
-            }
-
-            return ExportResult.Success;
+            exportedItems.Add(log.Copy());
         }
+
+        return ExportResult.Success;
     }
 }