metrics

var (

	// ProfilesSyncFullTimeouts is a gauge with the total number of timeout
	// errors occurred during full profiles sync.
	ProfilesSyncFullTimeouts = profilesSyncTimeouts.With(prometheus.Labels{
		"is_full_sync": "1",
	})

	// ProfilesSyncPartTimeouts is a gauge with the total number of timeout
	// errors occurred during partial profiles sync.
	ProfilesSyncPartTimeouts = profilesSyncTimeouts.With(prometheus.Labels{
		"is_full_sync": "0",
	})
)

var (
	// BillStatBufSize is a gauge with the total count of records in the local
	// billing statistics database.
	BillStatBufSize = promauto.NewGauge(prometheus.GaugeOpts{
		Name:      "buf_size",
		Namespace: namespace,
		Subsystem: subsystemBillStat,
		Help:      "Count of records in the local billstat DB.",
	})

	// BillStatUploadStatus is a gauge with the status of the last billing
	// statistics upload.
	BillStatUploadStatus = promauto.NewGauge(prometheus.GaugeOpts{
		Name:      "bill_stat_upload_status",
		Namespace: namespace,
		Subsystem: subsystemBillStat,
		Help:      "Status of the last billstat upload.",
	})

	// BillStatUploadTimestamp is a gauge with the timestamp of the last billing
	// statistics upload.
	BillStatUploadTimestamp = promauto.NewGauge(prometheus.GaugeOpts{
		Name:      "bill_stat_upload_timestamp",
		Namespace: namespace,
		Subsystem: subsystemBillStat,
		Help:      "Time when the billing statistics were uploaded last time.",
	})

	// BillStatUploadDuration is a histogram with the duration of the billing
	// statistics upload.
	BillStatUploadDuration = promauto.NewHistogram(prometheus.HistogramOpts{
		Name:      "bill_stat_upload_duration",
		Namespace: namespace,
		Subsystem: subsystemBillStat,
		Help:      "Time elapsed on uploading billing statistics to the backend.",
		Buckets:   []float64{0.001, 0.01, 0.1, 1, 5, 10, 30, 60, 120},
	})
)

var (

	// BindToDeviceUnknownTCPRequestsTotal is the total counter of DNS requests
	// over TCP to unknown local addresses.
	BindToDeviceUnknownTCPRequestsTotal = bindToDeviceUnknownRequestsTotal.With(prometheus.Labels{
		"proto": "tcp",
	})

	// BindToDeviceUnknownUDPRequestsTotal is the total counter of DNS requests
	// over UDP to unknown local addresses.
	BindToDeviceUnknownUDPRequestsTotal = bindToDeviceUnknownRequestsTotal.With(prometheus.Labels{
		"proto": "udp",
	})
)

var (
	// BindToDeviceTCPConnsChanSize is a gauge with the current number of TCP
	// connections in the buffer of the channel by each subnet.
	BindToDeviceTCPConnsChanSize = promauto.NewGaugeVec(prometheus.GaugeOpts{
		Name:      "tcp_conns_chan_size",
		Namespace: namespace,
		Subsystem: subsystemBindToDevice,
		Help:      "The current number of TCP connections in the channel.",
	}, []string{"subnet"})

	// BindToDeviceUDPSessionsChanSize is a gauge with the current number of UDP
	// sessions in the buffer of the channel by each subnet.
	BindToDeviceUDPSessionsChanSize = promauto.NewGaugeVec(prometheus.GaugeOpts{
		Name:      "udp_sessions_chan_size",
		Namespace: namespace,
		Subsystem: subsystemBindToDevice,
		Help:      "The current number of UDP sessions in the channel.",
	}, []string{"subnet"})

	// BindToDeviceUDPWriteRequestsChanSize is a gauge with the current number
	// of UDP write requests in the buffer of the channel by each subnet.
	BindToDeviceUDPWriteRequestsChanSize = promauto.NewGaugeVec(prometheus.GaugeOpts{
		Name:      "udp_write_requests_chan_size",
		Namespace: namespace,
		Subsystem: subsystemBindToDevice,
		Help:      "The current number of UDP write requests in the channel.",
	}, []string{"subnet"})
)

