Ejemplo n.º 1
0
        public void RegisterMetrics(ICollectorRegistry registry)
        {
            MetricFactory metricFactory = Prometheus.Metrics.WithCustomRegistry(registry);
            var           counter       = metricFactory.CreateCounter("gc_collect_count", "GC collection count",
                                                                      _lableNames.Union(new[] { "generation" }).ToArray());

            for (var number = 0; number <= GC.MaxGeneration; number++)
            {
                _collectionCounts.Add(counter.Labels(_labelValues.Union(new[] { number.ToString() }).ToArray()));
            }

            _startTime = metricFactory
                         .CreateGauge("start_time", "Start time of the process since unix epoch in seconds", _lableNames)
                         .Labels(_labelValues);
            _cpuTotal = metricFactory.CreateCounter("cpu_seconds_total",
                                                    "Total user and system CPU time spent in seconds", _lableNames).Labels(_labelValues);
            _virtualMemorySize = metricFactory.CreateGauge("virtual_bytes", "Process virtual memory size", _lableNames).Labels(_labelValues);
            _workingSet        = metricFactory.CreateGauge("working_set", "Process working set", _lableNames).Labels(_labelValues);
            _privateMemorySize = metricFactory.CreateGauge("private_bytes", "Process private memory size", _lableNames).Labels(_labelValues);
            _openHandles       = metricFactory.CreateGauge("open_handles", "Number of open handles", _lableNames).Labels(_labelValues);
            _numThreads        = metricFactory.CreateGauge("num_threads", "Total number of threads", _lableNames).Labels(_labelValues);
            _pid         = metricFactory.CreateGauge("processid", "Process ID", _lableNames).Labels(_labelValues);
            _totalMemory = metricFactory.CreateGauge("totalmemory", "Total known allocated memory", _lableNames).Labels(_labelValues);
            _startTime.Set((_process.StartTime.ToUniversalTime() - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc))
                           .TotalSeconds);
            _pid.Set(_process.Id);
        }
Ejemplo n.º 2
0
        public static GaugeVisitor Collect(this IGauge gauge)
        {
            var visitor = new GaugeVisitor();

            gauge.Visit(visitor);
            return(visitor);
        }
Ejemplo n.º 3
0
        protected NodeBase(ICluster owner, IPEndPoint endpoint, IFailurePolicy failurePolicy, ISocket socket)
        {
            this.owner         = owner;
            this.endpoint      = endpoint;
            this.socket        = socket;
            this.failurePolicy = failurePolicy;
            this.name          = endpoint.ToString();

            failLock   = new Object();
            writeQueue = new ConcurrentQueue <Data>();
            readQueue  = new Queue <Data>();

            mustReconnect = true;
            IsAlive       = true;

            counterEnqueuePerSec = Metrics.Meter("node write enqueue/sec", endpoint.ToString(), Interval.Seconds);
            counterDequeuePerSec = Metrics.Meter("node write dequeue/sec", endpoint.ToString(), Interval.Seconds);
            counterOpReadPerSec  = Metrics.Meter("node op read/sec", endpoint.ToString(), Interval.Seconds);
            counterWriteQueue    = Metrics.Counter("write queue length", endpoint.ToString());
            counterReadQueue     = Metrics.Counter("read queue length", endpoint.ToString());

            counterWritePerSec = Metrics.Meter("node write/sec", endpoint.ToString(), Interval.Seconds);
            counterErrorPerSec = Metrics.Meter("node in error/sec", endpoint.ToString(), Interval.Seconds);
            counterItemCount   = Metrics.Counter("commands", endpoint.ToString());
            gaugeSendSpeed     = Metrics.Gauge("send speed", endpoint.ToString());
        }
Ejemplo n.º 4
0
        public void Setup()
        {
            _gauge      = OurMetricFactory.CreateGauge("testgauge", HelpText);
            _gaugeInt64 = OurMetricFactory.CreateGaugeInt64("testgaugeInt64", HelpText);

            _theirGauge = TheirMetricFactory.CreateGauge("testgauge", HelpText);
        }
