modules/loki.nix


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

{
  config,
  lib,
  libNginx,
  this,
  ...
}:
with lib;
let
  cfg = config.nixfiles.modules.loki;
in
{
  options.nixfiles.modules.loki = {
    enable = mkEnableOption "Loki";

    port = mkOption {
      description = "Port.";
      type = with types; port;
      default = 30171;
    };

    domain = mkOption {
      description = "Domain name sans protocol scheme.";
      type = with types; str;
      default = "loki.${config.networking.domain}";
    };
  };

  config = mkIf cfg.enable {
    ark.directories = [ config.services.loki.configuration.common.path_prefix ];

    nixfiles.modules.nginx = with cfg; {
      enable = true;
      upstreams.loki.servers."127.0.0.1:${toString cfg.port}" = { };
      virtualHosts.${domain} = {
        locations."/".proxyPass = "http://loki";
        extraConfig = libNginx.config.internalOnly;
      };
    };

    services.loki = {
      enable = true;

      configuration = rec {
        auth_enabled = false;

        server = {
          http_listen_address = "127.0.0.1";
          http_listen_port = cfg.port;

          grpc_listen_address = "127.0.0.1";
          grpc_listen_port = server.http_listen_port + 1;

          log_level = "warn";
        };

        common = {
          path_prefix = config.services.loki.dataDir;
          storage.filesystem = {
            chunks_directory = "${common.path_prefix}/chunks";
            rules_directory = "${common.path_prefix}/rules";
          };
          replication_factor = 1;
          ring = {
            instance_addr = "127.0.0.1";
            kvstore.store = "inmemory";
          };
        };

        ingester = {
          chunk_idle_period = "15m";
          max_chunk_age = "15m";
        };

        compactor = {
          working_directory = "${common.path_prefix}/compactor";
          retention_enabled = true;
          retention_delete_delay = "1h";
          retention_delete_worker_count = 64;
        };

        ruler = {
          enable_api = true;
          storage = {
            type = "local";
            local.directory = common.storage.filesystem.rules_directory;
          };
        };

        limits_config = {
          max_streams_per_user = 0;
          max_global_streams_per_user = 0;
          max_query_series = 4096;
          retention_period = "720h";
          deletion_mode = "filter-and-delete";
        };

        schema_config.configs = [
          {
            from = "2024-01-01";
            store = "tsdb";
            object_store = "filesystem";
            schema = "v12";
            index = {
              prefix = "index_";
              period = "24h";
            };
            chunks = {
              prefix = "chunks_";
              period = "24h";
            };
          }
        ];

        analytics.reporting_enabled = false;
      };
    };

    systemd.tmpfiles.rules = with config.services.loki.configuration.common; [
      "d ${path_prefix} 0700 loki loki - -"
      "d ${storage.filesystem.chunks_directory} 0700 loki loki - -"
      "d ${storage.filesystem.rules_directory} 0700 loki loki - -"
    ];

    topology = with cfg; {
      nodes.${this.hostname}.services.loki = {
        info = domain;
      };
    };
  };
}