influxdb-java-182 Allow write precision of TimeUnit other than Nanoseconds

src/main/java/org/influxdb/InfluxDB.java

@@ -197,6 +197,16 @@ public InfluxDB enableBatch(final int actions, final int flushDuration, final Ti
   public void write(final String database, final String retentionPolicy,
                     final ConsistencyLevel consistency, final String records);
 
+  /**
+   * Write a set of Points to the influxdb database with the string records.
+   *
+   * {@linkplain "https://github.com/influxdb/influxdb/pull/2696"}
+   *
+   * @param records
+   */
+  public void write(final String database, final String retentionPolicy,
+          final ConsistencyLevel consistency, final TimeUnit precision, final String records);
+
   /**
    * Write a set of Points to the influxdb database with the list of string records.
    *
@@ -207,6 +217,16 @@ public void write(final String database, final String retentionPolicy,
   public void write(final String database, final String retentionPolicy,
                     final ConsistencyLevel consistency, final List<String> records);
 
+  /**
+   * Write a set of Points to the influxdb database with the list of string records.
+   *
+   * {@linkplain "https://github.com/influxdb/influxdb/pull/2696"}
+   *
+   * @param records
+   */
+  public void write(final String database, final String retentionPolicy,
+          final ConsistencyLevel consistency, final TimeUnit precision, final List<String> records);
+
   /**
    * Write a set of Points to the influxdb database with the string records through UDP.
    *

src/main/java/org/influxdb/dto/BatchPoints.java

@@ -4,6 +4,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.concurrent.TimeUnit;
 
 import org.influxdb.InfluxDB.ConsistencyLevel;
 
@@ -27,6 +28,7 @@ public class BatchPoints {
   private Map<String, String> tags;
   private List<Point> points;
   private ConsistencyLevel consistency;
+  private TimeUnit precision;
 
   BatchPoints() {
     // Only visible in the Builder
@@ -52,6 +54,7 @@ public static final class Builder {
     private final Map<String, String> tags = Maps.newTreeMap(Ordering.natural());
     private final List<Point> points = Lists.newArrayList();
     private ConsistencyLevel consistency;
+    private TimeUnit precision;
 
     /**
      * @param database
@@ -118,6 +121,16 @@ public Builder consistency(final ConsistencyLevel consistencyLevel) {
       return this;
     }
 
+    /**
+     * Set the time precision to use for the whole batch. If unspecified, will default to {@link TimeUnit#NANOSECONDS}
+     * @param precision
+     * @return the Builder instance
+     */
+    public Builder precision(final TimeUnit precision) {
+      this.precision = precision;
+      return this;
+    }
+
     /**
      * Create a new BatchPoints instance.
      *
@@ -138,6 +151,10 @@ public BatchPoints build() {
         this.consistency = ConsistencyLevel.ONE;
       }
       batchPoints.setConsistency(this.consistency);
+      if (null == this.precision) {
+        this.precision = TimeUnit.NANOSECONDS;
+      }
+      batchPoints.setPrecision(this.precision);
       return batchPoints;
     }
   }
@@ -187,6 +204,20 @@ void setPoints(final List<Point> points) {
     this.points = points;
   }
 
+  /**
+   * @return the time precision unit
+   */
+  public TimeUnit getPrecision() {
+    return precision;
+  }
+
+  /**
+   * @param precision the time precision to set for the batch points
+   */
+  public void setPrecision(final TimeUnit precision) {
+    this.precision = precision;
+  }
+
   /**
    * Add a single Point to these batches.
    *
@@ -242,12 +273,13 @@ public boolean equals(final Object o) {
             && Objects.equals(retentionPolicy, that.retentionPolicy)
             && Objects.equals(tags, that.tags)
             && Objects.equals(points, that.points)
-            && consistency == that.consistency;
+            && consistency == that.consistency
+            && precision == that.precision;
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(database, retentionPolicy, tags, points, consistency);
+    return Objects.hash(database, retentionPolicy, tags, points, consistency, precision);
   }
 
   /**
@@ -264,6 +296,8 @@ public String toString() {
     builder.append(this.consistency);
     builder.append(", tags=");
     builder.append(this.tags);
+    builder.append(", precision=");
+    builder.append(this.precision);
     builder.append(", points=");
     builder.append(this.points);
     builder.append("]");
@@ -278,8 +312,9 @@ public String toString() {
    */
   public String lineProtocol() {
     StringBuilder sb = new StringBuilder();
+
     for (Point point : this.points) {
-      sb.append(point.lineProtocol()).append("\n");
+      sb.append(point.lineProtocol(this.precision)).append("\n");
     }
     return sb.toString();
   }

src/main/java/org/influxdb/dto/Point.java

@@ -328,6 +328,20 @@ public String lineProtocol() {
     return sb.toString();
   }
 
+  /**
+   * Calculate the lineprotocol entry for a single point, using a specific {@link TimeUnit} for the timestamp.
+   * @param precision the time precision unit for this point
+   * @return the String without newLine
+   */
+  public String lineProtocol(final TimeUnit precision) {
+    final StringBuilder sb = new StringBuilder();
+    sb.append(KEY_ESCAPER.escape(this.measurement));
+    sb.append(concatenatedTags());
+    sb.append(concatenateFields());
+    sb.append(formatedTime(precision));
+    return sb.toString();
+  }
+
   private StringBuilder concatenatedTags() {
     final StringBuilder sb = new StringBuilder();
     for (Entry<String, String> tag : this.tags.entrySet()) {
@@ -385,4 +399,10 @@ private StringBuilder formatedTime() {
     return sb;
   }
 
+  private StringBuilder formatedTime(final TimeUnit precision) {
+    final StringBuilder sb = new StringBuilder();
+    sb.append(" ").append(precision.convert(this.time, this.precision));
+    return sb;
+  }
+
 }

src/main/java/org/influxdb/impl/InfluxDBImpl.java

@@ -269,31 +269,46 @@ public void write(final BatchPoints batchPoints) {
         this.password,
         batchPoints.getDatabase(),
         batchPoints.getRetentionPolicy(),
-        TimeUtil.toTimePrecision(TimeUnit.NANOSECONDS),
+        TimeUtil.toTimePrecision(batchPoints.getPrecision()),
         batchPoints.getConsistency().value(),
         lineProtocol));
   }
 
