commit f94da9b737e4a4394fd45643b21bd8e70b0e1ae0 · seiso.moe/alky

.env

···

       1
       +
       GOOSE_DRIVER="clickhouse"

     

       2
       +
       GOOSE_MIGRATION_DIR="./migrations/"

     

       3
       +
       GOOSE_DBSTRING="clickhouse://default:clickhouse@localhost:9000/default?dial_timeout=10s&compress=true"

+17

Justfile

···

       1
       +
       init:

     

       2
       +
         goose status

     

       3
       +
       

     

       4
       +
       format:

     

       5
       +
         go fmt ./...

     

       6
       +
         fd .go . | xargs gofumpt -l -w

     

       7
       +
         go mod tidy

     

       8
       +
       

     

       9
       +
       version:

     

       10
       +
         #!/usr/bin/env sh

     

       11
       +
         VERSION=$(git describe --tags 2>/dev/null || git rev-parse --short HEAD)

     

       12
       +
         echo "$VERSION"

     

       13
       +
       

     

       14
       +
       build: format

     

       15
       +
         #!/usr/bin/env sh

     

       16
       +
         VERSION=$(just version)

     

       17
       +
         go build -ldflags "-X code.kiri.systems/kiri/alky/pkg/metrics.version=$VERSION" .

+25

docker-compose.yml

···

       1
       +
       services:

     

       2
       +
         clickhouse:

     

       3
       +
           image: clickhouse/clickhouse-server:latest

     

       4
       +
           container_name: clickhouse

     

       5
       +
           network_mode: host

     

       6
       +
           environment:

     

       7
       +
             - CLICKHOUSE_DB=default

     

       8
       +
             - CLICKHOUSE_USER=default

     

       9
       +
             - CLICKHOUSE_DEFAULT_ACCESS_MANAGEMENT=1

     

       10
       +
             - CLICKHOUSE_PASSWORD=clickhouse

     

       11
       +
           ports:

     

       12
       +
             - "8123:8123"

     

       13
       +
             - "9000:9000"

     

       14
       +
             - "9009:9009"

     

       15
       +
           ulimits:

     

       16
       +
             nofile:

     

       17
       +
               soft: 262144

     

       18
       +
               hard: 262144

     

       19
       +
           healthcheck:

     

       20
       +
             test: wget --no-verbose --tries=1 --spider http://localhost:8123/ping || exit 1

     

       21
       +
             interval: 30s

     

       22
       +
             timeout: 5s

     

       23
       +
             retries: 3

     

       24
       +
             start_period: 30s

     

       25
       +
           restart: unless-stopped

+14

docs/alky.toml

···

       33
        
       # Type: Integer

     

       34
        
       expiration_time = 300

     

       35
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       36
        
       [advanced]

     

       37
        
       # Timeout (in milliseconds) for outgoing queries before being cancelled.

     

       38
        
       query_timeout = 100

···

       33
        
       # Type: Integer

     

       34
        
       expiration_time = 300

     

       35
        
       

     

       36
       +
       [metrics]

     

       37
       +
       # ClickHouse connection string

     

       38
       +
       dsn = "clickhouse://default:clickhouse@localhost:9000/default"

     

       39
       +
       

     

       40
       +
       # Number of metricsto buffer before sending to ClickHouse

     

       41
       +
       batch_size = 1000

     

       42
       +
       

     

       43
       +
       # How often to flush metrics to ClickHouse

     

       44
       +
       flush_interval = "10s"

     

       45
       +
       

     

       46
       +
       # How long to retain metrics data

     

       47
       +
       # This uses time.ParseDuration semantics

     

       48
       +
       retention_period = "720h"

     

       49
       +
       

     

       50
        
       [advanced]

     

       51
        
       # Timeout (in milliseconds) for outgoing queries before being cancelled.

     

       52
        
       query_timeout = 100

+20 -1

go.mod

···

       3
        
       go 1.22.5

     

       4
        
       

     

       5
        
       require (

     

       6
       -
       	code.kiri.systems/kiri/magna v0.0.0-20240922043826-2c2a1c508469

     

       7
        
       	github.com/BurntSushi/toml v1.4.0

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       8
        
       )

···

       3
        
       go 1.22.5

     

       4
        
       

     

       5
        
       require (

     

       6
       +
       	code.kiri.systems/kiri/magna v0.0.0-20250211050847-abb0522bcd30

     

       7
        
       	github.com/BurntSushi/toml v1.4.0

     

       8
       +
       	github.com/ClickHouse/clickhouse-go/v2 v2.31.0

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       require (

     

       12
       +
       	github.com/ClickHouse/ch-go v0.64.1 // indirect

     

       13
       +
       	github.com/andybalholm/brotli v1.1.1 // indirect

     

       14
       +
       	github.com/go-faster/city v1.0.1 // indirect

     

       15
       +
       	github.com/go-faster/errors v0.7.1 // indirect

     

       16
       +
       	github.com/google/uuid v1.6.0 // indirect

     

       17
       +
       	github.com/klauspost/compress v1.17.11 // indirect

     

       18
       +
       	github.com/paulmach/orb v0.11.1 // indirect

     

       19
       +
       	github.com/pierrec/lz4/v4 v4.1.22 // indirect

     

       20
       +
       	github.com/pkg/errors v0.9.1 // indirect

     

       21
       +
       	github.com/segmentio/asm v1.2.0 // indirect

     

       22
       +
       	github.com/shopspring/decimal v1.4.0 // indirect

     

       23
       +
       	go.opentelemetry.io/otel v1.34.0 // indirect

     

       24
       +
       	go.opentelemetry.io/otel/trace v1.34.0 // indirect

     

       25
       +
       	golang.org/x/sys v0.30.0 // indirect

     

       26
       +
       	gopkg.in/yaml.v3 v3.0.1 // indirect

     

       27
        
       )

+105 -6

go.sum

···

       1
       -
       code.kiri.systems/kiri/magna v0.0.0-20240721214902-8d0a079dbd84 h1:igzBX4k3REg0WZExjGLWW7/wu/X+U6QlbMc8aeO2030=

     

       2
       -
       code.kiri.systems/kiri/magna v0.0.0-20240721214902-8d0a079dbd84/go.mod h1:gSzCiTKyKlUEjGgl/qTb8rxF0QUVuWOEORAsTXA0qyI=

     

       3
       -
       code.kiri.systems/kiri/magna v0.0.0-20240922043826-2c2a1c508469 h1:LUvvGcJ7DuW3eo7yblNH2igCJzYsbWJQ08iZEXBWplc=

     

       4
       -
       code.kiri.systems/kiri/magna v0.0.0-20240922043826-2c2a1c508469/go.mod h1:gSzCiTKyKlUEjGgl/qTb8rxF0QUVuWOEORAsTXA0qyI=

     

       5
        
       github.com/BurntSushi/toml v1.4.0 h1:kuoIxZQy2WRRk1pttg9asf+WVv6tWQuBNVmK8+nqPr0=

     

       6
        
       github.com/BurntSushi/toml v1.4.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       7
        
       github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=

     

       8
        
       github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       9
        
       github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=

     

       10
        
       github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=

     

       11
       -
       github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=

     

       12
       -
       github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
       gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

     

       14
        
       gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

···

       1
       +
       code.kiri.systems/kiri/magna v0.0.0-20250211050847-abb0522bcd30 h1:ORu6TXli7rdqczAOE3Mi+Xc4IlzcgEpNXjUWeNLoqxg=

     

       2
       +
       code.kiri.systems/kiri/magna v0.0.0-20250211050847-abb0522bcd30/go.mod h1:gSzCiTKyKlUEjGgl/qTb8rxF0QUVuWOEORAsTXA0qyI=

     

       0
        
       
     

       0
        
       
     

       3
        
       github.com/BurntSushi/toml v1.4.0 h1:kuoIxZQy2WRRk1pttg9asf+WVv6tWQuBNVmK8+nqPr0=

     

       4
        
       github.com/BurntSushi/toml v1.4.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=

     

       5
       +
       github.com/ClickHouse/ch-go v0.64.1 h1:FWpP+QU4KchgzpEekuv8YoI/fUc4H2r6Bwc5WwrzvcI=

     

       6
       +
       github.com/ClickHouse/ch-go v0.64.1/go.mod h1:RBUynvczWwVzhS6Up9lPKlH1mrk4UAmle6uzCiW4Pkc=

     

       7
       +
       github.com/ClickHouse/clickhouse-go/v2 v2.31.0 h1:9MNHRDYXjFTJizGEJM1DfYAqdra/ohprPoZ+LPiuHXQ=

     

       8
       +
       github.com/ClickHouse/clickhouse-go/v2 v2.31.0/go.mod h1:V1aZaG0ctMbd8KVi+D4loXi97duWYtHiQHMCgipKJcI=

     

       9
       +
       github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=

     

       10
       +
       github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=

     

       11
       +
       github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     

       12
        
       github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=

     

       13
        
       github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     

       14
       +
       github.com/go-faster/city v1.0.1 h1:4WAxSZ3V2Ws4QRDrscLEDcibJY8uf41H6AhXDrNDcGw=

     

       15
       +
       github.com/go-faster/city v1.0.1/go.mod h1:jKcUJId49qdW3L1qKHH/3wPeUstCVpVSXTM6vO3VcTw=

     

       16
       +
       github.com/go-faster/errors v0.7.1 h1:MkJTnDoEdi9pDabt1dpWf7AA8/BaSYZqibYyhZ20AYg=

     

       17
       +
       github.com/go-faster/errors v0.7.1/go.mod h1:5ySTjWFiphBs07IKuiL69nxdfd5+fzh1u7FPGZP2quo=

     

       18
       +
       github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=

     

       19
       +
       github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=

     

       20
       +
       github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=

     

       21
       +
       github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=

     

       22
       +
       github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=

     

       23
       +
       github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=

     

       24
       +
       github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=

     

       25
       +
       github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=

     

       26
       +
       github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=

     

       27
       +
       github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=

     

       28
       +
       github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=

     

       29
       +
       github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=

     

       30
       +
       github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=

     

       31
       +
       github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=

     

       32
       +
       github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=

     

       33
       +
       github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=

     

       34
       +
       github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=

     

       35
       +
       github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=

     

       36
       +
       github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=

     

       37
       +
       github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=

     

       38
       +
       github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=

     

       39
       +
       github.com/paulmach/orb v0.11.1 h1:3koVegMC4X/WeiXYz9iswopaTwMem53NzTJuTF20JzU=

     

       40
       +
       github.com/paulmach/orb v0.11.1/go.mod h1:5mULz1xQfs3bmQm63QEJA6lNGujuRafwA5S/EnuLaLU=

     

       41
       +
       github.com/paulmach/protoscan v0.2.1/go.mod h1:SpcSwydNLrxUGSDvXvO0P7g7AuhJ7lcKfDlhJCDw2gY=

     

       42
       +
       github.com/pierrec/lz4/v4 v4.1.22 h1:cKFw6uJDK+/gfw5BcDL0JL5aBsAFdsIT18eRtLj7VIU=

     

       43
       +
       github.com/pierrec/lz4/v4 v4.1.22/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=

     

       44
       +
       github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=

     

       45
       +
       github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=

     

       46
        
       github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=

     

       47
        
       github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=

     

       48
       +
       github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=

     

       49
       +
       github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=

     

       50
       +
       github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=

     

       51
       +
       github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=

     

       52
       +
       github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=

     

       53
       +
       github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=

     

       54
       +
       github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=

     

       55
       +
       github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=

     

       56
       +
       github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=

     

       57
       +
       github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=

     

       58
       +
       github.com/xdg-go/scram v1.1.1/go.mod h1:RaEWvsqvNKKvBPvcKeFjrG2cJqOkHTiyTpzz23ni57g=

     

       59
       +
       github.com/xdg-go/stringprep v1.0.3/go.mod h1:W3f5j4i+9rC0kuIEJL0ky1VpHXQU3ocBgklLGvcBnW8=

     

       60
       +
       github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=

     

       61
       +
       github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=

     

       62
       +
       github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA=

     

       63
       +
       github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

     

       64
       +
       github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

     

       65
       +
       go.mongodb.org/mongo-driver v1.11.4/go.mod h1:PTSz5yu21bkT/wXpkS7WR5f0ddqw5quethTUn9WM+2g=

     

       66
       +
       go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY=

     

       67
       +
       go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI=

     

       68
       +
       go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC8mh/k=

     

       69
       +
       go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE=

     

       70
       +
       golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=

     

       71
       +
       golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=

     

       72
       +
       golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=

     

       73
       +
       golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=

     

       74
       +
       golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=

     

       75
       +
       golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=

     

       76
       +
       golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=

     

       77
       +
       golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=

     

       78
       +
       golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=

     

       79
       +
       golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=

     

       80
       +
       golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=

     

       81
       +
       golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       82
       +
       golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       83
       +
       golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       84
       +
       golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

     

       85
       +
       golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=

     

       86
       +
       golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

     

       87
       +
       golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

     

       88
       +
       golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

     

       89
       +
       golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

     

       90
       +
       golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

     

       91
       +
       golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=

     

       92
       +
       golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=

     

       93
       +
       golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=

     

       94
       +
       golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

     

       95
       +
       golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=

     

       96
       +
       golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=

     

       97
       +
       golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=

     

       98
       +
       golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

     

       99
       +
       golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=

     

       100
       +
       golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=

     

       101
       +
       golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=

     

       102
       +
       golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

     

       103
       +
       golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

     

       104
       +
       golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

     

       105
       +
       golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

     

       106
       +
       google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=

     

       107
       +
       google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=

     

       108
       +
       gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

     

       109
       +
       gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=

     

       110
       +
       gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

     

       111
       +
       gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

     

       112
        
       gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

     

       113
        
       gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

+53 -21

main.go

···

       9
        
       

     

       10
        
       	"code.kiri.systems/kiri/alky/pkg/config"

     

       11
        
       	"code.kiri.systems/kiri/alky/pkg/dns"

     

       0
        
       
     

       12
        
       	"code.kiri.systems/kiri/alky/pkg/rootservers"

     

       13
        
       )

     

       14
        
       

     
