commit f4d03b5c9cf2b694792dec88e3ca805cf7b43e3c · pyrox.dev/nixpkgs

+1 -10

nixos/modules/module-list.nix

···

       398
       398
        
         ./services/monitoring/osquery.nix

     

       399
       399
        
         ./services/monitoring/prometheus/default.nix

     

       400
       400
        
         ./services/monitoring/prometheus/alertmanager.nix

     

       401
       401
       -
         ./services/monitoring/prometheus/blackbox-exporter.nix

     

       402
       402
       -
         ./services/monitoring/prometheus/collectd-exporter.nix

     

       403
       403
       -
         ./services/monitoring/prometheus/fritzbox-exporter.nix

     

       404
       404
       -
         ./services/monitoring/prometheus/json-exporter.nix

     

       405
       405
       -
         ./services/monitoring/prometheus/minio-exporter.nix

     

       406
       406
       -
         ./services/monitoring/prometheus/nginx-exporter.nix

     

       407
       407
       -
         ./services/monitoring/prometheus/node-exporter.nix

     

       408
       408
       -
         ./services/monitoring/prometheus/snmp-exporter.nix

     

       409
       409
       -
         ./services/monitoring/prometheus/unifi-exporter.nix

     

       410
       410
       -
         ./services/monitoring/prometheus/varnish-exporter.nix

     

       401
       401
       +
         ./services/monitoring/prometheus/exporters.nix

     

       411
       402
        
         ./services/monitoring/riemann.nix

     

       412
       403
        
         ./services/monitoring/riemann-dash.nix

     

       413
       404
        
         ./services/monitoring/riemann-tools.nix

+7 -1

nixos/modules/rename.nix