Ejemplo n.º 5
0
        public ResourceMiddleware(
            RequestDelegate next,
            ILogger <ResourceMiddleware> logger,
            IOptions <ResourceMetricsOptions> ResourceMetricsOptionsAccessor,
            IMetrics metrics)
        {
            _logger  = logger;
            _next    = next;
            _metrics = metrics;

            // Setup the metrics.
            _maxWorkingSet              = _metrics.Provider.Gauge.Instance(ResourceMetricsRegistry.MaxWorkingSetGauge);
            _pagedMemorySize64          = _metrics.Provider.Gauge.Instance(ResourceMetricsRegistry.PagedMemorySize64Gauge);
            _nonpagedSystemMemorySize64 = _metrics.Provider.Gauge.Instance(ResourceMetricsRegistry.NonpagedSystemMemorySize64Gauge);
            _peakPagedMemorySize64      = _metrics.Provider.Gauge.Instance(ResourceMetricsRegistry.PeakPagedMemorySize64Gauge);
            _peakWorkingSet64           = _metrics.Provider.Gauge.Instance(ResourceMetricsRegistry.PeakWorkingSet64Gauge);
            _totalProcessorTime         = _metrics.Provider.Gauge.Instance(ResourceMetricsRegistry.TotalProcessorTimeGauge);
            _userProcessorTime          = _metrics.Provider.Gauge.Instance(ResourceMetricsRegistry.UserProcessorTimeGauge);
            _virtualMemorySize64        = _metrics.Provider.Gauge.Instance(ResourceMetricsRegistry.VirtualMemorySize64Gauge);
            _workingSet64      = _metrics.Provider.Gauge.Instance(ResourceMetricsRegistry.WorkingSet64Gauge);
            _threadsCount      = _metrics.Provider.Gauge.Instance(ResourceMetricsRegistry.ThreadsCountGauge);
            _gcCollectionCount = _metrics.Provider.Gauge.Instance(ResourceMetricsRegistry.GCCollectionCountGauge);
            _gcTotalMemory     = _metrics.Provider.Gauge.Instance(ResourceMetricsRegistry.GCTotalMemoryGauge);
            _lastGCTime        = _metrics.Provider.Gauge.Instance(ResourceMetricsRegistry.LastGCTimeGauge);
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Sets the value of the gauge to the current Unix timestamp in seconds.
        /// </summary>
        public static void SetToCurrentTime(this IGauge gauge)
        {
            var unixTicks = DateTime.UtcNow.Ticks - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).Ticks;

            // Convert to double first to ensure that we can report fractional seconds.
            gauge.Set((double)unixTicks / TimeSpan.TicksPerSecond);
        }
Ejemplo n.º 7
0
		protected NodeBase(ICluster owner, IPEndPoint endpoint, IFailurePolicy failurePolicy, ISocket socket)
		{
			this.owner = owner;
			this.endpoint = endpoint;
			this.socket = socket;
			this.failurePolicy = failurePolicy;
			this.name = endpoint.ToString();

			failLock = new Object();
			writeQueue = new ConcurrentQueue<Data>();
			readQueue = new Queue<Data>();

			mustReconnect = true;
			IsAlive = true;

			counterEnqueuePerSec = Metrics.Meter("node write enqueue/sec", endpoint.ToString(), Interval.Seconds);
			counterDequeuePerSec = Metrics.Meter("node write dequeue/sec", endpoint.ToString(), Interval.Seconds);
			counterOpReadPerSec = Metrics.Meter("node op read/sec", endpoint.ToString(), Interval.Seconds);
			counterWriteQueue = Metrics.Counter("write queue length", endpoint.ToString());
			counterReadQueue = Metrics.Counter("read queue length", endpoint.ToString());

			counterWritePerSec = Metrics.Meter("node write/sec", endpoint.ToString(), Interval.Seconds);
			counterErrorPerSec = Metrics.Meter("node in error/sec", endpoint.ToString(), Interval.Seconds);
			counterItemCount = Metrics.Counter("commands", endpoint.ToString());
			gaugeSendSpeed = Metrics.Gauge("send speed", endpoint.ToString());
		}
Ejemplo n.º 8
0
 public AppMetricsGauge(IMetrics metrics, IGauge gauge, string bucket, string name)
 {
     _metrics = metrics;
     _gauge   = gauge;
     Context  = bucket;
     Name     = name;
 }
Ejemplo n.º 9
0
        private const long UnixEpochSeconds = UnixEpochTicks / TimeSpan.TicksPerSecond;                                     // 62,135,596,800

        /// <summary>
        /// Sets the value of the gauge to the current UTC time as a Unix timestamp in seconds.
        /// Value does not include any elapsed leap seconds because Unix timestamps do not include leap seconds.
        /// </summary>
        public static void SetToCurrentTimeUtc(this IGauge gauge)
        {
            // This gets us sub-millisecond precision, which is better than ToUnixTimeMilliseconds().
            var ticksSinceUnixEpoch   = DateTimeOffset.UtcNow.Ticks - UnixEpochSeconds * TimeSpan.TicksPerSecond;
            var secondsSinceUnixEpoch = ticksSinceUnixEpoch / (double)TimeSpan.TicksPerSecond;

            gauge.Set(secondsSinceUnixEpoch);
        }
        public static T TrackInProgress <T>(this IGauge gauge, Func <T> fun)
        {
            gauge.Increment();
            var ret = fun.Invoke();

            gauge.Decrement();

            return(ret);
        }