···

       26
        
       		log.Fatal(err)

     

       27
        
       	}

     

       28
        
       

     

       29
       -
       	rootServers, err := rootservers.DecodeRootHints(cfg.Server.RootHintsFile)

     

       0
        
       
     

       0
        
       
     

       30
        
       	if err != nil {

     

       31
        
       		log.Fatal(err)

     

       32
        
       	}

     

       33
       -
       

     

       34
       -
       	var logger *slog.Logger

     

       35
       -
       	switch cfg.Logging.Output {

     

       36
       -
       	case "file":

     

       37
       -
       		f, err := os.OpenFile(cfg.Logging.FilePath, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0o644)

     

       38
       -
       		if err != nil {

     

       39
       -
       			log.Fatal(err)

     

       40
       -
       		}

     

       41
        
       

     

       42
       -
       		logger = slog.New(slog.NewJSONHandler(f, nil))

     

       43
       -
       	case "stdout":

     

       44
       -
       		fallthrough

     

       45
       -
       	default:

     

       46
       -
       		logger = slog.New(slog.NewJSONHandler(os.Stdout, nil))

     

       47
        
       	}

     

       48
        
       

     

       49
       -
       	memCache := dns.NewMemoryCache()

     

       50
       -
       	var cache dns.Cache = memCache

     

       51
        
       

     

       52
        
       	handler := &dns.QueryHandler{

     

       53
        
       		RootServers: rootServers,

     

       54
        
       		Timeout:     time.Duration(cfg.Advanced.QueryTimeout) * time.Second,

     

       55
       -
       		Cache:       &cache,

     

       0
        
       
     

       56
        
       	}

     

       57
        
       

     

       58
       -
       	logConfig := &dns.LogConfig{Logger: logger}

     

       59
        
       

     

       60
        
       	rateLimitHandler := dns.RateLimitMiddleware(&dns.RateLimitConfig{

     

       61
        
       		Rate:           float64(cfg.Ratelimit.Rate),

     
···

       63
        
       		WindowLength:   time.Duration(cfg.Ratelimit.Window) * time.Second,

     

       64
        
       		ExpirationTime: time.Duration(cfg.Ratelimit.ExpirationTime) * time.Second,

     

       65
        
       	})(handler)

     

       66
       -
       	loggingHandler := dns.LoggingMiddleware(logConfig)(rateLimitHandler)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       67
        
       

     

       68
        
       	s := dns.Server{

     

       69
        
       		Address:      cfg.Server.Address,

     
···

       72
        
       		UDPSize:      512,

     

       73
        
       		ReadTimeout:  2 * time.Second,

     

       74
        
       		WriteTimeout: 2 * time.Second,

     

       75
       -
       

     

       76
       -
       		Logger: logger,

     

       77
        
       	}

     

       78
        
       

     

       79
        
       	if err := s.ListenAndServe(); err != nil {

     

       80
        
       		slog.Error("Failed to start server", "error", err)

     

       81
        
       	}

     

       82
        
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       9
        
       

     

       10
        
       	"code.kiri.systems/kiri/alky/pkg/config"

     

       11
        
       	"code.kiri.systems/kiri/alky/pkg/dns"

     

       12
       +
       	"code.kiri.systems/kiri/alky/pkg/metrics"

     

       13
        
       	"code.kiri.systems/kiri/alky/pkg/rootservers"

     

       14
        
       )

     

       15
        
       

     
···

       27
        
       		log.Fatal(err)

     

       28
        
       	}

     

       29
        
       

     

       30
       +
       	logger := setupLogger(&cfg)

     

       31
       +
       

     

       32
       +
       	metricsClient, err := metrics.NewClickHouseMetrics(&cfg.Metrics, logger)

     

       33
        
       	if err != nil {

     

       34
        
       		log.Fatal(err)

     

       35
        
       	}

     

       36
       +
       	defer metricsClient.Close()

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       37
        
       

     

       38
       +
       	rootServers, err := rootservers.DecodeRootHints(cfg.Server.RootHintsFile)

     

       39
       +
       	if err != nil {

     

       40
       +
       		log.Fatal(err)

     

       0
        
       
     

       0
        
       
     

       41
        
       	}

     

       42
        
       

     

       43
       +
       	cache := dns.NewMemoryCache(5000, 5*time.Minute)

     

       0
        
       
     

       44
        
       

     

       45
        
       	handler := &dns.QueryHandler{

     

       46
        
       		RootServers: rootServers,

     

       47
        
       		Timeout:     time.Duration(cfg.Advanced.QueryTimeout) * time.Second,

     

       48
       +
       		Cache:       cache,

     

       49
       +
       		Logger:      logger,

     

       50
        
       	}

     

       51
        
       

     

       52
       +
       	go monitorCacheMetrics(cache, metricsClient, logger)

     

       53
        
       

     

       54
        
       	rateLimitHandler := dns.RateLimitMiddleware(&dns.RateLimitConfig{

     

       55
        
       		Rate:           float64(cfg.Ratelimit.Rate),

     
···

       57
        
       		WindowLength:   time.Duration(cfg.Ratelimit.Window) * time.Second,

     

       58
        
       		ExpirationTime: time.Duration(cfg.Ratelimit.ExpirationTime) * time.Second,

     

       59
        
       	})(handler)

     

       60
       +
       

     

       61
       +
       	metricsHandler := metrics.MetricsMiddleware(metricsClient)(rateLimitHandler)

     

       62
       +
       

     

       63
       +
       	loggingHandler := dns.LoggingMiddleware(&dns.LogConfig{

     

       64
       +
       		Logger: logger,

     

       65
       +
       		Level:  slog.LevelInfo,

     

       66
       +
       	})(metricsHandler)

     

       67
        
       

     

       68
        
       	s := dns.Server{

     

       69
        
       		Address:      cfg.Server.Address,

     
···

       72
        
       		UDPSize:      512,

     

       73
        
       		ReadTimeout:  2 * time.Second,

     

       74
        
       		WriteTimeout: 2 * time.Second,

     

       75
       +
       		Logger:       logger,

     

       0
        
       
     

       76
        
       	}

     

       77
        
       

     

       78
        
       	if err := s.ListenAndServe(); err != nil {

     

       79
        
       		slog.Error("Failed to start server", "error", err)

     

       80
        
       	}

     

       81
        
       }

     

       82
       +
       

     

       83
       +
       func monitorCacheMetrics(cache *dns.MemoryCache, metricsClient *metrics.ClickHouseMetrics, logger *slog.Logger) {

     

       84
       +
       	ticker := time.NewTicker(1 * time.Minute)

     

       85
       +
       	defer ticker.Stop()

     

       86
       +
       

     

       87
       +
       	for range ticker.C {

     

       88
       +
       		stats := cache.GetStats()

     

       89
       +
       		metricsClient.RecordCacheStats(stats)

     

       90
       +
       		logger.Info("Cache metrics recorded to ClickHouse")

     

       91
       +
       	}

     

       92
       +
       }

     

       93
       +
       

     

       94
       +
       func setupLogger(cfg *config.Config) *slog.Logger {

     

       95
       +
       	var logger *slog.Logger

     

       96
       +
       

     

       97
       +
       	handlerOpts := &slog.HandlerOptions{

     

       98
       +
       		Level: slog.LevelDebug,

     

       99
       +
       	}

     

       100
       +
       

     

       101
       +
       	switch cfg.Logging.Output {

     

       102
       +
       	case "file":

     

       103
       +
       		f, err := os.OpenFile(cfg.Logging.FilePath, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0o644)

     

       104
       +
       		if err != nil {

     

       105
       +
       			log.Fatal(err)

     

       106
       +
       		}

     

       107
       +
       

     

       108
       +
       		logger = slog.New(slog.NewJSONHandler(f, handlerOpts))

     

       109
       +
       	default:

     

       110
       +
       		logger = slog.New(slog.NewJSONHandler(os.Stdout, handlerOpts))

     

       111
       +
       	}

     

       112
       +
       

     

       113
       +
       	return logger

     

       114
       +
       }

