Merge branch 'dotnet4'

TerribleDev · TerribleDev · commit 6f57e26e2bbc · 2016-11-30T09:24:59.000-05:00
diff --git a/Readme.md b/Readme.md
@@ -84,6 +84,12 @@ var opt = new StatsdOptions(){
 
 By default the various logging metric functions return Tasks. **You do not need to await on these** If you await on these and you have buffered metrics off , you will return after the bytes have been added to the network stream. If you await, and buffered metrics are on then your await will return when your metric has been added to the Queue of metrics to be sent.
 
+
+## dotnet 4.0
+
+While this project does target dotnet 4.0, the unit tests do not run in 4.0. The support is limited (new features may not come to dotnet 4.S), but bugs will be addressed.
+
+
 ## Dev setup
 
 If you plan on playing around with the code, be sure to download and install [.NET core sdk](https://www.microsoft.com/net/core).
diff --git a/src/StatsN.IntergrationTests/project.json b/src/StatsN.IntergrationTests/project.json
@@ -4,7 +4,6 @@
   "dependencies": {
     "xunit": "2.2.0-beta2-build3300",
     "dotnet-test-xunit": "2.2.0-preview2-build1029",
-    "Moq": "4.6.38-alpha",
     "StatsN": "1.0.*"
   },
   "frameworks": {
diff --git a/src/StatsN.UnitTests/StastdTests.cs b/src/StatsN.UnitTests/StastdTests.cs
@@ -96,60 +96,68 @@ public void ConfirmMetricsBuffered()
             var mockedMetric = new Mock<NullChannel>();
             mockedMetric.Setup(a => a.IsConnected).Returns(true);
             mockedMetric.Setup(a => a.SendAsync(It.Is<byte[]>(param => param.Length > 200 && param.Length < 512))).Verifiable();
-            var statsd = new Statsd(new StatsdOptions() { BufferMetrics = true }, mockedMetric.Object);
-            for (int i = 0; i < 100000; i++)
+            using (var statsd = new Statsd(new StatsdOptions() { BufferMetrics = true }, mockedMetric.Object))
             {
-                statsd.CountAsync("fun");
+                for (int i = 0; i < 100000; i++)
+                {
+                    statsd.CountAsync("fun");
+                }
+                while (mockedMetric.Object.worker.IsBusy) { }
+                mockedMetric.Verify();
             }
-            while (mockedMetric.Object.worker.IsBusy) { }
-            mockedMetric.Verify();
         }
         [Fact]
         public void ConfirmMetricsNotBuffered()
         {
             var mockedMetric = new Mock<NullChannel>();
             mockedMetric.Setup(a => a.IsConnected).Returns(true);
             mockedMetric.Setup(a => a.SendAsync(It.Is<byte[]>(param => param.Length < 50))).Verifiable();
-            var statsd = new Statsd(new StatsdOptions() {}, mockedMetric.Object);
-            for (int i = 0; i < 100000; i++)
+            using (var statsd = new Statsd(new StatsdOptions() { }, mockedMetric.Object))
             {
-                statsd.CountAsync("fun");
+                for (int i = 0; i < 100000; i++)
+                {
+                    statsd.CountAsync("fun");
+                }
+                while (mockedMetric.Object.worker.IsBusy) { }
+                mockedMetric.Verify();
             }
-            while (mockedMetric.Object.worker.IsBusy) { }
-            mockedMetric.Verify();
         }
         [Fact]
         public void ConfirmUdpSendBuffTime()
         {
             var client = new Udp();
             var options = new StatsdOptions() { BufferMetrics = true, OnExceptionGenerated = (exception)=> { throw exception; } };
-            var statsd = new Statsd(options, client);
-            var stopwatch = new Stopwatch();
-            stopwatch.Start();
-            for (int i = 0; i < 100000; i++)
+            using (var statsd = new Statsd(options, client))
             {
-                statsd.CountAsync("fun");
+                var stopwatch = new Stopwatch();
+                stopwatch.Start();
+                for (int i = 0; i < 100000; i++)
+                {
+                    statsd.CountAsync("fun");
+                }
+                while (client.worker.IsBusy) { }
+                stopwatch.Stop();
+                //we shouldn't cost more than 1 milisecond a metric buffered or not
+                Assert.InRange(stopwatch.ElapsedMilliseconds, 0, 100000);
             }
-            while (client.worker.IsBusy) { }
-            stopwatch.Stop();
-            //we shouldn't cost more than 1 milisecond a metric buffered or not
-            Assert.InRange(stopwatch.ElapsedMilliseconds, 0, 100000);
         }
         [Fact]
         public void ConfirmUdpSendNoBufferedTime()
         {
             var client = new Udp();
-            var statsd = new Statsd(new StatsdOptions() { BufferMetrics = false, OnExceptionGenerated = (exception) => { throw exception; } }, client);
-            var stopwatch = new Stopwatch();
-            stopwatch.Start();
-            for (int i = 0; i < 100000; i++)
+            using (var statsd = new Statsd(new StatsdOptions() { BufferMetrics = false, OnExceptionGenerated = (exception) => { throw exception; } }, client))
             {
-                statsd.CountAsync("fun");
+                var stopwatch = new Stopwatch();
+                stopwatch.Start();
+                for (int i = 0; i < 100000; i++)
+                {
+                    statsd.CountAsync("fun");
+                }
+                while (client.worker.IsBusy) { }
+                stopwatch.Stop();
+                //we shouldn't cost more than 1 milisecond a metric buffered or not
+                Assert.InRange(stopwatch.ElapsedMilliseconds, 0, 100000);
             }
-            while (client.worker.IsBusy) { }
-            stopwatch.Stop();
-            //we shouldn't cost more than 1 milisecond a metric buffered or not
-            Assert.InRange(stopwatch.ElapsedMilliseconds, 0, 100000);
         }
     }
 }