Ejemplo n.º 11
0
    // Start is called before the first frame update
    void Start()
    {
        image.color = color;
        RectTransform rect = GetComponent <RectTransform>();

        rect.pivot     = pivot;
        rect.sizeDelta = new Vector2(volume, 10);
        gauge          = new Gauge("HP", 100, 0, 200);
        GetComponent <Slider>().value = gauge.NormalizedValue;
    }
Ejemplo n.º 12
0
        /// <inheritdoc />
        public IGauge CreateGauge(string name, string help, bool delayPublish, string[] labels)
        {
            var gauges = new IGauge[_providers.Count];

            for (var index = 0; index < gauges.Length; index++)
            {
                gauges[index] = _providers.ElementAt(index).Value.CreateGauge(name, help, delayPublish, labels);
            }

            return(gauges.Length == 1 ? gauges[0] : new Gauge(gauges, name, help, labels));
        }
        public void GaugeValueIsIncreased()
        {
            var tags = new Dictionary <string, string> {
                { "foo", "bar" }
            };

            NoopMetricsFactory metricsFactory = NoopMetricsFactory.Instance;
            IGauge             gauge          = metricsFactory.CreateGauge("thegauge", tags);

            gauge.Update(1);
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Tracks the number of in-progress operations taking place.
        ///
        /// Calling this increments the gauge. Disposing of the returned instance decrements it again.
        /// </summary>
        /// <remarks>
        /// It is safe to track the sum of multiple concurrent in-progress operations with the same gauge.
        /// </remarks>
        public static IDisposable TrackInProgress(this IGauge gauge)
        {
            if (gauge == null)
            {
                throw new ArgumentNullException(nameof(gauge));
            }

            gauge.Inc();

            return(new InProgressTracker(gauge));
        }
Ejemplo n.º 15
0
        public GaugeTests()
        {
            noLabel = new DefaultGauge("noLabel", new GaugeOptions
            {
                Help = "help noLabels",
            });

            labeled = new DefaultGauge("labeled", new GaugeOptions
            {
                Help       = "help labeled",
                LabelNames = Labeled.SingleLabels
            });
        }
Ejemplo n.º 16
0
        public void Configure(IMetricsRoot metrics)
        {
            Chunks = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context = Context,
                Name = "Chunks",
                MeasurementUnit = Unit.None
            });

            RenderedChunks = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context = Context,
                Name = "Rendered Chunks",
                MeasurementUnit = Unit.None
            });

            ChunkUpdatesQueued = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context = Context,
                Name = "Chunk Updates (Queued)",
                MeasurementUnit = Unit.None
            });

            ChunkUpdateActive = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context = Context,
                Name = "Chunk Updates (Active)",
                MeasurementUnit = Unit.None
            });

            Entities = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context = Context,
                Name = "Entities",
                MeasurementUnit = Unit.None
            });

            RenderedEntities = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context = Context,
                Name = "Rendered Entities",
                MeasurementUnit = Unit.None
            });

            RenderedVertices = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context = Context,
                Name = "Rendered Vertices",
                MeasurementUnit = Unit.None
            });
        }
Ejemplo n.º 17
0
        private void AddOverallScoreLabel(IGauge gauge, int score)
        {
            var scoreLabel = ((CircularGauge)gauge).AddLabel();

            scoreLabel.AppearanceText.TextBrush = new SolidBrushObject
            {
                Color = System.Drawing.Color.White
            };
            scoreLabel.Text = score >= 0
                                        ? $"{score.ToString()}%"
                                        : "N/A";
            scoreLabel.AppearanceText.Font = new Font("Open Sans", 34, FontStyle.Bold);
            scoreLabel.Size = new SizeF(300F, 300F);
        }
        public void GaugeValueIsIncreased()
        {
            var tags = new Dictionary <string, string> {
                { "foo", "bar" }
            };

            InMemoryMetricsFactory inMemoryMetricsFactory = new InMemoryMetricsFactory();
            IGauge gauge = inMemoryMetricsFactory.CreateGauge("thegauge", tags);

            Assert.Equal(0, inMemoryMetricsFactory.GetGauge("thegauge", tags));

            gauge.Update(1);

            Assert.Equal(1, inMemoryMetricsFactory.GetGauge("thegauge", tags));
        }
