public MetricsHttpListener(string listenerUriPrefix, MetricsRegistry registry, Func<HealthStatus> healthStatus) { this.httpListener = new HttpListener(); this.httpListener.Prefixes.Add(listenerUriPrefix); this.registry = registry; this.healthStatus = healthStatus; }
internal RpcMetrics(Server server, Configuration conf) { string port = server.GetListenerAddress().Port.ToString(); name = "RpcActivityForPort" + port; this.server = server; registry = new MetricsRegistry("rpc").Tag("port", "RPC port", port); int[] intervals = conf.GetInts(CommonConfigurationKeys.RpcMetricsPercentilesIntervalsKey ); rpcQuantileEnable = (intervals.Length > 0) && conf.GetBoolean(CommonConfigurationKeys .RpcMetricsQuantileEnable, CommonConfigurationKeys.RpcMetricsQuantileEnableDefault ); if (rpcQuantileEnable) { rpcQueueTimeMillisQuantiles = new MutableQuantiles[intervals.Length]; rpcProcessingTimeMillisQuantiles = new MutableQuantiles[intervals.Length]; for (int i = 0; i < intervals.Length; i++) { int interval = intervals[i]; rpcQueueTimeMillisQuantiles[i] = registry.NewQuantiles("rpcQueueTime" + interval + "s", "rpc queue time in milli second", "ops", "latency", interval); rpcProcessingTimeMillisQuantiles[i] = registry.NewQuantiles("rpcProcessingTime" + interval + "s", "rpc processing time in milli second", "ops", "latency", interval ); } } Log.Debug("Initialized " + registry); }
protected BaseMetricsContext(string context, MetricsRegistry registry, MetricsBuilder metricsBuilder, Func <DateTime> timestampProvider) { this.context = context; this.registry = registry; this.metricsBuilder = metricsBuilder; this.DataProvider = new DefaultDataProvider(this.context, timestampProvider, this.registry.DataProvider, () => this.childContexts.Values.Select(c => c.DataProvider)); }
public static string GetAsHumanReadable(MetricsRegistry registry, Func <HealthStatus> healthStatus) { var report = new StringReporter(); report.RunReport(registry, healthStatus); return(report.Result); }
public ModuleConfig(MetricsRegistry registry, Func <HealthStatus> healthStatus, Action <INancyModule> moduleConfig, string metricsPath) { this.Registry = registry; this.HealthStatus = healthStatus; this.ModuleConfigAction = moduleConfig; this.ModulePath = metricsPath; }
public override void Run() { try { var format = new SimpleDateFormat("s", _locale); var dateTime = DateTimeEx.GetInstance(_timeZone, _clock.Time()); var dateTimeString = format.Format(dateTime); _writer.Write(dateTimeString); _writer.Write(' '); for (var i = 0; i < CONSOLE_WIDTH - dateTimeString.Length - 1; i++) { _writer.Write('='); } _writer.WriteLine(); foreach (var entry in MetricsRegistry.GroupedMetrics(_predicate)) { _writer.Write(entry.Key); _writer.WriteLine(':'); foreach (var subEntry in entry.Value) { _writer.Write(" "); _writer.Write(subEntry.Key.Name); _writer.WriteLine(':'); subEntry.Value.ProcessWith(this, subEntry.Key, _writer); _writer.WriteLine(); } _writer.WriteLine(); } _writer.WriteLine(); _writer.Flush(); } catch (Exception e) { _writer.WriteLine(e.StackTrace); } }
internal RpcDetailedMetrics(int port) { name = "RpcDetailedActivityForPort" + port; registry = new MetricsRegistry("rpcdetailed").Tag("port", "RPC port", port.ToString ()); Log.Debug(registry.Info()); }
/// <summary> /// Configure NancyFx integration /// </summary> /// <param name="config">Chainable configuration object.</param> /// <param name="registry">Custom metrics registry.</param> /// <param name="healthStatus">Custom health checks status</param> /// <param name="nancyConfig">Action to configure NancyFx integration.</param> /// <returns>Chainable configuration object.</returns> public static MetricsConfig WithNancy(this MetricsConfig config, MetricsRegistry registry, Func <HealthStatus> healthStatus, Action <NancyMetricsConfig> nancyConfig) { CurrentConfig = new NancyMetricsConfig(registry, healthStatus); nancyConfig(CurrentConfig); return(config); }
public ModuleConfig(MetricsRegistry registry, Func<HealthStatus> healthStatus, Action<INancyModule> moduleConfig, string metricsPath) { this.Registry = registry; this.HealthStatus = healthStatus; this.ModuleConfigAction = moduleConfig; this.ModulePath = metricsPath; }
public static void RegisterSystemCounters(MetricsRegistry registry) { registry.Register("System AvailableRAM", () => new PerformanceCounterGauge("Memory", "Available MBytes"), Unit.Custom("Mb")); registry.Register("System CPU Usage", () => new PerformanceCounterGauge("Processor", "% Processor Time", TotalInstance), Unit.Custom("%")); registry.Register("System Disk Writes/sec", () => new DerivedGauge(new PerformanceCounterGauge("PhysicalDisk", "Disk Reads/sec", TotalInstance), f => f / 1024), Unit.Custom("kb/s")); registry.Register("System Disk Reads/sec", () => new DerivedGauge(new PerformanceCounterGauge("PhysicalDisk", "Disk Writes/sec", TotalInstance), f => f / 1024), Unit.Custom("kb/s")); }
public static void RegisterSystemCounters(MetricsRegistry registry) { registry.Register("System AvailableRAM", () => new PerformanceCounterGauge("Memory", "Available MBytes"), Unit.Custom("Mb")); registry.Register("System CPU Usage", () => new PerformanceCounterGauge("Processor", "% Processor Time", TotalInstance), Unit.Custom("%")); registry.Register("System Disk Writes/sec", () => new DerivedGauge(new PerformanceCounterGauge("PhysicalDisk", "Disk Reads/sec", TotalInstance), f => f / 1024), Unit.Custom("kb/s")); registry.Register("System Disk Reads/sec", () => new DerivedGauge(new PerformanceCounterGauge("PhysicalDisk", "Disk Writes/sec", TotalInstance), f => f / 1024), Unit.Custom("kb/s")); }
/// <summary> /// Configure NancyFx integration /// </summary> /// <param name="config">Chainable configuration object.</param> /// <param name="registry">Custom metrics registry.</param> /// <param name="healthStatus">Custom health checks status</param> /// <param name="nancyConfig">Action to configure NancyFx integration.</param> /// <returns>Chainable configuration object.</returns> public static MetricsConfig WithNancy(this MetricsConfig config, MetricsRegistry registry, Func<HealthStatus> healthStatus, Action<NancyMetricsConfig> nancyConfig) { CurrentConfig = new NancyMetricsConfig(registry, healthStatus); nancyConfig(CurrentConfig); return config; }
public void CompletelyDisableMetrics() { if (this.isDisabled) { return; } this.isDisabled = true; var oldRegistry = this.registry; this.registry = new NullMetricsRegistry(); oldRegistry.ClearAllMetrics(); using (oldRegistry as IDisposable) { } ForAllChildContexts(c => c.Advanced.CompletelyDisableMetrics()); if (this.ContextShuttingDown != null) { this.ContextShuttingDown(this, EventArgs.Empty); } if (this.ContextDisabled != null) { this.ContextDisabled(this, EventArgs.Empty); } }
public BaseMetricsContext(string context, MetricsRegistry registry, MetricsBuilder metricsBuilder) { this.context = context; this.registry = registry; this.metricsBuilder = metricsBuilder; this.DataProvider = new DefaultDataProvider(this.context, this.registry.DataProvider, () => this.childContexts.Values.Select(c => c.DataProvider)); }
public void Add(string contextName, MetricsRegistry registry) { if (!this.cntxtRegistry.ContainsKey(contextName)) { this.cntxtRegistry.Add(contextName, registry); } }
public MetricsHttpListener(string listenerUriPrefix, MetricsRegistry registry, Func <HealthStatus> healthStatus) { this.httpListener = new HttpListener(); this.httpListener.Prefixes.Add(listenerUriPrefix); this.registry = registry; this.healthStatus = healthStatus; }
/// <summary> /// Creates a new <seealso cref="ConsoleReporter" /> for a given metrics registry. /// </summary> /// <param name="metricsRegistry">the metrics registry</param> /// <param name="writer">the <seealso cref="TextWriter" /> to which output will be written</param> /// <param name="predicate"> /// the <seealso cref="MetricPredicate" /> used to determine whether a metric will be output /// </param> public ConsoleReporter( MetricsRegistry metricsRegistry, TextWriter writer, MetricPredicate predicate) : this(metricsRegistry, writer, predicate, Clock.DefaultClock, TimeZoneInfo.Utc) { }
public async Task <ActionResult <object> > GetFeatureLookup([FromQuery] FeatureRequestModel request) { _metrics.Measure.Counter.Increment(MetricsRegistry.GetFeatureLookupCounter); if (string.IsNullOrEmpty(request?.Key) || !Enum.IsDefined(typeof(ShapeProperties), request.Key)) { return(BadRequest()); } var validate = _shapeServiceResolver(ShapeProperties.BoroughBoundaries.ToString()).GetFeatureLookup(request.X, request.Y); if (validate == null) { return(NoContent()); } var results = _shapeServiceResolver(request.Key).GetFeatureLookup(request.X, request.Y); if (results == null) { return(NotFound()); } _metrics.Measure.Counter.Increment(MetricsRegistry.GetFeatureTypeLookupCounter(request.Key)); return(await Task.FromResult(Ok(results))); }
public ScheduledReporter(string name, Func<Reporter> reporter, MetricsRegistry registry, Func<HealthStatus> healthStatus, TimeSpan interval, Scheduler scheduler) { this.reporter = reporter; this.registry = registry; this.healthStatus = healthStatus; this.interval = interval; this.scheduler = scheduler; }
public ScheduledReporter(string name, Func <Reporter> reporter, MetricsRegistry registry, Func <HealthStatus> healthStatus, TimeSpan interval, Scheduler scheduler) { this.reporter = reporter; this.registry = registry; this.healthStatus = healthStatus; this.interval = interval; this.scheduler = scheduler; }
private static void AddMetrics(MetricsRegistry registry) { var name = "Test"; registry.Gauge(name, () => 0.0, Unit.Calls); registry.Counter(name, Unit.Calls); registry.Meter(name, Unit.Calls, TimeUnit.Seconds); registry.Histogram(name, Unit.Calls, SamplingType.FavourRecent); registry.Timer(name, Unit.Calls, SamplingType.FavourRecent, TimeUnit.Seconds, TimeUnit.Milliseconds); }
internal RetryCacheMetrics(RetryCache retryCache) { name = "RetryCache." + retryCache.GetCacheName(); registry = new MetricsRegistry(name); if (Log.IsDebugEnabled()) { Log.Debug("Initialized " + registry); } }
/// <summary> /// Creates a new <seealso cref="ConsoleReporter" /> for a given metrics registry. /// </summary> /// <param name="metricsRegistry">the metrics registry</param> /// <param name="writer">the <seealso cref="TextWriter" /> to which output will be written</param> /// <param name="predicate"> /// the <seealso cref="MetricPredicate" /> used to determine whether a metric will be output /// </param> /// <param name="clock">the <seealso cref="Clock" /> used to print time</param> /// <param name="timeZone">the <seealso cref="TimeZone" /> used to print time</param> public ConsoleReporter( MetricsRegistry metricsRegistry, TextWriter writer, MetricPredicate predicate, Clock clock, TimeZoneInfo timeZone) : this(metricsRegistry, writer, predicate, clock, timeZone, CultureInfo.CurrentCulture) { }
private static void AddMetrics(MetricsRegistry registry) { var name = "Test"; registry.Gauge(name, () => 0.0, Unit.Calls); registry.Counter(name, Unit.Calls); registry.Meter(name, Unit.Calls, TimeUnit.Seconds); registry.Histogram(name, Unit.Calls, SamplingType.FavourRecent); registry.Timer(name, Unit.Calls, SamplingType.FavourRecent, TimeUnit.Seconds, TimeUnit.Milliseconds); }
private static void RegisterMetrics() { registry = new MetricsRegistry(RecordInfo); registry.Tag(RecordInfo, "ResourceManager"); MetricsSystem ms = DefaultMetricsSystem.Instance(); if (ms != null) { ms.Register("ClusterMetrics", "Metrics for the Yarn Cluster", Instance); } }
private FSOpDurations() { registry = new MetricsRegistry(RecordInfo); registry.Tag(RecordInfo, "FSOpDurations"); MetricsSystem ms = DefaultMetricsSystem.Instance(); if (ms != null) { ms.Register(RecordInfo.Name(), RecordInfo.Description(), this); } }
/// <summary> /// Enables the console reporter for the given metrics registry, and causes it to print to STDOUT /// with the specified period and unrestricted output. /// </summary> /// <param name="metricsRegistry">the metrics registry</param> /// <param name="period">the period between successive outputs</param> /// <param name="unit">the time unit of {@code period}</param> public static void Enable( MetricsRegistry metricsRegistry, long period, TimeUnit unit) { var reporter = new ConsoleReporter( metricsRegistry, Console.Out, AnyMetricPredicate.INSTANCE); reporter.Start(period, unit); }
private static void WriteTextMetrics(HttpListenerContext context, MetricsRegistry registry, Func <HealthStatus> healthStatus) { context.Response.ContentType = "text/plain"; context.Response.StatusCode = 200; context.Response.StatusDescription = "OK"; using (var writer = new StreamWriter(context.Response.OutputStream)) { writer.Write(RegistrySerializer.GetAsHumanReadable(registry, healthStatus)); } context.Response.Close(); }
public static string GetAsJson(MetricsRegistry registry) { return new JsonFormatter() .AddTimestamp(Clock.Default) .AddObject(registry.Gauges) .AddObject(registry.Counters) .AddObject(registry.Meters) .AddObject(registry.Histograms) .AddObject(registry.Timers) .GetJson(); }
public static string GetAsJson(MetricsRegistry registry) { return(new JsonFormatter() .AddTimestamp(Clock.Default) .AddObject(registry.Gauges) .AddObject(registry.Counters) .AddObject(registry.Meters) .AddObject(registry.Histograms) .AddObject(registry.Timers) .GetJson()); }
public static void RegisterCLRAppCounters(MetricsRegistry registry) { var app = Process.GetCurrentProcess().ProcessName; registry.Register("Mb in all Heaps", () => new DerivedGauge(new PerformanceCounterGauge(Memory, "# Bytes in all Heaps", app), v => v / (1024 * 1024)), Unit.Custom("Mb")); registry.Register("Time in GC", () => new PerformanceCounterGauge(Memory, "% Time in GC", app), Unit.Custom("%")); registry.Register("Total Exceptions", () => new PerformanceCounterGauge(Exceptions, "# of Exceps Thrown", app), Unit.Custom("Exceptions")); registry.Register("Exceptions Thrown / Sec", () => new PerformanceCounterGauge(Exceptions, "# of Exceps Thrown / Sec", app), Unit.Custom("Exceptions/s")); registry.Register("Logical Threads", () => new PerformanceCounterGauge(LocksAndThreads, "# of current logical Threads", app), Unit.Custom("Threads")); registry.Register("Physical Threads", () => new PerformanceCounterGauge(LocksAndThreads, "# of current physical Threads", app), Unit.Custom("Threads")); registry.Register("Contention Rate / Sec", () => new PerformanceCounterGauge(LocksAndThreads, "Contention Rate / Sec", app), Unit.Custom("Attempts/s")); registry.Register("Queue Length / sec", () => new PerformanceCounterGauge(LocksAndThreads, "Queue Length / sec", app), Unit.Custom("Threads/s")); }
public static async Task <IForwarder> Create(IConfiguration configuration, string sectionName = null) { var options = configuration.GetSection(sectionName ?? DefaultConfigurationSectionName).Get <ServiceAgentOptions>(); var logger = LoggerBuilder.Initialize(configuration); var metricsRegistry = MetricsRegistry.CreateRoot(configuration); var forwarders = await BuildServiceForwarders(logger, metricsRegistry, options); return(new ServiceForwarderHost(metricsRegistry, forwarders)); }
protected internal QueueMetrics(MetricsSystem ms, string queueName, Queue parent, bool enableUserMetrics, Configuration conf) { registry = new MetricsRegistry(RecordInfo); this.queueName = queueName; this.parent = parent != null?parent.GetMetrics() : null; this.users = enableUserMetrics ? new Dictionary <string, Org.Apache.Hadoop.Yarn.Server.Resourcemanager.Scheduler.QueueMetrics >() : null; metricsSystem = ms; this.conf = conf; runningTime = BuildBuckets(conf); }
public static void RegisterCLRAppCounters(MetricsRegistry registry) { var app = Process.GetCurrentProcess().ProcessName; registry.Register("Mb in all Heaps", () => new DerivedGauge(new PerformanceCounterGauge(Memory, "# Bytes in all Heaps", app), v => v / (1024 * 1024)), Unit.Custom("Mb")); registry.Register("Time in GC", () => new PerformanceCounterGauge(Memory, "% Time in GC", app), Unit.Custom("%")); registry.Register("Total Exceptions", () => new PerformanceCounterGauge(Exceptions, "# of Exceps Thrown", app), Unit.Custom("Exceptions")); registry.Register("Exceptions Thrown / Sec", () => new PerformanceCounterGauge(Exceptions, "# of Exceps Thrown / Sec", app), Unit.Custom("Exceptions/s")); registry.Register("Logical Threads", () => new PerformanceCounterGauge(LocksAndThreads, "# of current logical Threads", app), Unit.Custom("Threads")); registry.Register("Physical Threads", () => new PerformanceCounterGauge(LocksAndThreads, "# of current physical Threads", app), Unit.Custom("Threads")); registry.Register("Contention Rate / Sec", () => new PerformanceCounterGauge(LocksAndThreads, "Contention Rate / Sec", app), Unit.Custom("Attempts/s")); registry.Register("Queue Length / sec", () => new PerformanceCounterGauge(LocksAndThreads, "Queue Length / sec", app), Unit.Custom("Threads/s")); }
public static async Task <ServiceForwarder> Create(ILogger logger, MetricsRegistry metricsRegistry, ServiceNamespaceOptions serviceNamespace, string entityPath) { var forwarderIdx = Interlocked.Increment(ref _idx); var endpointVia = new UriBuilder("sb", serviceNamespace.ServiceNamespace, -1, entityPath).Uri; var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(serviceNamespace.AccessRuleName, serviceNamespace.AccessRuleKey); var relayListener = new HybridConnectionListener(endpointVia, tokenProvider); var metadata = await RelayMetadata.Parse(logger, relayListener); return(new ServiceForwarder(logger, metricsRegistry, forwarderIdx, relayListener, metadata, entityPath)); }
public static ClientForwarderHost Create(IConfiguration configuration) { var options = configuration.GetSection("PortBridge").Get <ClientAgentOptions>(); var logger = LoggerBuilder.Initialize(configuration); logger.Information("Building Client Forwarders"); var metricsRegistry = MetricsRegistry.CreateRoot(configuration); var forwarders = BuildPortForwarders(logger, metricsRegistry, options); return(new ClientForwarderHost(metricsRegistry, forwarders)); }
public ClientTcpForwarder(ILogger logger, MetricsRegistry registry, ServiceNamespaceOptions serviceNamespace, int fromPort, PortMappingOptions portMappings) { _log = logger.ForContext(GetType()); _firewallRules = new FirewallRules(portMappings); _fromPort = fromPort; _bindTo = portMappings.BindToAddress; var metrics = new TunnelMetrics(registry, new MetricTags( new [] { "entityPath", "fromPort" }, new [] { portMappings.EntityPath, fromPort.ToString() })); _relayFactory = new RelayTunnelFactory(logger, metrics, serviceNamespace, portMappings); _log.Information("TCP Forwarder for port {port} initialized", fromPort); }
private ServiceForwarder(ILogger logger, MetricsRegistry registry, int forwarderIdx, HybridConnectionListener listener, RelayMetadata metadata, string entityPath) { _log = logger.ForContext(GetType()); _forwarderIdx = forwarderIdx; _relayListener = listener; _metadata = metadata; var tags = new MetricTags(nameof(entityPath), entityPath); var metrics = new TunnelMetrics(registry, tags); _tunnelFactory = new RelayTunnelFactory(logger, metrics); }
/// <summary> /// Configure the Metrics library to use a custom MetricsRegistry. /// </summary> /// <remarks> /// You must call Metric.Config.WithRegistry before any other Metric call. /// </remarks> /// <param name="registry">The custom registry to use for registering metrics.</param> /// <returns>Chainable configuration object.</returns> public MetricsConfig WithRegistry(MetricsRegistry registry) { if (this.isDisabled) { return this; } if (this.registry.IsValueCreated) { throw new InvalidOperationException("Metrics registry has already been created. You must call Metric.Config.WithRegistry before any other Metric call."); } this.registry = new Lazy<MetricsRegistry>(() => registry); return this; }
public static object GetForSerialization(MetricsRegistry registry) { return new { Gauges = registry.Gauges.ToDictionary(g => g.Name, g => g.Value), Counters = registry.Counters.ToDictionary(c => c.Name, c => c.Value), Meters = registry.Meters.ToDictionary(m => m.Name, m => m.Value.Scale(m.RateUnit)), Histograms = registry.Histograms.ToDictionary(h => h.Name, h => h.Value), Timers = registry.Timers.ToDictionary(t => t.Name, t => t.Value.Scale(t.RateUnit, t.DurationUnit)), Units = new { Gauges = registry.Gauges.ToDictionary(g => g.Name, g => g.Unit.Name), Counters = registry.Counters.ToDictionary(c => c.Name, c => c.Unit.Name), Meters = registry.Meters.ToDictionary(m => m.Name, m => string.Format("{0}/{1}", m.Unit.Name, m.RateUnit.Unit())), Histograms = registry.Histograms.ToDictionary(h => h.Name, h => h.Unit.Name), Timers = registry.Timers.ToDictionary(t => t.Name, t => new { Rate = string.Format("{0}/{1}", t.Unit.Name, t.RateUnit.Unit()), Duration = t.DurationUnit.Unit() }) } }; }
public MetricsEndpointMiddleware(OwinMetricsEndpointConfig endpointConfig, MetricsRegistry registry, Func<HealthStatus> healthStatus) { this.endpointConfig = endpointConfig; this.registry = registry; this.healthStatus = healthStatus; }
public OwinRequestMetricsConfig( Action<object> middlewareRegistration, MetricsRegistry metricsRegistry) { this.middlewareRegistration = middlewareRegistration; this.metricsRegistry = metricsRegistry; this.MetricsPrefix = "Owin"; }
public NancyGlobalMetrics(MetricsRegistry repository) { this.registry = repository; this.MetricsPrefix = "NancyFx"; }
public static void RegisterCLRGlobalCounters(MetricsRegistry registry) { registry.Register(".NET Mb in all Heaps", () => new DerivedGauge(new PerformanceCounterGauge(Memory, "# Bytes in all Heaps", GlobalInstance), v => v / (1024 * 1024)), Unit.Custom("Mb")); registry.Register(".NET Time in GC", () => new PerformanceCounterGauge(Memory, "% Time in GC", GlobalInstance), Unit.Custom("%")); }
public ErrorMeterMiddleware(MetricsRegistry registry, string metricName) { this.errorMeter = registry.Meter(metricName, Unit.Errors, TimeUnit.Seconds); }
public NancyMetricsConfig(MetricsRegistry metricsRegistry, Func<HealthStatus> healthStatus) { this.metricsRegistry = metricsRegistry; this.healthStatus = healthStatus; }
public ActiveRequestCounterMiddleware(MetricsRegistry registry, string metricName) { this.activeRequests = registry.Counter(metricName, Unit.Custom("ActiveRequests")); }
public TimerForEachRequestMiddleware(MetricsRegistry registry, string metricPrefix) { this.registry = registry; this.metricPrefix = metricPrefix; }
public static string GetAsHumanReadable(MetricsRegistry registry, Func<HealthStatus> healthStatus) { var report = new StringReporter(); report.RunReport(registry, healthStatus); return report.Result; }
private static void WriteJsonMetrics(HttpListenerContext context, MetricsRegistry registry) { context.Response.Headers.Add("Access-Control-Allow-Origin", "*"); context.Response.Headers.Add("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept"); context.Response.ContentType = "application/json"; context.Response.StatusCode = 200; context.Response.StatusDescription = "OK"; var json = RegistrySerializer.GetAsJson(registry); using (var writer = new StreamWriter(context.Response.OutputStream)) { writer.Write(json); } context.Response.Close(); }
public OwinMetricsConfig(IAppBuilder app, MetricsRegistry metricsRegistry) { this.app = app; this.metricsRegistry = metricsRegistry; this.MetricsPrefix = "Owin"; }
/// <summary> /// Configure NancyFx integration /// </summary> /// <param name="config">Chainable configuration object.</param> /// <param name="registry">Custom metrics registry.</param> /// <param name="nancyConfig">Action to configure NancyFx integration.</param> /// <returns>Chainable configuration object.</returns> public static MetricsConfig WithNancy(this MetricsConfig config, MetricsRegistry registry, Action<NancyMetricsConfig> nancyConfig) { return config.WithNancy(registry, config.HealthStatus, nancyConfig); }
public PostAndPutRequestSizeHistogramMiddleware(MetricsRegistry registry, string metricName) { this.histogram = registry.Histogram(metricName, Unit.Bytes, SamplingType.FavourRecent); }
public MetricsReports(MetricsRegistry metricsRegistry, Func<HealthStatus> healthStatus) { this.metricsRegistry = metricsRegistry; this.healthStatus = healthStatus; }
public RequestTimerMiddleware(MetricsRegistry registry, string metricName) { this.requestTimer = registry.Timer(metricName, Unit.Requests, SamplingType.FavourRecent, TimeUnit.Seconds, TimeUnit.Milliseconds); }
private static Task GetAsHumanReadable(IDictionary<string, object> environment, MetricsRegistry registry, Func<HealthStatus> healthStatus) { var report = new StringReporter(); report.RunReport(registry, healthStatus); return WriteResponse(environment, report.Result, "text/plain"); }
private static Task GetJsonContent(IDictionary<string, object> environment, MetricsRegistry registry) { var content = RegistrySerializer.GetAsJson(registry); return WriteResponse(environment, content, "application/json"); }
public static void Configure(MetricsRegistry registry, Func<HealthStatus> healthStatus, Action<INancyModule> moduleConfig, string metricsPath) { MetricsModule.Config = new ModuleConfig(registry, healthStatus, moduleConfig, metricsPath); }
public OwinMetricsConfig(Action<object> middlewareRegistration, MetricsRegistry registry, Func<HealthStatus> healthStatus) { this.middlewareRegistration = middlewareRegistration; this.registry = registry; this.healthStatus = healthStatus; }
private static void WriteTextMetrics(HttpListenerContext context, MetricsRegistry registry, Func<HealthStatus> healthStatus) { context.Response.ContentType = "text/plain"; context.Response.StatusCode = 200; context.Response.StatusDescription = "OK"; using (var writer = new StreamWriter(context.Response.OutputStream)) { writer.Write(RegistrySerializer.GetAsHumanReadable(registry, healthStatus)); } context.Response.Close(); }