Skip to content

Commit 5ba0a86

Browse files
rajkumar-rangarajrajkumar-rangaraj
committed
Merge branch 'out-of-process-collection' of https://github.com/open-telemetry/opentelemetry-dotnet-instrumentation into rajrang/nextGenCI
2 parents e11e881 + d102343 commit 5ba0a86

22 files changed

+4272
-15
lines changed

‎next-gen/test/OpenTelemetry.AutoInstrumentation.Sdk.Tests/Logging/BufferedLogRecordBatchTests.cs‎

Lines changed: 214 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,214 @@
1+
// Copyright The OpenTelemetry Authors
2+
// SPDX-License-Identifier: Apache-2.0
3+
4+
using OpenTelemetry.Logging;
5+
using OpenTelemetry.Resources;
6+
using Xunit;
7+
8+
namespace OpenTelemetry.AutoInstrumentation.Sdk.Tests.Logging;
9+
10+
public sealed class BufferedLogRecordBatchTests
11+
{
12+
[Fact]
13+
public void Constructor_WithValidBufferedBatch_DoesNotThrow()
14+
{
15+
// Arrange
16+
var resource = new Resource(new List<KeyValuePair<string, object>>());
17+
var bufferedBatch = new BufferedTelemetryBatch<BufferedLogRecord>(resource);
18+
19+
// Act & Assert - Should not throw
20+
_ = new BufferedLogRecordBatch(bufferedBatch);
21+
22+
// Assert that construction succeeds
23+
Assert.True(true);
24+
}
25+
26+
[Fact]
27+
public void WriteTo_WithEmptyBatch_WritesNothing()
28+
{
29+
// Arrange
30+
var resource = new Resources.Resource(new List<KeyValuePair<string, object>>());
31+
var bufferedBatch = new BufferedTelemetryBatch<BufferedLogRecord>(resource);
32+
var batch = new BufferedLogRecordBatch(bufferedBatch);
33+
var writer = new TestLogRecordBatchWriter();
34+
35+
// Act
36+
bool result = batch.WriteTo(writer);
37+
38+
// Assert
39+
Assert.True(result);
40+
Assert.Equal(0, writer.LogRecordCount);
41+
}
42+
43+
[Fact]
44+
public void WriteTo_WithSingleLogRecord_WritesCorrectly()
45+
{
46+
// Arrange
47+
var resource = new Resource(new List<KeyValuePair<string, object>>());
48+
var bufferedBatch = new BufferedTelemetryBatch<BufferedLogRecord>(resource);
49+
50+
var activityContext = new ActivityContext(
51+
ActivityTraceId.CreateRandom(),
52+
ActivitySpanId.CreateRandom(),
53+
ActivityTraceFlags.Recorded);
54+
55+
var scope = new InstrumentationScope("test.scope") { Version = "1.0.0" };
56+
var logRecordInfo = new LogRecordInfo(scope)
57+
{
58+
TimestampUtc = DateTime.UtcNow,
59+
Severity = LogRecordSeverity.Info,
60+
Body = "Test message"
61+
};
62+
63+
var attributes = new List<KeyValuePair<string, object?>>
64+
{
65+
new("key1", "value1"),
66+
new("key2", 42)
67+
};
68+
69+
var logRecord = new LogRecord(in activityContext, in logRecordInfo)
70+
{
71+
Attributes = attributes.ToArray()
72+
};
73+
74+
var bufferedLogRecord = new BufferedLogRecord(in logRecord);
75+
bufferedBatch.Add(bufferedLogRecord);
76+
77+
var batch = new BufferedLogRecordBatch(bufferedBatch);
78+
var writer = new TestLogRecordBatchWriter();
79+
80+
// Act
81+
bool result = batch.WriteTo(writer);
82+
83+
// Assert
84+
Assert.True(result);
85+
Assert.Equal(1, writer.LogRecordCount);
86+
Assert.NotNull(writer.LastLogRecordInfo);
87+
Assert.Equal("Test message", writer.LastLogRecordInfo.Value.Body);
88+
Assert.Equal(LogRecordSeverity.Info, writer.LastLogRecordInfo.Value.Severity);
89+
}
90+
91+
[Fact]
92+
public void WriteTo_WithMultipleLogRecords_WritesAllCorrectly()
93+
{
94+
// Arrange
95+
var resource = new Resource(new List<KeyValuePair<string, object>>());
96+
var bufferedBatch = new BufferedTelemetryBatch<BufferedLogRecord>(resource);
97+
98+
var scope = new InstrumentationScope("test.scope") { Version = "1.0.0" };
99+
100+
// Create multiple log records
101+
const int recordCount = 3;
102+
for (int i = 0; i < recordCount; i++)
103+
{
104+
var activityContext = new ActivityContext(
105+
ActivityTraceId.CreateRandom(),
106+
ActivitySpanId.CreateRandom(),
107+
ActivityTraceFlags.Recorded);
108+
109+
var logRecordInfo = new LogRecordInfo(scope)
110+
{
111+
TimestampUtc = DateTime.UtcNow.AddSeconds(i),
112+
Severity = LogRecordSeverity.Info,
113+
Body = $"Test message {i}"
114+
};
115+
116+
var logRecord = new LogRecord(in activityContext, in logRecordInfo);
117+
118+
var bufferedLogRecord = new BufferedLogRecord(in logRecord);
119+
bufferedBatch.Add(bufferedLogRecord);
120+
}
121+
122+
var batch = new BufferedLogRecordBatch(bufferedBatch);
123+
var writer = new TestLogRecordBatchWriter();
124+
125+
// Act
126+
bool result = batch.WriteTo(writer);
127+
128+
// Assert
129+
Assert.True(result);
130+
Assert.Equal(recordCount, writer.LogRecordCount);
131+
}
132+
133+
[Fact]
134+
public void WriteTo_WithDifferentSeverities_WritesAllCorrectly()
135+
{
136+
// Arrange
137+
var resource = new Resource(new List<KeyValuePair<string, object>>());
138+
var bufferedBatch = new BufferedTelemetryBatch<BufferedLogRecord>(resource);
139+
140+
var scope = new InstrumentationScope("test.scope") { Version = "1.0.0" };
141+
var severities = new[]
142+
{
143+
LogRecordSeverity.Debug,
144+
LogRecordSeverity.Info,
145+
LogRecordSeverity.Warn,
146+
LogRecordSeverity.Error
147+
};
148+
149+
foreach (var severity in severities)
150+
{
151+
var activityContext = default(ActivityContext);
152+
var logRecordInfo = new LogRecordInfo(scope)
153+
{
154+
Severity = severity,
155+
Body = $"Message with {severity} severity"
156+
};
157+
158+
var logRecord = new LogRecord(in activityContext, in logRecordInfo);
159+
var bufferedLogRecord = new BufferedLogRecord(in logRecord);
160+
bufferedBatch.Add(bufferedLogRecord);
161+
}
162+
163+
var batch = new BufferedLogRecordBatch(bufferedBatch);
164+
var writer = new TestLogRecordBatchWriter();
165+
166+
// Act
167+
bool result = batch.WriteTo(writer);
168+
169+
// Assert
170+
Assert.True(result);
171+
Assert.Equal(severities.Length, writer.LogRecordCount);
172+
}
173+
174+
private sealed class TestLogRecordBatchWriter : LogRecordBatchWriter
175+
{
176+
public int LogRecordCount { get; private set; }
177+
178+
public LogRecordInfo? LastLogRecordInfo { get; private set; }
179+
180+
public bool BeginBatchCalled { get; private set; }
181+
182+
public bool EndBatchCalled { get; private set; }
183+
184+
public bool BeginInstrumentationScopeCalled { get; private set; }
185+
186+
public bool EndInstrumentationScopeCalled { get; private set; }
187+
188+
public override void BeginBatch(Resource resource)
189+
{
190+
BeginBatchCalled = true;
191+
}
192+
193+
public override void EndBatch()
194+
{
195+
EndBatchCalled = true;
196+
}
197+
198+
public override void BeginInstrumentationScope(InstrumentationScope instrumentationScope)
199+
{
200+
BeginInstrumentationScopeCalled = true;
201+
}
202+
203+
public override void EndInstrumentationScope()
204+
{
205+
EndInstrumentationScopeCalled = true;
206+
}
207+
208+
public override void WriteLogRecord(in LogRecord logRecord)
209+
{
210+
LogRecordCount++;
211+
LastLogRecordInfo = logRecord.Info;
212+
}
213+
}
214+
}

