Add tests

Author: pakrym

src/Microsoft.Extensions.Logging.AzureWebAppDiagnostics/AzureWebAppDiagnosticsLoggerProvider.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Extensions.Logging.Abstractions.Internal;
 using Microsoft.Extensions.Logging.AzureWebAppDiagnostics.Internal;
 using Serilog;

src/Microsoft.Extensions.Logging.AzureWebAppDiagnostics/Internal/AzureBlobLoggerProvider.cs

@@ -74,7 +74,14 @@ public Logger ConfigureLogger(IWebAppLogConfigurationReader reader)
             var messageFormatter = new MessageTemplateTextFormatter(_outputTemplate, null);
             var container = new CloudBlobContainer(new Uri(reader.Current.BlobContainerUrl));
             var fileName = _instanceId + "-" + _fileName;
-            var azureBlobSink = new AzureBlobSink(container, _appName, fileName, messageFormatter, _batchSize, _period);
+            var azureBlobSink = new AzureBlobSink(
+                name => new BlobAppendReferenceWrapper(container.GetAppendBlobReference(name)),
+                _appName,
+                fileName,
+                messageFormatter,
+                _batchSize,
+                _period);
+
             var backgroundSink = new BackgroundSink(azureBlobSink, _backgroundQueueSize);
             var loggerConfiguration = new LoggerConfiguration();
 

src/Microsoft.Extensions.Logging.AzureWebAppDiagnostics/Internal/AzureBlobSink.cs

@@ -7,7 +7,6 @@
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.WindowsAzure.Storage;
-using Microsoft.WindowsAzure.Storage.Blob;
 using Serilog.Core;
 using Serilog.Events;
 using Serilog.Formatting;