var (
	// ConsulAllowlistSize is a gauge with the number of records in the
	// ratelimit allowlist loaded from Consul.
	ConsulAllowlistSize = promauto.NewGauge(prometheus.GaugeOpts{
		Subsystem: subsystemConsul,
		Namespace: namespace,
		Name:      "allowlist_size",
		Help:      "Size of the ratelimit allowlist loaded from Consul.",
	})
	// ConsulAllowlistUpdateStatus is a gauge with the status of the last
	// ratelimit allowlist update.  1 means success.
	ConsulAllowlistUpdateStatus = promauto.NewGauge(prometheus.GaugeOpts{
		Subsystem: subsystemConsul,
		Namespace: namespace,
		Name:      "allowlist_update_status",
		Help:      "Status of the last ratelimit allowlist update. 1 means success.",
	})
	// ConsulAllowlistUpdateTime is a gauge with the timestamp of the last
	// ratelimit allowlist update.
	ConsulAllowlistUpdateTime = promauto.NewGauge(prometheus.GaugeOpts{
		Subsystem: subsystemConsul,
		Namespace: namespace,
		Name:      "allowlist_update_timestamp",
		Help:      "Timestamp of the last ratelimit allowlist update.",
	})
)

var (
	// DNSDBBufferSize is a gauge with the total count of records in the
	// in-memory temporary buffer.
	DNSDBBufferSize = promauto.NewGauge(prometheus.GaugeOpts{
		Name:      "buffer_size",
		Namespace: namespace,
		Subsystem: subsystemDNSDB,
		Help:      "Count of records in the in-memory buffer.",
	})

	// DNSDBRotateTime is a gauge with the time when the DNSDB was rotated.
	DNSDBRotateTime = promauto.NewGauge(prometheus.GaugeOpts{
		Name:      "rotate_time",
		Namespace: namespace,
		Subsystem: subsystemDNSDB,
		Help:      "Last time when the database was rotated.",
	})

	// DNSDBSaveDuration is a histogram with the time elapsed on rotating the
	// buffer for sending over HTTP.
	DNSDBSaveDuration = promauto.NewHistogram(prometheus.HistogramOpts{
		Name:      "save_duration",
		Namespace: namespace,
		Subsystem: subsystemDNSDB,
		Help:      "Time elapsed on rotating the buffer for sending over HTTP.",
	})
)

var (

	// DNSSvcDDRRequestsTotal is a counter with total number of requests for
	// Discovery of Designated Resolvers.
	DNSSvcDDRRequestsTotal = specialRequestsTotal.With(prometheus.Labels{
		"kind": "ddr",
	})

	// DNSSvcBadResolverARPA is a counter with total number of requests for
	// malformed resolver.arpa queries.
	DNSSvcBadResolverARPA = specialRequestsTotal.With(prometheus.Labels{
		"kind": "bad_resolver_arpa",
	})

	// DNSSvcFirefoxRequestsTotal is a counter with total number of requests for
	// the domain name that Firefox uses to check if it should use its own
	// DNS-over-HTTPS settings.
	DNSSvcFirefoxRequestsTotal = specialRequestsTotal.With(prometheus.Labels{
		"kind": "firefox",
	})

	// DNSSvcApplePrivateRelayRequestsTotal is a counter with total number of
	// requests for the domain name that Apple devices use to check if Apple
	// Private Relay can be enabled.
	DNSSvcApplePrivateRelayRequestsTotal = specialRequestsTotal.With(prometheus.Labels{
		"kind": "apple_private_relay",
	})
)

var (

	// ECSNoSupportCacheSize is the gauge with the total number of items in
	// the cache for domain names that do not support ECS.
	ECSNoSupportCacheSize = ecsCacheSize.With(prometheus.Labels{
		"supports": "no",
	})

	// ECSHasSupportCacheSize is the gauge with the total number of items in
	// the cache for domain names that support ECS.
	ECSHasSupportCacheSize = ecsCacheSize.With(prometheus.Labels{
		"supports": "yes",
	})
)