Ejemplo n.º 19
0
        private void AddCategoryScoreLabels(IGauge gauge, int score, bool isWeekly)
        {
            var scoreLabel = ((CircularGauge)gauge).AddLabel();

            scoreLabel.Text = score >= 0
                                        ? $"{score.ToString()}%"
                                        : "N/A";
            scoreLabel.AppearanceText.Font = new Font("Open Sans", 32, FontStyle.Bold);
            scoreLabel.Size = new SizeF(300F, 300F);

            var infoLabel = ((CircularGauge)gauge).AddLabel();

            infoLabel.Text = isWeekly ? "\n\nWeekly" : "\n\nQuarterly";
            infoLabel.AppearanceText.Font = new Font("Open Sans", 17, FontStyle.Bold);
            infoLabel.Size = new SizeF(300F, 300F);
        }
Ejemplo n.º 20
0
        /// <summary>
        /// Initializes a new instance of the <see cref="FixedLimit" /> class.
        /// </summary>
        /// <param name="limit">The limit.</param>
        /// <param name="metricsRegistry">The metrics registry.</param>
        public FixedLimit(int limit, IMetricsRegistry metricsRegistry)
        {
            this.limit = limit;

            var maxOperations = metricsRegistry.CreateGauge(
                Metrics.MaxOperations.Name,
                Metrics.MaxOperations.Description,
                new[] { Metrics.Labels.LimitTypeName });

            maxOperations.WithLabels(new[] { Metrics.Labels.LimitTypeValue }).Set(limit);

            this.currentOperations = metricsRegistry.CreateGauge(
                Metrics.CurrentOperations.Name,
                Metrics.CurrentOperations.Description,
                new[] { Metrics.Labels.LimitTypeName })
                                     .WithLabels(new[] { Metrics.Labels.LimitTypeValue });
        }
Ejemplo n.º 21
0
        public void Configure(IMetricsRoot metrics)
        {
            ResourceCounter = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context         = Context,
                Name            = "Resources",
                MeasurementUnit = Unit.Items,
                // Tags = new MetricTags()
            });

            Memory = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context         = Context,
                Name            = "Memory Usage",
                MeasurementUnit = Unit.Bytes,
                // Tags = new MetricTags()
            });
        }
        public void Configure(IMetricsRoot metrics)
        {
            ProcessPhysicalMemoryGauge = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context         = ContextName,
                Name            = "Environment Working Set",
                MeasurementUnit = Unit.Bytes
            });

            ProcessTotalProcessorTime = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context         = ContextName,
                Name            = "CPU Time (total)",
                MeasurementUnit = Unit.None
            });

            ProcessUserProcessorTime = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context         = ContextName,
                Name            = "CPU Time (user)",
                MeasurementUnit = Unit.None
            });

            CpuUsage = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context         = ContextName,
                Name            = "CPU Usage",
                MeasurementUnit = Unit.Percent
            });

            Threads = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context         = ContextName,
                Name            = "Threads",
                MeasurementUnit = Unit.Threads
            });

            CompletionPorts = metrics.Provider.Gauge.Instance(new GaugeOptions()
            {
                Context         = ContextName,
                Name            = "Completion Ports",
                MeasurementUnit = Unit.None
            });
        }
Ejemplo n.º 23
0
        /// <summary>
        /// Initializes a new instance of the type
        /// </summary>
        /// <param name="dependencyService">A service that can be used to retrieve dependencies that were injected</param>
        /// <param name="loggerFactory">A factory that can be used to create loggers</param>
        /// <param name="metricFactory">A factory that can be used to create metrics</param>
        /// <param name="webSocketConfiguration">The configuration of the web socket</param>
        /// <param name="bufferPool">The buffer pool used to retreive arrays</param>
        public WebSocketHandler(IDependencyService dependencyService, IWebSocketConfiguration webSocketConfiguration, IMetricFactory metricFactory, ILoggerFactory loggerFactory, IBufferPool bufferPool)
        {
            Guard.NotNull(nameof(metricFactory), metricFactory);
            Guard.NotNull(nameof(loggerFactory), loggerFactory);
            Guard.NotNull(nameof(bufferPool), bufferPool);
            Guard.NotNull(nameof(webSocketConfiguration), webSocketConfiguration);

            WebSocketConfiguration = webSocketConfiguration;
            BufferPool             = bufferPool;
            SessionId     = Guid.NewGuid();
            MetricFactory = metricFactory;
            Logger        = loggerFactory.CreateLogger($"Session Handler: {SessionId:N}");

            DependencyService = dependencyService;

            _errorCounter        = metricFactory.CreateCounter("WebSocket error counter", "Tracks the number of errors that have occurred since the start of the service", false, new string[0]);
            _serviceSessionGauge = metricFactory.CreateGauge("WebSocket sessions in progress", "Tracks the number of sessions underway", false, new string[0]);
            _sessionTimes        = metricFactory.CreateSummary("WebSocket session iteration times", "Tracks the time taken to execute an iteration in the session", 10, false, new string[0]);
            _receiveTimes        = metricFactory.CreateSummary("WebSocket message receive time", "Tracks the time taken to receive a message", 10, false, new string[0]);
        }
