public void Write(string data)
{
using (WriteApi writeApi = _client.GetWriteApi())
{
writeApi.WriteRecord(DB_BUCKET, DB_ORGANIZATION, InfluxDB.Client.Api.Domain.WritePrecision.Ms, data);
}
}
public void DisposeCallFromInfluxDbClientToWriteApi()
{
var writeApi = _influxDbClient.GetWriteApi();
Assert.False(writeApi.Disposed);
_influxDbClient.Dispose();
Assert.True(writeApi.Disposed);
}
public void WriteData()
{
var point = PointData
.Measurement("influxData")
.Tag("assetId", "1")
.Field("used_percent", 23.43234543)
.Timestamp(DateTime.UtcNow, WritePrecision.Ns);
using (var writeApi = client.GetWriteApi())
{
writeApi.WritePoint(bucket, org, point);
}
}
public void Write(string bucket, string org, PointData point)
{
using (var writeApi = client.GetWriteApi())
{
writeApi.WritePoint(bucket, org, point);
}
}
private void Initialize()
{
try
{
if (_client == null)
{
char[] password = string.IsNullOrWhiteSpace(_settings.Password) ? null : _settings.Password.ToCharArray();
_client = InfluxDBClientFactory.CreateV1(_settings.Url, _settings.Username, password, _settings.Database, _settings.RetentionPolicy);
}
if (_writeApi == null)
{
_writeApi = _client.GetWriteApi(new WriteOptions.Builder().BatchSize(_settings.WriteBatchSize).FlushInterval(_settings.WriteFlushIntervalMillis).Build());
_writeApi.EventHandler += OnWriteApiEvent;
}
}
catch (Exception)
{
_writeApi?.Dispose();
_writeApi = null;
_client?.Dispose();
_client = null;
throw;
}
}
public static async Task GenerateSensorData(Sensor sensor, InfluxDBClient client)
{
var range = sensor.Max - sensor.Min;
var random = new Random();
var currentValue = (random.NextDouble() * range) + sensor.Min;
var modifier = Math.Abs(range / 100.0);
using var writeApi = client.GetWriteApi();
var dataCache = new List <PointData>();
Console.WriteLine($"Simulating sensor {sensor.Name} for device {Program.DeviceID} at an interval of {sensor.Interval}ms");
while (true)
{
currentValue += modifier * Math.Max(random.NextDouble(), 0.6);
if (currentValue <= sensor.Min || currentValue >= sensor.Max || random.NextDouble() > Math.Max(Math.Tanh((currentValue - sensor.Min) / range), 0.8))
{
modifier *= -1;
}
dataCache.Add(PointData
.Measurement("simulatedValues")
.Tag("deviceId", Program.DeviceID)
.Field(sensor.Name, currentValue));
if (dataCache.Count > 50)
{
writeApi.WritePoints(Program.ServerBucket, Program.ServerOrg, dataCache);
dataCache.Clear();
}
await Task.Delay(sensor.Interval);
}
}
public void Save(string id, string name, double amount, string measure)
{
using var writeApi = _influxDbClient.GetWriteApi();
var health = _influxDbClient.HealthAsync().GetAwaiter().GetResult();
PointData point = null;
if (measure == "%")
{
point = PointData.Measurement("sensor")
.Tag("id", id)
.Tag("name", name)
.Field("Humidity", amount)
.Timestamp(DateTime.UtcNow, WritePrecision.S);
}
else if (measure == "°C")
{
point = PointData.Measurement("sensor")
.Tag("id", id)
.Tag("name", name)
.Field("Temperature", amount)
.Timestamp(DateTime.UtcNow, WritePrecision.S);
}
if (point != null)
{
writeApi.WritePoint("AnimusHeart", "AnimusHeart", point);
}
}
static void update(EnvAgencyRainfall api, EnvAgencyRainfall.GetStationsData stations, InfluxDBClient influxDBClient)
{
// Write Data to influx
using (var writeApi = influxDBClient.GetWriteApi())
{
foreach (var s in stations.items)
{
if (s.measures == null || s.measures.Count == 0)
{
continue;
}
var rainfallMeasure = s.measures.Find(x => x.parameter.Equals("rainfall"));
if (rainfallMeasure == null)
{
continue;
}
var measurement = api.GetLatestMeasurement(s.stationReference);
if (measurement == null)
{
// TODO: One instance of this is a rainfall sensor returning value: [0, 0.4], as array instead of single value
// There doesn't appear to be anything in the api to signify this, will need to read the docs to tell if it's
// an actual error. No big deal really just that sensor won't be read
continue;
}
if (measurement.items != null && measurement.items.Count > 0)
{
foreach (var i in measurement.items)
{
if (!i.parameter.Equals("rainfall"))
{
continue;
}
var absReading = i.latestReading.value;
var mmPerPeriod = absReading;
if (!i.unit.Equals("http://qudt.org/1.1/vocab/unit#Millimeter"))
{
// Again TODO - Ignore for now as most sensors seem to be mm based.
// Should just scale up and we'd be good
continue;
}
var mmPerHour = mmPerPeriod * (3600.0 / i.period);
Console.WriteLine($"{s.stationReference} : {s.lat},{s.lon} : {mmPerHour}mm/h");
/// ///////////////////////////////////////////
// TODO: Take actual timestamp from rainfall reading. This is currently just polling, so less accurate/etc
var point = PointData.Measurement("rainfall")
.Tag("location", s.stationReference)
.Field("value", mmPerHour)
.Timestamp(DateTime.UtcNow, WritePrecision.S);
writeApi.WritePoint(BucketName, OrgName, point);
}
}
}
}
}
public void ReportError()
{
var pointdata = PointData.Measurement("error");
pointdata.Field("message", "TODO: use error messages :)");
pointdata.Timestamp(DateTime.UtcNow, InfluxDB.Client.Api.Domain.WritePrecision.Ms);
errors_client.GetWriteApi().WritePoint(pointdata);
}
public void ReportWeight(string tag, int weight)
{
var pointdata = PointData.Measurement("weight");
pointdata.Tag("vegetable", tag);
pointdata.Field("weight", weight);
pointdata.Timestamp(DateTime.UtcNow, InfluxDB.Client.Api.Domain.WritePrecision.Ms);
data_client.GetWriteApi().WritePoint(pointdata);
}
public void WriteData(Bot bot, Mem mem)
{
mem = new Mem {
Host = "host1", UsedPercent = 23.43234543, Time = DateTime.UtcNow
};
using (var writeApi = _client.GetWriteApi())
{
writeApi.WriteMeasurement(bot.Bucket, bot.Org, WritePrecision.Ms, mem);
}
}
public void LogLevelWithQueryString()
{
var writer = new StringWriter();
Trace.Listeners.Add(new TextWriterTraceListener(writer));
_client.SetLogLevel(LogLevel.Headers);
MockServer
.Given(Request.Create().WithPath("/api/v2/write").UsingPost())
.RespondWith(CreateResponse("{}"));
using (var writeApi = _client.GetWriteApi())
{
writeApi.WriteRecord("b1", "org1", WritePrecision.Ns,
"h2o_feet,location=coyote_creek water_level=1.0 1");
}
StringAssert.Contains("org=org1", writer.ToString());
StringAssert.Contains("bucket=b1", writer.ToString());
StringAssert.Contains("precision=ns", writer.ToString());
}
private async void QueueUpdate(QueueCountEventArgs e, string queue)
{
await CheckInflux();
using var db = _influxDb.GetWriteApi();
var datapoint = new DataPoint()
{
Count = e.QueueCount,
Queue = queue
};
db.WriteMeasurement("shoko", "default", WritePrecision.Ms, datapoint);
}
public void GzipDisabledWrite()
{
_client.DisableGzip();
MockServer
.Given(Request.Create().UsingPost())
.RespondWith(CreateResponse(""));
var writeApi = _client.GetWriteApi();
var listener = new WriteApiTest.EventListener(writeApi);
writeApi.WriteRecord("my-bucket", "my-org", WritePrecision.Ns,
"h2o_feet,location=coyote_creek water_level=1.0 1");
writeApi.Flush();
listener.WaitToSuccess();
var requestEntry = MockServer.LogEntries.Last();
Assert.AreEqual($"{MockServerUrl}/api/v2/write?org=my-org&bucket=my-bucket&precision=ns",
requestEntry.RequestMessage.Url);
Assert.AreEqual("identity", requestEntry.RequestMessage.Headers["Content-Encoding"].First());
Assert.AreEqual("identity", requestEntry.RequestMessage.Headers["Accept-Encoding"].First());
}
public SensorDataModel UpdateSensor(SensorDataModel sensorData)
{
using (var writeApi = _infux.GetWriteApi())
{
var point = PointData.Measurement("moisture")
.Tag("device", sensorData.Device)
.Field("value", sensorData.Reading)
.Timestamp(DateTime.UtcNow, WritePrecision.Ns);
writeApi.WritePoint("Sensors", "Droppy", point);
}
return(sensorData);
}
private NightFluxConnection(Configuration configuration)
{
Configuration = configuration;
InfluxClient = InfluxDBClientFactory.Create(Configuration.InfluxUrl, Configuration.InfluxToken.ToCharArray());
var wo = WriteOptions.CreateNew()
.BatchSize(8192)
.WriteScheduler(new NewThreadScheduler())
.RetryInterval(750)
.JitterInterval(136)
.FlushInterval(1000)
.Build();
InfluxWriteApi = InfluxClient.GetWriteApi(wo);
}
public static void insertDetection(Detection detectionInflux, InfluxDBClient influxDBClient, string bucket, string org)
{
using (var writeApi = influxDBClient.GetWriteApi())
{
try {
var point = PointData.Measurement("detection")
.Field("SensorId", (double)detectionInflux.SensorId)
.Field("ScooterId", (double)detectionInflux.ScooterId)
.Timestamp(DateTime.UtcNow.AddSeconds(-10), WritePrecision.Ns);
writeApi.WriteRecord(bucket, org, WritePrecision.Ns, "detection, sensor_id=1, scooter_id=2");
}
catch (Exception e) { Console.WriteLine(e.Message); }
}
}
public bool WriteToDB(cTelemetryEntry TelemetryEntry, string SatName)
{
var point = PointData
.Measurement("mem")
.Tag("host", SatName + "-ID" + TelemetryEntry.Id.ToString("00"))
.Field("value", TelemetryEntry.Value)
.Timestamp(TelemetryEntry.Timestamp, WritePrecision.Ns);
using (var writeApi = _Client.GetWriteApi())
{
writeApi.WritePoint(_Bucket, _Organisation, point);
}
return(true);
}
public ClientV2(List <CommandOption> options, WriteOptions writeOptions) : base(options, InfluxDb2Bucket, InfluxDb2Url, InfluxDb2Token)
{
if (writeOptions == null)
{
var batchSize = int.Parse(Benchmark.GetOptionValue(GetOption(options, "batchSize"), "50000"));
var flushInterval = int.Parse(Benchmark.GetOptionValue(GetOption(options, "flushInterval"), "10000"));
writeOptions = WriteOptions.CreateNew().BatchSize(batchSize).FlushInterval(flushInterval).Build();
}
InfluxDBClientOptions opts = InfluxDBClientOptions.Builder.CreateNew()
.Url(InfluxDb2Url)
.AuthenticateToken(InfluxDb2Token.ToCharArray())
.LogLevel(LogLevel.Headers).Build();
_client = InfluxDBClientFactory.Create(opts);
_writeApi = _client.GetWriteApi(writeOptions);
}
/// <inheritdoc />
/// <summary>
/// Emit a batch of log events, running asynchronously.
/// </summary>
/// <param name="events">The events to emit.</param>
/// <remarks>Override either <see cref="M:Serilog.Sinks.PeriodicBatching.PeriodicBatchingSink.EmitBatch(System.Collections.Generic.IEnumerable{Serilog.Events.LogEvent})" /> or <see cref="M:Serilog.Sinks.PeriodicBatching.PeriodicBatchingSink.EmitBatchAsync(System.Collections.Generic.IEnumerable{Serilog.Events.LogEvent})" />,
/// not both.</remarks>
protected override void EmitBatch(IEnumerable <LogEvent> events)
{
if (events == null)
{
throw new ArgumentNullException(nameof(events));
}
var logEvents = events as List <LogEvent> ?? events.ToList();
var points = new List <PointData>(logEvents.Count);
foreach (var logEvent in logEvents)
{
// Create point data object
var point = PointData.Measurement(_source);
// Add tags
point = point.Tag("level", logEvent.Level.ToString());
point = point.Tag("hostname", Environment.MachineName);
if (logEvent.Exception != null)
{
point = point.Tag("exceptionType", logEvent.Exception.GetType().Name);
}
if (logEvent.MessageTemplate != null)
{
point = point.Tag("messageTemplate", logEvent.MessageTemplate.Text);
}
// Add fields
foreach (var property in logEvent.Properties)
{
point = point.Field(property.Key, property.Value.ToString());
}
point = point.Field("message", logEvent.RenderMessage(_formatProvider));
// Set the log event timestamp
point = point.Timestamp(DateTime.UtcNow, InfluxDB.Client.Api.Domain.WritePrecision.Ns);
// Add a point in the list of points
points.Add(point);
}
// Send log events to InfluxDB instance.
using var writeApi = _influxDbClient.GetWriteApi();
writeApi.WritePoints(_connectionInfo.Bucket, _connectionInfo.Organization, points);
}
public void WriteRoomData(HeatHub hub)
{
using (var writeApi = client.GetWriteApi())
{
foreach (var room in hub.Room)
{
if (room.CalculatedTemperature < -1000.0)
{
this.logger.LogWarning("{roomName} is not reporting temperature ({reportedTemp}/{alexaTemp}).", room.Name, room.CalculatedTemperature, room.RoundedAlexaTemperature);
continue;
}
writeApi.WriteMeasurement(this.options.BucketId, this.options.OrgId, WritePrecision.S, room.AsRoomDataMeasurement());
}
writeApi.Flush();
}
}
/// <summary>
/// Scrittura telemetria su database
/// </summary>
/// <param name="jsonTelemetry">Telemetria in formato json</param>
/// <returns></returns>
public async Task WriteData(String jsonTelemetry)
{
try
{
//deserializzazione stringa json in dizionario
Dictionary <string, object> values = JsonConvert.DeserializeObject <Dictionary <string, object> >(jsonTelemetry);
using (var writeApi = client.GetWriteApi())
{
//ottengo id della macchina a partire dalla telemetria
var machine_id = values.First(u => u.Key.Equals("machine_id"));
//COSTRUZIONE NUOVA ENTRY (POINT)
//Questa entry verrà inserita nella serie (tabella/measurement) denominata dal'identificativo
//della macchina (machine_id)
var point = PointData.Measurement(machine_id.Value.ToString());
values.Remove(machine_id.Key);
foreach (KeyValuePair <string, object> kv in values)
{
if (kv.Key == "ts")
{
point = point.Timestamp(Convert.ToInt64(kv.Value), WritePrecision.Ms);
}
else
{
point = point.Field(kv.Key, Convert.ToInt64(kv.Value));
}
}
//scrittura su db
writeApi.WritePoint(point);
}
}
catch (Exception e)
{
log.ErrorFormat("!ERROR: {0}", e.ToString());
}
}
public InfluxDbClientWriter(InfluxDBClient client, BufferedChannelOptions options)
{
_api = client.GetWriteApi();
_channel = new BufferedChannel <PointData>(options);
_channel.RegisterConsumer(SendDataPoints);
}
public static async Task Example(InfluxDBClient influxDB)
{
var organizationClient = influxDB.GetOrganizationsApi();
var medicalGMBH = await organizationClient
.CreateOrganization("Medical Corp " +
DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff",
CultureInfo.InvariantCulture));
//
// Create New Bucket with retention 1h
//
var temperatureBucket = await influxDB.GetBucketsApi().CreateBucket("temperature-sensors", medicalGMBH.Id);
//
// Add Permissions to read and write to the Bucket
//
var resource = new PermissionResource
{
Type = PermissionResource.TypeEnum.Buckets, OrgID = medicalGMBH.Id, Id = temperatureBucket.Id
};
var readBucket = new Permission
{
Resource = resource,
Action = Permission.ActionEnum.Read
};
var writeBucket = new Permission
{
Resource = resource,
Action = Permission.ActionEnum.Write
};
var authorization = await influxDB.GetAuthorizationsApi()
.CreateAuthorization(medicalGMBH, new List <Permission> {
readBucket, writeBucket
});
Console.WriteLine($"The token to write to temperature-sensors bucket is: {authorization.Token}");
influxDB.Dispose();
//
// Create new client with specified authorization token
//
influxDB = InfluxDBClientFactory.Create("http://localhost:9999", authorization.Token.ToCharArray());
var writeOptions = WriteOptions
.CreateNew()
.BatchSize(5000)
.FlushInterval(1000)
.JitterInterval(1000)
.RetryInterval(5000)
.Build();
//
// Write data
//
using (var writeClient = influxDB.GetWriteApi(writeOptions))
{
//
// Write by POCO
//
var temperature = new Temperature {
Location = "south", Value = 62D, Time = DateTime.UtcNow
};
writeClient.WriteMeasurement("temperature-sensors", medicalGMBH.Id, WritePrecision.Ns, temperature);
//
// Write by Point
//
var point = Point.Measurement("temperature")
.Tag("location", "west")
.Field("value", 55D)
.Timestamp(DateTime.UtcNow.AddSeconds(-10), WritePrecision.Ns);
writeClient.WritePoint("temperature-sensors", medicalGMBH.Id, point);
//
// Write by LineProtocol
//
var record = "temperature,location=north value=60.0";
writeClient.WriteRecord("temperature-sensors", medicalGMBH.Id, WritePrecision.Ns, record);
writeClient.Flush();
Thread.Sleep(2000);
}
//
// Read data
//
var fluxTables = await influxDB.GetQueryApi().Query("from(bucket:\"temperature-sensors\") |> range(start: 0)", medicalGMBH.Id);
fluxTables.ForEach(fluxTable =>
{
var fluxRecords = fluxTable.Records;
fluxRecords.ForEach(fluxRecord =>
{
Console.WriteLine($"{fluxRecord.GetTime()}: {fluxRecord.GetValue()}");
});
});
influxDB.Dispose();
}
private void WriteToDb()
{
if (dbClient != null)
{
try
{
Log.Trace("WriteToDb");
var data = OverviewData.GetOverviewData();
var dbConfig = WorkersManager.GetWorkersManager().Config;
var point = Point.Measurement("air")
.Tag("location", dbConfig.Location != null ? dbConfig.Location : "prosek")
.Tag("device_id", dbConfig.DeviceId);
int validFields = 0;
if (!double.IsNaN(data.CurrentTemperature))
{
point.Field("temperature", data.CurrentTemperature);
++validFields;
}
if (!double.IsNaN(data.CurrentPressure))
{
point.Field("pressure", data.CurrentPressure);
++validFields;
}
if (!double.IsNaN(data.CurrentHumidity))
{
point.Field("humidity", data.CurrentHumidity);
++validFields;
}
if (validFields > 0)
{
using (var dbWriteApi = dbClient.GetWriteApi())
{
dbWriteApi.EventHandler += DbWriteApi_EventHandler;
dbWriteApi.WritePoint(dbConfig.Bucket, dbConfig.OrgId, point);
dbWriteApi.Flush();
}
if (delay != originalDelay)
{
delay = originalDelay;
Log.Info($"Restoring delay to {delay}");
}
}
else
{
Log.Debug("InfluxDbWorker:WriteToDb - nothing to write, all values are invalid");
}
}
catch (Exception ex)
{
Log.Error("Db Write error", ex);
OnStatusChanged("DB Write Error: " + ex.Message);
//probably temporarly net down or db error, prolong delay to not overload with exception
if (delay == originalDelay)
{
delay *= 5;
Log.Info($"Prolonging delay to {delay}");
}
}
}
}
public async Task CreateMonitoringAndAlerting()
{
MockServer
.Given(Request.Create().UsingGet())
.RespondWith(CreateResponse("{}", "application/json"));
MockServer
.Given(Request.Create().UsingPost())
.RespondWith(CreateResponse("{}", "application/json"));
var org = (await _client.GetOrganizationsApi().FindOrganizationsAsync())
.First(organization => organization.Name.Equals("my-org"));
var checksApi = _client.GetChecksApi();
var notificationEndpointsApi = _client.GetNotificationEndpointsApi();
var notificationRulesApi = _client.GetNotificationRulesApi();
var checks = await checksApi.FindChecksAsync(org.Id, new FindOptions());
foreach (var delete in checks._Checks.Where(ne => ne.Name.EndsWith("-IT")))
{
await checksApi.DeleteCheckAsync(delete);
}
var rules = await notificationRulesApi.FindNotificationRulesAsync(org.Id, new FindOptions());
foreach (var delete in rules._NotificationRules.Where(ne => ne.Name.EndsWith("-IT")))
{
await notificationRulesApi.DeleteNotificationRuleAsync(delete);
}
var endpoints = await notificationEndpointsApi.FindNotificationEndpointsAsync(org.Id, new FindOptions());
foreach (var delete in endpoints._NotificationEndpoints.Where(ne => ne.Name.EndsWith("-IT")))
{
await notificationEndpointsApi.DeleteNotificationEndpointAsync(delete);
}
//
// Create Threshold Check
//
// Set status to 'Critical' if the 'current' value for 'stock' measurement is lesser than '35'
//
var query = "from(bucket: \"my-bucket\") "
+ "|> range(start: v.timeRangeStart, stop: v.timeRangeStop) "
+ "|> filter(fn: (r) => r._measurement == \"stock\") "
+ "|> filter(fn: (r) => r.company == \"zyz\") "
+ "|> aggregateWindow(every: 5s, fn: mean) "
+ "|> filter(fn: (r) => r._field == \"current\") "
+ "|> yield(name: \"mean\")";
var threshold = new LesserThreshold(value: 35F, level: CheckStatusLevel.CRIT,
type: LesserThreshold.TypeEnum.Lesser);
var message = "The Stock price for XYZ is on: ${ r._level } level!";
await checksApi.CreateThresholdCheckAsync(AbstractItClientTest.GenerateName("XYZ Stock value"), query, "5s", message, threshold, org.Id);
//
// Create Slack Notification endpoint
//
var url = MockServerUrl;
var endpoint =
await notificationEndpointsApi.CreateSlackEndpointAsync(
AbstractItClientTest.GenerateName("Slack Endpoint"), url, org.Id);
//
// Create Notification Rule
//
// Send message if the status is 'Critical'
//
await notificationRulesApi.CreateSlackRuleAsync(
AbstractItClientTest.GenerateName("Critical status to Slack"), "10s", "${ r._message }",
RuleStatusLevel.CRIT, endpoint, org.Id);
//
// Write Data
//
var now = DateTime.UtcNow;
var point1 = PointData
.Measurement("stock")
.Tag("company", "zyz")
.Field("current", 33.65)
.Timestamp(now, WritePrecision.Ns);
var writeApi = _client.GetWriteApi();
var listener = new WriteApiTest.EventListener(writeApi);
writeApi.WritePoint("my-bucket", "my-org", point1);
writeApi.Flush();
listener.WaitToSuccess();
var start = DateTime.UtcNow;
while (!MockServer.LogEntries.Any() && (DateTime.UtcNow - start).TotalSeconds < 30)
{
Thread.Sleep(100);
}
var requestEntry = MockServer.LogEntries.Last();
Assert.AreEqual($"{MockServerUrl}/", requestEntry.RequestMessage.Url);
var json = (JObject)requestEntry.RequestMessage.BodyAsJson;
Assert.IsNotNull(json.GetValue("attachments"));
var attachments = (JArray)json.GetValue("attachments");
Assert.AreEqual(1, attachments.Count);
Assert.AreEqual("The Stock price for XYZ is on: crit level!", attachments[0]["text"].ToString());
}
public async Task TrailingSlashInUrl()
{
MockServer
.Given(Request.Create().WithPath("/api/v2/write").UsingPost())
.RespondWith(CreateResponse("{}"));
using (var writeApi = _client.GetWriteApi())
{
writeApi.WriteRecord("b1", "org1", WritePrecision.Ns,
"h2o_feet,location=coyote_creek water_level=1.0 1");
}
var request = MockServer.LogEntries.Last();
Assert.AreEqual(MockServerUrl + "/api/v2/write?org=org1&bucket=b1&precision=ns",
request.RequestMessage.AbsoluteUrl);
_client.Dispose();
_client = InfluxDBClientFactory.Create(MockServerUrl + "/");
using (var writeApi = _client.GetWriteApi())
{
writeApi.WriteRecord("b1", "org1", WritePrecision.Ns,
"h2o_feet,location=coyote_creek water_level=1.0 1");
}
request = MockServer.LogEntries.Last();
Assert.AreEqual(MockServerUrl + "/api/v2/write?org=org1&bucket=b1&precision=ns",
request.RequestMessage.AbsoluteUrl);
_client.Dispose();
_client = InfluxDBClientFactory.Create(new InfluxDBClientOptions.Builder().Url(MockServerUrl)
.AuthenticateToken("my-token").Build());
using (var writeApi = _client.GetWriteApi())
{
writeApi.WriteRecord("b1", "org1", WritePrecision.Ns,
"h2o_feet,location=coyote_creek water_level=1.0 1");
}
request = MockServer.LogEntries.Last();
Assert.AreEqual(MockServerUrl + "/api/v2/write?org=org1&bucket=b1&precision=ns",
request.RequestMessage.AbsoluteUrl);
_client.Dispose();
_client = InfluxDBClientFactory.Create(new InfluxDBClientOptions.Builder().Url(MockServerUrl + "/")
.AuthenticateToken("my-token").Build());
using (var writeApi = _client.GetWriteApi())
{
writeApi.WriteRecord("b1", "org1", WritePrecision.Ns,
"h2o_feet,location=coyote_creek water_level=1.0 1");
}
request = MockServer.LogEntries.Last();
Assert.AreEqual(MockServerUrl + "/api/v2/write?org=org1&bucket=b1&precision=ns",
request.RequestMessage.AbsoluteUrl);
Assert.True(MockServer.LogEntries.Any());
foreach (var logEntry in MockServer.LogEntries)
{
StringAssert.StartsWith(MockServerUrl + "/api/v2/", logEntry.RequestMessage.AbsoluteUrl);
}
}
public WriteApi GetWriteApi()
{
return(_client.GetWriteApi());
}
