commit 9cacd7ee42b045ac1d0112d3b358718bfdbd6cd2 · pyrox.dev/nixpkgs

nixos/doc/manual/release-notes/rl-2505.section.md

···

       166
        
       

     

       167
        
       - [OliveTin](https://www.olivetin.app/), gives safe and simple access to predefined shell commands from a web interface. Available as [services.olivetin](#opt-services.olivetin.enable).

     

       168
        
       

     

       0
        
       
     

       0
        
       
     

       169
        
       - [Stash](https://github.com/stashapp/stash), An organizer for your adult videos/images, written in Go. Available as [services.stash](#opt-services.stash.enable).

     

       170
        
       

     

       171
        
       - [vsmartcard-vpcd](https://frankmorgner.github.io/vsmartcard/virtualsmartcard/README.html), a virtual smart card driver. Available as [services.vsmartcard-vpcd](#opt-services.vsmartcard-vpcd.enable).

···

       166
        
       

     

       167
        
       - [OliveTin](https://www.olivetin.app/), gives safe and simple access to predefined shell commands from a web interface. Available as [services.olivetin](#opt-services.olivetin.enable).

     

       168
        
       

     

       169
       +
       - [alertmanager-ntfy](https://github.com/alexbakker/alertmanager-ntfy), forwards Prometheus Alertmanager notifications to ntfy.sh. Available as [services.prometheus.alertmanager-ntfy](#opt-services.prometheus.alertmanager-ntfy.enable).

     

       170
       +
       

     

       171
        
       - [Stash](https://github.com/stashapp/stash), An organizer for your adult videos/images, written in Go. Available as [services.stash](#opt-services.stash.enable).

     

       172
        
       

     

       173
        
       - [vsmartcard-vpcd](https://frankmorgner.github.io/vsmartcard/virtualsmartcard/README.html), a virtual smart card driver. Available as [services.vsmartcard-vpcd](#opt-services.vsmartcard-vpcd.enable).

nixos/modules/module-list.nix

···

       985
        
         ./services/monitoring/pgscv.nix

     

       986
        
         ./services/monitoring/prometheus/alertmanager-gotify-bridge.nix

     

       987
        
         ./services/monitoring/prometheus/alertmanager-irc-relay.nix

     

       0
        
       
     

       988
        
         ./services/monitoring/prometheus/alertmanager-webhook-logger.nix

     

       989
        
         ./services/monitoring/prometheus/alertmanager.nix

     

       990
        
         ./services/monitoring/prometheus/default.nix

···

       985
        
         ./services/monitoring/pgscv.nix

     

       986
        
         ./services/monitoring/prometheus/alertmanager-gotify-bridge.nix

     

       987
        
         ./services/monitoring/prometheus/alertmanager-irc-relay.nix

     

       988
       +
         ./services/monitoring/prometheus/alertmanager-ntfy.nix

     

       989
        
         ./services/monitoring/prometheus/alertmanager-webhook-logger.nix

     

       990
        
         ./services/monitoring/prometheus/alertmanager.nix

     

       991
        
         ./services/monitoring/prometheus/default.nix

+201

nixos/modules/services/monitoring/prometheus/alertmanager-ntfy.nix

···

       1
       +
       {

     

       2
       +
         config,

     

       3
       +
         lib,

     

       4
       +
         pkgs,

     

       5
       +
         ...

     

       6
       +
       }:

     

       7
       +
       

     

       8
       +
       let

     

       9
       +
         cfg = config.services.prometheus.alertmanager-ntfy;

     

       10
       +
       

     

       11
       +
         settingsFormat = pkgs.formats.yaml { };

     

       12
       +
         settingsFile = settingsFormat.generate "settings.yml" cfg.settings;

     

       13
       +
       

     

       14
       +
         configsArg = lib.concatStringsSep "," (

     

       15
       +
           [ settingsFile ] ++ lib.imap0 (i: _: "%d/config-${toString i}.yml") cfg.extraConfigFiles

     

       16
       +
         );

     

       17
       +
       in

     

       18
       +
       

     

       19
       +
       {

     

       20
       +
         meta.maintainers = with lib.maintainers; [ defelo ];

     

       21
       +
       

     

       22
       +
         options.services.prometheus.alertmanager-ntfy = {

     

       23
       +
           enable = lib.mkEnableOption "alertmanager-ntfy";

     

       24
       +
       

     

       25
       +
           package = lib.mkPackageOption pkgs "alertmanager-ntfy" { };

     

       26
       +
       

     

       27
       +
           settings = lib.mkOption {

     

       28
       +
             description = ''

     

       29
       +
               Configuration of alertmanager-ntfy.

     

       30
       +
               See <https://github.com/alexbakker/alertmanager-ntfy> for more information.

     

       31
       +
             '';

     

       32
       +
             default = { };

     

       33
       +
       

     

       34
       +
             type = lib.types.submodule {

     

       35
       +
               freeformType = settingsFormat.type;

     

       36
       +
       

     

       37
       +
               options = {

     

       38
       +
                 http.addr = lib.mkOption {

     

       39
       +
                   type = lib.types.str;

     

       40
       +
                   description = "The address to listen on.";

     

       41
       +
                   default = "127.0.0.1:8000";

     

       42
       +
                   example = ":8000";

     

       43
       +
                 };

     

       44
       +
       

     

       45
       +
                 ntfy = {

     

       46
       +
                   baseurl = lib.mkOption {

     

       47
       +
                     type = lib.types.str;

     

       48
       +
                     description = "The base URL of the ntfy.sh instance.";

     

       49
       +
                     example = "https://ntfy.sh";

     

       50
       +
                   };

     

       51
       +
       

     

       52
       +
                   notification = {

     

       53
       +
                     topic = lib.mkOption {

     

       54
       +
                       type = lib.types.str;

     

       55
       +
                       description = ''

     

       56
       +
                         The topic to which alerts should be published.

     

       57
       +
                         Can either be a hardcoded string or a gval expression that evaluates to a string.

     

       58
       +
                       '';

     

       59
       +
                       example = "alertmanager";

     

       60
       +
                     };

     

       61
       +
       

     

       62
       +
                     priority = lib.mkOption {

     

       63
       +
                       type = lib.types.str;

     

       64
       +
                       description = ''

     

       65
       +
                         The ntfy.sh message priority (see <https://docs.ntfy.sh/publish/#message-priority> for more information).

     

       66
       +
                         Can either be a hardcoded string or a gval expression that evaluates to a string.

     

       67
       +
                       '';

     

       68
       +
                       default = ''status == "firing" ? "high" : "default"'';

     

       69
       +
                     };

     

       70
       +
       

     

       71
       +
                     tags = lib.mkOption {

     

       72
       +
                       type = lib.types.listOf (

     

       73
       +
                         lib.types.submodule {

     

       74
       +
                           options = {

     

       75
       +
                             tag = lib.mkOption {

     

       76
       +
                               type = lib.types.str;

     

       77
       +
                               description = ''

     

       78
       +
                                 The tag to add.

     

       79
       +
                                 See <https://docs.ntfy.sh/emojis> for a list of all supported emojis.

     

       80
       +
                               '';

     

       81
       +
                               example = "rotating_light";

     

       82
       +
                             };

     

       83
       +
       

     

       84
       +
                             condition = lib.mkOption {

     

       85
       +
                               type = lib.types.nullOr lib.types.str;

     

       86
       +
                               description = ''

     

       87
       +
                                 The condition under which this tag should be added.

     

       88
       +
                                 Tags with no condition are always included.

     

       89
       +
                               '';

     

       90
       +
                               default = null;

     

       91
       +
                               example = ''status == "firing"'';

     

       92
       +
                             };

     

       93
       +
                           };

     

       94
       +
                         }

     

       95
       +
                       );

     

       96
       +
                       description = ''

     

       97
       +
                         Tags to add to ntfy.sh messages.

     

       98
       +
                         See <https://docs.ntfy.sh/publish/#tags-emojis> for more information.

     

       99
       +
                       '';

     

       100
       +
                       default = [

     

       101
       +
                         {

     

       102
       +
                           tag = "green_circle";

     

       103
       +
                           condition = ''status == "resolved"'';

     

       104
       +
                         }

     

       105
       +
                         {

     

       106
       +
                           tag = "red_circle";

     

       107
       +
                           condition = ''status == "firing"'';

     

       108
       +
                         }

     

       109
       +
                       ];

     

       110
       +
                     };

     

       111
       +
       

     

       112
       +
                     templates = {

     

       113
       +
                       title = lib.mkOption {

     

       114
       +
                         type = lib.types.str;

     

       115
       +
                         description = "The ntfy.sh message title template.";

     

       116
       +
                         default = ''

     

       117
       +
                           {{ if eq .Status "resolved" }}Resolved: {{ end }}{{ index .Annotations "summary" }}

     

       118
       +
                         '';

     

       119
       +
                       };

     

       120
       +
       

     

       121
       +
                       description = lib.mkOption {

     

       122
       +
                         type = lib.types.str;

     

       123
       +
                         description = "The ntfy.sh message description template.";

     

       124
       +
                         default = ''

     

       125
       +
                           {{ index .Annotations "description" }}

     

       126
       +
                         '';

     

       127
       +
                       };

     

       128
       +
                     };

     

       129
       +
                   };

     

       130
       +
                 };

     

       131
       +
               };

     

       132
       +
             };

     

       133
       +
           };

     

       134
       +
       

     

       135
       +
           extraConfigFiles = lib.mkOption {

     

       136
       +
             type = lib.types.listOf lib.types.path;

     

       137
       +
             default = [ ];

     

       138
       +
             example = [ "/run/secrets/alertmanager-ntfy.yml" ];

     

       139
       +
             description = ''

     

       140
       +
               Config files to merge into the settings defined in [](#opt-services.prometheus.alertmanager-ntfy.settings).

     

       141
       +
               This is useful to avoid putting secrets into the Nix store.

     

       142
       +
               See <https://github.com/alexbakker/alertmanager-ntfy> for more information.

     

       143
       +
             '';

     

       144
       +
           };

     

       145
       +
         };

     

       146
       +
       

     

       147
       +
         config = lib.mkIf cfg.enable {

     

       148
       +
           systemd.services.alertmanager-ntfy = {

     

       149
       +
             wantedBy = [ "multi-user.target" ];

     

       150
       +
       

     

       151
       +
             wants = [ "network-online.target" ];

     

       152
       +
             after = [ "network-online.target" ];

     

       153
       +
       

     

       154
       +
             serviceConfig = {

     

       155
       +
               User = "alertmanager-ntfy";

     

       156
       +
               Group = "alertmanager-ntfy";

     

       157
       +
               DynamicUser = true;

     

       158
       +
       

     

       159
       +
               LoadCredential = lib.imap0 (i: path: "config-${toString i}.yml:${path}") cfg.extraConfigFiles;

     

       160
       +
       

     

       161
       +
               ExecStart = "${lib.getExe cfg.package} --configs ${configsArg}";

     

       162
       +
       

     

       163
       +
               Restart = "always";

     

       164
       +
               RestartSec = 5;

     

       165
       +
       

     

       166
       +
               # Hardening

     

       167
       +
               AmbientCapabilities = "";

     

       168
       +
               CapabilityBoundingSet = [ "" ];

     

       169
       +
               DevicePolicy = "closed";

     

       170
       +
               LockPersonality = true;

     

       171
       +
               MemoryDenyWriteExecute = true;

     

       172
       +
               NoNewPrivileges = true;

     

       173
       +
               PrivateDevices = true;

     

       174
       +
               PrivateTmp = true;

     

       175
       +
               PrivateUsers = true;

     

       176
       +
               ProcSubset = "pid";

     

       177
       +
               ProtectClock = true;

     

       178
       +
               ProtectControlGroups = true;

     

       179
       +
               ProtectHome = true;

     

       180
       +
               ProtectHostname = true;

     

       181
       +
               ProtectKernelLogs = true;

     

       182
       +
               ProtectKernelModules = true;

     

       183
       +
               ProtectKernelTunables = true;

     

       184
       +
               ProtectProc = "invisible";

     

       185
       +
               ProtectSystem = "strict";

     

       186
       +
               RemoveIPC = true;

     

       187
       +
               RestrictAddressFamilies = [ "AF_INET AF_INET6" ];

     

       188
       +
               RestrictNamespaces = true;

     

       189
       +
               RestrictRealtime = true;

     

       190
       +
               RestrictSUIDSGID = true;

     

       191
       +
               SystemCallArchitectures = "native";

     

       192
       +
               SystemCallFilter = [

     

       193
       +
                 "@system-service"

     

       194
       +
                 "~@privileged"

     

       195
       +
                 "~@resources"

     

       196
       +
               ];

     

       197
       +
               UMask = "0077";

     

       198
       +
             };

     

       199
       +
           };

     

       200
       +
         };

     

       201
       +
       }

+1 -1

nixos/tests/all-tests.nix

···

       1117
        
         private-gpt = handleTest ./private-gpt.nix { };

     

       1118
        
         privatebin = runTest ./privatebin.nix;

     

       1119
        
         privoxy = handleTest ./privoxy.nix { };

     

       1120
       -
         prometheus = handleTest ./prometheus { };

     

       1121
        
         prometheus-exporters = handleTest ./prometheus-exporters.nix { };

     

       1122
        
         prosody = handleTest ./xmpp/prosody.nix { };

     

       1123
        
         prosody-mysql = handleTest ./xmpp/prosody-mysql.nix { };

···

       1117
        
         private-gpt = handleTest ./private-gpt.nix { };

     

       1118
        
         privatebin = runTest ./privatebin.nix;

     

       1119
        
         privoxy = handleTest ./privoxy.nix { };

     

       1120
       +
         prometheus = import ./prometheus { inherit runTest; };

     

       1121
        
         prometheus-exporters = handleTest ./prometheus-exporters.nix { };

     

       1122
        
         prosody = handleTest ./xmpp/prosody.nix { };

     

       1123
        
         prosody-mysql = handleTest ./xmpp/prosody-mysql.nix { };

+99

nixos/tests/prometheus/alertmanager-ntfy.nix

···

       1
       +
       { lib, ... }:

     

       2
       +
       

     

       3
       +
       let

     

       4
       +
         ports = {

     

       5
       +
           alertmanager-ntfy = 8000;

     

       6
       +
           ntfy-sh = 8001;

     

       7
       +
           alertmanager = 8002;

     

       8
       +
         };

     

       9
       +
       in

     

       10
       +
       

     

       11
       +
       {

     

       12
       +
         name = "alertmanager-ntfy";

     

       13
       +
         meta.maintainers = with lib.maintainers; [ defelo ];

     

       14
       +
       

     

       15
       +
         nodes.machine = {

     

       16
       +
           services.prometheus.alertmanager = {

     

       17
       +
             enable = true;

     

       18
       +
             listenAddress = "127.0.0.1";

     

       19
       +
             port = ports.alertmanager;

     

       20
       +
       

     

       21
       +
             configuration = {

     

       22
       +
               route = {

     

       23
       +
                 receiver = "test";

     

       24
       +
                 group_by = [ "..." ];

     

       25
       +
                 group_wait = "0s";

     

       26
       +
                 group_interval = "1s";

     

       27
       +
                 repeat_interval = "2h";

     

       28
       +
               };

     

       29
       +
       

     

       30
       +
               receivers = [

     

       31
       +
                 {

     

       32
       +
                   name = "test";

     

       33
       +
                   webhook_configs = [ { url = "http://127.0.0.1:${toString ports.alertmanager-ntfy}/hook"; } ];

     

       34
       +
                 }

     

       35
       +
               ];

     

       36
       +
             };

     

       37
       +
           };

     

       38
       +
       

     

       39
       +
           services.prometheus.alertmanager-ntfy = {

     

       40
       +
             enable = true;

     

       41
       +
             settings = {

     

       42
       +
               http.addr = "127.0.0.1:${toString ports.alertmanager-ntfy}";

     

       43
       +
               ntfy = {

     

       44
       +
                 baseurl = "http://127.0.0.1:${toString ports.ntfy-sh}";

     

       45
       +
                 notification.topic = "alertmanager";

     

       46
       +
               };

     

       47
       +
             };

     

       48
       +
           };

     

       49
       +
       

     

       50
       +
           services.ntfy-sh = {

     

       51
       +
             enable = true;

     

       52
       +
             settings = {

     

       53
       +
               listen-http = "127.0.0.1:${toString ports.ntfy-sh}";

     

       54
       +
               base-url = "http://127.0.0.1:${toString ports.ntfy-sh}";

     

       55
       +
             };

     

       56
       +
           };

     

       57
       +
         };

     

       58
       +
       

     

       59
       +
         interactive.nodes.machine = {

     

       60
       +
           services.prometheus.alertmanager.listenAddress = lib.mkForce "0.0.0.0";

     

       61
       +
           services.prometheus.alertmanager-ntfy.settings.http.addr =

     

       62
       +
             lib.mkForce "0.0.0.0:${toString ports.alertmanager-ntfy}";

     

       63
       +
           services.ntfy-sh.settings.listen-http = lib.mkForce "0.0.0.0:${toString ports.ntfy-sh}";

     

       64
       +
           networking.firewall.enable = false;

     

       65
       +
           virtualisation.forwardPorts = lib.mapAttrsToList (_: port: {

     

       66
       +
             from = "host";

     

       67
       +
             host = { inherit port; };

     

       68
       +
             guest = { inherit port; };

     

       69
       +
           }) ports;

     

       70
       +
         };

     

       71
       +
       

     

       72
       +
         testScript = ''

     

       73
       +
           import json

     

       74
       +
           import time

     

       75
       +
       

     

       76
       +
           machine.wait_for_unit("alertmanager.service")

     

       77
       +
           machine.wait_for_unit("alertmanager-ntfy.service")

     

       78
       +
           machine.wait_for_unit("ntfy-sh.service")

     

       79
       +
           machine.wait_for_open_port(${toString ports.alertmanager})

     

       80
       +
           machine.wait_for_open_port(${toString ports.alertmanager-ntfy})

     

       81
       +
           machine.wait_for_open_port(${toString ports.ntfy-sh})

     

       82
       +
       

     

       83
       +
           machine.succeed("""curl 127.0.0.1:${toString ports.alertmanager}/api/v2/alerts \

     

       84
       +
             -X POST -H 'Content-Type: application/json' \

     

       85
       +
             -d '[{ \

     

       86
       +
               "labels": {"alertname": "test"},

     

       87
       +
               "annotations": {"summary": "alert summary", "description": "alert description"} \

     

       88
       +
             }]'""")

     

       89
       +
       

     

       90
       +
           while not (resp := machine.succeed("curl '127.0.0.1:${toString ports.ntfy-sh}/alertmanager/json?poll=1'")):

     

       91
       +
             time.sleep(1)

     

       92
       +
       

     

       93
       +
           msg = json.loads(resp)

     

       94
       +
           assert msg["title"] == "alert summary"

     

       95
       +
           assert msg["message"] == "alert description"

     

       96
       +
           assert msg["priority"] == 4

     

       97
       +
           assert "red_circle" in msg["tags"]

     

       98
       +
         '';

     

       99
       +
       }

+119 -133

nixos/tests/prometheus/alertmanager.nix

···

       1
       -
       import ../make-test-python.nix (

     

       2
       -
         { lib, pkgs, ... }:

     

       3
        
       

     

       4
       -
         {

     

       5
       -
           name = "prometheus-alertmanager";

     

       6
        
       

     

       7
       -
           nodes = {

     

       8
       -
             prometheus =

     

       9
       -
               { config, pkgs, ... }:

     

       10
       -
               {

     

       11
       -
                 environment.systemPackages = [ pkgs.jq ];

     

       12
        
       

     

       13
       -
                 networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       14
        
       

     

       15
       -
                 services.prometheus = {

     

       16
       -
                   enable = true;

     

       17
       -
                   globalConfig.scrape_interval = "2s";

     

       18
        
       

     

       19
       -
                   alertmanagers = [

     

       20
       -
                     {

     

       21
       -
                       scheme = "http";

     

       22
       -
                       static_configs = [

     

       23
       -
                         {

     

       24
       -
                           targets = [

     

       25
       -
                             "alertmanager:${toString config.services.prometheus.alertmanager.port}"

     

       26
       -
                           ];

     

       27
       -
                         }

     

       28
       -
                       ];

     

       29
       -
                     }

     

       30
       -
                   ];

     

       31
        
       

     

       32
       -
                   rules = [

     

       33
       -
                     ''

     

       34
       -
                       groups:

     

       35
       -
                         - name: test

     

       36
       -
                           rules:

     

       37
       -
                             - alert: InstanceDown

     

       38
       -
                               expr: up == 0

     

       39
       -
                               for: 5s

     

       40
       -
                               labels:

     

       41
       -
                                 severity: page

     

       42
       -
                               annotations:

     

       43
       -
                                 summary: "Instance {{ $labels.instance }} down"

     

       44
       -
                     ''

     

       45
       -
                   ];

     

       46
        
       

     

       47
       -
                   scrapeConfigs = [

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       48
        
                     {

     

       49
       -
                       job_name = "alertmanager";

     

       50
       -
                       static_configs = [

     

       51
       -
                         {

     

       52
       -
                           targets = [

     

       53
       -
                             "alertmanager:${toString config.services.prometheus.alertmanager.port}"

     

       54
       -
                           ];

     

       55
       -
                         }

     

       56
       -
                       ];

     

       57
       -
                     }

     

       58
       -
                     {

     

       59
       -
                       job_name = "node";

     

       60
       -
                       static_configs = [

     

       61
        
                         {

     

       62
       -
                           targets = [

     

       63
       -
                             "node:${toString config.services.prometheus.exporters.node.port}"

     

       64
       -
                           ];

     

       65
        
                         }

     

       66
        
                       ];

     

       67
        
                     }

     

       68
        
                   ];

     

       69
        
                 };

     

       70
        
               };

     

       0
        
       
     

       71
        
       

     

       72
       -
             alertmanager =

     

       73
       -
               { config, pkgs, ... }:

     

       74
       -
               {

     

       75
       -
                 services.prometheus.alertmanager = {

     

       76
       -
                   enable = true;

     

       77
       -
                   openFirewall = true;

     

       78
        
       

     

       79
       -
                   configuration = {

     

       80
       -
                     global = {

     

       81
       -
                       resolve_timeout = "1m";

     

       82
       -
                     };

     

       83
        
       

     

       84
       -
                     route = {

     

       85
       -
                       # Root route node

     

       86
       -
                       receiver = "test";

     

       87
       -
                       group_by = [ "..." ];

     

       88
       -
                       continue = false;

     

       89
       -
                       group_wait = "1s";

     

       90
       -
                       group_interval = "15s";

     

       91
       -
                       repeat_interval = "24h";

     

       92
       -
                     };

     

       93
       -
       

     

       94
       -
                     receivers = [

     

       95
       -
                       {

     

       96
       -
                         name = "test";

     

       97
       -
                         webhook_configs = [

     

       98
       -
                           {

     

       99
       -
                             url = "http://logger:6725";

     

       100
       -
                             send_resolved = true;

     

       101
       -
                             max_alerts = 0;

     

       102
       -
                           }

     

       103
       -
                         ];

     

       104
       -
                       }

     

       105
       -
                     ];

     

       106
       -
                   };

     

       107
       -
                 };

     

       108
       -
               };

     

       109
       -
       

     

       110
       -
             logger =

     

       111
       -
               { config, pkgs, ... }:

     

       112
       -
               {

     

       113
       -
                 networking.firewall.allowedTCPPorts = [ 6725 ];

     

       114
       -
       

     

       115
       -
                 services.prometheus.alertmanagerWebhookLogger.enable = true;

     

       116
       -
               };

     

       117
       -
           };

     

       118
       -
       

     

       119
       -
           testScript = ''

     

       120
       -
             alertmanager.wait_for_unit("alertmanager")

     

       121
       -
             alertmanager.wait_for_open_port(9093)

     

       122
       -
             alertmanager.wait_until_succeeds("curl -s http://127.0.0.1:9093/-/ready")

     

       123
       -
             #alertmanager.wait_until_succeeds("journalctl -o cat -u alertmanager.service | grep 'version=${pkgs.prometheus-alertmanager.version}'")

     

       124
        
       

     

       125
       -
             logger.wait_for_unit("alertmanager-webhook-logger")

     

       126
       -
             logger.wait_for_open_port(6725)

     

       127
        
       

     

       128
       -
             prometheus.wait_for_unit("prometheus")

     

       129
       -
             prometheus.wait_for_open_port(9090)

     

       130
        
       

     

       131
       -
             prometheus.wait_until_succeeds(

     

       132
       -
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=count(up\{job=\"alertmanager\"\}==1)' | "

     

       133
       -
               + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       134
       -
             )

     

       135
        
       

     

       136
       -
             prometheus.wait_until_succeeds(

     

       137
       -
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=sum(alertmanager_build_info)%20by%20(version)' | "

     

       138
       -
               + "jq '.data.result[0].metric.version' | grep '\"${pkgs.prometheus-alertmanager.version}\"'"

     

       139
       -
             )

     

       140
        
       

     

       141
       -
             prometheus.wait_until_succeeds(

     

       142
       -
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=count(up\{job=\"node\"\}!=1)' | "

     

       143
       -
               + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       144
       -
             )

     

       145
        
       

     

       146
       -
             prometheus.wait_until_succeeds(

     

       147
       -
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=alertmanager_notifications_total\{integration=\"webhook\"\}' | "

     

       148
       -
               + "jq '.data.result[0].value[1]' | grep -v '\"0\"'"

     

       149
       -
             )

     

       150
        
       

     

       151
       -
             logger.wait_until_succeeds(

     

       152
       -
               "journalctl -o cat -u alertmanager-webhook-logger.service | grep '\"alertname\":\"InstanceDown\"'"

     

       153
       -
             )

     

       154
        
       

     

       155
       -
             logger.log(logger.succeed("systemd-analyze security alertmanager-webhook-logger.service | grep -v '✓'"))

     

       156
        
       

     

       157
       -
             alertmanager.log(alertmanager.succeed("systemd-analyze security alertmanager.service | grep -v '✓'"))

     

       158
       -
           '';

     

       159
       -
         }

     

       160
       -
       )

···

       1
       +
       { pkgs, ... }:

     

       0
        
       
     

       2
        
       

     

       3
       +
       {

     

       4
       +
         name = "prometheus-alertmanager";

     

       5
        
       

     

       6
       +
         nodes = {

     

       7
       +
           prometheus =

     

       8
       +
             { config, pkgs, ... }:

     

       9
       +
             {

     

       10
       +
               environment.systemPackages = [ pkgs.jq ];

     

       11
        
       

     

       12
       +
               networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       13
        
       

     

       14
       +
               services.prometheus = {

     

       15
       +
                 enable = true;

     

       16
       +
                 globalConfig.scrape_interval = "2s";

     

       17
        
       

     

       18
       +
                 alertmanagers = [

     

       19
       +
                   {

     

       20
       +
                     scheme = "http";

     

       21
       +
                     static_configs = [

     

       22
       +
                       { targets = [ "alertmanager:${toString config.services.prometheus.alertmanager.port}" ]; }

     

       23
       +
                     ];

     

       24
       +
                   }

     

       25
       +
                 ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       26
        
       

     

       27
       +
                 rules = [

     

       28
       +
                   ''

     

       29
       +
                     groups:

     

       30
       +
                       - name: test

     

       31
       +
                         rules:

     

       32
       +
                           - alert: InstanceDown

     

       33
       +
                             expr: up == 0

     

       34
       +
                             for: 5s

     

       35
       +
                             labels:

     

       36
       +
                               severity: page

     

       37
       +
                             annotations:

     

       38
       +
                               summary: "Instance {{ $labels.instance }} down"

     

       39
       +
                   ''

     

       40
       +
                 ];

     

       41
        
       

     

       42
       +
                 scrapeConfigs = [

     

       43
       +
                   {

     

       44
       +
                     job_name = "alertmanager";

     

       45
       +
                     static_configs = [

     

       46
       +
                       { targets = [ "alertmanager:${toString config.services.prometheus.alertmanager.port}" ]; }

     

       47
       +
                     ];

     

       48
       +
                   }

     

       49
       +
                   {

     

       50
       +
                     job_name = "node";

     

       51
       +
                     static_configs = [

     

       52
       +
                       { targets = [ "node:${toString config.services.prometheus.exporters.node.port}" ]; }

     

       53
       +
                     ];

     

       54
       +
                   }

     

       55
       +
                 ];

     

       56
       +
               };

     

       57
       +
             };

     

       58
       +
       

     

       59
       +
           alertmanager =

     

       60
       +
             { config, pkgs, ... }:

     

       61
       +
             {

     

       62
       +
               services.prometheus.alertmanager = {

     

       63
       +
                 enable = true;

     

       64
       +
                 openFirewall = true;

     

       65
       +
       

     

       66
       +
                 configuration = {

     

       67
       +
                   global = {

     

       68
       +
                     resolve_timeout = "1m";

     

       69
       +
                   };

     

       70
       +
       

     

       71
       +
                   route = {

     

       72
       +
                     # Root route node

     

       73
       +
                     receiver = "test";

     

       74
       +
                     group_by = [ "..." ];

     

       75
       +
                     continue = false;

     

       76
       +
                     group_wait = "1s";

     

       77
       +
                     group_interval = "15s";

     

       78
       +
                     repeat_interval = "24h";

     

       79
       +
                   };

     

       80
       +
       

     

       81
       +
                   receivers = [

     

       82
        
                     {

     

       83
       +
                       name = "test";

     

       84
       +
                       webhook_configs = [

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       85
        
                         {

     

       86
       +
                           url = "http://logger:6725";

     

       87
       +
                           send_resolved = true;

     

       88
       +
                           max_alerts = 0;

     

       89
        
                         }

     

       90
        
                       ];

     

       91
        
                     }

     

       92
        
                   ];

     

       93
        
                 };

     

       94
        
               };

     

       95
       +
             };

     

       96
        
       

     

       97
       +
           logger =

     

       98
       +
             { config, pkgs, ... }:

     

       99
       +
             {

     

       100
       +
               networking.firewall.allowedTCPPorts = [ 6725 ];

     

       0
        
       
     

       0
        
       
     

       101
        
       

     

       102
       +
               services.prometheus.alertmanagerWebhookLogger.enable = true;

     

       103
       +
             };

     

       104
       +
         };

     

       0
        
       
     

       105
        
       

     

       106
       +
         testScript = ''

     

       107
       +
           alertmanager.wait_for_unit("alertmanager")

     

       108
       +
           alertmanager.wait_for_open_port(9093)

     

       109
       +
           alertmanager.wait_until_succeeds("curl -s http://127.0.0.1:9093/-/ready")

     

       110
       +
           #alertmanager.wait_until_succeeds("journalctl -o cat -u alertmanager.service | grep 'version=${pkgs.prometheus-alertmanager.version}'")

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       111
        
       

     

       112
       +
           logger.wait_for_unit("alertmanager-webhook-logger")

     

       113
       +
           logger.wait_for_open_port(6725)

     

       114
        
       

     

       115
       +
           prometheus.wait_for_unit("prometheus")

     

       116
       +
           prometheus.wait_for_open_port(9090)

     

       117
        
       

     

       118
       +
           prometheus.wait_until_succeeds(

     

       119
       +
             "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=count(up\{job=\"alertmanager\"\}==1)' | "

     

       120
       +
             + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       121
       +
           )

     

       122
        
       

     

       123
       +
           prometheus.wait_until_succeeds(

     

       124
       +
             "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=sum(alertmanager_build_info)%20by%20(version)' | "

     

       125
       +
             + "jq '.data.result[0].metric.version' | grep '\"${pkgs.prometheus-alertmanager.version}\"'"

     

       126
       +
           )

     

       127
        
       

     

       128
       +
           prometheus.wait_until_succeeds(

     

       129
       +
             "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=count(up\{job=\"node\"\}!=1)' | "

     

       130
       +
             + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       131
       +
           )

     

       132
        
       

     

       133
       +
           prometheus.wait_until_succeeds(

     

       134
       +
             "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=alertmanager_notifications_total\{integration=\"webhook\"\}' | "

     

       135
       +
             + "jq '.data.result[0].value[1]' | grep -v '\"0\"'"

     

       136
       +
           )

     

       137
        
       

     

       138
       +
           logger.wait_until_succeeds(

     

       139
       +
             "journalctl -o cat -u alertmanager-webhook-logger.service | grep '\"alertname\":\"InstanceDown\"'"

     

       140
       +
           )

     

       141
        
       

     

       142
       +
           logger.log(logger.succeed("systemd-analyze security alertmanager-webhook-logger.service | grep -v '✓'"))

     

       143
        
       

     

       144
       +
           alertmanager.log(alertmanager.succeed("systemd-analyze security alertmanager.service | grep -v '✓'"))

     

       145
       +
         '';

     

       146
       +
       }

     

       0

+89 -101

nixos/tests/prometheus/config-reload.nix

···

       1
       -
       import ../make-test-python.nix (

     

       2
       -
         { lib, pkgs, ... }:

     

       3
        
       

     

       4
       -
         {

     

       5
       -
           name = "prometheus-config-reload";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       6
        
       

     

       7
       -
           nodes = {

     

       8
       -
             prometheus =

     

       9
       -
               { config, pkgs, ... }:

     

       10
       -
               {

     

       11
       -
                 environment.systemPackages = [ pkgs.jq ];

     

       12
        
       

     

       13
       -
                 networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
       

     

       15
       -
                 services.prometheus = {

     

       16
       -
                   enable = true;

     

       17
       -
                   enableReload = true;

     

       18
       -
                   globalConfig.scrape_interval = "2s";

     

       19
       -
                   scrapeConfigs = [

     

       20
       -
                     {

     

       21
       -
                       job_name = "prometheus";

     

       22
       -
                       static_configs = [

     

       0
        
       
     

       23
        
                         {

     

       24
       -
                           targets = [

     

       25
       -
                             "prometheus:${toString config.services.prometheus.port}"

     

       0
        
       
     

       26
        
                           ];

     

       27
        
                         }

     

       28
        
                       ];

     

       29
       -
                     }

     

       30
       -
                   ];

     

       31
       -
                 };

     

       32
       -
       

     

       33
       -
                 specialisation = {

     

       34
       -
                   "prometheus-config-change" = {

     

       35
       -
                     configuration = {

     

       36
       -
                       environment.systemPackages = [ pkgs.yq ];

     

       37
       -
       

     

       38
       -
                       # This configuration just adds a new prometheus job

     

       39
       -
                       # to scrape the node_exporter metrics of the s3 machine.

     

       40
       -
                       services.prometheus = {

     

       41
       -
                         scrapeConfigs = [

     

       42
       -
                           {

     

       43
       -
                             job_name = "node";

     

       44
       -
                             static_configs = [

     

       45
       -
                               {

     

       46
       -
                                 targets = [ "node:${toString config.services.prometheus.exporters.node.port}" ];

     

       47
       -
                               }

     

       48
       -
                             ];

     

       49
       -
                           }

     

       50
       -
                         ];

     

       51
       -
                       };

     

       52
        
                     };

     

       53
        
                   };

     

       54
        
                 };

     

       55
        
               };

     

       56
       -
           };

     

       0
        
       
     

       57
        
       

     

       58
       -
           testScript = ''

     

       59
       -
             prometheus.wait_for_unit("prometheus")

     

       60
       -
             prometheus.wait_for_open_port(9090)

     

       61
        
       

     

       62
       -
             # Check if switching to a NixOS configuration that changes the prometheus

     

       63
       -
             # configuration reloads (instead of restarts) prometheus before the switch

     

       64
       -
             # finishes successfully:

     

       65
       -
             with subtest("config change reloads prometheus"):

     

       66
       -
               import json

     

       67
       -
               # We check if prometheus has finished reloading by looking for the message

     

       68
       -
               # "Completed loading of configuration file" in the journal between the start

     

       69
       -
               # and finish of switching to the new NixOS configuration.

     

       70
       -
               #

     

       71
       -
               # To mark the start we record the journal cursor before starting the switch:

     

       72
       -
               cursor_before_switching = json.loads(

     

       73
       -
                   prometheus.succeed("journalctl -n1 -o json --output-fields=__CURSOR")

     

       74
       -
               )["__CURSOR"]

     

       75
        
       

     

       76
       -
               # Now we switch:

     

       77
       -
               prometheus_config_change = prometheus.succeed(

     

       78
       -
                   "readlink /run/current-system/specialisation/prometheus-config-change"

     

       79
       -
               ).strip()

     

       80
       -
               prometheus.succeed(prometheus_config_change + "/bin/switch-to-configuration test")

     

       81
        
       

     

       82
       -
               # Next we retrieve all logs since the start of switching:

     

       83
       -
               logs_after_starting_switching = prometheus.succeed(

     

       84
       -
                   """

     

       85
       -
                     journalctl --after-cursor='{cursor_before_switching}' -o json --output-fields=MESSAGE

     

       86
       -
                   """.format(

     

       87
       -
                       cursor_before_switching=cursor_before_switching

     

       88
       -
                   )

     

       89
       -
               )

     

       90
        
       

     

       91
       -
               # Finally we check if the message "Completed loading of configuration file"

     

       92
       -
               # occurs before the "finished switching to system configuration" message:

     

       93
       -
               finished_switching_msg = (

     

       94
       -
                   "finished switching to system configuration " + prometheus_config_change

     

       95
       -
               )

     

       96
       -
               reloaded_before_switching_finished = False

     

       97
       -
               finished_switching = False

     

       98
       -
               for log_line in logs_after_starting_switching.split("\n"):

     

       99
       -
                   msg = json.loads(log_line)["MESSAGE"]

     

       100
       -
                   if "Completed loading of configuration file" in msg:

     

       101
       -
                       reloaded_before_switching_finished = True

     

       102
       -
                   if msg == finished_switching_msg:

     

       103
       -
                       finished_switching = True

     

       104
       -
                       break

     

       105
        
       

     

       106
       -
               assert reloaded_before_switching_finished

     

       107
       -
               assert finished_switching

     

       108
        
       

     

       109
       -
               # Check if the reloaded config includes the new node job:

     

       110
       -
               prometheus.succeed(

     

       111
       -
                 """

     

       112
       -
                   curl -sf http://127.0.0.1:9090/api/v1/status/config \

     

       113
       -
                     | jq -r .data.yaml \

     

       114
       -
                     | yq '.scrape_configs | any(.job_name == "node")' \

     

       115
       -
                     | grep true

     

       116
       -
                 """

     

       117
       -
               )

     

       118
       -
           '';

     

       119
       -
         }

     

       120
       -
       )

···

       1
       +
       {

     

       2
       +
         name = "prometheus-config-reload";

     

       3
        
       

     

       4
       +
         nodes = {

     

       5
       +
           prometheus =

     

       6
       +
             { config, pkgs, ... }:

     

       7
       +
             {

     

       8
       +
               environment.systemPackages = [ pkgs.jq ];

     

       9
        
       

     

       10
       +
               networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       11
        
       

     

       12
       +
               services.prometheus = {

     

       13
       +
                 enable = true;

     

       14
       +
                 enableReload = true;

     

       15
       +
                 globalConfig.scrape_interval = "2s";

     

       16
       +
                 scrapeConfigs = [

     

       17
       +
                   {

     

       18
       +
                     job_name = "prometheus";

     

       19
       +
                     static_configs = [ { targets = [ "prometheus:${toString config.services.prometheus.port}" ]; } ];

     

       20
       +
                   }

     

       21
       +
                 ];

     

       22
       +
               };

     

       23
        
       

     

       24
       +
               specialisation = {

     

       25
       +
                 "prometheus-config-change" = {

     

       26
       +
                   configuration = {

     

       27
       +
                     environment.systemPackages = [ pkgs.yq ];

     

       28
       +
       

     

       29
       +
                     # This configuration just adds a new prometheus job

     

       30
       +
                     # to scrape the node_exporter metrics of the s3 machine.

     

       31
       +
                     services.prometheus = {

     

       32
       +
                       scrapeConfigs = [

     

       33
        
                         {

     

       34
       +
                           job_name = "node";

     

       35
       +
                           static_configs = [

     

       36
       +
                             { targets = [ "node:${toString config.services.prometheus.exporters.node.port}" ]; }

     

       37
        
                           ];

     

       38
        
                         }

     

       39
        
                       ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       40
        
                     };

     

       41
        
                   };

     

       42
        
                 };

     

       43
        
               };

     

       44
       +
             };

     

       45
       +
         };

     

       46
        
       

     

       47
       +
         testScript = ''

     

       48
       +
           prometheus.wait_for_unit("prometheus")

     

       49
       +
           prometheus.wait_for_open_port(9090)

     

       50
        
       

     

       51
       +
           # Check if switching to a NixOS configuration that changes the prometheus

     

       52
       +
           # configuration reloads (instead of restarts) prometheus before the switch

     

       53
       +
           # finishes successfully:

     

       54
       +
           with subtest("config change reloads prometheus"):

     

       55
       +
             import json

     

       56
       +
             # We check if prometheus has finished reloading by looking for the message

     

       57
       +
             # "Completed loading of configuration file" in the journal between the start

     

       58
       +
             # and finish of switching to the new NixOS configuration.

     

       59
       +
             #

     

       60
       +
             # To mark the start we record the journal cursor before starting the switch:

     

       61
       +
             cursor_before_switching = json.loads(

     

       62
       +
                 prometheus.succeed("journalctl -n1 -o json --output-fields=__CURSOR")

     

       63
       +
             )["__CURSOR"]

     

       64
        
       

     

       65
       +
             # Now we switch:

     

       66
       +
             prometheus_config_change = prometheus.succeed(

     

       67
       +
                 "readlink /run/current-system/specialisation/prometheus-config-change"

     

       68
       +
             ).strip()

     

       69
       +
             prometheus.succeed(prometheus_config_change + "/bin/switch-to-configuration test")

     

       70
        
       

     

       71
       +
             # Next we retrieve all logs since the start of switching:

     

       72
       +
             logs_after_starting_switching = prometheus.succeed(

     

       73
       +
                 """

     

       74
       +
                   journalctl --after-cursor='{cursor_before_switching}' -o json --output-fields=MESSAGE

     

       75
       +
                 """.format(

     

       76
       +
                     cursor_before_switching=cursor_before_switching

     

       77
       +
                 )

     

       78
       +
             )

     

       79
        
       

     

       80
       +
             # Finally we check if the message "Completed loading of configuration file"

     

       81
       +
             # occurs before the "finished switching to system configuration" message:

     

       82
       +
             finished_switching_msg = (

     

       83
       +
                 "finished switching to system configuration " + prometheus_config_change

     

       84
       +
             )

     

       85
       +
             reloaded_before_switching_finished = False

     

       86
       +
             finished_switching = False

     

       87
       +
             for log_line in logs_after_starting_switching.split("\n"):

     

       88
       +
                 msg = json.loads(log_line)["MESSAGE"]

     

       89
       +
                 if "Completed loading of configuration file" in msg:

     

       90
       +
                     reloaded_before_switching_finished = True

     

       91
       +
                 if msg == finished_switching_msg:

     

       92
       +
                     finished_switching = True

     

       93
       +
                     break

     

       94
        
       

     

       95
       +
             assert reloaded_before_switching_finished

     

       96
       +
             assert finished_switching

     

       97
        
       

     

       98
       +
             # Check if the reloaded config includes the new node job:

     

       99
       +
             prometheus.succeed(

     

       100
       +
               """

     

       101
       +
                 curl -sf http://127.0.0.1:9090/api/v1/status/config \

     

       102
       +
                   | jq -r .data.yaml \

     

       103
       +
                   | yq '.scrape_configs | any(.job_name == "node")' \

     

       104
       +
                   | grep true

     

       105
       +
               """

     

       106
       +
             )

     

       107
       +
         '';

     

       108
       +
       }

     

       0

+8 -11

nixos/tests/prometheus/default.nix

···

       1
       -
       {

     

       2
       -
         system ? builtins.currentSystem,

     

       3
       -
         config ? { },

     

       4
       -
         pkgs ? import ../../.. { inherit system config; },

     

       5
       -
       }:

     

       6
        
       

     

       7
        
       {

     

       8
       -
         alertmanager = import ./alertmanager.nix { inherit system pkgs; };

     

       9
       -
         config-reload = import ./config-reload.nix { inherit system pkgs; };

     

       10
       -
         federation = import ./federation.nix { inherit system pkgs; };

     

       11
       -
         prometheus-pair = import ./prometheus-pair.nix { inherit system pkgs; };

     

       12
       -
         pushgateway = import ./pushgateway.nix { inherit system pkgs; };

     

       13
       -
         remote-write = import ./remote-write.nix { inherit system pkgs; };

     

       0
        
       
     

       14
        
       }

···

       1
       +
       { runTest }:

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2
        
       

     

       3
        
       {

     

       4
       +
         alertmanager = runTest ./alertmanager.nix;

     

       5
       +
         alertmanager-ntfy = runTest ./alertmanager-ntfy.nix;

     

       6
       +
         config-reload = runTest ./config-reload.nix;

     

       7
       +
         federation = runTest ./federation.nix;

     

       8
       +
         prometheus-pair = runTest ./prometheus-pair.nix;

     

       9
       +
         pushgateway = runTest ./pushgateway.nix;

     

       10
       +
         remote-write = runTest ./remote-write.nix;

     

       11
        
       }

+169 -193

nixos/tests/prometheus/federation.nix

···

       1
       -
       import ../make-test-python.nix (

     

       2
       -
         { lib, pkgs, ... }:

     

       3
        
       

     

       4
       -
         {

     

       5
       -
           name = "prometheus-federation";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       6
        
       

     

       7
       -
           nodes = {

     

       8
       -
             global1 =

     

       9
       -
               { config, pkgs, ... }:

     

       10
       -
               {

     

       11
       -
                 environment.systemPackages = [ pkgs.jq ];

     

       12
        
       

     

       13
       -
                 networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       0
        
       
     

       0
        
       
     

       14
        
       

     

       15
       -
                 services.prometheus = {

     

       16
       -
                   enable = true;

     

       17
       -
                   globalConfig.scrape_interval = "2s";

     

       0
        
       
     

       0
        
       
     

       18
        
       

     

       19
       -
                   scrapeConfigs = [

     

       20
       -
                     {

     

       21
       -
                       job_name = "federate";

     

       22
       -
                       honor_labels = true;

     

       23
       -
                       metrics_path = "/federate";

     

       0
        
       
     

       24
        
       

     

       25
       -
                       params = {

     

       26
       -
                         "match[]" = [

     

       27
       -
                           "{job=\"node\"}"

     

       28
       -
                           "{job=\"prometheus\"}"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       29
        
                         ];

     

       30
       -
                       };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       31
        
       

     

       32
       -
                       static_configs = [

     

       33
       -
                         {

     

       34
       -
                           targets = [

     

       35
       -
                             "prometheus1:${toString config.services.prometheus.port}"

     

       36
       -
                             "prometheus2:${toString config.services.prometheus.port}"

     

       37
       -
                           ];

     

       38
       -
                         }

     

       39
       -
                       ];

     

       40
       -
                     }

     

       41
       -
                     {

     

       42
       -
                       job_name = "prometheus";

     

       43
       -
                       static_configs = [

     

       44
       -
                         {

     

       45
       -
                           targets = [

     

       46
       -
                             "global1:${toString config.services.prometheus.port}"

     

       47
       -
                             "global2:${toString config.services.prometheus.port}"

     

       48
       -
                           ];

     

       49
       -
                         }

     

       50
       -
                       ];

     

       51
       -
                     }

     

       52
       -
                   ];

     

       53
       -
                 };

     

       54
       -
               };

     

       55
        
       

     

       56
       -
             global2 =

     

       57
       -
               { config, pkgs, ... }:

     

       58
       -
               {

     

       59
       -
                 environment.systemPackages = [ pkgs.jq ];

     

       60
        
       

     

       61
       -
                 networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       0
        
       
     

       0
        
       
     

       62
        
       

     

       63
       -
                 services.prometheus = {

     

       64
       -
                   enable = true;

     

       65
       -
                   globalConfig.scrape_interval = "2s";

     

       0
        
       
     

       0
        
       
     

       66
        
       

     

       67
       -
                   scrapeConfigs = [

     

       68
       -
                     {

     

       69
       -
                       job_name = "federate";

     

       70
       -
                       honor_labels = true;

     

       71
       -
                       metrics_path = "/federate";

     

       0
        
       
     

       72
        
       

     

       73
       -
                       params = {

     

       74
       -
                         "match[]" = [

     

       75
       -
                           "{job=\"node\"}"

     

       76
       -
                           "{job=\"prometheus\"}"

     

       0
        
       
     

       77
        
                         ];

     

       78
       -
                       };

     

       79
       -
       

     

       80
       -
                       static_configs = [

     

       81
       -
                         {

     

       82
       -
                           targets = [

     

       83
       -
                             "prometheus1:${toString config.services.prometheus.port}"

     

       84
       -
                             "prometheus2:${toString config.services.prometheus.port}"

     

       85
       -
                           ];

     

       86
       -
                         }

     

       87
       -
                       ];

     

       88
       -
                     }

     

       89
       -
                     {

     

       90
       -
                       job_name = "prometheus";

     

       91
       -
                       static_configs = [

     

       92
       -
                         {

     

       93
       -
                           targets = [

     

       94
       -
                             "global1:${toString config.services.prometheus.port}"

     

       95
       -
                             "global2:${toString config.services.prometheus.port}"

     

       96
       -
                           ];

     

       97
       -
                         }

     

       98
       -
                       ];

     

       99
       -
                     }

     

       100
       -
                   ];

     

       101
       -
                 };

     

       102
        
               };

     

       0
        
       
     

       103
        
       

     

       104
       -
             prometheus1 =

     

       105
       -
               { config, pkgs, ... }:

     

       106
       -
               {

     

       107
       -
                 environment.systemPackages = [ pkgs.jq ];

     

       108
        
       

     

       109
       -
                 networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       110
        
       

     

       111
       -
                 services.prometheus = {

     

       112
       -
                   enable = true;

     

       113
       -
                   globalConfig.scrape_interval = "2s";

     

       114
        
       

     

       115
       -
                   scrapeConfigs = [

     

       116
       -
                     {

     

       117
       -
                       job_name = "node";

     

       118
       -
                       static_configs = [

     

       119
       -
                         {

     

       120
       -
                           targets = [

     

       121
       -
                             "node1:${toString config.services.prometheus.exporters.node.port}"

     

       122
       -
                           ];

     

       123
       -
                         }

     

       124
       -
                       ];

     

       125
       -
                     }

     

       126
       -
                     {

     

       127
       -
                       job_name = "prometheus";

     

       128
       -
                       static_configs = [

     

       129
       -
                         {

     

       130
       -
                           targets = [

     

       131
       -
                             "prometheus1:${toString config.services.prometheus.port}"

     

       132
       -
                           ];

     

       133
       -
                         }

     

       134
       -
                       ];

     

       135
       -
                     }

     

       136
       -
                   ];

     

       137
       -
                 };

     

       138
        
               };

     

       0
        
       
     

       139
        
       

     

       140
       -
             prometheus2 =

     

       141
       -
               { config, pkgs, ... }:

     

       142
       -
               {

     

       143
       -
                 environment.systemPackages = [ pkgs.jq ];

     

       144
        
       

     

       145
       -
                 networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       146
        
       

     

       147
       -
                 services.prometheus = {

     

       148
       -
                   enable = true;

     

       149
       -
                   globalConfig.scrape_interval = "2s";

     

       150
        
       

     

       151
       -
                   scrapeConfigs = [

     

       152
       -
                     {

     

       153
       -
                       job_name = "node";

     

       154
       -
                       static_configs = [

     

       155
       -
                         {

     

       156
       -
                           targets = [

     

       157
       -
                             "node2:${toString config.services.prometheus.exporters.node.port}"

     

       158
       -
                           ];

     

       159
       -
                         }

     

       160
       -
                       ];

     

       161
       -
                     }

     

       162
       -
                     {

     

       163
       -
                       job_name = "prometheus";

     

       164
       -
                       static_configs = [

     

       165
       -
                         {

     

       166
       -
                           targets = [

     

       167
       -
                             "prometheus2:${toString config.services.prometheus.port}"

     

       168
       -
                           ];

     

       169
       -
                         }

     

       170
       -
                       ];

     

       171
       -
                     }

     

       172
       -
                   ];

     

       173
       -
                 };

     

       174
        
               };

     

       0
        
       
     

       175
        
       

     

       176
       -
             node1 =

     

       177
       -
               { config, pkgs, ... }:

     

       178
       -
               {

     

       179
       -
                 services.prometheus.exporters.node = {

     

       180
       -
                   enable = true;

     

       181
       -
                   openFirewall = true;

     

       182
       -
                 };

     

       183
        
               };

     

       0
        
       
     

       184
        
       

     

       185
       -
             node2 =

     

       186
       -
               { config, pkgs, ... }:

     

       187
       -
               {

     

       188
       -
                 services.prometheus.exporters.node = {

     

       189
       -
                   enable = true;

     

       190
       -
                   openFirewall = true;

     

       191
       -
                 };

     

       192
        
               };

     

       193
       -
           };

     

       0
        
       
     

       194
        
       

     

       195
       -
           testScript = ''

     

       196
       -
             for machine in node1, node2:

     

       197
       -
               machine.wait_for_unit("prometheus-node-exporter")

     

       198
       -
               machine.wait_for_open_port(9100)

     

       199
        
       

     

       200
       -
             for machine in prometheus1, prometheus2, global1, global2:

     

       201
       -
               machine.wait_for_unit("prometheus")

     

       202
       -
               machine.wait_for_open_port(9090)

     

       203
        
       

     

       204
       -
             # Verify both servers got the same data from the exporter

     

       205
       -
             for machine in prometheus1, prometheus2:

     

       206
       -
               machine.wait_until_succeeds(

     

       207
       -
                 "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=count(up\{job=\"node\"\})' | "

     

       208
       -
                 + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       209
       -
               )

     

       210
       -
               machine.wait_until_succeeds(

     

       211
       -
                 "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=count(prometheus_build_info)' | "

     

       212
       -
                 + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       213
       -
               )

     

       214
        
       

     

       215
       -
             for machine in global1, global2:

     

       216
       -
               machine.wait_until_succeeds(

     

       217
       -
                 "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=count(up\{job=\"node\"\})' | "

     

       218
       -
                 + "jq '.data.result[0].value[1]' | grep '\"2\"'"

     

       219
       -
               )

     

       220
        
       

     

       221
       -
               machine.wait_until_succeeds(

     

       222
       -
                 "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=count(prometheus_build_info)' | "

     

       223
       -
                 + "jq '.data.result[0].value[1]' | grep '\"4\"'"

     

       224
       -
               )

     

       225
       -
           '';

     

       226
       -
         }

     

       227
       -
       )

···

       1
       +
       {

     

       2
       +
         name = "prometheus-federation";

     

       3
        
       

     

       4
       +
         nodes = {

     

       5
       +
           global1 =

     

       6
       +
             { config, pkgs, ... }:

     

       7
       +
             {

     

       8
       +
               environment.systemPackages = [ pkgs.jq ];

     

       9
        
       

     

       10
       +
               networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       11
        
       

     

       12
       +
               services.prometheus = {

     

       13
       +
                 enable = true;

     

       14
       +
                 globalConfig.scrape_interval = "2s";

     

       15
        
       

     

       16
       +
                 scrapeConfigs = [

     

       17
       +
                   {

     

       18
       +
                     job_name = "federate";

     

       19
       +
                     honor_labels = true;

     

       20
       +
                     metrics_path = "/federate";

     

       21
        
       

     

       22
       +
                     params = {

     

       23
       +
                       "match[]" = [

     

       24
       +
                         "{job=\"node\"}"

     

       25
       +
                         "{job=\"prometheus\"}"

     

       26
       +
                       ];

     

       27
       +
                     };

     

       28
        
       

     

       29
       +
                     static_configs = [

     

       30
       +
                       {

     

       31
       +
                         targets = [

     

       32
       +
                           "prometheus1:${toString config.services.prometheus.port}"

     

       33
       +
                           "prometheus2:${toString config.services.prometheus.port}"

     

       34
       +
                         ];

     

       35
       +
                       }

     

       36
       +
                     ];

     

       37
       +
                   }

     

       38
       +
                   {

     

       39
       +
                     job_name = "prometheus";

     

       40
       +
                     static_configs = [

     

       41
       +
                       {

     

       42
       +
                         targets = [

     

       43
       +
                           "global1:${toString config.services.prometheus.port}"

     

       44
       +
                           "global2:${toString config.services.prometheus.port}"

     

       45
        
                         ];

     

       46
       +
                       }

     

       47
       +
                     ];

     

       48
       +
                   }

     

       49
       +
                 ];

     

       50
       +
               };

     

       51
       +
             };

     

       52
        
       

     

       53
       +
           global2 =

     

       54
       +
             { config, pkgs, ... }:

     

       55
       +
             {

     

       56
       +
               environment.systemPackages = [ pkgs.jq ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       57
        
       

     

       58
       +
               networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       59
        
       

     

       60
       +
               services.prometheus = {

     

       61
       +
                 enable = true;

     

       62
       +
                 globalConfig.scrape_interval = "2s";

     

       63
        
       

     

       64
       +
                 scrapeConfigs = [

     

       65
       +
                   {

     

       66
       +
                     job_name = "federate";

     

       67
       +
                     honor_labels = true;

     

       68
       +
                     metrics_path = "/federate";

     

       69
        
       

     

       70
       +
                     params = {

     

       71
       +
                       "match[]" = [

     

       72
       +
                         "{job=\"node\"}"

     

       73
       +
                         "{job=\"prometheus\"}"

     

       74
       +
                       ];

     

       75
       +
                     };

     

       76
        
       

     

       77
       +
                     static_configs = [

     

       78
       +
                       {

     

       79
       +
                         targets = [

     

       80
       +
                           "prometheus1:${toString config.services.prometheus.port}"

     

       81
       +
                           "prometheus2:${toString config.services.prometheus.port}"

     

       82
        
                         ];

     

       83
       +
                       }

     

       84
       +
                     ];

     

       85
       +
                   }

     

       86
       +
                   {

     

       87
       +
                     job_name = "prometheus";

     

       88
       +
                     static_configs = [

     

       89
       +
                       {

     

       90
       +
                         targets = [

     

       91
       +
                           "global1:${toString config.services.prometheus.port}"

     

       92
       +
                           "global2:${toString config.services.prometheus.port}"

     

       93
       +
                         ];

     

       94
       +
                       }

     

       95
       +
                     ];

     

       96
       +
                   }

     

       97
       +
                 ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       98
        
               };

     

       99
       +
             };

     

       100
        
       

     

       101
       +
           prometheus1 =

     

       102
       +
             { config, pkgs, ... }:

     

       103
       +
             {

     

       104
       +
               environment.systemPackages = [ pkgs.jq ];

     

       105
        
       

     

       106
       +
               networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       107
        
       

     

       108
       +
               services.prometheus = {

     

       109
       +
                 enable = true;

     

       110
       +
                 globalConfig.scrape_interval = "2s";

     

       111
        
       

     

       112
       +
                 scrapeConfigs = [

     

       113
       +
                   {

     

       114
       +
                     job_name = "node";

     

       115
       +
                     static_configs = [

     

       116
       +
                       { targets = [ "node1:${toString config.services.prometheus.exporters.node.port}" ]; }

     

       117
       +
                     ];

     

       118
       +
                   }

     

       119
       +
                   {

     

       120
       +
                     job_name = "prometheus";

     

       121
       +
                     static_configs = [ { targets = [ "prometheus1:${toString config.services.prometheus.port}" ]; } ];

     

       122
       +
                   }

     

       123
       +
                 ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       124
        
               };

     

       125
       +
             };

     

       126
        
       

     

       127
       +
           prometheus2 =

     

       128
       +
             { config, pkgs, ... }:

     

       129
       +
             {

     

       130
       +
               environment.systemPackages = [ pkgs.jq ];

     

       131
        
       

     

       132
       +
               networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       133
        
       

     

       134
       +
               services.prometheus = {

     

       135
       +
                 enable = true;

     

       136
       +
                 globalConfig.scrape_interval = "2s";

     

       137
        
       

     

       138
       +
                 scrapeConfigs = [

     

       139
       +
                   {

     

       140
       +
                     job_name = "node";

     

       141
       +
                     static_configs = [

     

       142
       +
                       { targets = [ "node2:${toString config.services.prometheus.exporters.node.port}" ]; }

     

       143
       +
                     ];

     

       144
       +
                   }

     

       145
       +
                   {

     

       146
       +
                     job_name = "prometheus";

     

       147
       +
                     static_configs = [ { targets = [ "prometheus2:${toString config.services.prometheus.port}" ]; } ];

     

       148
       +
                   }

     

       149
       +
                 ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       150
        
               };

     

       151
       +
             };

     

       152
        
       

     

       153
       +
           node1 =

     

       154
       +
             { config, pkgs, ... }:

     

       155
       +
             {

     

       156
       +
               services.prometheus.exporters.node = {

     

       157
       +
                 enable = true;

     

       158
       +
                 openFirewall = true;

     

       0
        
       
     

       159
        
               };

     

       160
       +
             };

     

       161
        
       

     

       162
       +
           node2 =

     

       163
       +
             { config, pkgs, ... }:

     

       164
       +
             {

     

       165
       +
               services.prometheus.exporters.node = {

     

       166
       +
                 enable = true;

     

       167
       +
                 openFirewall = true;

     

       0
        
       
     

       168
        
               };

     

       169
       +
             };

     

       170
       +
         };

     

       171
        
       

     

       172
       +
         testScript = ''

     

       173
       +
           for machine in node1, node2:

     

       174
       +
             machine.wait_for_unit("prometheus-node-exporter")

     

       175
       +
             machine.wait_for_open_port(9100)

     

       176
        
       

     

       177
       +
           for machine in prometheus1, prometheus2, global1, global2:

     

       178
       +
             machine.wait_for_unit("prometheus")

     

       179
       +
             machine.wait_for_open_port(9090)

     

       180
        
       

     

       181
       +
           # Verify both servers got the same data from the exporter

     

       182
       +
           for machine in prometheus1, prometheus2:

     

       183
       +
             machine.wait_until_succeeds(

     

       184
       +
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=count(up\{job=\"node\"\})' | "

     

       185
       +
               + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       186
       +
             )

     

       187
       +
             machine.wait_until_succeeds(

     

       188
       +
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=count(prometheus_build_info)' | "

     

       189
       +
               + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       190
       +
             )

     

       191
        
       

     

       192
       +
           for machine in global1, global2:

     

       193
       +
             machine.wait_until_succeeds(

     

       194
       +
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=count(up\{job=\"node\"\})' | "

     

       195
       +
               + "jq '.data.result[0].value[1]' | grep '\"2\"'"

     

       196
       +
             )

     

       197
        
       

     

       198
       +
             machine.wait_until_succeeds(

     

       199
       +
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=count(prometheus_build_info)' | "

     

       200
       +
               + "jq '.data.result[0].value[1]' | grep '\"4\"'"

     

       201
       +
             )

     

       202
       +
         '';

     

       203
       +
       }

     

       0

+76 -78

nixos/tests/prometheus/prometheus-pair.nix

···

       1
       -
       import ../make-test-python.nix (

     

       2
       -
         { lib, pkgs, ... }:

     

       3
        
       

     

       4
       -
         {

     

       5
       -
           name = "prometheus-pair";

     

       6
        
       

     

       7
       -
           nodes = {

     

       8
       -
             prometheus1 =

     

       9
       -
               { config, pkgs, ... }:

     

       10
       -
               {

     

       11
       -
                 environment.systemPackages = [ pkgs.jq ];

     

       12
        
       

     

       13
       -
                 networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       14
        
       

     

       15
       -
                 services.prometheus = {

     

       16
       -
                   enable = true;

     

       17
       -
                   globalConfig.scrape_interval = "2s";

     

       18
       -
                   scrapeConfigs = [

     

       19
       -
                     {

     

       20
       -
                       job_name = "prometheus";

     

       21
       -
                       static_configs = [

     

       22
       -
                         {

     

       23
       -
                           targets = [

     

       24
       -
                             "prometheus1:${toString config.services.prometheus.port}"

     

       25
       -
                             "prometheus2:${toString config.services.prometheus.port}"

     

       26
       -
                           ];

     

       27
       -
                         }

     

       28
       -
                       ];

     

       29
       -
                     }

     

       30
       -
                   ];

     

       31
       -
                 };

     

       32
        
               };

     

       0
        
       
     

       33
        
       

     

       34
       -
             prometheus2 =

     

       35
       -
               { config, pkgs, ... }:

     

       36
       -
               {

     

       37
       -
                 environment.systemPackages = [ pkgs.jq ];

     

       38
        
       

     

       39
       -
                 networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       40
        
       

     

       41
       -
                 services.prometheus = {

     

       42
       -
                   enable = true;

     

       43
       -
                   globalConfig.scrape_interval = "2s";

     

       44
       -
                   scrapeConfigs = [

     

       45
       -
                     {

     

       46
       -
                       job_name = "prometheus";

     

       47
       -
                       static_configs = [

     

       48
       -
                         {

     

       49
       -
                           targets = [

     

       50
       -
                             "prometheus1:${toString config.services.prometheus.port}"

     

       51
       -
                             "prometheus2:${toString config.services.prometheus.port}"

     

       52
       -
                           ];

     

       53
       -
                         }

     

       54
       -
                       ];

     

       55
       -
                     }

     

       56
       -
                   ];

     

       57
       -
                 };

     

       58
        
               };

     

       59
       -
           };

     

       0
        
       
     

       60
        
       

     

       61
       -
           testScript = ''

     

       62
       -
             for machine in prometheus1, prometheus2:

     

       63
       -
               machine.wait_for_unit("prometheus")

     

       64
       -
               machine.wait_for_open_port(9090)

     

       65
       -
               machine.wait_until_succeeds("journalctl -o cat -u prometheus.service | grep 'version=${pkgs.prometheus.version}'")

     

       66
       -
               machine.wait_until_succeeds("curl -sSf http://localhost:9090/-/healthy")

     

       67
        
       

     

       68
       -
             # Prometheii ready - run some queries

     

       69
       -
             for machine in prometheus1, prometheus2:

     

       70
       -
               machine.wait_until_succeeds(

     

       71
       -
                 "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=prometheus_build_info\{instance=\"prometheus1:9090\",version=\"${pkgs.prometheus.version}\"\}' | "

     

       72
       -
                 + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       73
       -
               )

     

       74
        
       

     

       75
       -
               machine.wait_until_succeeds(

     

       76
       -
                 "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=prometheus_build_info\{instance=\"prometheus1:9090\"\}' | "

     

       77
       -
                 + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       78
       -
               )

     

       79
        
       

     

       80
       -
               machine.wait_until_succeeds(

     

       81
       -
                 "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=sum(prometheus_build_info)%20by%20(version)' | "

     

       82
       -
                 + "jq '.data.result[0].metric.version' | grep '\"${pkgs.prometheus.version}\"'"

     

       83
       -
               )

     

       84
        
       

     

       85
       -
               machine.wait_until_succeeds(

     

       86
       -
                 "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=sum(prometheus_build_info)%20by%20(version)' | "

     

       87
       -
                 + "jq '.data.result[0].value[1]' | grep '\"2\"'"

     

       88
       -
               )

     

       89
        
       

     

       90
       -
             prometheus1.log(prometheus1.succeed("systemd-analyze security prometheus.service | grep -v '✓'"))

     

       91
       -
           '';

     

       92
       -
         }

     

       93
       -
       )

···

       1
       +
       { pkgs, ... }:

     

       0
        
       
     

       2
        
       

     

       3
       +
       {

     

       4
       +
         name = "prometheus-pair";

     

       5
        
       

     

       6
       +
         nodes = {

     

       7
       +
           prometheus1 =

     

       8
       +
             { config, pkgs, ... }:

     

       9
       +
             {

     

       10
       +
               environment.systemPackages = [ pkgs.jq ];

     

       11
        
       

     

       12
       +
               networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       13
        
       

     

       14
       +
               services.prometheus = {

     

       15
       +
                 enable = true;

     

       16
       +
                 globalConfig.scrape_interval = "2s";

     

       17
       +
                 scrapeConfigs = [

     

       18
       +
                   {

     

       19
       +
                     job_name = "prometheus";

     

       20
       +
                     static_configs = [

     

       21
       +
                       {

     

       22
       +
                         targets = [

     

       23
       +
                           "prometheus1:${toString config.services.prometheus.port}"

     

       24
       +
                           "prometheus2:${toString config.services.prometheus.port}"

     

       25
       +
                         ];

     

       26
       +
                       }

     

       27
       +
                     ];

     

       28
       +
                   }

     

       29
       +
                 ];

     

       0
        
       
     

       30
        
               };

     

       31
       +
             };

     

       32
        
       

     

       33
       +
           prometheus2 =

     

       34
       +
             { config, pkgs, ... }:

     

       35
       +
             {

     

       36
       +
               environment.systemPackages = [ pkgs.jq ];

     

       37
        
       

     

       38
       +
               networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       39
        
       

     

       40
       +
               services.prometheus = {

     

       41
       +
                 enable = true;

     

       42
       +
                 globalConfig.scrape_interval = "2s";

     

       43
       +
                 scrapeConfigs = [

     

       44
       +
                   {

     

       45
       +
                     job_name = "prometheus";

     

       46
       +
                     static_configs = [

     

       47
       +
                       {

     

       48
       +
                         targets = [

     

       49
       +
                           "prometheus1:${toString config.services.prometheus.port}"

     

       50
       +
                           "prometheus2:${toString config.services.prometheus.port}"

     

       51
       +
                         ];

     

       52
       +
                       }

     

       53
       +
                     ];

     

       54
       +
                   }

     

       55
       +
                 ];

     

       0
        
       
     

       56
        
               };

     

       57
       +
             };

     

       58
       +
         };

     

       59
        
       

     

       60
       +
         testScript = ''

     

       61
       +
           for machine in prometheus1, prometheus2:

     

       62
       +
             machine.wait_for_unit("prometheus")

     

       63
       +
             machine.wait_for_open_port(9090)

     

       64
       +
             machine.wait_until_succeeds("journalctl -o cat -u prometheus.service | grep 'version=${pkgs.prometheus.version}'")

     

       65
       +
             machine.wait_until_succeeds("curl -sSf http://localhost:9090/-/healthy")

     

       66
        
       

     

       67
       +
           # Prometheii ready - run some queries

     

       68
       +
           for machine in prometheus1, prometheus2:

     

       69
       +
             machine.wait_until_succeeds(

     

       70
       +
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=prometheus_build_info\{instance=\"prometheus1:9090\",version=\"${pkgs.prometheus.version}\"\}' | "

     

       71
       +
               + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       72
       +
             )

     

       73
        
       

     

       74
       +
             machine.wait_until_succeeds(

     

       75
       +
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=prometheus_build_info\{instance=\"prometheus1:9090\"\}' | "

     

       76
       +
               + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       77
       +
             )

     

       78
        
       

     

       79
       +
             machine.wait_until_succeeds(

     

       80
       +
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=sum(prometheus_build_info)%20by%20(version)' | "

     

       81
       +
               + "jq '.data.result[0].metric.version' | grep '\"${pkgs.prometheus.version}\"'"

     

       82
       +
             )

     

       83
        
       

     

       84
       +
             machine.wait_until_succeeds(

     

       85
       +
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=sum(prometheus_build_info)%20by%20(version)' | "

     

       86
       +
               + "jq '.data.result[0].value[1]' | grep '\"2\"'"

     

       87
       +
             )

     

       88
        
       

     

       89
       +
           prometheus1.log(prometheus1.succeed("systemd-analyze security prometheus.service | grep -v '✓'"))

     

       90
       +
         '';

     

       91
       +
       }

     

       0

+70 -81

nixos/tests/prometheus/pushgateway.nix

···

       1
       -
       import ../make-test-python.nix (

     

       2
       -
         { lib, pkgs, ... }:

     

       3
        
       

     

       4
       -
         {

     

       5
       -
           name = "prometheus-pushgateway";

     

       6
        
       

     

       7
       -
           nodes = {

     

       8
       -
             prometheus =

     

       9
       -
               { config, pkgs, ... }:

     

       10
       -
               {

     

       11
       -
                 environment.systemPackages = [ pkgs.jq ];

     

       12
        
       

     

       13
       -
                 networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       14
        
       

     

       15
       -
                 services.prometheus = {

     

       16
       -
                   enable = true;

     

       17
       -
                   globalConfig.scrape_interval = "2s";

     

       18
        
       

     

       19
       -
                   scrapeConfigs = [

     

       20
       -
                     {

     

       21
       -
                       job_name = "pushgateway";

     

       22
       -
                       static_configs = [

     

       23
       -
                         {

     

       24
       -
                           targets = [

     

       25
       -
                             "pushgateway:9091"

     

       26
       -
                           ];

     

       27
       -
                         }

     

       28
       -
                       ];

     

       29
       -
                     }

     

       30
       -
                   ];

     

       31
       -
                 };

     

       32
        
               };

     

       0
        
       
     

       33
        
       

     

       34
       -
             pushgateway =

     

       35
       -
               { config, pkgs, ... }:

     

       36
       -
               {

     

       37
       -
                 networking.firewall.allowedTCPPorts = [ 9091 ];

     

       38
        
       

     

       39
       -
                 services.prometheus.pushgateway = {

     

       40
       -
                   enable = true;

     

       41
       -
                 };

     

       42
        
               };

     

       0
        
       
     

       43
        
       

     

       44
       -
             client =

     

       45
       -
               { config, pkgs, ... }:

     

       46
       -
               {

     

       47
       -
               };

     

       48
       -
           };

     

       49
        
       

     

       50
       -
           testScript = ''

     

       51
       -
             pushgateway.wait_for_unit("pushgateway")

     

       52
       -
             pushgateway.wait_for_open_port(9091)

     

       53
       -
             pushgateway.wait_until_succeeds("curl -s http://127.0.0.1:9091/-/ready")

     

       54
       -
             pushgateway.wait_until_succeeds("journalctl -o cat -u pushgateway.service | grep 'version=${pkgs.prometheus-pushgateway.version}'")

     

       55
        
       

     

       56
       -
             prometheus.wait_for_unit("prometheus")

     

       57
       -
             prometheus.wait_for_open_port(9090)

     

       58
        
       

     

       59
       -
             prometheus.wait_until_succeeds(

     

       60
       -
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=count(up\{job=\"pushgateway\"\})' | "

     

       61
       -
               + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       62
       -
             )

     

       63
        
       

     

       64
       -
             prometheus.wait_until_succeeds(

     

       65
       -
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=sum(pushgateway_build_info)%20by%20(version)' | "

     

       66
       -
               + "jq '.data.result[0].metric.version' | grep '\"${pkgs.prometheus-pushgateway.version}\"'"

     

       67
       -
             )

     

       68
        
       

     

       69
       -
             # Add a metric and check in Prometheus

     

       70
       -
             client.wait_until_succeeds(

     

       71
       -
               "echo 'some_metric 3.14' | curl --data-binary @- http://pushgateway:9091/metrics/job/some_job"

     

       72
       -
             )

     

       73
        
       

     

       74
       -
             prometheus.wait_until_succeeds(

     

       75
       -
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=some_metric' | "

     

       76
       -
               + "jq '.data.result[0].value[1]' | grep '\"3.14\"'"

     

       77
       -
             )

     

       78
        
       

     

       79
       -
             prometheus.wait_until_succeeds(

     

       80
       -
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=absent(some_metric)' | "

     

       81
       -
               + "jq '.data.result[0].value[1]' | grep 'null'"

     

       82
       -
             )

     

       83
        
       

     

       84
       -
             # Delete the metric, check not in Prometheus

     

       85
       -
             client.wait_until_succeeds(

     

       86
       -
               "curl -X DELETE http://pushgateway:9091/metrics/job/some_job"

     

       87
       -
             )

     

       88
        
       

     

       89
       -
             prometheus.wait_until_fails(

     

       90
       -
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=some_metric' | "

     

       91
       -
               + "jq '.data.result[0].value[1]' | grep '\"3.14\"'"

     

       92
       -
             )

     

       93
        
       

     

       94
       -
             prometheus.wait_until_succeeds(

     

       95
       -
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=absent(some_metric)' | "

     

       96
       -
               + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       97
       -
             )

     

       98
        
       

     

       99
       -
             pushgateway.log(pushgateway.succeed("systemd-analyze security pushgateway.service | grep -v '✓'"))

     

       100
       -
           '';

     

       101
       -
         }

     

       102
       -
       )

···

       1
       +
       { pkgs, ... }:

     

       0
        
       
     

       2
        
       

     

       3
       +
       {

     

       4
       +
         name = "prometheus-pushgateway";

     

       5
        
       

     

       6
       +
         nodes = {

     

       7
       +
           prometheus =

     

       8
       +
             { config, pkgs, ... }:

     

       9
       +
             {

     

       10
       +
               environment.systemPackages = [ pkgs.jq ];

     

       11
        
       

     

       12
       +
               networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       13
        
       

     

       14
       +
               services.prometheus = {

     

       15
       +
                 enable = true;

     

       16
       +
                 globalConfig.scrape_interval = "2s";

     

       17
        
       

     

       18
       +
                 scrapeConfigs = [

     

       19
       +
                   {

     

       20
       +
                     job_name = "pushgateway";

     

       21
       +
                     static_configs = [ { targets = [ "pushgateway:9091" ]; } ];

     

       22
       +
                   }

     

       23
       +
                 ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       24
        
               };

     

       25
       +
             };

     

       26
        
       

     

       27
       +
           pushgateway =

     

       28
       +
             { config, pkgs, ... }:

     

       29
       +
             {

     

       30
       +
               networking.firewall.allowedTCPPorts = [ 9091 ];

     

       31
        
       

     

       32
       +
               services.prometheus.pushgateway = {

     

       33
       +
                 enable = true;

     

       0
        
       
     

       34
        
               };

     

       35
       +
             };

     

       36
        
       

     

       37
       +
           client = { config, pkgs, ... }: { };

     

       38
       +
         };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       39
        
       

     

       40
       +
         testScript = ''

     

       41
       +
           pushgateway.wait_for_unit("pushgateway")

     

       42
       +
           pushgateway.wait_for_open_port(9091)

     

       43
       +
           pushgateway.wait_until_succeeds("curl -s http://127.0.0.1:9091/-/ready")

     

       44
       +
           pushgateway.wait_until_succeeds("journalctl -o cat -u pushgateway.service | grep 'version=${pkgs.prometheus-pushgateway.version}'")

     

       45
        
       

     

       46
       +
           prometheus.wait_for_unit("prometheus")

     

       47
       +
           prometheus.wait_for_open_port(9090)

     

       48
        
       

     

       49
       +
           prometheus.wait_until_succeeds(

     

       50
       +
             "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=count(up\{job=\"pushgateway\"\})' | "

     

       51
       +
             + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       52
       +
           )

     

       53
        
       

     

       54
       +
           prometheus.wait_until_succeeds(

     

       55
       +
             "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=sum(pushgateway_build_info)%20by%20(version)' | "

     

       56
       +
             + "jq '.data.result[0].metric.version' | grep '\"${pkgs.prometheus-pushgateway.version}\"'"

     

       57
       +
           )

     

       58
        
       

     

       59
       +
           # Add a metric and check in Prometheus

     

       60
       +
           client.wait_until_succeeds(

     

       61
       +
             "echo 'some_metric 3.14' | curl --data-binary @- http://pushgateway:9091/metrics/job/some_job"

     

       62
       +
           )

     

       63
        
       

     

       64
       +
           prometheus.wait_until_succeeds(

     

       65
       +
             "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=some_metric' | "

     

       66
       +
             + "jq '.data.result[0].value[1]' | grep '\"3.14\"'"

     

       67
       +
           )

     

       68
        
       

     

       69
       +
           prometheus.wait_until_succeeds(

     

       70
       +
             "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=absent(some_metric)' | "

     

       71
       +
             + "jq '.data.result[0].value[1]' | grep 'null'"

     

       72
       +
           )

     

       73
        
       

     

       74
       +
           # Delete the metric, check not in Prometheus

     

       75
       +
           client.wait_until_succeeds(

     

       76
       +
             "curl -X DELETE http://pushgateway:9091/metrics/job/some_job"

     

       77
       +
           )

     

       78
        
       

     

       79
       +
           prometheus.wait_until_fails(

     

       80
       +
             "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=some_metric' | "

     

       81
       +
             + "jq '.data.result[0].value[1]' | grep '\"3.14\"'"

     

       82
       +
           )

     

       83
        
       

     

       84
       +
           prometheus.wait_until_succeeds(

     

       85
       +
             "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=absent(some_metric)' | "

     

       86
       +
             + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       87
       +
           )

     

       88
        
       

     

       89
       +
           pushgateway.log(pushgateway.succeed("systemd-analyze security pushgateway.service | grep -v '✓'"))

     

       90
       +
         '';

     

       91
       +
       }

     

       0

+53 -65

nixos/tests/prometheus/remote-write.nix

···

       1
       -
       import ../make-test-python.nix (

     

       2
       -
         { lib, pkgs, ... }:

     

       3
        
       

     

       4
       -
         {

     

       5
       -
           name = "prometheus-remote-write";

     

       6
       -
       

     

       7
       -
           nodes = {

     

       8
       -
             receiver =

     

       9
       -
               { config, pkgs, ... }:

     

       10
       -
               {

     

       11
       -
                 environment.systemPackages = [ pkgs.jq ];

     

       12
        
       

     

       13
       -
                 networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       14
        
       

     

       15
       -
                 services.prometheus = {

     

       16
       -
                   enable = true;

     

       17
       -
                   globalConfig.scrape_interval = "2s";

     

       18
        
       

     

       19
       -
                   extraFlags = [ "--web.enable-remote-write-receiver" ];

     

       20
       -
                 };

     

       21
        
               };

     

       0
        
       
     

       22
        
       

     

       23
       -
             prometheus =

     

       24
       -
               { config, pkgs, ... }:

     

       25
       -
               {

     

       26
       -
                 environment.systemPackages = [ pkgs.jq ];

     

       27
        
       

     

       28
       -
                 networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       29
        
       

     

       30
       -
                 services.prometheus = {

     

       31
       -
                   enable = true;

     

       32
       -
                   globalConfig.scrape_interval = "2s";

     

       33
        
       

     

       34
       -
                   remoteWrite = [

     

       35
       -
                     {

     

       36
       -
                       url = "http://receiver:9090/api/v1/write";

     

       37
       -
                     }

     

       38
       -
                   ];

     

       39
        
       

     

       40
       -
                   scrapeConfigs = [

     

       41
       -
                     {

     

       42
       -
                       job_name = "node";

     

       43
       -
                       static_configs = [

     

       44
       -
                         {

     

       45
       -
                           targets = [

     

       46
       -
                             "node:${toString config.services.prometheus.exporters.node.port}"

     

       47
       -
                           ];

     

       48
       -
                         }

     

       49
       -
                       ];

     

       50
       -
                     }

     

       51
       -
                   ];

     

       52
       -
                 };

     

       53
        
               };

     

       0
        
       
     

       54
        
       

     

       55
       -
             node =

     

       56
       -
               { config, pkgs, ... }:

     

       57
       -
               {

     

       58
       -
                 services.prometheus.exporters.node = {

     

       59
       -
                   enable = true;

     

       60
       -
                   openFirewall = true;

     

       61
       -
                 };

     

       62
        
               };

     

       63
       -
           };

     

       0
        
       
     

       64
        
       

     

       65
       -
           testScript = ''

     

       66
       -
             node.wait_for_unit("prometheus-node-exporter")

     

       67
       -
             node.wait_for_open_port(9100)

     

       68
        
       

     

       69
       -
             for machine in prometheus, receiver:

     

       70
       -
               machine.wait_for_unit("prometheus")

     

       71
       -
               machine.wait_for_open_port(9090)

     

       72
        
       

     

       73
       -
             # Verify both servers got the same data from the exporter

     

       74
       -
             for machine in prometheus, receiver:

     

       75
       -
               machine.wait_until_succeeds(

     

       76
       -
                 "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=node_exporter_build_info\{instance=\"node:9100\"\}' | "

     

       77
       -
                 + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       78
       -
               )

     

       79
       -
           '';

     

       80
       -
         }

     

       81
       -
       )

···

       1
       +
       {

     

       2
       +
         name = "prometheus-remote-write";

     

       3
        
       

     

       4
       +
         nodes = {

     

       5
       +
           receiver =

     

       6
       +
             { config, pkgs, ... }:

     

       7
       +
             {

     

       8
       +
               environment.systemPackages = [ pkgs.jq ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       9
        
       

     

       10
       +
               networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       11
        
       

     

       12
       +
               services.prometheus = {

     

       13
       +
                 enable = true;

     

       14
       +
                 globalConfig.scrape_interval = "2s";

     

       15
        
       

     

       16
       +
                 extraFlags = [ "--web.enable-remote-write-receiver" ];

     

       0
        
       
     

       17
        
               };

     

       18
       +
             };

     

       19
        
       

     

       20
       +
           prometheus =

     

       21
       +
             { config, pkgs, ... }:

     

       22
       +
             {

     

       23
       +
               environment.systemPackages = [ pkgs.jq ];

     

       24
        
       

     

       25
       +
               networking.firewall.allowedTCPPorts = [ config.services.prometheus.port ];

     

       26
        
       

     

       27
       +
               services.prometheus = {

     

       28
       +
                 enable = true;

     

       29
       +
                 globalConfig.scrape_interval = "2s";

     

       30
        
       

     

       31
       +
                 remoteWrite = [ { url = "http://receiver:9090/api/v1/write"; } ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       32
        
       

     

       33
       +
                 scrapeConfigs = [

     

       34
       +
                   {

     

       35
       +
                     job_name = "node";

     

       36
       +
                     static_configs = [

     

       37
       +
                       { targets = [ "node:${toString config.services.prometheus.exporters.node.port}" ]; }

     

       38
       +
                     ];

     

       39
       +
                   }

     

       40
       +
                 ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       41
        
               };

     

       42
       +
             };

     

       43
        
       

     

       44
       +
           node =

     

       45
       +
             { config, pkgs, ... }:

     

       46
       +
             {

     

       47
       +
               services.prometheus.exporters.node = {

     

       48
       +
                 enable = true;

     

       49
       +
                 openFirewall = true;

     

       0
        
       
     

       50
        
               };

     

       51
       +
             };

     

       52
       +
         };

     

       53
        
       

     

       54
       +
         testScript = ''

     

       55
       +
           node.wait_for_unit("prometheus-node-exporter")

     

       56
       +
           node.wait_for_open_port(9100)

     

       57
        
       

     

       58
       +
           for machine in prometheus, receiver:

     

       59
       +
             machine.wait_for_unit("prometheus")

     

       60
       +
             machine.wait_for_open_port(9090)

     

       61
        
       

     

       62
       +
           # Verify both servers got the same data from the exporter

     

       63
       +
           for machine in prometheus, receiver:

     

       64
       +
             machine.wait_until_succeeds(

     

       65
       +
               "curl -sf 'http://127.0.0.1:9090/api/v1/query?query=node_exporter_build_info\{instance=\"node:9100\"\}' | "

     

       66
       +
               + "jq '.data.result[0].value[1]' | grep '\"1\"'"

     

       67
       +
             )

     

       68
       +
         '';

     

       69
       +
       }

     

       0

+43

pkgs/by-name/al/alertmanager-ntfy/package.nix

···

       1
       +
       {

     

       2
       +
         lib,

     

       3
       +
         buildGoModule,

     

       4
       +
         fetchFromGitHub,

     

       5
       +
         nixosTests,

     

       6
       +
         nix-update-script,

     

       7
       +
       }:

     

       8
       +
       

     

       9
       +
       buildGoModule {

     

       10
       +
         pname = "alertmanager-ntfy";

     

       11
       +
         version = "0-unstable-2025-02-24";

     

       12
       +
       

     

       13
       +
         src = fetchFromGitHub {

     

       14
       +
           owner = "alexbakker";

     

       15
       +
           repo = "alertmanager-ntfy";

     

       16
       +
           rev = "4573b96077faf39c3d04df913e93d9ded1f1a16c";

     

       17
       +
           hash = "sha256-JmXeDZBcbRDEaDVt7HuR9L9WZzrtqDrUMpHM7cHSQO0=";

     

       18
       +
         };

     

       19
       +
       

     

       20
       +
         vendorHash = "sha256-e1JAoDNm2+xB/bZcEGr5l4+va8GIg1R8pdj3d+/Y+UY=";

     

       21
       +
       

     

       22
       +
         doInstallCheck = true;

     

       23
       +
         installCheckPhase = ''

     

       24
       +
           runHook preInstallCheck

     

       25
       +
       

     

       26
       +
           $out/bin/alertmanager-ntfy --help > /dev/null

     

       27
       +
       

     

       28
       +
           runHook postInstallCheck

     

       29
       +
         '';

     

       30
       +
       

     

       31
       +
         passthru = {

     

       32
       +
           tests = { inherit (nixosTests.prometheus) alertmanager-ntfy; };

     

       33
       +
           updateScript = nix-update-script { extraArgs = [ "--version=branch=master" ]; };

     

       34
       +
         };

     

       35
       +
       

     

       36
       +
         meta = {

     

       37
       +
           description = "Forwards Prometheus Alertmanager notifications to ntfy.sh";

     

       38
       +
           homepage = "https://github.com/alexbakker/alertmanager-ntfy";

     

       39
       +
           license = lib.licenses.gpl3Only;

     

       40
       +
           maintainers = with lib.maintainers; [ defelo ];

     

       41
       +
           mainProgram = "alertmanager-ntfy";

     

       42
       +
         };

     

       43
       +
       }