public static DynamicInfluxRow[] CreateDynamicRowsStartingAt(DateTime start, int rows)
{
var rng = new Random();
var timestamp = start;
var infos = new DynamicInfluxRow[rows];
for (int i = 0; i < rows; i++)
{
long ram = rng.Next(int.MaxValue);
double cpu = rng.NextDouble();
string region = Regions[rng.Next(Regions.Length)];
string host = Hosts[rng.Next(Hosts.Length)];
var info = new DynamicInfluxRow();
info.Fields.Add("cpu", cpu);
info.Fields.Add("ram", ram);
info.Tags.Add("host", host);
info.Tags.Add("region", region);
info.Timestamp = timestamp;
infos[i] = info;
timestamp = timestamp.AddSeconds(1);
}
return(infos);
}
public async Task Should_Read_And_Write_Dynamic_DateTimes()
{
var time = new DateTime(2013, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var row = new DynamicInfluxRow();
row.Timestamp = time;
row.Fields.Add("otherTime", time);
row.Fields.Add("otherTimeAsString", time.ToIso8601());
await _client.WriteAsync(InfluxClientFixture.DatabaseName, "dateTimeTests2", new[] { row });
var resultSet = await _client.ReadAsync <DynamicInfluxRow>(InfluxClientFixture.DatabaseName, "SELECT * FROM dateTimeTests2");
Assert.Equal(1, resultSet.Results.Count);
var result = resultSet.Results[0];
Assert.Equal(1, result.Series.Count);
var series = result.Series[0];
Assert.Equal(1, series.Rows.Count);
Assert.Equal(time.ToIso8601(), series.Rows[0].Fields["otherTime"]);
Assert.Equal(row.Timestamp, series.Rows[0].Timestamp);
Assert.Equal(time.ToIso8601(), series.Rows[0].Fields["otherTimeAsString"]);
}
private void WriteMetrics(W3CEvent record)
{
var dbRecord = new DynamicInfluxRow();
dbRecord.Fields.Add("time_taken", double.Parse(record.time_taken));
dbRecord.Tags.Add("cs_uri_stem", record.cs_uri_stem);
dbRecord.Tags.Add("cs_method", record.cs_method);
dbRecord.Timestamp = record.dateTime;
_dbManager.WriteMetrics("page-stat", dbRecord);
}
public async Task SendAsync(ParsedData parsedData)
{
var keyValues = parsedData.KeyValues;
_logger.LogInformation($"{Measurement}, {parsedData.DateTime}, {keyValues.Count()}");
// var point = PointData.Measurement(Measurement);
// if (parsedData.DateTime.HasValue)
// point = point.Timestamp(parsedData.DateTime.Value, WritePrecision.Ms);
// if (!string.IsNullOrEmpty(parsedData.DevEUI))
// point = point.Tag("DevEUI", parsedData.DevEUI);
// foreach (var keyValue in parsedData.KeyValues)
// {
// if (keyValue.Value is int valInt)
// point = point.Field(keyValue.Key, (long)valInt);
// else if (keyValue.Value is long valLong)
// point = point.Field(keyValue.Key, valLong);
// else if (keyValue.Value is ulong valUlong)
// point = point.Field(keyValue.Key, valUlong);
// else if (keyValue.Value is double valDouble)
// point = point.Field(keyValue.Key, valDouble);
// else if (keyValue.Value is float valFloat)
// point = point.Field(keyValue.Key, valFloat);
// else if (keyValue.Value is decimal valDecimal)
// point = point.Field(keyValue.Key, valDecimal);
// else if (keyValue.Value is bool valBool)
// point = point.Field(keyValue.Key, valBool);
// else if (keyValue.Value is string valString)
// point = point.Field(keyValue.Key, valString);
// }
// WriteApi.WritePoint(point);
// return Task.CompletedTask;
var info = new DynamicInfluxRow();
if (parsedData.DateTime.HasValue)
{
info.Timestamp = parsedData.DateTime.Value;
}
if (!string.IsNullOrEmpty(parsedData.DevEUI))
{
info.Tags.Add("DevEUI", parsedData.DevEUI);
}
foreach (var keyValue in parsedData.KeyValues)
{
info.Fields.Add(keyValue.Key, keyValue.Value);
}
_logger.LogInformation($"Tags: {string.Join(", ", info.Tags.Select(s => $"{s.Key}={s.Value}"))}");
_logger.LogInformation($"Fields: {string.Join(", ", info.Fields.Select(s => $"{s.Key}={s.Value}"))}");
await InfluxClient.WriteAsync(Database, Measurement, new DynamicInfluxRow[] { info });
}
public virtual IActionResult RegisterDevice([FromBody] DeviceInfo body)
{
var info = new DynamicInfluxRow();
info.Tags.Add("serialNumberTag", body.SerialNumber);
info.Fields.Add("serialNumber", body.SerialNumber);
info.Fields.Add("firmwareVersion", body.FirmwareVersion);
info.Timestamp = DateTime.UtcNow;
_influxClient.WriteAsync(_influxDbName, "devices", new DynamicInfluxRow[] { info }).Wait();
return(StatusCode(201));
}
public void WriteMetrics/*<TInfluxRow>*/ (string measurement, DynamicInfluxRow props) //, IEnumerable<TInfluxRow> rows)
//where TInfluxRow : new()
{
lock (_syncObject)
{
using (var client = new InfluxClient(new Uri(Settings.DbAddress)))
{
var infos = new [] { props };
client.WriteAsync(Settings.DbName, measurement, infos)
.GetAwaiter()
.GetResult();
}
}
}
public virtual IActionResult SendReadings([FromBody] List <Reading> body, [FromRoute][Required] string serialNumber)
{
var influxRowsToInsert = body.Select(reading => {
var row = new DynamicInfluxRow();
row.Tags.Add("serialNumberTag", serialNumber);
row.Tags.Add("healthStatusTag", reading.HealthStatus);
row.Fields.Add("airHumidity", reading.AirHumidity);
row.Fields.Add("healthStatus", reading.HealthStatus);
row.Fields.Add("carbonMonoxide", reading.CarbonMonoxide);
row.Fields.Add("temperature", reading.Temperature);
row.Timestamp = reading.DateTime;
return(row);
});
_influxClient.WriteAsync(_influxDbName, "readings", influxRowsToInsert).Wait();
return(StatusCode(201));
}
public void WriteMetricsValue(string measurement, object value)
{
lock (_syncObject)
{
var dbRecord = new DynamicInfluxRow();
dbRecord.Fields.Add("value", value);
dbRecord.Tags.Add("pool-name", Settings.PoolName);
dbRecord.Tags.Add("host", Environment.GetEnvironmentVariable("COMPUTERNAME"));
dbRecord.Tags.Add("os", Environment.GetEnvironmentVariable("OS"));
dbRecord.Timestamp = DateTime.UtcNow;
using (var client = new InfluxClient(new Uri(Settings.DbAddress)))
{
var infos = new DynamicInfluxRow[] { dbRecord };
client.WriteAsync(Settings.DbName, measurement, infos)
.GetAwaiter()
.GetResult();
}
}
}
static void Main(string[] args)
{
try
{
Console.Write("Server IP or hostname: ");
var host = Console.ReadLine();
Console.Write("Number of Pings: ");
var numberOfPings = Console.ReadLine();
var client = new InfluxClient(new Uri($"http://{host}:8086"), "RALSystem", "1234");
var IsRunningROw = new DynamicInfluxRow();
IsRunningROw.Fields.Add("MAC", "Hello");
IsRunningROw.Fields.Add("Line", "Test");
IsRunningROw.Tags.Add("Name", "Test");
IsRunningROw.Tags.Add("IsRunning", "true");
IsRunningROw.Timestamp = DateTime.Now;
var StatusRow = new DynamicInfluxRow();
StatusRow.Fields.Add("MAC", "Hello");
StatusRow.Fields.Add("Line", "Test");
StatusRow.Tags.Add("Name", "Test");
StatusRow.Tags.Add("IsCycling", "true");
StatusRow.Timestamp = DateTime.Now;
try
{
client.WriteAsync("TRMI_RAL_System_Dev", "IsRunning", new[] { IsRunningROw }).GetAwaiter().GetResult();
client.WriteAsync("TRMI_RAL_System_Dev", "Status", new[] { StatusRow }).GetAwaiter().GetResult();
var result = client.ReadAsync <DynamicInfluxRow>("TRMI_RAL_System_Dev", "SELECT * FROM \"IsRunning\"").GetAwaiter().GetResult();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
List <Task <InfluxPingResult> > tasks = new List <Task <InfluxPingResult> >();
Console.WriteLine("Waiting....");
Task.Delay(1000).Wait();
Console.WriteLine("Starting Pings");
Stopwatch sw = new Stopwatch();
async Task <InfluxPingResult> DoPing(int i)
{
Stopwatch swa = new Stopwatch();
swa.Start();
var result = await client.PingAsync();
swa.Stop();
Console.WriteLine($"[{i}] {sw.Elapsed}");
return(result);
}
sw.Start();
for (int i = 0; i < Convert.ToInt32(numberOfPings); i++)
{
tasks.Add(DoPing(i));
}
Task.WaitAll(tasks.ToArray());
sw.Stop();
Console.WriteLine($"Total Time was {sw.Elapsed}");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.WriteLine($"Press Any Key to Exit");
Console.ReadKey();
}