var (

	// ECSCacheLookupTotalHits is a counter with the total number of ECS cache
	// hits.
	ECSCacheLookupTotalHits = ecsCacheLookups.With(prometheus.Labels{
		"hit":      "1",
		"supports": "all",
	})

	// ECSCacheLookupHasSupportHits is a counter with the number of ECS cache
	// hits for hosts that support ECS.
	ECSCacheLookupHasSupportHits = ecsCacheLookups.With(prometheus.Labels{
		"hit":      "1",
		"supports": "yes",
	})

	// ECSCacheLookupNoSupportHits is a counter with the number of ECS cache
	// hits for hosts that don't support ECS.
	ECSCacheLookupNoSupportHits = ecsCacheLookups.With(prometheus.Labels{
		"hit":      "1",
		"supports": "no",
	})

	// ECSCacheLookupTotalMisses is a counter with the total number of ECS cache
	// misses.
	ECSCacheLookupTotalMisses = ecsCacheLookups.With(prometheus.Labels{
		"hit":      "0",
		"supports": "all",
	})

	// ECSCacheLookupHasSupportMisses is a counter with the number of ECS cache
	// misses for hosts that support ECS.
	ECSCacheLookupHasSupportMisses = ecsCacheLookups.With(prometheus.Labels{
		"hit":      "0",
		"supports": "yes",
	})

	// ECSCacheLookupNoSupportMisses is a counter with the number of ECS cache
	// misses for hosts that don't support ECS.
	ECSCacheLookupNoSupportMisses = ecsCacheLookups.With(prometheus.Labels{
		"hit":      "0",
		"supports": "no",
	})
)

var (
	// FilterRulesTotal is a gauge with the number of rules loaded by each
	// filter.
	FilterRulesTotal = promauto.NewGaugeVec(prometheus.GaugeOpts{
		Name:      "rules_total",
		Subsystem: subsystemFilter,
		Namespace: namespace,
		Help:      "The number of rules loaded by filters.",
	}, []string{"filter"})

	// FilterUpdatedTime is a gauge with the last time when the filter was last
	// time updated.
	FilterUpdatedTime = promauto.NewGaugeVec(prometheus.GaugeOpts{
		Name:      "updated_time",
		Subsystem: subsystemFilter,
		Namespace: namespace,
		Help:      "Time when the filter was last time updated.",
	}, []string{"filter"})

	// FilterUpdatedStatus is a gauge with status of the last filter update.
	// "0" means error, "1" means success.
	FilterUpdatedStatus = promauto.NewGaugeVec(prometheus.GaugeOpts{
		Name:      "update_status",
		Subsystem: subsystemFilter,
		Namespace: namespace,
		Help:      "Status of the filter update. 1 means success.",
	}, []string{"filter"})

	// FilterCustomCacheLookupsHits is a counter with the total number of the
	// custom filter cache hits.
	FilterCustomCacheLookupsHits = filterCustomCacheLookups.With(prometheus.Labels{"hit": "1"})

	// FilterCustomCacheLookupsMisses is a counter with the total number of the
	// custom filter cache misses.
	FilterCustomCacheLookupsMisses = filterCustomCacheLookups.With(prometheus.Labels{"hit": "0"})
)

