nixos/modules/services/monitoring/thanos.nix

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