+34

migrations/00001_initial.sql

···

       1
       +
       -- +goose Up

     

       2
       +
       CREATE TABLE IF NOT EXISTS alky_dns_queries (

     

       3
       +
           timestamp DateTime,

     

       4
       +
           instance_id String,

     

       5
       +
           query_name String,

     

       6
       +
           query_type String,

     

       7
       +
           query_class String,

     

       8
       +
           remote_addr String,

     

       9
       +
           response_code String,

     

       10
       +
           duration Int64,

     

       11
       +
           cache_hit Bool

     

       12
       +
       ) ENGINE = MergeTree()

     

       13
       +
       PARTITION BY toYYYYMM(timestamp)

     

       14
       +
       ORDER BY (timestamp, instance_id, query_name)

     

       15
       +
       TTL timestamp + toIntervalDay(30);

     

       16
       +
       

     

       17
       +
       CREATE TABLE IF NOT EXISTS alky_dns_cache_metrics (

     

       18
       +
           timestamp DateTime,

     

       19
       +
           instance_id String,

     

       20
       +
           total_queries Int64,

     

       21
       +
           cache_hits Int64,

     

       22
       +
           cache_misses Int64,

     

       23
       +
           negative_hits Int64,

     

       24
       +
           positive_hits Int64,

     

       25
       +
           evictions    Int64,

     

       26
       +
           size         Int,

     

       27
       +
       ) ENGINE = MergeTree()

     

       28
       +
       PARTITION BY toYYYYMM(timestamp)

     

       29
       +
       ORDER BY (timestamp, instance_id)

     

       30
       +
       TTL timestamp + toIntervalDay(30);

     

       31
       +
       

     

       32
       +
       -- +goose Down

     

       33
       +
       DROP TABLE IF EXISTS alky_dns_queries;

     

       34
       +
       DROP TABLE IF EXISTS alky_dns_cache_metrics;

+35

pkg/config/config.go

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"fmt"

     

       0
        
       
     

       5
        
       

     

       6
        
       	"github.com/BurntSushi/toml"

     

       7
        
       )

     
···

       24
        
       	ExpirationTime int `toml:"expiration_time"`

     

       25
        
       }

     

       26
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       27
        
       type AdvancedConfig struct {

     

       28
        
       	QueryTimeout int `toml:"query_timeout"`

     

       29
        
       }

     
