metrics

Documentation

Index

• Constants
• Variables
• func RegisterAcquisitionMetric(metricName string)
• func RegisterMetrics(metricsLevel MetricsLevelConfig) error
• type AcquisitionMetricsLevel
• type MetricsLevelConfig

Constants

const AppsecBlockCounterMetricName = "cs_appsec_block_total"

const AppsecGlobalParsingHistogramMetricName = "cs_appsec_parsing_time_seconds"

const AppsecInbandParsingHistogramMetricName = "cs_appsec_inband_parsing_time_seconds"

const AppsecOutbandParsingHistogramMetricName = "cs_appsec_outband_parsing_time_seconds"

const AppsecReqCounterMetricName = "cs_appsec_reqs_total"

const AppsecRuleHitsMetricName = "cs_appsec_rule_hits"

const BucketPouredMetricName = "cs_bucket_poured_total"

const BucketsCanceledMetricName = "cs_bucket_canceled_total"

const BucketsCurrentCountMetricName = "cs_buckets"

const BucketsInstantiationMetricName = "cs_bucket_instantiation_total"

const BucketsOverflowMetricName = "cs_bucket_overflowed_total"

const BucketsUnderflowMetricName = "cs_bucket_underflowed_total"

const CacheMetricName = "cs_cache_size"

const CloudWatchDatasourceLinesReadMetricName = "cs_cloudwatch_stream_hits_total"

const CloudWatchDatasourceOpenedStreamsMetricName = "cs_cloudwatch_openstreams_total"

const DockerDatasourceLinesReadMetricName = "cs_dockersource_hits_total"

const FileDatasourceLinesReadMetricName = "cs_filesource_hits_total"

const GlobalActiveDecisionsMetricName = "cs_active_decisions"

const GlobalAlertsMetricName = "cs_alerts"

const GlobalBucketPourKoMetricName = "cs_bucket_pour_ko_total"

const GlobalBucketPourOkMetricName = "cs_bucket_pour_ok_total"

const GlobalCsInfoMetricName = "cs_info"

const GlobalParserHitsKoMetricName = "cs_parser_hits_ko_total"

const GlobalParserHitsMetricName = "cs_parser_hits_total"

const GlobalParserHitsOkMetricName = "cs_parser_hits_ok_total"

const GlobalParsingHistogramMetricName = "cs_parsing_time_seconds"

const GlobalPourHistogramMetricName = "cs_bucket_pour_seconds"

const HTTPDataSourceLinesReadMetricName = "cs_httpsource_hits_total"

const JournalCtlDataSourceLinesReadMetricName = "cs_journalctlsource_hits_total"

const K8SAuditDataSourceEventCountMetricName = "cs_k8sauditsource_hits_total"

const K8SAuditDataSourceRequestCountMetricName = "cs_k8sauditsource_requests_total"

const KafkaDataSourceLinesReadMetricName = "cs_kafkasource_hits_total"

const KinesisDataSourceLinesReadMetricName = "cs_kinesis_stream_hits_total"

const KinesisDataSourceLinesReadShardsMetricName = "cs_kinesis_shards_hits_total"

const LapiBouncerHitsMetricName = "cs_lapi_bouncer_requests_total"

hits per bouncer

const LapiMachineHitsMetricName = "cs_lapi_machine_requests_total"

hits per machine

const LapiNilDecisionsMetricName = "cs_lapi_decisions_ko_total"

keep track of the number of calls (per bouncer) that lead to nil/non-nil responses.

while it's not exact, it's a good way to know - when you have a rutpure bouncer - what is the rate of ok/ko answers you got from lapi

const LapiNonNilDecisionsMetricName = "cs_lapi_decisions_ok_total"

hits per bouncer

const LapiResponseTimeMetricName = "cs_lapi_request_duration_seconds"

const LapiRouteHitsMetricName = "cs_lapi_route_requests_total"

const LokiDataSourceLinesReadMetricName = "cs_lokisource_hits_total"

const NodesHitsKoMetricName = "cs_node_hits_ko_total"

const NodesHitsMetricName = "cs_node_hits_total"

const NodesHitsOkMetricName = "cs_node_hits_ok_total"

const NodesWlHitsMetricName = "cs_node_wl_hits_total"

const NodesWlHitsOkMetricName = "cs_node_wl_hits_ok_total"

const RegexpCacheMetricName = "cs_regexp_cache_size"

const S3DataSourceLinesReadMetricName = "cs_s3_hits_total"

const S3DataSourceObjectsReadMetricName = "cs_s3_objects_total"

const S3DataSourceSQSMessagesReceivedMetricName = "cs_s3_sqs_messages_total"

