prometheus

Commit Graph

Author	SHA1	Message	Date
Fabian Reinartz	0492ddbd4d	*: fully decouple tsdb, add new storage interfaces	9 years ago
Fabian Reinartz	9ea10d5265	promql: use labels.Builder to modify labels	9 years ago
Fabian Reinartz	c6cd998905	promql: use local labels, add conversion	9 years ago
Fabian Reinartz	ff504af2aa	promql: undo accidental exports	9 years ago
Fabian Reinartz	6dedf89cc3	promql: rename SampleStream to Series	9 years ago
Fabian Reinartz	c5f225b920	promql: export Sample	9 years ago
Fabian Reinartz	65581a3d46	promql: export SmapleStream	9 years ago
Fabian Reinartz	6315d00942	promql: export String value	9 years ago
Fabian Reinartz	ac5d3bc05e	promql: scalar T/V and Point	9 years ago
Fabian Reinartz	09666e2e2a	promql: make scalar public	9 years ago
Fabian Reinartz	b3f71df350	promql: make matrix exported	9 years ago
Fabian Reinartz	a62df87022	promql: rename vector	9 years ago
Fabian Reinartz	15a931dbdb	promql: migrate model types, use tsdb interfaces	9 years ago
Tristan Colgate	68fc15fe4e	Report type names in the form used in documentation	9 years ago
beorn7	4e3abc6cbf	Simply use `math.Mod(float64, float64)` after all This circumvents all the problems with int overflow, plus it is what was originally intended.	9 years ago
beorn7	5cf5bb427a	Check for int64 overflow when converting from float64	9 years ago
beorn7	07f1bdfe94	Fix MOD binop for scalars and vectors Previously, a floating point number that would round down to 0 would cause a "division by zero" panic.	9 years ago
Fabian Reinartz	8fa18d564a	storage: enhance Querier interface usage This extracts Querier as an instantiateable and closeable object rather than just defining extending methods of the storage interface. This improves composability and allows abstracting query transactions, which can be useful for transaction-level caches, consistent data views, and encapsulating teardown.	9 years ago
Julius Volz	c187308366	storage: Contextify storage interfaces. This is based on https://github.com/prometheus/prometheus/pull/1997. This adds contexts to the relevant Storage methods and already passes PromQL's new per-query context into the storage's query methods. The immediate motivation supporting multi-tenancy in Frankenstein, but this could also be used by Prometheus's normal local storage to support cancellations and timeouts at some point.	9 years ago
Julius Volz	ed5a0f0abe	promql: Allow per-query contexts. For Weaveworks' Frankenstein, we need to support multitenancy. In Frankenstein, we initially solved this without modifying the promql package at all: we constructed a new promql.Engine for every query and injected a storage implementation into that engine which would be primed to only collect data for a given user. This is problematic to upstream, however. Prometheus assumes that there is only one engine: the query concurrency gate is part of the engine, and the engine contains one central cancellable context to shut down all queries. Also, creating a new engine for every query seems like overkill. Thus, we want to be able to pass per-query contexts into a single engine. This change gets rid of the promql.Engine's built-in base context and allows passing in a per-query context instead. Central cancellation of all queries is still possible by deriving all passed-in contexts from one central one, but this is now the responsibility of the caller. The central query context is now created in main() and passed into the relevant components (web handler / API, rule manager). In a next step, the per-query context would have to be passed to the storage implementation, so that the storage can implement multi-tenancy or other features based on the contextual information.	9 years ago
beorn7	71571a8ec4	promql: Fix (and simplify) populating iterators This was only relevant so far for the benchmark suite as it would recycle Expr for repetitions. However, the append is unnecessary as each node is only inspected once when populating iterators, and population must always start from scratch. This also introduces error checking during benchmarks and fixes the so far undetected test errors during benchmarking. Also, remove a style nit (two golint warnings less…).	9 years ago
Julius Volz	3bfec97d46	Make the storage interface higher-level. See discussion in https://groups.google.com/forum/#!topic/prometheus-developers/bkuGbVlvQ9g The main idea is that the user of a storage shouldn't have to deal with fingerprints anymore, and should not need to do an individual preload call for each metric. The storage interface needs to be made more high-level to not expose these details. This also makes it easier to reuse the same storage interface for remote storages later, as fewer roundtrips are required and the fingerprint concept doesn't work well across the network. NOTE: this deliberately gets rid of a small optimization in the old query Analyzer, where we dedupe instants and ranges for the same series. This should have a minor impact, as most queries do not have multiple selectors loading the same series (and at the same offset).	10 years ago
Brian Brazil	0303ccc6a7	Add quantile aggregator.	10 years ago
Brian Brazil	16690736ab	Add count_values() aggregator. This is useful for counting how many instances of a job are running a particular version/build. Fixes #622	10 years ago
Brian Brazil	3e5136e36d	Make topk/bottomk aggregators.	10 years ago
Brian Brazil	3b89616d82	Allow on, ignoring, by and without wit empty laberls. This offers new semantics in allowing on() for matching two single-element vectors with no known common labels. Previosuly this was often done using on(dummy). This also allows making it explict that you meant to do an aggregation without labels via by(). Fixes #1597.	10 years ago
Brian Brazil	246a817300	Flip vector matching to be ignoring by default. This is a noop semantically.	10 years ago
Julius Volz	b7b6717438	Separate query interface out of local.Storage. PromQL only requires a much narrower interface than local.Storage in order to run queries. Narrower interfaces are easier to replace and test, too. We could also change the web interface to use local.Querier, except that we'll probably use appending functions from there in the future.	10 years ago
royels	2fdc5717a3	promql: add power binary operation	10 years ago
Ali Reza	e7eba75690	remove keeping_extra because it's replaced with keep_common change all keepExtra label into keepCommon, and move action into removed list change incorrect token list	10 years ago
Brian Brazil	7201c010c4	Rename On to MatchingLabels	10 years ago
Brian Brazil	d991f0cf47	For many-to-one matches, always copy label from one side. This is a breaking change for everyone using the machine roles labeling approach.	10 years ago
Brian Brazil	768d09fd2a	Change on+group_* to take copy from the one side. If the label doesn't exist on the one side, it's not copied. All labels on the many inside are included, this is a breaking change but likely low impact.	10 years ago
Brian Brazil	d1edfb25b3	Add support for OneToMany with IGNORING. The labels listed in the group_ modifier will be copied from the one side to the many side. It will be valid to specify no labels. This is intended to replace the existing ON/GROUP_* support.,	10 years ago
Brian Brazil	1d08c4fef0	Add 'ignoring' as modifier for binops. Where 'on' uses the given labels to match, 'ignoring' uses all other labels to match. group_left/right is not supported yet.	10 years ago
Tobias Schmidt	8cc86f25c0	Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}	10 years ago
beorn7	c740789ce3	Improve predict_linear Fixes https://github.com/prometheus/prometheus/issues/1401 This remove the last (and in fact bogus) use of BoundaryValues. Thus, a whole lot of unused (and arguably sub-optimal / ugly) code can be removed here, too.	10 years ago
beorn7	0e202dacb4	Streamline series iterator creation This will fix issue #1035 and will also help to make issue #1264 less bad. The fundamental problem in the current code: In the preload phase, we quite accurately determine which chunks will be used for the query being executed. However, in the subsequent step of creating series iterators, the created iterators are referencing _all_ in-memory chunks in their series, even the un-pinned ones. In iterator creation, we copy a pointer to each in-memory chunk of a series into the iterator. While this creates a certain amount of allocation churn, the worst thing about it is that copying the chunk pointer out of the chunkDesc requires a mutex acquisition. (Remember that the iterator will also reference un-pinned chunks, so we need to acquire the mutex to protect against concurrent eviction.) The worst case happens if a series doesn't even contain any relevant samples for the query time range. We notice that during preloading but then we will still create a series iterator for it. But even for series that do contain relevant samples, the overhead is quite bad for instant queries that retrieve a single sample from each series, but still go through all the effort of series iterator creation. All of that is particularly bad if a series has many in-memory chunks. This commit addresses the problem from two sides: First, it merges preloading and iterator creation into one step, i.e. the preload call returns an iterator for exactly the preloaded chunks. Second, the required mutex acquisition in chunkDesc has been greatly reduced. That was enabled by a side effect of the first step, which is that the iterator is only referencing pinned chunks, so there is no risk of concurrent eviction anymore, and chunks can be accessed without mutex acquisition. To simplify the code changes for the above, the long-planned change of ValueAtTime to ValueAtOrBefore time was performed at the same time. (It should have been done first, but it kind of accidentally happened while I was in the middle of writing the series iterator changes. Sorry for that.) So far, we actively filtered the up to two values that were returned by ValueAtTime, i.e. we invested work to retrieve up to two values, and then we invested more work to throw one of them away. The SeriesIterator.BoundaryValues method can be removed once #1401 is fixed. But I really didn't want to load even more changes into this PR. Benchmarks: The BenchmarkFuzz.* benchmarks run 83% faster (i.e. about six times faster) and allocate 95% fewer bytes. The reason for that is that the benchmark reads one sample after another from the time series and creates a new series iterator for each sample read. To find out how much these improvements matter in practice, I have mirrored a beefy Prometheus server at SoundCloud that suffers from both issues #1035 and #1264. To reach steady state that would be comparable, the server needs to run for 15d. So far, it has run for 1d. The test server currently has only half as many memory time series and 60% of the memory chunks the main server has. The 90th percentile rule evaluation cycle time is ~11s on the main server and only ~3s on the test server. However, these numbers might get much closer over time. In addition to performance improvements, this commit removes about 150 LOC.	10 years ago
Julius Volz	9b6d69610a	Fix various typos in comments. Helpfully reported by https://goreportcard.com/report/github.com/prometheus/prometheus :)	10 years ago
Brian Brazil	9d0112d7cf	Add without aggregator modifier. This has the advantage that the user doesn't need to list all labels they want to keep (as with "by") but without having to worry about inconsistent labels as when there's only one time series (as with "keeping_common"). Almost all aggregation should use this rather than the existing two options as it's much less error prone and easier to maintain due to not having to always add in "job" plus whatever other common job-level labels you have like "region".	10 years ago
Brian Brazil	89760dd77d	Handle NaN for min/max. Similar to topk and sort, prefer not returning NaN where possible.	10 years ago
Fabian Reinartz	e3b6ec9784	Switch to common/log	10 years ago
Brian Brazil	29e8dc2c49	promql: Add 'bool' modifier to comparison functions When doing comparison operations on vectors, filtering sometimes gets in the way and you have to go to a fair bit of effort to workaround it in order to always return a result. The 'bool' modifier instead of filtering returns 0/1 depending on the result of the compairson. This is also a prerequisite to removing plain scalar/scalar comparisons, as it maintains the current behaviour under a new syntax.	10 years ago
Fabian Reinartz	d6b8da8d43	Switch promql types to common/model	10 years ago
Brian Brazil	fb585e4591	promql: Remove interpolation of vector values. The current behaviour produces values that are not from rules or scrapes. So if for example I have a boolean 0/1 it can be returned as 0.2344589. This prevents a number of advanced use cases, introduces race conditions and can produce misleading graphs.	10 years ago
Fabian Reinartz	1535ef1457	Replace metric.SamplePair with model.SamplePair	10 years ago
Fabian Reinartz	438e232c9b	Fix grouping of import blocks	10 years ago
Fabian Reinartz	306e8468a0	Switch from client_golang/model to common/model	11 years ago
Laurie Malau	cdf38ab93a	Log runtime errors during query evaluation instead of panicking.	11 years ago
Julius Volz	27ed874358	Implement label_replace() Implements part of https://github.com/prometheus/prometheus/issues/959.	11 years ago

1 2

73 Commits (622ece6273376838d007e32ee88e166375a2f4a5)