func newMetrics(r prometheus.Registerer) *metrics { m := &metrics{} m.gcDuration = prometheus.NewSummary(prometheus.SummaryOpts{ Name: "alertmanager_silences_gc_duration_seconds", Help: "Duration of the last silence garbage collection cycle.", }) m.snapshotDuration = prometheus.NewSummary(prometheus.SummaryOpts{ Name: "alertmanager_silences_snapshot_duration_seconds", Help: "Duration of the last silence snapshot.", }) m.queriesTotal = prometheus.NewCounter(prometheus.CounterOpts{ Name: "alertmanager_silences_queries_total", Help: "How many silence queries were received.", }) m.queryErrorsTotal = prometheus.NewCounter(prometheus.CounterOpts{ Name: "alertmanager_silences_query_errors_total", Help: "How many silence received queries did not succeed.", }) m.queryDuration = prometheus.NewHistogram(prometheus.HistogramOpts{ Name: "alertmanager_silences_query_duration_seconds", Help: "Duration of silence query evaluation.", }) if r != nil { r.MustRegister( m.gcDuration, m.snapshotDuration, m.queriesTotal, m.queryErrorsTotal, m.queryDuration, ) } return m }
func newMetrics(r prometheus.Registerer) *metrics { m := &metrics{} m.gcDuration = prometheus.NewSummary(prometheus.SummaryOpts{ Name: "alertmanager_nflog_gc_duration_seconds", Help: "Duration of the last notification log garbage collection cycle.", }) m.snapshotDuration = prometheus.NewSummary(prometheus.SummaryOpts{ Name: "alertmanager_nflog_snapshot_duration_seconds", Help: "Duration of the last notification log snapshot.", }) m.queriesTotal = prometheus.NewCounter(prometheus.CounterOpts{ Name: "alertmanager_nflog_queries_total", Help: "Number of notification log queries were received.", }) m.queryErrorsTotal = prometheus.NewCounter(prometheus.CounterOpts{ Name: "alertmanager_nflog_query_errors_total", Help: "Number notification log received queries that failed.", }) m.queryDuration = prometheus.NewHistogram(prometheus.HistogramOpts{ Name: "alertmanager_nflog_query_duration_seconds", Help: "Duration of notification log query evaluation.", }) if r != nil { r.MustRegister( m.gcDuration, m.snapshotDuration, m.queriesTotal, m.queryErrorsTotal, m.queryDuration, ) } return m }
func TestSensorRecordHistogram(t *testing.T) { testServer := httptest.NewServer(prometheus.UninstrumentedHandler()) defer testServer.Close() sensor := &Sensor{ Type: "histogram", collector: prometheus.NewHistogram(prometheus.HistogramOpts{ Namespace: "telemetry", Subsystem: "sensors", Name: "TestSensorRecordHistogram", Help: "help", })} prometheus.MustRegister(sensor.collector) patt := `telemetry_sensors_TestSensorRecordHistogram_bucket{le="([\.0-9|\+Inf]*)"} ([1-9])` sensor.record("1.2") resp := getFromTestServer(t, testServer) expected := [][]string{{"2.5", "1"}, {"5", "1"}, {"10", "1"}, {"+Inf", "1"}} if !checkBuckets(resp, patt, expected) { t.Fatalf("Failed to get match for sensor in response") } sensor.record("1.2") // same value should add resp = getFromTestServer(t, testServer) expected = [][]string{{"2.5", "2"}, {"5", "2"}, {"10", "2"}, {"+Inf", "2"}} if !checkBuckets(resp, patt, expected) { t.Fatalf("Failed to get match for sensor in response") } sensor.record("4.5") // overlapping should overlap resp = getFromTestServer(t, testServer) expected = [][]string{{"2.5", "2"}, {"5", "3"}, {"10", "3"}, {"+Inf", "3"}} if !checkBuckets(resp, patt, expected) { t.Fatalf("Failed to get match for sensor in response") } }
func (n *Namespace) NewTimer(name, help string) Timer { t := &timer{ m: prometheus.NewHistogram(n.newTimerOpts(name, help)), } n.addMetric(t) return t }
// NewSensors creates new sensors from a raw config func NewSensors(raw []interface{}) ([]*Sensor, error) { var sensors []*Sensor if err := utils.DecodeRaw(raw, &sensors); err != nil { return nil, fmt.Errorf("Sensor configuration error: %v", err) } for _, s := range sensors { check, err := commands.NewCommand(s.CheckExec, s.Timeout) if err != nil { return nil, fmt.Errorf("could not parse check in sensor %s: %s", s.Name, err) } check.Name = fmt.Sprintf("%s.sensor", s.Name) s.checkCmd = check // the prometheus client lib's API here is baffling... they don't expose // an interface or embed their Opts type in each of the Opts "subtypes", // so we can't share the initialization. switch { case s.Type == "counter": s.collector = prometheus.NewCounter(prometheus.CounterOpts{ Namespace: s.Namespace, Subsystem: s.Subsystem, Name: s.Name, Help: s.Help, }) case s.Type == "gauge": s.collector = prometheus.NewGauge(prometheus.GaugeOpts{ Namespace: s.Namespace, Subsystem: s.Subsystem, Name: s.Name, Help: s.Help, }) case s.Type == "histogram": s.collector = prometheus.NewHistogram(prometheus.HistogramOpts{ Namespace: s.Namespace, Subsystem: s.Subsystem, Name: s.Name, Help: s.Help, }) case s.Type == "summary": s.collector = prometheus.NewSummary(prometheus.SummaryOpts{ Namespace: s.Namespace, Subsystem: s.Subsystem, Name: s.Name, Help: s.Help, }) default: return nil, fmt.Errorf("invalid sensor type: %s", s.Type) } // we're going to unregister before every attempt to register // so that we can reload config prometheus.Unregister(s.collector) if err := prometheus.Register(s.collector); err != nil { return nil, err } } return sensors, nil }
func ExampleHistogram() { temps := prometheus.NewHistogram(prometheus.HistogramOpts{ Name: "pond_temperature_celsius", Help: "The temperature of the frog pond.", // Sorry, we can't measure how badly it smells. Buckets: prometheus.LinearBuckets(20, 5, 5), // 5 buckets, each 5 centigrade wide. }) // Simulate some observations. for i := 0; i < 1000; i++ { temps.Observe(30 + math.Floor(120*math.Sin(float64(i)*0.1))/10) } // Just for demonstration, let's check the state of the histogram by // (ab)using its Write method (which is usually only used by Prometheus // internally). metric := &dto.Metric{} temps.Write(metric) fmt.Println(proto.MarshalTextString(metric)) // Output: // histogram: < // sample_count: 1000 // sample_sum: 29969.50000000001 // bucket: < // cumulative_count: 192 // upper_bound: 20 // > // bucket: < // cumulative_count: 366 // upper_bound: 25 // > // bucket: < // cumulative_count: 501 // upper_bound: 30 // > // bucket: < // cumulative_count: 638 // upper_bound: 35 // > // bucket: < // cumulative_count: 816 // upper_bound: 40 // > // > }
func newHistogram(opts prometheus.Opts, cutoffs []int64) (prometheus.Histogram, func(int64)) { buckets := make([]float64, len(cutoffs)) for i := range cutoffs { buckets[i] = float64(cutoffs[i]) } hOpts := prometheus.HistogramOpts{ Namespace: opts.Namespace, Subsystem: opts.Subsystem, Name: opts.Name, Help: opts.Help, ConstLabels: opts.ConstLabels, Buckets: buckets, } m := prometheus.NewHistogram(hOpts) return m, func(n int64) { m.Observe(float64(n)) } }
func main() { router := routers.NewRouter() var port string fmt.Printf("len(os.Args) = %d ", len(os.Args)) if len(os.Args) <= 1 { fmt.Println("Please speficy the port or use default port 8090") port = "8090" } else { port = os.Args[1] } fmt.Printf("port = %s", port) // histogram temps := prometheus.NewHistogram(prometheus.HistogramOpts{ Name: "pond_temperature_celsius", Help: "The temperature of the frog pond.", // Sorry, we can't measure how badly it smells. Buckets: prometheus.LinearBuckets(20, 5, 5), // 5 buckets, each 5 centigrade wide. }) // Simulate some observations. for i := 0; i < 1000; i++ { temps.Observe(30 + math.Floor(120*math.Sin(float64(i)*0.1))/10) } // Just for demonstration, let's check the state of the histogram by // (ab)using its Write method (which is usually only used by Prometheus // internally). metric := &dto.Metric{} temps.Write(metric) fmt.Println(proto.MarshalTextString(metric)) router.Handle("/metrics", prometheus.Handler()) //log.Fatal(http.ListenAndServe(":8090", router)) log.Fatal(http.ListenAndServe(":"+port, router)) }
// NewHistogram creates a new configured prometheus histogram object. func NewHistogram(config HistogramConfig) (spec.Histogram, error) { newHistogram := &histogram{ HistogramConfig: config, } if len(newHistogram.Buckets) == 0 { return nil, maskAnyf(invalidConfigError, "buckets must not be empty") } if newHistogram.Help == "" { return nil, maskAnyf(invalidConfigError, "help must not be empty") } if newHistogram.Name == "" { return nil, maskAnyf(invalidConfigError, "name must not be empty") } newHistogram.ClientHistogram = prometheusclient.NewHistogram(prometheusclient.HistogramOpts{ Buckets: newHistogram.Buckets, Help: newHistogram.Help, Name: newHistogram.Name, }) return newHistogram, nil }
func init() { flag.StringVar(&iface, "i", "eth0", "Interface to read packets from") flag.StringVar(&fname, "r", "", "Filename to read from, overrides -i") flag.IntVar(&snaplen, "s", 65536, "Number of max bytes to read per packet") flag.StringVar(&tstype, "t", "", "Type of timestamp to use") flag.IntVar(&port, "P", 9119, "The port number to listen on ") flag.BoolVar(&verbose, "v", false, "Enable verbose mode") } // the currently max seen response time value var max = 0.0 // prometheus histogram (https://godoc.org/github.com/prometheus/client_golang/prometheus#Histogram) var rtHistogram = prometheus.NewHistogram(prometheus.HistogramOpts{ Name: "mongodb_histogram_response_time", Help: "Response time for MongoDB operations", Buckets: prometheus.ExponentialBuckets(0.00000001, 2, 10), }) // prometheus summary (https://godoc.org/github.com/prometheus/client_golang/prometheus#Summary) var rtSummary = prometheus.NewSummary(prometheus.SummaryOpts{ Name: "mongodb_summary_response_time", Help: "Response time for MongoDB operations", }) // prometheus gauge (https://godoc.org/github.com/prometheus/client_golang/prometheus#Gauge) var rtMax = prometheus.NewGauge(prometheus.GaugeOpts{ Namespace: "ognom", Name: "mongodb_max_response_time", Help: "Max response time seen for MongoDB operations in the last 10 seconds", })
// differentiated via a "service" label. rpcDurations = prometheus.NewSummaryVec( prometheus.SummaryOpts{ Name: "rpc_durations_seconds", Help: "RPC latency distributions.", Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001}, }, []string{"service"}, ) // The same as above, but now as a histogram, and only for the normal // distribution. The buckets are targeted to the parameters of the // normal distribution, with 20 buckets centered on the mean, each // half-sigma wide. rpcDurationsHistogram = prometheus.NewHistogram(prometheus.HistogramOpts{ Name: "rpc_durations_histogram_seconds", Help: "RPC latency distributions.", Buckets: prometheus.LinearBuckets(*normMean-5**normDomain, .5**normDomain, 20), }) ) func init() { // Register the summary and the histogram with Prometheus's default registry. prometheus.MustRegister(rpcDurations) prometheus.MustRegister(rpcDurationsHistogram) } func main() { flag.Parse() start := time.Now()
func newMasterCollector(httpClient *httpClient) prometheus.Collector { metrics := map[prometheus.Collector]func(metricMap, prometheus.Collector) error{ // CPU/Disk/Mem resources in free/used gauge("master", "cpus", "Current CPU resources in cluster.", "type"): func(m metricMap, c prometheus.Collector) error { total, ok := m["master/cpus_total"] used, ok := m["master/cpus_used"] if !ok { return notFoundInMap } c.(*prometheus.GaugeVec).WithLabelValues("free").Set(total - used) c.(*prometheus.GaugeVec).WithLabelValues("used").Set(used) return nil }, gauge("master", "cpus_revocable", "Current revocable CPU resources in cluster.", "type"): func(m metricMap, c prometheus.Collector) error { total, ok := m["master/cpus_revocable_total"] used, ok := m["master/cpus_revocable_used"] if !ok { return notFoundInMap } c.(*prometheus.GaugeVec).WithLabelValues("free").Set(total - used) c.(*prometheus.GaugeVec).WithLabelValues("used").Set(used) return nil }, gauge("master", "mem", "Current memory resources in cluster.", "type"): func(m metricMap, c prometheus.Collector) error { total, ok := m["master/mem_total"] used, ok := m["master/mem_used"] if !ok { return notFoundInMap } c.(*prometheus.GaugeVec).WithLabelValues("free").Set(total - used) c.(*prometheus.GaugeVec).WithLabelValues("used").Set(used) return nil }, gauge("master", "mem_revocable", "Current revocable memory resources in cluster.", "type"): func(m metricMap, c prometheus.Collector) error { total, ok := m["master/mem_revocable_total"] used, ok := m["master/mem_revocable_used"] if !ok { return notFoundInMap } c.(*prometheus.GaugeVec).WithLabelValues("free").Set(total - used) c.(*prometheus.GaugeVec).WithLabelValues("used").Set(used) return nil }, gauge("master", "disk", "Current disk resources in cluster.", "type"): func(m metricMap, c prometheus.Collector) error { total, ok := m["master/disk_total"] used, ok := m["master/disk_used"] if !ok { return notFoundInMap } c.(*prometheus.GaugeVec).WithLabelValues("free").Set(total - used) c.(*prometheus.GaugeVec).WithLabelValues("used").Set(used) return nil }, gauge("master", "disk_revocable", "Current disk resources in cluster.", "type"): func(m metricMap, c prometheus.Collector) error { total, ok := m["master/disk_revocable_total"] used, ok := m["master/disk_revocable_used"] if !ok { return notFoundInMap } c.(*prometheus.GaugeVec).WithLabelValues("free").Set(total - used) c.(*prometheus.GaugeVec).WithLabelValues("used").Set(used) return nil }, // Master stats about uptime and election state prometheus.NewGauge(prometheus.GaugeOpts{ Namespace: "mesos", Subsystem: "master", Name: "elected", Help: "1 if master is elected leader, 0 if not", }): func(m metricMap, c prometheus.Collector) error { elected, ok := m["master/elected"] if !ok { return notFoundInMap } c.(prometheus.Gauge).Set(elected) return nil }, prometheus.NewGauge(prometheus.GaugeOpts{ Namespace: "mesos", Subsystem: "master", Name: "uptime_seconds", Help: "Number of seconds the master process is running.", }): func(m metricMap, c prometheus.Collector) error { uptime, ok := m["master/uptime_secs"] if !ok { return notFoundInMap } c.(prometheus.Gauge).Set(uptime) return nil }, // Master stats about agents counter("master", "slave_registration_events_total", "Total number of registration events on this master since it booted.", "event"): func(m metricMap, c prometheus.Collector) error { registrations, ok := m["master/slave_registrations"] reregistrations, ok := m["master/slave_reregistrations"] if !ok { return notFoundInMap } c.(*settableCounterVec).Set(registrations, "register") c.(*settableCounterVec).Set(reregistrations, "reregister") return nil }, counter("master", "slave_removal_events_total", "Total number of removal events on this master since it booted.", "event"): func(m metricMap, c prometheus.Collector) error { scheduled, ok := m["master/slave_shutdowns_scheduled"] canceled, ok := m["master/slave_shutdowns_canceled"] completed, ok := m["master/slave_shutdowns_completed"] removals, ok := m["master/slave_removals"] if !ok { return notFoundInMap } c.(*settableCounterVec).Set(scheduled, "scheduled") c.(*settableCounterVec).Set(canceled, "canceled") c.(*settableCounterVec).Set(completed, "completed") c.(*settableCounterVec).Set(removals-completed, "died") return nil }, gauge("master", "slaves_state", "Current number of slaves known to the master per connection and registration state.", "connection_state", "registration_state"): func(m metricMap, c prometheus.Collector) error { active, ok := m["master/slaves_active"] inactive, ok := m["master/slaves_inactive"] disconnected, ok := m["master/slaves_disconnected"] if !ok { return notFoundInMap } // FIXME: Make sure those assumptions are right // Every "active" node is connected to the master c.(*prometheus.GaugeVec).WithLabelValues("connected", "active").Set(active) // Every "inactive" node is connected but node sending offers c.(*prometheus.GaugeVec).WithLabelValues("connected", "inactive").Set(inactive) // Every "disconnected" node is "inactive" c.(*prometheus.GaugeVec).WithLabelValues("disconnected", "inactive").Set(disconnected) // Every "connected" node is either active or inactive return nil }, // Master stats about frameworks gauge("master", "frameworks_state", "Current number of frames known to the master per connection and registration state.", "connection_state", "registration_state"): func(m metricMap, c prometheus.Collector) error { active, ok := m["master/frameworks_active"] inactive, ok := m["master/frameworks_inactive"] disconnected, ok := m["master/frameworks_disconnected"] if !ok { return notFoundInMap } // FIXME: Make sure those assumptions are right // Every "active" framework is connected to the master c.(*prometheus.GaugeVec).WithLabelValues("connected", "active").Set(active) // Every "inactive" framework is connected but framework sending offers c.(*prometheus.GaugeVec).WithLabelValues("connected", "inactive").Set(inactive) // Every "disconnected" framework is "inactive" c.(*prometheus.GaugeVec).WithLabelValues("disconnected", "inactive").Set(disconnected) // Every "connected" framework is either active or inactive return nil }, prometheus.NewGauge(prometheus.GaugeOpts{ Namespace: "mesos", Subsystem: "master", Name: "offers_pending", Help: "Current number of offers made by the master which aren't yet accepted or declined by frameworks.", }): func(m metricMap, c prometheus.Collector) error { offers, ok := m["master/outstanding_offers"] if !ok { return notFoundInMap } c.(prometheus.Gauge).Set(offers) // c.(*prometheus.Gauge).Set(offers) return nil }, // Master stats about tasks counter("master", "task_states_exit_total", "Total number of tasks processed by exit state.", "state"): func(m metricMap, c prometheus.Collector) error { errored, ok := m["master/tasks_error"] failed, ok := m["master/tasks_failed"] finished, ok := m["master/tasks_finished"] killed, ok := m["master/tasks_killed"] lost, ok := m["master/tasks_lost"] if !ok { return notFoundInMap } c.(*settableCounterVec).Set(errored, "errored") c.(*settableCounterVec).Set(failed, "failed") c.(*settableCounterVec).Set(finished, "finished") c.(*settableCounterVec).Set(killed, "killed") c.(*settableCounterVec).Set(lost, "lost") return nil }, counter("master", "task_states_current", "Current number of tasks by state.", "state"): func(m metricMap, c prometheus.Collector) error { running, ok := m["master/tasks_running"] staging, ok := m["master/tasks_staging"] starting, ok := m["master/tasks_starting"] if !ok { return notFoundInMap } c.(*settableCounterVec).Set(running, "running") c.(*settableCounterVec).Set(staging, "staging") c.(*settableCounterVec).Set(starting, "starting") return nil }, // Master stats about messages counter("master", "messages_outcomes_total", "Total number of messages by outcome of operation and direction.", "source", "destination", "type", "outcome"): func(m metricMap, c prometheus.Collector) error { frameworkToExecutorValid, ok := m["master/valid_framework_to_executor_messages"] frameworkToExecutorInvalid, ok := m["master/invalid_framework_to_executor_messages"] executorToFrameworkValid, ok := m["master/valid_executor_to_framework_messages"] executorToFrameworkInvalid, ok := m["master/invalid_executor_to_framework_messages"] // status updates are sent from framework?(FIXME) to slave // status update acks are sent from slave to framework? statusUpdateAckValid, ok := m["master/valid_status_update_acknowledgements"] statusUpdateAckInvalid, ok := m["master/invalid_status_update_acknowledgements"] statusUpdateValid, ok := m["master/valid_status_updates"] statusUpdateInvalid, ok := m["master/invalid_status_updates"] if !ok { return notFoundInMap } c.(*settableCounterVec).Set(frameworkToExecutorValid, "framework", "executor", "", "valid") c.(*settableCounterVec).Set(frameworkToExecutorInvalid, "framework", "executor", "", "invalid") c.(*settableCounterVec).Set(executorToFrameworkValid, "executor", "framework", "", "valid") c.(*settableCounterVec).Set(executorToFrameworkInvalid, "executor", "framework", "", "invalid") // We consider a ack message simply as a message from slave to framework c.(*settableCounterVec).Set(statusUpdateValid, "framework", "slave", "status_update", "valid") c.(*settableCounterVec).Set(statusUpdateInvalid, "framework", "slave", "status_update", "invalid") c.(*settableCounterVec).Set(statusUpdateAckValid, "slave", "framework", "status_update", "valid") c.(*settableCounterVec).Set(statusUpdateAckInvalid, "slave", "framework", "status_update", "invalid") return nil }, counter("master", "messages_type_total", "Total number of valid messages by type.", "type"): func(m metricMap, c prometheus.Collector) error { for k, v := range m { i := strings.Index("master/messages_", k) if i == -1 { continue } // FIXME: We expose things like messages_framework_to_executor twice c.(*settableCounterVec).Set(v, k[i:]) } return nil }, // Master stats about events gauge("master", "event_queue_length", "Current number of elements in event queue by type", "type"): func(m metricMap, c prometheus.Collector) error { dispatches, ok := m["master/event_queue_dispatches"] httpRequests, ok := m["master/event_queue_http_requests"] messages, ok := m["master/event_queue_messages"] if !ok { return notFoundInMap } c.(*prometheus.GaugeVec).WithLabelValues("message").Set(messages) c.(*prometheus.GaugeVec).WithLabelValues("http_request").Set(httpRequests) c.(*prometheus.GaugeVec).WithLabelValues("dispatches").Set(dispatches) return nil }, // Master stats about registrar prometheus.NewHistogram(prometheus.HistogramOpts{ Namespace: "mesos", Subsystem: "master", Name: "state_store_seconds", Help: "Registry write latency in seconds", }): func(m metricMap, c prometheus.Collector) error { // c.(*prometheus.Histogram).Buckets //FIXME return nil }, } return newMetricCollector(httpClient, metrics) }
refreshHighWatermarks = "refresh_high_watermarks" renderView = "render_view" cutOff = "recency_threshold" processorName = "processor" ) var ( diskLatencyHistogram = &prometheus.HistogramSpecification{ Starts: prometheus.LogarithmicSizedBucketsFor(0, 5000), BucketBuilder: prometheus.AccumulatingBucketBuilder(prometheus.EvictAndReplaceWith(10, prometheus.AverageReducer), 100), ReportablePercentiles: []float64{0.01, 0.05, 0.5, 0.90, 0.99}, } curationDuration = prometheus.NewCounter() curationDurations = prometheus.NewHistogram(diskLatencyHistogram) curationFilterOperations = prometheus.NewCounter() storageOperations = prometheus.NewCounter() storageOperationDurations = prometheus.NewCounter() storageLatency = prometheus.NewHistogram(diskLatencyHistogram) queueSizes = prometheus.NewGauge() storedSamplesCount = prometheus.NewCounter() ) func recordOutcome(duration time.Duration, err error, success, failure map[string]string) { labels := success if err != nil { labels = failure } storageOperations.Increment(labels)
alive = "alive" failure = "failure" outcome = "outcome" state = "state" success = "success" unreachable = "unreachable" ) var ( networkLatencyHistogram = &prometheus.HistogramSpecification{ Starts: prometheus.LogarithmicSizedBucketsFor(0, 1000), BucketBuilder: prometheus.AccumulatingBucketBuilder(prometheus.EvictAndReplaceWith(10, prometheus.AverageReducer), 100), ReportablePercentiles: []float64{0.01, 0.05, 0.5, 0.90, 0.99}, } targetOperationLatencies = prometheus.NewHistogram(networkLatencyHistogram) retrievalDurations = prometheus.NewHistogram(&prometheus.HistogramSpecification{ Starts: prometheus.LogarithmicSizedBucketsFor(0, 10000), BucketBuilder: prometheus.AccumulatingBucketBuilder(prometheus.EvictAndReplaceWith(10, prometheus.AverageReducer), 100), ReportablePercentiles: []float64{0.01, 0.05, 0.5, 0.90, 0.99}}) targetOperations = prometheus.NewCounter() dnsSDLookupsCount = prometheus.NewCounter() ) func recordOutcome(err error) { message := success if err != nil { message = failure }
// // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package wal import "github.com/prometheus/client_golang/prometheus" var ( syncDurations = prometheus.NewHistogram(prometheus.HistogramOpts{ Namespace: "etcd", Subsystem: "disk", Name: "wal_fsync_duration_seconds", Help: "The latency distributions of fsync called by wal.", Buckets: prometheus.ExponentialBuckets(0.001, 2, 14), }) ) func init() { prometheus.MustRegister(syncDurations) }
Buckets: prometheus.ExponentialBuckets(0.0005, 2, 18), }, []string{"type"}) sendReqHistogram = prometheus.NewHistogramVec( prometheus.HistogramOpts{ Namespace: "tidb", Subsystem: "tikvclient", Name: "request_seconds", Help: "Bucketed histogram of sending request duration.", Buckets: prometheus.ExponentialBuckets(0.0005, 2, 18), }, []string{"type"}) copBuildTaskHistogram = prometheus.NewHistogram( prometheus.HistogramOpts{ Namespace: "tidb", Subsystem: "tikvclient", Name: "cop_buildtask_seconds", Help: "Coprocessor buildTask cost time.", }) copTaskLenHistogram = prometheus.NewHistogram( prometheus.HistogramOpts{ Namespace: "tidb", Subsystem: "tikvclient", Name: "cop_task_len", Help: "Coprocessor task length.", Buckets: prometheus.ExponentialBuckets(1, 2, 11), }) coprocessorCounter = prometheus.NewCounterVec( prometheus.CounterOpts{
package etcdserver import ( "time" "github.com/coreos/etcd/pkg/runtime" "github.com/prometheus/client_golang/prometheus" ) var ( // TODO: with label in v3? proposeDurations = prometheus.NewHistogram(prometheus.HistogramOpts{ Namespace: "etcd", Subsystem: "server", Name: "proposal_durations_seconds", Help: "The latency distributions of committing proposal.", Buckets: prometheus.ExponentialBuckets(0.001, 2, 14), }) proposePending = prometheus.NewGauge(prometheus.GaugeOpts{ Namespace: "etcd", Subsystem: "server", Name: "pending_proposal_total", Help: "The total number of pending proposals.", }) // This is number of proposal failed in client's view. // The proposal might be later got committed in raft. proposeFailed = prometheus.NewCounter(prometheus.CounterOpts{ Namespace: "etcd", Subsystem: "server", Name: "proposal_failed_total",
var ( queryResultsPath = flag.String("query_results_path", "/tmp/qr/", "Path where query results files (page_0.json etc.) are stored") perPackagePathRe = regexp.MustCompile(`^/perpackage-results/([^/]+)/` + strconv.Itoa(resultsPerPackage) + `/page_([0-9]+).json$`) queryDurations = prometheus.NewHistogram( prometheus.HistogramOpts{ Name: "query_durations_ms", Help: "Duration of a query in milliseconds.", Buckets: []float64{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 150, 200, 250, 300, 350, 400, 450, 500, 550, 600, 650, 700, 750, 800, 850, 900, 950, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 20000, 30000, 40000, 50000, 60000, 70000, 80000, 90000, 100000, 500000, 1000000, }, }) ) const ( // NB: All of these constants needs to match those in static/instant.js. packagesPerPage = 5 resultsPerPackage = 2 resultsPerPage = 10 )
Name: "request_total", Help: "Counter of tikv-server requests.", }, []string{"type"}) sendReqHistogram = prometheus.NewHistogramVec( prometheus.HistogramOpts{ Namespace: "tidb", Subsystem: "tikvclient", Name: "request_seconds", Help: "Bucketed histogram of sending request duration.", }, []string{"type"}) copBuildTaskHistogram = prometheus.NewHistogram( prometheus.HistogramOpts{ Namespace: "tidb", Subsystem: "tikvclient", Name: "cop_buildtask_seconds", Help: "Coprocessor buildTask cost time.", }) copTaskLenHistogram = prometheus.NewHistogram( prometheus.HistogramOpts{ Namespace: "tidb", Subsystem: "tikvclient", Name: "cop_task_len", Help: "Coprocessor task length.", Buckets: prometheus.ExponentialBuckets(1, 2, 11), }) coprocessorCounter = prometheus.NewCounterVec( prometheus.CounterOpts{
// See the License for the specific language governing permissions and // limitations under the License. package metrics import ( "time" "github.com/prometheus/client_golang/prometheus" ) var ( queryMetric = prometheus.NewHistogram( prometheus.HistogramOpts{ Namespace: "tidb", Subsystem: "query", Name: "handle_query_duration_seconds", Help: "Bucketed histogram of processing time (s) of handled queries.", Buckets: prometheus.ExponentialBuckets(0.0005, 2, 13), }) ) // Query is used for add query cost time into metrics. func Query(costTime time.Duration) { queryMetric.Observe(float64(costTime)) } func init() { prometheus.MustRegister(queryMetric) }
Namespace: Namespace, Subsystem: "engine", Name: "task_failure_count_total", Help: "Counter of engine schedule task failures.", }, []string{"type"}) engineReconcileCount = prometheus.NewCounter(prometheus.CounterOpts{ Namespace: Namespace, Subsystem: "engine", Name: "reconcile_count_total", Help: "Counter of reconcile rounds.", }) engineReconcileDuration = prometheus.NewHistogram(prometheus.HistogramOpts{ Namespace: Namespace, Subsystem: "engine", Name: "reconcile_duration_second", Help: "Histogram of time (in seconds) each schedule round takes.", }) engineReconcileFailureCount = prometheus.NewCounterVec(prometheus.CounterOpts{ Namespace: Namespace, Subsystem: "engine", Name: "reconcile_failure_count_total", Help: "Counter of scheduling failures.", }, []string{"type"}) registryOpCount = prometheus.NewCounterVec(prometheus.CounterOpts{ Namespace: Namespace, Subsystem: "registry", Name: "operation_count_total", Help: "Counter of registry operations.",
) const ( checkInterval = 5 * time.Minute refreshLockDuration = time.Minute * 2 lockDuration = time.Minute*8 + refreshLockDuration maxBackOff = 15 * time.Minute ) var ( log = capnslog.NewPackageLogger("github.com/coreos/clair", "notifier") notifiers = make(map[string]Notifier) promNotifierLatencyMilliseconds = prometheus.NewHistogram(prometheus.HistogramOpts{ Name: "clair_notifier_latency_milliseconds", Help: "Time it takes to send a notification after it's been created.", }) promNotifierBackendErrorsTotal = prometheus.NewCounterVec(prometheus.CounterOpts{ Name: "clair_notifier_backend_errors_total", Help: "Number of errors that notifier backends generated.", }, []string{"backend"}) ) // Notifier represents anything that can transmit notifications. type Notifier interface { // Configure attempts to initialize the notifier with the provided configuration. // It returns whether the notifier is enabled or not. Configure(*config.NotifierConfig) (bool, error) // Send informs the existence of the specified notification. Send(notification database.VulnerabilityNotification) error
// Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // See the License for the specific language governing permissions and // limitations under the License. package tidb import ( "github.com/prometheus/client_golang/prometheus" ) var ( sessionExecuteParseDuration = prometheus.NewHistogram( prometheus.HistogramOpts{ Namespace: "tidb", Subsystem: "server", Name: "session_execute_parse_duration", Help: "Bucketed histogram of processing time (s) in parse SQL.", Buckets: prometheus.LinearBuckets(0.00004, 0.00001, 13), }) sessionExecuteCompileDuration = prometheus.NewHistogram( prometheus.HistogramOpts{ Namespace: "tidb", Subsystem: "server", Name: "session_execute_compile_duration", Help: "Bucketed histogram of processing time (s) in query optimize.", Buckets: prometheus.LinearBuckets(0.00004, 0.00001, 13), }) sessionExecuteRunDuration = prometheus.NewHistogram( prometheus.HistogramOpts{ Namespace: "tidb", Subsystem: "server",
uniqueLurkingAgentCount = prometheus.NewGauge(prometheus.GaugeOpts{ Name: "unique_lurking_agents", Subsystem: "presence", Help: "Number of unique, lurking agents in the presence table.", }) uniqueWebAgentCount = prometheus.NewGauge(prometheus.GaugeOpts{ Name: "unique_web_agents", Subsystem: "presence", Help: "Number of unique agents using the web client in the presence table.", }) sessionsPerAgent = prometheus.NewHistogram(prometheus.HistogramOpts{ Name: "sessions_per_agent", Subsystem: "presence", Help: "Number of simultaneous live sessions for each active agent.", Buckets: prometheus.LinearBuckets(0, 1, 10), }) ) func init() { prometheus.MustRegister(rowCount) prometheus.MustRegister(activeRowCount) prometheus.MustRegister(activeRowCountPerRoom) prometheus.MustRegister(lurkingRowCount) prometheus.MustRegister(lurkingRowCountPerRoom) prometheus.MustRegister(uniqueAgentCount) prometheus.MustRegister(uniqueLurkingAgentCount) prometheus.MustRegister(uniqueWebAgentCount) prometheus.MustRegister(sessionsPerAgent) }
"time" "github.com/prometheus/client_golang/prometheus" ) var ( port = flag.String("port", "8000", "Port to listen on.") ) var ( requests = prometheus.NewCounter(prometheus.CounterOpts{ Name: "requests", Help: "total requests received"}) errors = prometheus.NewCounterVec(prometheus.CounterOpts{ Name: "errors", Help: "total errors served"}, []string{"code"}) latency_ms = prometheus.NewHistogram(prometheus.HistogramOpts{ Name: "latency_ms", Help: "request latency in milliseconds", Buckets: prometheus.ExponentialBuckets(1, 2, 20)}) backend_latency_ms = prometheus.NewHistogram(prometheus.HistogramOpts{ Name: "backend_latency_ms", Help: "request latency in milliseconds", Buckets: prometheus.ExponentialBuckets(1, 2, 20)}) ) func init() { prometheus.MustRegister(requests) prometheus.MustRegister(errors) prometheus.MustRegister(latency_ms) prometheus.MustRegister(backend_latency_ms) } var (
// Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package snap import "github.com/prometheus/client_golang/prometheus" var ( // TODO: save_fsync latency? saveDurations = prometheus.NewHistogram(prometheus.HistogramOpts{ Namespace: "etcd_debugging", Subsystem: "snap", Name: "save_total_durations_seconds", Help: "The total latency distributions of save called by snapshot.", Buckets: prometheus.ExponentialBuckets(0.001, 2, 14), }) marshallingDurations = prometheus.NewHistogram(prometheus.HistogramOpts{ Namespace: "etcd_debugging", Subsystem: "snap", Name: "save_marshalling_durations_seconds", Help: "The marshalling cost distributions of save called by snapshot.", Buckets: prometheus.ExponentialBuckets(0.001, 2, 14), }) ) func init() { prometheus.MustRegister(saveDurations)
}, []string{"volume"}) promFileSyncs = prometheus.NewCounterVec(prometheus.CounterOpts{ Name: "torus_server_file_syncs", Help: "Number of times a file has been synced on this server", }, []string{"volume"}) promFileChangedSyncs = prometheus.NewCounterVec(prometheus.CounterOpts{ Name: "torus_server_file_changed_syncs", Help: "Number of times a file has been synced on this server, and the file has changed underneath it", }, []string{"volume"}) promFileWrittenBytes = prometheus.NewCounterVec(prometheus.CounterOpts{ Name: "torus_server_file_written_bytes", Help: "Number of bytes written to a file on this server", }, []string{"volume"}) promFileBlockRead = prometheus.NewHistogram(prometheus.HistogramOpts{ Name: "torus_server_file_block_read_us", Help: "Histogram of ms taken to read a block through the layers and into the file abstraction", Buckets: prometheus.ExponentialBuckets(50.0, 2, 20), }) promFileBlockWrite = prometheus.NewHistogram(prometheus.HistogramOpts{ Name: "torus_server_file_block_write_us", Help: "Histogram of ms taken to write a block through the layers and into the file abstraction", Buckets: prometheus.ExponentialBuckets(50.0, 2, 20), }) ) func init() { prometheus.MustRegister(promOpenINodes) prometheus.MustRegister(promOpenFiles) prometheus.MustRegister(promFileSyncs) prometheus.MustRegister(promFileChangedSyncs) prometheus.MustRegister(promFileWrittenBytes)
Help: "Total number of events sent by this member.", }) pendingEventsGauge = prometheus.NewGauge( prometheus.GaugeOpts{ Namespace: "etcd", Subsystem: "storage", Name: "pending_events_total", Help: "Total number of pending events to be sent.", }) indexCompactionPauseDurations = prometheus.NewHistogram( prometheus.HistogramOpts{ Namespace: "etcd", Subsystem: "storage", Name: "index_compaction_pause_duration_milliseconds", Help: "Bucketed histogram of index compaction pause duration.", // 0.5ms -> 1second Buckets: prometheus.ExponentialBuckets(0.5, 2, 12), }) dbCompactionPauseDurations = prometheus.NewHistogram( prometheus.HistogramOpts{ Namespace: "etcd", Subsystem: "storage", Name: "db_compaction_pause_duration_milliseconds", Help: "Bucketed histogram of db compaction pause duration.", // 1ms -> 4second Buckets: prometheus.ExponentialBuckets(1, 2, 13), })
// // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package backend import "github.com/prometheus/client_golang/prometheus" var ( commitDurations = prometheus.NewHistogram(prometheus.HistogramOpts{ Namespace: "etcd", Subsystem: "disk", Name: "backend_commit_duration_seconds", Help: "The latency distributions of commit called by backend.", Buckets: prometheus.ExponentialBuckets(0.001, 2, 14), }) ) func init() { prometheus.MustRegister(commitDurations) }
import ( "sync" "time" "github.com/prometheus/client_golang/prometheus" ) const schedulerSubsystem = "scheduler" var BindingSaturationReportInterval = 1 * time.Second var ( E2eSchedulingLatency = prometheus.NewHistogram( prometheus.HistogramOpts{ Subsystem: schedulerSubsystem, Name: "e2e_scheduling_latency_microseconds", Help: "E2e scheduling latency (scheduling algorithm + binding)", Buckets: prometheus.ExponentialBuckets(1000, 2, 15), }, ) SchedulingAlgorithmLatency = prometheus.NewHistogram( prometheus.HistogramOpts{ Subsystem: schedulerSubsystem, Name: "scheduling_algorithm_latency_microseconds", Help: "Scheduling algorithm latency", Buckets: prometheus.ExponentialBuckets(1000, 2, 15), }, ) BindingLatency = prometheus.NewHistogram( prometheus.HistogramOpts{ Subsystem: schedulerSubsystem, Name: "binding_latency_microseconds",