diff --git a/src/StatsN.UnitTests/project.json b/src/StatsN.UnitTests/project.json
@@ -8,7 +8,7 @@
     "StatsN": "1.0.*"
   },
   "frameworks": {
-    "net461":{},
+    "net461": {},
     "netcoreapp1.0": {
       "dependencies": {
         "Microsoft.NETCore.App": {
diff --git a/src/StatsN/BaseCommunicationProvider.cs b/src/StatsN/BaseCommunicationProvider.cs
@@ -13,6 +13,9 @@ namespace StatsN
 {
     public abstract class BaseCommunicationProvider : IDisposable
     {
+        /// <summary>
+        /// User Options
+        /// </summary>
         protected StatsdOptions Options { get; private set; }
         internal BackgroundWorker worker { get; set; }
         private ConcurrentQueue<byte[]> Queue { get; } = new ConcurrentQueue<byte[]>();
@@ -58,24 +61,43 @@ internal BaseCommunicationProvider Construct(StatsdOptions options)
             this.Options = options;
             return this;
         }
+        /// <summary>
+        /// Connect the socket
+        /// </summary>
+        /// <returns></returns>
         public abstract Task<bool> Connect();
+        /// <summary>
+        /// Is the socket connected?
+        /// </summary>
         public abstract bool IsConnected { get; }
-
+        /// <summary>
+        /// Send metric to inherited provider
+        /// </summary>
+        /// <param name="metric"></param>
+        /// <returns></returns>
         internal Task SendMetric(string metric)
         {
             var payload = Encoding.ASCII.GetBytes(metric + Environment.NewLine);
             if (Options.BufferMetrics)
             {
                 Queue.Enqueue(payload);
                 if (!worker.IsBusy) worker.RunWorkerAsync();
-                return Task.FromResult(0);
+                return TplFactory.FromResult();
             }
             return SendAsync(payload);
         }
         public abstract Task SendAsync(byte[] payload);
-
-        protected Task<IPEndPoint> GetIpAddressAsync() => GetIpAddressAsync(this.Options.HostOrIp, this.Options.Port); 
-        
+        /// <summary>
+        /// Get the IPEndpoint for the Options object, will return null if it cannot be established
+        /// </summary>
+        /// <returns></returns>
+        protected Task<IPEndPoint> GetIpAddressAsync() => GetIpAddressAsync(this.Options.HostOrIp, this.Options.Port);
+        /// <summary>
+        /// Get the IPEndpoint for the Options object, will return null if it cannot be established
+        /// </summary>
+        /// <param name="hostOrIPAddress"></param>
+        /// <param name="port"></param>
+        /// <returns></returns>
         protected async Task<IPEndPoint> GetIpAddressAsync(string hostOrIPAddress, int port)
         {
             IPAddress ipAddress;
@@ -84,7 +106,12 @@ protected async Task<IPEndPoint> GetIpAddressAsync(string hostOrIPAddress, int p
             {
                 try
                 {
+#if net40
+                    ipAddress = await TaskEx.Run(()=>Dns.GetHostAddresses(hostOrIPAddress).First(p => p.AddressFamily == AddressFamily.InterNetwork)).ConfigureAwait(false);
+#else
                     ipAddress = (await Dns.GetHostAddressesAsync(hostOrIPAddress).ConfigureAwait(false)).First(p => p.AddressFamily == AddressFamily.InterNetwork);
+#endif
+
                 }
                 catch (Exception)
                 {
diff --git a/src/StatsN/Constants.cs b/src/StatsN/Constants.cs
@@ -6,13 +6,13 @@
 
 namespace StatsN
 {
-    internal class Constants
+    internal static class Constants
     {
         internal const char colon = ':';
         internal const char pipe = '|';
         internal const char dot = '.';
         internal const string Localhost = "127.0.0.1";
-        internal const string Statsd = "Statsd";
+        internal const string StatsN = "StatsN";
         
         internal static class Metrics
         {
diff --git a/src/StatsN/Exceptions/StatsdLogMessage.cs b/src/StatsN/Exceptions/StatsdLogMessage.cs
@@ -8,10 +8,9 @@ public class StatsdLogMessage
     {
         public string Message { get; set; }
         public EventType Weight { get; set; }
-        
         public StatsdLogMessage(string message, EventType weight)
         {
-            this.Message = message;
+            this.Message = message ?? string.Empty;
             Weight = weight;
         }
     }
diff --git a/src/StatsN/NullChannel.cs b/src/StatsN/NullChannel.cs
@@ -17,14 +17,14 @@ public override bool IsConnected
 
         public override Task<bool> Connect()
         {
-            return Task.FromResult(true);
+            return TplFactory.FromResult(true);
         }
 
         public override void OnDispose(){}
 
         public override Task SendAsync(byte[] payload)
         {
-            return Task.FromResult(0);
+            return TplFactory.FromResult(0);
         }
     }
 }
diff --git a/src/StatsN/Statsd.cs b/src/StatsN/Statsd.cs
@@ -86,6 +86,7 @@ internal async Task LogMetricAsync(string metricName, string value, string metri
                 return;
             }
             var calculateMetric = BuildMetric(metricName, value, metricType, options.Prefix, postfix);
+            options.LogEvent(calculateMetric, EventType.Info);
             if (string.IsNullOrWhiteSpace(calculateMetric))
             {
                 options.LogEvent($"Unable to generate metric for {metricType} value {value}", EventType.Error);
diff --git a/src/StatsN/StatsdOptions.cs b/src/StatsN/StatsdOptions.cs
@@ -11,7 +11,7 @@ public class StatsdOptions
     {
         public Action<System.Exception> OnExceptionGenerated;
         public Action<StatsdLogMessage> OnLogEventGenerated;
-
+        public TraceSource TraceSource { get; private set; } = new TraceSource(Constants.StatsN, SourceLevels.Warning);
         public bool BufferMetrics { get; set; } = false;
         public int BufferSize { get; set; } = 512;
         public string HostOrIp { get; set; } = Constants.Localhost;
@@ -30,7 +30,7 @@ public string Prefix
             }
         }
 
-        internal void LogException(System.Exception exception)
+        internal void LogException(Exception exception)
         {
             if(OnExceptionGenerated == null)
             {
@@ -39,25 +39,23 @@ internal void LogException(System.Exception exception)
             }
             OnExceptionGenerated.Invoke(exception);
 
-            
         }
         internal void LogEvent(string message, EventType weight) => this.LogEvent(new StatsdLogMessage(message, weight));
         
         internal void LogEvent(StatsdLogMessage logMessage)
         {
-            if(OnLogEventGenerated == null)
+            if (OnLogEventGenerated == null)
             {
-                var traceMessage = $"{Constants.Statsd}: {logMessage.Message}";
                 switch (logMessage.Weight)
                 {
                     case EventType.Info:
-                        Trace.TraceInformation(traceMessage);
+                        TraceSource.TraceEvent(TraceEventType.Information, 1, logMessage.Message);
                         break;
                     case EventType.Warning:
-                        Trace.TraceWarning(traceMessage);
+                        TraceSource.TraceEvent(TraceEventType.Warning, 2, logMessage.Message);
                         break;
                     case EventType.Error:
-                        Trace.TraceError(traceMessage);
+                        TraceSource.TraceEvent(TraceEventType.Error, 1, logMessage.Message);
                         break;
                 }
             }
diff --git a/src/StatsN/Tcp.cs b/src/StatsN/Tcp.cs
@@ -61,7 +61,7 @@ public override void OnDispose()
         }
         public void DisposeClient()
         {
-#if net45
+#if NETFULL
             Client?.Close();
 #else
             Client?.Dispose();
diff --git a/src/StatsN/TplFactory.cs b/src/StatsN/TplFactory.cs
@@ -0,0 +1,31 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace StatsN
+{
+    /// <summary>
+    /// Class that provides Task.FromResult functions for dotnet 4 and up
+    /// </summary>
+    public static class TplFactory
+    {
+        public static Task<Result> FromResult<Result>(Result result)
+        {
+#if net40
+            return TaskEx.FromResult(result);
+#else
+            return Task.FromResult<Result>(result);
+#endif
+        }
+        public static Task FromResult()
+        {
+#if net40
+            return TaskEx.FromResult(0);
+#else
+            return Task.FromResult(0);
+#endif
+        }
+    }
+
+}
diff --git a/src/StatsN/Udp.cs b/src/StatsN/Udp.cs
@@ -24,13 +24,26 @@ public override async Task SendAsync(byte[] payload)
             if(_ipEndpoint == null)
             {
                 endpoint = await GetIpAddressAsync().ConfigureAwait(false);
+
                 if (endpoint == null) return;
             }
             else
             {
                 endpoint = _ipEndpoint;
             }
-            await _udpClient.SendAsync(payload, payload.Length, endpoint).ConfigureAwait(false);
+            try
+            {
+#if net40
+                await TaskEx.Run(() => _udpClient.Send(payload, payload.Length, endpoint)).ConfigureAwait(false);
+#else
+                await _udpClient.SendAsync(payload, payload.Length, endpoint).ConfigureAwait(false);
+#endif
+            }
+            catch(Exception e)
+            {
+                Options.LogException(e);
+            }
+
         }
         public override bool IsConnected
         {
@@ -54,7 +67,7 @@ public override async Task<bool> Connect()
         }
         public override void OnDispose()
         {
-#if net45
+#if NETFULL
             _udpClient.Close();
 #else
             _udpClient.Dispose();
diff --git a/src/StatsN/project.json b/src/StatsN/project.json
@@ -31,7 +31,17 @@
         "System.Dynamic.Runtime": "4.0.0.0"
       },
       "buildOptions": {
-        "define": [ "net45" ]
+        "define": [ "net45", "NETFULL" ]
+      }
+    },
+    "net40": {
+      "frameworkAssemblies": {
+      },
+      "dependencies": {
+        "Microsoft.Bcl.Async":  "1.0.166"
+      },
+      "buildOptions": {
+        "define": [ "net40", "NETFULL" ]
       }
     },
     "netstandard1.3": {

Original file line number	Diff line number	Diff line change
`@@ -6,13 +6,13 @@`
`6`	`6`
`7`	`7`	`namespace StatsN`
`8`	`8`	`{`
`9`		`- internal class Constants`
	`9`	`+ internal static class Constants`
`10`	`10`	`{`
`11`	`11`	`internal const char colon = ':';`
`12`	`12`	`internal const char pipe = '\|';`
`13`	`13`	`internal const char dot = '.';`
`14`	`14`	`internal const string Localhost = "127.0.0.1";`
`15`		`- internal const string Statsd = "Statsd";`
	`15`	`+ internal const string StatsN = "StatsN";`
`16`	`16`
`17`	`17`	`internal static class Metrics`
`18`	`18`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,10 +8,9 @@ public class StatsdLogMessage`
`8`	`8`	`{`
`9`	`9`	`public string Message { get; set; }`
`10`	`10`	`public EventType Weight { get; set; }`
`11`		`-`
`12`	`11`	`public StatsdLogMessage(string message, EventType weight)`
`13`	`12`	`{`
`14`		`- this.Message = message;`
	`13`	`+ this.Message = message ?? string.Empty;`
`15`	`14`	`Weight = weight;`
`16`	`15`	`}`
`17`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,14 +17,14 @@ public override bool IsConnected`
`17`	`17`
`18`	`18`	`public override Task<bool> Connect()`
`19`	`19`	`{`
`20`		`- return Task.FromResult(true);`
	`20`	`+ return TplFactory.FromResult(true);`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`public override void OnDispose(){}`
`24`	`24`
`25`	`25`	`public override Task SendAsync(byte[] payload)`
`26`	`26`	`{`
`27`		`- return Task.FromResult(0);`
	`27`	`+ return TplFactory.FromResult(0);`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,6 +86,7 @@ internal async Task LogMetricAsync(string metricName, string value, string metri`
`86`	`86`	`return;`
`87`	`87`	`}`
`88`	`88`	`var calculateMetric = BuildMetric(metricName, value, metricType, options.Prefix, postfix);`
	`89`	`+ options.LogEvent(calculateMetric, EventType.Info);`
`89`	`90`	`if (string.IsNullOrWhiteSpace(calculateMetric))`
`90`	`91`	`{`
`91`	`92`	`options.LogEvent($"Unable to generate metric for {metricType} value {value}", EventType.Error);`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ public class StatsdOptions`
`11`	`11`	`{`
`12`	`12`	`public Action<System.Exception> OnExceptionGenerated;`
`13`	`13`	`public Action<StatsdLogMessage> OnLogEventGenerated;`
`14`		`-`
	`14`	`+ public TraceSource TraceSource { get; private set; } = new TraceSource(Constants.StatsN, SourceLevels.Warning);`
`15`	`15`	`public bool BufferMetrics { get; set; } = false;`
`16`	`16`	`public int BufferSize { get; set; } = 512;`
`17`	`17`	`public string HostOrIp { get; set; } = Constants.Localhost;`
`@@ -30,7 +30,7 @@ public string Prefix`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`33`		`- internal void LogException(System.Exception exception)`
	`33`	`+ internal void LogException(Exception exception)`
`34`	`34`	`{`
`35`	`35`	`if(OnExceptionGenerated == null)`
`36`	`36`	`{`
`@@ -39,25 +39,23 @@ internal void LogException(System.Exception exception)`
`39`	`39`	`}`
`40`	`40`	`OnExceptionGenerated.Invoke(exception);`
`41`	`41`
`42`		`-`
`43`	`42`	`}`
`44`	`43`	`internal void LogEvent(string message, EventType weight) => this.LogEvent(new StatsdLogMessage(message, weight));`
`45`	`44`
`46`	`45`	`internal void LogEvent(StatsdLogMessage logMessage)`
`47`	`46`	`{`
`48`		`- if(OnLogEventGenerated == null)`
	`47`	`+ if (OnLogEventGenerated == null)`
`49`	`48`	`{`
`50`		`- var traceMessage = $"{Constants.Statsd}: {logMessage.Message}";`
`51`	`49`	`switch (logMessage.Weight)`
`52`	`50`	`{`
`53`	`51`	`case EventType.Info:`
`54`		`- Trace.TraceInformation(traceMessage);`
	`52`	`+ TraceSource.TraceEvent(TraceEventType.Information, 1, logMessage.Message);`
`55`	`53`	`break;`
`56`	`54`	`case EventType.Warning:`
`57`		`- Trace.TraceWarning(traceMessage);`
	`55`	`+ TraceSource.TraceEvent(TraceEventType.Warning, 2, logMessage.Message);`
`58`	`56`	`break;`
`59`	`57`	`case EventType.Error:`
`60`		`- Trace.TraceError(traceMessage);`
	`58`	`+ TraceSource.TraceEvent(TraceEventType.Error, 1, logMessage.Message);`
`61`	`59`	`break;`
`62`	`60`	`}`
`63`	`61`	`}`