Merge pull request #25 from LeeCampbell/Recorder

Recorder

Author: LeeCampbell

src/HdrHistogram.Examples/HdrHistogram.Examples.csproj

@@ -43,6 +43,7 @@
   <ItemGroup>
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RecorderExample.cs" />
     <Compile Include="SimpleHistogramExample.cs" />
   </ItemGroup>
   <ItemGroup>

src/HdrHistogram.Examples/Program.cs

@@ -4,7 +4,8 @@ class Program
     {
         static void Main(string[] args)
         {
-            SimpleHistogramExample.Run();
+            //SimpleHistogramExample.Run();
+            RecorderExample.Run();
         }
     }
 }

src/HdrHistogram.Examples/RecorderExample.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+
+namespace HdrHistogram.Examples
+{
+    /// <summary>
+    /// A simple example of using HdrHistogram's Recorder: run for 20 seconds collecting the
+    /// time it takes to perform a simple Datagram Socket create/close operation,
+    /// and report a histogram of the times at the end.
+    /// </summary>
+    static class RecorderExample
+    {
+        private static readonly Recorder Recorder = new Recorder(1, TimeSpan.TicksPerHour, 3, (id, low, high, sf) => new LongHistogram(id, low, high, sf));
+        private static readonly Lazy<AddressFamily> AddressFamily = new Lazy<AddressFamily>(() => GetAddressFamily("google.com"));
+        private static readonly TimeSpan RunPeriod = TimeSpan.FromSeconds(10);
+        private static readonly LongHistogram AccumulatingHistogram = new LongHistogram(TimeSpan.TicksPerHour, 3);
+        private const string LogPath = "DatagramSocket.histogram.log";        
+        private static HistogramLogWriter _logWriter;
+        private static FileStream _outputStream;
+        private static int _isCompleted = 0;
+
+        public static void Run()
+        {
+            Console.WriteLine($"Running for {RunPeriod.TotalSeconds}sec.");
+
+            _outputStream = File.Create(LogPath);
+            _logWriter = new HistogramLogWriter(_outputStream);
+            //Write the headers, but no histograms (as we don't have any yet).
+            _logWriter.Write(DateTime.Now);
+
+            var outputThread = new Thread(ts => WriteToDisk());
+            outputThread.Start();
+            RecordMeasurements();
+        }
+
+        private static void WriteToDisk()
+        {
+            //Sample every second until flagged as completed.
+            while (_isCompleted == 0)
+            {
+                Thread.Sleep(1000);
+
+                var histogram = Recorder.GetIntervalHistogram();
+                AccumulatingHistogram.Add(histogram);
+                _logWriter.Append(histogram);
+                Console.WriteLine($"{DateTime.Now:o} Interval.TotalCount = {histogram.TotalCount,10:G}. Accumulated.TotalCount = {AccumulatingHistogram.TotalCount,10:G}.");
+            }
+            _logWriter.Dispose();
+            _outputStream.Dispose();
+            Console.WriteLine("Log contents");
+            Console.WriteLine(File.ReadAllText(LogPath));
+            Console.WriteLine("Output thread finishing.");
+        }
+
+        /// <summary>
+        /// Shows a sample loop where an action is executed, and the latency of each execution is recorded.
+        /// </summary>
+        private static void RecordMeasurements()
+        {
+            var timer = Stopwatch.StartNew();
+            Action actionToMeasure = CreateAndCloseDatagramSocket;
+            do
+            {
+                Recorder.Record(actionToMeasure);
+            } while (timer.Elapsed < RunPeriod);
+            Interlocked.Increment(ref _isCompleted);
+        }
+
+        private static void CreateAndCloseDatagramSocket()
+        {
+            try
+            {
+                using (var socket = new Socket(AddressFamily.Value, SocketType.Stream, ProtocolType.Tcp))
+                {
+                }
+            }
+            catch (SocketException)
+            {
+            }
+        }
+
+        private static AddressFamily GetAddressFamily(string url)
+        {
+            var hostIpAddress = Dns.GetHostEntry(url).AddressList[0];
+            var hostIpEndPoint = new IPEndPoint(hostIpAddress, 80);
+            return hostIpEndPoint.AddressFamily;
+        }
+    }
+}

src/HdrHistogram.UnitTests/HdrHistogram.UnitTests.csproj

@@ -64,6 +64,7 @@
     <Compile Include="Persistence\ShortHistogramLogReaderWriterTests.cs" />
     <Compile Include="Persistence\TestCaseGenerator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RecorderTests.cs" />
     <Compile Include="ShortHistogramTests.cs" />
   </ItemGroup>
   <ItemGroup>

src/HdrHistogram.UnitTests/HistogramTestBase.cs

@@ -1,4 +1,6 @@
 using System;
+using System.IO;
+using System.Threading;
 using NUnit.Framework;
 
 namespace HdrHistogram.UnitTests
@@ -21,7 +23,7 @@ public void ConstructorShouldRejectInvalidParameters(
             Assert.AreEqual(errorParamName, ex.ParamName);
             StringAssert.StartsWith(errorMessage, ex.Message);
         }
-        
+
 
         [TestCase(2, 2)]
         [TestCase(HighestTrackableValue, NumberOfSignificantValueDigits)]
@@ -123,6 +125,23 @@ public void RecordAction_increments_TotalCount()
             Assert.AreEqual(1, longHistogram.TotalCount);
         }
 
+        [Test]
+        public void RecordAction_records_in_correct_units()
+        {
+            var pause = TimeSpan.FromSeconds(1);
+            var longHistogram = Create(HighestTrackableValue, NumberOfSignificantValueDigits);
+
+            longHistogram.Record(() => Thread.Sleep(pause));
+
+            var stringWriter = new StringWriter();
+            longHistogram.OutputPercentileDistribution(stringWriter, 5, OutputScalingFactor.TimeStampToMilliseconds, true);
+            //First column of second row.
+            var recordedMilliseconds = GetCellValue(stringWriter.ToString(), 0, 1);
+            var actual = double.Parse(recordedMilliseconds);
+            var expected = pause.TotalMilliseconds;
+            var delta = expected * 0.1;   //10% Variance to allow for slack in transitioning from Thread.Sleep
+            Assert.AreEqual(expected, actual, delta);
+        }
 
         [Test]
         public void Reset_sets_counts_to_zero()
@@ -265,5 +284,10 @@ private static int GetBucketsNeededToCoverValue(int subBucketSize, long value)
         protected abstract int WordSize { get; }
         protected abstract HistogramBase Create(long highestTrackableValue, int numberOfSignificantValueDigits);
         protected abstract HistogramBase Create(long lowestTrackableValue, long highestTrackableValue, int numberOfSignificantValueDigits);
+
+        private static string GetCellValue(string csvData, int col, int row)
+        {
+            return csvData.Split('\n')[row].Split(',')[col];
+        }
     }
 }