var (

	// HashPrefixFilterSafeBrowsingCacheSize is the gauge with the total number
	// of items in the cache for domain names for safe browsing filter.
	HashPrefixFilterSafeBrowsingCacheSize = hashPrefixFilterCacheSize.With(prometheus.Labels{
		"filter": "safe_browsing",
	})

	// HashPrefixFilterAdultBlockingCacheSize is the gauge with the total number
	// of items in the cache for domain names for adult blocking filter.
	HashPrefixFilterAdultBlockingCacheSize = hashPrefixFilterCacheSize.With(prometheus.Labels{
		"filter": "adult_blocking",
	})

	// HashPrefixFilterNewRegDomainsCacheSize is the gauge with the total number
	// of items in the cache for domain names for safe browsing newly registered
	// domains filter.
	HashPrefixFilterNewRegDomainsCacheSize = hashPrefixFilterCacheSize.With(prometheus.Labels{
		"filter": "newly_registered_domains",
	})

	// HashPrefixFilterCacheSafeBrowsingHits is a counter with the total number
	// of safe browsing filter cache hits.
	HashPrefixFilterCacheSafeBrowsingHits = hashPrefixFilterCacheLookups.With(prometheus.Labels{
		"hit":    "1",
		"filter": "safe_browsing",
	})

	// HashPrefixFilterCacheSafeBrowsingMisses is a counter with the total number
	// of safe browsing filter cache misses.
	HashPrefixFilterCacheSafeBrowsingMisses = hashPrefixFilterCacheLookups.With(prometheus.Labels{
		"hit":    "0",
		"filter": "safe_browsing",
	})

	// HashPrefixFilterCacheAdultBlockingHits is a counter with the total number
	// of adult blocking filter cache hits.
	HashPrefixFilterCacheAdultBlockingHits = hashPrefixFilterCacheLookups.With(prometheus.Labels{
		"hit":    "1",
		"filter": "adult_blocking",
	})

	// HashPrefixFilterCacheAdultBlockingMisses is a counter with the total number
	// of adult blocking filter cache misses.
	HashPrefixFilterCacheAdultBlockingMisses = hashPrefixFilterCacheLookups.With(prometheus.Labels{
		"hit":    "0",
		"filter": "adult_blocking",
	})

	// HashPrefixFilterCacheNewRegDomainsHits is a counter with the total number
	// of newly registered domains filter cache hits.
	HashPrefixFilterCacheNewRegDomainsHits = hashPrefixFilterCacheLookups.With(prometheus.Labels{
		"hit":    "1",
		"filter": "newly_registered_domains",
	})

	// HashPrefixFilterCacheNewRegDomainsMisses is a counter with the total
	// number of newly registered domains filter cache misses.
	HashPrefixFilterCacheNewRegDomainsMisses = hashPrefixFilterCacheLookups.With(prometheus.Labels{
		"hit":    "0",
		"filter": "newly_registered_domains",
	})
)

var (
	// GeoIPUpdateTime is a gauge with the timestamp of the last GeoIP database
	// update.
	GeoIPUpdateTime = promauto.NewGaugeVec(prometheus.GaugeOpts{
		Name:      "update_time",
		Subsystem: subsystemGeoIP,
		Namespace: namespace,
		Help:      "The time when the GeoIP was loaded last time.",
	}, []string{"path"})

	// GeoIPUpdateStatus is a gauge with the last GeoIP database update status.
	// 1 means success, 0 means an error occurred.
	GeoIPUpdateStatus = promauto.NewGaugeVec(prometheus.GaugeOpts{
		Name:      "update_status",
		Subsystem: subsystemGeoIP,
		Namespace: namespace,
		Help:      "Status of the last GeoIP update. 1 is okay, 0 means that something went wrong.",
	}, []string{"path"})
)

var (

	// GeoIPCacheLookupsHits is a counter with the total number of the GeoIP IP
	// cache hits.
	GeoIPCacheLookupsHits = geoIPCacheLookups.With(prometheus.Labels{"hit": "1"})

	// GeoIPCacheLookupsMisses is a counter with the total number of the GeoIP
	// IP cache misses.
	GeoIPCacheLookupsMisses = geoIPCacheLookups.With(prometheus.Labels{"hit": "0"})
)

var (

	// GeoIPHostCacheLookupsHits is a counter with the total number of the GeoIP
	// hostname cache hits.
	GeoIPHostCacheLookupsHits = geoIPHostCacheLookups.With(prometheus.Labels{"hit": "1"})

	// GeoIPHostCacheLookupsMisses is a counter with the total number of the
	// GeoIP hostname cache misses.
	GeoIPHostCacheLookupsMisses = geoIPHostCacheLookups.With(prometheus.Labels{"hit": "0"})
)

