private static void Main(string[] args) { var fileName = args[0]; var metricServer = new MetricServer(null, new MetricServerOptions { Port = 58433, Host = Debugger.IsAttached ? "127.0.0.1" : "*" }); try { metricServer.Start(); Observable.Create <string>(async(o, cancel) => { using var reader = File.OpenText(fileName); while (!cancel.IsCancellationRequested) { var line = reader.ReadLine(); if (reader.BaseStream.Length < reader.BaseStream.Position) { reader.BaseStream.Seek(0, SeekOrigin.Begin); } if (line != null) { Console.WriteLine(); Console.WriteLine(line); o.OnNext(line); } else { Console.Write("."); await Task.Delay(1000, cancel); } } o.OnCompleted(); }) .Select(JObject.Parse) .Select(j => new Reading(j)) .SelectMany(r => r.Metrics.Select(m => new Metric(r.Unique + m.Key, m.Key, m.Value, r.Labels))) .Subscribe(m => { if (!metrics.TryGetValue(m.Unique, out var gauge)) { gauge = Metrics.CreateGauge("rtl433_" + m.Name, "", true, "model", "channel", "id", "unique"); } gauge.WithLabels(m.LabelValues) .Set(m.Value, DateTimeOffset.Now); }); var mre = new ManualResetEvent(false); Console.CancelKeyPress += (sender, eventArgs) => mre.Set(); mre.WaitOne(); } finally { metricServer.Stop(); } }
private static IManage CreateManager(MetricConfig config, SensorCollector collector) { double seconds = config.Interval.TotalSeconds; if (config.Graphite != null) { Logger.Info( $"Graphite host: {config.Graphite.Host} port: {config.Graphite.Port} interval: {seconds} tags: {config.Graphite.Tags}"); var writer = new GraphiteWriter(config.Graphite.Host, config.Graphite.Port, Environment.MachineName, config.Graphite.Tags); return(new MetricTimer(config.Interval, collector, writer)); } else if (config.Prometheus != null) { Logger.Info($"Prometheus port: {config.Prometheus.Port}"); var prometheusCollection = new PrometheusCollection(collector, Environment.MachineName); var server = new MetricServer(config.Prometheus.Host, config.Prometheus.Port); return(new PrometheusServer(server, collector, prometheusCollection)); } else { Logger.Info($"Influxdb address: {config.Influx.Address} db: {config.Influx.Db}"); var writer = new InfluxWriter(config.Influx, Environment.MachineName); return(new MetricTimer(config.Interval, collector, writer)); } }
public static async Task Main(string[] args) { var server = new MetricServer(hostname: "localhost", port: 5001, useHttps: false); server.Start(); await CreateHostBuilder(args).Build().RunAsync(); }
static void Main(string[] args) { if (!File.Exists(Config.CollectorConfigPath)) { WriteLine("No collector config path configured. Set $env:COLLECTOR_CONFIG_PATH"); return; } var logger = new LoggerConfiguration() .ReadFrom.AppSettings() .CreateLogger(); var json = File.ReadAllText(Config.CollectorConfigPath); var collectorConfig = JsonConvert.DeserializeObject <CollectorConfiguration>(json); if (!collectorConfig.PerformanceCounterCollectors.Any()) { logger.Information("No collectors configured. Config file path: {Path}", Config.CollectorConfigPath); return; } DefaultCollectorRegistry.Instance.Clear(); DefaultCollectorRegistry.Instance.RegisterOnDemandCollectors( new ConfiguredPerformanceCounterCollector(collectorConfig, Config.RecordCollections, logger)); var server = new MetricServer(Config.MetricsPort); server.Start(); logger.Information("Metrics server listening on port: {Port}", Config.MetricsPort); _ResetEvent.WaitOne(); }
public MetricsService(IOptions <MetricsOptions> options, ILogger <MetricsService> logger) : base(logger) { var hostname = options.Value.Hostname; if (hostname == "0.0.0.0" || string.IsNullOrEmpty(hostname)) { hostname = "+"; } options.Value.Hostname = hostname; if (string.IsNullOrEmpty(options.Value.Endpoint)) { options.Value.Endpoint = "metrics/"; } if (options.Value.Port == default) { options.Value.Port = 8080; } this.m_options = options.Value; this.m_server = new MetricServer(hostname, options.Value.Port, options.Value.Endpoint); this.m_logger = logger; }
private static IManage CreateManager(MetricConfig config, SensorCollector collector) { var hostname = config.LookupName(); double seconds = config.Interval.TotalSeconds; if (config.Graphite != null) { Logger.Info( $"Graphite host: {config.Graphite.Host} port: {config.Graphite.Port} interval: {seconds} tags: {config.Graphite.Tags}"); var writer = new GraphiteWriter(config.Graphite.Host, config.Graphite.Port, hostname, config.Graphite.Tags); return(new MetricTimer(config.Interval, collector, writer)); } else if (config.Prometheus != null) { Logger.Info($"Prometheus port: {config.Prometheus.Port}"); var prometheusCollection = new PrometheusCollection(collector, hostname, Metrics.DefaultRegistry); var server = new MetricServer(config.Prometheus.Host, config.Prometheus.Port); return(new PrometheusServer(server, collector)); } else if (config.Timescale != null) { var writer = new TimescaleWriter(config.Timescale.Connection, config.Timescale.SetupTable, hostname); return(new MetricTimer(config.Interval, collector, writer)); } else { Logger.Info($"Influxdb address: {config.Influx.Address} db: {config.Influx.Db}"); var writer = new InfluxWriter(config.Influx, hostname); return(new MetricTimer(config.Interval, collector, writer)); } }
private Task StartMetricsServer() { Thread.Sleep(TimeSpan.FromSeconds(ConfigData.Data.Bot.BotWarmupTimeInSeconds)); if (this._client == null || this._client.CurrentUser == null) { this._logger.Log("Delaying metric server startup"); Thread.Sleep(TimeSpan.FromSeconds(ConfigData.Data.Bot.BotWarmupTimeInSeconds)); } this._logger.Log("Starting metrics server"); var prometheusPort = 4444; if (!this._client.CurrentUser.Id.Equals(Constants.BotProductionId)) { this._logger.Log("Prometheus port selected is non-production"); prometheusPort = 4422; } this._logger.Log($"Prometheus starting on port {prometheusPort}"); var server = new MetricServer("localhost", prometheusPort); server.Start(); this._logger.Log($"Prometheus running on localhost:{prometheusPort}/metrics"); return(Task.CompletedTask); }
// Use this for initialization private void Start() { if (!Application.isEditor) { metricServer = new MetricServer(port: 1234); metricServer.Start(); } resetCounter = Metrics.CreateCounter("reset", "How many times the worker has been reset"); herbivorousInUseGauge = Metrics.CreateGauge("herbivorousInUse", "Current total amount of herbivorous agents"); carnivorousInUseGauge = Metrics.CreateGauge("carnivorousInUse", "Current total amount of carnivorous agents"); herbivorousSpecieLifeExpectancyGauge = Metrics.CreateGauge("herbivorousSpecieLifeExpectancy", "Life expectancy of herbivorous specie"); carnivorousSpecieLifeExpectancyGauge = Metrics.CreateGauge("carnivorousSpecieLifeExpectancy", "Life expectancy of carnivorous specie"); evolAcademy = FindObjectOfType <EvolAcademy>(); workerObjects = new List <Utils.Tuple <Utils.Tuple <int, int>, GameObject> >(); // Instanciate pools to spawn / release objects herbivorousPool = new Pool(ItemsToSpawn.Find(go => go.name.Equals("HerbivorousAgent")), false); carnivorousPool = new Pool(ItemsToSpawn.Find(go => go.name.Equals("CarnivorousAgent")), false); herbPool = new Pool(ItemsToSpawn.Find(go => go.name.Equals("Herb")), false); godPool = new Pool(ItemsToSpawn.Find(go => go.name.Equals("GodAgent")), false); SpawnWorkers(); }
static async Task Main() { Console.CancelKeyPress += OnExit; Console.Title = "Lhi.HsbDemo.Orders.EmailNotificationHandler"; // Start Metrics for Prometheus //var metricServer = new MetricServer(port: 3031); var prometheus = AppSettings.Prometheus; var metricServer = new MetricServer(prometheus, 3031); metricServer.Start(); var endpointConfiguration = new EndpointConfiguration("Lhi.NsbDemo.Orders.EmailNotificationHandler"); // Configure Stackify StackifyLib.Config.ApiKey = AppSettings.StackifyApiKey; StackifyLib.Config.AppName = AppSettings.StackifyApiName; StackifyLib.Config.Environment = AppSettings.StackifyEnvironment; // configure Serilog var tracingLog = new LoggerConfiguration() .WriteTo.Elasticsearch(new ElasticsearchSinkOptions(new Uri(AppSettings.ElasticSearchUrl)) { AutoRegisterTemplate = true, AutoRegisterTemplateVersion = AutoRegisterTemplateVersion.ESv6, IndexFormat = "nsbdemo-{0:yyyy.MM.dd}", InlineFields = true }) .WriteTo.Stackify() .MinimumLevel.Information() .CreateLogger(); var serilogFactory = LogManager.Use <SerilogFactory>(); serilogFactory.WithLogger(tracingLog); endpointConfiguration.EnableFeature <TracingLog>(); endpointConfiguration.SerilogTracingTarget(tracingLog); var transport = endpointConfiguration.UseTransport <RabbitMQTransport>(); transport.UseConventionalRoutingTopology(); var rabbitmqConnectionString = AppSettings.RabbitMQUrl; transport.ConnectionString(rabbitmqConnectionString); //endpointConfiguration.UseSerialization<NewtonsoftSerializer>(); endpointConfiguration.EnableInstallers(); endpointConfiguration.Conventions() //.DefiningEventsAs(c => c.Namespace != null && c.Name.EndsWith("Event")) .DefiningCommandsAs(c => c.Namespace != null && c.Name.EndsWith("Command")); var endpointInstance = Endpoint.Start(endpointConfiguration) .GetAwaiter().GetResult(); // Wait until the message arrives. closingEvent.WaitOne(); await endpointInstance.Stop() .ConfigureAwait(false); }
public async Task RunAsync(CancellationToken cancel) { _log.Info($"Configured to probe Docker on {DockerUrl}"); _tracker = new DockerTracker(new Uri(DockerUrl)); Metrics.DefaultRegistry.AddBeforeCollectCallback(UpdateMetricsAsync); var server = new MetricServer(9417); #if DEBUG _log.Info($"Open http://localhost:9417/metrics to initiate a probe."); #endif server.Start(); while (!cancel.IsCancellationRequested) { try { await Task.Delay(-1, cancel); } catch (TaskCanceledException) when(cancel.IsCancellationRequested) { // Totally normal - we are exiting. break; } } await server.StopAsync(); }
/// <summary> /// Constructor /// </summary> /// <param name="pveHostsAndPortHA"></param> /// <param name="pveUsername"></param> /// <param name="pvePassword"></param> /// <param name="pveApiToken"></param> /// <param name="loggerFactory"></param> /// <param name="host"></param> /// <param name="port"></param> /// <param name="url"></param> /// <param name="prefix"></param> /// <param name="exportNodeDiskInfo"></param> public PrometheusExporter(string pveHostsAndPortHA, string pveUsername, string pvePassword, string pveApiToken, ILoggerFactory loggerFactory, string host, int port, string url, string prefix, bool exportNodeDiskInfo) : this(Prometheus.Metrics.NewCustomRegistry(), prefix, exportNodeDiskInfo) { _registry.AddBeforeCollectCallback(async() => { var stopwatch = new Stopwatch(); stopwatch.Start(); var client = ClientHelper.GetClientFromHA(pveHostsAndPortHA); client.LoggerFactory = loggerFactory; if (string.IsNullOrWhiteSpace(pveApiToken)) { await client.Login(pveUsername, pvePassword); } await Collect(client); stopwatch.Stop(); }); _server = new MetricServer(host, port, url, _registry); }
public static void Main(string[] args) { CreateHostBuilder(args).Build().Run(); var server = new MetricServer(hostname: "localhost", port: 5000); server.Start(); }
public MetricsService(IRocksDbContext context, IConfigManager config) { _context = context; var rpcConfig = config.GetConfig <RpcConfig>("rpc") ?? RpcConfig.Default; _server = new MetricServer(hostname: "*", port: rpcConfig.MetricsPort); }
/// <summary> /// Run module host /// </summary> public async Task <int> RunAsync() { // Wait until the module unloads while (true) { using (var hostScope = ConfigureContainer(_config)) { _reset = new TaskCompletionSource <bool>(); var module = hostScope.Resolve <IModuleHost>(); var events = hostScope.Resolve <IEventEmitter>(); var workerSupervisor = hostScope.Resolve <IWorkerSupervisor>(); var logger = hostScope.Resolve <ILogger>(); var moduleConfig = hostScope.Resolve <IModuleConfig>(); var identity = hostScope.Resolve <IIdentity>(); ISessionManager sessionManager = null; var server = new MetricServer(port: kPublisherPrometheusPort); try { var version = GetType().Assembly.GetReleaseVersion().ToString(); logger.Information("Starting module OpcPublisher version {version}.", version); logger.Information("Initiating prometheus at port {0}/metrics", kPublisherPrometheusPort); server.StartWhenEnabled(moduleConfig, logger); CheckDeprecatedParams(logger); // Start module await module.StartAsync(IdentityType.Publisher, SiteId, "OpcPublisher", version, this); kPublisherModuleStart.WithLabels( identity.DeviceId ?? "", identity.ModuleId ?? "").Inc(); await workerSupervisor.StartAsync(); sessionManager = hostScope.Resolve <ISessionManager>(); OnRunning?.Invoke(this, true); await Task.WhenAny(_reset.Task, _exit.Task); if (_exit.Task.IsCompleted) { logger.Information("Module exits..."); return(_exitCode); } _reset = new TaskCompletionSource <bool>(); logger.Information("Module reset..."); } catch (Exception ex) { logger.Error(ex, "Error during module execution - restarting!"); } finally { await workerSupervisor.StopAsync(); await sessionManager?.StopAsync(); await module.StopAsync(); OnRunning?.Invoke(this, false); kPublisherModuleStart.WithLabels( identity.DeviceId ?? "", identity.ModuleId ?? "").Set(0); server.StopWhenEnabled(moduleConfig, logger); } } } }
private static void StartMetricServer() { var metricsPort = Config.Current.GetValue <int>("Metrics:Port"); var server = new MetricServer(metricsPort); server.Start(); Console.WriteLine($"Metrics server listening on port ${metricsPort}"); }
/// <summary> /// Stop metric server if enabled /// </summary> /// <returns></returns> public static void StopWhenEnabled(this MetricServer server, IModuleConfig config, Serilog.ILogger logger) { if (config.EnableMetrics) { server.Stop();; logger.Information("Stopped prometheus metric server"); } }
private void StartMetricServer() { var metricsPort = 80; var server = new MetricServer(metricsPort); server.Start(); Console.WriteLine($"Metrics server listening on port {metricsPort}"); }
private static void StartMetricServer(IConfiguration config) { var metricsPort = config.GetValue <int>("Metrics:Port"); var server = new MetricServer(metricsPort); server.Start(); Log.Information("Metrics server listening on port: {metricsPort}", metricsPort); }
public static void StartMetrics(string instanceName, int bindPort, string bindHost = null) { _name = instanceName; _srv = bindHost != null ? new MetricServer(bindHost, bindPort) : new MetricServer(bindPort); _srv.Start(); }
public static void Main(string[] args) { var server = new MetricServer(port: 9000); server.Start(); CreateHostBuilder(args).Build().Run(); }
/// <inheritdoc/> public void Start() { const string path = "metrics/"; _logger.Information($"Starting metric server on port {_configuration.Port} on path '{path}'"); _server = new MetricServer(hostname: "*", port: _configuration.Port, url: path, registry: _collectorRegistry); _server.Start(); }
/// <summary> /// Initialises Prometheus /// </summary> /// <param name="game">TShock game</param> public TShockPrometheus(Main game) : base(game) { Metrics.SuppressDefaultMetrics(); server = new MetricServer(port: 9763); // TODO: read config collectors.Add(new Collectors.ConnectedPlayers(this)); collectors.Add(new Collectors.DotNetStats(this)); collectors.Add(new Collectors.TicksPerSecond(this)); }
static void Main(string[] args) { Menu menu = new Menu(); var server = new MetricServer(hostname: "localhost", port: 1234); server.Start(); TickTock.Inc(); menu.MainMenu(); }
private static void ConfigurePrometheusListener(IConfigurationRoot configuration) { var port = int.Parse(configuration["PrometheusPort"]); Log.Information("Starting Prometheus listener at {uri}", $"+:{port}"); var server = new MetricServer(hostname: "+", port: port); server.Start(); }
public ProcessorMetricServer(ILogger logger) { _logger = logger; _metricServer = new MetricServer(port: 9201); _counter = Metrics.CreateCounter("processor_messagecounter", "counting accumulative all messages sent to redis and calculate messages processed by a second"); _metricServer.Start(); _logger.Debug($"[Processor at {DateTime.Now}] Metric server started"); }
public ExporterService(ILogger <ExporterService> logger, IOptions <ServerOptions> serverOptions) { _logger = logger; _server = new MetricServer(serverOptions.Value.Hostname, serverOptions.Value.Port, serverOptions.Value.Path); _listeningUrl = new UriBuilder("http", serverOptions.Value.Hostname, serverOptions.Value.Port, serverOptions.Value.Path).ToString(); }
public void Start_Stop_IsRunning() { const int port = 9000; var metricServer = new MetricServer(port); metricServer.Start(); Assert.True(metricServer.IsRunning); metricServer.Stop(); Assert.False(metricServer.IsRunning); }
public static void Main(string[] args) { var envConfig = new ConfigurationBuilder().AddEnvironmentVariables().Build(); var metricServer = new MetricServer(port: int.Parse(envConfig["config:metricport"])); metricServer.Start(); CreateHostBuilder(args).Build().Run(); }
protected void Application_Start(object sender, EventArgs e) { var metricsEnabled = bool.Parse(ConfigurationManager.AppSettings["Computation:Metrics:Enabled"]); if (metricsEnabled) { _Server = new MetricServer(50505); _Server.Start(); } }
static async Task Main(string[] args) { Task.Run(() => ConsumeMessages("my-client-1", "my-consumer-group-1", "my-topic-1", 100)); Task.Run(() => ConsumeMessages("my-client-2", "my-consumer-group-2", "my-topic-1", 110)); var metricServer = new MetricServer(port: 7075); metricServer.Start(); Console.ReadLine(); }