‎next-gen/test/OpenTelemetry.AutoInstrumentation.Sdk.Tests/Logging/BufferedLogRecordTests.cs‎

Lines changed: 164 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,164 @@
1+
// Copyright The OpenTelemetry Authors
2+
// SPDX-License-Identifier: Apache-2.0
3+
4+
using OpenTelemetry.Logging;
5+
using Xunit;
6+
7+
namespace OpenTelemetry.AutoInstrumentation.Sdk.Tests.Logging;
8+
9+
public sealed class BufferedLogRecordTests
10+
{
11+
[Fact]
12+
public void Constructor_WithValidLogRecord_SetsPropertiesCorrectly()
13+
{
14+
// Arrange
15+
var activityContext = new ActivityContext(
16+
ActivityTraceId.CreateRandom(),
17+
ActivitySpanId.CreateRandom(),
18+
ActivityTraceFlags.Recorded);
19+
20+
var scope = new InstrumentationScope("test.scope") { Version = "1.0.0" };
21+
var logRecordInfo = new LogRecordInfo(scope)
22+
{
23+
TimestampUtc = DateTime.UtcNow,
24+
ObservedTimestampUtc = DateTime.UtcNow,
25+
Severity = LogRecordSeverity.Info,
26+
SeverityText = "Info",
27+
Body = "Test log message"
28+
};
29+
30+
var attributes = new List<KeyValuePair<string, object?>>
31+
{
32+
new("key1", "value1"),
33+
new("key2", 42),
34+
new("key3", true)
35+
};
36+
37+
var logRecord = new LogRecord(in activityContext, in logRecordInfo)
38+
{
39+
Attributes = attributes.ToArray()
40+
};
41+
42+
// Act
43+
var bufferedLogRecord = new BufferedLogRecord(in logRecord);
44+
45+
// Assert
46+
Assert.Equal(activityContext, bufferedLogRecord.SpanContext);
47+
Assert.Equal(logRecordInfo, bufferedLogRecord.Info);
48+
Assert.Equal(scope, bufferedLogRecord.Scope);
49+
Assert.Null(bufferedLogRecord.Next);
50+
}
51+
52+
[Fact]
53+
public void Next_Property_CanBeSetAndGet()
54+
{
55+
// Arrange
56+
var activityContext = default(ActivityContext);
57+
var scope = new InstrumentationScope("test.scope") { Version = "1.0.0" };
58+
var logRecordInfo = new LogRecordInfo(scope);
59+
var logRecord = new LogRecord(in activityContext, in logRecordInfo);
60+
61+
var bufferedLogRecord1 = new BufferedLogRecord(in logRecord);
62+
var bufferedLogRecord2 = new BufferedLogRecord(in logRecord);
63+
64+
// Act
65+
bufferedLogRecord1.Next = bufferedLogRecord2;
66+
67+
// Assert
68+
Assert.Same(bufferedLogRecord2, bufferedLogRecord1.Next);
69+
}
70+
71+
[Fact]
72+
public void ToLogRecord_ReconstructsOriginalLogRecord()
73+
{
74+
// Arrange
75+
var activityContext = new ActivityContext(
76+
ActivityTraceId.CreateRandom(),
77+
ActivitySpanId.CreateRandom(),
78+
ActivityTraceFlags.Recorded);
79+
80+
var scope = new InstrumentationScope("test.scope") { Version = "1.0.0" };
81+
var originalTimestamp = DateTime.UtcNow;
82+
var originalObservedTimestamp = DateTime.UtcNow.AddMilliseconds(100);
83+
84+
var logRecordInfo = new LogRecordInfo(scope)
85+
{
86+
TimestampUtc = originalTimestamp,
87+
ObservedTimestampUtc = originalObservedTimestamp,
88+
Severity = LogRecordSeverity.Warn,
89+
SeverityText = "Warning",
90+
Body = "Test warning message"
91+
};
92+
93+
var attributes = new List<KeyValuePair<string, object?>>
94+
{
95+
new("service.name", "test-service"),
96+
new("level", "warn"),
97+
new("count", 10)
98+
};
99+
100+
var originalLogRecord = new LogRecord(in activityContext, in logRecordInfo)
101+
{
102+
Attributes = attributes.ToArray()
103+
};
104+
105+
var bufferedLogRecord = new BufferedLogRecord(in originalLogRecord);
106+
107+
// Act
108+
bufferedLogRecord.ToLogRecord(out LogRecord reconstructedLogRecord);
109+
110+
// Assert
111+
Assert.Equal(originalLogRecord.SpanContext, reconstructedLogRecord.SpanContext);
112+
Assert.Equal(originalLogRecord.Info, reconstructedLogRecord.Info);
113+
114+
// Verify attributes are correctly reconstructed
115+
var originalAttributesList = originalLogRecord.Attributes.ToArray();
116+
var reconstructedAttributesList = reconstructedLogRecord.Attributes.ToArray();
117+
118+
Assert.Equal(originalAttributesList.Length, reconstructedAttributesList.Length);
119+
120+
for (int i = 0; i < originalAttributesList.Length; i++)
121+
{
122+
Assert.Equal(originalAttributesList[i].Key, reconstructedAttributesList[i].Key);
123+
Assert.Equal(originalAttributesList[i].Value, reconstructedAttributesList[i].Value);
124+
}
125+
}
126+
127+
[Fact]
128+
public void ToLogRecord_WithEmptyAttributes_Works()
129+
{
130+
// Arrange
131+
var activityContext = default(ActivityContext);
132+
var scope = new InstrumentationScope("test.scope") { Version = "1.0.0" };
133+
var logRecordInfo = new LogRecordInfo(scope);
134+
var logRecord = new LogRecord(in activityContext, in logRecordInfo);
135+
136+
var bufferedLogRecord = new BufferedLogRecord(in logRecord);
137+
138+
// Act
139+
bufferedLogRecord.ToLogRecord(out LogRecord reconstructedLogRecord);
140+
141+
// Assert
142+
Assert.Equal(activityContext, reconstructedLogRecord.SpanContext);
143+
Assert.Equal(logRecordInfo, reconstructedLogRecord.Info);
144+
Assert.True(reconstructedLogRecord.Attributes.IsEmpty);
145+
}
146+
147+
[Fact]
148+
public void Scope_ReturnsCorrectInstrumentationScope()
149+
{
150+
// Arrange
151+
var activityContext = default(ActivityContext);
152+
var scope = new InstrumentationScope("custom.scope") { Version = "2.1.0" };
153+
var logRecordInfo = new LogRecordInfo(scope);
154+
var logRecord = new LogRecord(in activityContext, in logRecordInfo);
155+
156+
// Act
157+
var bufferedLogRecord = new BufferedLogRecord(in logRecord);
158+
159+
// Assert
160+
Assert.Same(scope, bufferedLogRecord.Scope);
161+
Assert.Equal("custom.scope", bufferedLogRecord.Scope.Name);
162+
Assert.Equal("2.1.0", bufferedLogRecord.Scope.Version);
163+
}
164+
}

0 commit comments

Comments
 (0)