var (
	// RuleStatCacheSize is a gauge with the count of recorded rule hits not
	// yet uploaded.
	RuleStatCacheSize = promauto.NewGauge(prometheus.GaugeOpts{
		Name:      "stats_cache_size",
		Namespace: namespace,
		Subsystem: subsystemRuleStat,
		Help:      "Count of recorded rule hits not yet dumped.",
	})
	// RuleStatUploadStatus is a gauge with the status of the last stats upload.
	RuleStatUploadStatus = promauto.NewGauge(prometheus.GaugeOpts{
		Name:      "stats_upload_status",
		Namespace: namespace,
		Subsystem: subsystemRuleStat,
		Help:      "Status of the last stats upload.",
	})
	// RuleStatUploadTimestamp is a gauge with the timestamp of the last stats
	// upload.
	RuleStatUploadTimestamp = promauto.NewGauge(prometheus.GaugeOpts{
		Name:      "stats_upload_timestamp",
		Namespace: namespace,
		Subsystem: subsystemRuleStat,
		Help:      "Time when stats were uploaded last time.",
	})
)

var (
	// TLSCertificateInfo is a gauge with the authentication algorithm of
	// the certificate.
	TLSCertificateInfo = promauto.NewGaugeVec(prometheus.GaugeOpts{
		Name:      "cert_info",
		Namespace: namespace,
		Subsystem: subsystemTLS,
		Help:      "Authentication algorithm and other information about the certificate.",
	}, []string{"auth_algo", "subject"})

	// TLSCertificateNotAfter is a gauge with the time when the certificate
	// expires.
	TLSCertificateNotAfter = promauto.NewGaugeVec(prometheus.GaugeOpts{
		Name:      "cert_not_after",
		Namespace: namespace,
		Subsystem: subsystemTLS,
		Help:      "Time when the certificate expires.",
	}, []string{"subject"})

	// TLSSessionTicketsRotateStatus is a gauge with the status of the last
	// tickets rotation.
	TLSSessionTicketsRotateStatus = promauto.NewGauge(prometheus.GaugeOpts{
		Name:      "session_tickets_rotate_status",
		Namespace: namespace,
		Subsystem: subsystemTLS,
		Help:      "Status of the last tickets rotation.",
	})
	// TLSSessionTicketsRotateTime is a gauge with the time when the TLS session
	// tickets were rotated.
	TLSSessionTicketsRotateTime = promauto.NewGauge(prometheus.GaugeOpts{
		Name:      "session_tickets_rotate_time",
		Namespace: namespace,
		Subsystem: subsystemTLS,
		Help:      "Time when the TLS session tickets were rotated.",
	})
	// TLSHandshakeAttemptsTotal is a counter with the total number of attempts
	// to establish a TLS connection.  "supported_protos" is a comma-separated
	// list of the protocols supported by the client.
	TLSHandshakeAttemptsTotal = promauto.NewCounterVec(prometheus.CounterOpts{
		Name:      "handshake_attempts_total",
		Namespace: namespace,
		Subsystem: subsystemTLS,
		Help:      "Total count of TLS handshakes.",
	}, []string{
		"proto",
		"supported_protos",
		"tls_version",
	})
	// TLSHandshakeTotal is a counter with the total count of TLS handshakes.
	TLSHandshakeTotal = promauto.NewCounterVec(prometheus.CounterOpts{
		Name:      "handshake_total",
		Namespace: namespace,
		Subsystem: subsystemTLS,
		Help:      "Total count of TLS handshakes.",
	}, []string{
		"proto",
		"tls_version",
		"did_resume",
		"cipher_suite",
		"negotiated_proto",
		"server_name",
	})
)

