blip

package module
v2.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 11, 2026 License: Apache-2.0 Imports: 24 Imported by: 0

README

Blip

Build

Blip is a MySQL monitor: it collects and reports metrics from MySQL to monitoring platforms like Datadog. It works with all vendors and distributions of MySQL 5.7 and 8.0, on-premise and in the cloud. It has built-in support for Datadog, Splunk, and Chronosphere, and a plugin architecture to report metrics to any monitoring platform.

Blip was created by engineers at Cash App and Square and built for everyone using MySQL.

Users

📖 Blip Documentation

🔗 Release Notes

Developers

🔗 Contributions welcome

Go Reference

Documentation

Overview

Package blip provides high-level data structs and const for integrating with Blip.

Index

Constants

View Source 
const (
	UNKNOWN byte = iota
	CUMULATIVE_COUNTER
	DELTA_COUNTER
	GAUGE
	BOOL
	EVENT
)

Metric types.

View Source 
const (
	STATE_NONE      = ""
	STATE_OFFLINE   = "offline"
	STATE_STANDBY   = "standby"
	STATE_READ_ONLY = "read-only"
	STATE_ACTIVE    = "active"
)

Monitor states used for plan changing: https://block.github.io/blip/plans/changing/

View Source 
const (
	DEFAULT_CONFIG_FILE = "blip.yaml"
	DEFAULT_DATABASE    = "blip"
)
View Source 
const (
	DEFAULT_MONITOR_USERNAME        = "blip"
	DEFAULT_MONITOR_TIMEOUT_CONNECT = "10s"
)
View Source 
const (
	EXPORTER_MODE_DUAL   = "dual"   // Blip and exporter run together
	EXPORTER_MODE_LEGACY = "legacy" // only exporter runs

	DEFAULT_EXPORTER_LISTEN_ADDR = "127.0.0.1:9104"
	DEFAULT_EXPORTER_PATH        = "/metrics"
	DEFAULT_EXPORTER_PLAN        = "default-exporter"
)
View Source 
const (
	DEFAULT_API_BIND = "127.0.0.1:7522"
)
View Source 
const (
	DEFAULT_HEARTBEAT_TABLE = "blip.heartbeat"
)
View Source 
const (
	DEFAULT_PLANS_TABLE = "blip.plans"
)
View Source 
const VERSION = "2.1.0"

Variables

View Source 
var (
	Debugging = false
)
View Source 
var ErrMore = errors.New("more metrics")

ErrMore signals that a collector will return more values. See https://block.github.io/blip/develop/collectors/#long-running.

View Source 
var FormatTime func(time.Time) string = func(t time.Time) string {
	return t.Format(time.RFC3339)
}
View Source 
var SHA = ""

Functions

func Bool 

func Bool(s string) bool

func Debug 

func Debug(msg string, v ...interface{})

func DecodeDatabaseConfig 

func DecodeDatabaseConfig(config ConfigDatabase, out interface{}) error

DecodeDatabaseConfig strictly decodes opaque monitor database configuration into a module-owned typed value.

func DefaultPasswordSecretParser 

func DefaultPasswordSecretParser(_ context.Context, cfg ConfigMonitor, payload []byte, credentials *DbCredentials) error

DefaultPasswordSecretParser parses the default AWS RDS secret shape: "password" is required, and "username" is optional.

func MonitorId 

func MonitorId(cfg ConfigMonitor) string

func RegisterDatabaseModule 

func RegisterDatabaseModule(module DatabaseModule) error

RegisterDatabaseModule registers one external database module. Registering a duplicate type or one of Blip's reserved database types returns an error.

func RemoveDatabaseModule 

func RemoveDatabaseModule(databaseType DatabaseType)

RemoveDatabaseModule removes an external database module. It supports test isolation and registration rollback when a larger module enable operation fails after registering its database type.

func SetOrDefault 

func SetOrDefault(a, b string) string

SetOrDefault returns a if not empty, else it returns b. This is a convenience function to define variables with an explicit value or a DEFAULT_* value.

func StopLoss 

func StopLoss(v string) (uint, float64, error)

func TimeLimit 

func TimeLimit(p float64, d, max time.Duration) time.Duration

TimeLimit returns d minus p percentage (0.1 = 10%) of time up to max. For example, (0.1, 5s, 1s) returns 4.5s: 5000ms - 10% = 4500ms. But (0.1, 20s, 1s) returns 29s because 10% of 30s = 3s > 1s max, so the buffer is reduced to max. This is used to calculate engine max runtime (EMR) and collector max runtime (CMR).

