youtubebeat/vendor/github.com/elastic/beats/libbeat/outputs/metrics.go

147 lines
4.5 KiB
Go
Raw Normal View History

2018-11-18 11:08:38 +01:00
// Licensed to Elasticsearch B.V. under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. Elasticsearch B.V. licenses this file to you 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 outputs
import "github.com/elastic/beats/libbeat/monitoring"
// Stats implements the Observer interface, for collecting metrics on common
// outputs events.
type Stats struct {
//
// Output event stats
//
batches *monitoring.Uint // total number of batches processed by output
events *monitoring.Uint // total number of events processed by output
acked *monitoring.Uint // total number of events ACKed by output
failed *monitoring.Uint // total number of events failed in output
active *monitoring.Uint // events sent and waiting for ACK/fail from output
duplicates *monitoring.Uint // events sent and waiting for ACK/fail from output
dropped *monitoring.Uint // total number of invalid events dropped by the output
//
// Output network connection stats
//
writeBytes *monitoring.Uint // total amount of bytes written by output
writeErrors *monitoring.Uint // total number of errors on write
readBytes *monitoring.Uint // total amount of bytes read
readErrors *monitoring.Uint // total number of errors while waiting for response on output
}
// NewStats creates a new Stats instance using a backing monitoring registry.
// This function will create and register a number of metrics with the registry passed.
// The registry must not be null.
func NewStats(reg *monitoring.Registry) *Stats {
return &Stats{
batches: monitoring.NewUint(reg, "events.batches"),
events: monitoring.NewUint(reg, "events.total"),
acked: monitoring.NewUint(reg, "events.acked"),
failed: monitoring.NewUint(reg, "events.failed"),
dropped: monitoring.NewUint(reg, "events.dropped"),
duplicates: monitoring.NewUint(reg, "events.duplicates"),
active: monitoring.NewUint(reg, "events.active"),
writeBytes: monitoring.NewUint(reg, "write.bytes"),
writeErrors: monitoring.NewUint(reg, "write.errors"),
readBytes: monitoring.NewUint(reg, "read.bytes"),
readErrors: monitoring.NewUint(reg, "read.errors"),
}
}
// NewBatch updates active batch and event metrics.
func (s *Stats) NewBatch(n int) {
if s != nil {
s.batches.Inc()
s.events.Add(uint64(n))
s.active.Add(uint64(n))
}
}
// Acked updates active and acked event metrics.
func (s *Stats) Acked(n int) {
if s != nil {
s.acked.Add(uint64(n))
s.active.Sub(uint64(n))
}
}
// Failed updates active and failed event metrics.
func (s *Stats) Failed(n int) {
if s != nil {
s.failed.Add(uint64(n))
s.active.Sub(uint64(n))
}
}
// Duplicate updates the active and duplicate event metrics.
func (s *Stats) Duplicate(n int) {
if s != nil {
s.duplicates.Add(uint64(n))
s.active.Sub(uint64(n))
}
}
// Dropped updates total number of event drops as reported by the output.
// Outputs will only report dropped events on fatal errors which lead to the
// event not being publishable. For example encoding errors or total event size
// being bigger then maximum supported event size.
func (s *Stats) Dropped(n int) {
// number of dropped events (e.g. encoding failures)
if s != nil {
s.active.Sub(uint64(n))
s.dropped.Add(uint64(n))
}
}
// Cancelled updates the active event metrics.
func (s *Stats) Cancelled(n int) {
if s != nil {
s.active.Sub(uint64(n))
}
}
// WriteError increases the write I/O error metrics.
func (s *Stats) WriteError(err error) {
if s != nil {
s.writeErrors.Inc()
}
}
// WriteBytes updates the total number of bytes written/send by an output.
func (s *Stats) WriteBytes(n int) {
if s != nil {
s.writeBytes.Add(uint64(n))
}
}
// ReadError increases the read I/O error metrics.
func (s *Stats) ReadError(err error) {
if s != nil {
s.readErrors.Inc()
}
}
// ReadBytes updates the total number of bytes read/received by an output.
func (s *Stats) ReadBytes(n int) {
if s != nil {
s.readBytes.Add(uint64(n))
}
}