+
   @Override
   public void write(final String database, final String retentionPolicy, final ConsistencyLevel consistency,
-      final String records) {
+          final TimeUnit precision, final String records) {
     execute(this.influxDBService.writePoints(
         this.username,
         this.password,
         database,
         retentionPolicy,
-        TimeUtil.toTimePrecision(TimeUnit.NANOSECONDS),
+        TimeUtil.toTimePrecision(precision),
         consistency.value(),
         RequestBody.create(MEDIA_TYPE_STRING, records)));
   }
 
+  @Override
+  public void write(final String database, final String retentionPolicy, final ConsistencyLevel consistency,
+      final String records) {
+    write(database, retentionPolicy, consistency, TimeUnit.NANOSECONDS, records);
+  }
+
   @Override
   public void write(final String database, final String retentionPolicy, final ConsistencyLevel consistency,
       final List<String> records) {
+    write(database, retentionPolicy, consistency, TimeUnit.NANOSECONDS, records);
+  }
+
+
+  @Override
+  public void write(final String database, final String retentionPolicy, final ConsistencyLevel consistency,
+          final TimeUnit precision, final List<String> records) {
     final String joinedRecords = Joiner.on("\n").join(records);
-    write(database, retentionPolicy, consistency, joinedRecords);
+    write(database, retentionPolicy, consistency, precision, joinedRecords);
   }
 
+
   /**
    * {@inheritDoc}
    */