func True 

func True(b *bool) bool

True returns true if b is non-nil and true. This is convenience function related to *bool files in config structs, which is required for knowing when a bool config is explicitly set or not. If set, it's not changed; if not, it's set to the default value. That makes a good config experience but a less than ideal code experience because !*b will panic if b is nil, hence the need for this func.

func ValidDatabaseType 

func ValidDatabaseType(databaseType DatabaseType) bool

ValidDatabaseType reports whether a value is a valid concrete monitor and collector database type. DatabaseTypeAny is not a concrete type.

Types

type AWS 

type AWS struct {
	Region string
}

type AWSConfigFactory 

type AWSConfigFactory interface {
	Make(AWS, string) (aws.Config, error)
}

type Collector 

type Collector interface {
	// Domain returns the Blip domain name.
	Domain() string

	// Help returns collector descipiton, options, and other usage printed by
	// blip --print-domains. Blip uses this information to validate user-provided
	// values in plans.
	Help() CollectorHelp

	// Prepare prepares a plan for future calls to Collect. The return function
	// is called once when the collector is destroyed; it allows the collector
	// to clean up. If Prepare returns an error, Blip will retry preparing the
	// plan. Therefore, Prepare should not retry on error (for example, if the
	// database is not online yet).
	Prepare(ctx context.Context, plan Plan) (func(), error)

	// Collect collects metrics for the previously prepared plan. Collect is only
	// called after Prepare returns nil.
	Collect(ctx context.Context, levelName string) ([]MetricValue, error)
}

Collector collects metrics for a single metric domain.

type CollectorFactory 

type CollectorFactory interface {
	Make(domain string, args CollectorFactoryArgs) (Collector, error)
}

A CollectorFactory makes one or more Collector.

type CollectorFactoryArgs 

type CollectorFactoryArgs struct {
	// Config is the full and final monitor config. Most collectors do not need
	// this, but some that collect metrics outside the database, like cloud metrics,
	// might need additional monitor config values.
	Config ConfigMonitor

	// DB is the monitor's database connection. It is safe for concurrent use,
	// and it is used concurrently by other parts of a monitor. The Collector
	// must not modify the connection, reconnect, and so forth--only use the
	// connection.
	DB *sql.DB

	// MonitorId is the monitor identifier. The Collector must include
	// this value in all errors, output, and so forth. Everything monitor-related
	// in Blip is keyed on monitor ID.
	MonitorId string

	// Validate is true only when the plan loader is validating collectors.
	// Do not use this field.
	Validate bool
}

CollectorFactoryArgs are provided by Blip to a CollectorFactory when making a Collector. The factory must use the args to create the collector.

type CollectorFactoryDatabaseTypes 

type CollectorFactoryDatabaseTypes interface {
	CollectorFactory
	DatabaseTypes(domain string) []DatabaseType
}

CollectorFactoryDatabaseTypes is an optional CollectorFactory capability that identifies the database types supported by a domain. Factories that do not implement this interface retain Blip's historical MySQL behavior.

The domain argument allows one factory to serve domains with different compatibility, such as MySQL collectors and database-neutral cloud metrics. Implementations must return at least one database type. Return DatabaseTypeAny by itself for a database-neutral domain.

type CollectorFactoryWithDBProvider 

type CollectorFactoryWithDBProvider interface {
	CollectorFactory
	MakeWithDBProvider(domain string, args CollectorFactoryArgs, provider DbProvider) (Collector, error)
}

CollectorFactoryWithDBProvider is an optional CollectorFactory capability for database-specific collectors that need access to the monitor-owned database provider. Factories that do not implement it retain the historical Make behavior.

type CollectorHelp 

type CollectorHelp struct {
	Domain      string
	Description string
	Options     map[string]CollectorHelpOption
	Errors      map[string]CollectorHelpError
	Groups      []CollectorKeyValue
	Meta        []CollectorKeyValue
	Metrics     []CollectorMetric
}

Help represents information about a collector.

func (CollectorHelp) Validate 

func (h CollectorHelp) Validate(opts map[string]string) error

Validate returns nil if all the given options are valid, else it an error.

type CollectorHelpError 

type CollectorHelpError struct {
	Name    string
	Handles string
	Default string
}

type CollectorHelpOption 

type CollectorHelpOption struct {
	Name    string
	Desc    string            // describes Name
	Default string            // key in Values
	Values  map[string]string // value => description
}