@@ -20,23 +19,21 @@ namespace Microsoft.Extensions.Logging.AzureWebAppDiagnostics.Internal
     /// </summary>
     public class AzureBlobSink : PeriodicBatchingSink
     {
-        private const string BlobPathSeparator = "/";
-
         private readonly string _appName;
         private readonly string _fileName;
         private readonly ITextFormatter _formatter;
-        private readonly CloudBlobContainer _container;
+        private readonly Func<string, ICloudAppendBlob> _blobReferenceFactory;
 
         /// <summary>
         /// Creates a new instance of <see cref="AzureBlobSink"/>
         /// </summary>
-        /// <param name="container">The container to store logs to.</param>
+        /// <param name="blobReferenceFactory">The container to store logs to.</param>
         /// <param name="appName">The application name to use in blob path generation.</param>
         /// <param name="fileName">The last segment of blob name.</param>
         /// <param name="formatter">The <see cref="ITextFormatter"/> for log messages.</param>
         /// <param name="batchSizeLimit">The maximum number of events to include in a single batch.</param>
         /// <param name="period">The time to wait between checking for event batches.</param>
-        public AzureBlobSink(CloudBlobContainer container,
+        public AzureBlobSink(Func<string, ICloudAppendBlob> blobReferenceFactory,
             string appName,
             string fileName,
             ITextFormatter formatter,
@@ -67,7 +64,7 @@ public AzureBlobSink(CloudBlobContainer container,
             _appName = appName;
             _fileName = fileName;
             _formatter = formatter;
-            _container = container;
+            _blobReferenceFactory = blobReferenceFactory;
         }
 
         /// <inheritdoc />
@@ -76,37 +73,28 @@ protected override async Task EmitBatchAsync(IEnumerable<LogEvent> events)
             var eventGroups = events.GroupBy(GetBlobKey);
             foreach (var eventGroup in eventGroups)
             {
-                var blobName = string.Concat(
-                    _appName, BlobPathSeparator,
-                    eventGroup.Key.Item1, BlobPathSeparator,
-                    eventGroup.Key.Item2, BlobPathSeparator,
-                    eventGroup.Key.Item3, BlobPathSeparator,
-                    eventGroup.Key.Item4, BlobPathSeparator,
-                    _fileName
-                );
+                var key = eventGroup.Key;
+                var blobName = $"{_appName}/{key.Item1}/{key.Item2:00}/{key.Item3:00}/{key.Item4:00}/{_fileName}";
 
-                var blob = _container.GetAppendBlobReference(blobName);
+                var blob = _blobReferenceFactory(blobName);
 
-                CloudBlobStream stream;
+                Stream stream;
                 try
                 {
-                    stream = await blob.OpenWriteAsync(createNew: false);
+                    stream = await blob.OpenWriteAsync();
                 }
                 // Blob does not exist
                 catch (StorageException ex) when (ex.RequestInformation.HttpStatusCode == 404)
                 {
-                    await blob.CreateOrReplaceAsync(AccessCondition.GenerateIfNotExistsCondition(), null, null);
-                    stream = await blob.OpenWriteAsync(createNew: false);
+                    await blob.CreateAsync();
+                    stream = await blob.OpenWriteAsync();
                 }
 
-                using (stream)
+                using (var writer = new StreamWriter(stream))
                 {
-                    using (var writer = new StreamWriter(stream))
+                    foreach (var logEvent in eventGroup)
                     {
-                        foreach (var logEvent in eventGroup)
-                        {
-                            _formatter.Format(logEvent, writer);
-                        }
+                        _formatter.Format(logEvent, writer);
                     }
                 }
             }

src/Microsoft.Extensions.Logging.AzureWebAppDiagnostics/Internal/BlobAppendReferenceWrapper.cs

@@ -0,0 +1,36 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.IO;
+using System.Threading.Tasks;
+using Microsoft.WindowsAzure.Storage;
+using Microsoft.WindowsAzure.Storage.Blob;
+
+namespace Microsoft.Extensions.Logging.AzureWebAppDiagnostics.Internal
+{
+    /// <inheritdoc />
+    public class BlobAppendReferenceWrapper : ICloudAppendBlob
+    {
+        private readonly CloudAppendBlob _cloudAppendBlob;
+
+        /// <summary>
+        /// Creates new instance of <see cref="BlobAppendReferenceWrapper"/>.
+        /// </summary>
+        /// <param name="cloudAppendBlob">The <see cref="CloudAppendBlob"/> instance to wrap.</param>
+        public BlobAppendReferenceWrapper(CloudAppendBlob cloudAppendBlob)
+        {
+            _cloudAppendBlob = cloudAppendBlob;
+        }
+        /// <inheritdoc />
+        public async Task<Stream> OpenWriteAsync()
+        {
+            return await _cloudAppendBlob.OpenWriteAsync(createNew: false);
+        }
+
+        /// <inheritdoc />
+        public async Task CreateAsync()
+        {
+            await _cloudAppendBlob.CreateOrReplaceAsync(AccessCondition.GenerateIfNotExistsCondition(), options: null, operationContext: null);
+        }
+    }
+}

src/Microsoft.Extensions.Logging.AzureWebAppDiagnostics/Internal/ICloudAppendBlob.cs

@@ -0,0 +1,26 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Microsoft.Extensions.Logging.AzureWebAppDiagnostics.Internal
+{
+    /// <summary>
+    /// Represents an append blob, a type of blob where blocks of data are always committed to the end of the blob.
+    /// </summary>
+    public interface ICloudAppendBlob
+    {
+        /// <summary>
+        /// Initiates an asynchronous operation to open a stream for writing to the blob.
+        /// </summary>
+        /// <returns>A <see cref="T:System.Threading.Tasks.Task`1" /> object of type <see cref="Stream" /> that represents the asynchronous operation.</returns>
+        Task<Stream> OpenWriteAsync();
+
+        /// <summary>
+        /// Initiates an asynchronous operation to create an empty append blob.
+        /// </summary>
+        /// <returns>A <see cref="T:System.Threading.Tasks.Task" /> object that represents the asynchronous operation.</returns>
+        Task CreateAsync();
+    }
+}

test/Microsoft.Extensions.Logging.AzureWebAppDiagnostics.Test/AzureBlobSinkTests.cs

@@ -0,0 +1,179 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging.AzureWebAppDiagnostics.Internal;
+using Microsoft.WindowsAzure.Storage;
+using Moq;
+using Serilog;
+using Serilog.Core;
+using Serilog.Events;
+using Serilog.Formatting.Display;
+using Serilog.Parsing;
+using Xunit;
+
+namespace Microsoft.Extensions.Logging.AzureWebApps.Test
+{
+    public class AzureBlobSinkTests
+    {
+        [Fact]
+        public void WritesMessagesInBatches()
+        {
+            var blob = new Mock<ICloudAppendBlob>();
+            var buffers = new List<byte[]>();
+            blob.Setup(b => b.OpenWriteAsync()).Returns(() => Task.FromResult((Stream)new TestMemoryStream(buffers)));
+
+            var sink = new TestAzureBlobSink(name => blob.Object, 5);
+            var logger = CreateLogger(sink);
+
+            for (int i = 0; i < 5; i++)
+            {
+                logger.Information("Text " + i);
+            }
+
+            Assert.True(sink.CountdownEvent.Wait(TimeSpan.FromSeconds(1)));
+
+#if NET451
+            Assert.Equal(1, buffers.Count);
+            Assert.Equal(Encoding.UTF8.GetString(buffers[0]), @"Information Text 0
+Information Text 1
+Information Text 2
+Information Text 3
+Information Text 4
+");
+#else
+            // PeriodicBatchingSink always writes first message as seperate batch on coreclr
+            // https://github.com/serilog/serilog-sinks-periodicbatching/issues/7
+            Assert.Equal(2, buffers.Count);
+            Assert.Equal(Encoding.UTF8.GetString(buffers[0]), "Information Text 0\r\n");
+            Assert.Equal(Encoding.UTF8.GetString(buffers[1]), @"Information Text 1
+Information Text 2
+Information Text 3
+Information Text 4
+");
+#endif
+        }
+
+        [Fact]
+        public void GroupsByHour()
+        {
+            var blob = new Mock<ICloudAppendBlob>();
+            var buffers = new List<byte[]>();
+            var names = new List<string>();
+
+            blob.Setup(b => b.OpenWriteAsync()).Returns(() => Task.FromResult((Stream)new TestMemoryStream(buffers)));
+
+            var sink = new TestAzureBlobSink(name =>
+            {
+                names.Add(name);
+                return blob.Object;
+            }, 3);
+            var logger = CreateLogger(sink);
+
+            var startDate = new DateTime(2016, 8, 29, 22, 0, 0);
+            for (int i = 0; i < 3; i++)
+            {
+                var addHours = startDate.AddHours(i);
+                logger.Write(new LogEvent(
+                    new DateTimeOffset(addHours),
+                    LogEventLevel.Information,
+                    null,
+                    new MessageTemplate("Text", Enumerable.Empty<MessageTemplateToken>()),
+                    Enumerable.Empty<LogEventProperty>()));
+            }
+
+            Assert.True(sink.CountdownEvent.Wait(TimeSpan.FromSeconds(1)));
+
+            Assert.Equal(3, buffers.Count);
+
+            Assert.Equal("appname/2016/08/29/22/filename", names[0]);
+            Assert.Equal("appname/2016/08/29/23/filename", names[1]);
+            Assert.Equal("appname/2016/08/30/00/filename", names[2]);
+        }
+
+        [Fact]
+        public void CreatesBlobIfNotExists()
+        {
+            var blob = new Mock<ICloudAppendBlob>();
+            var buffers = new List<byte[]>();
+            bool created = false;
+
+            blob.Setup(b => b.OpenWriteAsync()).Returns(() =>
+            {
+                if (!created)
+                {
+                    throw new StorageException(new RequestResult() { HttpStatusCode = 404 }, string.Empty, null);
+                }
+                return Task.FromResult((Stream) new TestMemoryStream(buffers));
+            });
+
+            blob.Setup(b => b.CreateAsync()).Returns(() =>
+            {
+                created = true;
+                return Task.FromResult(0);
+            });
+
+            var sink = new TestAzureBlobSink((name) => blob.Object, 1);
+            var logger = CreateLogger(sink);
+            logger.Information("Text");
+
+            Assert.True(sink.CountdownEvent.Wait(TimeSpan.FromSeconds(1)));
+
+            Assert.Equal(1, buffers.Count);
+            Assert.Equal(true, created);
+        }
+
+        private static Logger CreateLogger(AzureBlobSink sink)
+        {
+            var loggerConfiguration = new LoggerConfiguration();
+            loggerConfiguration.WriteTo.Sink(sink);
+            var logger = loggerConfiguration.CreateLogger();
+            return logger;
+        }
+
+        private class TestAzureBlobSink: AzureBlobSink
+        {
+            public CountdownEvent CountdownEvent { get; }
+
+            public TestAzureBlobSink(Func<string, ICloudAppendBlob> blob, int count):base(
+                blob,
+                "appname",
+                "filename",
+                new MessageTemplateTextFormatter("{Level} {Message}{NewLine}", CultureInfo.InvariantCulture),
+                10,
+                TimeSpan.FromSeconds(0.1))
+            {
+                CountdownEvent = new CountdownEvent(count);
+            }
+
+            protected override async Task EmitBatchAsync(IEnumerable<LogEvent> events)
+            {
+                await base.EmitBatchAsync(events);
+                CountdownEvent.Signal(events.Count());
+            }
+        }
+
+        private class TestMemoryStream : MemoryStream
+        {
+            public List<byte[]> Buffers { get; }
+
+            public TestMemoryStream(List<byte[]> buffers)
+            {
+                Buffers = buffers;
+            }
+
+            protected override void Dispose(bool disposing)
+            {
+                Buffers.Add(ToArray());
+                base.Dispose(disposing);
+            }
+        }
+    }
+}