var (

	// WebSvcError404RequestsTotal is a counter with total number of
	// requests with error 404.
	WebSvcError404RequestsTotal = webSvcRequestsTotal.With(prometheus.Labels{
		"kind": "error404",
	})

	// WebSvcError500RequestsTotal is a counter with total number of
	// requests with error 500.
	WebSvcError500RequestsTotal = webSvcRequestsTotal.With(prometheus.Labels{
		"kind": "error500",
	})

	// WebSvcStaticContentRequestsTotal is a counter with total number of
	// requests for static content.
	WebSvcStaticContentRequestsTotal = webSvcRequestsTotal.With(prometheus.Labels{
		"kind": "static_content",
	})

	// WebSvcDNSCheckTestRequestsTotal is a counter with total number of
	// requests for dnscheck_test.
	WebSvcDNSCheckTestRequestsTotal = webSvcRequestsTotal.With(prometheus.Labels{
		"kind": "dnscheck_test",
	})

	// WebSvcRobotsTxtRequestsTotal is a counter with total number of
	// requests for robots_txt.
	WebSvcRobotsTxtRequestsTotal = webSvcRequestsTotal.With(prometheus.Labels{
		"kind": "robots_txt",
	})

	// WebSvcRootRedirectRequestsTotal is a counter with total number of
	// root redirected requests.
	WebSvcRootRedirectRequestsTotal = webSvcRequestsTotal.With(prometheus.Labels{
		"kind": "root_redirect",
	})

	// WebSvcLinkedIPProxyRequestsTotal is a counter with total number of
	// requests with linked ip.
	WebSvcLinkedIPProxyRequestsTotal = webSvcRequestsTotal.With(prometheus.Labels{
		"kind": "linkip",
	})

	// WebSvcAdultBlockingPageRequestsTotal is a counter with total number
	// of requests for adult blocking page.
	WebSvcAdultBlockingPageRequestsTotal = webSvcRequestsTotal.With(prometheus.Labels{
		"kind": "adult_blocking_page",
	})

	// WebSvcSafeBrowsingPageRequestsTotal is a counter with total number
	// of requests for safe browsing page.
	WebSvcSafeBrowsingPageRequestsTotal = webSvcRequestsTotal.With(prometheus.Labels{
		"kind": "safe_browsing_page",
	})
)

var AccessBlockedForHostTotal = promauto.NewCounter(prometheus.CounterOpts{
	Name:      "blocked_host_total",
	Namespace: namespace,
	Subsystem: subsystemAccess,
	Help:      "Total count of blocked host requests.",
})

var AccessBlockedForProfileTotal = promauto.NewCounter(prometheus.CounterOpts{
	Name:      "profile_blocked_total",
	Namespace: namespace,
	Subsystem: subsystemAccess,
	Help:      "Total count of blocked profile requests.",
})

var AccessBlockedForSubnetTotal = promauto.NewCounter(prometheus.CounterOpts{
	Name:      "blocked_subnet_total",
	Namespace: namespace,
	Subsystem: subsystemAccess,
	Help:      "Total count of blocked subnet requests.",
})

var AccessProfileInitDuration = promauto.NewHistogram(prometheus.HistogramOpts{
	Name:      "profile_init_engine_duration_seconds",
	Namespace: namespace,
	Subsystem: subsystemAccess,
	Help:      "Time elapsed on profile access engine initialization.",
})

var ConnLimiterActiveStreamConns = promauto.NewGaugeVec(prometheus.GaugeOpts{
	Name:      "active_stream_conns",
	Namespace: namespace,
	Subsystem: subsystemConnLimiter,
	Help:      `The number of currently active stream-connections.`,
}, []string{"name", "proto", "addr"})

var ConnLimiterLimits = promauto.NewGaugeVec(prometheus.GaugeOpts{
	Name:      "limits",
	Namespace: namespace,
	Subsystem: subsystemConnLimiter,
	Help: `The current limits of the number of active stream-connections: ` +
		`kind="stop" for the stopping limit and kind="resume" for the resuming one.`,
}, []string{"kind"})

var DNSCheckErrorTotal = promauto.NewGaugeVec(prometheus.GaugeOpts{
	Name:      "error_total",
	Namespace: namespace,
	Subsystem: subsystemDNSCheck,
	Help:      "The total number of errors with requests to the DNSCheck service.",
}, []string{"source", "type"})

var DNSCheckRequestTotal = promauto.NewCounterVec(prometheus.CounterOpts{
	Name:      "request_total",
	Namespace: namespace,
	Subsystem: subsystemDNSCheck,
	Help:      "The number of requests to the DNSCheck service.",
}, []string{"type", "valid"})

var DNSSvcFilteringDuration = promauto.NewHistogram(prometheus.HistogramOpts{
	Name:      "filtering_duration_seconds",
	Namespace: namespace,
	Subsystem: subsystemDNSSvc,
	Help:      "Time elapsed on processing a DNS query.",

	Buckets: []float64{

		0.000001,

		0.00001,

		0.00005,

		0.0001,

		0.001,

		0.01,
		0.1,
		1,
	},
})

