wip: make log processors immutable

Workiva · Jan 31, 2025 · 4622316 · 4622316
1 parent 562833a
commit 4622316
Show file tree

Hide file tree

Showing 2 changed files with 37 additions and 23 deletions.
diff --git a/lib/src/sdk/logs/logger_provider.dart b/lib/src/sdk/logs/logger_provider.dart
@@ -1,6 +1,7 @@
 // Copyright 2021-2022 Workiva.
 // Licensed under the Apache License, Version 2.0. Please see https://github.com/Workiva/opentelemetry-dart/blob/master/LICENSE for more information
 
+import 'package:collection/collection.dart';
 import 'package:meta/meta.dart';
 import 'package:opentelemetry/api.dart' as api;
 import 'package:opentelemetry/sdk.dart' as sdk;
@@ -19,7 +20,7 @@ class LoggerProvider implements api.LoggerProvider {
 
   final LoggerConfig config;
 
-  final List<sdk.LogRecordProcessor> processors;
+  final List<sdk.LogRecordProcessor> _processors;
 
   final sdk.Resource? resource;
   final sdk.LogRecordLimits logRecordLimits;
@@ -32,9 +33,12 @@ class LoggerProvider implements api.LoggerProvider {
     this.logRecordLimits = const LogRecordLimitsImpl(),
     List<sdk.LogRecordProcessor>? processors,
     sdk.TimeProvider? timeProvider,
-  })  : processors = processors ?? <sdk.LogRecordProcessor>[],
+  })  : _processors = processors ?? <sdk.LogRecordProcessor>[],
         _timeProvider = timeProvider ?? sdk.DateTimeTimeProvider();
 
+  UnmodifiableListView<sdk.LogRecordProcessor> get processors =>
+      UnmodifiableListView(_processors);
+
   @override
   api.Logger get(
     String name, {
@@ -52,7 +56,8 @@ class LoggerProvider implements api.LoggerProvider {
       () => sdk.Logger(
         logRecordLimits: logRecordLimits,
         resource: resource,
-        instrumentationScope: sdk.InstrumentationScope(loggerName, version, schemaUrl, attributes),
+        instrumentationScope: sdk.InstrumentationScope(
+            loggerName, version, schemaUrl, attributes),
         timeProvider: _timeProvider,
         onLogEmit: (log) {
           for (final processor in processors) {
@@ -63,10 +68,6 @@ class LoggerProvider implements api.LoggerProvider {
     );
   }
 
-  void addLogRecordProcessor(sdk.LogRecordProcessor processor) {
-    processors.add(processor);
-  }
-
   Future<void> forceFlush() async {
     await Future.forEach(processors, (e) => e.forceFlush());
   }

diff --git a/test/unit/sdk/logs/logger_provider_test.dart b/test/unit/sdk/logs/logger_provider_test.dart
@@ -14,7 +14,8 @@ import '../../mocks.dart';
 void main() {
   setUpAll(() {
     registerFallbackValue(sdk.LogRecord(
-      instrumentationScope: sdk.InstrumentationScope('library_name', 'library_version', 'url://schema', []),
+      instrumentationScope: sdk.InstrumentationScope(
+          'library_name', 'library_version', 'url://schema', []),
       logRecordLimits: LogRecordLimitsImpl(),
     ));
   });
@@ -25,38 +26,47 @@ void main() {
     final barTracer = provider.get('bar');
     final fooWithVersionTracer = provider.get('foo', version: '1.0');
 
-    expect(fooTracer, allOf([isNot(barTracer), isNot(fooWithVersionTracer), same(provider.get('foo'))]));
+    expect(
+        fooTracer,
+        allOf([
+          isNot(barTracer),
+          isNot(fooWithVersionTracer),
+          same(provider.get('foo'))
+        ]));
 
     expect(provider.processors, isA<List<sdk.LogRecordProcessor>>());
   });
 
   test('tracerProvider custom span processors', () {
     final mockProcessor1 = MockLogRecordProcessor();
     final mockProcessor2 = MockLogRecordProcessor();
-    final provider = sdk.LoggerProvider(processors: [mockProcessor1, mockProcessor2]);
+    final provider =
+        sdk.LoggerProvider(processors: [mockProcessor1, mockProcessor2]);
 
     expect(provider.processors, [mockProcessor1, mockProcessor2]);
   });
 
   test('traceProvider custom timeProvider', () {
     final mockTimeProvider = FakeTimeProvider(now: Int64(123));
     final mockProcessor1 = MockLogRecordProcessor();
-    final provider = sdk.LoggerProvider(timeProvider: mockTimeProvider, processors: [mockProcessor1]);
+    final provider = sdk.LoggerProvider(
+        timeProvider: mockTimeProvider, processors: [mockProcessor1]);
     provider.get('foo').emit();
     verify(() => mockProcessor1.onEmit(any(
-      that: predicate((a) {
-        if (a is! sdk.ReadWriteLogRecord) return false;
-        return a.timeStamp == 123 && a.observedTimestamp == 123;
-      }),
-    ))).called(1);
+          that: predicate((a) {
+            if (a is! sdk.ReadWriteLogRecord) return false;
+            return a.timeStamp == 123 && a.observedTimestamp == 123;
+          }),
+        ))).called(1);
   });
 
   test('loggerProvider force flushes all processors', () async {
     final mockProcessor1 = MockLogRecordProcessor();
     final mockProcessor2 = MockLogRecordProcessor();
     when(mockProcessor1.forceFlush).thenAnswer((_) async => Future.value());
     when(mockProcessor2.forceFlush).thenAnswer((_) async => Future.value());
-    await sdk.LoggerProvider(processors: [mockProcessor1, mockProcessor2]).forceFlush();
+    await sdk.LoggerProvider(processors: [mockProcessor1, mockProcessor2])
+        .forceFlush();
 
     verify(mockProcessor1.forceFlush).called(1);
     verify(mockProcessor2.forceFlush).called(1);
@@ -67,17 +77,20 @@ void main() {
     final mockProcessor2 = MockLogRecordProcessor();
     when(mockProcessor1.shutdown).thenAnswer((_) async => Future.value());
     when(mockProcessor2.shutdown).thenAnswer((_) async => Future.value());
-    await sdk.LoggerProvider(processors: [mockProcessor1, mockProcessor2]).shutdown();
+    await sdk.LoggerProvider(processors: [mockProcessor1, mockProcessor2])
+        .shutdown();
 
     verify(mockProcessor1.shutdown).called(1);
     verify(mockProcessor2.shutdown).called(1);
   });
 
-  test('logger provider test add processor', () {
-    final provider = sdk.LoggerProvider()
-      ..addLogRecordProcessor(const sdk.NoopLogRecordProcessor())
-      ..addLogRecordProcessor(const sdk.NoopLogRecordProcessor());
+  test('loggerProvider processors is immutable', () async {
+    final mockProcessor1 = MockLogRecordProcessor();
+    final mockProcessor2 = MockLogRecordProcessor();
+    when(mockProcessor1.shutdown).thenAnswer((_) async => Future.value());
+    when(mockProcessor2.shutdown).thenAnswer((_) async => Future.value());
+    final provider = sdk.LoggerProvider(processors: [mockProcessor1]);
 
-    expect(provider.processors.length, 2);
+    expect(() => provider.processors.add(mockProcessor2), throwsUnsupportedError);
   });
 }