const SyslogDataSourceLinesParsedMetricName = "cs_syslogsource_parsed_total"

const SyslogDataSourceLinesReceivedMetricName = "cs_syslogsource_hits_total"

const VictorialogsDataSourceLinesReadMetricName = "cs_victorialogssource_hits_total"

const WineventlogDataSourceLinesReadMetricName = "cs_winevtlogsource_hits_total"

Variables

var AcquisitionMetricsNames = []string{}

var AppsecBlockCounter = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: AppsecBlockCounterMetricName,
		Help: "Total events blocked by the Application Security Engine.",
	},
	[]string{"source", "appsec_engine"},
)

var AppsecGlobalParsingHistogram = prometheus.NewHistogramVec(
	prometheus.HistogramOpts{
		Help:    "Time spent processing a request by the Application Security Engine.",
		Name:    AppsecGlobalParsingHistogramMetricName,
		Buckets: []float64{0.0001, 0.00025, 0.0005, 0.001, 0.0025, 0.0050, 0.01, 0.025, 0.05, 0.1, 0.25},
	},
	[]string{"source", "appsec_engine"},
)

var AppsecInbandParsingHistogram = prometheus.NewHistogramVec(
	prometheus.HistogramOpts{
		Help:    "Time spent processing a request by the inband Application Security Engine.",
		Name:    AppsecInbandParsingHistogramMetricName,
		Buckets: []float64{0.0001, 0.00025, 0.0005, 0.001, 0.0025, 0.0050, 0.01, 0.025, 0.05, 0.1, 0.25},
	},
	[]string{"source", "appsec_engine"},
)

var AppsecOutbandParsingHistogram = prometheus.NewHistogramVec(
	prometheus.HistogramOpts{
		Help:    "Time spent processing a request by the Application Security Engine.",
		Name:    AppsecOutbandParsingHistogramMetricName,
		Buckets: []float64{0.0001, 0.00025, 0.0005, 0.001, 0.0025, 0.0050, 0.01, 0.025, 0.05, 0.1, 0.25},
	},
	[]string{"source", "appsec_engine"},
)

var AppsecReqCounter = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: AppsecReqCounterMetricName,
		Help: "Total events processed by the Application Security Engine.",
	},
	[]string{"source", "appsec_engine"},
)

var AppsecRuleHits = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: AppsecRuleHitsMetricName,
		Help: "Count of triggered rule, by rule_name, type (inband/outofband), appsec_engine and source",
	},
	[]string{"rule_name", "type", "appsec_engine", "source"},
)

var BucketsCanceled = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: BucketsCanceledMetricName,
		Help: "Total buckets canceled.",
	},
	[]string{"name"},
)

var BucketsCurrentCount = prometheus.NewGaugeVec(
	prometheus.GaugeOpts{
		Name: BucketsCurrentCountMetricName,
		Help: "Number of buckets that currently exist.",
	},
	[]string{"name"},
)

var BucketsInstantiation = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: BucketsInstantiationMetricName,
		Help: "Total buckets were instantiated.",
	},
	[]string{"name"},
)

var BucketsOverflow = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: BucketsOverflowMetricName,
		Help: "Total buckets overflowed.",
	},
	[]string{"name"},
)

var BucketsPour = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: BucketPouredMetricName,
		Help: "Total events were poured in bucket.",
	},
	[]string{"source", "type", "name"},
)

var BucketsUnderflow = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: BucketsUnderflowMetricName,
		Help: "Total buckets underflowed.",
	},
	[]string{"name"},
)

var CacheMetrics = prometheus.NewGaugeVec(
	prometheus.GaugeOpts{
		Name: CacheMetricName,
		Help: "Entries per cache.",
	},
	[]string{"name", "type"},
)

var CloudWatchDatasourceLinesRead = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: CloudWatchDatasourceLinesReadMetricName,
		Help: "Number of event read from stream.",
	},
	[]string{"group", "stream", "datasource_type", "acquis_type"},
)

var CloudWatchDatasourceOpenedStreams = prometheus.NewGaugeVec(
	prometheus.GaugeOpts{
		Name: CloudWatchDatasourceOpenedStreamsMetricName,
		Help: "Number of opened stream within group.",
	},
	[]string{"group"},
)

var DockerDatasourceLinesRead = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: DockerDatasourceLinesReadMetricName,
		Help: "Total lines that were read.",
	},
	[]string{"source", "datasource_type", "acquis_type"})

var ErrInvalidMetricsLevel = errors.New("invalid metrics level")

var FileDatasourceLinesRead = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: FileDatasourceLinesReadMetricName,
		Help: "Total lines that were read.",
	},
	[]string{"source", "datasource_type", "acquis_type"},
)

