예제 #1
0
        private async Task <Organization> EnsureOrganizationCreated(InfluxDBClient influxDBClient)
        {
            var orgs = await influxDBClient.GetOrganizationsApi().FindOrganizationsAsync();

            var organization = orgs.FirstOrDefault(r => r.Name == _options.Organization);

            if (organization == null)
            {
                organization = await influxDBClient.GetOrganizationsApi().CreateOrganizationAsync(_options.Organization);
            }

            return(organization);
        }
        protected async Task <Organization> FindMyOrg()
        {
            var org = (await Client.GetOrganizationsApi().FindOrganizationsAsync(100))
                      .FirstOrDefault(organization => organization.Name.Equals("my-org"));

            Assert.IsNotNull(org, "my-org is required for integration tests");

            return(org);
        }
예제 #3
0
        private async Task RecreateBucket()
        {
            var bucketApi    = InfluxClient.GetBucketsApi();
            var orgApi       = InfluxClient.GetOrganizationsApi();
            var organization = (await orgApi.FindOrganizationsAsync()).First();
            var bucket       = await bucketApi.FindBucketByNameAsync(Configuration.InfluxBucket);

            if (bucket?.Name == Configuration.InfluxBucket)
            {
                await bucketApi.DeleteBucketAsync(bucket);

                //var deleteApi = client.GetDeleteApi();
                //await deleteApi.Delete(DateTime.MinValue, DateTime.MaxValue, "true",
                //    bucket, organization);
            }
            await bucketApi.CreateBucketAsync(Configuration.InfluxBucket, organization);
        }
예제 #4
0
        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();
        }
예제 #5
0
 protected async Task <Organization> FindMyOrg()
 {
     return((await Client.GetOrganizationsApi().FindOrganizationsAsync())
            .First(organization => organization.Name.Equals("my-org")));
 }
        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());
        }