type CollectorKeyValue 

type CollectorKeyValue struct {
	Key   string
	Value string
}

type CollectorMetric 

type CollectorMetric struct {
	Name string
	Desc string // describes Name
	Type byte
}

type Config 

type Config struct {
	// Blip server
	API           ConfigAPI           `yaml:"api,omitempty"`
	HTTP          ConfigHTTP          `yaml:"http,omitempty"`
	MonitorLoader ConfigMonitorLoader `yaml:"monitor-loader,omitempty"`
	Sinks         ConfigSinks         `yaml:"sinks,omitempty"`

	// Monitor defaults
	AWS       ConfigAWS              `yaml:"aws,omitempty"`
	Exporter  ConfigExporter         `yaml:"exporter,omitempty"`
	HA        ConfigHighAvailability `yaml:"ha,omitempty"`
	Heartbeat ConfigHeartbeat        `yaml:"heartbeat,omitempty"`
	MySQL     ConfigMySQL            `yaml:"mysql,omitempty"`
	Plans     ConfigPlans            `yaml:"plans,omitempty"`
	Tags      map[string]string      `yaml:"tags,omitempty"`
	TLS       ConfigTLS              `yaml:"tls,omitempty"`

	Monitors []ConfigMonitor `yaml:"monitors,omitempty"`
}

Config represents the Blip startup configuration.

func DefaultConfig 

func DefaultConfig() Config

func LoadConfig 

func LoadConfig(filePath string, cfg Config, required bool) (Config, error)

func (*Config) ApplyDefaults 

func (c *Config) ApplyDefaults(b Config)

func (*Config) InterpolateEnvVars 

func (c *Config) InterpolateEnvVars()

func (Config) Redacted 

func (c Config) Redacted() Config

Redacted returns a copy of the config safe for logging. It redacts inline passwords without changing the config used to connect to monitored databases.

func (Config) Validate 

func (c Config) Validate() error

type ConfigAPI 

type ConfigAPI struct {
	Bind    string `yaml:"bind"`
	Disable bool   `yaml:"disable,omitempty"`
}

func DefaultConfigAPI 

func DefaultConfigAPI() ConfigAPI

func (*ConfigAPI) ApplyDefaults 

func (c *ConfigAPI) ApplyDefaults(b Config)

func (*ConfigAPI) InterpolateEnvVars 

func (c *ConfigAPI) InterpolateEnvVars()

func (ConfigAPI) Validate 

func (c ConfigAPI) Validate() error

type ConfigAWS 

type ConfigAWS struct {
	IAMAuth           *bool  `yaml:"iam-auth,omitempty"`
	PasswordSecret    string `yaml:"password-secret,omitempty"`
	Region            string `yaml:"region,omitempty"`
	DisableAutoRegion *bool  `yaml:"disable-auto-region,omitempty"`
	DisableAutoTLS    *bool  `yaml:"disable-auto-tls,omitempty"`
}

func DefaultConfigAWS 

func DefaultConfigAWS() ConfigAWS

func (*ConfigAWS) ApplyDefaults 

func (c *ConfigAWS) ApplyDefaults(b Config)

func (*ConfigAWS) InterpolateEnvVars 

func (c *ConfigAWS) InterpolateEnvVars()

func (*ConfigAWS) InterpolateMonitor 

func (c *ConfigAWS) InterpolateMonitor(m *ConfigMonitor)

func (ConfigAWS) Validate 

func (c ConfigAWS) Validate() error

type ConfigDatabase 

type ConfigDatabase map[string]interface{}

ConfigDatabase contains configuration owned by an external database module. Blip interpolates string values but otherwise treats this map as opaque. A module should use DecodeDatabaseConfig to strictly decode it into a typed configuration before applying its defaults and validation.

type ConfigExporter 

type ConfigExporter struct {
	Flags map[string]string `yaml:"flags,omitempty"`
	Mode  string            `yaml:"mode,omitempty"`
	Plan  string            `yaml:"plan,omitempty"`
}

func DefaultConfigExporter 

func DefaultConfigExporter() ConfigExporter

func (*ConfigExporter) ApplyDefaults 

func (c *ConfigExporter) ApplyDefaults(b Config)

func (*ConfigExporter) InterpolateEnvVars 

func (c *ConfigExporter) InterpolateEnvVars()

func (*ConfigExporter) InterpolateMonitor 

