Example #1
0
        Task OnTick()
        {
            try
            {
                Queue <PointData> batch;
                lock (_queueLock)
                {
                    if (_queue.Count == 0)
                    {
                        return(Task.Delay(0));
                    }

                    batch  = _queue;
                    _queue = new Queue <PointData>();
                }

                _parent.Emit(batch.ToArray());
            }
            catch (Exception ex)
            {
                CollectorLog.ReportError("Failed to emit metrics batch", ex);
            }
            finally
            {
                lock (_stateLock)
                {
                    if (!_unloading)
                    {
                        _timer.Start(_interval);
                    }
                }
            }

            return(Task.Delay(0));
        }
        public void ListenerCanUnregister()
        {
            var invocationCount = 0;

            using (CollectorLog.RegisterErrorHandler((message, exception) => invocationCount++))
            {
                CollectorLog.ReportError("", null);
            }
            CollectorLog.ReportError("", null);
            Assert.Equal(1, invocationCount);
        }
Example #3
0
 public void Write(string measurement, IReadOnlyDictionary <string, object> fields, IReadOnlyDictionary <string, string> tags = null, DateTime?timestamp = null)
 {
     try
     {
         var point = new PointData(measurement, fields, tags, timestamp ?? DateTime.UtcNow);
         Emit(new[] { point });
     }
     catch (Exception ex)
     {
         CollectorLog.ReportError("Failed to write point", ex);
     }
 }
        public void SingleListenerGetsInvoked()
        {
            var          invocationCount = 0;
            Exception    dummyException  = new Exception("Bang!");
            const string errorMessage    = "Bad things";

            CollectorLog.RegisterErrorHandler((message, exception) =>
            {
                Assert.Equal(errorMessage, message);
                Assert.Equal(dummyException, exception);
                invocationCount++;
            });

            CollectorLog.ReportError(errorMessage, dummyException);
            Assert.Equal(1, invocationCount);
        }
        public void Emit(PointData[] points)
        {
            var payload = new LineProtocolPayload();

            foreach (var point in points)
            {
                payload.Add(new LineProtocolPoint(point.Measurement, point.Fields, point.Tags, point.UtcTimestamp));
            }

            var influxResult = _client.WriteAsync(payload).Result;

            if (!influxResult.Success)
            {
                CollectorLog.ReportError(influxResult.ErrorMessage, null);
            }
        }
Example #6
0
        async void OnTick()
        {
            try
            {
                lock (_stateLock)
                {
                    if (_disposed)
                    {
                        return;
                    }

                    // There's a little bit of raciness here, but it's needed to support the
                    // current API, which allows the tick handler to reenter and set the next interval.

                    if (_running)
                    {
                        Monitor.Wait(_stateLock);

                        if (_disposed)
                        {
                            return;
                        }
                    }

                    _running = true;
                }

                if (!_cancel.Token.IsCancellationRequested)
                {
                    await _onTick(_cancel.Token);
                }
            }
            catch (OperationCanceledException tcx)
            {
                CollectorLog.ReportError("The timer was canceled during invocation", tcx);
            }
            finally
            {
                lock (_stateLock)
                {
                    _running = false;
                    Monitor.PulseAll(_stateLock);
                }
            }
        }
        Task OnTick()
        {
            try
            {
                Queue <PointData> batch;
                lock (_queueLock)
                {
                    if (_queue.Count == 0)
                    {
                        return(Task.Delay(0));
                    }

                    batch  = _queue;
                    _queue = new Queue <PointData>();
                }

                if (_maxBatchSize == null || batch.Count <= _maxBatchSize.Value)
                {
                    _parent.Emit(batch.ToArray());
                }
                else
                {
                    foreach (var chunk in batch.Batch(_maxBatchSize.Value))
                    {
                        _parent.Emit(chunk.ToArray());
                    }
                }
            }
            catch (Exception ex)
            {
                CollectorLog.ReportError("Failed to emit metrics batch", ex);
            }
            finally
            {
                lock (_stateLock)
                {
                    if (!_unloading)
                    {
                        _timer.Start(_interval);
                    }
                }
            }

            return(Task.Delay(0));
        }
        public void EnsureListenerExceptionPropagates()
        {
            CollectorLog.RegisterErrorHandler((message, exception) =>
            {
                throw new Exception("");
            });

            var threw = false;

            try
            {
                CollectorLog.ReportError("", null);
            }
            catch
            {
                threw = true;
            }
            Assert.True(threw, "Excpected an exception thrown by the error handler to propagate to the caller");
        }
 public void CanReportWithoutListeners()
 {
     CollectorLog.ReportError("", null);
 }