···

       32
        
       	Server    ServerConfig    `toml:"server"`

     

       33
        
       	Logging   LoggingConfig   `toml:"logging"`

     

       34
        
       	Ratelimit RatelimitConfig `toml:"ratelimit"`

     

       0
        
       
     

       35
        
       	Advanced  AdvancedConfig  `toml:"advanced"`

     

       36
        
       }

     

       37
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       38
        
       func LoadConfig(path string) (Config, error) {

     

       39
        
       	cfg := Config{}

     

       40
        
       	if _, err := toml.DecodeFile(path, &cfg); err != nil {

     
···

       55
        
       

     

       56
        
       	if cfg.Logging.Output == "file" && cfg.Logging.FilePath == "" {

     

       57
        
       		return cfg, fmt.Errorf("If `[logging.output]` is `file` then `file_path` must be set.")

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       58
        
       	}

     

       59
        
       

     

       60
        
       	if cfg.Advanced.QueryTimeout == 0 {

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"fmt"

     

       5
       +
       	"time"

     

       6
        
       

     

       7
        
       	"github.com/BurntSushi/toml"

     

       8
        
       )

     
···

       25
        
       	ExpirationTime int `toml:"expiration_time"`

     

       26
        
       }

     

       27
        
       

     

       28
       +
       type MetricsConfig struct {

     

       29
       +
       	DSN             string   `toml:"dsn"`

     

       30
       +
       	BatchSize       int      `toml:"batch_size"`

     

       31
       +
       	FlushInterval   duration `toml:"flush_interval"`

     

       32
       +
       	RetentionPeriod duration `toml:"retention_period"`

     

       33
       +
       }

     

       34
       +
       

     

       35
        
       type AdvancedConfig struct {

     

       36
        
       	QueryTimeout int `toml:"query_timeout"`

     

       37
        
       }

     
···

       40
        
       	Server    ServerConfig    `toml:"server"`

     

       41
        
       	Logging   LoggingConfig   `toml:"logging"`

     

       42
        
       	Ratelimit RatelimitConfig `toml:"ratelimit"`

     

       43
       +
       	Metrics   MetricsConfig   `toml:"metrics"`

     

       44
        
       	Advanced  AdvancedConfig  `toml:"advanced"`

     

       45
        
       }

     

       46
        
       

     

       47
       +
       type duration struct {

     

       48
       +
       	time.Duration

     

       49
       +
       }

     

       50
       +
       

     

       51
       +
       func (d *duration) UnmarshalText(text []byte) error {

     

       52
       +
       	var err error

     

       53
       +
       	d.Duration, err = time.ParseDuration(string(text))

     

       54
       +
       	return err

     

       55
       +
       }

     

       56
       +
       

     

       57
        
       func LoadConfig(path string) (Config, error) {

     

       58
        
       	cfg := Config{}

     

       59
        
       	if _, err := toml.DecodeFile(path, &cfg); err != nil {

     
···

       74
        
       

     

       75
        
       	if cfg.Logging.Output == "file" && cfg.Logging.FilePath == "" {

     

       76
        
       		return cfg, fmt.Errorf("If `[logging.output]` is `file` then `file_path` must be set.")

     

       77
       +
       	}

     

       78
       +
       

     

       79
       +
       	if cfg.Metrics.DSN == "" {

     

       80
       +
       		cfg.Metrics.DSN = "clickhouse://localhost:9000/default"

     

       81
       +
       	}

     

       82
       +
       

     

       83
       +
       	if cfg.Metrics.BatchSize == 0 {

     

       84
       +
       		cfg.Metrics.BatchSize = 1000

     

       85
       +
       	}

     

       86
       +
       

     

       87
       +
       	if cfg.Metrics.FlushInterval.Duration == 0 {

     

       88
       +
       		cfg.Metrics.FlushInterval.Duration = 10 * time.Second

     

       89
       +
       	}

     

       90
       +
       

     

       91
       +
       	if cfg.Metrics.RetentionPeriod.Duration == 0 {

     

       92
       +
       		cfg.Metrics.RetentionPeriod.Duration = 30 * 24 * time.Hour

     

       93
        
       	}

     

       94
        
       

     

       95
        
       	if cfg.Advanced.QueryTimeout == 0 {

+261 -12

pkg/dns/cache.go

···

       1
        
       package dns

     

       2
        
       

     

       3
        
       import (

     

       0
        
       
     

       0
        
       
     

       4
        
       	"sync"

     

       5
        
       	"time"

     

       6
        
       

     

       7
        
       	"code.kiri.systems/kiri/magna"

     

       8
        
       )

     

       9
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       10
        
       type CachedResourceRecord struct {

     

       11
       -
       	Record   magna.ResourceRecord

     

       12
       -
       	ExpireAt time.Time

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
       }

     

       14
        
       

     

       15
       -
       type CacheEntry struct {

     

       16
       -
       	Answer []CachedResourceRecord

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       17
        
       }

     

       18
        
       

     

       19
        
       type Cache interface {

     

       20
        
       	Get(key string) (*CacheEntry, bool)

     

       21
        
       	Set(key string, entry *CacheEntry)

     

       22
       -
       }

     

       23
       -
       

     

       24
       -
       type MemoryCache struct {

     

       25
       -
       	entries map[string]*CacheEntry

     

       26
       -
       	mu      sync.RWMutex

     

       27
        
       }

     

       28
        
       

     

       29
       -
       func NewMemoryCache() *MemoryCache {

     

       30
       -
       	return &MemoryCache{

     

       31
       -
       		entries: make(map[string]*CacheEntry),

     

       0
        
       
     

       0
        
       
     

       32
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       33
        
       }

     

       34
        
       

     

       35
        
       func (c *MemoryCache) Get(key string) (*CacheEntry, bool) {

     

       36
        
       	c.mu.RLock()

     

       37
        
       	c.mu.RUnlock()

     

       38
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       39
        
       	entry, exists := c.entries[key]

     

       40
        
       	if !exists {

     

       0
        
       
     

       0
        
       
     

       41
        
       		return nil, false

     

       42
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       43
        
       

     

       44
        
       	return entry, true

     

       45
        
       }

     
···

       48
        
       	c.mu.Lock()

     

       49
        
       	defer c.mu.Unlock()

     

       50
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       51
        
       	c.entries[key] = entry

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       52
        
       }

···

       1
        
       package dns

     

       2
        
       

     

       3
        
       import (

     

       4
       +
       	"log"

     

       5
       +
       	"strings"

     

       6
        
       	"sync"

     

       7
        
       	"time"

     

       8
        
       

     

       9
        
       	"code.kiri.systems/kiri/magna"

     

       10
        
       )

     

       11
        
       

     

       12
       +
       type BailiwickRule int

     

       13
       +
       

     

       14
       +
       const (

     

       15
       +
       	BailiwickSame BailiwickRule = iota

     

       16
       +
       	BailiwickChild

     

       17
       +
       	BailiwickOutside

     

       18
       +
       )

     

       19
       +
       

     

       20
       +
       type CacheEntry struct {

     

       21
       +
       	Answer      []CachedResourceRecord

     

       22
       +
       	Authority   []CachedResourceRecord

     

       23
       +
       	Additional  []CachedResourceRecord

     

       24
       +
       	NegativeTTL time.Duration

     

       25
       +
       	ExpireAt    time.Time

     

       26
       +
       	CreateTime  time.Time

     

       27
       +
       	IsNegative  bool

     

       28
       +
       	Bailiwick   string

     

       29
       +
       }

     

       30
       +
       

     

       31
        
       type CachedResourceRecord struct {

     

       32
       +
       	Record        magna.ResourceRecord

     

       33
       +
       	ExpireAt      time.Time

     

       34
       +
       	BailiwickRule BailiwickRule

     

       35
       +
       }

     

       36
       +
       

     

       37
       +
       type MemoryCache struct {

     

       38
       +
       	entries        map[string]*CacheEntry

     

       39
       +
       	mu             sync.RWMutex

     

       40
       +
       	stats          CacheStats

     

       41
       +
       	maxSize        int

     

       42
       +
       	cleaupInterval time.Duration

     

       43
        
       }

     

       44
        
       

     

       45
       +
       type CacheStats struct {

     

       46
       +
       	TotalQueries int64

     

       47
       +
       	CacheHits    int64

     

       48
       +
       	CacheMisses  int64

     

       49
       +
       	NegativeHits int64

     

       50
       +
       	PositiveHits int64

     

       51
       +
       	Evictions    int64

     

       52
       +
       	Size         int

     

       53
        
       }

     

       54
        
       

     

       55
        
       type Cache interface {

     

       56
        
       	Get(key string) (*CacheEntry, bool)

     

       57
        
       	Set(key string, entry *CacheEntry)

     

       58
       +
       	Clear()

     

       59
       +
       	GetStats() *CacheStats

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       60
        
       }

     

       61
        
       

     

       62
       +
       func NewMemoryCache(maxSize int, cleanupInterval time.Duration) *MemoryCache {

     

       63
       +
       	cache := &MemoryCache{

     

       64
       +
       		entries:        make(map[string]*CacheEntry),

     

       65
       +
       		maxSize:        maxSize,

     

       66
       +
       		cleaupInterval: cleanupInterval,

     

       67
        
       	}

     

       68
       +
       

     

       69
       +
       	go cache.periodicCleanup()

     

       70
       +
       	return cache

     

       71
        
       }

     

       72
        
       

     

       73
        
       func (c *MemoryCache) Get(key string) (*CacheEntry, bool) {

     

       74
        
       	c.mu.RLock()

     

       75
        
       	c.mu.RUnlock()

     

       76
        
       

     

       77
       +
       	c.stats.TotalQueries++

     

       78
       +
       

     

       79
       +
       	log.Println("looking for: ", key)

     

       80
       +
       	for k := range c.entries {

     

       81
       +
       		log.Printf("\t%s\n", k)

     

       82
       +
       	}

     

       83
       +
       

     

       84
       +
       	log.Println(c.entries[key])

     

       85
       +
       

     

       86
        
       	entry, exists := c.entries[key]

     

       87
        
       	if !exists {

     

       88
       +
       		log.Println("cache miss")

     

       89
       +
       		c.stats.CacheMisses++

     

       90
        
       		return nil, false

     

       91
        
       	}

     

       92
       +
       

     

       93
       +
       	if time.Now().After(entry.ExpireAt) {

     

       94
       +
       		c.stats.CacheMisses++

     

       95
       +
       		log.Println("cache expire")

     

       96
       +
       		return nil, false

     

       97
       +
       	}

     

       98
       +
       

     

       99
       +
       	if entry.IsNegative {

     

       100
       +
       		c.stats.NegativeHits++

     

       101
       +
       	} else {

     

       102
       +
       		c.stats.PositiveHits++

     

       103
       +
       	}

     

       104
       +
       	c.stats.CacheHits++

     

       105
        
       

     

       106
        
       	return entry, true

     

       107
        
       }

     
···

       110
        
       	c.mu.Lock()

     

       111
        
       	defer c.mu.Unlock()

     

       112
        
       

     

       113
       +
       	if len(c.entries) >= c.maxSize {

     

       114
       +
       		c.evictOldest()

     

       115
       +
       	}

     

       116
       +
       

     

       117
        
       	c.entries[key] = entry

     

       118
       +
       	c.stats.Size = len(c.entries)

     

       119
       +
       }

     

       120
       +
       

     

       121
       +
       func (c *MemoryCache) Clear() {

     

       122
       +
       	c.mu.Lock()

     

       123
       +
       	defer c.mu.Unlock()

     

       124
       +
       

     

       125
       +
       	c.entries = make(map[string]*CacheEntry)

     

       126
       +
       	c.stats = CacheStats{}

     

       127
       +
       }

     

       128
       +
       

     

       129
       +
       func (c *MemoryCache) GetStats() *CacheStats {

     

       130
       +
       	c.mu.RLock()

     

       131
       +
       	defer c.mu.RUnlock()

     

       132
       +
       

     

       133
       +
       	stats := c.stats

     

       134
       +
       	return &stats

     

       135
       +
       }

     

       136
       +
       

     

       137
       +
       func (c *MemoryCache) evictOldest() {

     

       138
       +
       	var oldestKey string

     

       139
       +
       	var oldestTime time.Time

     

       140
       +
       

     

       141
       +
       	first := true

     

       142
       +
       	for k, e := range c.entries {

     

       143
       +
       		if first || e.CreateTime.Before(oldestTime) {

     

       144
       +
       			oldestKey = k

     

       145
       +
       			oldestTime = e.CreateTime

     

       146
       +
       			first = false

     

       147
       +
       		}

     

       148
       +
       	}

     

       149
       +
       

     

       150
       +
       	if oldestKey != "" {

     

       151
       +
       		delete(c.entries, oldestKey)

     

       152
       +
       		c.stats.Evictions++

     

       153
       +
       	}

     

       154
       +
       }

     

       155
       +
       

     

       156
       +
       func (c *MemoryCache) periodicCleanup() {

     

       157
       +
       	ticker := time.NewTicker(c.cleaupInterval)

     

       158
       +
       	defer ticker.Stop()

     

       159
       +
       

     

       160
       +
       	for range ticker.C {

     

       161
       +
       		c.cleanup()

     

       162
       +
       	}

     

       163
       +
       }

     

       164
       +
       

     

       165
       +
       func (c *MemoryCache) cleanup() {

     

       166
       +
       	c.mu.Lock()

     

       167
       +
       	defer c.mu.Unlock()

     

       168
       +
       

     

       169
       +
       	now := time.Now()

     

       170
       +
       	for k, e := range c.entries {

     

       171
       +
       		if now.After(e.ExpireAt) {

     

       172
       +
       			delete(c.entries, k)

     

       173
       +
       		}

     

       174
       +
       	}

     

       175
       +
       

     

       176
       +
       	c.stats.Size = len(c.entries)

     

       177
       +
       }

     

       178
       +
       

     

       179
       +
       func getMinTTL(records []magna.ResourceRecord) uint32 {

     

       180
       +
       	if len(records) == 0 {

     

       181
       +
       		return 0

     

       182
       +
       	}

     

       183
       +
       

     

       184
       +
       	minTTL := records[0].TTL

     

       185
       +
       	for _, rr := range records[1:] {

     

       186
       +
       		if rr.TTL < minTTL {

     

       187
       +
       			minTTL = rr.TTL

     

       188
       +
       		}

     

       189
       +
       	}

     

       190
       +
       	return minTTL

     

       191
       +
       }

     

       192
       +
       

     

       193
       +
       func CreateCacheEntry(msg *magna.Message, zone string) *CacheEntry {

     

       194
       +
       	now := time.Now()

     

       195
       +
       	entry := &CacheEntry{

     

       196
       +
       		CreateTime: now,

     

       197
       +
       		IsNegative: msg.Header.RCode == magna.NXDOMAIN,

     

       198
       +
       		Bailiwick:  zone,

     

       199
       +
       	}

     

       200
       +
       

     

       201
       +
       	if entry.IsNegative {

     

       202
       +
       		var soaTTL uint32

     

       203
       +
       		for _, auth := range msg.Authority {

     

       204
       +
       			if auth.RType == magna.SOAType {

     

       205
       +
       				soaTTL = auth.TTL

     

       206
       +
       				break

     

       207
       +
       			}

     

       208
       +
       		}

     

       209
       +
       

     

       210
       +
       		if soaTTL == 0 {

     

       211
       +
       			soaTTL = 900

     

       212
       +
       		}

     

       213
       +
       

     

       214
       +
       		entry.NegativeTTL = time.Duration(soaTTL) * time.Second

     

       215
       +
       		entry.ExpireAt = now.Add(entry.NegativeTTL)

     

       216
       +
       		entry.Authority = make([]CachedResourceRecord, len(msg.Authority))

     

       217
       +
       		for i, rr := range msg.Authority {

     

       218
       +
       			rule := determineBailiwickRule(zone, rr.Name)

     

       219
       +
       			entry.Authority[i] = CachedResourceRecord{

     

       220
       +
       				Record:        rr,

     

       221
       +
       				ExpireAt:      now.Add(time.Duration(rr.TTL) * time.Second),

     

       222
       +
       				BailiwickRule: rule,

     

       223
       +
       			}

     

       224
       +
       		}

     

       225
       +
       

     

       226
       +
       		return entry

     

       227
       +
       	}

     

       228
       +
       

     

       229
       +
       	minTTL := getMinTTL(msg.Answer)

     

       230
       +
       	entry.ExpireAt = now.Add(time.Duration(minTTL) * time.Second)

     

       231
       +
       

     

       232
       +
       	entry.Answer = make([]CachedResourceRecord, len(msg.Answer))

     

       233
       +
       	for i, rr := range msg.Answer {

     

       234
       +
       		rule := determineBailiwickRule(zone, rr.Name)

     

       235
       +
       		entry.Answer[i] = CachedResourceRecord{

     

       236
       +
       			Record:        rr,

     

       237
       +
       			ExpireAt:      now.Add(time.Duration(rr.TTL) * time.Second),

     

       238
       +
       			BailiwickRule: rule,

     

       239
       +
       		}

     

       240
       +
       	}

     

       241
       +
       

     

       242
       +
       	entry.Authority = make([]CachedResourceRecord, len(msg.Authority))

     

       243
       +
       	for i, rr := range msg.Authority {

     

       244
       +
       		rule := determineBailiwickRule(zone, rr.Name)

     

       245
       +
       		entry.Authority[i] = CachedResourceRecord{

     

       246
       +
       			Record:        rr,

     

       247
       +
       			ExpireAt:      now.Add(time.Duration(rr.TTL) * time.Second),

     

       248
       +
       			BailiwickRule: rule,

     

       249
       +
       		}

     

       250
       +
       	}

     

       251
       +
       

     

       252
       +
       	entry.Additional = make([]CachedResourceRecord, len(msg.Additional))

     

       253
       +
       	for i, rr := range msg.Additional {

     

       254
       +
       		rule := determineBailiwickRule(zone, rr.Name)

     

       255
       +
       		entry.Additional[i] = CachedResourceRecord{

     

       256
       +
       			Record:        rr,

     

       257
       +
       			ExpireAt:      now.Add(time.Duration(rr.TTL) * time.Second),

     

       258
       +
       			BailiwickRule: rule,

     

       259
       +
       		}

     

       260
       +
       	}

     

       261
       +
       

     

       262
       +
       	return entry

     

       263
       +
       }

     

       264
       +
       

     

       265
       +
       func isSubdomainOf(a, b string) bool {

     

       266
       +
       	if a == b {

     

       267
       +
       		return true

     

       268
       +
       	}

     

       269
       +
       

     

       270
       +
       	return strings.HasSuffix(b, "."+a)

     

       271
       +
       }

     

       272
       +
       

     

       273
       +
       func determineBailiwickRule(zone, name string) BailiwickRule {

     

       274
       +
       	if zone == name {

     

       275
       +
       		return BailiwickSame

     

       276
       +
       	}

     

       277
       +
       

     

       278
       +
       	if isSubdomainOf(zone, name) {

     

       279
       +
       		return BailiwickChild

     

       280
       +
       	}

     

       281
       +
       

     

       282
       +
       	return BailiwickOutside

     

       283
       +
       }

     

       284
       +
       

     

       285
       +
       func extractZone(msg *magna.Message) string {

     

       286
       +
       	for _, auth := range msg.Authority {

     

       287
       +
       		if auth.RType == magna.SOAType {

     

       288
       +
       			return auth.Name

     

       289
       +
       		}

     

       290
       +
       

     

       291
       +
       		if auth.RType == magna.NSType {

     

       292
       +
       			return auth.Name

     

       293
       +
       		}

     

       294
       +
       	}

     

       295
       +
       

     

       296
       +
       	if len(msg.Question) > 0 {

     

       297
       +
       		return msg.Question[0].QName

     

       298
       +
       	}

     

       299
       +
       

     

       300
       +
       	return ""

     

       301
        
       }

+167 -110

pkg/dns/resolve.go

···

       3
        
       import (

     

       4
        
       	"context"

     

       5
        
       	"fmt"

     

       0
        
       
     

       0
        
       
     

       6
        
       	"net"

     

       7
       -
       	"strings"

     

       8
        
       	"time"

     

       9
        
       

     

       10
        
       	"code.kiri.systems/kiri/magna"

     
···

       13
        
       type QueryHandler struct {

     

       14
        
       	RootServers []string

     

       15
        
       	Timeout     time.Duration

     

       16
       -
       	Cache       *Cache

     

       0
        
       
     

       17
        
       }

     

       18
        
       

     

       19
        
       type queryResponse struct {

     
···

       23
        
       }

     

       24
        
       

     

       25
        
       func (h *QueryHandler) ServeDNS(w ResponseWriter, r *Request) {

     

       26
       -
       	msg := h.processQuery(r.Message.Encode())

     

       27
       -
       	w.WriteMsg(msg)

     

       28
       -
       }

     

       29
       -
       

     

       30
       -
       func (h *QueryHandler) processQuery(messageBuffer []byte) *magna.Message {

     

       31
       -
       	var query magna.Message

     

       32
       -
       	if err := query.Decode(messageBuffer); err != nil {

     

       33
       -
       		return nil

     

       34
        
       	}

     

       35
        
       

     

       36
       -
       	msg := new(magna.Message)

     

       37
       -
       	msg = msg.CreateReply(&query)

     

       38
        
       

     

       39
       -
       	if len(query.Question) < 1 {

     

       40
       -
       		return msg.SetRCode(magna.FORMERR)

     

       41
       -
       	}

     

       42
       -
       

     

       43
       -
       	question := query.Question[0]

     

       44
       -
       	msg = msg.AddQuestion(question)

     

       45
       -
       

     

       46
       -
       	if question.QClass != magna.IN {

     

       47
       -
       		return msg.SetRCode(magna.NOTIMP)

     

       48
       -
       	}

     

       49
        
       

     

       50
       -
       	answer, err := h.resolveWithCache(question)

     

       51
        
       	if err != nil {

     

       52
       -
       		return msg.SetRCode(magna.SERVFAIL)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       53
        
       	}

     

       54
        
       

     

       55
       -
       	if len(answer) == 0 {

     

       56
       -
       		return msg.SetRCode(magna.NXDOMAIN)

     

       57
       -
       	}

     

       58
        
       

     

       59
       -
       	msg.Header.ANCount = uint16(len(answer))

     

       60
       -
       	msg.Answer = answer

     

       61
       -
       	return msg.SetRCode(magna.NOERROR)

     

       62
        
       }

     

       63
        
       

     

       64
       -
       func (h *QueryHandler) resolveWithCache(question magna.Question) ([]magna.ResourceRecord, error) {

     

       65
       -
       	cacheKey := fmt.Sprintf("%s:%s:%s", strings.ToLower(question.QName), question.QType.String(), question.QClass.String())

     

       66
        
       

     

       67
       -
       	if e, found := (*h.Cache).Get(cacheKey); found {

     

       68
       -
       		now := time.Now()

     

       69
       -
       		var updatedAnswer []magna.ResourceRecord

     

       70
       -
       		var cname *magna.ResourceRecord

     

       71
       -
       		hasAddressRecord := false

     

       0
        
       
     

       72
        
       

     

       73
       -
       		for _, cachedRR := range e.Answer {

     

       74
       -
       			if now.Before(cachedRR.ExpireAt) {

     

       75
       -
       				updatedRR := cachedRR.Record

     

       76
       -
       				updatedRR.TTL = uint32(cachedRR.ExpireAt.Sub(now).Seconds())

     

       77
       -
       				updatedAnswer = append(updatedAnswer, updatedRR)

     

       78
        
       

     

       79
       -
       				if updatedRR.RType == magna.CNAMEType && cname == nil {

     

       80
       -
       					cname = &updatedRR

     

       81
       -
       				} else if updatedRR.RType == question.QType {

     

       82
       -
       					hasAddressRecord = true

     

       83
       -
       				}

     

       84
        
       			}

     

       85
       -
       		}

     

       86
        
       

     

       87
       -
       		if len(updatedAnswer) > 0 {

     

       88
       -
       			// add AAAA types when magna supports those record types

     

       89
       -
       			if cname != nil && !hasAddressRecord && (question.QType == magna.AType) {

     

       90
       -
       				cnameTarget := cname.RData.String()

     

       91
       -
       				aRecords, err := h.resolveWithCache(magna.Question{QName: cnameTarget, QType: question.QType, QClass: question.QClass})

     

       92
       -
       				if err == nil && len(aRecords) > 0 {

     

       93
       -
       					updatedAnswer = append(updatedAnswer, aRecords...)

     

       94
       -
       				}

     

       95
        
       			}

     

       96
       -
       			return updatedAnswer, nil

     

       97
        
       		}

     

       98
        
       	}

     

       99
        
       

     

       100
       -
       	answer, err := h.resolveQuestion(question, h.RootServers)

     

       101
       -
       	if err != nil {

     

       102
       -
       		return nil, err

     

       103
       -
       	}

     

       104
       -
       

     

       105
       -
       	now := time.Now()

     

       106
       -
       	cachedAnswer := make([]CachedResourceRecord, len(answer))

     

       107
       -
       	for i, rr := range answer {

     

       108
       -
       		cachedAnswer[i] = CachedResourceRecord{

     

       109
       -
       			Record:   rr,

     

       110
       -
       			ExpireAt: now.Add(time.Duration(rr.TTL) * time.Second),

     

       111
       -
       		}

     

       112
       -
       	}

     

       113
       -
       

     

       114
       -
       	entry := &CacheEntry{

     

       115
       -
       		Answer: cachedAnswer,

     

       116
       -
       	}

     

       117
       -
       	(*h.Cache).Set(cacheKey, entry)

     

       118
       -
       

     

       119
       -
       	if len(answer) > 0 && answer[0].RType == magna.CNAMEType && question.QType == magna.AType {

     

       120
       -
       		cnameTarget := answer[len(answer)-1].RData.String()

     

       121
       -
       		addressRecords, err := h.resolveWithCache(magna.Question{QName: cnameTarget, QType: question.QType, QClass: question.QClass})

     

       122
       -
       		if err == nil && len(addressRecords) > 0 {

     

       123
       -
       			answer = append(answer, addressRecords...)

     

       124
       -
       		}

     

       125
       -
       	}

     

       126
       -
       

     

       127
       -
       	return answer, nil

     

       128
       -
       }

     

       129
       -
       

     

       130
       -
       func (h *QueryHandler) resolveQuestion(question magna.Question, servers []string) ([]magna.ResourceRecord, error) {

     

       131
       -
       	ctx, cancel := context.WithCancel(context.Background())

     

       132
        
       	defer cancel()

     

       133
        
       

     

       134
        
       	ch := make(chan queryResponse, len(servers))

     

       135
       -
       

     

       136
        
       	for _, s := range servers {

     

       137
        
       		go queryServer(ctx, question, s, ch, h.Timeout)

     

       138
        
       	}

     
···

       141
        
       		select {

     

       142
        
       		case res := <-ch:

     

       143
        
       			if res.Error != nil {

     

       144
       -
       				break

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       145
        
       			}

     

       146
        
       

     

       147
        
       			msg := res.MSG

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       148
        
       			if msg.Header.ANCount > 0 {

     

       149
        
       				if msg.Answer[0].RType == magna.CNAMEType {

     

       150
       -
       					cname_answers, err := h.resolveQuestion(magna.Question{QName: msg.Answer[0].RData.String(), QType: question.QType, QClass: question.QClass}, h.RootServers)

     

       151
       -
       					if err != nil {

     

       152
       -
       						continue

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       153
        
       					}

     

       154
       -
       					msg.Answer = append(msg.Answer, cname_answers...)

     

       0
        
       
     

       155
        
       				}

     

       156
        
       

     

       157
       -
       				return msg.Answer, nil

     

       0
        
       
     

       0
        
       
     

       158
        
       			}

     

       159
        
       

     

       160
        
       			if msg.Header.ARCount > 0 {

     
···

       165
        
       					}

     

       166
        
       				}

     

       167
        
       

     

       168
       -
       				return h.resolveQuestion(question, nextZone)

     

       0
        
       
     

       0
        
       
     

       169
        
       			}

     

       170
        
       

     

       171
        
       			if msg.Header.NSCount > 0 {

     

       172
       -
       				var ns []string

     

       173
       -
       				for _, a := range msg.Authority {

     

       174
       -
       					if a.RType == magna.NSType {

     

       175
       -
       						ans, err := h.resolveQuestion(magna.Question{QName: a.RData.String(), QType: magna.AType, QClass: magna.IN}, h.RootServers)

     

       176
       -
       						if err != nil {

     

       177
       -
       							break

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       178
        
       						}

     

       179
       -
       						for _, x := range ans {

     

       180
       -
       							ns = append(ns, x.RData.String())

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       181
        
       						}

     

       182
        
       					}

     

       183
        
       				}

     

       184
        
       

     

       185
       -
       				return h.resolveQuestion(question, ns)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       186
        
       			}

     

       187
        
       

     

       188
       -
       			return []magna.ResourceRecord{}, nil

     

       189
       -
       		case <-time.After(h.Timeout):

     

       190
       -
       			cancel()

     

       191
        
       		}

     

       192
        
       	}

     

       193
        
       

     

       194
       -
       	return []magna.ResourceRecord{}, nil

     

       195
        
       }

     

       196
        
       

     

       197
        
       func queryServer(ctx context.Context, question magna.Question, server string, ch chan<- queryResponse, timeout time.Duration) {

     
···

       238
        
       		ch <- queryResponse{Server: server, Error: fmt.Errorf("timeout")}

     

       239
        
       	}

     

       240
        
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       3
        
       import (

     

       4
        
       	"context"

     

       5
        
       	"fmt"

     

       6
       +
       	"log"

     

       7
       +
       	"log/slog"

     

       8
        
       	"net"

     

       0
        
       
     

       9
        
       	"time"

     

       10
        
       

     

       11
        
       	"code.kiri.systems/kiri/magna"

     
···

       14
        
       type QueryHandler struct {

     

       15
        
       	RootServers []string

     

       16
        
       	Timeout     time.Duration

     

       17
       +
       	Cache       *MemoryCache

     

       18
       +
       	Logger      *slog.Logger

     

       19
        
       }

     

       20
        
       

     

       21
        
       type queryResponse struct {

     
···

       25
        
       }

     

       26
        
       

     

       27
        
       func (h *QueryHandler) ServeDNS(w ResponseWriter, r *Request) {

     

       28
       +
       	if len(r.Message.Question) < 1 {

     

       29
       +
       		h.Logger.Debug("received query with no questions")

     

       30
       +
       		msg := r.Message.CreateReply(r.Message)

     

       31
       +
       		msg = msg.SetRCode(magna.FORMERR)

     

       32
       +
       		w.WriteMsg(msg)

     

       33
       +
       		return

     

       0
        
       
     

       0
        
       
     

       34
        
       	}

     

       35
        
       

     

       36
       +
       	question := r.Message.Question[0]

     

       37
       +
       	answers, authority, err := h.resolveQuestion(r.Context, question, h.RootServers)

     

       38
        
       

     

       39
       +
       	msg := r.Message.CreateReply(r.Message)

     

       40
       +
       	msg.Header.RA = true

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       41
        
       

     

       0
        
       
     

       42
        
       	if err != nil {

     

       43
       +
       		if err.Error() == "nxdomain" {

     

       44
       +
       			msg = msg.SetRCode(magna.NXDOMAIN)

     

       45
       +
       			msg.Authority = authority

     

       46
       +
       			msg.Header.NSCount = uint16(len(authority))

     

       47
       +
       		} else {

     

       48
       +
       			msg = msg.SetRCode(magna.SERVFAIL)

     

       49
       +
       		}

     

       50
       +
       	} else {

     

       51
       +
       		msg.Answer = answers

     

       52
       +
       		msg.Header.ANCount = uint16(len(answers))

     

       53
       +
       		msg = msg.SetRCode(magna.NOERROR)

     

       54
        
       	}

     

       55
        
       

     

       56
       +
       	w.WriteMsg(msg)

     

       57
       +
       }

     

       0
        
       
     

       58
        
       

     

       59
       +
       func (h *QueryHandler) resolveQuestion(ctx context.Context, question magna.Question, servers []string) ([]magna.ResourceRecord, []magna.ResourceRecord, error) {

     

       60
       +
       	return h.resolveQuestionWithZone(ctx, question, servers, ".")

     

       0
        
       
     

       61
        
       }

     

       62
        
       

     

       63
       +
       func (h *QueryHandler) resolveQuestionWithZone(ctx context.Context, question magna.Question, servers []string, currentZone string) ([]magna.ResourceRecord, []magna.ResourceRecord, error) {

     

       64
       +
       	cacheKey := fmt.Sprintf("%s:%s:%s", question.QName, question.QType.String(), question.QClass.String())

     

       65
        
       

     

       66
       +
       	if h.Cache != nil {

     

       67
       +
       		log.Println("cache is set")

     

       68
       +
       		if entry, hit := h.Cache.Get(cacheKey); hit {

     

       69
       +
       			log.Println("womp womp here here", entry, hit)

     

       70
       +
       			log.Println("request context: ", getCurrentRequest(ctx))

     

       71
       +
       			now := time.Now()

     

       72
        
       

     

       73
       +
       			if r := getCurrentRequest(ctx); r != nil {

     

       74
       +
       				r.Context = setCacheHit(r.Context)

     

       75
       +
       			}

     

       0
        
       
     

       0
        
       
     

       76
        
       

     

       77
       +
       			if entry.IsNegative {

     

       78
       +
       				return nil, convertCachedToMagna(entry.Authority, now), fmt.Errorf("nxdomain")

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       79
        
       			}

     

       0
        
       
     

       80
        
       

     

       81
       +
       			validAnswers := convertCachedToMagna(entry.Answer, now)

     

       82
       +
       			if len(validAnswers) > 0 {

     

       83
       +
       				return validAnswers, nil, nil

     

       84
       +
       			}

     

       85
       +
       		} else {

     

       86
       +
       			if r := getCurrentRequest(ctx); r != nil {

     

       87
       +
       				r.Context = setCacheMiss(r.Context)

     

       0
        
       
     

       88
        
       			}

     

       0
        
       
     

       89
        
       		}

     

       90
        
       	}

     

       91
        
       

     

       92
       +
       	ctx, cancel := context.WithTimeout(ctx, h.Timeout)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       93
        
       	defer cancel()

     

       94
        
       

     

       95
        
       	ch := make(chan queryResponse, len(servers))

     

       0
        
       
     

       96
        
       	for _, s := range servers {

     

       97
        
       		go queryServer(ctx, question, s, ch, h.Timeout)

     

       98
        
       	}

     
···

       101
        
       		select {

     

       102
        
       		case res := <-ch:

     

       103
        
       			if res.Error != nil {

     

       104
       +
       				h.Logger.Debug("server query failed",

     

       105
       +
       					"server", res.Server,

     

       106
       +
       					"error", res.Error)

     

       107
       +
       				continue

     

       108
        
       			}

     

       109
        
       

     

       110
        
       			msg := res.MSG

     

       111
       +
       			zone := extractZone(&msg)

     

       112
       +
       			if zone == "" {

     

       113
       +
       				zone = currentZone

     

       114
       +
       			}

     

       115
       +
       

     

       116
       +
       			if msg.Header.RCode == magna.NXDOMAIN {

     

       117
       +
       				entry := CreateCacheEntry(&msg, zone)

     

       118
       +
       				h.Cache.Set(cacheKey, entry)

     

       119
       +
       				now := time.Now()

     

       120
       +
       				return nil, convertCachedToMagna(entry.Authority, now), fmt.Errorf("nxdomain")

     

       121
       +
       			}

     

       122
       +
       

     

       123
        
       			if msg.Header.ANCount > 0 {

     

       124
        
       				if msg.Answer[0].RType == magna.CNAMEType {

     

       125
       +
       					h.Logger.Debug("following CNAME",

     

       126
       +
       						"cname", msg.Answer[0].RData.String())

     

       127
       +
       

     

       128
       +
       					entry := CreateCacheEntry(&msg, zone)

     

       129
       +
       					h.Cache.Set(cacheKey, entry)

     

       130
       +
       

     

       131
       +
       					answers, auth, err := h.resolveQuestionWithZone(ctx, magna.Question{QName: msg.Answer[0].RData.String(), QType: question.QType, QClass: question.QClass}, h.RootServers, zone)

     

       132
       +
       					if err == nil {

     

       133
       +
       						return append(msg.Answer, answers...), auth, nil

     

       134
        
       					}

     

       135
       +
       

     

       136
       +
       					return nil, auth, err

     

       137
        
       				}

     

       138
        
       

     

       139
       +
       				entry := CreateCacheEntry(&msg, zone)

     

       140
       +
       				h.Cache.Set(cacheKey, entry)

     

       141
       +
       				return msg.Answer, nil, nil

     

       142
        
       			}

     

       143
        
       

     

       144
        
       			if msg.Header.ARCount > 0 {

     
···

       149
        
       					}

     

       150
        
       				}

     

       151
        
       

     

       152
       +
       				if len(nextZone) > 0 {

     

       153
       +
       					return h.resolveQuestion(ctx, question, nextZone)

     

       154
       +
       				}

     

       155
        
       			}

     

       156
        
       

     

       157
        
       			if msg.Header.NSCount > 0 {

     

       158
       +
       				nsRecords := make(map[string]string)

     

       159
       +
       				glueRecords := make(map[string]string)

     

       160
       +
       

     

       161
       +
       				if msg.Header.ARCount > 0 {

     

       162
       +
       					for _, additional := range msg.Additional {

     

       163
       +
       						if additional.RType == magna.AType {

     

       164
       +
       							rule := determineBailiwickRule(zone, additional.Name)

     

       165
       +
       							if rule != BailiwickOutside {

     

       166
       +
       								glueRecords[additional.Name] = additional.RData.String()

     

       167
       +
       							}

     

       168
        
       						}

     

       169
       +
       					}

     

       170
       +
       				}

     

       171
       +
       

     

       172
       +
       				var nextServers []string

     

       173
       +
       				var needResolution []string

     

       174
       +
       

     

       175
       +
       				for _, auth := range msg.Authority {

     

       176
       +
       					if auth.RType == magna.NSType {

     

       177
       +
       						rule := determineBailiwickRule(zone, auth.Name)

     

       178
       +
       						if rule != BailiwickOutside {

     

       179
       +
       							nsName := auth.RData.String()

     

       180
       +
       							nsRecords[nsName] = ""

     

       181
       +
       

     

       182
       +
       							if ip, exists := glueRecords[nsName]; exists {

     

       183
       +
       								nextServers = append(nextServers, ip)

     

       184
       +
       							} else {

     

       185
       +
       								needResolution = append(needResolution, nsName)

     

       186
       +
       							}

     

       187
        
       						}

     

       188
        
       					}

     

       189
        
       				}

     

       190
        
       

     

       191
       +
       				if len(nextServers) > 0 {

     

       192
       +
       					h.Logger.Debug("using glue records for resolution",

     

       193
       +
       						"servers", nextServers)

     

       194
       +
       					return h.resolveQuestionWithZone(ctx, question, nextServers, zone)

     

       195
       +
       				}

     

       196
       +
       

     

       197
       +
       				for _, ns := range needResolution {

     

       198
       +
       					answers, _, err := h.resolveQuestionWithZone(

     

       199
       +
       						ctx,

     

       200
       +
       						magna.Question{

     

       201
       +
       							QName:  ns,

     

       202
       +
       							QType:  magna.AType,

     

       203
       +
       							QClass: magna.IN,

     

       204
       +
       						},

     

       205
       +
       						h.RootServers,

     

       206
       +
       						zone,

     

       207
       +
       					)

     

       208
       +
       					if err == nil {

     

       209
       +
       						for _, ans := range answers {

     

       210
       +
       							nextServers = append(nextServers, ans.RData.String())

     

       211
       +
       						}

     

       212
       +
       					}

     

       213
       +
       				}

     

       214
       +
       

     

       215
       +
       				if len(nextServers) > 0 {

     

       216
       +
       					return h.resolveQuestionWithZone(ctx, question, nextServers, zone)

     

       217
       +
       				}

     

       218
        
       			}

     

       219
        
       

     

       220
       +
       		case <-ctx.Done():

     

       221
       +
       			return nil, nil, ctx.Err()

     

       0
        
       
     

       222
        
       		}

     

       223
        
       	}

     

       224
        
       

     

       225
       +
       	return nil, nil, fmt.Errorf("all queries failed")

     

       226
        
       }

     

       227
        
       

     

       228
        
       func queryServer(ctx context.Context, question magna.Question, server string, ch chan<- queryResponse, timeout time.Duration) {

     
···

       269
        
       		ch <- queryResponse{Server: server, Error: fmt.Errorf("timeout")}

     

       270
        
       	}

     

       271
        
       }

     

       272
       +
       

     

       273
       +
       func convertCachedToMagna(cached []CachedResourceRecord, now time.Time) []magna.ResourceRecord {

     

       274
       +
       	result := make([]magna.ResourceRecord, 0, len(cached))

     

       275
       +
       	for _, record := range cached {

     

       276
       +
       		if now.Before(record.ExpireAt) {

     

       277
       +
       			rr := record.Record

     

       278
       +
       			rr.TTL = uint32(record.ExpireAt.Sub(now).Seconds())

     

       279
       +
       			result = append(result, rr)

     

       280
       +
       		}

     

       281
       +
       	}

     

       282
       +
       	return result

     

       283
       +
       }

     

       284
       +
       

     

       285
       +
       func getCurrentRequest(ctx context.Context) *Request {

     

       286
       +
       	log.Println(ctx)

     

       287
       +
       	if ctx == nil {

     

       288
       +
       		log.Println(">>>>")

     

       289
       +
       		return nil

     

       290
       +
       	}

     

       291
       +
       	if r, ok := ctx.Value(contextKey("request")).(*Request); ok {

     

       292
       +
       		log.Println("<<<<")

     

       293
       +
       		return r

     

       294
       +
       	}

     

       295
       +
       	log.Println("====")

     

       296
       +
       	return nil

     

       297
       +
       }