func (c *ConfigExporter) InterpolateMonitor(m *ConfigMonitor)

func (ConfigExporter) Validate 

func (c ConfigExporter) Validate() error

type ConfigHTTP 

type ConfigHTTP struct {
	Proxy string `yaml:"proxy,omityempty"`
}

func DefaultConfigHTTP 

func DefaultConfigHTTP() ConfigHTTP

func (*ConfigHTTP) ApplyDefaults 

func (c *ConfigHTTP) ApplyDefaults(b Config)

func (*ConfigHTTP) InterpolateEnvVars 

func (c *ConfigHTTP) InterpolateEnvVars()

func (ConfigHTTP) Redacted 

func (c ConfigHTTP) Redacted() ConfigHTTP

Redacted returns a copy of the HTTP config safe for logging.

func (ConfigHTTP) Validate 

func (c ConfigHTTP) Validate() error

type ConfigHeartbeat 

type ConfigHeartbeat struct {
	Freq     string `yaml:"freq,omitempty"`
	SourceId string `yaml:"source-id,omitempty"`
	Role     string `yaml:"role,omitempty"`
	Table    string `yaml:"table,omitempty"`
}

func DefaultConfigHeartbeat 

func DefaultConfigHeartbeat() ConfigHeartbeat

func (*ConfigHeartbeat) ApplyDefaults 

func (c *ConfigHeartbeat) ApplyDefaults(b Config)

func (*ConfigHeartbeat) InterpolateEnvVars 

func (c *ConfigHeartbeat) InterpolateEnvVars()

func (*ConfigHeartbeat) InterpolateMonitor 

func (c *ConfigHeartbeat) InterpolateMonitor(m *ConfigMonitor)

func (ConfigHeartbeat) Validate 

func (c ConfigHeartbeat) Validate() error

type ConfigHighAvailability 

type ConfigHighAvailability struct{}

func DefaultConfigHA 

func DefaultConfigHA() ConfigHighAvailability

func (*ConfigHighAvailability) ApplyDefaults 

func (c *ConfigHighAvailability) ApplyDefaults(b Config)

func (*ConfigHighAvailability) InterpolateEnvVars 

func (c *ConfigHighAvailability) InterpolateEnvVars()

func (*ConfigHighAvailability) InterpolateMonitor 

func (c *ConfigHighAvailability) InterpolateMonitor(m *ConfigMonitor)

func (ConfigHighAvailability) Validate 

func (c ConfigHighAvailability) Validate() error

type ConfigMonitor 

type ConfigMonitor struct {
	MonitorId string `yaml:"id"`
	// DatabaseType selects the database-specific connection and metric module.
	// Empty values retain Blip's historical MySQL behavior.
	DatabaseType DatabaseType `yaml:"database-type,omitempty"`

	// Shared connection identity and credentials. Socket and MyCnf are specific
	// to Blip's built-in MySQL connection factory.
	Socket         string `yaml:"socket,omitempty"`
	Hostname       string `yaml:"hostname,omitempty"`
	MyCnf          string `yaml:"mycnf,omitempty"`
	Username       string `yaml:"username,omitempty"`
	Password       string `yaml:"password,omitempty"`
	PasswordFile   string `yaml:"password-file,omitempty"`
	TimeoutConnect string `yaml:"timeout-connect,omitempty"`

	// Tags are passed to each metric sink. Tags inherit from config.tags,
	// but these monitor.tags take precedent (are not overwritten by config.tags).
	Tags map[string]string `yaml:"tags,omitempty"`

	AWS       ConfigAWS              `yaml:"aws,omitempty"`
	Exporter  ConfigExporter         `yaml:"exporter,omitempty"`
	HA        ConfigHighAvailability `yaml:"ha,omitempty"`
	Heartbeat ConfigHeartbeat        `yaml:"heartbeat,omitempty"`
	Plans     ConfigPlans            `yaml:"plans,omitempty"`
	Plan      string                 `yaml:"plan,omitempty"`
	// DatabaseConfig is opaque configuration owned by the external module
	// selected by DatabaseType. MySQL continues to use the historical monitor
	// fields above and rejects this section.
	DatabaseConfig ConfigDatabase `yaml:"database-config,omitempty"`
	Sinks          ConfigSinks    `yaml:"sinks,omitempty"`
	TLS            ConfigTLS      `yaml:"tls,omitempty"`

	Meta map[string]string `yaml:"meta,omitempty"`
}

func DefaultConfigMonitor 

