influxdata · nblumhardt · Sep 5, 2017 · Sep 1, 2017 · Sep 1, 2017 · Sep 3, 2017
diff --git a/src/InfluxDB.LineProtocol/Client/LineProtocolClient.cs b/src/InfluxDB.LineProtocol/Client/LineProtocolClient.cs
@@ -32,24 +32,43 @@ protected LineProtocolClient(HttpMessageHandler handler, Uri serverBaseAddress,
 
         public Task<LineProtocolWriteResult> WriteAsync(LineProtocolPayload payload, CancellationToken cancellationToken = default(CancellationToken))
         {
-            var writer = new StringWriter();
+            var stringWriter = new StringWriter();
 
-            payload.Format(writer);
+            payload.Format(stringWriter);
 
-            return SendAsync(writer.ToString(), cancellationToken);
+            return SendAsync(stringWriter.ToString(), Precision.Nanoseconds, cancellationToken);
         }
 
-        public Task<LineProtocolWriteResult> SendAsync(LineProtocolWriter writer, CancellationToken cancellationToken = default(CancellationToken))
+        public Task<LineProtocolWriteResult> SendAsync(LineProtocolWriter lineProtocolWriter, CancellationToken cancellationToken = default(CancellationToken))
         {
-            return SendAsync(writer.ToString(), cancellationToken);
+            return SendAsync(lineProtocolWriter.ToString(), lineProtocolWriter.Precision, cancellationToken);
         }
 
-        private async Task<LineProtocolWriteResult> SendAsync(string payload, CancellationToken cancellationToken = default(CancellationToken))
+        private async Task<LineProtocolWriteResult> SendAsync(string payload, Precision precision, CancellationToken cancellationToken = default(CancellationToken))
         {
             var endpoint = $"write?db={Uri.EscapeDataString(_database)}";
             if (!string.IsNullOrEmpty(_username))
                 endpoint += $"&u={Uri.EscapeDataString(_username)}&p={Uri.EscapeDataString(_password)}";
 
+            switch (precision)
+            {
+                case Precision.Microseconds:
+                    endpoint += "&precision=u";
+                    break;
+                case Precision.Milliseconds:
+                    endpoint += "&precision=ms";
+                    break;
+                case Precision.Seconds:
+                    endpoint += "&precision=s";
+                    break;
+                case Precision.Minutes:
+                    endpoint += "&precision=m";
+                    break;
+                case Precision.Hours:
+                    endpoint += "&precision=h";
+                    break;
+            }
+
             var content = new StringContent(payload, Encoding.UTF8);
             var response = await _httpClient.PostAsync(endpoint, content, cancellationToken).ConfigureAwait(false);
             if (response.IsSuccessStatusCode)

diff --git a/src/InfluxDB.LineProtocol/LineProtocolWriter.cs b/src/InfluxDB.LineProtocol/LineProtocolWriter.cs
@@ -9,14 +9,33 @@ public class LineProtocolWriter
         private static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
         private readonly TextWriter textWriter;
+        private readonly PrecisionResolutionStrategy defaultResolutionStrategy;
 
         private LinePosition position = LinePosition.NothingWritten;
 
-        public LineProtocolWriter()
+        public LineProtocolWriter() : this(Precision.Nanoseconds)
         {
+        }
+
+        public LineProtocolWriter(Precision precision, PrecisionResolutionStrategy defaultResolutionStrategy = PrecisionResolutionStrategy.Error)
+        {
+            if (!Enum.IsDefined(typeof(Precision), precision))
+            {
+                throw new ArgumentOutOfRangeException(nameof(precision));
+            }
+
+            if (!Enum.IsDefined(typeof(PrecisionResolutionStrategy), defaultResolutionStrategy))
+            {
+                throw new ArgumentOutOfRangeException(nameof(defaultResolutionStrategy));
+            }
+
+            this.Precision = precision;
+            this.defaultResolutionStrategy = defaultResolutionStrategy;
             this.textWriter = new StringWriter();
         }
 
+        public Precision Precision { get; }
+
         public LineProtocolWriter Measurement(string name)
         {
             if (name == null)
@@ -164,8 +183,42 @@ public LineProtocolWriter Field(string name, bool value)
             return this;
         }
 
-        public void Timestamp(long value)
+        public void Timestamp(long nanoseconds)
+        {
+            this.Timestamp(nanoseconds, defaultResolutionStrategy);
+        }
+
+        public void Timestamp(long nanoseconds, PrecisionResolutionStrategy resolutionStrategy)
         {
+            var nanosecondsAbovePrecision = nanoseconds % (long)Precision;
+
+            if (nanosecondsAbovePrecision != 0)
+            {
+                switch (resolutionStrategy)
+                {
+                    case PrecisionResolutionStrategy.Error:
+                        throw new ArgumentOutOfRangeException(nameof(nanoseconds));
+                    case PrecisionResolutionStrategy.Floor:
+                        nanoseconds -= nanosecondsAbovePrecision;
+                        break;
+                    case PrecisionResolutionStrategy.Ceiling:
+                        nanoseconds += (long)Precision - nanosecondsAbovePrecision;
+                        break;
+                    case PrecisionResolutionStrategy.Round:
+                        if (nanosecondsAbovePrecision < (long)Precision / 2)
+                        {
+                            Timestamp(nanoseconds, PrecisionResolutionStrategy.Floor);
+                        }
+                        else
+                        {
+                            Timestamp(nanoseconds, PrecisionResolutionStrategy.Ceiling);
+                        }
+                        return;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(resolutionStrategy));
+                }
+            }
+
             switch (position)
             {
                 case LinePosition.FieldWritten:
@@ -177,29 +230,45 @@ public void Timestamp(long value)
                     throw InvalidPositionException("Cannot write timestamp as no field written for current measurement.");
             }
 
-            textWriter.Write(value.ToString(CultureInfo.InvariantCulture));
+            var timestamp = nanoseconds / (long)Precision;
+            textWriter.Write(timestamp.ToString(CultureInfo.InvariantCulture));
 
             position = LinePosition.TimestampWritten;
         }
 
         public void Timestamp(TimeSpan value)
         {
-            Timestamp(value.Ticks * 100L);
+            Timestamp(value, defaultResolutionStrategy);
+        }
+
+        public void Timestamp(TimeSpan value, PrecisionResolutionStrategy resolutionStrategy)
+        {
+            Timestamp(value.Ticks * 100, resolutionStrategy);
         }
 
         public void Timestamp(DateTimeOffset value)
         {
-            Timestamp(value.UtcDateTime);
+            Timestamp(value, defaultResolutionStrategy);
+        }
+
+        public void Timestamp(DateTimeOffset value, PrecisionResolutionStrategy resolutionStrategy)
+        {
+            Timestamp(value.UtcDateTime, resolutionStrategy);
         }
 
         public void Timestamp(DateTime value)
+        {
+            Timestamp(value, defaultResolutionStrategy);
+        }
+
+        public void Timestamp(DateTime value, PrecisionResolutionStrategy resolutionStrategy)
         {
             if (value != null && value.Kind != DateTimeKind.Utc)
             {
                 throw new ArgumentException("Timestamps must be specified as UTC", nameof(value));
             }
 
-            Timestamp(value - UnixEpoch);
+            Timestamp(value - UnixEpoch, resolutionStrategy);
         }
 
         public override string ToString()

diff --git a/src/InfluxDB.LineProtocol/Precision.cs b/src/InfluxDB.LineProtocol/Precision.cs
@@ -0,0 +1,12 @@
+namespace InfluxDB.LineProtocol
+{
+    public enum Precision : long
+    {
+        Nanoseconds = 1,
+        Microseconds = 1000,
+        Milliseconds = Microseconds * 1000,
+        Seconds = Milliseconds * 1000,
+        Minutes = Seconds * 60,
+        Hours = Minutes * 60
+    }
+}
diff --git a/src/InfluxDB.LineProtocol/PrecisionResolutionStrategy.cs b/src/InfluxDB.LineProtocol/PrecisionResolutionStrategy.cs
@@ -0,0 +1,10 @@
+namespace InfluxDB.LineProtocol
+{
+    public enum PrecisionResolutionStrategy
+    {
+        Error,
+        Round,
+        Floor,
+        Ceiling
+    }
+}
diff --git a/test/InfluxDB.LineProtocol.Tests/LineProtocolWriterPrecisionTests.cs b/test/InfluxDB.LineProtocol.Tests/LineProtocolWriterPrecisionTests.cs
@@ -0,0 +1,112 @@
+using System;
+using Xunit;
+
+namespace InfluxDB.LineProtocol.Tests
+{
+    public class LineProtocolWriterPrecisionTests
+    {
+        [Theory]
+        [InlineData(Precision.Nanoseconds, 1500832764070165800, "1500832764070165800")]
+        [InlineData(Precision.Microseconds, 1500832764070165000, "1500832764070165")]
+        [InlineData(Precision.Milliseconds, 1500832764070000000, "1500832764070")]
+        [InlineData(Precision.Seconds, 1500832764000000000, "1500832764")]
+        [InlineData(Precision.Hours, 1500829200000000000, "416897")]
+        public void Will_write_timestamps_using_precision_of_writer(Precision precision, long nanoseconds, string expectedTimestamp)
+        {
+            var unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+            var timestamp = unixEpoch.AddTicks(nanoseconds / 100); // .net tick is 100 nanoseconds.
+
+            var writer = new LineProtocolWriter(precision);
+
+            writer.Measurement("foo").Field("bar", 1f).Timestamp(timestamp);
+
+            Assert.Equal($"foo bar=1 {expectedTimestamp}", writer.ToString());
+        }
+
+        [Theory]
+        [InlineData(Precision.Microseconds)]
+        [InlineData(Precision.Milliseconds)]
+        [InlineData(Precision.Seconds)]
+        [InlineData(Precision.Hours)]
+        public void Will_throw_if_wrong_precision_used(Precision precision)
+        {
+            var writer = new LineProtocolWriter(precision);
+
+            var timestamp = TimeSpan.FromTicks(1);
+
+            writer.Measurement("foo").Field("bar", 1f);
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => writer.Timestamp(timestamp));
+        }
+
+        [Theory]
+        [InlineData(Precision.Microseconds)]
+        [InlineData(Precision.Milliseconds)]
+        [InlineData(Precision.Seconds)]
+        [InlineData(Precision.Hours)]
+        public void Can_floor_if_wrong_precision_used(Precision precision)
+        {
+            var writer = new LineProtocolWriter(precision);
+
+            var timestamp = TimeSpan.FromTicks(1);
+
+            writer.Measurement("foo").Field("bar", 1f).Timestamp(timestamp, PrecisionResolutionStrategy.Floor);
+
+            Assert.Equal("foo bar=1 0", writer.ToString());
+        }
+
+        [Theory]
+        [InlineData(Precision.Microseconds)]
+        [InlineData(Precision.Milliseconds)]
+        [InlineData(Precision.Seconds)]
+        [InlineData(Precision.Hours)]
+        public void Can_ceiling_if_wrong_precision_used(Precision precision)
+        {
+            var writer = new LineProtocolWriter(precision);
+
+            var timestamp = TimeSpan.FromTicks(1);
+
+            writer.Measurement("foo").Field("bar", 1f).Timestamp(timestamp, PrecisionResolutionStrategy.Ceiling);
+
+            Assert.Equal("foo bar=1 1", writer.ToString());
+        }
+
+        [Theory]
+        [InlineData(Precision.Microseconds)]
+        [InlineData(Precision.Milliseconds)]
+        [InlineData(Precision.Seconds)]
+        [InlineData(Precision.Hours)]
+        public void Can_round_if_wrong_precision_used(Precision precision)
+        {
+            var writer = new LineProtocolWriter(precision);
+
+            writer.Measurement("foo").Field("bar", true).Timestamp(TimeSpan.FromTicks(1), PrecisionResolutionStrategy.Round);
+            writer.Measurement("foo").Field("bar", true).Timestamp(TimeSpan.FromTicks(((long)precision / 100) - 1), PrecisionResolutionStrategy.Round);
+
+            Assert.Equal("foo bar=t 0\nfoo bar=t 1", writer.ToString());
+        }
+
+        [Fact]
+        public void Can_define_resolution_strategy_when_creating_the_writer()
+        {
+            var writer = new LineProtocolWriter(Precision.Seconds, PrecisionResolutionStrategy.Round);
+
+            writer.Measurement("foo").Field("bar", true).Timestamp(TimeSpan.FromMilliseconds(499));
+            writer.Measurement("foo").Field("bar", true).Timestamp(TimeSpan.FromMilliseconds(500));
+
+            Assert.Equal("foo bar=t 0\nfoo bar=t 1", writer.ToString());
+        }
+
+        [Fact]
+        public void Can_override_resolution_strategy_when_writing_point()
+        {
+            var writer = new LineProtocolWriter(Precision.Seconds, PrecisionResolutionStrategy.Round);
+
+            writer.Measurement("foo").Field("bar", true).Timestamp(TimeSpan.FromMilliseconds(700));
+            writer.Measurement("foo").Field("bar", true).Timestamp(TimeSpan.FromMilliseconds(700), PrecisionResolutionStrategy.Floor);
+
+            Assert.Equal("foo bar=t 1\nfoo bar=t 0", writer.ToString());
+        }
+    }
+}