var DNSSvcRequestByASNTotal = promauto.NewCounterVec(prometheus.CounterOpts{
	Name:      "request_per_asn_total",
	Namespace: namespace,
	Subsystem: subsystemDNSSvc,
	Help:      "The number of processed DNS requests labeled by country and ASN.",
	ConstLabels: prometheus.Labels{
		dontStoreLabel: dontStoreLabelValue,
	},
}, []string{"country", "asn"})

var DNSSvcRequestByCountryTotal = promauto.NewCounterVec(prometheus.CounterOpts{
	Name:      "request_per_country_total",
	Namespace: namespace,
	Subsystem: subsystemDNSSvc,
	Help:      "The number of processed DNS requests labeled by country and continent.",
}, []string{"continent", "country"})

var DNSSvcRequestByFilterTotal = promauto.NewCounterVec(prometheus.CounterOpts{
	Name:      "request_per_filter_total",
	Namespace: namespace,
	Subsystem: subsystemDNSSvc,
	Help:      "The number of filtered DNS requests labeled by filter applied.",
}, []string{"filter", "anonymous"})

var DNSSvcUnknownDedicatedTotal = promauto.NewCounter(prometheus.CounterOpts{
	Name:      "unknown_dedicated",
	Namespace: namespace,
	Subsystem: subsystemDNSSvc,
	Help:      "The number of dropped queries for unrecognized dedicated addresses.",
})

var DevicesCountGauge = promauto.NewGauge(prometheus.GaugeOpts{
	Name:      "devices_total",
	Subsystem: subsystemBackend,
	Namespace: namespace,
	Help:      "The total number of user devices loaded from the backend.",
})

var DevicesInvalidTotal = promauto.NewCounter(prometheus.CounterOpts{
	Name:      "devices_invalid_total",
	Subsystem: subsystemBackend,
	Namespace: namespace,
	Help:      "The total number of invalid user devices loaded from the backend.",
})

var DevicesNewCountGauge = promauto.NewGauge(prometheus.GaugeOpts{
	Name:      "devices_newly_synced_total",
	Subsystem: subsystemBackend,
	Namespace: namespace,
	Help:      "The number of user devices that were changed or added since the previous sync.",
})

var GRPCAvgProfileDecDuration = promauto.NewHistogram(prometheus.HistogramOpts{
	Name:      "grpc_avg_profile_dec_duration_seconds",
	Subsystem: subsystemBackend,
	Namespace: namespace,
	Help: "The average duration of decoding one profile during a call to the backend, " +
		"in seconds.",
	Buckets: []float64{0.000_001, 0.000_01, 0.000_1, 0.001},
})

var GRPCAvgProfileRecvDuration = promauto.NewHistogram(prometheus.HistogramOpts{
	Name:      "grpc_avg_profile_recv_duration_seconds",
	Subsystem: subsystemBackend,
	Namespace: namespace,
	Help: "The average duration of a receive of a profile during a call to the backend, " +
		"in seconds.",
	Buckets: []float64{0.000_001, 0.000_010, 0.000_100, 0.001},
})

var ProfilesCountGauge = promauto.NewGauge(prometheus.GaugeOpts{
	Name:      "profiles_total",
	Subsystem: subsystemBackend,
	Namespace: namespace,
	Help:      "The total number of user profiles loaded from the backend.",
})

var ProfilesFullSyncDuration = promauto.NewGauge(prometheus.GaugeOpts{
	Name:      "profiles_full_sync_duration_seconds",
	Subsystem: subsystemBackend,
	Namespace: namespace,
	Help:      "Time elapsed on fully syncing user profiles with the backend, in seconds.",
})

var ProfilesNewCountGauge = promauto.NewGauge(prometheus.GaugeOpts{
	Name:      "profiles_newly_synced_total",
	Subsystem: subsystemBackend,
	Namespace: namespace,
	Help:      "The number of user profiles that were changed or added since the previous sync.",
})

var ProfilesSyncDuration = promauto.NewHistogram(prometheus.HistogramOpts{
	Name:      "profiles_sync_duration_seconds",
	Subsystem: subsystemBackend,
	Namespace: namespace,
	Help:      "Time elapsed on syncing user profiles with the backend.",

	Buckets: []float64{0.01, 0.1, 1, 5, 10, 30, 60, 120, 240},
})