func DefaultConfigMonitor() ConfigMonitor

func (*ConfigMonitor) ApplyDefaults 

func (c *ConfigMonitor) ApplyDefaults(b Config)

func (ConfigMonitor) EffectiveDatabaseType 

func (c ConfigMonitor) EffectiveDatabaseType() DatabaseType

EffectiveDatabaseType returns the configured database type. An omitted value retains Blip's historical MySQL behavior. Direct environment-variable interpolation is resolved before defaults are selected; database type is a structural discriminator and does not support monitor-field interpolation.

func (*ConfigMonitor) InterpolateEnvVars 

func (c *ConfigMonitor) InterpolateEnvVars()

func (*ConfigMonitor) InterpolateMonitor 

func (c *ConfigMonitor) InterpolateMonitor()

func (ConfigMonitor) Redacted 

func (c ConfigMonitor) Redacted() ConfigMonitor

Redacted returns a copy of the monitor config safe for logging.

func (ConfigMonitor) Validate 

func (c ConfigMonitor) Validate() error

type ConfigMonitorLoader 

type ConfigMonitorLoader struct {
	Files    []string                 `yaml:"files,omitempty"`
	StopLoss string                   `yaml:"stop-loss,omitempty"`
	AWS      ConfigMonitorLoaderAWS   `yaml:"aws,omitempty"`
	Local    ConfigMonitorLoaderLocal `yaml:"local,omitempty"`
}

func DefaultConfigMonitorLoader 

func DefaultConfigMonitorLoader() ConfigMonitorLoader

func (*ConfigMonitorLoader) ApplyDefaults 

func (c *ConfigMonitorLoader) ApplyDefaults(b Config)

func (*ConfigMonitorLoader) InterpolateEnvVars 

func (c *ConfigMonitorLoader) InterpolateEnvVars()

func (ConfigMonitorLoader) Validate 

func (c ConfigMonitorLoader) Validate() error

type ConfigMonitorLoaderAWS 

type ConfigMonitorLoaderAWS struct {
	Regions []string `yaml:"regions,omitempty"`
}

func (ConfigMonitorLoaderAWS) Automatic 

func (c ConfigMonitorLoaderAWS) Automatic() bool

type ConfigMonitorLoaderLocal 

type ConfigMonitorLoaderLocal struct {
	DisableAuto     bool `yaml:"disable-auto"`
	DisableAutoRoot bool `yaml:"disable-auto-root"`
}

type ConfigMySQL 

type ConfigMySQL struct {
	Hostname       string `yaml:"hostname,omitempty"`
	MyCnf          string `yaml:"mycnf,omitempty"`
	Password       string `yaml:"password,omitempty"`
	PasswordFile   string `yaml:"password-file,omitempty"`
	Socket         string `yaml:"socket,omitempty"`
	TimeoutConnect string `yaml:"timeout-connect,omitempty"`
	Username       string `yaml:"username,omitempty"`
}

ConfigMySQL are monitor defaults for each MySQL connection.

func DefaultConfigMySQL 

func DefaultConfigMySQL() ConfigMySQL

func (*ConfigMySQL) ApplyDefaults 

func (c *ConfigMySQL) ApplyDefaults(b Config)

func (*ConfigMySQL) InterpolateEnvVars 

func (c *ConfigMySQL) InterpolateEnvVars()

func (*ConfigMySQL) InterpolateMonitor 

func (c *ConfigMySQL) InterpolateMonitor(m *ConfigMonitor)

func (ConfigMySQL) Redacted 

func (c ConfigMySQL) Redacted() string

func (ConfigMySQL) Validate 

func (c ConfigMySQL) Validate() error

type ConfigPlanChange 

type ConfigPlanChange struct {
	Offline  ConfigStatePlan `yaml:"offline,omitempty"`
	Standby  ConfigStatePlan `yaml:"standby,omitempty"`
	ReadOnly ConfigStatePlan `yaml:"read-only,omitempty"`
	Active   ConfigStatePlan `yaml:"active,omitempty"`
}

func (*ConfigPlanChange) ApplyDefaults 

func (c *ConfigPlanChange) ApplyDefaults(b Config)

func (ConfigPlanChange) Enabled 

func (c ConfigPlanChange) Enabled() bool

func (*ConfigPlanChange) InterpolateEnvVars 

func (c *ConfigPlanChange) InterpolateEnvVars()

func (*ConfigPlanChange) InterpolateMonitor 