var GlobalActiveDecisions = prometheus.NewGaugeVec(
	prometheus.GaugeOpts{
		Name: GlobalActiveDecisionsMetricName,
		Help: "Number of active decisions.",
	},
	[]string{"reason", "origin", "action"},
)

var GlobalAlerts = prometheus.NewGaugeVec(
	prometheus.GaugeOpts{
		Name: GlobalAlertsMetricName,
		Help: "Number of alerts (excluding CAPI).",
	},
	[]string{"reason"},
)

var GlobalBucketPourKo = prometheus.NewCounter(
	prometheus.CounterOpts{
		Name: GlobalBucketPourKoMetricName,
		Help: "Total events were not poured in a bucket.",
	},
)

var GlobalBucketPourOk = prometheus.NewCounter(
	prometheus.CounterOpts{
		Name: GlobalBucketPourOkMetricName,
		Help: "Total events were poured in at least one bucket.",
	},
)

var GlobalCsInfo = prometheus.NewGauge(
	prometheus.GaugeOpts{
		Name:        GlobalCsInfoMetricName,
		Help:        "Information about Crowdsec.",
		ConstLabels: prometheus.Labels{"version": version.String()},
	},
)

var GlobalParserHits = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: GlobalParserHitsMetricName,
		Help: "Total events entered the parser.",
	},
	[]string{"source", "type"},
)

var GlobalParserHitsKo = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: GlobalParserHitsKoMetricName,
		Help: "Total events were unsuccessfully parsed.",
	},
	[]string{"source", "type", "acquis_type"},
)

var GlobalParserHitsOk = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: GlobalParserHitsOkMetricName,
		Help: "Total events were successfully parsed.",
	},
	[]string{"source", "type", "acquis_type"},
)

var GlobalParsingHistogram = prometheus.NewHistogramVec(
	prometheus.HistogramOpts{
		Help:    "Time spent parsing a line",
		Name:    GlobalParsingHistogramMetricName,
		Buckets: []float64{0.0005, 0.001, 0.0015, 0.002, 0.0025, 0.003, 0.004, 0.005, 0.0075, 0.01},
	},
	[]string{"type", "source"},
)

var GlobalPourHistogram = prometheus.NewHistogramVec(
	prometheus.HistogramOpts{
		Name:    GlobalPourHistogramMetricName,
		Help:    "Time spent pouring an event to buckets.",
		Buckets: []float64{0.001, 0.002, 0.005, 0.01, 0.015, 0.02, 0.03, 0.04, 0.05},
	},
	[]string{"type", "source"},
)

var HTTPDataSourceLinesRead = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: HTTPDataSourceLinesReadMetricName,
		Help: "Total lines that were read from http source",
	},
	[]string{"path", "src", "datasource_type", "acquis_type"})

var JournalCtlDataSourceLinesRead = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: JournalCtlDataSourceLinesReadMetricName,
		Help: "Total lines that were read.",
	},
	[]string{"source", "datasource_type", "acquis_type"})

var K8SAuditDataSourceEventCount = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: K8SAuditDataSourceEventCountMetricName,
		Help: "Total number of events received by k8s-audit source",
	},
	[]string{"source", "datasource_type", "acquis_type"})

var K8SAuditDataSourceRequestCount = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: K8SAuditDataSourceRequestCountMetricName,
		Help: "Total number of requests received",
	},
	[]string{"source"})

var KafkaDataSourceLinesRead = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: KafkaDataSourceLinesReadMetricName,
		Help: "Total lines that were read from topic",
	},
	[]string{"topic", "datasource_type", "acquis_type"})

var KinesisDataSourceLinesRead = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: KinesisDataSourceLinesReadMetricName,
		Help: "Number of event read per stream.",
	},
	[]string{"stream", "datasource_type", "acquis_type"},
)

var KinesisDataSourceLinesReadShards = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: KinesisDataSourceLinesReadShardsMetricName,
		Help: "Number of event read per shards.",
	},
	[]string{"stream", "shard"},
)

var LapiBouncerHits = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: LapiBouncerHitsMetricName,
		Help: "Number of calls to each route per method grouped by bouncers.",
	},
	[]string{"bouncer", "route", "method"},
)

var LapiMachineHits = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: LapiMachineHitsMetricName,
		Help: "Number of calls to each route per method grouped by machines.",
	},
	[]string{"machine", "route", "method"},
)

var LapiNilDecisions = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: LapiNilDecisionsMetricName,
		Help: "Number of calls to /decisions that returned nil result.",
	},
	[]string{"bouncer"},
)