···

       240
       240
        
       

     

       241
       241
        
           # Xen

     

       242
       242
        
           (mkRenamedOptionModule [ "virtualisation" "xen" "qemu-package" ] [ "virtualisation" "xen" "package-qemu" ])

     

       243
       243
       -
         ];

     

       243
       243
       +
         ] ++ (flip map [ "blackboxExporter" "collectdExporter" "fritzboxExporter"

     

       244
       244
       +
                          "jsonExporter" "minioExporter" "nginxExporter" "nodeExporter"

     

       245
       245
       +
                          "snmpExporter" "unifiExporter" "varnishExporter" ]

     

       246
       246
       +
              (opt: mkRemovedOptionModule [ "services" "prometheus" "${opt}" ] ''

     

       247
       247
       +
                The prometheus exporters are now configured using `services.prometheus.exporters'.

     

       248
       248
       +
                See the 18.03 release notes for more information.

     

       249
       249
       +
              '' ));

     

       244
       250
        
       }

-68

nixos/modules/services/monitoring/prometheus/blackbox-exporter.nix

···

       1
       1
       -
       { config, pkgs, lib, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       5
       -
       let

     

       6
       6
       -
         cfg = config.services.prometheus.blackboxExporter;

     

       7
       7
       -
       in {

     

       8
       8
       -
         options = {

     

       9
       9
       -
           services.prometheus.blackboxExporter = {

     

       10
       10
       -
             enable = mkEnableOption "prometheus blackbox exporter";

     

       11
       11
       -
       

     

       12
       12
       -
             configFile = mkOption {

     

       13
       13
       -
               type = types.path;

     

       14
       14
       -
               description = ''

     

       15
       15
       -
                 Path to configuration file.

     

       16
       16
       -
               '';

     

       17
       17
       -
             };

     

       18
       18
       -
       

     

       19
       19
       -
             port = mkOption {

     

       20
       20
       -
               type = types.int;

     

       21
       21
       -
               default = 9115;

     

       22
       22
       -
               description = ''

     

       23
       23
       -
                 Port to listen on.

     

       24
       24
       -
               '';

     

       25
       25
       -
             };

     

       26
       26
       -
       

     

       27
       27
       -
             extraFlags = mkOption {

     

       28
       28
       -
               type = types.listOf types.str;

     

       29
       29
       -
               default = [];

     

       30
       30
       -
               description = ''

     

       31
       31
       -
                 Extra commandline options when launching the blackbox exporter.

     

       32
       32
       -
               '';

     

       33
       33
       -
             };

     

       34
       34
       -
       

     

       35
       35
       -
             openFirewall = mkOption {

     

       36
       36
       -
               type = types.bool;

     

       37
       37
       -
               default = false;

     

       38
       38
       -
               description = ''

     

       39
       39
       -
                 Open port in firewall for incoming connections.

     

       40
       40
       -
               '';

     

       41
       41
       -
             };

     

       42
       42
       -
           };

     

       43
       43
       -
         };

     

       44
       44
       -
       

     

       45
       45
       -
         config = mkIf cfg.enable {

     

       46
       46
       -
           networking.firewall.allowedTCPPorts = optional cfg.openFirewall cfg.port;

     

       47
       47
       -
       

     

       48
       48
       -
           systemd.services.prometheus-blackbox-exporter = {

     

       49
       49
       -
             description = "Prometheus exporter for blackbox probes";

     

       50
       50
       -
             unitConfig.Documentation = "https://github.com/prometheus/blackbox_exporter";

     

       51
       51
       -
             wantedBy = [ "multi-user.target" ];

     

       52
       52
       -
             serviceConfig = {

     

       53
       53
       -
               User = "nobody";

     

       54
       54
       -
               Restart = "always";

     

       55
       55
       -
               PrivateTmp = true;

     

       56
       56
       -
               WorkingDirectory = /tmp;

     

       57
       57
       -
               AmbientCapabilities = [ "CAP_NET_RAW" ]; # for ping probes

     

       58
       58
       -
               ExecStart = ''

     

       59
       59
       -
                 ${pkgs.prometheus-blackbox-exporter}/bin/blackbox_exporter \

     

       60
       60
       -
                   --web.listen-address :${toString cfg.port} \

     

       61
       61
       -
                   --config.file ${cfg.configFile} \

     

       62
       62
       -
                   ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       63
       63
       -
               '';

     

       64
       64
       -
               ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";

     

       65
       65
       -
             };

     

       66
       66
       -
           };

     

       67
       67
       -
         };

     

       68
       68
       -
       }

-128

nixos/modules/services/monitoring/prometheus/collectd-exporter.nix

···

       1
       1
       -
       { config, pkgs, lib, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       5
       -
       let

     

       6
       6
       -
         cfg = config.services.prometheus.collectdExporter;

     

       7
       7
       -
       

     

       8
       8
       -
         collectSettingsArgs = if (cfg.collectdBinary.enable) then ''

     

       9
       9
       -
           -collectd.listen-address ${optionalString (cfg.collectdBinary.listenAddress != null) cfg.collectdBinary.listenAddress}:${toString cfg.collectdBinary.port} \

     

       10
       10
       -
           -collectd.security-level ${cfg.collectdBinary.securityLevel} \

     

       11
       11
       -
         '' else "";

     

       12
       12
       -
       

     

       13
       13
       -
       in {

     

       14
       14
       -
         options = {

     

       15
       15
       -
           services.prometheus.collectdExporter = {

     

       16
       16
       -
             enable = mkEnableOption "prometheus collectd exporter";

     

       17
       17
       -
       

     

       18
       18
       -
             port = mkOption {

     

       19
       19
       -
               type = types.int;

     

       20
       20
       -
               default = 9103;

     

       21
       21
       -
               description = ''

     

       22
       22
       -
                 Port to listen on.

     

       23
       23
       -
                 This is used for scraping as well as the to receive collectd data via the write_http plugin.

     

       24
       24
       -
               '';

     

       25
       25
       -
             };

     

       26
       26
       -
       

     

       27
       27
       -
             listenAddress = mkOption {

     

       28
       28
       -
               type = types.nullOr types.str;

     

       29
       29
       -
               default = null;

     

       30
       30
       -
               example = "0.0.0.0";

     

       31
       31
       -
               description = ''

     

       32
       32
       -
                 Address to listen on for web interface, telemetry and collectd JSON data.

     

       33
       33
       -
               '';

     

       34
       34
       -
             };

     

       35
       35
       -
       

     

       36
       36
       -
             collectdBinary = {

     

       37
       37
       -
               enable = mkEnableOption "collectd binary protocol receiver";

     

       38
       38
       -
       

     

       39
       39
       -
               authFile = mkOption {

     

       40
       40
       -
                 default = null;

     

       41
       41
       -
                 type = types.nullOr types.path;

     

       42
       42
       -
                 description = "File mapping user names to pre-shared keys (passwords).";

     

       43
       43
       -
               };

     

       44
       44
       -
       

     

       45
       45
       -
               port = mkOption {

     

       46
       46
       -
                 type = types.int;

     

       47
       47
       -
                 default = 25826;

     

       48
       48
       -
                 description = ''Network address on which to accept collectd binary network packets.'';

     

       49
       49
       -
               };

     

       50
       50
       -
       

     

       51
       51
       -
               listenAddress = mkOption {

     

       52
       52
       -
                 type = types.nullOr types.str;

     

       53
       53
       -
                 default = null;

     

       54
       54
       -
                 example = "0.0.0.0";

     

       55
       55
       -
                 description = ''

     

       56
       56
       -
                   Address to listen on for binary network packets.

     

       57
       57
       -
                   '';

     

       58
       58
       -
               };

     

       59
       59
       -
       

     

       60
       60
       -
               securityLevel = mkOption {

     

       61
       61
       -
                 type = types.enum ["None" "Sign" "Encrypt"];

     

       62
       62
       -
                 default = "None";

     

       63
       63
       -
                 description = ''

     

       64
       64
       -
                   Minimum required security level for accepted packets.

     

       65
       65
       -
                   '';

     

       66
       66
       -
               };

     

       67
       67
       -
             };

     

       68
       68
       -
       

     

       69
       69
       -
             extraFlags = mkOption {

     

       70
       70
       -
               type = types.listOf types.str;

     

       71
       71
       -
               default = [];

     

       72
       72
       -
               description = ''

     

       73
       73
       -
                 Extra commandline options when launching the collectd exporter.

     

       74
       74
       -
               '';

     

       75
       75
       -
             };

     

       76
       76
       -
       

     

       77
       77
       -
             logFormat = mkOption {

     

       78
       78
       -
               type = types.str;

     

       79
       79
       -
               default = "logger:stderr";

     

       80
       80
       -
               example = "logger:syslog?appname=bob&local=7 or logger:stdout?json=true";

     

       81
       81
       -
               description = ''

     

       82
       82
       -
                 Set the log target and format.

     

       83
       83
       -
               '';

     

       84
       84
       -
             };

     

       85
       85
       -
       

     

       86
       86
       -
             logLevel = mkOption {

     

       87
       87
       -
               type = types.enum ["debug" "info" "warn" "error" "fatal"];

     

       88
       88
       -
               default = "info";

     

       89
       89
       -
               description = ''

     

       90
       90
       -
                 Only log messages with the given severity or above.

     

       91
       91
       -
               '';

     

       92
       92
       -
             };

     

       93
       93
       -
       

     

       94
       94
       -
             openFirewall = mkOption {

     

       95
       95
       -
               type = types.bool;

     

       96
       96
       -
               default = false;

     

       97
       97
       -
               description = ''

     

       98
       98
       -
                 Open port in firewall for incoming connections.

     

       99
       99
       -
               '';

     

       100
       100
       -
             };

     

       101
       101
       -
           };

     

       102
       102
       -
         };

     

       103
       103
       -
       

     

       104
       104
       -
         config = mkIf cfg.enable {

     

       105
       105
       -
           networking.firewall.allowedTCPPorts = (optional cfg.openFirewall cfg.port) ++

     

       106
       106
       -
             (optional (cfg.openFirewall && cfg.collectdBinary.enable) cfg.collectdBinary.port);

     

       107
       107
       -
       

     

       108
       108
       -
           systemd.services.prometheus-collectd-exporter = {

     

       109
       109
       -
             description = "Prometheus exporter for Collectd metrics";

     

       110
       110
       -
             unitConfig.Documentation = "https://github.com/prometheus/collectd_exporter";

     

       111
       111
       -
             wantedBy = [ "multi-user.target" ];

     

       112
       112
       -
             serviceConfig = {

     

       113
       113
       -
               DynamicUser = true;

     

       114
       114
       -
               Restart = "always";

     

       115
       115
       -
               PrivateTmp = true;

     

       116
       116
       -
               WorkingDirectory = /tmp;

     

       117
       117
       -
               ExecStart = ''

     

       118
       118
       -
                 ${pkgs.prometheus-collectd-exporter}/bin/collectd_exporter \

     

       119
       119
       -
                   -log.format ${cfg.logFormat} \

     

       120
       120
       -
                   -log.level ${cfg.logLevel} \

     

       121
       121
       -
                   -web.listen-address ${optionalString (cfg.listenAddress != null) cfg.listenAddress}:${toString cfg.port} \

     

       122
       122
       -
                   ${collectSettingsArgs} \

     

       123
       123
       -
                   ${concatStringsSep " " cfg.extraFlags}

     

       124
       124
       -
               '';

     

       125
       125
       -
             };

     

       126
       126
       -
           };

     

       127
       127
       -
         };

     

       128
       128
       -
       }

+169

nixos/modules/services/monitoring/prometheus/exporters.nix

···

       1
       1
       +
       { config, pkgs, lib, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cfg = config.services.prometheus.exporters;

     

       7
       7
       +
       

     

       8
       8
       +
         # each attribute in `exporterOpts` is expected to have specified:

     

       9
       9
       +
         #   - port        (types.int):   port on which the exporter listens

     

       10
       10
       +
         #   - serviceOpts (types.attrs): config that is merged with the

     

       11
       11
       +
         #                                default definition of the exporter's

     

       12
       12
       +
         #                                systemd service

     

       13
       13
       +
         #   - extraOpts   (types.attrs): extra configuration options to

     

       14
       14
       +
         #                                configure the exporter with, which

     

       15
       15
       +
         #                                are appended to the default options

     

       16
       16
       +
         #

     

       17
       17
       +
         #  Note that `extraOpts` is optional, but a script for the exporter's

     

       18
       18
       +
         #  systemd service must be provided by specifying either

     

       19
       19
       +
         #  `serviceOpts.script` or `serviceOpts.serviceConfig.ExecStart`

     

       20
       20
       +
         exporterOpts = {

     

       21
       21
       +
           blackbox = import ./exporters/blackbox.nix { inherit config lib pkgs; };

     

       22
       22
       +
           collectd = import ./exporters/collectd.nix { inherit config lib pkgs; };

     

       23
       23
       +
           fritzbox = import ./exporters/fritzbox.nix { inherit config lib pkgs; };

     

       24
       24
       +
           json     = import ./exporters/json.nix     { inherit config lib pkgs; };

     

       25
       25
       +
           minio    = import ./exporters/minio.nix    { inherit config lib pkgs; };

     

       26
       26
       +
           nginx    = import ./exporters/nginx.nix    { inherit config lib pkgs; };

     

       27
       27
       +
           node     = import ./exporters/node.nix     { inherit config lib pkgs; };

     

       28
       28
       +
           snmp     = import ./exporters/snmp.nix     { inherit config lib pkgs; };

     

       29
       29
       +
           unifi    = import ./exporters/unifi.nix    { inherit config lib pkgs; };

     

       30
       30
       +
           varnish  = import ./exporters/varnish.nix  { inherit config lib pkgs; };

     

       31
       31
       +
         };

     

       32
       32
       +
       

     

       33
       33
       +
         mkExporterOpts = ({ name, port }: {

     

       34
       34
       +
           enable = mkEnableOption "the prometheus ${name} exporter";

     

       35
       35
       +
           port = mkOption {

     

       36
       36
       +
             type = types.int;

     

       37
       37
       +
             default = port;

     

       38
       38
       +
             description = ''

     

       39
       39
       +
               Port to listen on.

     

       40
       40
       +
             '';

     

       41
       41
       +
           };

     

       42
       42
       +
           listenAddress = mkOption {

     

       43
       43
       +
             type = types.str;

     

       44
       44
       +
             default = "0.0.0.0";

     

       45
       45
       +
             description = ''

     

       46
       46
       +
               Address to listen on.

     

       47
       47
       +
             '';

     

       48
       48
       +
           };

     

       49
       49
       +
           extraFlags = mkOption {

     

       50
       50
       +
             type = types.listOf types.str;

     

       51
       51
       +
             default = [];

     

       52
       52
       +
             description = ''

     

       53
       53
       +
               Extra commandline options to pass to the ${name} exporter.

     

       54
       54
       +
             '';

     

       55
       55
       +
           };

     

       56
       56
       +
           openFirewall = mkOption {

     

       57
       57
       +
             type = types.bool;

     

       58
       58
       +
             default = false;

     

       59
       59
       +
             description = ''

     

       60
       60
       +
               Open port in firewall for incoming connections.

     

       61
       61
       +
             '';

     

       62
       62
       +
           };

     

       63
       63
       +
           firewallFilter = mkOption {

     

       64
       64
       +
             type = types.str;

     

       65
       65
       +
             default = "-p tcp -m tcp --dport ${toString port}";

     

       66
       66
       +
             example = literalExample ''

     

       67
       67
       +
               "-i eth0 -p tcp -m tcp --dport ${toString port}"

     

       68
       68
       +
             '';

     

       69
       69
       +
             description = ''

     

       70
       70
       +
               Specify a filter for iptables to use when

     

       71
       71
       +
               <option>services.prometheus.exporters.${name}.openFirewall</option>

     

       72
       72
       +
               is true. It is used as `ip46tables -I INPUT <option>firewallFilter</option> -j ACCEPT`.

     

       73
       73
       +
             '';

     

       74
       74
       +
           };

     

       75
       75
       +
           user = mkOption {

     

       76
       76
       +
             type = types.str;

     

       77
       77
       +
             default = "nobody";

     

       78
       78
       +
             description = ''

     

       79
       79
       +
               User name under which the ${name} exporter shall be run.

     

       80
       80
       +
               Has no effect when <option>systemd.services.prometheus-${name}-exporter.serviceConfig.DynamicUser</option> is true.

     

       81
       81
       +
             '';

     

       82
       82
       +
           };

     

       83
       83
       +
           group = mkOption {

     

       84
       84
       +
             type = types.str;

     

       85
       85
       +
             default = "nobody";

     

       86
       86
       +
             description = ''

     

       87
       87
       +
               Group under which the ${name} exporter shall be run.

     

       88
       88
       +
               Has no effect when <option>systemd.services.prometheus-${name}-exporter.serviceConfig.DynamicUser</option> is true.

     

       89
       89
       +
             '';

     

       90
       90
       +
           };

     

       91
       91
       +
         });

     

       92
       92
       +
       

     

       93
       93
       +
         mkSubModule = { name, port, extraOpts, serviceOpts }: {

     

       94
       94
       +
           ${name} = mkOption {

     

       95
       95
       +
             type = types.submodule {

     

       96
       96
       +
               options = (mkExporterOpts {

     

       97
       97
       +
                 inherit name port;

     

       98
       98
       +
               } // extraOpts);

     

       99
       99
       +
             };

     

       100
       100
       +
             internal = true;

     

       101
       101
       +
             default = {};

     

       102
       102
       +
           };

     

       103
       103
       +
         };

     

       104
       104
       +
       

     

       105
       105
       +
         mkSubModules = (foldl' (a: b: a//b) {}

     

       106
       106
       +
           (mapAttrsToList (name: opts: mkSubModule {

     

       107
       107
       +
             inherit name;

     

       108
       108
       +
             inherit (opts) port serviceOpts;

     

       109
       109
       +
             extraOpts = opts.extraOpts or {};

     

       110
       110
       +
           }) exporterOpts)

     

       111
       111
       +
         );

     

       112
       112
       +
       

     

       113
       113
       +
         mkExporterConf = { name, conf, serviceOpts }:

     

       114
       114
       +
           mkIf conf.enable {

     

       115
       115
       +
             networking.firewall.extraCommands = mkIf conf.openFirewall ''

     

       116
       116
       +
               ip46tables -I INPUT ${conf.firewallFilter} -j ACCEPT

     

       117
       117
       +
             '';

     

       118
       118
       +
             systemd.services."prometheus-${name}-exporter" = mkMerge ([{

     

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

     

       120
       120
       +
               after = [ "network.target" ];

     

       121
       121
       +
               serviceConfig = {

     

       122
       122
       +
                 Restart = mkDefault "always";

     

       123
       123
       +
                 PrivateTmp = mkDefault true;

     

       124
       124
       +
                 WorkingDirectory = mkDefault /tmp;

     

       125
       125
       +
               } // mkIf (!(serviceOpts.serviceConfig.DynamicUser or false)) {

     

       126
       126
       +
                 User = conf.user;

     

       127
       127
       +
                 Group = conf.group;

     

       128
       128
       +
               };

     

       129
       129
       +
             } serviceOpts ]);

     

       130
       130
       +
         };

     

       131
       131
       +
       in

     

       132
       132
       +
       {

     

       133
       133
       +
         options.services.prometheus.exporters = mkOption {

     

       134
       134
       +
           type = types.submodule {

     

       135
       135
       +
             options = (mkSubModules);

     

       136
       136
       +
           };

     

       137
       137
       +
           description = "Prometheus exporter configuration";

     

       138
       138
       +
           default = {};

     

       139
       139
       +
           example = literalExample ''

     

       140
       140
       +
             {

     

       141
       141
       +
               node = {

     

       142
       142
       +
                 enable = true;

     

       143
       143
       +
                 enabledCollectors = [ "systemd" ];

     

       144
       144
       +
               };

     

       145
       145
       +
               varnish.enable = true;

     

       146
       146
       +
             }

     

       147
       147
       +
           '';

     

       148
       148
       +
         };

     

       149
       149
       +
       

     

       150
       150
       +
         config = mkMerge ([{

     

       151
       151
       +
           assertions = [{

     

       152
       152
       +
             assertion = (cfg.snmp.configurationPath == null) != (cfg.snmp.configuration == null);

     

       153
       153
       +
             message = ''

     

       154
       154
       +
               Please ensure you have either `services.prometheus.exporters.snmp.configuration'

     

       155
       155
       +
                 or `services.prometheus.exporters.snmp.configurationPath' set!

     

       156
       156
       +
             '';

     

       157
       157
       +
           }];

     

       158
       158
       +
         }] ++ [(mkIf config.services.minio.enable {

     

       159
       159
       +
           services.prometheus.exporters.minio.minioAddress  = mkDefault "http://localhost:9000";

     

       160
       160
       +
           services.prometheus.exporters.minio.minioAccessKey = mkDefault config.services.minio.accessKey;

     

       161
       161
       +
           services.prometheus.exporters.minio.minioAccessSecret = mkDefault config.services.minio.secretKey;

     

       162
       162
       +
         })] ++ (mapAttrsToList (name: conf:

     

       163
       163
       +
           mkExporterConf {

     

       164
       164
       +
             inherit name;

     

       165
       165
       +
             inherit (conf) serviceOpts;

     

       166
       166
       +
             conf = cfg.${name};

     

       167
       167
       +
           }) exporterOpts)

     

       168
       168
       +
         );

     

       169
       169
       +
       }

+31

nixos/modules/services/monitoring/prometheus/exporters/blackbox.nix

···

       1
       1
       +
       { config, lib, pkgs }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cfg = config.services.prometheus.exporters.blackbox;

     

       7
       7
       +
       in

     

       8
       8
       +
       {

     

       9
       9
       +
         port = 9115;

     

       10
       10
       +
         extraOpts = {

     

       11
       11
       +
           configFile = mkOption {

     

       12
       12
       +
             type = types.path;

     

       13
       13
       +
             description = ''

     

       14
       14
       +
               Path to configuration file.

     

       15
       15
       +
             '';

     

       16
       16
       +
           };

     

       17
       17
       +
         };

     

       18
       18
       +
         serviceOpts = {

     

       19
       19
       +
           serviceConfig = {

     

       20
       20
       +
             AmbientCapabilities = [ "CAP_NET_RAW" ]; # for ping probes

     

       21
       21
       +
             DynamicUser = true;

     

       22
       22
       +
             ExecStart = ''

     

       23
       23
       +
               ${pkgs.prometheus-blackbox-exporter}/bin/blackbox_exporter \

     

       24
       24
       +
                 --web.listen-address ${cfg.listenAddress}:${toString cfg.port} \

     

       25
       25
       +
                 --config.file ${cfg.configFile} \

     

       26
       26
       +
                 ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       27
       27
       +
             '';

     

       28
       28
       +
             ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";

     

       29
       29
       +
           };

     

       30
       30
       +
         };

     

       31
       31
       +
       }

+78

nixos/modules/services/monitoring/prometheus/exporters/collectd.nix

···

       1
       1
       +
       { config, lib, pkgs }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cfg = config.services.prometheus.exporters.collectd;

     

       7
       7
       +
       in

     

       8
       8
       +
       {

     

       9
       9
       +
         port = 9103;

     

       10
       10
       +
         extraOpts = {

     

       11
       11
       +
           collectdBinary = {

     

       12
       12
       +
             enable = mkEnableOption "collectd binary protocol receiver";

     

       13
       13
       +
       

     

       14
       14
       +
             authFile = mkOption {

     

       15
       15
       +
               default = null;

     

       16
       16
       +
               type = types.nullOr types.path;

     

       17
       17
       +
               description = "File mapping user names to pre-shared keys (passwords).";

     

       18
       18
       +
             };

     

       19
       19
       +
       

     

       20
       20
       +
             port = mkOption {

     

       21
       21
       +
               type = types.int;

     

       22
       22
       +
               default = 25826;

     

       23
       23
       +
               description = ''Network address on which to accept collectd binary network packets.'';

     

       24
       24
       +
             };

     

       25
       25
       +
       

     

       26
       26
       +
             listenAddress = mkOption {

     

       27
       27
       +
               type = types.str;

     

       28
       28
       +
               default = "0.0.0.0";

     

       29
       29
       +
               description = ''

     

       30
       30
       +
                 Address to listen on for binary network packets.

     

       31
       31
       +
                 '';

     

       32
       32
       +
             };

     

       33
       33
       +
       

     

       34
       34
       +
             securityLevel = mkOption {

     

       35
       35
       +
               type = types.enum ["None" "Sign" "Encrypt"];

     

       36
       36
       +
               default = "None";

     

       37
       37
       +
               description = ''

     

       38
       38
       +
                 Minimum required security level for accepted packets.

     

       39
       39
       +
               '';

     

       40
       40
       +
             };

     

       41
       41
       +
           };

     

       42
       42
       +
       

     

       43
       43
       +
           logFormat = mkOption {

     

       44
       44
       +
             type = types.str;

     

       45
       45
       +
             default = "logger:stderr";

     

       46
       46
       +
             example = "logger:syslog?appname=bob&local=7 or logger:stdout?json=true";

     

       47
       47
       +
             description = ''

     

       48
       48
       +
               Set the log target and format.

     

       49
       49
       +
             '';

     

       50
       50
       +
           };

     

       51
       51
       +
       

     

       52
       52
       +
           logLevel = mkOption {

     

       53
       53
       +
             type = types.enum ["debug" "info" "warn" "error" "fatal"];

     

       54
       54
       +
             default = "info";

     

       55
       55
       +
             description = ''

     

       56
       56
       +
               Only log messages with the given severity or above.

     

       57
       57
       +
             '';

     

       58
       58
       +
           };

     

       59
       59
       +
         };

     

       60
       60
       +
         serviceOpts = let

     

       61
       61
       +
           collectSettingsArgs = if (cfg.collectdBinary.enable) then ''

     

       62
       62
       +
             -collectd.listen-address ${cfg.collectdBinary.listenAddress}:${toString cfg.collectdBinary.port} \

     

       63
       63
       +
             -collectd.security-level ${cfg.collectdBinary.securityLevel} \

     

       64
       64
       +
           '' else "";

     

       65
       65
       +
         in {

     

       66
       66
       +
           serviceConfig = {

     

       67
       67
       +
             DynamicUser = true;

     

       68
       68
       +
             ExecStart = ''

     

       69
       69
       +
               ${pkgs.prometheus-collectd-exporter}/bin/collectd_exporter \

     

       70
       70
       +
                 -log.format ${cfg.logFormat} \

     

       71
       71
       +
                 -log.level ${cfg.logLevel} \

     

       72
       72
       +
                 -web.listen-address ${cfg.listenAddress}:${toString cfg.port} \

     

       73
       73
       +
                 ${collectSettingsArgs} \

     

       74
       74
       +
                 ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       75
       75
       +
             '';

     

       76
       76
       +
           };

     

       77
       77
       +
         };

     

       78
       78
       +
       }

+39

nixos/modules/services/monitoring/prometheus/exporters/fritzbox.nix

···

       1
       1
       +
       { config, lib, pkgs }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cfg = config.services.prometheus.exporters.fritzbox;

     

       7
       7
       +
       in

     

       8
       8
       +
       {

     

       9
       9
       +
         port = 9133;

     

       10
       10
       +
         extraOpts = {

     

       11
       11
       +
           gatewayAddress = mkOption {

     

       12
       12
       +
             type = types.str;

     

       13
       13
       +
             default = "fritz.box";

     

       14
       14
       +
             description = ''

     

       15
       15
       +
               The hostname or IP of the FRITZ!Box.

     

       16
       16
       +
             '';

     

       17
       17
       +
           };

     

       18
       18
       +
       

     

       19
       19
       +
           gatewayPort = mkOption {

     

       20
       20
       +
             type = types.int;

     

       21
       21
       +
             default = 49000;

     

       22
       22
       +
             description = ''

     

       23
       23
       +
               The port of the FRITZ!Box UPnP service.

     

       24
       24
       +
             '';

     

       25
       25
       +
           };

     

       26
       26
       +
         };

     

       27
       27
       +
         serviceOpts = {

     

       28
       28
       +
           serviceConfig = {

     

       29
       29
       +
             DynamicUser = true;

     

       30
       30
       +
             ExecStart = ''

     

       31
       31
       +
               ${pkgs.prometheus-fritzbox-exporter}/bin/fritzbox_exporter \

     

       32
       32
       +
                 -listen-address ${cfg.listenAddress}:${toString cfg.port} \

     

       33
       33
       +
                 -gateway-address ${cfg.gatewayAddress} \

     

       34
       34
       +
                 -gateway-port ${toString cfg.gatewayPort} \

     

       35
       35
       +
                 ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       36
       36
       +
             '';

     

       37
       37
       +
           };

     

       38
       38
       +
         };

     

       39
       39
       +
       }

+36

nixos/modules/services/monitoring/prometheus/exporters/json.nix

···

       1
       1
       +
       { config, lib, pkgs }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cfg = config.services.prometheus.exporters.json;

     

       7
       7
       +
       in

     

       8
       8
       +
       {

     

       9
       9
       +
         port = 7979;

     

       10
       10
       +
         extraOpts = {

     

       11
       11
       +
           url = mkOption {

     

       12
       12
       +
             type = types.str;

     

       13
       13
       +
             description = ''

     

       14
       14
       +
               URL to scrape JSON from.

     

       15
       15
       +
             '';

     

       16
       16
       +
           };

     

       17
       17
       +
           configFile = mkOption {

     

       18
       18
       +
             type = types.path;

     

       19
       19
       +
             description = ''

     

       20
       20
       +
               Path to configuration file.

     

       21
       21
       +
             '';

     

       22
       22
       +
           };

     

       23
       23
       +
           listenAddress = {}; # not used

     

       24
       24
       +
         };

     

       25
       25
       +
         serviceOpts = {

     

       26
       26
       +
           serviceConfig = {

     

       27
       27
       +
             DynamicUser = true;

     

       28
       28
       +
             ExecStart = ''

     

       29
       29
       +
               ${pkgs.prometheus-json-exporter}/bin/prometheus-json-exporter \

     

       30
       30
       +
                 --port ${toString cfg.port} \

     

       31
       31
       +
                 ${cfg.url} ${cfg.configFile} \

     

       32
       32
       +
                 ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       33
       33
       +
             '';

     

       34
       34
       +
           };

     

       35
       35
       +
         };

     

       36
       36
       +
       }

+65

nixos/modules/services/monitoring/prometheus/exporters/minio.nix

···

       1
       1
       +
       { config, lib, pkgs }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cfg = config.services.prometheus.exporters.minio;

     

       7
       7
       +
       in

     

       8
       8
       +
       {

     

       9
       9
       +
         port = 9290;

     

       10
       10
       +
         extraOpts = {

     

       11
       11
       +
           minioAddress = mkOption {

     

       12
       12
       +
             type = types.str;

     

       13
       13
       +
             example = "https://10.0.0.1:9000";

     

       14
       14
       +
             description = ''

     

       15
       15
       +
               The URL of the minio server.

     

       16
       16
       +
               Use HTTPS if Minio accepts secure connections only.

     

       17
       17
       +
               By default this connects to the local minio server if enabled.

     

       18
       18
       +
             '';

     

       19
       19
       +
           };

     

       20
       20
       +
       

     

       21
       21
       +
           minioAccessKey = mkOption {

     

       22
       22
       +
             type = types.str;

     

       23
       23
       +
             example = "yourMinioAccessKey";

     

       24
       24
       +
             description = ''

     

       25
       25
       +
               The value of the Minio access key.

     

       26
       26
       +
               It is required in order to connect to the server.

     

       27
       27
       +
               By default this uses the one from the local minio server if enabled

     

       28
       28
       +
               and <literal>config.services.minio.accessKey</literal>.

     

       29
       29
       +
             '';

     

       30
       30
       +
           };

     

       31
       31
       +
       

     

       32
       32
       +
           minioAccessSecret = mkOption {

     

       33
       33
       +
             type = types.str;

     

       34
       34
       +
             description = ''

     

       35
       35
       +
               The value of the Minio access secret.

     

       36
       36
       +
               It is required in order to connect to the server.

     

       37
       37
       +
               By default this uses the one from the local minio server if enabled

     

       38
       38
       +
               and <literal>config.services.minio.secretKey</literal>.

     

       39
       39
       +
             '';

     

       40
       40
       +
           };

     

       41
       41
       +
       

     

       42
       42
       +
           minioBucketStats = mkOption {

     

       43
       43
       +
             type = types.bool;

     

       44
       44
       +
             default = false;

     

       45
       45
       +
             description = ''

     

       46
       46
       +
               Collect statistics about the buckets and files in buckets.

     

       47
       47
       +
               It requires more computation, use it carefully in case of large buckets..

     

       48
       48
       +
             '';

     

       49
       49
       +
           };

     

       50
       50
       +
         };

     

       51
       51
       +
         serviceOpts = {

     

       52
       52
       +
           serviceConfig = {

     

       53
       53
       +
             DynamicUser = true;

     

       54
       54
       +
             ExecStart = ''

     

       55
       55
       +
               ${pkgs.prometheus-minio-exporter}/bin/minio-exporter \

     

       56
       56
       +
                 -web.listen-address ${cfg.listenAddress}:${toString cfg.port} \

     

       57
       57
       +
                 -minio.server ${cfg.minioAddress} \

     

       58
       58
       +
                 -minio.access-key ${cfg.minioAccessKey} \

     

       59
       59
       +
                 -minio.access-secret ${cfg.minioAccessSecret} \

     

       60
       60
       +
                 ${optionalString cfg.minioBucketStats "-minio.bucket-stats"} \

     

       61
       61
       +
                 ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       62
       62
       +
             '';

     

       63
       63
       +
           };

     

       64
       64
       +
         };

     

       65
       65
       +
       }

+31

nixos/modules/services/monitoring/prometheus/exporters/nginx.nix

···

       1
       1
       +
       { config, lib, pkgs }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cfg = config.services.prometheus.exporters.nginx;

     

       7
       7
       +
       in

     

       8
       8
       +
       {

     

       9
       9
       +
         port = 9113;

     

       10
       10
       +
         extraOpts = {

     

       11
       11
       +
           scrapeUri = mkOption {

     

       12
       12
       +
             type = types.string;

     

       13
       13
       +
             default = "http://localhost/nginx_status";

     

       14
       14
       +
             description = ''

     

       15
       15
       +
               Address to access the nginx status page.

     

       16
       16
       +
               Can be enabled with services.nginx.statusPage = true.

     

       17
       17
       +
             '';

     

       18
       18
       +
           };

     

       19
       19
       +
         };

     

       20
       20
       +
         serviceOpts = {

     

       21
       21
       +
           serviceConfig = {

     

       22
       22
       +
             DynamicUser = true;

     

       23
       23
       +
             ExecStart = ''

     

       24
       24
       +
               ${pkgs.prometheus-nginx-exporter}/bin/nginx_exporter \

     

       25
       25
       +
                 -nginx.scrape_uri '${cfg.scrapeUri}' \

     

       26
       26
       +
                 -telemetry.address ${cfg.listenAddress}:${toString cfg.port} \

     

       27
       27
       +
                 ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       28
       28
       +
             '';

     

       29
       29
       +
           };

     

       30
       30
       +
         };

     

       31
       31
       +
       }

+39

nixos/modules/services/monitoring/prometheus/exporters/node.nix

···

       1
       1
       +
       { config, lib, pkgs }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cfg = config.services.prometheus.exporters.node;

     

       7
       7
       +
       in

     

       8
       8
       +
       {

     

       9
       9
       +
         port = 9100;

     

       10
       10
       +
         extraOpts = {

     

       11
       11
       +
           enabledCollectors = mkOption {

     

       12
       12
       +
             type = types.listOf types.string;

     

       13
       13
       +
             default = [];

     

       14
       14
       +
             example = ''[ "systemd" ]'';

     

       15
       15
       +
             description = ''

     

       16
       16
       +
               Collectors to enable. The collectors listed here are enabled in addition to the default ones.

     

       17
       17
       +
             '';

     

       18
       18
       +
           };

     

       19
       19
       +
           disabledCollectors = mkOption {

     

       20
       20
       +
             type = types.listOf types.str;

     

       21
       21
       +
             default = [];

     

       22
       22
       +
             example = ''[ "timex" ]'';

     

       23
       23
       +
             description = ''

     

       24
       24
       +
               Collectors to disable which are enabled by default.

     

       25
       25
       +
             '';

     

       26
       26
       +
           };

     

       27
       27
       +
         };

     

       28
       28
       +
         serviceOpts = {

     

       29
       29
       +
           serviceConfig = {

     

       30
       30
       +
             ExecStart = ''

     

       31
       31
       +
               ${pkgs.prometheus-node-exporter}/bin/node_exporter \

     

       32
       32
       +
                 ${concatMapStringsSep " " (x: "--collector." + x) cfg.enabledCollectors} \

     

       33
       33
       +
                 ${concatMapStringsSep " " (x: "--no-collector." + x) cfg.disabledCollectors} \

     

       34
       34
       +
                 --web.listen-address ${cfg.listenAddress}:${toString cfg.port} \

     

       35
       35
       +
                 ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       36
       36
       +
             '';

     

       37
       37
       +
           };

     

       38
       38
       +
         };

     

       39
       39
       +
       }

+71

nixos/modules/services/monitoring/prometheus/exporters/snmp.nix

···

       1
       1
       +
       { config, lib, pkgs }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cfg = config.services.prometheus.exporters.snmp;

     

       7
       7
       +
       in

     

       8
       8
       +
       {

     

       9
       9
       +
         port = 9116;

     

       10
       10
       +
         extraOpts = {

     

       11
       11
       +
           configurationPath = mkOption {

     

       12
       12
       +
             type = types.nullOr types.path;

     

       13
       13
       +
             default = null;

     

       14
       14
       +
             description = ''

     

       15
       15
       +
               Path to a snmp exporter configuration file. Mutually exclusive with 'configuration' option.

     

       16
       16
       +
             '';

     

       17
       17
       +
             example = "./snmp.yml";

     

       18
       18
       +
           };

     

       19
       19
       +
       

     

       20
       20
       +
           configuration = mkOption {

     

       21
       21
       +
             type = types.nullOr types.attrs;

     

       22
       22
       +
             default = {};

     

       23
       23
       +
             description = ''

     

       24
       24
       +
               Snmp exporter configuration as nix attribute set. Mutually exclusive with 'configurationPath' option.

     

       25
       25
       +
             '';

     

       26
       26
       +
             example = ''

     

       27
       27
       +
               {

     

       28
       28
       +
                 "default" = {

     

       29
       29
       +
                   "version" = 2;

     

       30
       30
       +
                   "auth" = {

     

       31
       31
       +
                     "community" = "public";

     

       32
       32
       +
                   };

     

       33
       33
       +
                 };

     

       34
       34
       +
               };

     

       35
       35
       +
             '';

     

       36
       36
       +
           };

     

       37
       37
       +
       

     

       38
       38
       +
           logFormat = mkOption {

     

       39
       39
       +
             type = types.str;

     

       40
       40
       +
             default = "logger:stderr";

     

       41
       41
       +
             description = ''

     

       42
       42
       +
               Set the log target and format.

     

       43
       43
       +
             '';

     

       44
       44
       +
           };

     

       45
       45
       +
       

     

       46
       46
       +
           logLevel = mkOption {

     

       47
       47
       +
             type = types.enum ["debug" "info" "warn" "error" "fatal"];

     

       48
       48
       +
             default = "info";

     

       49
       49
       +
             description = ''

     

       50
       50
       +
               Only log messages with the given severity or above.

     

       51
       51
       +
             '';

     

       52
       52
       +
           };

     

       53
       53
       +
         };

     

       54
       54
       +
         serviceOpts = let

     

       55
       55
       +
           configFile = if cfg.configurationPath != null

     

       56
       56
       +
                        then cfg.configurationPath

     

       57
       57
       +
                        else "${pkgs.writeText "snmp-eporter-conf.yml" (builtins.toJSON cfg.configuration)}";

     

       58
       58
       +
           in {

     

       59
       59
       +
           serviceConfig = {

     

       60
       60
       +
             DynamicUser = true;

     

       61
       61
       +
             ExecStart = ''

     

       62
       62
       +
               ${pkgs.prometheus-snmp-exporter.bin}/bin/snmp_exporter \

     

       63
       63
       +
                 -config.file ${configFile} \

     

       64
       64
       +
                 -log.format ${cfg.logFormat} \

     

       65
       65
       +
                 -log.level ${cfg.logLevel} \

     

       66
       66
       +
                 -web.listen-address ${cfg.listenAddress}:${toString cfg.port} \

     

       67
       67
       +
                 ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       68
       68
       +
             '';

     

       69
       69
       +
           };

     

       70
       70
       +
         };

     

       71
       71
       +
       }

+67

nixos/modules/services/monitoring/prometheus/exporters/unifi.nix

···

       1
       1
       +
       { config, lib, pkgs }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cfg = config.services.prometheus.exporters.unifi;

     

       7
       7
       +
       in

     

       8
       8
       +
       {

     

       9
       9
       +
         port = 9130;

     

       10
       10
       +
         extraOpts = {

     

       11
       11
       +
           unifiAddress = mkOption {

     

       12
       12
       +
             type = types.str;

     

       13
       13
       +
             example = "https://10.0.0.1:8443";

     

       14
       14
       +
             description = ''

     

       15
       15
       +
               URL of the UniFi Controller API.

     

       16
       16
       +
             '';

     

       17
       17
       +
           };

     

       18
       18
       +
       

     

       19
       19
       +
           unifiInsecure = mkOption {

     

       20
       20
       +
             type = types.bool;

     

       21
       21
       +
             default = false;

     

       22
       22
       +
             description = ''

     

       23
       23
       +
               If enabled skip the verification of the TLS certificate of the UniFi Controller API.

     

       24
       24
       +
               Use with caution.

     

       25
       25
       +
             '';

     

       26
       26
       +
           };

     

       27
       27
       +
       

     

       28
       28
       +
           unifiUsername = mkOption {

     

       29
       29
       +
             type = types.str;

     

       30
       30
       +
             example = "ReadOnlyUser";

     

       31
       31
       +
             description = ''

     

       32
       32
       +
               username for authentication against UniFi Controller API.

     

       33
       33
       +
             '';

     

       34
       34
       +
           };

     

       35
       35
       +
       

     

       36
       36
       +
           unifiPassword = mkOption {

     

       37
       37
       +
             type = types.str;

     

       38
       38
       +
             description = ''

     

       39
       39
       +
               Password for authentication against UniFi Controller API.

     

       40
       40
       +
             '';

     

       41
       41
       +
           };

     

       42
       42
       +
       

     

       43
       43
       +
           unifiTimeout = mkOption {

     

       44
       44
       +
             type = types.str;

     

       45
       45
       +
             default = "5s";

     

       46
       46
       +
             example = "2m";

     

       47
       47
       +
             description = ''

     

       48
       48
       +
               Timeout including unit for UniFi Controller API requests.

     

       49
       49
       +
             '';

     

       50
       50
       +
           };

     

       51
       51
       +
         };

     

       52
       52
       +
         serviceOpts = {

     

       53
       53
       +
           serviceConfig = {

     

       54
       54
       +
             DynamicUser = true;

     

       55
       55
       +
             ExecStart = ''

     

       56
       56
       +
               ${pkgs.prometheus-unifi-exporter}/bin/unifi_exporter \

     

       57
       57
       +
                 -telemetry.addr ${cfg.listenAddress}:${toString cfg.port} \

     

       58
       58
       +
                 -unifi.addr ${cfg.unifiAddress} \

     

       59
       59
       +
                 -unifi.username ${cfg.unifiUsername} \

     

       60
       60
       +
                 -unifi.password ${cfg.unifiPassword} \

     

       61
       61
       +
                 -unifi.timeout ${cfg.unifiTimeout} \

     

       62
       62
       +
                 ${optionalString cfg.unifiInsecure "-unifi.insecure" } \

     

       63
       63
       +
                 ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       64
       64
       +
             '';

     

       65
       65
       +
           };

     

       66
       66
       +
         };

     

       67
       67
       +
       }

+21

nixos/modules/services/monitoring/prometheus/exporters/varnish.nix

···

       1
       1
       +
       { config, lib, pkgs }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       5
       5
       +
       let

     

       6
       6
       +
         cfg = config.services.prometheus.exporters.varnish;

     

       7
       7
       +
       in

     

       8
       8
       +
       {

     

       9
       9
       +
         port = 9131;

     

       10
       10
       +
         serviceOpts = {

     

       11
       11
       +
           path = [ pkgs.varnish ];

     

       12
       12
       +
           serviceConfig = {

     

       13
       13
       +
             DynamicUser = true;

     

       14
       14
       +
             ExecStart = ''

     

       15
       15
       +
               ${pkgs.prometheus-varnish-exporter}/bin/prometheus_varnish_exporter \

     

       16
       16
       +
                 -web.listen-address ${cfg.listenAddress}:${toString cfg.port} \

     

       17
       17
       +
                 ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       18
       18
       +
             '';

     

       19
       19
       +
           };

     

       20
       20
       +
         };

     

       21
       21
       +
       }

-76

nixos/modules/services/monitoring/prometheus/fritzbox-exporter.nix

···

       1
       1
       -
       { config, pkgs, lib, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       5
       -
       let

     

       6
       6
       -
         cfg = config.services.prometheus.fritzboxExporter;

     

       7
       7
       -
       in {

     

       8
       8
       -
         options = {

     

       9
       9
       -
           services.prometheus.fritzboxExporter = {

     

       10
       10
       -
             enable = mkEnableOption "prometheus fritzbox exporter";

     

       11
       11
       -
       

     

       12
       12
       -
             port = mkOption {

     

       13
       13
       -
               type = types.int;

     

       14
       14
       -
               default = 9133;

     

       15
       15
       -
               description = ''

     

       16
       16
       -
                 Port to listen on.

     

       17
       17
       -
               '';

     

       18
       18
       -
             };

     

       19
       19
       -
       

     

       20
       20
       -
             gatewayAddress = mkOption {

     

       21
       21
       -
               type = types.str;

     

       22
       22
       -
               default = "fritz.box";

     

       23
       23
       -
               description = ''

     

       24
       24
       -
                 The hostname or IP of the FRITZ!Box.

     

       25
       25
       -
               '';

     

       26
       26
       -
             };

     

       27
       27
       -
       

     

       28
       28
       -
             gatewayPort = mkOption {

     

       29
       29
       -
               type = types.int;

     

       30
       30
       -
               default = 49000;

     

       31
       31
       -
               description = ''

     

       32
       32
       -
                 The port of the FRITZ!Box UPnP service.

     

       33
       33
       -
               '';

     

       34
       34
       -
             };

     

       35
       35
       -
       

     

       36
       36
       -
             extraFlags = mkOption {

     

       37
       37
       -
               type = types.listOf types.str;

     

       38
       38
       -
               default = [];

     

       39
       39
       -
               description = ''

     

       40
       40
       -
                 Extra commandline options when launching the fritzbox exporter.

     

       41
       41
       -
               '';

     

       42
       42
       -
             };

     

       43
       43
       -
       

     

       44
       44
       -
             openFirewall = mkOption {

     

       45
       45
       -
               type = types.bool;

     

       46
       46
       -
               default = false;

     

       47
       47
       -
               description = ''

     

       48
       48
       -
                 Open port in firewall for incoming connections.

     

       49
       49
       -
               '';

     

       50
       50
       -
             };

     

       51
       51
       -
           };

     

       52
       52
       -
         };

     

       53
       53
       -
       

     

       54
       54
       -
         config = mkIf cfg.enable {

     

       55
       55
       -
           networking.firewall.allowedTCPPorts = optional cfg.openFirewall cfg.port;

     

       56
       56
       -
       

     

       57
       57
       -
           systemd.services.prometheus-fritzbox-exporter = {

     

       58
       58
       -
             description = "Prometheus exporter for FRITZ!Box via UPnP";

     

       59
       59
       -
             unitConfig.Documentation = "https://github.com/ndecker/fritzbox_exporter";

     

       60
       60
       -
             wantedBy = [ "multi-user.target" ];

     

       61
       61
       -
             serviceConfig = {

     

       62
       62
       -
               User = "nobody";

     

       63
       63
       -
               Restart = "always";

     

       64
       64
       -
               PrivateTmp = true;

     

       65
       65
       -
               WorkingDirectory = /tmp;

     

       66
       66
       -
               ExecStart = ''

     

       67
       67
       -
                 ${pkgs.prometheus-fritzbox-exporter}/bin/fritzbox_exporter \

     

       68
       68
       -
                   -listen-address :${toString cfg.port} \

     

       69
       69
       -
                   -gateway-address ${cfg.gatewayAddress} \

     

       70
       70
       -
                   -gateway-port ${toString cfg.gatewayPort} \

     

       71
       71
       -
                   ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       72
       72
       -
               '';

     

       73
       73
       -
             };

     

       74
       74
       -
           };

     

       75
       75
       -
         };

     

       76
       76
       -
       }

-74

nixos/modules/services/monitoring/prometheus/json-exporter.nix

···

       1
       1
       -
       { config, pkgs, lib, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       5
       -
       let

     

       6
       6
       -
         cfg = config.services.prometheus.jsonExporter;

     

       7
       7
       -
       in {

     

       8
       8
       -
         options = {

     

       9
       9
       -
           services.prometheus.jsonExporter = {

     

       10
       10
       -
             enable = mkEnableOption "prometheus JSON exporter";

     

       11
       11
       -
       

     

       12
       12
       -
             url = mkOption {

     

       13
       13
       -
               type = types.str;

     

       14
       14
       -
               description = ''

     

       15
       15
       -
                 URL to scrape JSON from.

     

       16
       16
       -
               '';

     

       17
       17
       -
             };

     

       18
       18
       -
       

     

       19
       19
       -
             configFile = mkOption {

     

       20
       20
       -
               type = types.path;

     

       21
       21
       -
               description = ''

     

       22
       22
       -
                 Path to configuration file.

     

       23
       23
       -
               '';

     

       24
       24
       -
             };

     

       25
       25
       -
       

     

       26
       26
       -
             port = mkOption {

     

       27
       27
       -
               type = types.int;

     

       28
       28
       -
               default = 7979;

     

       29
       29
       -
               description = ''

     

       30
       30
       -
                 Port to listen on.

     

       31
       31
       -
               '';

     

       32
       32
       -
             };

     

       33
       33
       -
       

     

       34
       34
       -
             extraFlags = mkOption {

     

       35
       35
       -
               type = types.listOf types.str;

     

       36
       36
       -
               default = [];

     

       37
       37
       -
               description = ''

     

       38
       38
       -
                 Extra commandline options when launching the JSON exporter.

     

       39
       39
       -
               '';

     

       40
       40
       -
             };

     

       41
       41
       -
       

     

       42
       42
       -
             openFirewall = mkOption {

     

       43
       43
       -
               type = types.bool;

     

       44
       44
       -
               default = false;

     

       45
       45
       -
               description = ''

     

       46
       46
       -
                 Open port in firewall for incoming connections.

     

       47
       47
       -
               '';

     

       48
       48
       -
             };

     

       49
       49
       -
           };

     

       50
       50
       -
         };

     

       51
       51
       -
       

     

       52
       52
       -
         config = mkIf cfg.enable {

     

       53
       53
       -
           networking.firewall.allowedTCPPorts = optional cfg.openFirewall cfg.port;

     

       54
       54
       -
       

     

       55
       55
       -
           systemd.services.prometheus-json-exporter = {

     

       56
       56
       -
             description = "Prometheus exporter for JSON over HTTP";

     

       57
       57
       -
             unitConfig.Documentation = "https://github.com/kawamuray/prometheus-json-exporter";

     

       58
       58
       -
             wantedBy = [ "multi-user.target" ];

     

       59
       59
       -
             serviceConfig = {

     

       60
       60
       -
               User = "nobody";

     

       61
       61
       -
               Restart = "always";

     

       62
       62
       -
               PrivateTmp = true;

     

       63
       63
       -
               WorkingDirectory = /tmp;

     

       64
       64
       -
               ExecStart = ''

     

       65
       65
       -
                 ${pkgs.prometheus-json-exporter}/bin/prometheus-json-exporter \

     

       66
       66
       -
                   --port ${toString cfg.port} \

     

       67
       67
       -
                   ${cfg.url} ${cfg.configFile} \

     

       68
       68
       -
                   ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       69
       69
       -
               '';

     

       70
       70
       -
               ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";

     

       71
       71
       -
             };

     

       72
       72
       -
           };

     

       73
       73
       -
         };

     

       74
       74
       -
       }

-117

nixos/modules/services/monitoring/prometheus/minio-exporter.nix

···

       1
       1
       -
       { config, pkgs, lib, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       5
       -
       let

     

       6
       6
       -
         cfg = config.services.prometheus.minioExporter;

     

       7
       7
       -
       in {

     

       8
       8
       -
         options = {

     

       9
       9
       -
           services.prometheus.minioExporter = {

     

       10
       10
       -
             enable = mkEnableOption "prometheus minio exporter";

     

       11
       11
       -
       

     

       12
       12
       -
             port = mkOption {

     

       13
       13
       -
               type = types.int;

     

       14
       14
       -
               default = 9290;

     

       15
       15
       -
               description = ''

     

       16
       16
       -
                 Port to listen on.

     

       17
       17
       -
               '';

     

       18
       18
       -
             };

     

       19
       19
       -
       

     

       20
       20
       -
             listenAddress = mkOption {

     

       21
       21
       -
               type = types.nullOr types.str;

     

       22
       22
       -
               default = null;

     

       23
       23
       -
               example = "0.0.0.0";

     

       24
       24
       -
               description = ''

     

       25
       25
       -
                 Address to listen on for web interface and telemetry.

     

       26
       26
       -
               '';

     

       27
       27
       -
             };

     

       28
       28
       -
       

     

       29
       29
       -
             minioAddress = mkOption {

     

       30
       30
       -
               type = types.str;

     

       31
       31
       -
               example = "https://10.0.0.1:9000";

     

       32
       32
       -
               default = if config.services.minio.enable then "http://localhost:9000" else null;

     

       33
       33
       -
               description = ''

     

       34
       34
       -
                 The URL of the minio server.

     

       35
       35
       -
                 Use HTTPS if Minio accepts secure connections only.

     

       36
       36
       -
                 By default this connects to the local minio server if enabled.

     

       37
       37
       -
               '';

     

       38
       38
       -
             };

     

       39
       39
       -
       

     

       40
       40
       -
             minioAccessKey = mkOption ({

     

       41
       41
       -
               type = types.str;

     

       42
       42
       -
               example = "BKIKJAA5BMMU2RHO6IBB";

     

       43
       43
       -
               description = ''

     

       44
       44
       -
                 The value of the Minio access key.

     

       45
       45
       -
                 It is required in order to connect to the server.

     

       46
       46
       -
                 By default this uses the one from the local minio server if enabled

     

       47
       47
       -
                 and <literal>config.services.minio.accessKey</literal>.

     

       48
       48
       -
               '';

     

       49
       49
       -
             } // optionalAttrs (config.services.minio.enable && config.services.minio.accessKey != "") {

     

       50
       50
       -
               default = config.services.minio.accessKey;

     

       51
       51
       -
             });

     

       52
       52
       -
       

     

       53
       53
       -
             minioAccessSecret = mkOption ({

     

       54
       54
       -
               type = types.str;

     

       55
       55
       -
               description = ''

     

       56
       56
       -
                 The calue of the Minio access secret.

     

       57
       57
       -
                 It is required in order to connect to the server.

     

       58
       58
       -
                 By default this uses the one from the local minio server if enabled

     

       59
       59
       -
                 and <literal>config.services.minio.secretKey</literal>.

     

       60
       60
       -
               '';

     

       61
       61
       -
             } // optionalAttrs (config.services.minio.enable && config.services.minio.secretKey != "") {

     

       62
       62
       -
               default = config.services.minio.secretKey;

     

       63
       63
       -
             });

     

       64
       64
       -
       

     

       65
       65
       -
             minioBucketStats = mkOption {

     

       66
       66
       -
               type = types.bool;

     

       67
       67
       -
               default = false;

     

       68
       68
       -
               description = ''

     

       69
       69
       -
                 Collect statistics about the buckets and files in buckets.

     

       70
       70
       -
                 It requires more computation, use it carefully in case of large buckets..

     

       71
       71
       -
               '';

     

       72
       72
       -
             };

     

       73
       73
       -
       

     

       74
       74
       -
             extraFlags = mkOption {

     

       75
       75
       -
               type = types.listOf types.str;

     

       76
       76
       -
               default = [];

     

       77
       77
       -
               description = ''

     

       78
       78
       -
                 Extra commandline options when launching the minio exporter.

     

       79
       79
       -
               '';

     

       80
       80
       -
             };

     

       81
       81
       -
       

     

       82
       82
       -
             openFirewall = mkOption {

     

       83
       83
       -
               type = types.bool;

     

       84
       84
       -
               default = false;

     

       85
       85
       -
               description = ''

     

       86
       86
       -
                 Open port in firewall for incoming connections.

     

       87
       87
       -
               '';

     

       88
       88
       -
             };

     

       89
       89
       -
           };

     

       90
       90
       -
         };

     

       91
       91
       -
       

     

       92
       92
       -
         config = mkIf cfg.enable {

     

       93
       93
       -
           networking.firewall.allowedTCPPorts = optional cfg.openFirewall cfg.port;

     

       94
       94
       -
       

     

       95
       95
       -
           systemd.services.prometheus-minio-exporter = {

     

       96
       96
       -
             description = "Prometheus exporter for Minio server metrics";

     

       97
       97
       -
             unitConfig.Documentation = "https://github.com/joe-pll/minio-exporter";

     

       98
       98
       -
             wantedBy = [ "multi-user.target" ];

     

       99
       99
       -
             after = optional config.services.minio.enable "minio.service";

     

       100
       100
       -
             serviceConfig = {

     

       101
       101
       -
               DynamicUser = true;

     

       102
       102
       -
               Restart = "always";

     

       103
       103
       -
               PrivateTmp = true;

     

       104
       104
       -
               WorkingDirectory = /tmp;

     

       105
       105
       -
               ExecStart = ''

     

       106
       106
       -
                 ${pkgs.prometheus-minio-exporter}/bin/minio-exporter \

     

       107
       107
       -
                   -web.listen-address ${optionalString (cfg.listenAddress != null) cfg.listenAddress}:${toString cfg.port} \

     

       108
       108
       -
                   -minio.server ${cfg.minioAddress} \

     

       109
       109
       -
                   -minio.access-key ${cfg.minioAccessKey} \

     

       110
       110
       -
                   -minio.access-secret ${cfg.minioAccessSecret} \

     

       111
       111
       -
                   ${optionalString cfg.minioBucketStats "-minio.bucket-stats"} \

     

       112
       112
       -
                   ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       113
       113
       -
               '';

     

       114
       114
       -
             };

     

       115
       115
       -
           };

     

       116
       116
       -
         };

     

       117
       117
       -
       }

-78

nixos/modules/services/monitoring/prometheus/nginx-exporter.nix

···

       1
       1
       -
       { config, pkgs, lib, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       5
       -
       let

     

       6
       6
       -
         cfg = config.services.prometheus.nginxExporter;

     

       7
       7
       -
       in {

     

       8
       8
       -
         options = {

     

       9
       9
       -
           services.prometheus.nginxExporter = {

     

       10
       10
       -
             enable = mkEnableOption "prometheus nginx exporter";

     

       11
       11
       -
       

     

       12
       12
       -
             port = mkOption {

     

       13
       13
       -
               type = types.int;

     

       14
       14
       -
               default = 9113;

     

       15
       15
       -
               description = ''

     

       16
       16
       -
                 Port to listen on.

     

       17
       17
       -
               '';

     

       18
       18
       -
             };

     

       19
       19
       -
       

     

       20
       20
       -
             listenAddress = mkOption {

     

       21
       21
       -
               type = types.string;

     

       22
       22
       -
               default = "0.0.0.0";

     

       23
       23
       -
               description = ''

     

       24
       24
       -
                 Address to listen on.

     

       25
       25
       -
               '';

     

       26
       26
       -
             };

     

       27
       27
       -
       

     

       28
       28
       -
             scrapeUri = mkOption {

     

       29
       29
       -
               type = types.string;

     

       30
       30
       -
               default = "http://localhost/nginx_status";

     

       31
       31
       -
               description = ''

     

       32
       32
       -
                 Address to access the nginx status page.

     

       33
       33
       -
                 Can be enabled with services.nginx.statusPage = true.

     

       34
       34
       -
               '';

     

       35
       35
       -
             };

     

       36
       36
       -
       

     

       37
       37
       -
             extraFlags = mkOption {

     

       38
       38
       -
               type = types.listOf types.str;

     

       39
       39
       -
               default = [];

     

       40
       40
       -
               description = ''

     

       41
       41
       -
                 Extra commandline options when launching the nginx exporter.

     

       42
       42
       -
               '';

     

       43
       43
       -
             };

     

       44
       44
       -
       

     

       45
       45
       -
             openFirewall = mkOption {

     

       46
       46
       -
               type = types.bool;

     

       47
       47
       -
               default = false;

     

       48
       48
       -
               description = ''

     

       49
       49
       -
                 Open port in firewall for incoming connections.

     

       50
       50
       -
               '';

     

       51
       51
       -
             };

     

       52
       52
       -
           };

     

       53
       53
       -
         };

     

       54
       54
       -
       

     

       55
       55
       -
         config = mkIf cfg.enable {

     

       56
       56
       -
           networking.firewall.allowedTCPPorts = optional cfg.openFirewall cfg.port;

     

       57
       57
       -
       

     

       58
       58
       -
           systemd.services.prometheus-nginx-exporter = {

     

       59
       59
       -
             after = [ "network.target" "nginx.service" ];

     

       60
       60
       -
             description = "Prometheus exporter for nginx metrics";

     

       61
       61
       -
             unitConfig.Documentation = "https://github.com/discordianfish/nginx_exporter";

     

       62
       62
       -
             wantedBy = [ "multi-user.target" ];

     

       63
       63
       -
             serviceConfig = {

     

       64
       64
       -
               User = "nobody";

     

       65
       65
       -
               Restart  = "always";

     

       66
       66
       -
               PrivateTmp = true;

     

       67
       67
       -
               WorkingDirectory = /tmp;

     

       68
       68
       -
               ExecStart = ''

     

       69
       69
       -
                 ${pkgs.prometheus-nginx-exporter}/bin/nginx_exporter \

     

       70
       70
       -
                   -nginx.scrape_uri '${cfg.scrapeUri}' \

     

       71
       71
       -
                   -telemetry.address ${cfg.listenAddress}:${toString cfg.port} \

     

       72
       72
       -
                   ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       73
       73
       -
               '';

     

       74
       74
       -
               ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";

     

       75
       75
       -
             };

     

       76
       76
       -
           };

     

       77
       77
       -
         };

     

       78
       78
       -
       }

-87

nixos/modules/services/monitoring/prometheus/node-exporter.nix

···

       1
       1
       -
       { config, pkgs, lib, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       5
       -
       let

     

       6
       6
       -
         cfg = config.services.prometheus.nodeExporter;

     

       7
       7
       -
       in {

     

       8
       8
       -
         options = {

     

       9
       9
       -
           services.prometheus.nodeExporter = {

     

       10
       10
       -
             enable = mkEnableOption "prometheus node exporter";

     

       11
       11
       -
       

     

       12
       12
       -
             port = mkOption {

     

       13
       13
       -
               type = types.int;

     

       14
       14
       -
               default = 9100;

     

       15
       15
       -
               description = ''

     

       16
       16
       -
                 Port to listen on.

     

       17
       17
       -
               '';

     

       18
       18
       -
             };

     

       19
       19
       -
       

     

       20
       20
       -
             listenAddress = mkOption {

     

       21
       21
       -
               type = types.string;

     

       22
       22
       -
               default = "0.0.0.0";

     

       23
       23
       -
               description = ''

     

       24
       24
       -
                 Address to listen on.

     

       25
       25
       -
               '';

     

       26
       26
       -
             };

     

       27
       27
       -
       

     

       28
       28
       -
             enabledCollectors = mkOption {

     

       29
       29
       -
               type = types.listOf types.string;

     

       30
       30
       -
               default = [];

     

       31
       31
       -
               example = ''[ "systemd" ]'';

     

       32
       32
       -
               description = ''

     

       33
       33
       -
                 Collectors to enable. The collectors listed here are enabled in addition to the default ones.

     

       34
       34
       -
               '';

     

       35
       35
       -
             };

     

       36
       36
       -
       

     

       37
       37
       -
             disabledCollectors = mkOption {

     

       38
       38
       -
               type = types.listOf types.str;

     

       39
       39
       -
               default = [];

     

       40
       40
       -
               example = ''[ "timex" ]'';

     

       41
       41
       -
               description = ''

     

       42
       42
       -
                 Collectors to disable which are enabled by default.

     

       43
       43
       -
               '';

     

       44
       44
       -
             };

     

       45
       45
       -
       

     

       46
       46
       -
             extraFlags = mkOption {

     

       47
       47
       -
               type = types.listOf types.str;

     

       48
       48
       -
               default = [];

     

       49
       49
       -
               description = ''

     

       50
       50
       -
                 Extra commandline options when launching the node exporter.

     

       51
       51
       -
               '';

     

       52
       52
       -
             };

     

       53
       53
       -
       

     

       54
       54
       -
             openFirewall = mkOption {

     

       55
       55
       -
               type = types.bool;

     

       56
       56
       -
               default = false;

     

       57
       57
       -
               description = ''

     

       58
       58
       -
                 Open port in firewall for incoming connections.

     

       59
       59
       -
               '';

     

       60
       60
       -
             };

     

       61
       61
       -
           };

     

       62
       62
       -
         };

     

       63
       63
       -
       

     

       64
       64
       -
         config = mkIf cfg.enable {

     

       65
       65
       -
           networking.firewall.allowedTCPPorts = optional cfg.openFirewall cfg.port;

     

       66
       66
       -
       

     

       67
       67
       -
           systemd.services.prometheus-node-exporter = {

     

       68
       68
       -
             description = "Prometheus exporter for machine metrics";

     

       69
       69
       -
             unitConfig.Documentation = "https://github.com/prometheus/node_exporter";

     

       70
       70
       -
             wantedBy = [ "multi-user.target" ];

     

       71
       71
       -
             script = ''

     

       72
       72
       -
               exec ${pkgs.prometheus-node-exporter}/bin/node_exporter \

     

       73
       73
       -
                 ${concatMapStringsSep " " (x: "--collector." + x) cfg.enabledCollectors} \

     

       74
       74
       -
                 ${concatMapStringsSep " " (x: "--no-collector." + x) cfg.disabledCollectors} \

     

       75
       75
       -
                 --web.listen-address ${cfg.listenAddress}:${toString cfg.port} \

     

       76
       76
       -
                 ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       77
       77
       -
             '';

     

       78
       78
       -
             serviceConfig = {

     

       79
       79
       -
               User = "nobody";

     

       80
       80
       -
               Restart = "always";

     

       81
       81
       -
               PrivateTmp = true;

     

       82
       82
       -
               WorkingDirectory = /tmp;

     

       83
       83
       -
               ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";

     

       84
       84
       -
             };

     

       85
       85
       -
           };

     

       86
       86
       -
         };

     

       87
       87
       -
       }

-127

nixos/modules/services/monitoring/prometheus/snmp-exporter.nix

···

       1
       1
       -
       { config, pkgs, lib, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       5
       -
       let

     

       6
       6
       -
         cfg = config.services.prometheus.snmpExporter;

     

       7
       7
       -
         mkConfigFile = pkgs.writeText "snmp.yml" (if cfg.configurationPath == null then builtins.toJSON cfg.configuration else builtins.readFile cfg.configurationPath);

     

       8
       8
       -
       in {

     

       9
       9
       -
         options = {

     

       10
       10
       -
           services.prometheus.snmpExporter = {

     

       11
       11
       -
             enable = mkEnableOption "Prometheus snmp exporter";

     

       12
       12
       -
       

     

       13
       13
       -
             user = mkOption {

     

       14
       14
       -
               type = types.str;

     

       15
       15
       -
               default = "nobody";

     

       16
       16
       -
               description = ''

     

       17
       17
       -
                 User name under which snmp exporter shall be run.

     

       18
       18
       -
               '';

     

       19
       19
       -
             };

     

       20
       20
       -
       

     

       21
       21
       -
             group = mkOption {

     

       22
       22
       -
               type = types.str;

     

       23
       23
       -
               default = "nogroup";

     

       24
       24
       -
               description = ''

     

       25
       25
       -
                 Group under which snmp exporter shall be run.

     

       26
       26
       -
               '';

     

       27
       27
       -
             };

     

       28
       28
       -
       

     

       29
       29
       -
             port = mkOption {

     

       30
       30
       -
               type = types.int;

     

       31
       31
       -
               default = 9116;

     

       32
       32
       -
               description = ''

     

       33
       33
       -
                 Port to listen on.

     

       34
       34
       -
               '';

     

       35
       35
       -
             };

     

       36
       36
       -
       

     

       37
       37
       -
             listenAddress = mkOption {

     

       38
       38
       -
               type = types.nullOr types.str;

     

       39
       39
       -
               default = null;

     

       40
       40
       -
               description = ''

     

       41
       41
       -
                 Address to listen on for web interface and telemetry.

     

       42
       42
       -
               '';

     

       43
       43
       -
             };

     

       44
       44
       -
       

     

       45
       45
       -
             configurationPath = mkOption {

     

       46
       46
       -
               type = types.nullOr types.path;

     

       47
       47
       -
               default = null;

     

       48
       48
       -
               description = ''

     

       49
       49
       -
                 Path to a snmp exporter configuration file. Mutually exclusive with 'configuration' option.

     

       50
       50
       -
               '';

     

       51
       51
       -
               example = "./snmp.yml";

     

       52
       52
       -
             };

     

       53
       53
       -
       

     

       54
       54
       -
             configuration = mkOption {

     

       55
       55
       -
               type = types.nullOr types.attrs;

     

       56
       56
       -
               default = {};

     

       57
       57
       -
               description = ''

     

       58
       58
       -
                 Snmp exporter configuration as nix attribute set. Mutually exclusive with 'configurationPath' option.

     

       59
       59
       -
               '';

     

       60
       60
       -
               example = ''

     

       61
       61
       -
                 {

     

       62
       62
       -
                   "default" = {

     

       63
       63
       -
                     "version" = 2;

     

       64
       64
       -
                     "auth" = {

     

       65
       65
       -
                       "community" = "public";

     

       66
       66
       -
                     };

     

       67
       67
       -
                   };

     

       68
       68
       -
                 };

     

       69
       69
       -
               '';

     

       70
       70
       -
             };

     

       71
       71
       -
       

     

       72
       72
       -
             logFormat = mkOption {

     

       73
       73
       -
               type = types.str;

     

       74
       74
       -
               default = "logger:stderr";

     

       75
       75
       -
               description = ''

     

       76
       76
       -
                 Set the log target and format.

     

       77
       77
       -
               '';

     

       78
       78
       -
             };

     

       79
       79
       -
       

     

       80
       80
       -
             logLevel = mkOption {

     

       81
       81
       -
               type = types.enum ["debug" "info" "warn" "error" "fatal"];

     

       82
       82
       -
               default = "info";

     

       83
       83
       -
               description = ''

     

       84
       84
       -
                 Only log messages with the given severity or above.

     

       85
       85
       -
               '';

     

       86
       86
       -
             };

     

       87
       87
       -
       

     

       88
       88
       -
             openFirewall = mkOption {

     

       89
       89
       -
               type = types.bool;

     

       90
       90
       -
               default = false;

     

       91
       91
       -
               description = ''

     

       92
       92
       -
                 Open port in firewall for incoming connections.

     

       93
       93
       -
               '';

     

       94
       94
       -
             };

     

       95
       95
       -
           };

     

       96
       96
       -
         };

     

       97
       97
       -
       

     

       98
       98
       -
         config = mkIf cfg.enable {

     

       99
       99
       -
           networking.firewall.allowedTCPPorts = optional cfg.openFirewall cfg.port;

     

       100
       100
       -
       

     

       101
       101
       -
           assertions = singleton

     

       102
       102
       -
             {

     

       103
       103
       -
               assertion = (cfg.configurationPath == null) != (cfg.configuration == null);

     

       104
       104
       -
               message = "Please ensure you have either 'configuration' or 'configurationPath' set!";

     

       105
       105
       -
             };

     

       106
       106
       -
       

     

       107
       107
       -
           systemd.services.prometheus-snmp-exporter = {

     

       108
       108
       -
             wantedBy = [ "multi-user.target" ];

     

       109
       109
       -
             after = [ "network.target" ];

     

       110
       110
       -
             script = ''

     

       111
       111
       -
               ${pkgs.prometheus-snmp-exporter.bin}/bin/snmp_exporter \

     

       112
       112
       -
                 -config.file ${mkConfigFile} \

     

       113
       113
       -
                 -log.format ${cfg.logFormat} \

     

       114
       114
       -
                 -log.level ${cfg.logLevel} \

     

       115
       115
       -
                 -web.listen-address ${optionalString (cfg.listenAddress != null) cfg.listenAddress}:${toString cfg.port}

     

       116
       116
       -
             '';

     

       117
       117
       -
       

     

       118
       118
       -
             serviceConfig = {

     

       119
       119
       -
               User = cfg.user;

     

       120
       120
       -
               Group = cfg.group;

     

       121
       121
       -
               Restart  = "always";

     

       122
       122
       -
               PrivateTmp = true;

     

       123
       123
       -
               WorkingDirectory = "/tmp";

     

       124
       124
       -
             };

     

       125
       125
       -
           };

     

       126
       126
       -
         };

     

       127
       127
       -
       }

-105

nixos/modules/services/monitoring/prometheus/unifi-exporter.nix

···

       1
       1
       -
       { config, pkgs, lib, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       with lib;

     

       4
       4
       -
       

     

       5
       5
       -
       let

     

       6
       6
       -
         cfg = config.services.prometheus.unifiExporter;

     

       7
       7
       -
       in {

     

       8
       8
       -
         options = {

     

       9
       9
       -
           services.prometheus.unifiExporter = {

     

       10
       10
       -
             enable = mkEnableOption "prometheus unifi exporter";

     

       11
       11
       -
       

     

       12
       12
       -
             port = mkOption {

     

       13
       13
       -
               type = types.int;

     

       14
       14
       -
               default = 9130;

     

       15
       15
       -
               description = ''

     

       16
       16
       -
                 Port to listen on.

     

       17
       17
       -
               '';

     

       18
       18
       -
             };

     

       19
       19
       -
       

     

       20
       20
       -
             unifiAddress = mkOption {

     

       21
       21
       -
               type = types.str;

     

       22
       22
       -
               example = "https://10.0.0.1:8443";

     

       23
       23
       -
               description = ''

     

       24
       24
       -
                 URL of the UniFi Controller API.

     

       25
       25
       -
               '';

     

       26
       26
       -
             };

     

       27
       27
       -
       

     

       28
       28
       -
             unifiInsecure = mkOption {

     

       29
       29
       -
               type = types.bool;

     

       30
       30
       -
               default = false;

     

       31
       31
       -
               description = ''

     

       32
       32
       -
                 If enabled skip the verification of the TLS certificate of the UniFi Controller API.

     

       33
       33
       -
                 Use with caution.

     

       34
       34
       -
               '';

     

       35
       35
       -
             };

     

       36
       36
       -
             

     

       37
       37
       -
             unifiUsername = mkOption {

     

       38
       38
       -
               type = types.str;

     

       39
       39
       -
               example = "ReadOnlyUser";

     

       40
       40
       -
               description = ''

     

       41
       41
       -
                 username for authentication against UniFi Controller API.

     

       42
       42
       -
               '';

     

       43
       43
       -
             };

     

       44
       44
       -
             

     

       45
       45
       -
             unifiPassword = mkOption {

     

       46
       46
       -
               type = types.str;

     

       47
       47
       -
               description = ''

     

       48
       48
       -
                 Password for authentication against UniFi Controller API.

     

       49
       49
       -
               '';

     

       50
       50
       -
             };

     

       51
       51
       -
             

     

       52
       52
       -
             unifiTimeout = mkOption {

     

       53
       53
       -
               type = types.str;

     

       54
       54
       -
               default = "5s";

     

       55
       55
       -
               example = "2m";

     

       56
       56
       -
               description = ''

     

       57
       57
       -
                 Timeout including unit for UniFi Controller API requests.

     

       58
       58
       -
               '';

     

       59
       59
       -
             };

     

       60
       60
       -
       

     

       61
       61
       -
             extraFlags = mkOption {

     

       62
       62
       -
               type = types.listOf types.str;

     

       63
       63
       -
               default = [];

     

       64
       64
       -
               description = ''

     

       65
       65
       -
                 Extra commandline options when launching the unifi exporter.

     

       66
       66
       -
               '';

     

       67
       67
       -
             };

     

       68
       68
       -
       

     

       69
       69
       -
             openFirewall = mkOption {

     

       70
       70
       -
               type = types.bool;

     

       71
       71
       -
               default = false;

     

       72
       72
       -
               description = ''

     

       73
       73
       -
                 Open port in firewall for incoming connections.

     

       74
       74
       -
               '';

     

       75
       75
       -
             };

     

       76
       76
       -
           };

     

       77
       77
       -
         };

     

       78
       78
       -
       

     

       79
       79
       -
         config = mkIf cfg.enable {

     

       80
       80
       -
           networking.firewall.allowedTCPPorts = optional cfg.openFirewall cfg.port;

     

       81
       81
       -
       

     

       82
       82
       -
           systemd.services.prometheus-unifi-exporter = {

     

       83
       83
       -
             description = "Prometheus exporter for UniFi Controller metrics";

     

       84
       84
       -
             unitConfig.Documentation = "https://github.com/mdlayher/unifi_exporter";

     

       85
       85
       -
             wantedBy = [ "multi-user.target" ];

     

       86
       86
       -
             after = optional config.services.unifi.enable "unifi.service";

     

       87
       87
       -
             serviceConfig = {

     

       88
       88
       -
               User = "nobody";

     

       89
       89
       -
               Restart = "always";

     

       90
       90
       -
               PrivateTmp = true;

     

       91
       91
       -
               WorkingDirectory = /tmp;

     

       92
       92
       -
               ExecStart = ''

     

       93
       93
       -
                 ${pkgs.prometheus-unifi-exporter}/bin/unifi_exporter \

     

       94
       94
       -
                   -telemetry.addr :${toString cfg.port} \

     

       95
       95
       -
                   -unifi.addr ${cfg.unifiAddress} \

     

       96
       96
       -
                   -unifi.username ${cfg.unifiUsername} \

     

       97
       97
       -
                   -unifi.password ${cfg.unifiPassword} \

     

       98
       98
       -
                   -unifi.timeout ${cfg.unifiTimeout} \

     

       99
       99
       -
                   ${optionalString cfg.unifiInsecure "-unifi.insecure" } \

     

       100
       100
       -
                   ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       101
       101
       -
               '';

     

       102
       102
       -
             };

     

       103
       103
       -
           };

     

       104
       104
       -
         };

     

       105
       105
       -
       }

-61

nixos/modules/services/monitoring/prometheus/varnish-exporter.nix

···

       1
       1
       -
       { config, pkgs, lib, ... }:

     

       2
       2
       -
       

     

       3
       3
       -
       # Shamelessly cribbed from nginx-exporter.nix. ~ C.

     

       4
       4
       -
       with lib;

     

       5
       5
       -
       

     

       6
       6
       -
       let

     

       7
       7
       -
         cfg = config.services.prometheus.varnishExporter;

     

       8
       8
       -
       in {

     

       9
       9
       -
         options = {

     

       10
       10
       -
           services.prometheus.varnishExporter = {

     

       11
       11
       -
             enable = mkEnableOption "prometheus Varnish exporter";

     

       12
       12
       -
       

     

       13
       13
       -
             port = mkOption {

     

       14
       14
       -
               type = types.int;

     

       15
       15
       -
               default = 9131;

     

       16
       16
       -
               description = ''

     

       17
       17
       -
                 Port to listen on.

     

       18
       18
       -
               '';

     

       19
       19
       -
             };

     

       20
       20
       -
       

     

       21
       21
       -
             extraFlags = mkOption {

     

       22
       22
       -
               type = types.listOf types.str;

     

       23
       23
       -
               default = [];

     

       24
       24
       -
               description = ''

     

       25
       25
       -
                 Extra commandline options when launching the Varnish exporter.

     

       26
       26
       -
               '';

     

       27
       27
       -
             };

     

       28
       28
       -
       

     

       29
       29
       -
             openFirewall = mkOption {

     

       30
       30
       -
               type = types.bool;

     

       31
       31
       -
               default = false;

     

       32
       32
       -
               description = ''

     

       33
       33
       -
                 Open port in firewall for incoming connections.

     

       34
       34
       -
               '';

     

       35
       35
       -
             };

     

       36
       36
       -
           };

     

       37
       37
       -
         };

     

       38
       38
       -
       

     

       39
       39
       -
         config = mkIf cfg.enable {

     

       40
       40
       -
           networking.firewall.allowedTCPPorts = optional cfg.openFirewall cfg.port;

     

       41
       41
       -
       

     

       42
       42
       -
           systemd.services.prometheus-varnish-exporter = {

     

       43
       43
       -
             description = "Prometheus exporter for Varnish metrics";

     

       44
       44
       -
             unitConfig.Documentation = "https://github.com/jonnenauha/prometheus_varnish_exporter";

     

       45
       45
       -
             wantedBy = [ "multi-user.target" ];

     

       46
       46
       -
             path = [ pkgs.varnish ];

     

       47
       47
       -
             script = ''

     

       48
       48
       -
               exec ${pkgs.prometheus-varnish-exporter}/bin/prometheus_varnish_exporter \

     

       49
       49
       -
                 -web.listen-address :${toString cfg.port} \

     

       50
       50
       -
                 ${concatStringsSep " \\\n  " cfg.extraFlags}

     

       51
       51
       -
             '';

     

       52
       52
       -
             serviceConfig = {

     

       53
       53
       -
               User = "nobody";

     

       54
       54
       -
               Restart = "always";

     

       55
       55
       -
               PrivateTmp = true;

     

       56
       56
       -
               WorkingDirectory = /tmp;

     

       57
       57
       -
               ExecReload = "${pkgs.coreutils}/bin/kill -HUP $MAINPID";

     

       58
       58
       -
             };

     

       59
       59
       -
           };

     

       60
       60
       -
         };

     

       61
       61
       -
       }