+35 -5

pkg/dns/server.go

···

       1
        
       package dns

     

       2
        
       

     

       3
        
       import (

     

       0
        
       
     

       4
        
       	"encoding/binary"

     

       5
        
       	"fmt"

     

       6
        
       	"io"

     

       0
        
       
     

       7
        
       	"log/slog"

     

       8
        
       	"net"

     

       9
        
       	"sync"

     
···

       12
        
       	"code.kiri.systems/kiri/magna"

     

       13
        
       )

     

       14
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       15
        
       type Handler interface {

     

       16
        
       	ServeDNS(ResponseWriter, *Request)

     

       17
        
       }

     
···

       23
        
       }

     

       24
        
       

     

       25
        
       type Request struct {

     

       0
        
       
     

       26
        
       	RemoteAddr net.Addr

     

       27
        
       	Message    *magna.Message

     

       28
        
       }

     
···

       89
        
       	ReadTimeout  time.Duration

     

       90
        
       	WriteTimeout time.Duration

     

       91
        
       	Logger       *slog.Logger

     

       92
       -
       	Cache        Cache

     

       93
        
       }

     

       94
        
       

     

       95
        
       func (srv *Server) ListenAndServe() error {

     
···

       184
        
       	for {

     

       185
        
       		conn, err := listener.Accept()

     

       186
        
       		if err != nil {

     

       187
       -
       			srv.Logger.Warn("tcp accept error:", err)

     

       188
        
       			continue

     

       189
        
       		}

     

       190
        
       

     
···

       203
        
       

     

       204
        
       	sizeBuffer := make([]byte, 2)

     

       205
        
       	if _, err := io.ReadFull(conn, sizeBuffer); err != nil {

     

       206
       -
       		srv.Logger.Warn("tcp-error", err)

     

       207
        
       		return

     

       208
        
       	}

     

       209
        
       

     

       210
        
       	size := binary.BigEndian.Uint16(sizeBuffer)

     

       211
        
       	data := make([]byte, size)

     

       212
        
       	if _, err := io.ReadFull(conn, data); err != nil {

     

       213
       -
       		srv.Logger.Warn("tcp-error", err)

     

       214
        
       		return

     

       215
        
       	}

     

       216
        
       

     
···

       226
        
       func (srv *Server) handleQuery(messageBuffer []byte, w ResponseWriter, remoteAddr net.Addr) {

     

       227
        
       	var query magna.Message

     

       228
        
       	if err := query.Decode(messageBuffer); err != nil {

     

       229
       -
       		srv.Logger.Warn("decode error", err)

     

       230
        
       		return

     

       231
        
       	}

     

       232
        
       

     
···

       234
        
       		Message:    &query,

     

       235
        
       		RemoteAddr: remoteAddr,

     

       236
        
       	}

     

       0
        
       
     

       0
        
       
     

       237
        
       

     

       238
        
       	srv.Handler.ServeDNS(w, r)

     

       239
        
       }

···

       1
        
       package dns

     

       2
        
       

     

       3
        
       import (

     

       4
       +
       	"context"

     

       5
        
       	"encoding/binary"

     

       6
        
       	"fmt"

     

       7
        
       	"io"

     

       8
       +
       	"log"

     

       9
        
       	"log/slog"

     

       10
        
       	"net"

     

       11
        
       	"sync"

     
···

       14
        
       	"code.kiri.systems/kiri/magna"

     

       15
        
       )

     

       16
        
       

     

       17
       +
       type contextKey string

     

       18
       +
       

     

       19
       +
       const (

     

       20
       +
       	cacheHitKey contextKey = "cache_hit"

     

       21
       +
       )

     

       22
       +
       

     

       23
       +
       func setCacheHit(ctx context.Context) context.Context {

     

       24
       +
       	log.Println("setting to true")

     

       25
       +
       	return context.WithValue(ctx, cacheHitKey, true)

     

       26
       +
       }

     

       27
       +
       

     

       28
       +
       func setCacheMiss(ctx context.Context) context.Context {

     

       29
       +
       	log.Println("setting to false")

     

       30
       +
       	return context.WithValue(ctx, cacheHitKey, false)

     

       31
       +
       }

     

       32
       +
       

     

       33
       +
       func GetCacheHit(ctx context.Context) bool {

     

       34
       +
       	v := ctx.Value(cacheHitKey)

     

       35
       +
       	if v == nil {

     

       36
       +
       		return false

     

       37
       +
       	}

     

       38
       +
       

     

       39
       +
       	return v.(bool)

     

       40
       +
       }

     

       41
       +
       

     

       42
        
       type Handler interface {

     

       43
        
       	ServeDNS(ResponseWriter, *Request)

     

       44
        
       }

     
···

       50
        
       }

     

       51
        
       

     

       52
        
       type Request struct {

     

       53
       +
       	Context    context.Context

     

       54
        
       	RemoteAddr net.Addr

     

       55
        
       	Message    *magna.Message

     

       56
        
       }

     