Ejemplo n.º 24
0
        public ModuleLicensingService(ILogger <ModuleLicensingService> logger, ILicenseValidator licenseValidator,
                                      IModuleMetrics moduleMetrics)
        {
            this.logger           = logger;
            this.licenseValidator = licenseValidator;
            moduleInstanceName    = Environment.GetEnvironmentVariable("IOTEDGE_MODULEID");
            if (string.IsNullOrWhiteSpace(moduleInstanceName))
            {
                throw new InvalidOperationException($"IOTEDGE_MODULEID environment variable is null or blank.");
            }
            hostName = Environment.GetEnvironmentVariable("IOTEDGE_DEVICEID");
            if (string.IsNullOrWhiteSpace(hostName))
            {
                throw new InvalidOperationException($"IOTEDGE_DEVICEID environment variable is null or blank.");
            }
            hubName = Environment.GetEnvironmentVariable("IOTEDGE_IOTHUBHOSTNAME");
            if (string.IsNullOrWhiteSpace(hubName))
            {
                throw new InvalidOperationException($"IOTEDGE_IOTHUBHOSTNAME environment variable is null or blank.");
            }
            logger.LogInformation("Beginning periodic license validation for module {Module} on host {Host} for IoT Hub {Hub}",
                                  moduleInstanceName, hostName, hubName);

            licenseKey = Environment.GetEnvironmentVariable("MODULE_LICENSE_KEY");
            if (string.IsNullOrWhiteSpace(licenseKey))
            {
                throw new InvalidOperationException($"MODULE_LICENSE_KEY environment variable is null or blank.");
            }
            logger.LogInformation("License key '{LicenseKey}' loaded from environment variable", licenseKey);

            licenseCheckInterval        = TimeSpan.FromHours(1);
            maxConsecutiveCheckFailures = 36;
            serviceStopping             = new CancellationTokenSource();

            consecutiveLicenseCheckFailures = moduleMetrics.CreateGauge(
                "edgelicensing_consecutive_failures", "Consecutive edge licensing check failures");
            remainingConsecutiveLicenseCheckFailures = moduleMetrics.CreateGauge(
                "edgelicensing_remaining_consecutive_failures", "Remaining consecutive edge licensing check failures");
        }
Ejemplo n.º 25
0
 /// <summary>
 /// Enables you to easily report elapsed seconds in the value of a gauge.
 /// You need to manually call .ApplyDuration() on the returned instance to update the value of the gauge.
 /// </summary>
 public static Gauge.Timer StartTimer(this IGauge gauge)
 {
     return(new Gauge.Timer(gauge));
 }
 public BackgroundTaskQueue(IGauge queuedItemsGauge)
 {
     _queuedItemsGauge = queuedItemsGauge ?? throw new ArgumentNullException(nameof(queuedItemsGauge));
 }
Ejemplo n.º 27
0
 public IGauge Gauge(IGauge parent, string instance)
 {
     return(new DefaultGauge(parent, instance));
 }
Ejemplo n.º 28
0
 protected override void Visit(IGauge gauge)
 {
     sb.AppendFormat("{0} ({1}/{2})", gauge.Value, gauge.Min, gauge.Max);
 }
Ejemplo n.º 29
0
 protected abstract void Visit(IGauge gauge);
Ejemplo n.º 30
0
		protected override void Visit(IGauge gauge)
		{
			sb.AppendFormat("{0} ({1}/{2})", gauge.Value, gauge.Min, gauge.Max);
		}
Ejemplo n.º 31
0
 public InProgressTracker(IGauge gauge)
 {
     _gauge = gauge;
 }
Ejemplo n.º 32
0
			public IGauge Gauge(IGauge parent, string instance)
			{
				return new DefaultGauge(parent, instance);
			}
Ejemplo n.º 33
0
		protected abstract void Visit(IGauge gauge);
Ejemplo n.º 34
0
 public Timer(IGauge gauge)
 {
     _gauge     = gauge;
     _stopwatch = System.Diagnostics.Stopwatch.StartNew();
 }