nixos/modules/services/monitoring/thanos.nix

   1 { config, lib, pkgs, ... }:
   2
   3 let
   4   inherit (lib)
   5     collect
   6     concatLists
   7     concatStringsSep
   8     flip
   9     getAttrFromPath
  10     hasPrefix
  11     isList
  12     length
  13     literalExpression
  14     literalMD
  15     mapAttrsRecursiveCond
  16     mapAttrsToList
  17     mkEnableOption
  18     mkIf
  19     mkMerge
  20     mkOption
  21     mkPackageOption
  22     optional
  23     optionalAttrs
  24     optionalString
  25     types
  26     ;
  27
  28   cfg = config.services.thanos;
  29
  30   nullOpt = type: description: mkOption {
  31     type = types.nullOr type;
  32     default = null;
  33     description = description;
  34   };
  35
  36   optionToArgs = opt: v  : optional (v != null)  ''--${opt}="${toString v}"'';
  37   flagToArgs   = opt: v  : optional v            "--${opt}";
  38   listToArgs   = opt: vs : map               (v: ''--${opt}="${v}"'') vs;
  39   attrsToArgs  = opt: kvs: mapAttrsToList (k: v: ''--${opt}=${k}=\"${v}\"'') kvs;
  40
  41   mkParamDef = type: default: description: mkParam type (description + ''
  42
  43     Defaults to `${toString default}` in Thanos
  44     when set to `null`.
  45   '');
  46
  47   mkParam = type: description: {
  48     toArgs = optionToArgs;
  49     option = nullOpt type description;
  50   };
  51
  52   mkFlagParam = description: {
  53     toArgs = flagToArgs;
  54     option = mkOption {
  55       type = types.bool;
  56       default = false;
  57       description = description;
  58     };
  59   };
  60
  61   mkListParam = opt: description: {
  62     toArgs = _opt: listToArgs opt;
  63     option = mkOption {
  64       type = types.listOf types.str;
  65       default = [];
  66       description = description;
  67     };
  68   };
  69
  70   mkAttrsParam = opt: description: {
  71     toArgs = _opt: attrsToArgs opt;
  72     option = mkOption {
  73       type = types.attrsOf types.str;
  74       default = {};
  75       description = description;
  76     };
  77   };
  78
  79   mkStateDirParam = opt: default: description: {
  80     toArgs = _opt: stateDir: optionToArgs opt "/var/lib/${stateDir}";
  81     option = mkOption {
  82       type = types.str;
  83       inherit default;
  84       description = description;
  85     };
  86   };
  87
  88   toYAML = name: attrs: pkgs.runCommand name {
  89     preferLocalBuild = true;
  90     json = builtins.toFile "${name}.json" (builtins.toJSON attrs);
  91     nativeBuildInputs = [ pkgs.remarshal ];
  92   } "json2yaml -i $json -o $out";
  93
  94   thanos = cmd: "${cfg.package}/bin/thanos ${cmd}" +
  95     (let args = cfg.${cmd}.arguments;
  96      in optionalString (length args != 0) (" \\\n  " +
  97          concatStringsSep " \\\n  " args));
  98
  99   argumentsOf = cmd: concatLists (collect isList
 100     (flip mapParamsRecursive params.${cmd} (path: param:
 101       let opt = concatStringsSep "." path;
 102           v = getAttrFromPath path cfg.${cmd};
 103       in param.toArgs opt v)));
 104
 105   mkArgumentsOption = cmd: mkOption {
 106     type = types.listOf types.str;
 107     default = argumentsOf cmd;
 108     defaultText = literalMD ''
 109       calculated from `config.services.thanos.${cmd}`
 110     '';
 111     description = ''
 112       Arguments to the `thanos ${cmd}` command.
 113
 114       Defaults to a list of arguments formed by converting the structured
 115       options of {option}`services.thanos.${cmd}` to a list of arguments.
 116
 117       Overriding this option will cause none of the structured options to have
 118       any effect. So only set this if you know what you're doing!
 119     '';
 120   };
 121
 122   mapParamsRecursive =
 123     let noParam = attr: !(attr ? toArgs && attr ? option);
 124     in mapAttrsRecursiveCond noParam;
 125
 126   paramsToOptions = mapParamsRecursive (_path: param: param.option);
 127
 128   params = {
 129
 130     log = {
 131
 132       log.level = mkParamDef (types.enum ["debug" "info" "warn" "error" "fatal"]) "info" ''
 133         Log filtering level.
 134       '';
 135
 136       log.format = mkParam types.str ''
 137         Log format to use.
 138       '';
 139     };
 140
 141     tracing = cfg: {
 142       tracing.config-file = {
 143         toArgs = _opt: path: optionToArgs "tracing.config-file" path;
 144         option = mkOption {
 145           type = with types; nullOr str;
 146           default = if cfg.tracing.config == null then null
 147                     else toString (toYAML "tracing.yaml" cfg.tracing.config);
 148           defaultText = literalExpression ''
 149             if config.services.thanos.<cmd>.tracing.config == null then null
 150             else toString (toYAML "tracing.yaml" config.services.thanos.<cmd>.tracing.config);
 151           '';
 152           description = ''
 153             Path to YAML file that contains tracing configuration.
 154
 155             See format details: <https://thanos.io/tip/thanos/tracing.md/#configuration>
 156           '';
 157         };
 158       };
 159
 160       tracing.config =
 161         {
 162           toArgs = _opt: _attrs: [];
 163           option = nullOpt types.attrs ''
 164             Tracing configuration.
 165
 166             When not `null` the attribute set gets converted to
 167             a YAML file and stored in the Nix store. The option
 168             {option}`tracing.config-file` will default to its path.
 169
 170             If {option}`tracing.config-file` is set this option has no effect.
 171
 172             See format details: <https://thanos.io/tip/thanos/tracing.md/#configuration>
 173           '';
 174         };
 175     };
 176
 177     common = cfg: params.log // params.tracing cfg // {
 178
 179       http-address = mkParamDef types.str "0.0.0.0:10902" ''
 180         Listen `host:port` for HTTP endpoints.
 181       '';
 182
 183       grpc-address = mkParamDef types.str "0.0.0.0:10901" ''
 184         Listen `ip:port` address for gRPC endpoints (StoreAPI).
 185
 186         Make sure this address is routable from other components.
 187       '';
 188
 189       grpc-server-tls-cert = mkParam types.str ''
 190         TLS Certificate for gRPC server, leave blank to disable TLS
 191       '';
 192
 193       grpc-server-tls-key = mkParam types.str ''
 194         TLS Key for the gRPC server, leave blank to disable TLS
 195       '';
 196
 197       grpc-server-tls-client-ca = mkParam types.str ''
 198         TLS CA to verify clients against.
 199
 200         If no client CA is specified, there is no client verification on server side.
 201         (tls.NoClientCert)
 202       '';
 203     };
 204
 205     objstore = cfg: {
 206
 207       objstore.config-file = {
 208         toArgs = _opt: path: optionToArgs "objstore.config-file" path;
 209         option = mkOption {
 210           type = with types; nullOr str;
 211           default = if cfg.objstore.config == null then null
 212                     else toString (toYAML "objstore.yaml" cfg.objstore.config);
 213           defaultText = literalExpression ''
 214             if config.services.thanos.<cmd>.objstore.config == null then null
 215             else toString (toYAML "objstore.yaml" config.services.thanos.<cmd>.objstore.config);
 216           '';
 217           description = ''
 218             Path to YAML file that contains object store configuration.
 219
 220             See format details: <https://thanos.io/tip/thanos/storage.md/#configuring-access-to-object-storage>
 221           '';
 222         };
 223       };
 224
 225       objstore.config =
 226         {
 227           toArgs = _opt: _attrs: [];
 228           option = nullOpt types.attrs ''
 229             Object store configuration.
 230
 231             When not `null` the attribute set gets converted to
 232             a YAML file and stored in the Nix store. The option
 233             {option}`objstore.config-file` will default to its path.
 234
 235             If {option}`objstore.config-file` is set this option has no effect.
 236
 237             See format details: <https://thanos.io/tip/thanos/storage.md/#configuring-access-to-object-storage>
 238           '';
 239         };
 240     };
 241
 242     sidecar = params.common cfg.sidecar // params.objstore cfg.sidecar // {
 243
 244       prometheus.url = mkParamDef types.str "http://localhost:9090" ''
 245         URL at which to reach Prometheus's API.
 246
 247         For better performance use local network.
 248       '';
 249
 250       tsdb.path = {
 251         toArgs = optionToArgs;
 252         option = mkOption {
 253           type = types.str;
 254           default = "/var/lib/${config.services.prometheus.stateDir}/data";
 255           defaultText = literalExpression ''"/var/lib/''${config.services.prometheus.stateDir}/data"'';
 256           description = ''
 257             Data directory of TSDB.
 258           '';
 259         };
 260       };
 261
 262       reloader.config-file = mkParam types.str ''
 263         Config file watched by the reloader.
 264       '';
 265
 266       reloader.config-envsubst-file = mkParam types.str ''
 267         Output file for environment variable substituted config file.
 268       '';
 269
 270       reloader.rule-dirs = mkListParam "reloader.rule-dir" ''
 271         Rule directories for the reloader to refresh.
 272       '';
 273
 274     };
 275
 276     store = params.common cfg.store // params.objstore cfg.store // {
 277
 278       stateDir = mkStateDirParam "data-dir" "thanos-store" ''
 279         Data directory relative to `/var/lib`
 280         in which to cache remote blocks.
 281       '';
 282
 283       index-cache-size = mkParamDef types.str "250MB" ''
 284         Maximum size of items held in the index cache.
 285       '';
 286
 287       chunk-pool-size = mkParamDef types.str "2GB" ''
 288         Maximum size of concurrently allocatable bytes for chunks.
 289       '';
 290
 291       store.limits.request-samples = mkParamDef types.int 0 ''
 292         The maximum samples allowed for a single Series request.
 293         The Series call fails if this limit is exceeded.
 294
 295         `0` means no limit.
 296
 297         NOTE: For efficiency the limit is internally implemented as 'chunks limit'
 298         considering each chunk contains a maximum of 120 samples.
 299       '';
 300
 301       store.grpc.series-max-concurrency = mkParamDef types.int 20 ''
 302         Maximum number of concurrent Series calls.
 303       '';
 304
 305       sync-block-duration = mkParamDef types.str "3m" ''
 306         Repeat interval for syncing the blocks between local and remote view.
 307       '';
 308
 309       block-sync-concurrency = mkParamDef types.int 20 ''
 310         Number of goroutines to use when syncing blocks from object storage.
 311       '';
 312
 313       min-time = mkParamDef types.str "0000-01-01T00:00:00Z" ''
 314         Start of time range limit to serve.
 315
 316         Thanos Store serves only metrics, which happened later than this
 317         value. Option can be a constant time in RFC3339 format or time duration
 318         relative to current time, such as -1d or 2h45m. Valid duration units are
 319         ms, s, m, h, d, w, y.
 320       '';
 321
 322       max-time = mkParamDef types.str "9999-12-31T23:59:59Z" ''
 323         End of time range limit to serve.
 324
 325         Thanos Store serves only blocks, which happened earlier than this
 326         value. Option can be a constant time in RFC3339 format or time duration
 327         relative to current time, such as -1d or 2h45m. Valid duration units are
 328         ms, s, m, h, d, w, y.
 329       '';
 330     };
 331
 332     query = params.common cfg.query // {
 333
 334       grpc-client-tls-secure = mkFlagParam ''
 335         Use TLS when talking to the gRPC server
 336       '';
 337
 338       grpc-client-tls-cert = mkParam types.str ''
 339         TLS Certificates to use to identify this client to the server
 340       '';
 341
 342       grpc-client-tls-key = mkParam types.str ''
 343         TLS Key for the client's certificate
 344       '';
 345
 346       grpc-client-tls-ca = mkParam types.str ''
 347         TLS CA Certificates to use to verify gRPC servers
 348       '';
 349
 350       grpc-client-server-name = mkParam types.str ''
 351         Server name to verify the hostname on the returned gRPC certificates.
 352         See <https://tools.ietf.org/html/rfc4366#section-3.1>
 353       '';
 354
 355       grpc-compression = mkParam types.str ''
 356         Compression algorithm to use for gRPC requests to other clients.
 357       '';
 358
 359       web.route-prefix = mkParam types.str ''
 360         Prefix for API and UI endpoints.
 361
 362         This allows thanos UI to be served on a sub-path. This option is
 363         analogous to {option}`web.route-prefix` of Promethus.
 364       '';
 365
 366       web.external-prefix = mkParam types.str ''
 367         Static prefix for all HTML links and redirect URLs in the UI query web
 368         interface.
 369
 370         Actual endpoints are still served on / or the
 371         {option}`web.route-prefix`. This allows thanos UI to be served
 372         behind a reverse proxy that strips a URL sub-path.
 373       '';
 374
 375       web.prefix-header = mkParam types.str ''
 376         Name of HTTP request header used for dynamic prefixing of UI links and
 377         redirects.
 378
 379         This option is ignored if the option
 380         `web.external-prefix` is set.
 381
 382         Security risk: enable this option only if a reverse proxy in front of
 383         thanos is resetting the header.
 384
 385         The setting `web.prefix-header="X-Forwarded-Prefix"`
 386         can be useful, for example, if Thanos UI is served via Traefik reverse
 387         proxy with `PathPrefixStrip` option enabled, which
 388         sends the stripped prefix value in `X-Forwarded-Prefix`
 389         header. This allows thanos UI to be served on a sub-path.
 390       '';
 391
 392       query.timeout = mkParamDef types.str "2m" ''
 393         Maximum time to process query by query node.
 394       '';
 395
 396       query.max-concurrent = mkParamDef types.int 20 ''
 397         Maximum number of queries processed concurrently by query node.
 398       '';
 399
 400       query.replica-labels = mkListParam "query.replica-label" ''
 401         Labels to treat as a replica indicator along which data is
 402         deduplicated.
 403
 404         Still you will be able to query without deduplication using
 405         'dedup=false' parameter. Data includes time series, recording
 406         rules, and alerting rules.
 407       '';
 408
 409       selector-labels = mkAttrsParam "selector-label" ''
 410         Query selector labels that will be exposed in info endpoint.
 411       '';
 412
 413       endpoints = mkListParam "endpoint" ''
 414         Addresses of statically configured Thanos API servers (repeatable).
 415
 416         The scheme may be prefixed with 'dns+' or 'dnssrv+' to detect
 417         Thanos API servers through respective DNS lookups.
 418       '';
 419
 420       store.sd-files = mkListParam "store.sd-files" ''
 421         Path to files that contain addresses of store API servers. The path
 422         can be a glob pattern.
 423       '';
 424
 425       store.sd-interval = mkParamDef types.str "5m" ''
 426         Refresh interval to re-read file SD files. It is used as a resync fallback.
 427       '';
 428
 429       store.sd-dns-interval = mkParamDef types.str "30s" ''
 430         Interval between DNS resolutions.
 431       '';
 432
 433       store.unhealthy-timeout = mkParamDef types.str "5m" ''
 434         Timeout before an unhealthy store is cleaned from the store UI page.
 435       '';
 436
 437       query.auto-downsampling = mkFlagParam ''
 438         Enable automatic adjustment (step / 5) to what source of data should
 439         be used in store gateways if no
 440         `max_source_resolution` param is specified.
 441       '';
 442
 443       query.partial-response = mkFlagParam ''
 444         Enable partial response for queries if no
 445         `partial_response` param is specified.
 446       '';
 447
 448       query.default-evaluation-interval = mkParamDef types.str "1m" ''
 449         Set default evaluation interval for sub queries.
 450       '';
 451
 452       store.response-timeout = mkParamDef types.str "0ms" ''
 453         If a Store doesn't send any data in this specified duration then a
 454         Store will be ignored and partial data will be returned if it's
 455         enabled. `0` disables timeout.
 456       '';
 457     };
 458
 459     query-frontend = params.common cfg.query-frontend // {
 460       query-frontend.downstream-url = mkParamDef types.str "http://localhost:9090" ''
 461         URL of downstream Prometheus Query compatible API.
 462       '';
 463     };
 464
 465     rule = params.common cfg.rule // params.objstore cfg.rule // {
 466
 467       labels = mkAttrsParam "label" ''
 468         Labels to be applied to all generated metrics.
 469
 470         Similar to external labels for Prometheus,
 471         used to identify ruler and its blocks as unique source.
 472       '';
 473
 474       stateDir = mkStateDirParam "data-dir" "thanos-rule" ''
 475         Data directory relative to `/var/lib`.
 476       '';
 477
 478       rule-files = mkListParam "rule-file" ''
 479         Rule files that should be used by rule manager. Can be in glob format.
 480       '';
 481
 482       eval-interval = mkParamDef types.str "1m" ''
 483         The default evaluation interval to use.
 484       '';
 485
 486       tsdb.block-duration = mkParamDef types.str "2h" ''
 487         Block duration for TSDB block.
 488       '';
 489
 490       tsdb.retention = mkParamDef types.str "48h" ''
 491         Block retention time on local disk.
 492       '';
 493
 494       alertmanagers.urls = mkListParam "alertmanagers.url" ''
 495         Alertmanager replica URLs to push firing alerts.
 496
 497         Ruler claims success if push to at least one alertmanager from
 498         discovered succeeds. The scheme may be prefixed with
 499         `dns+` or `dnssrv+` to detect
 500         Alertmanager IPs through respective DNS lookups. The port defaults to
 501         `9093` or the SRV record's value. The URL path is
 502         used as a prefix for the regular Alertmanager API path.
 503       '';
 504
 505       alertmanagers.send-timeout = mkParamDef types.str "10s" ''
 506         Timeout for sending alerts to alertmanager.
 507       '';
 508
 509       alert.query-url = mkParam types.str ''
 510         The external Thanos Query URL that would be set in all alerts 'Source' field.
 511       '';
 512
 513       alert.label-drop = mkListParam "alert.label-drop" ''
 514         Labels by name to drop before sending to alertmanager.
 515
 516         This allows alert to be deduplicated on replica label.
 517
 518         Similar Prometheus alert relabelling
 519       '';
 520
 521       web.route-prefix = mkParam types.str ''
 522         Prefix for API and UI endpoints.
 523
 524         This allows thanos UI to be served on a sub-path.
 525
 526         This option is analogous to `--web.route-prefix` of Promethus.
 527       '';
 528
 529       web.external-prefix = mkParam types.str ''
 530         Static prefix for all HTML links and redirect URLs in the UI query web
 531         interface.
 532
 533         Actual endpoints are still served on / or the
 534         {option}`web.route-prefix`. This allows thanos UI to be served
 535         behind a reverse proxy that strips a URL sub-path.
 536       '';
 537
 538       web.prefix-header = mkParam types.str ''
 539         Name of HTTP request header used for dynamic prefixing of UI links and
 540         redirects.
 541
 542         This option is ignored if the option
 543         {option}`web.external-prefix` is set.
 544
 545         Security risk: enable this option only if a reverse proxy in front of
 546         thanos is resetting the header.
 547
 548         The header `X-Forwarded-Prefix` can be useful, for
 549         example, if Thanos UI is served via Traefik reverse proxy with
 550         `PathPrefixStrip` option enabled, which sends the
 551         stripped prefix value in `X-Forwarded-Prefix`
 552         header. This allows thanos UI to be served on a sub-path.
 553       '';
 554
 555       query.addresses = mkListParam "query" ''
 556         Addresses of statically configured query API servers.
 557
 558         The scheme may be prefixed with `dns+` or
 559         `dnssrv+` to detect query API servers through
 560         respective DNS lookups.
 561       '';
 562
 563       query.sd-files = mkListParam "query.sd-files" ''
 564         Path to file that contain addresses of query peers.
 565         The path can be a glob pattern.
 566       '';
 567
 568       query.sd-interval = mkParamDef types.str "5m" ''
 569         Refresh interval to re-read file SD files. (used as a fallback)
 570       '';
 571
 572       query.sd-dns-interval = mkParamDef types.str "30s" ''
 573         Interval between DNS resolutions.
 574       '';
 575     };
 576
 577     compact = params.log // params.tracing cfg.compact // params.objstore cfg.compact // {
 578
 579       http-address = mkParamDef types.str "0.0.0.0:10902" ''
 580         Listen `host:port` for HTTP endpoints.
 581       '';
 582
 583       stateDir = mkStateDirParam "data-dir" "thanos-compact" ''
 584         Data directory relative to `/var/lib`
 585         in which to cache blocks and process compactions.
 586       '';
 587
 588       consistency-delay = mkParamDef types.str "30m" ''
 589         Minimum age of fresh (non-compacted) blocks before they are being
 590         processed. Malformed blocks older than the maximum of consistency-delay
 591         and 30m0s will be removed.
 592       '';
 593
 594       retention.resolution-raw = mkParamDef types.str "0d" ''
 595         How long to retain raw samples in bucket.
 596
 597         `0d` - disables this retention
 598       '';
 599
 600       retention.resolution-5m = mkParamDef types.str "0d" ''
 601         How long to retain samples of resolution 1 (5 minutes) in bucket.
 602
 603         `0d` - disables this retention
 604       '';
 605
 606       retention.resolution-1h = mkParamDef types.str "0d" ''
 607         How long to retain samples of resolution 2 (1 hour) in bucket.
 608
 609         `0d` - disables this retention
 610       '';
 611
 612       startAt = {
 613         toArgs = _opt: startAt: flagToArgs "wait" (startAt == null);
 614         option = nullOpt types.str ''
 615           When this option is set to a `systemd.time`
 616           specification the Thanos compactor will run at the specified period.
 617
 618           When this option is `null` the Thanos compactor service
 619           will run continuously. So it will not exit after all compactions have
 620           been processed but wait for new work.
 621         '';
 622       };
 623
 624       downsampling.disable = mkFlagParam ''
 625         Disables downsampling.
 626
 627         This is not recommended as querying long time ranges without
 628         non-downsampled data is not efficient and useful e.g it is not possible
 629         to render all samples for a human eye anyway
 630       '';
 631
 632       compact.concurrency = mkParamDef types.int 1 ''
 633         Number of goroutines to use when compacting groups.
 634       '';
 635     };
 636
 637     downsample = params.log // params.tracing cfg.downsample // params.objstore cfg.downsample // {
 638
 639       stateDir = mkStateDirParam "data-dir" "thanos-downsample" ''
 640         Data directory relative to `/var/lib`
 641         in which to cache blocks and process downsamplings.
 642       '';
 643
 644     };
 645
 646     receive = params.common cfg.receive // params.objstore cfg.receive // {
 647
 648       receive.grpc-compression = mkParam types.str ''
 649         Compression algorithm to use for gRPC requests to other receivers.
 650       '';
 651
 652       remote-write.address = mkParamDef types.str "0.0.0.0:19291" ''
 653         Address to listen on for remote write requests.
 654       '';
 655
 656       stateDir = mkStateDirParam "tsdb.path" "thanos-receive" ''
 657         Data directory relative to `/var/lib` of TSDB.
 658       '';
 659
 660       labels = mkAttrsParam "label" ''
 661         External labels to announce.
 662
 663         This flag will be removed in the future when handling multiple tsdb
 664         instances is added.
 665       '';
 666
 667       tsdb.retention = mkParamDef types.str "15d" ''
 668         How long to retain raw samples on local storage.
 669
 670         `0d` - disables this retention
 671       '';
 672     };
 673
 674   };
 675
 676   assertRelativeStateDir = cmd: {
 677     assertions = [
 678       {
 679         assertion = !hasPrefix "/" cfg.${cmd}.stateDir;
 680         message =
 681           "The option services.thanos.${cmd}.stateDir should not be an absolute directory." +
 682           " It should be a directory relative to /var/lib.";
 683       }
 684     ];
 685   };
 686
 687 in {
 688
 689   options.services.thanos = {
 690
 691     package = mkPackageOption pkgs "thanos" {};
 692
 693     sidecar = paramsToOptions params.sidecar // {
 694       enable = mkEnableOption "the Thanos sidecar for Prometheus server";
 695       arguments = mkArgumentsOption "sidecar";
 696     };
 697
 698     store = paramsToOptions params.store // {
 699       enable = mkEnableOption "the Thanos store node giving access to blocks in a bucket provider";
 700       arguments = mkArgumentsOption "store";
 701     };
 702
 703     query = paramsToOptions params.query // {
 704       enable = mkEnableOption ("the Thanos query node exposing PromQL enabled Query API " +
 705          "with data retrieved from multiple store nodes");
 706       arguments = mkArgumentsOption "query";
 707     };
 708
 709     query-frontend = paramsToOptions params.query-frontend // {
 710       enable = mkEnableOption ("the Thanos query frontend implements a service deployed in front of queriers to
 711           improve query parallelization and caching.");
 712       arguments = mkArgumentsOption "query-frontend";
 713     };
 714
 715     rule = paramsToOptions params.rule // {
 716       enable = mkEnableOption ("the Thanos ruler service which evaluates Prometheus rules against" +
 717         " given Query nodes, exposing Store API and storing old blocks in bucket");
 718       arguments = mkArgumentsOption "rule";
 719     };
 720
 721     compact = paramsToOptions params.compact // {
 722       enable = mkEnableOption "the Thanos compactor which continuously compacts blocks in an object store bucket";
 723       arguments = mkArgumentsOption "compact";
 724     };
 725
 726     downsample = paramsToOptions params.downsample // {
 727       enable = mkEnableOption "the Thanos downsampler which continuously downsamples blocks in an object store bucket";
 728       arguments = mkArgumentsOption "downsample";
 729     };
 730
 731     receive = paramsToOptions params.receive // {
 732       enable = mkEnableOption ("the Thanos receiver which accept Prometheus remote write API requests and write to local tsdb");
 733       arguments = mkArgumentsOption "receive";
 734     };
 735   };
 736
 737   config = mkMerge [
 738
 739     (mkIf cfg.sidecar.enable {
 740       assertions = [
 741         {
 742           assertion = config.services.prometheus.enable;
 743           message =
 744             "Please enable services.prometheus when enabling services.thanos.sidecar.";
 745         }
 746         {
 747           assertion = !(config.services.prometheus.globalConfig.external_labels == null ||
 748                         config.services.prometheus.globalConfig.external_labels == {});
 749           message =
 750             "services.thanos.sidecar requires uniquely identifying external labels " +
 751             "to be configured in the Prometheus server. " +
 752             "Please set services.prometheus.globalConfig.external_labels.";
 753         }
 754       ];
 755       systemd.services.thanos-sidecar = {
 756         wantedBy = [ "multi-user.target" ];
 757         after    = [ "network.target" "prometheus.service" ];
 758         serviceConfig = {
 759           User = "prometheus";
 760           Restart = "always";
 761           ExecStart = thanos "sidecar";
 762           ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
 763         };
 764       };
 765     })
 766
 767     (mkIf cfg.store.enable (mkMerge [
 768       (assertRelativeStateDir "store")
 769       {
 770         systemd.services.thanos-store = {
 771           wantedBy = [ "multi-user.target" ];
 772           after    = [ "network.target" ];
 773           serviceConfig = {
 774             DynamicUser = true;
 775             StateDirectory = cfg.store.stateDir;
 776             Restart = "always";
 777             ExecStart = thanos "store";
 778             ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
 779           };
 780         };
 781       }
 782     ]))
 783
 784     (mkIf cfg.query.enable {
 785       systemd.services.thanos-query = {
 786         wantedBy = [ "multi-user.target" ];
 787         after    = [ "network.target" ];
 788         serviceConfig = {
 789           DynamicUser = true;
 790           Restart = "always";
 791           ExecStart = thanos "query";
 792           ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
 793         };
 794       };
 795     })
 796
 797     (mkIf cfg.query-frontend.enable {
 798       systemd.services.thanos-query-frontend = {
 799         wantedBy = [ "multi-user.target" ];
 800         after    = [ "network.target" ];
 801         serviceConfig = {
 802           DynamicUser = true;
 803           Restart = "always";
 804           ExecStart = thanos "query-frontend";
 805           ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
 806         };
 807       };
 808     })
 809
 810     (mkIf cfg.rule.enable (mkMerge [
 811       (assertRelativeStateDir "rule")
 812       {
 813         systemd.services.thanos-rule = {
 814           wantedBy = [ "multi-user.target" ];
 815           after    = [ "network.target" ];
 816           serviceConfig = {
 817             DynamicUser = true;
 818             StateDirectory = cfg.rule.stateDir;
 819             Restart = "always";
 820             ExecStart = thanos "rule";
 821             ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
 822           };
 823         };
 824       }
 825     ]))
 826
 827     (mkIf cfg.compact.enable (mkMerge [
 828       (assertRelativeStateDir "compact")
 829       {
 830         systemd.services.thanos-compact =
 831           let wait = cfg.compact.startAt == null; in {
 832             wantedBy = [ "multi-user.target" ];
 833             after    = [ "network.target" ];
 834             serviceConfig = {
 835               Type    = if wait then "simple" else "oneshot";
 836               Restart = if wait then "always" else "no";
 837               DynamicUser = true;
 838               StateDirectory = cfg.compact.stateDir;
 839               ExecStart = thanos "compact";
 840               ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
 841             };
 842           } // optionalAttrs (!wait) { inherit (cfg.compact) startAt; };
 843       }
 844     ]))
 845
 846     (mkIf cfg.downsample.enable (mkMerge [
 847       (assertRelativeStateDir "downsample")
 848       {
 849         systemd.services.thanos-downsample = {
 850           wantedBy = [ "multi-user.target" ];
 851           after    = [ "network.target" ];
 852           serviceConfig = {
 853             DynamicUser = true;
 854             StateDirectory = cfg.downsample.stateDir;
 855             Restart = "always";
 856             ExecStart = thanos "downsample";
 857             ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
 858           };
 859         };
 860       }
 861     ]))
 862
 863     (mkIf cfg.receive.enable (mkMerge [
 864       (assertRelativeStateDir "receive")
 865       {
 866         systemd.services.thanos-receive = {
 867           wantedBy = [ "multi-user.target" ];
 868           after    = [ "network.target" ];
 869           serviceConfig = {
 870             DynamicUser = true;
 871             StateDirectory = cfg.receive.stateDir;
 872             Restart = "always";
 873             ExecStart = thanos "receive";
 874             ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";
 875           };
 876         };
 877       }
 878     ]))
 879
 880   ];
 881 }