···

       117
        
       	ReadTimeout  time.Duration

     

       118
        
       	WriteTimeout time.Duration

     

       119
        
       	Logger       *slog.Logger

     

       120
       +
       	Cache        *MemoryCache

     

       121
        
       }

     

       122
        
       

     

       123
        
       func (srv *Server) ListenAndServe() error {

     
···

       212
        
       	for {

     

       213
        
       		conn, err := listener.Accept()

     

       214
        
       		if err != nil {

     

       215
       +
       			srv.Logger.Warn("tcp accept error:", "error", err)

     

       216
        
       			continue

     

       217
        
       		}

     

       218
        
       

     
···

       231
        
       

     

       232
        
       	sizeBuffer := make([]byte, 2)

     

       233
        
       	if _, err := io.ReadFull(conn, sizeBuffer); err != nil {

     

       234
       +
       		srv.Logger.Warn("tcp error occurred", "error", err)

     

       235
        
       		return

     

       236
        
       	}

     

       237
        
       

     

       238
        
       	size := binary.BigEndian.Uint16(sizeBuffer)

     

       239
        
       	data := make([]byte, size)

     

       240
        
       	if _, err := io.ReadFull(conn, data); err != nil {

     

       241
       +
       		srv.Logger.Warn("tcp error occurred", "error", err)

     

       242
        
       		return

     

       243
        
       	}

     

       244
        
       

     
···

       254
        
       func (srv *Server) handleQuery(messageBuffer []byte, w ResponseWriter, remoteAddr net.Addr) {

     

       255
        
       	var query magna.Message

     

       256
        
       	if err := query.Decode(messageBuffer); err != nil {

     

       257
       +
       		srv.Logger.Warn("message decode error", "error", err)

     

       258
        
       		return

     

       259
        
       	}

     

       260
        
       

     
···

       262
        
       		Message:    &query,

     

       263
        
       		RemoteAddr: remoteAddr,

     

       264
        
       	}

     

       265
       +
       

     

       266
       +
         r.Context = context.WithValue(context.Background(), contextKey("request"), r)

     

       267
        
       

     

       268
        
       	srv.Handler.ServeDNS(w, r)

     

       269
        
       }

+230

pkg/metrics/clickhouse.go

···

       1
       +
       package metrics

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"database/sql"

     

       5
       +
       	"fmt"

     

       6
       +
       	"log"

     

       7
       +
       	"log/slog"

     

       8
       +
       	"sync"

     

       9
       +
       	"time"

     

       10
       +
       

     

       11
       +
       	_ "github.com/ClickHouse/clickhouse-go/v2"

     

       12
       +
       

     

       13
       +
       	"code.kiri.systems/kiri/alky/pkg/config"

     

       14
       +
       	"code.kiri.systems/kiri/alky/pkg/dns"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       type ClickHouseMetrics struct {

     

       18
       +
       	db          *sql.DB

     

       19
       +
       	config      *config.MetricsConfig

     

       20
       +
       	queryBuffer []QueryMetric

     

       21
       +
       	cacheBuffer []CacheMetric

     

       22
       +
       	mu          sync.Mutex

     

       23
       +
       	stopChan    chan struct{}

     

       24
       +
       	logger      *slog.Logger

     

       25
       +
       }

     

       26
       +
       

     

       27
       +
       type QueryMetric struct {

     

       28
       +
       	Timestamp    time.Time

     

       29
       +
       	InstanceID   string

     

       30
       +
       	QueryName    string

     

       31
       +
       	QueryType    string

     

       32
       +
       	QueryClass   string

     

       33
       +
       	RemoteAddr   string

     

       34
       +
       	ResponseCode string

     

       35
       +
       	Duration     int64

     

       36
       +
       	CacheHit     bool

     

       37
       +
       }

     

       38
       +
       

     

       39
       +
       type CacheMetric struct {

     

       40
       +
       	Timestamp    time.Time

     

       41
       +
       	TotalQueries int64

     

       42
       +
       	CacheHits    int64

     

       43
       +
       	CacheMisses  int64

     

       44
       +
       	NegativeHits int64

     

       45
       +
       }

     

       46
       +
       

     

       47
       +
       func NewClickHouseMetrics(config *config.MetricsConfig, logger *slog.Logger) (*ClickHouseMetrics, error) {

     

       48
       +
       	db, err := sql.Open("clickhouse", config.DSN)

     

       49
       +
       	if err != nil {

     

       50
       +
       		return nil, fmt.Errorf("failed to connect to ClickHouse: %w", err)

     

       51
       +
       	}

     

       52
       +
       

     

       53
       +
       	m := &ClickHouseMetrics{

     

       54
       +
       		db:          db,

     

       55
       +
       		config:      config,

     

       56
       +
       		queryBuffer: make([]QueryMetric, 0, config.BatchSize),

     

       57
       +
       		cacheBuffer: make([]CacheMetric, 0, config.BatchSize),

     

       58
       +
       		stopChan:    make(chan struct{}),

     

       59
       +
       		logger:      logger,

     

       60
       +
       	}

     

       61
       +
       

     

       62
       +
       	if err := m.changeTTL(); err != nil {

     

       63
       +
       		db.Close()

     

       64
       +
       		return nil, fmt.Errorf("failed to initialize tables: %w", err)

     

       65
       +
       	}

     

       66
       +
       

     

       67
       +
       	go m.flushLoop()

     

       68
       +
       	return m, nil

     

       69
       +
       }

     

       70
       +
       

     

       71
       +
       func (m *ClickHouseMetrics) RecordQuery(metric QueryMetric) {

     

       72
       +
       	m.mu.Lock()

     

       73
       +
       	defer m.mu.Unlock()

     

       74
       +
       

     

       75
       +
       	m.queryBuffer = append(m.queryBuffer, metric)

     

       76
       +
       	if len(m.queryBuffer) >= m.config.BatchSize {

     

       77
       +
       		m.flush()

     

       78
       +
       	}

     

       79
       +
       }

     

       80
       +
       

     

       81
       +
       func (m *ClickHouseMetrics) RecordCacheMetrics(metric CacheMetric) {

     

       82
       +
       	m.mu.Lock()

     

       83
       +
       	defer m.mu.Unlock()

     

       84
       +
       

     

       85
       +
       	m.cacheBuffer = append(m.cacheBuffer, metric)

     

       86
       +
       	if len(m.cacheBuffer) >= m.config.BatchSize {

     

       87
       +
       		m.flush()

     

       88
       +
       	}

     

       89
       +
       }

     

       90
       +
       

     

       91
       +
       func (m *ClickHouseMetrics) RecordCacheStats(stats *dns.CacheStats) {

     

       92
       +
       	m.RecordCacheMetrics(CacheMetric{

     

       93
       +
       		Timestamp:    time.Now(),

     

       94
       +
       		TotalQueries: stats.TotalQueries,

     

       95
       +
       		CacheHits:    stats.CacheHits,

     

       96
       +
       		CacheMisses:  stats.CacheMisses,

     

       97
       +
       		NegativeHits: stats.NegativeHits,

     

       98
       +
       	})

     

       99
       +
       }

     

       100
       +
       

     

       101
       +
       func (m *ClickHouseMetrics) flushLoop() {

     

       102
       +
       	ticker := time.NewTicker(m.config.FlushInterval.Duration)

     

       103
       +
       	defer ticker.Stop()

     

       104
       +
       

     

       105
       +
       	for {

     

       106
       +
       		select {

     

       107
       +
       		case <-ticker.C:

     

       108
       +
       			m.mu.Lock()

     

       109
       +
       			m.flush()

     

       110
       +
       			m.mu.Unlock()

     

       111
       +
       		case <-m.stopChan:

     

       112
       +
       			return

     

       113
       +
       		}

     

       114
       +
       	}

     

       115
       +
       }

     

       116
       +
       

     

       117
       +
       func (m *ClickHouseMetrics) flush() {

     

       118
       +
       	if len(m.queryBuffer) > 0 {

     

       119
       +
       		if err := m.flushQueries(); err != nil {

     

       120
       +
       			m.logger.Error("Failed to flush query metrics", "error", err)

     

       121
       +
       		}

     

       122
       +
       		m.queryBuffer = m.queryBuffer[:0]

     

       123
       +
       	}

     

       124
       +
       

     

       125
       +
       	if len(m.cacheBuffer) > 0 {

     

       126
       +
       		if err := m.flushCacheMetrics(); err != nil {

     

       127
       +
       			m.logger.Error("Failed to flush cache metrics", "error", err)

     

       128
       +
       		}

     

       129
       +
       		m.cacheBuffer = m.cacheBuffer[:0]

     

       130
       +
       	}

     

       131
       +
       }

     

       132
       +
       

     

       133
       +
       func (m *ClickHouseMetrics) changeTTL() error {

     

       134
       +
       	if _, err := m.db.Exec(

     

       135
       +
       		"ALTER TABLE alky_dns_queries MODIFY TTL timestamp + toIntervalSecond(?)",

     

       136
       +
       		int(m.config.RetentionPeriod.Seconds()),

     

       137
       +
       	); err != nil {

     

       138
       +
       		return fmt.Errorf("failed to update alky_dns_queries TTL: %w", err)

     

       139
       +
       	}

     

       140
       +
       

     

       141
       +
       	if _, err := m.db.Exec(

     

       142
       +
       		"ALTER TABLE alky_dns_cache_metrics MODIFY TTL timestamp + toIntervalSecond(?)",

     

       143
       +
       		int(m.config.RetentionPeriod.Seconds()),

     

       144
       +
       	); err != nil {

     

       145
       +
       		return fmt.Errorf("failed to update alky_dns_cache_metrics TTL: %w", err)

     

       146
       +
       	}

     

       147
       +
       

     

       148
       +
       	return nil

     

       149
       +
       }

     

       150
       +
       

     

       151
       +
       func (m *ClickHouseMetrics) flushQueries() error {

     

       152
       +
       	tx, err := m.db.Begin()

     

       153
       +
       	if err != nil {

     

       154
       +
       		return err

     

       155
       +
       	}

     

       156
       +
       	defer tx.Rollback()

     

       157
       +
       

     

       158
       +
       	stmt, err := tx.Prepare(`

     

       159
       +
       		INSERT INTO alky_dns_queries (

     

       160
       +
       			timestamp, instance_id, query_name, query_type, query_class,

     

       161
       +
       			remote_addr, response_code, duration, cache_hit

     

       162
       +
       		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)

     

       163
       +
       	`)

     

       164
       +
       	if err != nil {

     

       165
       +
       		return err

     

       166
       +
       	}

     

       167
       +
       	defer stmt.Close()

     

       168
       +
       

     

       169
       +
       	for _, metric := range m.queryBuffer {

     

       170
       +
       		log.Println(metric)

     

       171
       +
       		_, err := stmt.Exec(

     

       172
       +
       			metric.Timestamp,

     

       173
       +
       			metric.InstanceID,

     

       174
       +
       			metric.QueryName,

     

       175
       +
       			metric.QueryType,

     

       176
       +
       			metric.QueryClass,

     

       177
       +
       			metric.RemoteAddr,

     

       178
       +
       			metric.ResponseCode,

     

       179
       +
       			metric.Duration,

     

       180
       +
       			metric.CacheHit,

     

       181
       +
       		)

     

       182
       +
       		if err != nil {

     

       183
       +
       			return err

     

       184
       +
       		}

     

       185
       +
       	}

     

       186
       +
       

     

       187
       +
       	return tx.Commit()

     

       188
       +
       }

     

       189
       +
       

     

       190
       +
       func (m *ClickHouseMetrics) flushCacheMetrics() error {

     

       191
       +
       	tx, err := m.db.Begin()

     

       192
       +
       	if err != nil {

     

       193
       +
       		return err

     

       194
       +
       	}

     

       195
       +
       	defer tx.Rollback()

     

       196
       +
       

     

       197
       +
       	stmt, err := tx.Prepare(`

     

       198
       +
       		INSERT INTO alky_dns_cache_metrics (

     

       199
       +
       			timestamp, total_queries, cache_hits, cache_misses,

     

       200
       +
       			negative_hits 

     

       201
       +
       		) VALUES (?, ?, ?, ?, ?)

     

       202
       +
       	`)

     

       203
       +
       	if err != nil {

     

       204
       +
       		return err

     

       205
       +
       	}

     

       206
       +
       	defer stmt.Close()

     

       207
       +
       

     

       208
       +
       	for _, metric := range m.cacheBuffer {

     

       209
       +
       		_, err := stmt.Exec(

     

       210
       +
       			metric.Timestamp,

     

       211
       +
       			metric.TotalQueries,

     

       212
       +
       			metric.CacheHits,

     

       213
       +
       			metric.CacheMisses,

     

       214
       +
       			metric.NegativeHits,

     

       215
       +
       		)

     

       216
       +
       		if err != nil {

     

       217
       +
       			return err

     

       218
       +
       		}

     

       219
       +
       	}

     

       220
       +
       

     

       221
       +
       	return tx.Commit()

     

       222
       +
       }

     

       223
       +
       

     

       224
       +
       func (m *ClickHouseMetrics) Close() error {

     

       225
       +
       	close(m.stopChan)

     

       226
       +
       	m.mu.Lock()

     

       227
       +
       	defer m.mu.Unlock()

     

       228
       +
       	m.flush()

     

       229
       +
       	return m.db.Close()

     

       230
       +
       }

+60

pkg/metrics/middleware.go

···

       1
       +
       package metrics

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"context"

     

       5
       +
       	"fmt"

     

       6
       +
       	"log"

     

       7
       +
       	"os"

     

       8
       +
       	"time"

     

       9
       +
       

     

       10
       +
       	"code.kiri.systems/kiri/alky/pkg/dns"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       var (

     

       14
       +
       	hostID  string

     

       15
       +
       	version string

     

       16
       +
       )

     

       17
       +
       

     

       18
       +
       func init() {

     

       19
       +
       	var err error

     

       20
       +
       	hostname, err := os.Hostname()

     

       21
       +
       	if err != nil {

     

       22
       +
       		hostname = "unknown"

     

       23
       +
       	}

     

       24
       +
       

     

       25
       +
       	if version != "" {

     

       26
       +
       		hostID = fmt.Sprintf("%s-%s", hostname, version)

     

       27
       +
       	} else {

     

       28
       +
       		hostID = hostname

     

       29
       +
       	}

     

       30
       +
       }

     

       31
       +
       

     

       32
       +
       func MetricsMiddleware(metrics *ClickHouseMetrics) func(dns.Handler) dns.Handler {

     

       33
       +
       	return func(next dns.Handler) dns.Handler {

     

       34
       +
       		return dns.HandlerFunc(func(w dns.ResponseWriter, r *dns.Request) {

     

       35
       +
       			if r.Context == nil {

     

       36
       +
       				r.Context = context.Background()

     

       37
       +
       			}

     

       38
       +
       

     

       39
       +
       			start := time.Now()

     

       40
       +
       			next.ServeDNS(w, r)

     

       41
       +
       			duration := time.Since(start)

     

       42
       +
       

     

       43
       +
       			question := r.Message.Question[0]

     

       44
       +
       			log.Println(hostID)

     

       45
       +
       			log.Println(dns.GetCacheHit(r.Context))

     

       46
       +
       

     

       47
       +
       			metrics.RecordQuery(QueryMetric{

     

       48
       +
       				Timestamp:    time.Now(),

     

       49
       +
       				InstanceID:   hostID,

     

       50
       +
       				QueryName:    question.QName,

     

       51
       +
       				QueryType:    question.QType.String(),

     

       52
       +
       				QueryClass:   question.QClass.String(),

     

       53
       +
       				RemoteAddr:   r.RemoteAddr.String(),

     

       54
       +
       				ResponseCode: r.Message.Header.RCode.String(),

     

       55
       +
       				Duration:     duration.Nanoseconds(),

     

       56
       +
       				CacheHit:     dns.GetCacheHit(r.Context),

     

       57
       +
       			})

     

       58
       +
       		})

     

       59
       +
       	}

     

       60
       +
       }