func (c *ConfigPlanChange) InterpolateMonitor(m *ConfigMonitor)

type ConfigPlans 

type ConfigPlans struct {
	Files               []string         `yaml:"files,omitempty"`
	Table               string           `yaml:"table,omitempty"`
	Monitor             *ConfigMonitor   `yaml:"monitor,omitempty"`
	Change              ConfigPlanChange `yaml:"change,omitempty"`
	DisableDefaultPlans bool             `yaml:"disable-default-plans"`
}

func DefaultConfigPlans 

func DefaultConfigPlans() ConfigPlans

func (*ConfigPlans) ApplyDefaults 

func (c *ConfigPlans) ApplyDefaults(b Config)

func (*ConfigPlans) InterpolateEnvVars 

func (c *ConfigPlans) InterpolateEnvVars()

func (*ConfigPlans) InterpolateMonitor 

func (c *ConfigPlans) InterpolateMonitor(m *ConfigMonitor)

func (ConfigPlans) Validate 

func (c ConfigPlans) Validate() error

type ConfigSinks 

type ConfigSinks map[string]map[string]string

func DefaultConfigSinks 

func DefaultConfigSinks() ConfigSinks

func (ConfigSinks) ApplyDefaults 

func (c ConfigSinks) ApplyDefaults(b Config)

func (ConfigSinks) InterpolateEnvVars 

func (c ConfigSinks) InterpolateEnvVars()

func (ConfigSinks) InterpolateMonitor 

func (c ConfigSinks) InterpolateMonitor(m *ConfigMonitor)

func (ConfigSinks) Validate 

func (c ConfigSinks) Validate() error

type ConfigStatePlan 

type ConfigStatePlan struct {
	After string `yaml:"after,omitempty"`
	Plan  string `yaml:"plan,omitempty"`
}

type ConfigTLS 

type ConfigTLS struct {
	CA         string `yaml:"ca,omitempty"`   // ssl-ca
	Cert       string `yaml:"cert,omitempty"` // ssl-cert
	Key        string `yaml:"key,omitempty"`  // ssl-key
	SkipVerify *bool  `yaml:"skip-verify,omitempty"`
	Disable    *bool  `yaml:"disable,omitempty"`

	// ssl-mode from a my.cnf (see dbconn.ParseMyCnf)
	MySQLMode string `yaml:"-"`
}

func DefaultConfigTLS 

func DefaultConfigTLS() ConfigTLS

func (*ConfigTLS) ApplyDefaults 

func (c *ConfigTLS) ApplyDefaults(b Config)

func (*ConfigTLS) InterpolateEnvVars 

func (c *ConfigTLS) InterpolateEnvVars()

func (*ConfigTLS) InterpolateMonitor 

func (c *ConfigTLS) InterpolateMonitor(m *ConfigMonitor)

func (ConfigTLS) LoadTLS 

func (c ConfigTLS) LoadTLS(server string) (*tls.Config, error)

Create tls.Config from the Blip TLS config settings.

func (ConfigTLS) Set 

func (c ConfigTLS) Set() bool

Set return true if TLS is not disabled and at least one file is specified. If not set, Blip ignores the TLS config. If set, Blip validates, loads, and registers the TLS config.

func (ConfigTLS) Validate 

func (c ConfigTLS) Validate() error

type DatabaseModule 

type DatabaseModule interface {
	DatabaseType() DatabaseType
	ValidateConfig(ConfigMonitor) error
}

DatabaseModule validates configuration for one external database type. Modules register before server boot. MySQL is built into Blip and does not use this interface.

type DatabaseType 

type DatabaseType string

DatabaseType identifies the database engine used by one monitor. 

const (
	// DatabaseTypeMySQL is Blip's built-in database type. An omitted monitor
	// database type retains this historical behavior.
	DatabaseTypeMySQL DatabaseType = "mysql"

	// DatabaseTypeAny declares that a collector is database-neutral. It is a
	// collector compatibility marker, not a valid monitor database type.
	DatabaseTypeAny DatabaseType = "*"
)

type DbCredentials 

type DbCredentials struct {
	Username string
	Password string
	TLS      ConfigTLS
}

DbCredentials are database credentials parsed or loaded for a connection.

type DbFactory 

type DbFactory interface {
	Make(ConfigMonitor) (*sql.DB, string, error)
}

type DbProvider 

type DbProvider interface {
	Primary() *sql.DB
	Close() error
}