var ProfilesSyncStatus = promauto.NewGauge(prometheus.GaugeOpts{
	Name:      "profiles_sync_status",
	Subsystem: subsystemBackend,
	Namespace: namespace,
	Help:      "Status of the last profiles sync. 1 is okay, 0 means there was an error",
})

var ProfilesSyncTime = promauto.NewGauge(prometheus.GaugeOpts{
	Name:      "profiles_sync_timestamp",
	Subsystem: subsystemBackend,
	Namespace: namespace,
	Help:      "The time when the user profiles were synced last time.",
})

var QueryLogItemSize = promauto.NewHistogram(prometheus.HistogramOpts{
	Name:      "items_size_bytes",
	Subsystem: subsystemQueryLog,
	Namespace: namespace,
	Help:      "A histogram with the query log items size.",

	Buckets: []float64{50, 100, 200, 300, 400, 600, 800, 1000, 2000},
})

var QueryLogItemsCount = promauto.NewCounter(prometheus.CounterOpts{
	Name:      "items_total",
	Subsystem: subsystemQueryLog,
	Namespace: namespace,
	Help:      "The total number of query log items written.",
})

var QueryLogWriteDuration = promauto.NewHistogram(prometheus.HistogramOpts{
	Name:      "write_duration_seconds",
	Subsystem: subsystemQueryLog,
	Namespace: namespace,
	Help:      "A histogram with the query log items size.",

	Buckets: []float64{0.00001, 0.0001, 0.001, 0.01, 0.1, 1},
})

var ResearchBlockedRequestsPerCountryTotal = promauto.NewCounterVec(prometheus.CounterOpts{
	Name:      "blocked_per_country_total",
	Namespace: namespace,
	Subsystem: subsystemResearch,
	Help:      "The number of blocked DNS queries per country from anonymous users.",
}, []string{"filter", "country"})

var ResearchBlockedRequestsPerSubdivTotal = promauto.NewCounterVec(prometheus.CounterOpts{
	Name:      "blocked_per_subdivision_total",
	Namespace: namespace,
	Subsystem: subsystemResearch,
	Help: `The number of blocked DNS queries per countries with top ` +
		`subdivision from anonymous users.`,
}, []string{"filter", "country", "subdivision"})

var ResearchRequestsPerCountryTotal = promauto.NewCounterVec(prometheus.CounterOpts{
	Name:      "requests_per_country_total",
	Namespace: namespace,
	Subsystem: subsystemResearch,
	Help:      "The total number of DNS queries per country from anonymous users.",
}, []string{"country"})

var ResearchRequestsPerSubdivTotal = promauto.NewCounterVec(prometheus.CounterOpts{
	Name:      "requests_per_subdivision_total",
	Namespace: namespace,
	Subsystem: subsystemResearch,
	Help: `The total number of DNS queries per countries with top ` +
		`subdivision from anonymous users.`,
}, []string{"country", "subdivision"})

var ResearchResponseECH = promauto.NewCounter(prometheus.CounterOpts{
	Name:      "response_ech",
	Namespace: namespace,
	Subsystem: subsystemResearch,
	Help:      `The number of DNS responses with a ECH config.`,
})

var StreamConnLifeDuration = promauto.NewHistogramVec(prometheus.HistogramOpts{
	Name:      "stream_conn_life_duration_seconds",
	Subsystem: subsystemConnLimiter,
	Namespace: namespace,
	Help:      "How long a stream connection lives, in seconds.",
	Buckets:   []float64{0.1, 1, 5, 10, 30, 60},
}, []string{"name", "proto", "addr"})

var StreamConnWaitDuration = promauto.NewHistogramVec(prometheus.HistogramOpts{
	Name:      "stream_conn_wait_duration_seconds",
	Subsystem: subsystemConnLimiter,
	Namespace: namespace,
	Help:      "How long a stream connection waits for an accept, in seconds.",
	Buckets:   []float64{0.00001, 0.01, 0.1, 1, 10, 30, 60},
}, []string{"name", "proto", "addr"})