/// <summary>
/// Updates the timestamp for the point represented by <see cref="TimeSpan"/>.
/// </summary>
/// <param name="timestamp">the timestamp</param>
/// <param name="timeUnit">the timestamp precision</param>
/// <returns></returns>
public Point Timestamp(TimeSpan timestamp, WritePrecision timeUnit)
{
Precision = timeUnit;
switch (timeUnit)
{
case WritePrecision.Ns:
_time = timestamp.Ticks * 100;
break;
case WritePrecision.Us:
_time = (BigInteger)(timestamp.Ticks * 0.1);
break;
case WritePrecision.Ms:
_time = (BigInteger)timestamp.TotalMilliseconds;
break;
case WritePrecision.S:
_time = (BigInteger)timestamp.TotalSeconds;
break;
}
return(this);
}
/// <summary>
/// Updates the timestamp for the point.
/// </summary>
/// <param name="timestamp">the timestamp</param>
/// <param name="timeUnit">the timestamp precision</param>
/// <returns></returns>
public Point Timestamp(long timestamp, WritePrecision timeUnit)
{
Precision = timeUnit;
_time = timestamp;
return(this);
}
private Builder(string measurementName)
{
Arguments.CheckNonEmptyString(measurementName, "Measurement name");
_measurementName = measurementName;
_precision = WritePrecision.Ns;
}
private static BigInteger InstantToBigInteger(Instant timestamp, WritePrecision timeUnit)
{
BigInteger time;
switch (timeUnit)
{
case WritePrecision.S:
time = timestamp.ToUnixTimeSeconds();
break;
case WritePrecision.Ms:
time = timestamp.ToUnixTimeMilliseconds();
break;
case WritePrecision.Us:
time = (long)(timestamp.ToUnixTimeTicks() * 0.1);
break;
case WritePrecision.Ns:
time = (timestamp - NodaConstants.UnixEpoch).ToBigIntegerNanoseconds();
break;
default:
throw new ArgumentOutOfRangeException(nameof(timeUnit), timeUnit, "WritePrecision value is not supported");
}
return(time);
}
/// <summary>
/// Updates the timestamp for the point represented by <see cref="Instant"/>.
/// </summary>
/// <param name="timestamp">the timestamp</param>
/// <param name="timeUnit">the timestamp precision</param>
/// <returns></returns>
public Point Timestamp(Instant timestamp, WritePrecision timeUnit)
{
Precision = timeUnit;
switch (timeUnit)
{
case WritePrecision.S:
_time = timestamp.ToUnixTimeSeconds();
break;
case WritePrecision.Ms:
_time = timestamp.ToUnixTimeMilliseconds();
break;
case WritePrecision.Us:
_time = (long)(timestamp.ToUnixTimeTicks() * 0.1);
break;
default:
_time = (timestamp - NodaConstants.UnixEpoch).ToBigIntegerNanoseconds();
break;
}
return(this);
}
/// <summary>
/// Updates the timestamp for the point represented by <see cref="Instant"/>.
/// </summary>
/// <param name="timestamp">the timestamp</param>
/// <param name="timeUnit">the timestamp precision</param>
/// <returns></returns>
public PointData Timestamp(Instant timestamp, WritePrecision timeUnit)
{
BigInteger?time = null;
switch (timeUnit)
{
case WritePrecision.S:
time = timestamp.ToUnixTimeSeconds();
break;
case WritePrecision.Ms:
time = timestamp.ToUnixTimeMilliseconds();
break;
case WritePrecision.Us:
time = (long)(timestamp.ToUnixTimeTicks() * 0.1);
break;
default:
time = (timestamp - NodaConstants.UnixEpoch).ToBigIntegerNanoseconds();
break;
}
return(new PointData(_measurementName,
timeUnit,
time,
_tags,
_fields));
}
private async Task <IRestResponse> WriteData(string org, string bucket, WritePrecision precision, IEnumerable <BatchWriteData> data)
{
var sb = new StringBuilder("");
foreach (var item in data)
{
var lineProtocol = item.ToLineProtocol();
if (string.IsNullOrEmpty(lineProtocol))
{
continue;
}
sb.Append(lineProtocol);
sb.Append("\n");
}
if (sb.Length == 0)
{
return(new RestResponse()
{
StatusCode = System.Net.HttpStatusCode.BadRequest, ErrorMessage = "The write doesn't contain any data, skipping"
});
}
// remove last \n
sb.Remove(sb.Length - 1, 1);
return(await _service.PostWriteAsync(org, bucket, Encoding.UTF8.GetBytes(sb.ToString()), null, "identity", "text/plain; charset=utf-8", null, "application/json", null, precision));
}
internal AbstractWriteEvent(string organization, string bucket, WritePrecision precision, string lineProtocol)
{
Organization = organization;
Bucket = bucket;
Precision = precision;
LineProtocol = lineProtocol;
}
private static BigInteger TimeSpanToBigInteger(TimeSpan timestamp, WritePrecision timeUnit)
{
BigInteger time;
switch (timeUnit)
{
case WritePrecision.Ns:
time = timestamp.Ticks * 100;
break;
case WritePrecision.Us:
time = (BigInteger)(timestamp.Ticks * 0.1);
break;
case WritePrecision.Ms:
time = (BigInteger)timestamp.TotalMilliseconds;
break;
case WritePrecision.S:
time = (BigInteger)timestamp.TotalSeconds;
break;
default:
throw new ArgumentOutOfRangeException(nameof(timeUnit), timeUnit, "WritePrecision value is not supported");
}
return(time);
}
private PointData(string measurementName)
{
Arguments.CheckNonEmptyString(measurementName, "Measurement name");
_measurementName = measurementName;
Precision = WritePrecision.Ns;
}
private async Task WriteData(string org, string bucket, WritePrecision precision, IEnumerable <BatchWriteData> data)
{
var sb = new StringBuilder("");
foreach (var item in data)
{
var lineProtocol = item.ToLineProtocol();
if (string.IsNullOrEmpty(lineProtocol))
{
continue;
}
sb.Append(lineProtocol);
sb.Append("\n");
}
if (sb.Length == 0)
{
Trace.WriteLine($"The writes: {data} doesn't contains any Line Protocol, skipping");
return;
}
// remove last \n
sb.Remove(sb.Length - 1, 1);
await _service.PostWriteAsync(org, bucket, Encoding.UTF8.GetBytes(sb.ToString()), null,
"identity", "text/plain; charset=utf-8", null, "application/json", null, precision);
}
/// <summary>
/// Updates the timestamp for the point represented by <see cref="TimeSpan"/>.
/// </summary>
/// <param name="timestamp">the timestamp</param>
/// <param name="timeUnit">the timestamp precision</param>
/// <returns></returns>
public PointData Timestamp(TimeSpan timestamp, WritePrecision timeUnit)
{
BigInteger?time = null;
switch (timeUnit)
{
case WritePrecision.Ns:
time = timestamp.Ticks * 100;
break;
case WritePrecision.Us:
time = (BigInteger)(timestamp.Ticks * 0.1);
break;
case WritePrecision.Ms:
time = (BigInteger)timestamp.TotalMilliseconds;
break;
case WritePrecision.S:
time = (BigInteger)timestamp.TotalSeconds;
break;
}
return(new PointData(_measurementName,
timeUnit,
time,
_tags,
_fields));
}
/// <summary>
/// Write Line Protocol record into specified bucket.
/// </summary>
/// <param name="bucket">specifies the destination bucket for writes</param>
/// <param name="org">specifies the destination organization for writes</param>
/// <param name="precision">specifies the precision for the unix timestamps within the body line-protocol</param>
/// <param name="record">
/// specifies the record in InfluxDB Line Protocol.
/// The <see cref="record" /> is considered as one batch unit.
/// </param>
public void WriteRecord(string bucket, string org, WritePrecision precision, string record)
{
Arguments.CheckNonEmptyString(bucket, nameof(bucket));
Arguments.CheckNonEmptyString(org, nameof(org));
Arguments.CheckNotNull(precision, nameof(precision));
_subject.OnNext(new BatchWriteRecord(new BatchWriteOptions(bucket, org, precision), record));
}
/// <summary>
/// Write Line Protocol records into specified bucket.
/// </summary>
/// <param name="bucket">specifies the destination bucket for writes</param>
/// <param name="org">specifies the destination organization for writes</param>
/// <param name="precision">specifies the precision for the unix timestamps within the body line-protocol</param>
/// <param name="records">specifies the record in InfluxDB Line Protocol</param>
public void WriteRecords(string bucket, string org, WritePrecision precision, List <string> records)
{
Arguments.CheckNonEmptyString(bucket, nameof(bucket));
Arguments.CheckNonEmptyString(org, nameof(org));
Arguments.CheckNotNull(precision, nameof(precision));
records.ForEach(record => WriteRecord(bucket, org, precision, record));
}
/// <summary>
/// Updates the timestamp for the point.
/// </summary>
/// <param name="timestamp">the timestamp</param>
/// <param name="timeUnit">the timestamp precision</param>
/// <returns></returns>
public PointData Timestamp(long timestamp, WritePrecision timeUnit)
{
return(new PointData(_measurementName,
timeUnit,
timestamp,
_tags,
_fields));
}
/// <summary>
/// Write Measurements into specified bucket.
/// </summary>
/// <param name="bucket">specifies the destination bucket for writes</param>
/// <param name="org">specifies the destination organization for writes</param>
/// <param name="precision">specifies the precision for the unix timestamps within the body line-protocol</param>
/// <param name="measurements">specifies Measurements to write into bucket</param>
/// <typeparam name="TM">measurement type</typeparam>
public void WriteMeasurements <TM>(string bucket, string org, WritePrecision precision,
params TM[] measurements)
{
Arguments.CheckNonEmptyString(bucket, nameof(bucket));
Arguments.CheckNonEmptyString(org, nameof(org));
Arguments.CheckNotNull(precision, nameof(precision));
WriteMeasurements(bucket, org, precision, measurements.ToList());
}
/// <summary>
/// Write Measurements into specified bucket.
/// </summary>
/// <param name="bucket">specifies the destination bucket for writes</param>
/// <param name="org">specifies the destination organization for writes</param>
/// <param name="precision">specifies the precision for the unix timestamps within the body line-protocol</param>
/// <param name="cancellationToken">specifies the token to monitor for cancellation requests</param>
/// <param name="measurements">specifies Measurements to write into bucket</param>
/// <typeparam name="TM">measurement type</typeparam>
public Task WriteMeasurementsAsync <TM>(string bucket, string org, WritePrecision precision,
CancellationToken cancellationToken, params TM[] measurements)
{
Arguments.CheckNonEmptyString(bucket, nameof(bucket));
Arguments.CheckNonEmptyString(org, nameof(org));
Arguments.CheckNotNull(precision, nameof(precision));
return(WriteMeasurementsAsync(bucket, org, precision, measurements.ToList(), cancellationToken));
}
/// <summary>
/// Write Line Protocol records into specified bucket.
/// </summary>
/// <param name="bucket">specifies the destination bucket for writes</param>
/// <param name="org">specifies the destination organization for writes</param>
/// <param name="precision">specifies the precision for the unix timestamps within the body line-protocol</param>
/// <param name="records">specifies the record in InfluxDB Line Protocol</param>
public async Task WriteRecordsAsync(string bucket, string org, WritePrecision precision,
params string[] records)
{
Arguments.CheckNonEmptyString(bucket, nameof(bucket));
Arguments.CheckNonEmptyString(org, nameof(org));
Arguments.CheckNotNull(precision, nameof(precision));
await WriteRecordsAsync(bucket, org, precision, records.ToList());
}
/// <summary>
/// Write Measurements into specified bucket.
/// </summary>
/// <param name="bucket">specifies the destination bucket for writes</param>
/// <param name="org">specifies the destination organization for writes</param>
/// <param name="precision">specifies the precision for the unix timestamps within the body line-protocol</param>
/// <param name="measurements">specifies Measurements to write into bucket</param>
/// <typeparam name="TM">measurement type</typeparam>
public async Task WriteMeasurementsAsync <TM>(string bucket, string org, WritePrecision precision,
params TM[] measurements)
{
Arguments.CheckNonEmptyString(bucket, nameof(bucket));
Arguments.CheckNonEmptyString(org, nameof(org));
Arguments.CheckNotNull(precision, nameof(precision));
await WriteMeasurementsAsync(bucket, org, precision, measurements.ToList());
}
/// <summary>
/// Write Line Protocol records into specified bucket.
/// </summary>
/// <param name="bucket">specifies the destination bucket for writes</param>
/// <param name="org">specifies the destination organization for writes</param>
/// <param name="precision">specifies the precision for the unix timestamps within the body line-protocol</param>
/// <param name="cancellationToken">specifies the token to monitor for cancellation requests</param>
/// <param name="records">specifies the record in InfluxDB Line Protocol</param>
public Task WriteRecordsAsync(string bucket, string org, WritePrecision precision,
CancellationToken cancellationToken, params string[] records)
{
Arguments.CheckNonEmptyString(bucket, nameof(bucket));
Arguments.CheckNonEmptyString(org, nameof(org));
Arguments.CheckNotNull(precision, nameof(precision));
return(WriteRecordsAsync(bucket, org, precision, records.ToList(), cancellationToken));
}
private Point(string measurementName)
{
Arguments.CheckNonEmptyString(measurementName, "Measurement name");
_measurementName = measurementName;
_fields = new SortedDictionary <string, object>(StringComparer.Ordinal);
_tags = new SortedDictionary <string, string>(StringComparer.Ordinal);
Precision = WritePrecision.Ns;
}
internal BatchWriteOptions(string bucket, string org, WritePrecision precision)
{
Arguments.CheckNonEmptyString(bucket, nameof(bucket));
Arguments.CheckNonEmptyString(org, nameof(org));
Arguments.CheckNotNull(precision, nameof(precision));
Bucket = bucket;
OrganizationId = org;
Precision = precision;
}
/// <summary>
/// Write Line Protocol record into specified bucket.
/// </summary>
/// <param name="bucket">specifies the destination bucket for writes</param>
/// <param name="org">specifies the destination organization for writes</param>
/// <param name="precision">specifies the precision for the unix timestamps within the body line-protocol</param>
/// <param name="record">
/// specifies the record in InfluxDB Line Protocol.
/// The <see cref="record" /> is considered as one batch unit.
/// </param>
public async Task WriteRecordAsync(string bucket, string org, WritePrecision precision, string record)
{
Arguments.CheckNonEmptyString(bucket, nameof(bucket));
Arguments.CheckNonEmptyString(org, nameof(org));
Arguments.CheckNotNull(precision, nameof(precision));
await WriteRecordsAsync(bucket, org, precision, new List <string> {
record
});
}
/// <summary>
/// Write Line Protocol record into specified bucket.
/// </summary>
/// <param name="bucket">specifies the destination bucket for writes</param>
/// <param name="org">specifies the destination organization for writes</param>
/// <param name="precision">specifies the precision for the unix timestamps within the body line-protocol</param>
/// <param name="record">
/// specifies the record in InfluxDB Line Protocol.
/// The <see cref="record" /> is considered as one batch unit.
/// </param>
/// <param name="cancellationToken">specifies the token to monitor for cancellation requests</param>
public Task WriteRecordAsync(string bucket, string org, WritePrecision precision, string record, CancellationToken cancellationToken = default)
{
Arguments.CheckNonEmptyString(bucket, nameof(bucket));
Arguments.CheckNonEmptyString(org, nameof(org));
Arguments.CheckNotNull(precision, nameof(precision));
return(WriteRecordsAsync(bucket, org, precision, new List <string> {
record
}, cancellationToken));
}
/// <summary>
/// Updates the timestamp for the point represented by <see cref="Instant"/>.
/// </summary>
/// <param name="timestamp">the timestamp</param>
/// <param name="timeUnit">the timestamp precision</param>
/// <returns></returns>
public PointData Timestamp(Instant timestamp, WritePrecision timeUnit)
{
var time = InstantToBigInteger(timestamp, timeUnit);
return(new PointData(_measurementName,
timeUnit,
time,
_tags,
_fields));
}
/// <summary>
/// Updates the timestamp for the point represented by <see cref="DateTime"/>.
/// </summary>
/// <param name="timestamp">the timestamp</param>
/// <param name="timeUnit">the timestamp precision</param>
/// <returns></returns>
public PointData Timestamp(DateTime timestamp, WritePrecision timeUnit)
{
if (timestamp != null && timestamp.Kind != DateTimeKind.Utc)
{
throw new ArgumentException("Timestamps must be specified as UTC", nameof(timestamp));
}
var timeSpan = timestamp.Subtract(EpochStart);
return(Timestamp(timeSpan, timeUnit));
}
/// <summary>
/// Write Line Protocol records into specified bucket.
/// </summary>
/// <param name="bucket">specifies the destination bucket for writes</param>
/// <param name="org">specifies the destination organization for writes</param>
/// <param name="precision">specifies the precision for the unix timestamps within the body line-protocol</param>
/// <param name="records">specifies the record in InfluxDB Line Protocol</param>
public void WriteRecords(string bucket, string org, WritePrecision precision, params string[] records)
{
Arguments.CheckNonEmptyString(bucket, nameof(bucket));
Arguments.CheckNonEmptyString(org, nameof(org));
Arguments.CheckNotNull(precision, nameof(precision));
foreach (var record in records)
{
WriteRecord(bucket, org, precision, record);
}
}
/// <summary>
/// Write Measurements into specified bucket.
/// </summary>
/// <param name="bucket">specifies the destination bucket for writes</param>
/// <param name="org">specifies the destination organization for writes</param>
/// <param name="precision">specifies the precision for the unix timestamps within the body line-protocol</param>
/// <param name="measurements">specifies Measurements to write into bucket</param>
/// <typeparam name="TM">measurement type</typeparam>
public void WriteMeasurements <TM>(string bucket, string org, WritePrecision precision, List <TM> measurements)
{
Arguments.CheckNonEmptyString(bucket, nameof(bucket));
Arguments.CheckNonEmptyString(org, nameof(org));
Arguments.CheckNotNull(precision, nameof(precision));
foreach (var measurement in measurements)
{
WriteMeasurement(bucket, org, precision, measurement);
}
}
private PointData(string measurementName,
WritePrecision precision,
BigInteger?time,
ImmutableSortedDictionary <string, string> tags,
ImmutableSortedDictionary <string, object> fields)
{
_measurementName = measurementName;
Precision = precision;
_time = time;
_tags = tags;
_fields = fields;
}
/// <summary>
/// Write a Measurement into specified bucket.
/// </summary>
/// <param name="bucket">specifies the destination bucket for writes</param>
/// <param name="org">specifies the destination organization for writes</param>
/// <param name="precision">specifies the precision for the unix timestamps within the body line-protocol</param>
/// <param name="measurement">specifies the Measurement to write into bucket</param>
/// <typeparam name="TM">measurement type</typeparam>
public async Task WriteMeasurementAsync <TM>(string bucket, string org, WritePrecision precision, TM measurement)
{
Arguments.CheckNonEmptyString(bucket, nameof(bucket));
Arguments.CheckNonEmptyString(org, nameof(org));
Arguments.CheckNotNull(precision, nameof(precision));
if (measurement == null)
{
return;
}
await WriteMeasurementsAsync(bucket, org, precision, new List <TM>() { measurement });
}