DbProvider owns the database connections associated with one monitor. Primary returns the connection used by existing Blip subsystems and collectors. Close releases the primary connection and any additional database-specific resources owned by the provider.

type DbProviderFactory 

type DbProviderFactory interface {
	DbFactory
	MakeProvider(ConfigMonitor) (DbProvider, string, error)
}

DbProviderFactory is an optional DbFactory capability for database engines that need to own more than one connection pool per monitor. Blip preserves the existing DbFactory.Make path for factories that do not implement it.

type Domain 

type Domain struct {
	Name    string            `yaml:"-"`
	Metrics []string          `yaml:"metrics,omitempty"`
	Options map[string]string `yaml:"options,omitempty"`
	Errors  map[string]string `yaml:"errors,omitempty"`
}

Domain is one metric domain for collecting related metrics.

type Env 

type Env struct {
	Args []string
	Env  []string
}

Env is the startup environment: command line args and environment variables. This is mostly used for testing to override the defaults.

type Factories 

type Factories struct {
	AWSConfig  AWSConfigFactory
	DbConn     DbFactory
	HTTPClient HTTPClientFactory
}

Factories are interfaces that override certain object creation of Blip. Factories are optional, but if specified the override the built-in factories.

type HTTPClientFactory 

type HTTPClientFactory interface {
	MakeForSink(sinkName, monitorId string, opts, tags map[string]string) (*http.Client, error)
}

type Level 

type Level struct {
	Name    string            `yaml:"-"`
	Freq    string            `yaml:"freq"`
	Collect map[string]Domain `yaml:"collect"`
}

Level is one collection frequency in a plan.

type MetricValue 

type MetricValue struct {
	// Name is the domain-specific metric name, like threads_running from the
	// status.global collector. Names are lowercase but otherwise not modified
	// (for example, hyphens and underscores are not changed).
	Name string

	// Value is the value of the metric. String values are not supported.
	// Boolean values are reported as 0 and 1.
	Value float64

	// Type is the metric type: GAUGE, CUMULATIVE_COUNTER, and other const.
	Type byte

	// Group is the set of name-value pairs that determine the group to which
	// the metric value belongs. Only certain domains group metrics.
	Group map[string]string

	// Meta is optional key-value pairs that annotate or describe the metric value.
	Meta map[string]string
}

MetricValue is one metric and its name, type, value, and tags. Tags are optional; the other fields are required and always set. This is the lowest-level data struct: a Collector reports metric values, which the monitor.Engine organize into Metrics by adding the appropriate metadata.

type Metrics 

type Metrics struct {
	Begin     time.Time                // when collection started
	End       time.Time                // when collection completed
	MonitorId string                   // ID of monitor
	Plan      string                   // plan name
	Level     string                   // level name
	Interval  uint                     // interval number
	State     string                   // state of monitor
	Values    map[string][]MetricValue // keyed on domain
}

Metrics are metrics collected for one plan level, from one monitor.

func (*Metrics) String 

func (m *Metrics) String() string

type PasswordSecretParser 

type PasswordSecretParser func(context.Context, ConfigMonitor, []byte, *DbCredentials) error

PasswordSecretParser maps an AWS Secrets Manager payload to database credentials. The DbCredentials argument is pre-populated with config defaults and can be modified by the parser. The payload is the raw SecretString or SecretBinary value.

type Plan 

type Plan struct {
	// Name is the name of the plan (required).
	//
	// When loaded from config.plans.files, Name is the exact name of the config.
	// The first file is the default plan if config.plan.default is not specified.
	//
	// When loaded from a config.plans.table, Name is the name column. The name
	// column cannot be NULL. The plan table is ordered by name (ascending) and
	// the first plan is the default if config.plan.default is not specified.
	//
	// config.plan.adjust.readonly and .active refer to Name.
	Name string

	// Levels are the collection frequencies that constitue the plan (required).
	Levels map[string]Level

	// MonitorId is the optional monitorId column from a plan table.
	//
	// When default plans are loaded from a table (config.plans.table),
	// the talbe is not filtered; all plans in the table are loaded.
	//
	// When a monitor (M) loads plans from a table (config.monitors.plans.table),
	// the table is filtered: WHERE monitorId = config.monitors.M.id.
	MonitorId string `yaml:"-"`

	// Source of plan: file name, table name, "plugin", or "blip" (internal plans).
	Source string `yaml:"-"`
}

Plan represents different levels of metrics collection.

func (Plan) Freq 

func (p Plan) Freq() (time.Duration, map[string]time.Duration)

