direct spandata export API (#100)

* direct spandata export API

* fix merge issues and build

Author: SergeyKanzhelev

src/OpenCensus.Abstractions/Trace/Export/ISpanExporter.cs

@@ -17,6 +17,9 @@
 namespace OpenCensus.Trace.Export
 {
     using System;
+    using System.Collections.Generic;
+    using System.Threading;
+    using System.Threading.Tasks;
 
     /// <summary>
     /// Span exporter.
@@ -29,6 +32,16 @@ public interface ISpanExporter : IDisposable
         /// <param name="span">Span to export.</param>
         void AddSpan(ISpan span);
 
+        /// <summary>
+        /// Exports collection of spans. This method is used for the situation when the
+        /// span objects have been created from external sources, not using the Open Censis API.
+        /// For example, read from file or generated from objects recieved in async queue.
+        /// </summary>
+        /// <param name="export">Set of <see cref="ISpanData"/> objects to export.</param>
+        /// <param name="token">Cancellation token.</param>
+        /// <returns>A <see cref="Task"/> representing asynchronous export operation.</returns>
+        Task ExportAsync(IEnumerable<ISpanData> export, CancellationToken token);
+
         /// <summary>
         /// Registers the exporter handler.
         /// </summary>

src/OpenCensus/Trace/Export/NoopSpanExporter.cs

@@ -16,12 +16,21 @@
 
 namespace OpenCensus.Trace.Export
 {
+    using System.Collections.Generic;
+    using System.Threading;
+    using System.Threading.Tasks;
+
     internal sealed class NoopSpanExporter : ISpanExporter
     {
         public void AddSpan(ISpan span)
         {
         }
 
+        public Task ExportAsync(IEnumerable<ISpanData> export, CancellationToken token)
+        {
+            return Task.CompletedTask;
+        }
+
         public void Dispose()
         {
         }

src/OpenCensus/Trace/Export/SpanExporter.cs

@@ -16,7 +16,9 @@
 
 namespace OpenCensus.Trace.Export
 {
+    using System.Collections.Generic;
     using System.Threading;
+    using System.Threading.Tasks;
     using OpenCensus.Common;
 
     public sealed class SpanExporter : SpanExporterBase
@@ -49,6 +51,14 @@ public override void AddSpan(ISpan span)
             this.worker.AddSpan(span);
         }
 
+        /// <inheritdoc/>
+        public override Task ExportAsync(IEnumerable<ISpanData> export, CancellationToken token)
+        {
+            this.worker.ExportAsync(export, token);
+
+            return Task.CompletedTask;
+        }
+
         public override void RegisterHandler(string name, IHandler handler)
         {
             this.worker.RegisterHandler(name, handler);

src/OpenCensus/Trace/Export/SpanExporterBase.cs

@@ -14,6 +14,10 @@
 // limitations under the License.
 // </copyright>
 
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
 namespace OpenCensus.Trace.Export
 {
     public abstract class SpanExporterBase : ISpanExporter
@@ -30,6 +34,9 @@ public static ISpanExporter NoopSpanExporter
 
         public abstract void AddSpan(ISpan span);
 
+        /// <inheritdoc/>
+        public abstract Task ExportAsync(IEnumerable<ISpanData> export, CancellationToken token);
+
         public abstract void Dispose();
 
         public abstract void RegisterHandler(string name, IHandler handler);

src/OpenCensus/Trace/Export/SpanExporterWorker.cs

@@ -19,6 +19,8 @@ namespace OpenCensus.Trace.Export
     using System;
     using System.Collections.Concurrent;
     using System.Collections.Generic;
+    using System.Threading;
+    using System.Threading.Tasks;
     using OpenCensus.Common;
     using OpenCensus.Implementation;
 
@@ -54,6 +56,25 @@ internal void AddSpan(ISpan span)
             }
         }
 
+        internal Task ExportAsync(IEnumerable<ISpanData> export, CancellationToken token)
+        {
+            var handlers = this.serviceHandlers.Values;
+            foreach (var handler in handlers)
+            {
+                try
+                {
+                    // TODO: when handlers interface will be switched to async - this need to await
+                    handler.Export(export);
+                }
+                catch (Exception ex)
+                {
+                    OpenCensusEventSource.Log.ExporterThrownExceptionWarning(ex);
+                }
+            }
+
+            return Task.CompletedTask;
+        }
+
         internal void Run(object obj)
         {
             List<ISpanData> toExport = new List<ISpanData>();
@@ -67,7 +88,7 @@ internal void Run(object obj)
                         this.BuildList(item, toExport);
 
                         // Export them
-                        this.Export(toExport);
+                        this.ExportAsync(toExport, CancellationToken.None);
 
                         // Get ready for next batch
                         toExport.Clear();
@@ -128,21 +149,5 @@ private void BuildList(ISpan item, List<ISpanData> toExport)
                 }
             }
         }
-
-        private void Export(IEnumerable<ISpanData> export)
-        {
-            var handlers = this.serviceHandlers.Values;
-            foreach (var handler in handlers)
-            {
-                try
-                {
-                    handler.Export(export);
-                }
-                catch (Exception ex)
-                {
-                    OpenCensusEventSource.Log.ExporterThrownExceptionWarning(ex);
-                }
-            }
-        }
     }
 }

test/OpenCensus.Tests/Impl/Trace/Export/SpanExporterTest.cs

@@ -20,6 +20,7 @@ namespace OpenCensus.Trace.Export.Test
     using System.Collections.Generic;
     using System.Linq;
     using System.Threading;
+    using System.Threading.Tasks;
     using Moq;
     using OpenCensus.Common;
     using OpenCensus.Internal;
@@ -181,7 +182,38 @@ public void ExportNotSampledSpans()
             Assert.Single(exported);
             Assert.DoesNotContain(span1.ToSpanData(), exported);
             Assert.Contains(span2.ToSpanData(), exported);
+        }
+
+        [Fact]
+        public async Task ExportAsyncCallsAllHandlers()
+        {
+            var exporter = SpanExporter.Create(4, Duration.Create(1, 0));
+
+            var handler1 = new Mock<IHandler>();
+            var handler2 = new Mock<IHandler>();
+
+
+            exporter.RegisterHandler("first", handler1.Object);
+            exporter.RegisterHandler("second", handler2.Object);
+
+            var span1 = new Mock<ISpanData>();
+            var span2 = new Mock<ISpanData>();
+
+            await exporter.ExportAsync(new ISpanData[] { span1.Object, span2.Object }, CancellationToken.None);
+
+            Assert.Single(handler1.Invocations);
+            var args = (IEnumerable<ISpanData>)handler1.Invocations.First().Arguments.First();
+
+
+            handler1.Verify(c => c.Export(It.Is<IEnumerable<ISpanData>>(
+                (x) => x.Where((s) => s == span1.Object).Count() > 0 &&
+                       x.Where((s) => s == span2.Object).Count() > 0 &&
+                       x.Count() == 2)));
 
+            handler2.Verify(c => c.Export(It.Is<IEnumerable<ISpanData>>(
+                (x) => x.Where((s) => s == span1.Object).Count() > 0 &&
+                       x.Where((s) => s == span2.Object).Count() > 0 &&
+                       x.Count() == 2)));
         }
     }