var LapiNonNilDecisions = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: LapiNonNilDecisionsMetricName,
		Help: "Number of calls to /decisions that returned non-nil result.",
	},
	[]string{"bouncer"},
)

var LapiResponseTime = prometheus.NewHistogramVec(
	prometheus.HistogramOpts{
		Name:    LapiResponseTimeMetricName,
		Help:    "Response time of LAPI",
		Buckets: []float64{0.005, 0.01, 0.025, 0.05, 0.075, 0.1, 0.2, 0.3, 0.4, 0.5, 0.75, 1},
	},
	[]string{"endpoint", "method"},
)

var LapiRouteHits = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: LapiRouteHitsMetricName,
		Help: "Number of calls to each route per method.",
	},
	[]string{"route", "method"},
)

var LokiDataSourceLinesRead = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: LokiDataSourceLinesReadMetricName,
		Help: "Total lines that were read.",
	},
	[]string{"source", "datasource_type", "acquis_type"})

var NodesHits = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: NodesHitsMetricName,
		Help: "Total events entered node.",
	},
	[]string{"source", "type", "name", "stage", "acquis_type"},
)

var NodesHitsKo = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: NodesHitsKoMetricName,
		Help: "Total events unsuccessfully exited node.",
	},
	[]string{"source", "type", "name", "stage", "acquis_type"},
)

var NodesHitsOk = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: NodesHitsOkMetricName,
		Help: "Total events successfully exited node.",
	},
	[]string{"source", "type", "name", "stage", "acquis_type"},
)

var NodesWlHits = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: NodesWlHitsMetricName,
		Help: "Total events processed by whitelist node.",
	},
	[]string{"source", "type", "name", "reason", "stage", "acquis_type"},
)

var NodesWlHitsOk = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: NodesWlHitsOkMetricName,
		Help: "Total events successfully whitelisted by node.",
	},
	[]string{"source", "type", "name", "reason", "stage", "acquis_type"},
)

var RegexpCacheMetrics = prometheus.NewGaugeVec(
	prometheus.GaugeOpts{
		Name: RegexpCacheMetricName,
		Help: "Entries per regexp cache.",
	},
	[]string{"name"},
)

var S3DataSourceLinesRead = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: S3DataSourceLinesReadMetricName,
		Help: "Number of events read per bucket.",
	},
	[]string{"bucket", "datasource_type", "acquis_type"},
)

var S3DataSourceObjectsRead = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: S3DataSourceObjectsReadMetricName,
		Help: "Number of objects read per bucket.",
	},
	[]string{"bucket"},
)

var S3DataSourceSQSMessagesReceived = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: S3DataSourceSQSMessagesReceivedMetricName,
		Help: "Number of SQS messages received per queue.",
	},
	[]string{"queue"},
)

var SyslogDataSourceLinesParsed = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: SyslogDataSourceLinesParsedMetricName,
		Help: "Total lines that were successfully parsed",
	},
	[]string{"source", "type", "datasource_type", "acquis_type"})

var SyslogDataSourceLinesReceived = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: SyslogDataSourceLinesReceivedMetricName,
		Help: "Total lines that were received.",
	},
	[]string{"source", "datasource_type", "acquis_type"})

var VictorialogsDataSourceLinesRead = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: VictorialogsDataSourceLinesReadMetricName,
		Help: "Total lines that were read.",
	},
	[]string{"source", "datasource_type", "acquis_type"})

var WineventlogDataSourceLinesRead = prometheus.NewCounterVec(
	prometheus.CounterOpts{
		Name: WineventlogDataSourceLinesReadMetricName,
		Help: "Total event that were read.",
	},
	[]string{"source", "datasource_type", "acquis_type"})

Functions

func RegisterAcquisitionMetric

func RegisterAcquisitionMetric(metricName string)

func RegisterMetrics

func RegisterMetrics(metricsLevel MetricsLevelConfig) error

Types

type AcquisitionMetricsLevel

type AcquisitionMetricsLevel int

const (
	AcquisitionMetricsLevelNone       AcquisitionMetricsLevel       = iota // No metrics
	AcquisitionMetricsLevelAggregated                                      // Aggregated metrics
	AcquisitionMetricsLevelFull                                            // Full metrics
	AcquisitionMetricsLevelDefault    = AcquisitionMetricsLevelFull        // Default metrics level
)

type MetricsLevelConfig

type MetricsLevelConfig string

const (
	MetricsLevelNone       MetricsLevelConfig = "none"
	MetricsLevelAggregated MetricsLevelConfig = "aggregated"
	MetricsLevelFull       MetricsLevelConfig = "full"
	// MetricsLevelDefault is the default metrics level.
	MetricsLevelDefault MetricsLevelConfig = MetricsLevelFull
)