func (*Plan) InterpolateEnvVars 

func (p *Plan) InterpolateEnvVars()

func (*Plan) InterpolateMonitor 

func (p *Plan) InterpolateMonitor(mon *ConfigMonitor)

func (Plan) Validate 

func (p Plan) Validate() error

type Plugins 

type Plugins struct {
	// LoadConfig loads the Blip config on startup. It's passed the Blip default
	// config that should be applied like:
	//
	//   mycfg.ApplyDefaults(def.DefaultConfig())
	//
	// mycfg is the custom config loaded by the plugin, and def is the default
	// config passed to the plugin. Alternatively, the plugin can set values in
	// def (without unsetting default values). Without defaults, Blip might not
	// work as expected.
	//
	// Do not call InterpolateEnvVars. Blip calls that after loading the config.
	LoadConfig func(Config) (Config, error)

	// LoadMonitors loads monitors on startup and reloads them on POST /monitors/reload.
	LoadMonitors func(Config) ([]ConfigMonitor, error)

	// LoadPlans loads plans on startup.
	LoadPlans func(ConfigPlans) ([]Plan, error)

	// ModifyDB modifies the *sql.DB connection pool. Use with caution.
	ModifyDB func(*sql.DB, string)

	// ParsePasswordSecret maps an AWS Secrets Manager payload to database credentials.
	// If nil, Blip uses DefaultPasswordSecretParser.
	ParsePasswordSecret PasswordSecretParser

	// StartMonitor allows a monitor to start by returning true. Else the monitor
	// is loaded but not started. This is used to load all monitors but start only
	// certain monitors.
	StartMonitor func(ConfigMonitor) bool

	// TransformMetrics transforms metrics before they are sent to sinks.
	// If it returns an error, all metrics are dropped (not sent). The function
	// is shared and called concurrently by all monitors. Use Metrics.MonitorId
	// to determine the source of the metrics. Metrics are ordered by Metrics.Interval
	// should not be reordered if delta counters are used (doing so will result
	// in negative or incorrect values). Otherwise, the slice of metrics can be modified.
	TransformMetrics func([]*Metrics) error
}

Plugins are function callbacks that override specific functionality of Blip. Plugins are optional, but if specified it overrides the built-in functionality.

type Sink 

type Sink interface {
	// Send sends metrics to the sink. It must respect the context timeout, if any.
	Send(context.Context, *Metrics) error

	// Name returns the sink name (lowercase). It is used for monitor status to
	// report sink errors, if any.
	Name() string
}

Sink sends metrics to an external destination.

type SinkFactory 

type SinkFactory interface {
	Make(SinkFactoryArgs) (Sink, error)
}

SinkFactory makes a Sink for a monitor.

type SinkFactoryArgs 

type SinkFactoryArgs struct {
	SinkName  string            // config.monitor.sinks.name (required)
	MonitorId string            // config.monitor.id (required)
	Options   map[string]string // config.monitor.sinks.name: key-value pairs
	Tags      map[string]string // config.monitor.tags
}

Source Files

View all Source files

Directories

Path Synopsis
bin
blip command
Package credentials constructs engine-neutral database credential callbacks.
 Package credentials constructs engine-neutral database credential callbacks.
Package dbconn provides a Factory that makes *sql.DB connections to MySQL.
 Package dbconn provides a Factory that makes *sql.DB connections to MySQL.
Package event provides a simple event stream in lieu of standard logging.
 Package event provides a simple event stream in lieu of standard logging.
autoinc
aws.rds
error
innodb
innodb.buffer-pool
percona
query.response-time
repl
repl.lag
size.binlog
size.database
size.table
status.global
Package statusglobal provides the status.global metric domain collector.
 Package statusglobal provides the status.global metric domain collector.
stmt.current
tls
trx
var.global
wait.io.table
Package monitor provides core Blip components that, together, monitor one database target.
 Package monitor provides core Blip components that, together, monitor one database target.
Package plan provides the Loader singleton that loads metric collection plans.
 Package plan provides the Loader singleton that loads metric collection plans.
default
Package prom provides Prometheus emulation and translation.
 Package prom provides Prometheus emulation and translation.
tr
Package server provides the core runtime for Blip.
 Package server provides the core runtime for Blip.
tr
Package status provides real-time instantaneous status of every Blip component.
 Package status provides real-time instantaneous status of every Blip component.
Package test provides helper functions for tests.
 Package test provides helper functions for tests.
mock

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.