916ec63af6
This is a new revision of the discovery server. Relevant changes and non-changes: - Protocol towards clients is unchanged. - Recommended large scale design is still to be deployed nehind nginx (I tested, and it's still a lot faster at terminating TLS). - Database backend is leveldb again, only. It scales enough, is easy to setup, and we don't need any backend to take care of. - Server supports replication. This is a simple TCP channel - protect it with a firewall when deploying over the internet. (We deploy this within the same datacenter, and with firewall.) Any incoming client announces are sent over the replication channel(s) to other peer discosrvs. Incoming replication changes are applied to the database as if they came from clients, but without the TLS/certificate overhead. - Metrics are exposed using the prometheus library, when enabled. - The database values and replication protocol is protobuf, because JSON was quite CPU intensive when I tried that and benchmarked it. - The "Retry-After" value for failed lookups gets slowly increased from a default of 120 seconds, by 5 seconds for each failed lookup, independently by each discosrv. This lowers the query load over time for clients that are never seen. The Retry-After maxes out at 3600 after a couple of weeks of this increase. The number of failed lookups is stored in the database, now and then (avoiding making each lookup a database put). All in all this means clients can be pointed towards a cluster using just multiple A / AAAA records to gain both load sharing and redundancy (if one is down, clients will talk to the remaining ones). GitHub-Pull-Request: https://github.com/syncthing/syncthing/pull/4648
76 lines
3.5 KiB
Go
76 lines
3.5 KiB
Go
// Copyright 2014 The Prometheus Authors
|
|
// 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 prometheus
|
|
|
|
// Collector is the interface implemented by anything that can be used by
|
|
// Prometheus to collect metrics. A Collector has to be registered for
|
|
// collection. See Registerer.Register.
|
|
//
|
|
// The stock metrics provided by this package (Gauge, Counter, Summary,
|
|
// Histogram, Untyped) are also Collectors (which only ever collect one metric,
|
|
// namely itself). An implementer of Collector may, however, collect multiple
|
|
// metrics in a coordinated fashion and/or create metrics on the fly. Examples
|
|
// for collectors already implemented in this library are the metric vectors
|
|
// (i.e. collection of multiple instances of the same Metric but with different
|
|
// label values) like GaugeVec or SummaryVec, and the ExpvarCollector.
|
|
type Collector interface {
|
|
// Describe sends the super-set of all possible descriptors of metrics
|
|
// collected by this Collector to the provided channel and returns once
|
|
// the last descriptor has been sent. The sent descriptors fulfill the
|
|
// consistency and uniqueness requirements described in the Desc
|
|
// documentation. (It is valid if one and the same Collector sends
|
|
// duplicate descriptors. Those duplicates are simply ignored. However,
|
|
// two different Collectors must not send duplicate descriptors.) This
|
|
// method idempotently sends the same descriptors throughout the
|
|
// lifetime of the Collector. If a Collector encounters an error while
|
|
// executing this method, it must send an invalid descriptor (created
|
|
// with NewInvalidDesc) to signal the error to the registry.
|
|
Describe(chan<- *Desc)
|
|
// Collect is called by the Prometheus registry when collecting
|
|
// metrics. The implementation sends each collected metric via the
|
|
// provided channel and returns once the last metric has been sent. The
|
|
// descriptor of each sent metric is one of those returned by
|
|
// Describe. Returned metrics that share the same descriptor must differ
|
|
// in their variable label values. This method may be called
|
|
// concurrently and must therefore be implemented in a concurrency safe
|
|
// way. Blocking occurs at the expense of total performance of rendering
|
|
// all registered metrics. Ideally, Collector implementations support
|
|
// concurrent readers.
|
|
Collect(chan<- Metric)
|
|
}
|
|
|
|
// selfCollector implements Collector for a single Metric so that the Metric
|
|
// collects itself. Add it as an anonymous field to a struct that implements
|
|
// Metric, and call init with the Metric itself as an argument.
|
|
type selfCollector struct {
|
|
self Metric
|
|
}
|
|
|
|
// init provides the selfCollector with a reference to the metric it is supposed
|
|
// to collect. It is usually called within the factory function to create a
|
|
// metric. See example.
|
|
func (c *selfCollector) init(self Metric) {
|
|
c.self = self
|
|
}
|
|
|
|
// Describe implements Collector.
|
|
func (c *selfCollector) Describe(ch chan<- *Desc) {
|
|
ch <- c.self.Desc()
|
|
}
|
|
|
|
// Collect implements Collector.
|
|
func (c *selfCollector) Collect(ch chan<- Metric) {
|
|
ch <- c.self
|
|
}
|