From 09781d6871eead8ca07e8327669e21ce6362f362 Mon Sep 17 00:00:00 2001 From: Aryan Mehrotra Date: Wed, 2 Sep 2026 18:44:45 +0530 Subject: [PATCH 01/48] Merge pull request #4147 from gofr-dev/chore/gcp-exporter-pin-v1.60.1 chore(metrics): pin gcp exporter to gofr.dev v1.60.1 --- pkg/gofr/metrics/exporters/gcp/go.mod | 24 ++++++------- pkg/gofr/metrics/exporters/gcp/go.sum | 52 +++++++++++++-------------- 2 files changed, 38 insertions(+), 38 deletions(-) diff --git a/pkg/gofr/metrics/exporters/gcp/go.mod b/pkg/gofr/metrics/exporters/gcp/go.mod index a47d839133..4c1ff08324 100644 --- a/pkg/gofr/metrics/exporters/gcp/go.mod +++ b/pkg/gofr/metrics/exporters/gcp/go.mod @@ -4,11 +4,11 @@ go 1.26.0 require ( go.opentelemetry.io/contrib/detectors/gcp v1.44.0 - go.opentelemetry.io/otel v1.44.0 + go.opentelemetry.io/otel v1.45.0 go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0 - go.opentelemetry.io/otel/sdk v1.44.0 - go.opentelemetry.io/otel/sdk/metric v1.44.0 - gofr.dev v1.59.0 + go.opentelemetry.io/otel/sdk v1.45.0 + go.opentelemetry.io/otel/sdk/metric v1.45.0 + gofr.dev v1.60.1 golang.org/x/oauth2 v0.36.0 google.golang.org/grpc v1.83.0 ) @@ -19,26 +19,26 @@ require ( github.com/beorn7/perks v1.0.1 // indirect github.com/cenkalti/backoff/v5 v5.0.3 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/google/uuid v1.6.0 // indirect github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect - github.com/prometheus/client_golang v1.24.0 // indirect + github.com/prometheus/client_golang v1.24.1 // indirect github.com/prometheus/client_model v0.6.2 // indirect - github.com/prometheus/common v0.70.0 // indirect + github.com/prometheus/common v0.70.1 // indirect github.com/prometheus/otlptranslator v1.0.0 // indirect github.com/prometheus/procfs v0.21.1 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.44.0 // indirect - go.opentelemetry.io/otel/exporters/prometheus v0.65.0 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - go.opentelemetry.io/otel/trace v1.44.0 // indirect + go.opentelemetry.io/otel/exporters/prometheus v0.67.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/trace v1.45.0 // indirect go.opentelemetry.io/proto/otlp v1.10.0 // indirect golang.org/x/net v0.57.0 // indirect golang.org/x/sys v0.47.0 // indirect - golang.org/x/text v0.40.0 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20260630182238-925bb5da69e7 // indirect + golang.org/x/text v0.41.0 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect google.golang.org/protobuf v1.36.11 // indirect ) diff --git a/pkg/gofr/metrics/exporters/gcp/go.sum b/pkg/gofr/metrics/exporters/gcp/go.sum index bd8844eedf..1d752c4776 100644 --- a/pkg/gofr/metrics/exporters/gcp/go.sum +++ b/pkg/gofr/metrics/exporters/gcp/go.sum @@ -11,8 +11,8 @@ github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XL github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= @@ -29,12 +29,12 @@ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v1.24.0 h1:5XStIklKuAtJSNpdD3s8XJj/Yv78IQmE1kbNk87JrAI= -github.com/prometheus/client_golang v1.24.0/go.mod h1:QcsNdotprC2nS4BTM2ucbcqxd2CeXTEa9jW7zHO9iDE= +github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU= +github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE= github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= -github.com/prometheus/common v0.70.0 h1:bcpru3tWPVnxGnETLgOV5jbp/JRXgYEyv65CuBLAMMI= -github.com/prometheus/common v0.70.0/go.mod h1:S/SFasQmgGiYH6C81LKCtYa8QACgthGg5zxL2udV7SY= +github.com/prometheus/common v0.70.1 h1:1HvjP4D5oL3t8RsPlwxA9onvvStjtIHYE5XuuwOi/PY= +github.com/prometheus/common v0.70.1/go.mod h1:VdFUQDMZK3VLkurFUVhia6uys/0suUp86TJz5qbJRhc= github.com/prometheus/otlptranslator v1.0.0 h1:s0LJW/iN9dkIH+EnhiD3BlkkP5QVIUVEoIwkU+A6qos= github.com/prometheus/otlptranslator v1.0.0/go.mod h1:vRYWnXvI6aWGpsdY/mOT/cbeVRBlPWtBNDb7kGR3uKM= github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI= @@ -45,32 +45,32 @@ go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/contrib/detectors/gcp v1.44.0 h1:NmLfL734pJhM0JKaYd2Y28+nY9dPRWYAAbxhRCrKXPw= go.opentelemetry.io/contrib/detectors/gcp v1.44.0/go.mod h1:tNAsgd8avTGke1+MndXlU5Cru4PQ9Ai/cCNWQv/ZJ/s= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0 h1:SUplec5dp06reu1zaXmOXdvqH398taqrDXqUl99jxSc= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0/go.mod h1:ho2g4N+ane+swq5I/VBkKWnRDY4kUINH3FuqyZqX/Ug= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.44.0 h1:RuynHbfU8JUEw7DyONgkVYg2SVtsoF28y0LGIr69jgA= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.44.0/go.mod h1:qZF+/lBs71APw8mlnEZcqZHMzqrYrsFiJOv83lX1OGo= -go.opentelemetry.io/otel/exporters/prometheus v0.65.0 h1:jOveH/b4lU9HT7y+Gfamf18BqlOuz2PWEvs8yM7Q6XE= -go.opentelemetry.io/otel/exporters/prometheus v0.65.0/go.mod h1:i1P8pcumauPtUI4YNopea1dhzEMuEqWP1xoUZDylLHo= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/metric/x v0.66.0 h1:YkCrx1zLOChi9ZcZ6euupOcsgzbVlec7D/xoEU1+cTA= -go.opentelemetry.io/otel/metric/x v0.66.0/go.mod h1:d1+BDj9t96do0/1LoU1ayfCv79ZgNE41qbhBvnMOBZk= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= -go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel/exporters/prometheus v0.67.0 h1:7IefDa35e6V3NoiqIeLDMDxMFyZDk5qcoC0Ax4cC16E= +go.opentelemetry.io/otel/exporters/prometheus v0.67.0/go.mod h1:nsPI1awTg5Vmg1YrommL2mVarVGlqc4yXOoKAkPRD0c= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/metric/x v0.67.0 h1:PcicCNZFkZ4bXfSooXdo3WN7RBOVOtjVdo1wD358Uns= +go.opentelemetry.io/otel/metric/x v0.67.0/go.mod h1:FBjCWZe6wgcqxcMtjdGiClDKXb2YxxXii0CXftE4QtI= +go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= +go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= +go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= +go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.opentelemetry.io/proto/otlp v1.10.0 h1:IQRWgT5srOCYfiWnpqUYz9CVmbO8bFmKcwYxpuCSL2g= go.opentelemetry.io/proto/otlp v1.10.0/go.mod h1:/CV4QoCR/S9yaPj8utp3lvQPoqMtxXdzn7ozvvozVqk= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= -gofr.dev v1.59.0 h1:T5+eoCoKPQK3CosQG4YVv2u9BE4bUeHDM9aZTHWmF24= -gofr.dev v1.59.0/go.mod h1:fYZuaqpiHKByz87XOQkNRiyklsJQE3/NEqDDmaRGEik= +gofr.dev v1.60.1 h1:tgUCh33369oDSQNmcSxVNM+xgFxtCXxA9LZLgUK2m6k= +gofr.dev v1.60.1/go.mod h1:5b56VoXF2ImEkDnYV69ExzRS586o2juu96zJKaRuZL4= golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= @@ -79,12 +79,12 @@ golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= -golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs= -golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/genproto/googleapis/api v0.0.0-20260630182238-925bb5da69e7 h1:jQ9p21COKWjP3VwuFrNRiiOTMh3mPpN45R7SLrH/HUU= -google.golang.org/genproto/googleapis/api v0.0.0-20260630182238-925bb5da69e7/go.mod h1:KqHwBx2upmfa1XSi1WuRvC+2VGCLtooKkfmyvRbUmqA= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= From d4185d113fe655dcb4603ed61196b3f623ad9405 Mon Sep 17 00:00:00 2001 From: Ronan Donnelly Date: Thu, 3 Sep 2026 06:08:10 +0100 Subject: [PATCH 02/48] fix(middleware): require a path separator in the well-known auth exemption (#4099) * fix(middleware): require a path separator in the well-known auth exemption * test(middleware): cover the rate limiter well-known exemption * chore(middleware): satisfy goconst and noctx in the well-known check * docs(auth): describe the separator requirement in the well-known exemption --------- Co-authored-by: Aryan Mehrotra Co-authored-by: Umang Mundhra --- docs/advanced-guide/authentication/page.md | 2 +- pkg/gofr/http/middleware/auth_test.go | 4 ++- pkg/gofr/http/middleware/rate_limiter_test.go | 34 +++++++++++++++++++ pkg/gofr/http/middleware/validate.go | 4 ++- pkg/gofr/http/middleware/validate_test.go | 4 +++ 5 files changed, 45 insertions(+), 3 deletions(-) diff --git a/docs/advanced-guide/authentication/page.md b/docs/advanced-guide/authentication/page.md index c31bad9412..62151fde27 100644 --- a/docs/advanced-guide/authentication/page.md +++ b/docs/advanced-guide/authentication/page.md @@ -17,7 +17,7 @@ applies to both your HTTP and gRPC services. ## Exempted Paths -By default, the authentication middleware exempts every path under `/.well-known/*` from authentication (the middleware's `isWellKnown` check uses `strings.HasPrefix(path, "/.well-known")`). This includes: +By default, the authentication middleware exempts every path under `/.well-known/*` from authentication (the middleware's `isWellKnown` check requires a `/` separator after the prefix, so a path such as `/.well-knownprivate` is not exempt). This includes: - `/.well-known/alive` — liveness probe - `/.well-known/health` — readiness/health probe with the aggregate service status diff --git a/pkg/gofr/http/middleware/auth_test.go b/pkg/gofr/http/middleware/auth_test.go index 565447a565..a1c0db8560 100644 --- a/pkg/gofr/http/middleware/auth_test.go +++ b/pkg/gofr/http/middleware/auth_test.go @@ -24,6 +24,8 @@ func TestAuthMiddleware(t *testing.T) { {url: "/.well-known/health", statusCode: http.StatusOK, expectedBody: `OK`}, {url: "/", success: true, statusCode: http.StatusOK, expectedHeader: "user-header-string", expectedBody: `OK`}, {url: "/", success: false, statusCode: http.StatusUnauthorized, expectedBody: errBody}, + {url: "/.well-knownprivate", success: false, statusCode: http.StatusUnauthorized, expectedBody: errBody}, + {url: "/.well-knownprivate", success: true, statusCode: http.StatusOK, expectedHeader: "user-header-string", expectedBody: `OK`}, } for i, tc := range testCases { t.Run(strconv.Itoa(i), func(t *testing.T) { @@ -44,7 +46,7 @@ func TestAuthMiddleware(t *testing.T) { assert.Equal(t, tc.statusCode == http.StatusOK, mockHandler.handlerCalled) assert.Equal(t, tc.expectedBody, strings.TrimSuffix(rr.Body.String(), "\n")) - if strings.HasPrefix(tc.url, "/.well-known") { + if strings.HasPrefix(tc.url, "/.well-known/") { return } diff --git a/pkg/gofr/http/middleware/rate_limiter_test.go b/pkg/gofr/http/middleware/rate_limiter_test.go index c96fcd4816..aa9a38096a 100644 --- a/pkg/gofr/http/middleware/rate_limiter_test.go +++ b/pkg/gofr/http/middleware/rate_limiter_test.go @@ -143,6 +143,40 @@ func TestRateLimiter_SkipHealthEndpoints(t *testing.T) { } } +func TestRateLimiter_WellKnownPrefixIsRateLimited(t *testing.T) { + metrics := newRateLimiterMockMetrics() + config := RateLimiterConfig{ + RequestsPerSecond: 1, + Burst: 1, + PerIP: false, + } + + handler := RateLimiter(config, metrics)(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusOK) + })) + + // A path that only shares the well-known prefix is not exempt, so it consumes the bucket + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/.well-knownprivate", http.NoBody) + rr := httptest.NewRecorder() + handler.ServeHTTP(rr, req) + assert.Equal(t, http.StatusOK, rr.Code, "First request should succeed") + + req = httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/.well-knownprivate", http.NoBody) + rr = httptest.NewRecorder() + handler.ServeHTTP(rr, req) + assert.Equal(t, http.StatusTooManyRequests, rr.Code, "Prefixed path should be rate limited") + + assert.Equal(t, 1, metrics.GetCounter("app_http_rate_limit_exceeded_total")) + + // Genuine well-known endpoints stay exempt even once the bucket is empty + for i := 0; i < 5; i++ { + req = httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/.well-known/alive", http.NoBody) + rr = httptest.NewRecorder() + handler.ServeHTTP(rr, req) + assert.Equal(t, http.StatusOK, rr.Code, "Well-known endpoint should not be rate limited") + } +} + func TestRateLimiter_ConcurrentRequests(t *testing.T) { metrics := newRateLimiterMockMetrics() config := RateLimiterConfig{ diff --git a/pkg/gofr/http/middleware/validate.go b/pkg/gofr/http/middleware/validate.go index be019aaad9..4c8f711c5b 100644 --- a/pkg/gofr/http/middleware/validate.go +++ b/pkg/gofr/http/middleware/validate.go @@ -2,6 +2,8 @@ package middleware import "strings" +const wellKnownPrefix = "/.well-known" + func isWellKnown(path string) bool { - return strings.HasPrefix(path, "/.well-known") + return path == wellKnownPrefix || strings.HasPrefix(path, wellKnownPrefix+"/") } diff --git a/pkg/gofr/http/middleware/validate_test.go b/pkg/gofr/http/middleware/validate_test.go index cbbf322222..bee7daa03d 100644 --- a/pkg/gofr/http/middleware/validate_test.go +++ b/pkg/gofr/http/middleware/validate_test.go @@ -16,6 +16,10 @@ func Test_isWellKnown(t *testing.T) { {"sample endpoint", "/sample", false}, {"health-check endpoint", "/.well-known/health-check", true}, {"alive endpoint", "/.well-known/alive", true}, + {"well-known root", "/.well-known", true}, + {"prefixed endpoint without separator", "/.well-knownprivate", false}, + {"prefixed endpoint with sub path", "/.well-knownprivate/secret", false}, + {"well-known not at the start of the path", "/api/.well-known/alive", false}, } for i, tc := range tests { From a513230c0b3599d95c05adb8950b734ebce1a806 Mon Sep 17 00:00:00 2001 From: Aryan Mehrotra Date: Thu, 3 Sep 2026 12:22:42 +0530 Subject: [PATCH 03/48] perf(metrics): build the measurement option once per route, method and status (#3972) --- pkg/gofr/http/middleware/metrics.go | 284 ++++++++++++++------- pkg/gofr/http/middleware/metrics_test.go | 298 ++++++++++++++++++++++- pkg/gofr/http/middleware/routecache.go | 34 ++- pkg/gofr/http/middleware/tracer.go | 12 +- pkg/gofr/http/middleware/tracer_test.go | 2 +- pkg/gofr/metrics/register.go | 26 ++ pkg/gofr/metrics/register_test.go | 68 ++++++ 7 files changed, 620 insertions(+), 104 deletions(-) diff --git a/pkg/gofr/http/middleware/metrics.go b/pkg/gofr/http/middleware/metrics.go index 7bf6c883a5..cf8e24999f 100644 --- a/pkg/gofr/http/middleware/metrics.go +++ b/pkg/gofr/http/middleware/metrics.go @@ -2,7 +2,6 @@ package middleware import ( "context" - "fmt" "net/http" "path/filepath" "strconv" @@ -11,6 +10,7 @@ import ( "time" "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/metric" gofrhttp "gofr.dev/pkg/gofr/http" ) @@ -46,38 +46,10 @@ const graphqlPath = "/graphql" // Metrics is a middleware that records request response time metrics using the provided metrics interface. func Metrics(metrics metrics) func(inner http.Handler) http.Handler { - // Per-middleware-instance caches (closure-owned, not package globals): - // * routeAttrs maps (path, method) → [path-kv, method-kv]. The slice is - // built once per unique route-method combination and reused for every - // subsequent request. Bounded by routes × methods (typically <100 - // entries even for large APIs). - // * statusAttrs maps int → attribute.KeyValue for the http status code. - // Bounded by ~20 distinct status codes seen in practice. - // * attrer is the type-asserted fast-path receiver, captured once if - // available. - var ( - routeAttrs sync.Map // map[routeMethodKey][]attribute.KeyValue - statusAttrs sync.Map // map[int]attribute.KeyValue - ) - - // Cache the status attribute with a string value (not Int) so the - // fast path matches the slow path's varargs label type. - // metricsManager.getAttributes emits status as a string for the slow - // path, and OTLP exporters distinguish KeyValue types — a mismatch - // would break user queries expecting the label to be a string across - // both code paths. - statusAttr := func(code int) attribute.KeyValue { - if v, ok := statusAttrs.Load(code); ok { - return v.(attribute.KeyValue) - } - - kv := attribute.String("status", strconv.Itoa(code)) - statusAttrs.Store(code, kv) - - return kv - } - - attrer, hasAttrer := metrics.(metricsAttrer) + // The recording strategy is selected once, here, from what the metrics + // backend supports. The per-request path then makes a single call and + // carries none of that branching itself. + recorder := newHistogramRecorder(metrics) return func(inner http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { @@ -90,28 +62,7 @@ func Metrics(metrics metrics) func(inner http.Handler) http.Handler { srw = &StatusResponseWriter{ResponseWriter: w} } - // Resolve the route template for the metric label via the - // router-agnostic accessor (it reads the trie router's context key - // or mux.CurrentRoute, whichever applies). It is "" for unmatched - // routes and for routes built without an explicit Path() (e.g. - // PathPrefix-only handlers), so fall back to r.URL.Path there to - // keep a usable path label rather than an empty key. - path := gofrhttp.RouteTemplate(r) - if path == "" { - path = r.URL.Path - } - - ext := strings.ToLower(filepath.Ext(r.URL.Path)) - switch ext { - case ".css", ".js", ".png", ".jpg", ".jpeg", ".gif", ".ico", ".svg", ".txt", ".html", ".json", ".woff", ".woff2", ".ttf", ".eot", ".pdf": - path = r.URL.Path - } - - if path == "/" || strings.HasPrefix(path, "/static") { - path = r.URL.Path - } - - path = strings.TrimSuffix(path, "/") + path, templated := metricsPath(r) // Skip recording for /graphql — it has its own dedicated metrics // (app_graphql_*). time.Now() (vDSO call) is deferred past this @@ -126,41 +77,202 @@ func Metrics(metrics metrics) func(inner http.Handler) http.Handler { // this has to be called in the end so that status code is populated. // res.Status() normalizes a zero internal status (handler wrote // nothing, net/http implicit-200) to http.StatusOK so neither the - // histogram nor the statusAttrs cache gets poisoned with status=0. + // histogram nor any status cache is poisoned with status=0. defer func(res *StatusResponseWriter, req *http.Request) { - duration := time.Since(start) - status := res.Status() - - if hasAttrer { - // Fast path: copy the cached (path, method) attribute pair - // into a fixed 3-element local array and add the - // per-request status KV in slot 2. Avoids the per-request - // append-and-grow that occurs when growing a cap=2 slice - // to length 3. - key := routeMethodKey{path: path, method: req.Method} - - base, ok := routeAttrs.Load(key) - if !ok { - b := []attribute.KeyValue{ - attribute.String("path", path), - attribute.String("method", req.Method), - } - base, _ = routeAttrs.LoadOrStore(key, b) - } - - b := base.([]attribute.KeyValue) - attrs := [3]attribute.KeyValue{b[0], b[1], statusAttr(status)} - attrer.RecordHistogramAttrs(context.Background(), "app_http_response", duration.Seconds(), attrs[:]...) - - return - } - - // Slow path: external metrics implementation, no fast method. - metrics.RecordHistogram(context.Background(), "app_http_response", duration.Seconds(), - "path", path, "method", req.Method, "status", fmt.Sprintf("%d", status)) + recorder.record(path, req.Method, res.Status(), time.Since(start).Seconds(), templated) }(srw, r) inner.ServeHTTP(srw, r) }) } } + +// metricsPath resolves the path label and reports whether it is a bounded route +// template. +// +// The label itself is unchanged. What is new is the second return value, which +// decides whether the result may be used as a cache key. Every branch that falls +// back to r.URL.Path yields a caller-controlled string: an unmatched route, a +// static-asset extension, /static, and - crucially - the "/" template that +// GoFr's PathPrefix("/") catch-all produces for every unmatched request. Without +// this distinction a stream of unique unmatched paths filled the shared cache to +// its ceiling, after which every first-seen LEGITIMATE route could never be +// stored and rebuilt its measurement option per request forever. Memory stayed +// bounded; the optimization silently reverted to baseline for real traffic. +func metricsPath(r *http.Request) (path string, templated bool) { + path = gofrhttp.RouteTemplate(r) + templated = path != "" + + // It is "" for unmatched routes and for routes built without an explicit + // Path() (e.g. PathPrefix-only handlers), so fall back to r.URL.Path there + // to keep a usable path label rather than an empty key. + if !templated { + path = r.URL.Path + } + + ext := strings.ToLower(filepath.Ext(r.URL.Path)) + switch ext { + case ".css", ".js", ".png", ".jpg", ".jpeg", ".gif", ".ico", ".svg", ".txt", ".html", ".json", ".woff", ".woff2", ".ttf", ".eot", ".pdf": + path, templated = r.URL.Path, false + } + + if path == "/" || strings.HasPrefix(path, "/static") { + path, templated = r.URL.Path, false + } + + return strings.TrimSuffix(path, "/"), templated +} + +// histogramName is the request-duration histogram this middleware records. +const histogramName = "app_http_response" + +// metricsOptRecorder is the fastest optional interface: an implementation that +// accepts an already-built measurement option lets this middleware build each +// (path, method, status) option once instead of on every request. +type metricsOptRecorder interface { + RecordHistogramOpt(ctx context.Context, name string, value float64, opts ...metric.RecordOption) +} + +// statusRouteKey identifies a (path, method, status) triple. +type statusRouteKey struct { + path, method string + status int +} + +// histogramRecorder records one app_http_response observation. +// +// Three implementations exist because a metrics backend may support three +// levels of pre-building. Choosing between them once, at construction, keeps +// that decision out of the request path and keeps each strategy independently +// readable and testable. +type histogramRecorder interface { + // templated reports whether path is a bounded route template. Only a + // templated path may be used as a cache key -- see metricsPath. + record(path, method string, status int, seconds float64, templated bool) +} + +// newHistogramRecorder selects the most capable strategy the backend supports. +func newHistogramRecorder(m metrics) histogramRecorder { + statusAttr := newStatusAttrCache() + + if r, ok := m.(metricsOptRecorder); ok { + return &optionRecorder{rec: r, statusAttr: statusAttr} + } + + if a, ok := m.(metricsAttrer); ok { + return &attrsRecorder{rec: a, statusAttr: statusAttr} + } + + return &labelsRecorder{rec: m} +} + +// newStatusAttrCache returns a memoized status-attribute builder. +// +// The value is a string, not an Int: metricsManager's varargs path emits status +// as a string and OTLP exporters distinguish KeyValue types, so a mismatch would +// break user queries expecting a string across the two code paths. +func newStatusAttrCache() func(int) attribute.KeyValue { + var cache sync.Map // map[int]attribute.KeyValue + + return func(code int) attribute.KeyValue { + if v, ok := cache.Load(code); ok { + kv, _ := v.(attribute.KeyValue) + + return kv + } + + kv := attribute.String("status", strconv.Itoa(code)) + cache.Store(code, kv) + + return kv + } +} + +// optionRecorder caches one fully built measurement option per +// (path, method, status), so metric.WithAttributes -- which builds and sorts an +// attribute.Set -- runs once per combination rather than once per request. +type optionRecorder struct { + rec metricsOptRecorder + statusAttr func(int) attribute.KeyValue + cache routeCache[[]metric.RecordOption] // keyed on statusRouteKey +} + +func (o *optionRecorder) record(path, method string, status int, seconds float64, templated bool) { + cacheable := templated && cacheableMethod(method) + key := statusRouteKey{path: path, method: method, status: status} + + if cacheable { + if opts, ok := o.cache.load(key); ok { + o.rec.RecordHistogramOpt(context.Background(), histogramName, seconds, opts...) + + return + } + } + + // Cache the option slice, not the option: passing a lone option into the + // variadic would allocate a one-element slice on every request. + // + // The status attribute is a String, not an Int: metricsManager's varargs + // path emits status as a string and OTLP exporters distinguish KeyValue + // types, so the two paths must agree or a dashboard breaks depending on + // which recorder the backend selected. + opts := []metric.RecordOption{metric.WithAttributes( + attribute.String("path", path), + attribute.String("method", method), + o.statusAttr(status), + )} + + if cacheable { + o.cache.store(key, opts) + } + + o.rec.RecordHistogramOpt(context.Background(), histogramName, seconds, opts...) +} + +// attrsRecorder caches the (path, method) attribute pair and copies it into a +// fixed three-element array, avoiding the append-and-grow that appending status +// to a cap=2 slice would cost. +type attrsRecorder struct { + rec metricsAttrer + statusAttr func(int) attribute.KeyValue + cache routeCache[[]attribute.KeyValue] // keyed on routeMethodKey +} + +func (a *attrsRecorder) record(path, method string, status int, seconds float64, templated bool) { + key := routeMethodKey{path: path, method: method} + + var b []attribute.KeyValue + + // This cache used to have no ceiling at all while its sibling above had one, + // which is exactly the inconsistency that makes a shared key space dangerous: + // one malicious request stream inflates whichever cache is unbounded. Both + // now go through routeCache under the same rules. + cacheable := templated && cacheableMethod(method) + if cacheable { + b, _ = a.cache.load(key) + } + + if b == nil { + b = []attribute.KeyValue{ + attribute.String("path", path), + attribute.String("method", method), + } + + if cacheable { + a.cache.store(key, b) + } + } + + attrs := [3]attribute.KeyValue{b[0], b[1], a.statusAttr(status)} + + a.rec.RecordHistogramAttrs(context.Background(), histogramName, seconds, attrs[:]...) +} + +// labelsRecorder is the fallback for an external metrics implementation that +// offers neither fast-path interface. +type labelsRecorder struct{ rec metrics } + +func (l *labelsRecorder) record(path, method string, status int, seconds float64, _ bool) { + l.rec.RecordHistogram(context.Background(), histogramName, seconds, + "path", path, "method", method, "status", strconv.Itoa(status)) +} diff --git a/pkg/gofr/http/middleware/metrics_test.go b/pkg/gofr/http/middleware/metrics_test.go index 927e4fc821..d5a841111a 100644 --- a/pkg/gofr/http/middleware/metrics_test.go +++ b/pkg/gofr/http/middleware/metrics_test.go @@ -12,9 +12,11 @@ import ( "time" "github.com/gorilla/mux" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/metric" ) type mockMetrics struct { @@ -202,7 +204,301 @@ func TestMetrics_StaticFileWithQueryParam(t *testing.T) { []string{"path", "/static/example.js", "method", "GET", "status", "200"}) } -// --------------------------------------------------------------------------- +// mockOptRecorder implements both optional fast-path interfaces so the +// measurement-option path is exercised, and records what it was handed. +type mockOptRecorder struct { + noopMetrics + + mu sync.Mutex + optHits int + values []float64 + // attrs holds the attribute set of every recorded observation, so a test + // can assert WHAT was labeled and not merely that something was. + attrs []attribute.Set +} + +// noopMetrics satisfies the metrics interface without assertions, so the option +// path can be exercised without a mock expectation for every call. +type noopMetrics struct{} + +func (noopMetrics) IncrementCounter(context.Context, string, ...string) {} +func (noopMetrics) DeltaUpDownCounter(context.Context, string, float64, ...string) {} +func (noopMetrics) RecordHistogram(context.Context, string, float64, ...string) {} +func (noopMetrics) SetGauge(string, float64, ...string) {} + +func (m *mockOptRecorder) RecordHistogramOpt(_ context.Context, _ string, v float64, opts ...metric.RecordOption) { + m.mu.Lock() + defer m.mu.Unlock() + + m.optHits++ + m.values = append(m.values, v) + m.attrs = append(m.attrs, metric.NewRecordConfig(opts).Attributes()) +} + +// attrMap flattens the i-th recorded attribute set into a map of key to the +// value AND its type, so a String->Int regression is visible. +func (m *mockOptRecorder) attrMap(i int) map[string]string { + m.mu.Lock() + defer m.mu.Unlock() + + out := map[string]string{} + for _, kv := range m.attrs[i].ToSlice() { + out[string(kv.Key)] = kv.Value.Type().String() + ":" + kv.Value.String() + } + + return out +} + +// capturedPath runs one request through a router that has the given routes +// registered and returns what metricsPath resolved for it. +// +// It goes through mux rather than calling metricsPath on a bare request because +// the templated half of the answer comes from the matched route, which only +// exists once the router has run. +func capturedPath(t *testing.T, target string, routes ...string) (path string, templated bool) { + t.Helper() + + capture := func(_ http.ResponseWriter, r *http.Request) { path, templated = metricsPath(r) } + + router := mux.NewRouter() + for _, route := range routes { + router.NewRoute().Methods(http.MethodGet).Path(route).HandlerFunc(capture) + } + + router.NotFoundHandler = http.HandlerFunc(capture) + + router.ServeHTTP(httptest.NewRecorder(), + httptest.NewRequestWithContext(t.Context(), http.MethodGet, target, http.NoBody)) + + return path, templated +} + +// TestMetricsPath pins the path label and the cacheability flag directly, rather +// than only through the cache-growth tests that consume them. +// +// The second return value is the whole reason the caches are bounded: it must be +// false for every branch that falls back to the raw, caller-controlled URL path, +// and true only for a route template. +func TestMetricsPath(t *testing.T) { + tests := []struct { + desc string + target string + routes []string + wantPath string + wantTemplated bool + }{ + {"matched template", "/users/7", []string{"/users/{id}"}, "/users/{id}", true}, + {"trailing slash trimmed off the template", "/users/7/", []string{"/users/{id}/"}, "/users/{id}", true}, + {"unmatched route falls back to the raw path", "/nope/xyz", nil, "/nope/xyz", false}, + {"root template is never cacheable", "/", []string{"/"}, "", false}, + {"/static prefix is never cacheable", "/static/app/x", []string{"/static/{rest}"}, "/static/app/x", false}, + // The two below MATCH a route, so the template would win were the + // extension not checked -- that is the branch they exist to pin. + {"static extension beats the template", "/assets/logo.css", []string{"/assets/{f}"}, "/assets/logo.css", false}, + {"uppercase static extension too", "/assets/LOGO.CSS", []string{"/assets/{f}"}, "/assets/LOGO.CSS", false}, + {"graphql is matched and templated", "/graphql", []string{"/graphql"}, "/graphql", true}, + } + + for _, tc := range tests { + t.Run(tc.desc, func(t *testing.T) { + path, templated := capturedPath(t, tc.target, tc.routes...) + + assert.Equal(t, tc.wantPath, path, "path label") + assert.Equal(t, tc.wantTemplated, templated, "cacheable only for a route template") + }) + } +} + +// TestMetricsOptRecorderIsUsedAndStillRecords pins that the faster path is taken +// and that every request is still observed exactly once. +func TestMetricsOptRecorderIsUsedAndStillRecords(t *testing.T) { + rec := &mockOptRecorder{} + + router := mux.NewRouter() + router.Use(Metrics(rec)) + router.NewRoute().Methods(http.MethodGet).Path("/users/{id}"). + HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusOK) }) + + const n = 25 + for i := range n { + router.ServeHTTP(httptest.NewRecorder(), + httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/users/"+strconv.Itoa(i), http.NoBody)) + } + + require.Equal(t, n, rec.optHits, "every request must still be recorded") + + for _, v := range rec.values { + // Not Positive: a handler this trivial can complete inside the clock's + // granularity, making a zero-second duration legitimate rather than a + // defect. The upper bound is the assertion that earns its place — it + // pins the unit, so passing nanoseconds here instead of seconds fails. + require.GreaterOrEqual(t, v, 0.0, "duration must be a non-negative number of seconds") + require.Less(t, v, 1.0, "a trivial handler records well under a second; larger means wrong units") + } +} + +// TestMetricsOptRecorderLabels pins WHAT the fast path emits. metricsManager +// implements RecordHistogramOpt, so production flows through optionRecorder -- +// yet nothing asserted its labels, which meant changing status from +// attribute.String to attribute.Int, or emitting the concrete path instead of +// the template, kept every test green while dashboards broke and metric +// cardinality exploded. +func TestMetricsOptRecorderLabels(t *testing.T) { + rec := &mockOptRecorder{} + + router := mux.NewRouter() + router.Use(Metrics(rec)) + router.NewRoute().Methods(http.MethodGet).Path("/users/{id}"). + HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusCreated) }) + + router.ServeHTTP(httptest.NewRecorder(), + httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/users/7", http.NoBody)) + + require.Equal(t, 1, rec.optHits) + + assert.Equal(t, map[string]string{ + // The ROUTE TEMPLATE, never the concrete path: "/users/7" here would put + // one time series per user id into the backend. + "path": "STRING:/users/{id}", + "method": "STRING:GET", + // STRING, not INT64: metricsManager's varargs path emits status as a + // string and OTLP distinguishes KeyValue types, so the two recorders + // must agree or a query breaks depending on which one was selected. + "status": "STRING:201", + }, rec.attrMap(0)) +} + +// TestMetricsOptCacheIsBounded drives the guard rather than asserting that a +// compile-time constant is positive. Deleting the ceiling used to leave this +// test green. +func TestMetricsOptCacheIsBounded(t *testing.T) { + require.Positive(t, routeCacheLimit, "the option cache must carry a ceiling") + + o := &optionRecorder{rec: &mockOptRecorder{}, statusAttr: newStatusAttrCache()} + + // Well past the ceiling, all templated and all with a cacheable method, so + // nothing but the ceiling itself can stop the growth. + for i := range routeCacheLimit + 1000 { + o.record("/r/"+strconv.Itoa(i), http.MethodGet, http.StatusOK, 0.01, true) + } + + assert.Equal(t, int64(routeCacheLimit), o.cache.len(), + "the option cache must stop at its ceiling") +} + +// TestMetricsCachesRejectUntemplatedPaths is the regression test for real routes +// being starved out of the cache by catch-all traffic. +// +// Every unmatched request resolves through GoFr's PathPrefix("/") catch-all and +// falls back to the raw URL path, which is caller-controlled. Those used to be +// cached, so a stream of unique unmatched paths filled the cache to its ceiling; +// after that every first-seen legitimate route could never be stored and rebuilt +// its measurement option per request forever. Memory stayed bounded and the +// optimization silently reverted to baseline for production traffic. +func TestMetricsCachesRejectUntemplatedPaths(t *testing.T) { + t.Run("optionRecorder", func(t *testing.T) { + o := &optionRecorder{rec: &mockOptRecorder{}, statusAttr: newStatusAttrCache()} + + for i := range 2000 { + o.record("/attacker/"+strconv.Itoa(i), http.MethodGet, http.StatusOK, 0.01, false) + } + + require.Zero(t, o.cache.len(), "a caller-controlled path must never be cached") + + // A real route is still cached, and is not competing with the noise. + o.record("/users/{id}", http.MethodGet, http.StatusOK, 0.01, true) + assert.Equal(t, int64(1), o.cache.len()) + }) + + t.Run("attrsRecorder", func(t *testing.T) { + a := &attrsRecorder{rec: &mockAttrsRecorder{}, statusAttr: newStatusAttrCache()} + + for i := range 2000 { + a.record("/attacker/"+strconv.Itoa(i), http.MethodGet, http.StatusOK, 0.01, false) + } + + require.Zero(t, a.cache.len(), "a caller-controlled path must never be cached") + + a.record("/users/{id}", http.MethodGet, http.StatusOK, 0.01, true) + assert.Equal(t, int64(1), a.cache.len()) + }) +} + +// TestMetricsCachesRejectUndefinedMethods pins the other half of the key. The +// path is bounded by the route table, but net/http accepts any RFC 7230 token as +// a method, so an unbounded method half reopens the same growth on a bounded +// route. +func TestMetricsCachesRejectUndefinedMethods(t *testing.T) { + o := &optionRecorder{rec: &mockOptRecorder{}, statusAttr: newStatusAttrCache()} + a := &attrsRecorder{rec: &mockAttrsRecorder{}, statusAttr: newStatusAttrCache()} + + for i := range 2000 { + o.record("/users/{id}", "M"+strconv.Itoa(i), http.StatusOK, 0.01, true) + a.record("/users/{id}", "M"+strconv.Itoa(i), http.StatusOK, 0.01, true) + } + + assert.Zero(t, o.cache.len(), "an undefined method must never mint an option-cache entry") + assert.Zero(t, a.cache.len(), "an undefined method must never mint an attrs-cache entry") +} + +// TestAttrsRecorderIsCorrectAndBounded covers attrsRecorder, which no in-tree +// type selects (*metricsManager implements both optional interfaces, so +// optionRecorder always wins) and which therefore ran at zero coverage while its +// cache had no ceiling at all. +func TestAttrsRecorderIsCorrectAndBounded(t *testing.T) { + rec := &mockAttrsRecorder{} + a := &attrsRecorder{rec: rec, statusAttr: newStatusAttrCache()} + + a.record("/users/{id}", http.MethodGet, http.StatusCreated, 0.02, true) + + require.Len(t, rec.attrs, 1) + assert.Equal(t, map[string]string{ + "path": "STRING:/users/{id}", + "method": "STRING:GET", + "status": "STRING:201", + }, kvSlice(rec.attrs[0])) + + // Repeated calls reuse the cached base pair rather than growing. + for range 100 { + a.record("/users/{id}", http.MethodGet, http.StatusOK, 0.02, true) + } + + assert.Equal(t, int64(1), a.cache.len()) + + for i := range routeCacheLimit + 500 { + a.record("/r/"+strconv.Itoa(i), http.MethodGet, http.StatusOK, 0.01, true) + } + + assert.Equal(t, int64(routeCacheLimit), a.cache.len(), + "the attrs cache must carry the same ceiling as the option cache") +} + +// mockAttrsRecorder captures what the attribute fast path emits. +type mockAttrsRecorder struct { + noopMetrics + + mu sync.Mutex + attrs [][]attribute.KeyValue +} + +func (m *mockAttrsRecorder) RecordHistogramAttrs(_ context.Context, _ string, _ float64, + attrs ...attribute.KeyValue, +) { + m.mu.Lock() + defer m.mu.Unlock() + + m.attrs = append(m.attrs, append([]attribute.KeyValue(nil), attrs...)) +} + +func kvSlice(kvs []attribute.KeyValue) map[string]string { + out := map[string]string{} + for _, kv := range kvs { + out[string(kv.Key)] = kv.Value.Type().String() + ":" + kv.Value.String() + } + + return out +} + // Characterization suite for the Metrics HTTP middleware. // // Everything below pins CURRENT behavior of pkg/gofr/http/middleware/metrics.go diff --git a/pkg/gofr/http/middleware/routecache.go b/pkg/gofr/http/middleware/routecache.go index 382043163f..ed7632d568 100644 --- a/pkg/gofr/http/middleware/routecache.go +++ b/pkg/gofr/http/middleware/routecache.go @@ -51,7 +51,20 @@ type routeKey struct { method, route string } -// routeCache is a bounded, concurrent cache keyed on routeKey. +// routeCache is a bounded, concurrent cache of V keyed on any comparable +// per-route key. +// +// The KEY is `any` because the caches sharing this bound do not share a key +// shape: the tracer keys on (method, route) while the metrics recorders key on +// (path, method, status) and (path, method). What they DO share is the exposure +// - all three are fed from the same attacker-influenced method and path - so the +// bound is what belongs in one place, not the key type. +// +// The VALUE is a type parameter rather than `any` so that callers do not each +// carry a type assertion. A cache is single-consumer, so those assertions could +// never fail, which left every one of them with a branch no test could reach and +// nothing but a comment explaining why. Naming the type here deletes them: the +// single assertion below is the only one left, and store makes it unfalsifiable. // // Reads stay on sync.Map's lock-free path. Writes stop at routeCacheLimit rather // than evicting: the entries are pure functions of their key and are all equally @@ -59,14 +72,21 @@ type routeKey struct { // both cheaper and easier to reason about than an eviction policy. Past the cap // the affected requests rebuild their data per request — the optimization stops // applying, but memory is flat and behavior is unchanged. -type routeCache struct { +type routeCache[V any] struct { entries sync.Map count atomic.Int64 } // load returns the cached value for key, if present. -func (c *routeCache) load(key routeKey) (any, bool) { - return c.entries.Load(key) +// +// The assertion cannot fail: store is the only writer and it takes a V. +func (c *routeCache[V]) load(key any) (value V, ok bool) { + v, ok := c.entries.Load(key) + if !ok { + return value, false + } + + return v.(V), true } // store caches value under key unless the cache is already at its limit. @@ -74,7 +94,7 @@ func (c *routeCache) load(key routeKey) (any, bool) { // The count is advisory: concurrent stores can race past the cap by the number of // goroutines in flight, which is bounded and harmless. What matters is that the // cache cannot grow without limit. -func (c *routeCache) store(key routeKey, value any) { +func (c *routeCache[V]) store(key any, value V) { if c.count.Load() >= routeCacheLimit { return } @@ -85,13 +105,13 @@ func (c *routeCache) store(key routeKey, value any) { } // len reports the number of cached entries. Test-only. -func (c *routeCache) len() int64 { +func (c *routeCache[V]) len() int64 { return c.count.Load() } // reset empties the cache. Test-only: the package-level caches are process-wide, // so a test that asserts on size has to start from a known state. -func (c *routeCache) reset() { +func (c *routeCache[V]) reset() { c.entries.Range(func(k, _ any) bool { c.entries.Delete(k) diff --git a/pkg/gofr/http/middleware/tracer.go b/pkg/gofr/http/middleware/tracer.go index 3017eeee6f..cc0f9964b8 100644 --- a/pkg/gofr/http/middleware/tracer.go +++ b/pkg/gofr/http/middleware/tracer.go @@ -84,7 +84,7 @@ type spanMeta struct { // each time and never serve a second request. // //nolint:gochecknoglobals // rationale above: a per-closure cache would never be reused. -var tracerSpanCache routeCache +var tracerSpanCache routeCache[*spanMeta] // spanMetaFor returns the span name and attributes for a route, building them on // first use. @@ -102,14 +102,8 @@ func spanMetaFor(method, route string, templated bool) *spanMeta { key := routeKey{method: method, route: route} - // A failed assertion falls through to the rebuild below rather than returning - // the nil it would otherwise produce. Nothing else stores into this cache, so - // it cannot fail today; ignoring the result would turn any future change that - // broke that into a nil dereference on the request path. - if v, ok := tracerSpanCache.load(key); ok { - if meta, ok := v.(*spanMeta); ok { - return meta - } + if meta, ok := tracerSpanCache.load(key); ok { + return meta } meta := newSpanMeta(method, route) diff --git a/pkg/gofr/http/middleware/tracer_test.go b/pkg/gofr/http/middleware/tracer_test.go index 06e2b86809..7402ae9ba4 100644 --- a/pkg/gofr/http/middleware/tracer_test.go +++ b/pkg/gofr/http/middleware/tracer_test.go @@ -525,7 +525,7 @@ func TestSpanMetaCacheStillCachesStandardMethods(t *testing.T) { // primary bound, but it is an argument about reachability; the cap is a number, // and process memory should rest on the number too. func TestRouteCacheStopsAtItsLimit(t *testing.T) { - var c routeCache + var c routeCache[int] for i := range routeCacheLimit + 500 { c.store(routeKey{method: http.MethodGet, route: "/r/" + strconv.Itoa(i)}, i) diff --git a/pkg/gofr/metrics/register.go b/pkg/gofr/metrics/register.go index 0cfd6e7b7d..7a2eca645c 100644 --- a/pkg/gofr/metrics/register.go +++ b/pkg/gofr/metrics/register.go @@ -250,6 +250,32 @@ func (m *metricsManager) RecordHistogramAttrs(ctx context.Context, name string, histogram.Record(ctx, value, metric.WithAttributes(attrs...)) } +// RecordHistogramOpt records a histogram observation using a caller-supplied, +// already-built measurement option. +// +// RecordHistogramAttrs has to call metric.WithAttributes on every observation, +// which builds an attribute.Set (sorting and deduplicating the attributes) and +// an option wrapper. For a caller whose attribute combinations are drawn from a +// small fixed set -- a request metric keyed by route, method and status -- that +// work produces the same option over and over, so the option is better built +// once by the caller and reused. +// +// The options are taken as a slice rather than a single value so a caller can +// hand over one it already holds: passing a cached slice through with opts... +// reuses it, whereas passing a lone option would allocate a fresh one-element +// slice for the variadic on every observation. +func (m *metricsManager) RecordHistogramOpt(ctx context.Context, name string, value float64, + opts ...metric.RecordOption) { + histogram, err := m.store.getHistogram(name) + if err != nil { + m.logger.Error(err) + + return + } + + histogram.Record(ctx, value, opts...) +} + // SetGauge gets the value and sets the metric to the specified value. // Unlike counters, gauges do not track the last value for the metric. This method allows us to // directly set the value of the gauge to the specified value. diff --git a/pkg/gofr/metrics/register_test.go b/pkg/gofr/metrics/register_test.go index 8f4402af3c..d76c9d0e10 100644 --- a/pkg/gofr/metrics/register_test.go +++ b/pkg/gofr/metrics/register_test.go @@ -1,12 +1,15 @@ package metrics import ( + "context" "io" "net/http" "net/http/httptest" "testing" "github.com/stretchr/testify/assert" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/metric" "gofr.dev/pkg/gofr/logging" "gofr.dev/pkg/gofr/metrics/exporters" @@ -186,3 +189,68 @@ func BenchmarkAttrBuild_HTTP(b *testing.B) { ) } } + +// benchHistogramAttrs are the labels a request metric carries: for a given route, method and status +// they are byte-identical on every single observation. +func benchHistogramAttrs() []attribute.KeyValue { + return []attribute.KeyValue{ + attribute.String("path", "/users/{id}"), + attribute.String("method", http.MethodGet), + attribute.String("status", "200"), + } +} + +// benchManager returns the concrete manager, because the option-based recorder is a capability of +// the implementation rather than part of the Manager interface -- callers reach it by assertion. +func benchManager(b *testing.B) *metricsManager { + b.Helper() + + cfg := exporters.Config{AppName: "bench-app", AppVersion: "v1.0.0"} + shutdown, meter := exporters.Build(b.Context(), &cfg, logging.NewMockLogger(logging.ERROR)) + + b.Cleanup(func() { + if shutdown != nil { + _ = shutdown(context.Background()) + } + }) + + m, ok := NewMetricsManager(meter, logging.NewMockLogger(logging.ERROR)).(*metricsManager) + if !ok { + b.Fatal("NewMetricsManager did not return *metricsManager") + } + + m.NewHistogram("bench-histogram", "histogram used by the benchmarks") + + return m +} + +// BenchmarkRecordHistogramAttrs is the cost of an observation when the measurement option is rebuilt +// each time: metric.WithAttributes sorts and deduplicates the attributes into a new attribute.Set +// and wraps it, on every single request. +func BenchmarkRecordHistogramAttrs(b *testing.B) { + m := benchManager(b) + attrs := benchHistogramAttrs() + + b.ReportAllocs() + b.ResetTimer() + + for range b.N { + m.RecordHistogramAttrs(b.Context(), "bench-histogram", 1, attrs...) + } +} + +// BenchmarkRecordHistogramOpt is the same observation with the option built once by the caller and +// reused, which is what a request metric can do because its label combinations come from a small +// fixed set. +func BenchmarkRecordHistogramOpt(b *testing.B) { + m := benchManager(b) + + cached := []metric.RecordOption{metric.WithAttributes(benchHistogramAttrs()...)} + + b.ReportAllocs() + b.ResetTimer() + + for range b.N { + m.RecordHistogramOpt(b.Context(), "bench-histogram", 1, cached...) + } +} From 2728bf5baad9a58c6ab79261690cd6599cb4ada8 Mon Sep 17 00:00:00 2001 From: Aryan Mehrotra Date: Thu, 3 Sep 2026 17:43:03 +0530 Subject: [PATCH 04/48] perf(http): pool the response envelope and stop recanonicalising Content-Type (#3973) --- pkg/gofr/handler_test.go | 1 + pkg/gofr/http/responder.go | 114 +++++++++++---- pkg/gofr/http/responder_test.go | 250 ++++++++++++++++++++++++++++++++ pkg/gofr/http_server_test.go | 22 +++ 4 files changed, 361 insertions(+), 26 deletions(-) diff --git a/pkg/gofr/handler_test.go b/pkg/gofr/handler_test.go index 4c5b768a45..cd7f0c238b 100644 --- a/pkg/gofr/handler_test.go +++ b/pkg/gofr/handler_test.go @@ -638,6 +638,7 @@ func BenchmarkRequest_RealHandlerPath(b *testing.B) { b.ResetTimer() for range b.N { + w.reset() h.ServeHTTP(w, req) } } diff --git a/pkg/gofr/http/responder.go b/pkg/gofr/http/responder.go index b7ca95b590..dfe5a74450 100644 --- a/pkg/gofr/http/responder.go +++ b/pkg/gofr/http/responder.go @@ -5,6 +5,7 @@ import ( "encoding/json" "errors" "net/http" + "net/textproto" "reflect" "sync" @@ -30,9 +31,36 @@ const initialRespBufCap = 512 // process-wide pool is the idiomatic shape for this and is safe for concurrent // use by construction. // -//nolint:gochecknoglobals // process-wide pool of reusable response-encode buffers. +// The encoder is pooled together with its buffer, not separately: a +// json.Encoder is bound to the writer it was constructed with, so the two have +// to travel as a pair. Constructing one per response was an allocation on every +// request even though the buffer it wrote into was already pooled. +// +//nolint:gochecknoglobals // process-wide pool of reusable response encoders. var respBufPool = sync.Pool{ - New: func() any { return bytes.NewBuffer(make([]byte, 0, initialRespBufCap)) }, + New: func() any { return newRespEncoder() }, +} + +// Canonical key and shared value for the JSON content type, resolved once so no +// response pays for canonicalization or a value-slice allocation. +// +//nolint:gochecknoglobals // immutable, process-wide header constants. +var ( + canonicalContentType = textproto.CanonicalMIMEHeaderKey("Content-Type") + jsonContentType = []string{contentTypeJSON} +) + +// respEncoder pairs a reusable buffer with the encoder bound to it, plus the +// response envelope itself. +// +// The envelope is kept here so it can be encoded through a pointer. Passing a +// struct to Encode, whose parameter is any, boxes it and costs an allocation on +// every response; passing a pointer to a struct that already lives in the pool +// does not. encoding/json produces identical output either way. +type respEncoder struct { + buf *bytes.Buffer + enc *json.Encoder + resp response } // NewResponder creates a new Responder instance from the given http.ResponseWriter. @@ -64,34 +92,48 @@ func (r Responder) Respond(data any, err error) { statusCode, errorObj := r.determineResponse(data, err) + // Assigned rather than Set: Header.Set canonicalizes the key and allocates a + // fresh []string for the value on every response, and both are constant here. + // Sharing the value slice is safe because it has len == cap == 1, so a later + // Header.Add appends into a new array instead of mutating it. + // + // The guard is a VALUE check, not a presence check. Header().Get returns "" + // both for an absent key and for a key explicitly set to "", and the default + // has to apply in both cases: a caller that pre-set Content-Type to "" would + // otherwise ship a JSON body with a blank Content-Type, since the present-but- + // empty entry also suppresses net/http's own sniffing. + header := r.w.Header() + if v := header[canonicalContentType]; len(v) == 0 || v[0] == "" { + header[canonicalContentType] = jsonContentType + } + + re := getRespBuf() + buf := re.buf + var resp any switch v := data.(type) { case resTypes.Raw: resp = v.Data case resTypes.Response: - resp = response{Data: v.Data, Metadata: v.Metadata, Error: errorObj} + re.resp = response{Data: v.Data, Metadata: v.Metadata, Error: errorObj} + resp = &re.resp default: // handling where an interface contains a nullable type with a nil value. if isNil(data) { data = nil } - resp = response{Data: data, Error: errorObj} - } - - if r.w.Header().Get("Content-Type") == "" { - r.w.Header().Set("Content-Type", "application/json") + re.resp = response{Data: data, Error: errorObj} + resp = &re.resp } - buf := getRespBuf() - // json.Encoder.Encode appends a trailing newline, exactly matching the // previous json.Marshal(resp) followed by a separate Write of "\n". It also // uses the same default HTML escaping as json.Marshal, so the bytes on the // wire are identical to before. - if encodeErr := json.NewEncoder(buf).Encode(resp); encodeErr != nil { - putRespBuf(buf) + if encodeErr := re.enc.Encode(resp); encodeErr != nil { + putRespBuf(re) r.w.WriteHeader(http.StatusInternalServerError) @@ -103,25 +145,45 @@ func (r Responder) Respond(data any, err error) { r.w.WriteHeader(statusCode) _, _ = r.w.Write(buf.Bytes()) - putRespBuf(buf) + putRespBuf(re) } -// getRespBuf takes a reset buffer from the pool, ready to encode into. It is the -// counterpart to putRespBuf, keeping the pool's type assertion in one place. The -// assertion is safe: respBufPool is private and only ever holds *bytes.Buffer. -func getRespBuf() *bytes.Buffer { - buf := respBufPool.Get().(*bytes.Buffer) - buf.Reset() +// newRespEncoder builds an encoder bound to its own buffer. A json.Encoder is +// tied to the writer it was constructed with, so the two are only ever created +// and pooled as a pair. +func newRespEncoder() *respEncoder { + buf := bytes.NewBuffer(make([]byte, 0, initialRespBufCap)) + + return &respEncoder{buf: buf, enc: json.NewEncoder(buf)} +} + +// getRespBuf takes a reset encoder from the pool, ready to encode into. It is +// the counterpart to putRespBuf, keeping the pool's type assertion in one place. +func getRespBuf() *respEncoder { + // The pool is private and New only ever yields *respEncoder, so this cannot fail. It is written + // to recover rather than to discard the result: ignoring it would turn an impossible failure into + // a nil dereference on the next line, which says nothing about what went wrong. + re, ok := respBufPool.Get().(*respEncoder) + if !ok { + re = newRespEncoder() + } + + re.buf.Reset() - return buf + return re } -// putRespBuf returns buf to the pool unless it has grown past maxRespPooledBuf, -// so one oversized response cannot permanently inflate every pooled buffer. All -// return-to-pool paths go through here to keep that cap invariant in one place. -func putRespBuf(buf *bytes.Buffer) { - if buf.Cap() <= maxRespPooledBuf { - respBufPool.Put(buf) +// putRespBuf returns re to the pool unless its buffer has grown past +// maxRespPooledBuf, so one oversized response cannot permanently inflate every +// pooled buffer. All return-to-pool paths go through here to keep that cap +// invariant in one place. +func putRespBuf(re *respEncoder) { + // Clear the envelope so a payload cannot outlive its response inside the + // pool, and so nothing it referenced is kept alive. + re.resp = response{} + + if re.buf.Cap() <= maxRespPooledBuf { + respBufPool.Put(re) } } diff --git a/pkg/gofr/http/responder_test.go b/pkg/gofr/http/responder_test.go index 34e9079ade..44f59621b3 100644 --- a/pkg/gofr/http/responder_test.go +++ b/pkg/gofr/http/responder_test.go @@ -4,11 +4,13 @@ import ( "bytes" "encoding/json" "errors" + "fmt" "io" "math" "net/http" "net/http/httptest" "os" + "strings" "sync" "testing" @@ -1830,3 +1832,251 @@ func TestResponder_Char_MethodCaseSensitivity(t *testing.T) { assert.Equal(t, http.StatusOK, w.Code) } + +// TestRespondEncoderIsReusedAcrossResponses pins that pooling the encoder with +// its buffer does not leak one response into the next: each body must contain +// only its own payload. +func TestRespondEncoderIsReusedAcrossResponses(t *testing.T) { + for i := range 50 { + w := httptest.NewRecorder() + want := fmt.Sprintf("payload-%d", i) + + NewResponder(w, http.MethodGet).Respond(map[string]string{"v": want}, nil) + + body := w.Body.String() + require.Contains(t, body, want) + require.Equal(t, 1, strings.Count(body, "payload-"), + "a response must carry only its own payload, got %q", body) + } +} + +// TestRespondEncoderConcurrent runs the pooled encoder under contention; the +// race detector is the point of this test. + +// TestRespondEncoderConcurrent runs the pooled encoder under contention; the +// race detector is the point of this test. +func TestRespondEncoderConcurrent(t *testing.T) { + var wg sync.WaitGroup + + for g := range 32 { + wg.Add(1) + + go func(g int) { + defer wg.Done() + + for i := range 25 { + w := httptest.NewRecorder() + want := fmt.Sprintf("g%d-i%d", g, i) + + NewResponder(w, http.MethodGet).Respond(map[string]string{"v": want}, nil) + + if !strings.Contains(w.Body.String(), want) { + t.Errorf("response lost its payload: %q", w.Body.String()) + } + } + }(g) + } + + wg.Wait() +} + +// TestRespondEnvelopeDoesNotLeakMetadata is the isolation guard for reusing the +// response envelope from the pool: a response carrying metadata must not leave +// it behind for the next one, which sets no metadata at all. +func TestRespondEnvelopeDoesNotLeakMetadata(t *testing.T) { + withMeta := httptest.NewRecorder() + NewResponder(withMeta, http.MethodGet).Respond( + resTypes.Response{Data: "first", Metadata: map[string]any{"secret": "classified"}}, nil) + + require.Contains(t, withMeta.Body.String(), "classified") + + // Drive enough follow-ups to make reuse of that pooled envelope certain. + for range 50 { + plain := httptest.NewRecorder() + NewResponder(plain, http.MethodGet).Respond(map[string]string{"v": "second"}, nil) + + require.NotContains(t, plain.Body.String(), "classified", + "metadata from an earlier response leaked through the pool") + require.NotContains(t, plain.Body.String(), "metadata") + } +} + +// TestRespondEnvelopeErrorDoesNotLeak covers the same hazard for the error field. +func TestRespondEnvelopeErrorDoesNotLeak(t *testing.T) { + failed := httptest.NewRecorder() + NewResponder(failed, http.MethodGet).Respond(nil, errTestResponder) + + require.Contains(t, failed.Body.String(), "error") + + for range 50 { + ok := httptest.NewRecorder() + NewResponder(ok, http.MethodGet).Respond(map[string]string{"v": "fine"}, nil) + + require.NotContains(t, ok.Body.String(), errTestResponder.Error(), + "an error from an earlier response leaked through the pool") + } +} + +// TestContentTypeSharedValueSurvivesAdd is the safety proof for assigning the +// shared Content-Type value slice: a later Header.Add must not mutate it. +func TestContentTypeSharedValueSurvivesAdd(t *testing.T) { + before := append([]string(nil), jsonContentType...) + + for range 3 { + w := httptest.NewRecorder() + NewResponder(w, http.MethodGet).Respond(map[string]string{"v": "x"}, nil) + + w.Header().Add("Content-Type", "text/plain") + } + + require.Equal(t, before, jsonContentType, "the shared Content-Type value must never be mutated") + require.Len(t, jsonContentType, 1) +} + +// TestContentTypeNotOverriddenWhenAlreadySet pins that an already-set +// Content-Type still wins, as it did with the previous Get/Set pair. + +// TestContentTypeNotOverriddenWhenAlreadySet pins that an already-set +// Content-Type still wins, as it did with the previous Get/Set pair. +func TestContentTypeNotOverriddenWhenAlreadySet(t *testing.T) { + w := httptest.NewRecorder() + w.Header().Set("Content-Type", "application/custom") + + NewResponder(w, http.MethodGet).Respond(map[string]string{"v": "x"}, nil) + + require.Equal(t, "application/custom", w.Header().Get("Content-Type")) +} + +// responderBenchWriter keeps a header map and discards the body, so the benchmark measures the +// responder rather than a recorder or the network. + +// BenchmarkResponder_Respond measures writing one successful JSON response, which is how the vast +// majority of requests to a GoFr service end. +// +// Allocations are the metric. The envelope and its encoder have the same shape on every response and +// the Content-Type is a constant, so anything allocated per response here is repeated work. +func BenchmarkResponder_Respond(b *testing.B) { + payload := map[string]any{"id": "42", "name": "widget", "in_stock": true} + w := &responderBenchWriter{h: make(http.Header, 4)} + + b.ReportAllocs() + b.ResetTimer() + + for range b.N { + clear(w.h) + NewResponder(w, http.MethodGet).Respond(payload, nil) + } +} + +// TestRespondContentTypeDefaultAppliesToPresentButEmpty pins that the default +// applies when Content-Type is present with an empty value, not only when the +// key is absent. +// +// The pre-pool guard was Header().Get("Content-Type") == "", which is a value +// check: Get returns "" for an absent key AND for a key set to "". Replacing it +// with a presence check silently changed that. A caller doing +// header["Content-Type"] = []string{""} then shipped a JSON body with a blank +// Content-Type, because the present-but-empty entry also suppresses net/http's +// own content sniffing. + +// TestRespondContentTypeDefaultAppliesToPresentButEmpty pins that the default +// applies when Content-Type is present with an empty value, not only when the +// key is absent. +// +// The pre-pool guard was Header().Get("Content-Type") == "", which is a value +// check: Get returns "" for an absent key AND for a key set to "". Replacing it +// with a presence check silently changed that. A caller doing +// header["Content-Type"] = []string{""} then shipped a JSON body with a blank +// Content-Type, because the present-but-empty entry also suppresses net/http's +// own content sniffing. +func TestRespondContentTypeDefaultAppliesToPresentButEmpty(t *testing.T) { + tests := []struct { + name string + seed func(http.Header) + want string + notes string + }{ + { + name: "absent", + seed: func(http.Header) {}, + want: "application/json", + }, + { + name: "present but empty", + seed: func(h http.Header) { h["Content-Type"] = []string{""} }, + want: "application/json", + }, + { + name: "present but empty slice", + seed: func(h http.Header) { h["Content-Type"] = []string{} }, + want: "application/json", + }, + { + name: "already set is preserved", + seed: func(h http.Header) { h.Set("Content-Type", "application/vnd.api+json") }, + want: "application/vnd.api+json", + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + w := httptest.NewRecorder() + tc.seed(w.Header()) + + NewResponder(w, http.MethodGet).Respond(map[string]string{"a": "b"}, nil) + + assert.Equal(t, tc.want, w.Header().Get("Content-Type")) + }) + } +} + +// TestPutRespBufClearsTheEnvelope is the real guard for the pooled envelope. +// +// The three "envelope does not leak" tests stay green even with putRespBuf's +// `re.resp = response{}` deleted, because every JSON path fully reassigns re.resp +// via a composite literal before encoding — so the clear is only load-bearing for +// GC retention, which none of them assert. A future refactor that stopped fully +// reassigning re.resp on some path would leak the previous response's metadata or +// error into the next one, and those tests would not catch it. +// +// This one holds the pooled encoder and inspects it directly, so deleting the +// clear fails. + +// TestPutRespBufClearsTheEnvelope is the real guard for the pooled envelope. +// +// The three "envelope does not leak" tests stay green even with putRespBuf's +// `re.resp = response{}` deleted, because every JSON path fully reassigns re.resp +// via a composite literal before encoding — so the clear is only load-bearing for +// GC retention, which none of them assert. A future refactor that stopped fully +// reassigning re.resp on some path would leak the previous response's metadata or +// error into the next one, and those tests would not catch it. +// +// This one holds the pooled encoder and inspects it directly, so deleting the +// clear fails. +func TestPutRespBufClearsTheEnvelope(t *testing.T) { + re := getRespBuf() + + // A fully populated envelope, so every field has something to leak. + re.resp = response{ + Data: map[string]string{"secret": "value"}, + Metadata: map[string]any{"tenant": "acme"}, + Error: map[string]any{"message": "boom"}, + } + + putRespBuf(re) + + assert.Nil(t, re.resp.Data, "a payload must not outlive its response inside the pool") + assert.Nil(t, re.resp.Metadata, "metadata must not outlive its response inside the pool") + assert.Nil(t, re.resp.Error, "an error must not outlive its response inside the pool") + assert.Equal(t, response{}, re.resp, "the whole envelope must be zeroed") +} + +// errTestResponder is the stand-in error for the pooled-envelope guards; a +// package-level static error keeps err113 satisfied. +var errTestResponder = errors.New("responder pool guard") + +type responderBenchWriter struct{ h http.Header } + +func (w *responderBenchWriter) Header() http.Header { return w.h } +func (*responderBenchWriter) Write(b []byte) (int, error) { return len(b), nil } +func (*responderBenchWriter) WriteHeader(int) {} diff --git a/pkg/gofr/http_server_test.go b/pkg/gofr/http_server_test.go index 1243381912..30c8f2a677 100644 --- a/pkg/gofr/http_server_test.go +++ b/pkg/gofr/http_server_test.go @@ -351,6 +351,18 @@ func (d *benchDiscardResponseWriter) Header() http.Header { return d.h } +// reset returns the writer to the state a FRESH request would find it in. +// +// Without it one writer is reused across every iteration, so a header written +// only when absent -- Content-Type is exactly that -- is set on the first +// iteration and measured as free on every one after. Any benchmark that reaches +// Responder.Respond must call this, or it silently understates the response +// path by one allocation. +func (d *benchDiscardResponseWriter) reset() { + clear(d.Header()) + d.code = 0 +} + func (*benchDiscardResponseWriter) Write(b []byte) (int, error) { return len(b), nil } func (d *benchDiscardResponseWriter) WriteHeader(c int) { d.code = c } @@ -417,12 +429,20 @@ func BenchmarkRequest_FullChain(b *testing.B) { b.ResetTimer() for i := 0; i < b.N; i++ { + w.reset() h.ServeHTTP(w, req) } } // BenchmarkRequest_FullChain_JSON runs the same chain against the /json // handler. Pairs with the /json endpoint in the wrk benchmarks. +// +// It does NOT exercise the response-envelope pooling in this PR, and should not +// be cited as evidence for it: /json is registered as a raw http.HandlerFunc +// that writes its bytes directly, so it never reaches Responder.Respond. The +// responder-level benchmarks are what demonstrate that change. The writer reset +// below is kept for symmetry with the sibling benchmarks, where it is load +// bearing. func BenchmarkRequest_FullChain_JSON(b *testing.B) { c := container.NewContainer(config.NewMockConfig(map[string]string{"LOG_LEVEL": "ERROR"})) h := buildBenchRouter(c) @@ -433,6 +453,7 @@ func BenchmarkRequest_FullChain_JSON(b *testing.B) { b.ResetTimer() for i := 0; i < b.N; i++ { + w.reset() h.ServeHTTP(w, req) } } @@ -464,6 +485,7 @@ func BenchmarkRequest_FullChain_SDK(b *testing.B) { b.ResetTimer() for i := 0; i < b.N; i++ { + w.reset() h.ServeHTTP(w, req) } } From fa3942c11c36d3a34e8906f72194b7b0972b91d4 Mon Sep 17 00:00:00 2001 From: Aryan Mehrotra Date: Fri, 4 Sep 2026 11:11:29 +0530 Subject: [PATCH 05/48] perf(cors): build the fixed response headers once, not per request (#3971) --- pkg/gofr/http/middleware/cors.go | 240 ++++++--- pkg/gofr/http/middleware/cors_test.go | 669 +++++++++++++++++--------- 2 files changed, 629 insertions(+), 280 deletions(-) diff --git a/pkg/gofr/http/middleware/cors.go b/pkg/gofr/http/middleware/cors.go index 71eb9acd1b..477c79384d 100644 --- a/pkg/gofr/http/middleware/cors.go +++ b/pkg/gofr/http/middleware/cors.go @@ -2,29 +2,108 @@ package middleware import ( "net/http" + "net/textproto" "strings" + "sync" ) const ( allowedHeaders = "Authorization, Content-Type, x-requested-with, origin, true-client-ip, X-Correlation-ID" - headerAccessControlAllowOrigin = "Access-Control-Allow-Origin" headerAccessControlAllowMethods = "Access-Control-Allow-Methods" headerAccessControlAllowHeaders = "Access-Control-Allow-Headers" + headerAccessControlAllowOrigin = "Access-Control-Allow-Origin" +) + +// Canonical keys and the shared wildcard value, resolved once at package level +// so no response pays for canonicalization or a value-slice allocation. +// +//nolint:gochecknoglobals // immutable, process-wide header constants. +var ( + canonicalAllowOrigin = textproto.CanonicalMIMEHeaderKey(headerAccessControlAllowOrigin) + canonicalAllowMethods = textproto.CanonicalMIMEHeaderKey(headerAccessControlAllowMethods) + canonicalAllowHeaders = textproto.CanonicalMIMEHeaderKey(headerAccessControlAllowHeaders) + wildcardOrigin = sharedValue("*") ) +// sharedValue builds a header value slice that is safe to share across every +// response. +// +// The safety rests entirely on len == cap == 1, which a one-element composite +// literal guarantees: a later Header.Add on the same key sees no spare capacity +// and appends into a NEWLY allocated array instead of writing into this one. +// Every shared value goes through this function so the invariant has a single +// place to be stated, and TestSharedHeaderValuesHaveNoSpareCapacity asserts it +// for all of them -- a slice with room to grow would let one response scribble +// on every other response's headers, process-wide. +func sharedValue(v string) []string { + return []string{v} +} + // CORS is a middleware that adds CORS (Cross-Origin Resource Sharing) headers to the response. // It supports multiple allowed origins via comma-separated values in the // Access-Control-Allow-Origin config. When multiple origins are configured, // the middleware dynamically matches the request's Origin header and responds // with the matched origin, adding a Vary: Origin header for correct caching. func CORS(middlewareConfigs map[string]string, routes *[]string) func(inner http.Handler) http.Handler { - configs := canonicalizeConfig(middlewareConfigs) - allowedOrigins := parseOrigins(configs[headerAccessControlAllowOrigin]) + // Every header this middleware writes, apart from Allow-Origin, is a pure + // function of the configuration and the registered route set. Both are fixed + // before the first request, yet they were recomputed on every one: a map + // literal, a strings.Join over the route list, and an append into the + // caller's slice. + // + // LIFECYCLE CONTRACT: the configuration map AND the route slice are both read + // exactly once, on the first request, and never again. + // + // "On the first request" rather than here, because the route set does not exist + // yet when this runs. CORS is constructed inside App.New, and RegisteredRoutes + // is EMPTY at that point -- registering handlers does not fill it, since + // Router.Add does not touch it. The only write in the tree is a single + // assignment in httpServerSetup (gofr.go), which walks the finished router and + // assigns the complete method list. Reading routes at construction would + // therefore emit "Access-Control-Allow-Methods: OPTIONS" and nothing else. + // Verified: after New() and after registering GET+POST the slice is still []; + // only after httpServerSetup is it [GET POST]. + // + // httpServerSetup runs synchronously in Run, before the serve goroutine starts, + // so by the first request the set is final and never changes again. The Once is + // a lazy stand-in for that point -- it costs an atomic load (~0.02 ns against a + // ~49 ns hot path) and avoids handing the middleware an explicit freeze hook. + // + // The config is read at the same moment even though it IS complete at + // construction (GetConfigs builds the map fully before newHTTPServer passes it + // here). Reading the two halves of one configuration at two different instants + // is a distinction nothing documents and nobody would expect; one instant is + // easier to state and to test. + // + // A caller that mutates either input after the first request is served will not + // see the change. Inside GoFr that is unreachable -- neither input is ever + // mutated after httpServerSetup -- so this only concerns direct callers of the + // exported CORS. For them it is still the right behavior: both inputs are read + // from every serving goroutine, so mutating them concurrently is a data race + // whenever the read happens. Freezing makes that race impossible rather than + // merely unlikely. TestCORSLifecycleContract and + // TestCORSLifecycleFrozenAfterFirstRequest pin all of it. + var ( + once sync.Once + allowedOrigins map[string]bool + fixed []headerValue + methods []string + ) + + // sync.Once establishes happens-before between this build and every later + // request that observes it, so the assignments below are safely published to + // all serving goroutines without a further lock. + build := func() { + configs := canonicalizeConfig(middlewareConfigs) + allowedOrigins = parseOrigins(configs[headerAccessControlAllowOrigin]) + fixed, methods = buildFixedHeaders(configs, *routes) + } return func(inner http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - setMiddlewareHeaders(configs, *routes, w, r.Header.Get("Origin"), allowedOrigins) + once.Do(build) + setMiddlewareHeaders(w, r.Header.Get("Origin"), allowedOrigins, fixed, methods) if r.Method == http.MethodOptions { w.WriteHeader(http.StatusOK) @@ -36,60 +115,68 @@ func CORS(middlewareConfigs map[string]string, routes *[]string) func(inner http } } -func setMiddlewareHeaders(middlewareConfigs map[string]string, routes []string, - w http.ResponseWriter, origin string, allowedOrigins map[string]bool, -) { - // Handle Access-Control-Allow-Origin separately for dynamic matching. - if allowedOrigins["*"] { - w.Header().Set(headerAccessControlAllowOrigin, "*") - } else if allowedOrigins[origin] { - w.Header().Set(headerAccessControlAllowOrigin, origin) - w.Header().Add("Vary", "Origin") - } +// headerValue is a precomputed response header, held in the shape net/http +// stores it: a canonical key and a one-element value slice. +// +// Writing it with Header.Set would canonicalize the key and allocate a fresh +// []string on every response. Assigning the map entry directly does neither. +// Sharing the slice across responses is safe because it has len == cap == 1, so +// a later Header.Add appends into a NEW array rather than mutating this one -- +// pinned by TestSharedHeaderValueSurvivesAdd. +type headerValue struct { + key string + value []string +} - // The keys arrive canonicalized from canonicalizeConfig, so a differently-cased - // spelling cannot reach a header it was never checked against — replacing the - // origin negotiated above, or overwriting the default allow-list instead of - // extending it. - var customMethods, customHeaders string - - for key, value := range middlewareConfigs { - switch key { - case headerAccessControlAllowOrigin: - // Always negotiated against the configured allow-list above; never - // overridable from here. - case headerAccessControlAllowMethods: - customMethods = value - case headerAccessControlAllowHeaders: - customHeaders = value - default: - w.Header().Set(key, value) - } +// buildFixedHeaders computes every header whose value cannot change once routes +// are registered. It returns them alongside the Access-Control-Allow-Methods +// value, which is kept separate only because it is the one derived from routes. +// +// middlewareConfigs arrives already folded onto canonical header keys by +// canonicalizeConfig. That matters for more than tidiness: this function +// classifies entries by key and writes everything it does not recognize into +// fixed, and fixed is applied AFTER the per-request origin negotiation. Matching +// on the raw key would send a config spelled "access-control-allow-origin" to the +// default branch, where it would be canonicalized into the very header the +// allow-list just negotiated and overwrite it. +// +// The method list is joined without appending to the caller's slice: that slice +// is the router's RegisteredRoutes, and appending in place would write into it +// whenever its capacity exceeded its length. +func buildFixedHeaders(middlewareConfigs map[string]string, routes []string) (fixed []headerValue, methods []string) { + allowMethods := joinAllowedMethods(routes) + if custom, ok := middlewareConfigs[headerAccessControlAllowMethods]; ok && custom != "" { + allowMethods = custom } - // A configured method list replaces the derived one; configured headers - // EXTEND the defaults rather than replacing them, so the framework's own - // required headers (Authorization, Content-Type, X-Correlation-ID, ...) - // cannot be dropped by adding one of your own. - if customMethods == "" { - customMethods = joinAllowedMethods(routes) + methods = sharedValue(allowMethods) + + allowHeaders := allowedHeaders + if custom, ok := middlewareConfigs[headerAccessControlAllowHeaders]; ok && custom != "" { + allowHeaders = allowedHeaders + ", " + custom } - allowHeaderValue := allowedHeaders - if customHeaders != "" { - allowHeaderValue = allowedHeaders + ", " + customHeaders + fixed = append(fixed, headerValue{ + key: canonicalAllowHeaders, + value: sharedValue(allowHeaders), + }) + + // Any other configured header is passed through unchanged. Allow-Origin is + // excluded because it is negotiated per request against the allow-list. + for header, value := range middlewareConfigs { + switch header { + case headerAccessControlAllowOrigin, headerAccessControlAllowMethods, headerAccessControlAllowHeaders: + continue + default: + fixed = append(fixed, headerValue{key: header, value: sharedValue(value)}) + } } - w.Header().Set(headerAccessControlAllowMethods, customMethods) - w.Header().Set(headerAccessControlAllowHeaders, allowHeaderValue) + return fixed, methods } -// joinAllowedMethods renders the Access-Control-Allow-Methods value: the -// registered routes plus OPTIONS. -// -// It deliberately does not append to routes. That slice shares its backing -// array with the caller's (the router's RegisteredRoutes), so appending in -// place writes "OPTIONS" over the caller's next element whenever cap > len. +// joinAllowedMethods renders Access-Control-Allow-Methods: the registered routes +// plus OPTIONS. func joinAllowedMethods(routes []string) string { if len(routes) == 0 { return http.MethodOptions @@ -98,23 +185,52 @@ func joinAllowedMethods(routes []string) string { return strings.Join(routes, ", ") + ", " + http.MethodOptions } -// canonicalizeConfig folds the caller's configuration onto canonical header keys, once, at setup. +// setMiddlewareHeaders writes the CORS headers for one response. Only +// Allow-Origin depends on the request; everything else was built once. +// +// The value slices are shared process-wide rather than copied per response, which is safe only +// because each has len == cap == 1: a later Header.Add on the same key appends into a NEWLY +// allocated array instead of writing into the shared one. TestSharedHeaderValueSurvivesAdd pins +// that. Anything added here must keep that property -- a slice with spare capacity would let one +// response scribble on every other response's header. +func setMiddlewareHeaders(w http.ResponseWriter, origin string, allowedOrigins map[string]bool, + fixed []headerValue, methods []string) { + header := w.Header() + + if allowedOrigins["*"] { + header[canonicalAllowOrigin] = wildcardOrigin + } else if allowedOrigins[origin] { + // The value varies per request, so this one cannot be shared. + header.Set(headerAccessControlAllowOrigin, origin) + header.Add("Vary", "Origin") + } + + header[canonicalAllowMethods] = methods + + for _, h := range fixed { + header[h.key] = h.value + } +} + +// canonicalizeConfig folds the caller's configuration onto canonical header keys, +// once, at construction. // -// Two things depend on this. The allow-list read by parseOrigins used a raw literal lookup while the -// per-request walk classified by canonical name, so the two disagreed: a caller who spelled the key -// "access-control-allow-origin" had it dropped by the classifier AND missed by parseOrigins, which -// then fell through to its wildcard default — turning a config that restricted the origin into one -// that echoed "*" to an unlisted origin. CORS is exported, so callers do build this map themselves. +// Header names are case-insensitive and net/http canonicalizes whatever it is +// given, so two spellings are one header. Without this fold the allow-list read +// by parseOrigins used a raw literal lookup while buildFixedHeaders classified by +// its own raw key, and the two disagreed: a caller spelling the key +// "access-control-allow-origin" -- CORS is exported, so callers do build this map +// -- had it missed by parseOrigins, which fell back to its wildcard default, AND +// routed to buildFixedHeaders' default branch, which canonicalizes it into fixed. +// Since fixed is applied after origin negotiation, that config both lost its +// allow-list and overwrote the negotiated header. // -// The other is determinism. Header names are case-insensitive, so two spellings are one header, and -// a map has no order — resolving the collision during the per-request walk meant the winner was -// whichever key map iteration reached last, and a different value could be sent on different -// requests within a single process. Precedence is explicit here instead: an exactly-canonical -// spelling always wins, and among the rest the lexicographically smallest key does. +// Precedence is explicit rather than left to map iteration order, which would +// otherwise let two spellings of one header resolve differently on different +// requests within a single process: an exactly-canonical spelling always wins, +// and among the rest the lexicographically smallest key does. func canonicalizeConfig(cfg map[string]string) map[string]string { canonical := make(map[string]string, len(cfg)) - - // Track which raw key won each canonical slot, so precedence does not depend on iteration order. winner := make(map[string]string, len(cfg)) for key, value := range cfg { diff --git a/pkg/gofr/http/middleware/cors_test.go b/pkg/gofr/http/middleware/cors_test.go index d8b3055c42..f728bcc172 100644 --- a/pkg/gofr/http/middleware/cors_test.go +++ b/pkg/gofr/http/middleware/cors_test.go @@ -6,6 +6,7 @@ import ( "sort" "strconv" "strings" + "sync" "testing" "github.com/stretchr/testify/assert" @@ -104,7 +105,10 @@ func TestSetMiddlewareHeaders(t *testing.T) { t.Run(tc.name, func(t *testing.T) { w := httptest.NewRecorder() - setMiddlewareHeaders(tc.environmentConfig, tc.registeredRoutes, w, tc.origin, tc.allowedOrigins) + // The fixed headers are now built once per middleware instance + // rather than per request; build them here the same way CORS does. + fixed, methods := buildFixedHeaders(tc.environmentConfig, tc.registeredRoutes) + setMiddlewareHeaders(w, tc.origin, tc.allowedOrigins, fixed, methods) for header, expectedValue := range tc.expectedHeaders { actualValue := w.Header().Get(header) @@ -137,7 +141,7 @@ func setMiddlewareHeadersTestCases() []struct { allowedOrigins: map[string]bool{"*": true}, expectedHeaders: map[string]string{ "Access-Control-Allow-Origin": "*", - "Access-Control-Allow-Headers": corsCharDefaultAllowHeaders, + "Access-Control-Allow-Headers": allowedHeaders, "Access-Control-Allow-Methods": "GET, OPTIONS", }, }, @@ -148,7 +152,7 @@ func setMiddlewareHeadersTestCases() []struct { allowedOrigins: map[string]bool{"*": true}, expectedHeaders: map[string]string{ "Access-Control-Allow-Origin": "*", - "Access-Control-Allow-Headers": corsCharDefaultAllowHeaders + ", clientid", + "Access-Control-Allow-Headers": allowedHeaders + ", clientid", "Access-Control-Allow-Methods": "POST, PUT, OPTIONS", }, }, @@ -164,7 +168,7 @@ func setMiddlewareHeadersTestCases() []struct { expectedHeaders: map[string]string{ "Access-Control-Max-Age": strconv.Itoa(600), "Access-Control-Allow-Origin": "https://example.com", - "Access-Control-Allow-Headers": corsCharDefaultAllowHeaders, + "Access-Control-Allow-Headers": allowedHeaders, "Access-Control-Allow-Methods": "OPTIONS", "Vary": "Origin", }, @@ -178,7 +182,7 @@ func setMiddlewareHeadersTestCases() []struct { allowedOrigins: map[string]bool{"*": true}, expectedHeaders: map[string]string{ "Access-Control-Allow-Origin": "*", - "Access-Control-Allow-Headers": corsCharDefaultAllowHeaders, + "Access-Control-Allow-Headers": allowedHeaders, "Access-Control-Allow-Methods": "GET, POST, PUT, PATCH, DELETE, OPTIONS", }, }, @@ -192,7 +196,7 @@ func setMiddlewareHeadersTestCases() []struct { allowedOrigins: map[string]bool{"https://a.com": true, "https://b.com": true}, expectedHeaders: map[string]string{ "Access-Control-Allow-Origin": "https://b.com", - "Access-Control-Allow-Headers": corsCharDefaultAllowHeaders, + "Access-Control-Allow-Headers": allowedHeaders, "Access-Control-Allow-Methods": "GET, OPTIONS", "Vary": "Origin", }, @@ -207,7 +211,7 @@ func setMiddlewareHeadersTestCases() []struct { allowedOrigins: map[string]bool{"https://a.com": true}, expectedHeaders: map[string]string{ "Access-Control-Allow-Origin": "", - "Access-Control-Allow-Headers": corsCharDefaultAllowHeaders, + "Access-Control-Allow-Headers": allowedHeaders, "Access-Control-Allow-Methods": "GET, OPTIONS", }, }, @@ -267,7 +271,417 @@ func TestParseOrigins(t *testing.T) { } } -// --------------------------------------------------------------------------- +// TestCORSDoesNotMutateRegisteredRoutes pins that building the method list does +// not append into the caller's slice. That slice is the router's +// RegisteredRoutes, and appending in place would write past the caller's length +// whenever capacity exceeded it. +func TestCORSDoesNotMutateRegisteredRoutes(t *testing.T) { + // A sentinel sits just past the caller's length, in spare capacity: an + // in-place append would overwrite exactly that element. + backing := make([]string, 3, 8) + backing[0], backing[1], backing[2] = http.MethodGet, http.MethodPost, "sentinel" + routes := backing[:2] + + _, methods := buildFixedHeaders(map[string]string{}, routes) + + require.Equal(t, []string{"GET, POST, OPTIONS"}, methods) + require.Equal(t, []string{http.MethodGet, http.MethodPost}, routes, + "the caller's slice must be unchanged") + require.Equal(t, "sentinel", backing[2], "nothing may be written past the caller's length") +} + +// TestCORSHeadersStableAcrossRequests pins that precomputing the fixed headers +// yields the same response headers on every request, including a configured +// override and a pass-through custom header. +func TestCORSHeadersStableAcrossRequests(t *testing.T) { + routes := []string{http.MethodGet} + cfg := map[string]string{ + "Access-Control-Allow-Origin": "*", + "X-Custom-Header": "custom", + } + + h := CORS(cfg, &routes)(http.HandlerFunc( + func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusOK) })) + + var first http.Header + + for i := range 5 { + w := httptest.NewRecorder() + h.ServeHTTP(w, httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/x", http.NoBody)) + + if i == 0 { + first = w.Header().Clone() + + continue + } + + require.Equal(t, first, w.Header(), "headers must not drift between requests") + } + + require.Equal(t, "*", first.Get("Access-Control-Allow-Origin")) + require.Equal(t, "GET, OPTIONS", first.Get("Access-Control-Allow-Methods")) + require.Equal(t, "custom", first.Get("X-Custom-Header")) + require.Contains(t, first.Get("Access-Control-Allow-Headers"), "Authorization") +} + +// TestSharedHeaderValueSurvivesAdd is the safety proof for assigning a shared +// one-element value slice straight into the header map: a later Header.Add must +// append into a new array rather than mutating the slice every response shares. +func TestSharedHeaderValueSurvivesAdd(t *testing.T) { + routes := []string{http.MethodGet} + fixed, methods := buildFixedHeaders(map[string]string{}, routes) + + before := append([]string(nil), methods...) + + for range 3 { + h := http.Header{} + setMiddlewareHeaders(h2w(h), "", map[string]bool{"*": true}, fixed, methods) + + h.Add("Access-Control-Allow-Methods", "PATCH") + h.Add("Access-Control-Allow-Headers", "X-Extra") + } + + require.Equal(t, before, methods, "the shared methods slice must never be mutated") + + for _, f := range fixed { + require.Len(t, f.value, 1, "a shared header value must stay single-element") + } +} + +// h2w adapts a bare Header to the ResponseWriter setMiddlewareHeaders expects. +type headerOnlyWriter struct{ h http.Header } + +func (w headerOnlyWriter) Header() http.Header { return w.h } +func (headerOnlyWriter) Write([]byte) (int, error) { return 0, nil } +func (headerOnlyWriter) WriteHeader(int) {} + +func h2w(h http.Header) http.ResponseWriter { return headerOnlyWriter{h: h} } + +// corsBenchWriter is a ResponseWriter that keeps a header map and discards everything else, so a +// benchmark measures the middleware rather than the recorder. +type corsBenchWriter struct{ h http.Header } + +func (w *corsBenchWriter) Header() http.Header { return w.h } +func (*corsBenchWriter) Write(b []byte) (int, error) { return len(b), nil } +func (*corsBenchWriter) WriteHeader(int) {} + +// BenchmarkCORS measures the middleware on the path every request takes: the CORS headers are +// written before the handler runs, on every response, matched or not. +// +// Allocations are the metric that matters here. The header set is constant for the lifetime of the +// server, so building it per request was pure waste. +func BenchmarkCORS(b *testing.B) { + routes := []string{"GET /users", "POST /users", "GET /users/{id}"} + h := CORS(map[string]string{}, &routes)(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {})) + + req := httptest.NewRequestWithContext(b.Context(), http.MethodGet, "/users", http.NoBody) + req.Header.Set("Origin", "https://example.com") + + w := &corsBenchWriter{h: make(http.Header, 8)} + + b.ReportAllocs() + b.ResetTimer() + + for range b.N { + clear(w.h) + h.ServeHTTP(w, req) + } +} + +// TestCORS_OriginAllowListMatchedByCanonicalKey is the regression test for a +// config that restricted the origin being turned into one that echoed a +// wildcard, and for that same config then overwriting the negotiated header. +// +// buildFixedHeaders classifies each config entry by key and writes everything it +// does not recognize into the fixed set, which is applied AFTER the per-request +// origin negotiation. With a raw-key match, a caller spelling the key +// "access-control-allow-origin" -- CORS is exported, so callers do build this map +// -- was missed by parseOrigins, which fell back to its wildcard default, and was +// routed to the default branch, which canonicalized it straight over the +// negotiated Access-Control-Allow-Origin. +func TestCORS_OriginAllowListMatchedByCanonicalKey(t *testing.T) { + for _, spelling := range []string{ + "Access-Control-Allow-Origin", + "access-control-allow-origin", + "ACCESS-CONTROL-ALLOW-ORIGIN", + "Access-control-allow-origin", + } { + t.Run(spelling, func(t *testing.T) { + routes := []string{http.MethodGet} + handler := CORS(map[string]string{spelling: "https://trusted.com"}, &routes)( + http.HandlerFunc(func(http.ResponseWriter, *http.Request) {})) + + unlisted := httptest.NewRecorder() + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/", http.NoBody) + req.Header.Set("Origin", "https://evil.com") + handler.ServeHTTP(unlisted, req) + + assert.Empty(t, unlisted.Header().Get(headerAccessControlAllowOrigin), + "an unlisted origin must not be granted access under any spelling of the config key") + + listed := httptest.NewRecorder() + req = httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/", http.NoBody) + req.Header.Set("Origin", "https://trusted.com") + handler.ServeHTTP(listed, req) + + assert.Equal(t, "https://trusted.com", listed.Header().Get(headerAccessControlAllowOrigin), + "the negotiated origin must survive the fixed-header pass that runs after it") + assert.Equal(t, "Origin", listed.Header().Get("Vary")) + }) + } +} + +// TestCORS_CaseVariantMethodsAndHeadersAreClassified pins the other two headers +// the classifier owns. A case-variant spelling reaching the default branch would +// REPLACE the derived Allow-Methods, or replace rather than extend the +// framework's required Allow-Headers. +func TestCORS_CaseVariantMethodsAndHeadersAreClassified(t *testing.T) { + routes := []string{http.MethodGet} + handler := CORS(map[string]string{ + "access-control-allow-methods": "GET, PATCH", + "access-control-allow-headers": "clientid", + }, &routes)(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {})) + + w := httptest.NewRecorder() + handler.ServeHTTP(w, httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/", http.NoBody)) + + assert.Equal(t, "GET, PATCH", w.Header().Get(headerAccessControlAllowMethods), + "a configured method list replaces the derived one") + assert.Equal(t, allowedHeaders+", clientid", w.Header().Get(headerAccessControlAllowHeaders), + "configured headers extend the framework's required set rather than replacing it") +} + +// TestCORS_DuplicateSpellingsResolveDeterministically pins the precedence rule. +// Two spellings of one header are one header, and the map they arrive in has no +// order, so leaving the collision to the classifier let map iteration decide the +// winner -- a different value could be sent on different requests in one process. +func TestCORS_DuplicateSpellingsResolveDeterministically(t *testing.T) { + routes := []string{http.MethodGet} + handler := CORS(map[string]string{ + "Access-Control-Allow-Headers": "X-Canonical", + "access-control-allow-headers": "x-lower", + "ACCESS-CONTROL-ALLOW-HEADERS": "X-UPPER", + }, &routes)(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {})) + + for range 50 { + w := httptest.NewRecorder() + handler.ServeHTTP(w, httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/", http.NoBody)) + + assert.Equal(t, allowedHeaders+", X-Canonical", w.Header().Get(headerAccessControlAllowHeaders), + "the exactly-canonical spelling must win, on every request") + } +} + +// TestSharedHeaderValuesHaveNoSpareCapacity states the invariant the shared +// value slices rest on, for every slice rather than only the ones a particular +// test happens to touch. A shared slice with room to grow would let one +// response's Header.Add write into every other response's header, process-wide. +func TestSharedHeaderValuesHaveNoSpareCapacity(t *testing.T) { + routes := []string{http.MethodGet, http.MethodPost} + fixed, methods := buildFixedHeaders(canonicalizeConfig(map[string]string{ + "Access-Control-Max-Age": "600", + "access-control-allow-headers": "clientid", + }), routes) + + require.Len(t, methods, 1) + assert.Equal(t, 1, cap(methods), "the shared methods slice must have no spare capacity") + + assert.Equal(t, 1, cap(wildcardOrigin), "the shared wildcard origin must have no spare capacity") + + for _, f := range fixed { + assert.Len(t, f.value, 1, "a shared header value must stay single-element") + assert.Equal(t, 1, cap(f.value), "a shared header value must have no spare capacity: "+f.key) + } +} + +// BenchmarkCORS_NamedOrigin measures the branch BenchmarkCORS does not reach. +// An empty config takes the wildcard fast path, where the value slice is shared +// and nothing allocates; a named-origin config still goes through Header.Set and +// Vary's Header.Add, so the "→ 0 allocs" claim does not hold for it. +func BenchmarkCORS_NamedOrigin(b *testing.B) { + routes := []string{"GET /users", "POST /users", "GET /users/{id}"} + h := CORS(map[string]string{ + headerAccessControlAllowOrigin: "https://a.example.com, https://b.example.com", + }, &routes)(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {})) + + req := httptest.NewRequestWithContext(b.Context(), http.MethodGet, "/users", http.NoBody) + req.Header.Set("Origin", "https://b.example.com") + + w := &corsBenchWriter{h: make(http.Header, 8)} + + b.ReportAllocs() + b.ResetTimer() + + for range b.N { + clear(w.h) + h.ServeHTTP(w, req) + } +} + +// TestCORS_WildcardPathIsAllocationFree guards the headline claim with a number +// rather than a benchmark reading, so a regression fails the suite instead of +// quietly showing up in a table nobody diffs. +func TestCORS_WildcardPathIsAllocationFree(t *testing.T) { + routes := []string{"GET /users", "POST /users"} + h := CORS(map[string]string{}, &routes)(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {})) + + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/users", http.NoBody) + req.Header.Set("Origin", "https://example.com") + + w := &corsBenchWriter{h: make(http.Header, 8)} + + // Warm the sync.Once so first-request construction is not counted. + h.ServeHTTP(w, req) + + allocs := testing.AllocsPerRun(200, func() { + clear(w.h) + h.ServeHTTP(w, req) + }) + + assert.Zero(t, allocs, "the wildcard path must write its headers without allocating") +} + +// corsLifecycleServe issues one request through h and returns the response headers. +func corsLifecycleServe(t *testing.T, h http.Handler, origin string) http.Header { + t.Helper() + + w := httptest.NewRecorder() + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/x", http.NoBody) + + if origin != "" { + req.Header.Set("Origin", origin) + } + + h.ServeHTTP(w, req) + + return w.Header() +} + +func corsLifecycleNoop() http.Handler { + return http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}) +} + +// TestCORSLifecycleContract pins WHEN the configuration and the route set are +// read, which is the one behavioral difference this PR introduces against the +// per-request build it replaces. +// +// The contract is a single rule: BOTH inputs are read exactly once, on the first +// request, and never again. The rule matters because the two halves used to +// freeze at different instants -- the config at construction, the routes at the +// first request -- a split nothing documented and nobody would expect. Anything +// completed before the first request is therefore still honored, which is what +// this test covers; TestCORSLifecycleFrozenAfterFirstRequest covers the other +// half. +func TestCORSLifecycleContract(t *testing.T) { + t.Run("config completed before the first request is observed", func(t *testing.T) { + cfg := map[string]string{} + routes := []string{http.MethodGet} + h := CORS(cfg, &routes)(corsLifecycleNoop()) + + cfg["Access-Control-Max-Age"] = "99" + cfg[headerAccessControlAllowOrigin] = "https://late.com" + + got := corsLifecycleServe(t, h, "https://late.com") + + assert.Equal(t, "99", got.Get("Access-Control-Max-Age"), + "a config completed after CORS() but before serving must still be honored") + assert.Equal(t, "https://late.com", got.Get(headerAccessControlAllowOrigin), + "the allow-list must be built from the same snapshot as the fixed headers") + }) + + t.Run("routes appended before the first request are observed", func(t *testing.T) { + routes := make([]string, 0, 3) + routes = append(routes, http.MethodGet) + + h := CORS(map[string]string{}, &routes)(corsLifecycleNoop()) + + // Exactly what handler registration does: finish the route list, then serve. + routes = append(routes, http.MethodPatch, http.MethodDelete) + + assert.Equal(t, "GET, PATCH, DELETE, OPTIONS", + corsLifecycleServe(t, h, "").Get(headerAccessControlAllowMethods)) + }) + + t.Run("routes replaced through the pointer before serving are observed", func(t *testing.T) { + // gofr.go assigns rather than appends: *RegisteredRoutes = registeredMethods. + routes := []string{http.MethodGet} + h := CORS(map[string]string{}, &routes)(corsLifecycleNoop()) + + routes = []string{http.MethodPost, http.MethodPut} + + assert.Equal(t, "POST, PUT, OPTIONS", + corsLifecycleServe(t, h, "").Get(headerAccessControlAllowMethods)) + }) +} + +// TestCORSLifecycleFrozenAfterFirstRequest pins the other half of the contract. +// +// Mutating either input after the first request is served is unsupported, and +// deliberately so: both are read from every serving goroutine, so a caller +// mutating them concurrently races regardless of when the read happens. Freezing +// makes that race impossible rather than merely unlikely. GoFr never does it -- +// GetConfigs builds the map fully before handing it to CORS, and httpServerSetup +// assigns the final route list synchronously before the serve goroutine starts. +func TestCORSLifecycleFrozenAfterFirstRequest(t *testing.T) { + t.Run("both inputs are frozen once a request has been served", func(t *testing.T) { + cfg := map[string]string{"Access-Control-Max-Age": "600"} + routes := make([]string, 0, 2) + routes = append(routes, http.MethodGet) + + h := CORS(cfg, &routes)(corsLifecycleNoop()) + + before := corsLifecycleServe(t, h, "") + require.Equal(t, "600", before.Get("Access-Control-Max-Age")) + require.Equal(t, "GET, OPTIONS", before.Get(headerAccessControlAllowMethods)) + + cfg["Access-Control-Max-Age"] = "1" + cfg[headerAccessControlAllowHeaders] = "clientid" + + routes = append(routes, http.MethodDelete) + + after := corsLifecycleServe(t, h, "") + + assert.Equal(t, "600", after.Get("Access-Control-Max-Age"), + "config is frozen after the first request") + assert.Equal(t, allowedHeaders, after.Get(headerAccessControlAllowHeaders), + "config is frozen after the first request") + assert.Equal(t, "GET, OPTIONS", after.Get(headerAccessControlAllowMethods), + "routes are frozen after the first request") + }) + + t.Run("the freeze happens exactly once under concurrent first requests", func(t *testing.T) { + routes := []string{http.MethodGet, http.MethodPost} + h := CORS(map[string]string{"Access-Control-Max-Age": "600"}, &routes)(corsLifecycleNoop()) + + const n = 200 + + var ( + wg sync.WaitGroup + mu sync.Mutex + seen = map[string]int{} + ) + + for range n { + wg.Add(1) + + go func() { + defer wg.Done() + + got := corsLifecycleServe(t, h, "").Get(headerAccessControlAllowMethods) + + mu.Lock() + seen[got]++ + mu.Unlock() + }() + } + + wg.Wait() + + assert.Equal(t, map[string]int{"GET, POST, OPTIONS": n}, seen, + "every concurrent first request must observe the same fully-built header set") + }) +} + // Characterization suite: pins the EXACT observable output of the CORS // middleware. Every helper/type/const below is prefixed with `corsChar` and // every test with `Test_CORSContract` to stay collision-free. @@ -286,6 +700,9 @@ func TestParseOrigins(t *testing.T) { const corsCharDefaultAllowHeaders = "Authorization, Content-Type, x-requested-with, " + "origin, true-client-ip, X-Correlation-ID" +// Test_CORSContract_DefaultAllowHeadersLiteral pins the exact bytes of the +// default Access-Control-Allow-Headers value. + // Test_CORSContract_DefaultAllowHeadersLiteral pins the exact bytes of the // default Access-Control-Allow-Headers value. func Test_CORSContract_DefaultAllowHeadersLiteral(t *testing.T) { @@ -304,6 +721,8 @@ const ( corsCharVaryLine = "Vary: Origin" ) +// corsCharSpyHandler records whether the inner handler was reached. + // corsCharSpyHandler records whether the inner handler was reached. type corsCharSpyHandler struct { called int @@ -316,6 +735,9 @@ func (h *corsCharSpyHandler) ServeHTTP(w http.ResponseWriter, _ *http.Request) { _, _ = w.Write([]byte(corsCharBody)) } +// corsCharHeaderLines renders a whole http.Header into a deterministic, sorted +// slice of "Key: v1, v2" lines so a full snapshot can be compared exactly. + // corsCharHeaderLines renders a whole http.Header into a deterministic, sorted // slice of "Key: v1, v2" lines so a full snapshot can be compared exactly. func corsCharHeaderLines(h http.Header) []string { @@ -341,6 +763,8 @@ func corsCharMethodsLine(v string) string { return corsCharKeyMethods + ": " + v func corsCharOriginLine(v string) string { return corsCharKeyOrigin + ": " + v } +// corsCharRun drives the middleware once and returns the recorder plus the spy. + // corsCharRun drives the middleware once and returns the recorder plus the spy. func corsCharRun(t *testing.T, cfg map[string]string, routes *[]string, method, origin string, @@ -576,6 +1000,9 @@ func corsCharCustomHeaderCases() []corsCharCase { } } +// corsCharGarbageKeyCases pins what happens for config keys that are not the +// canonical, exactly-cased header names the implementation compares against. + // corsCharGarbageKeyCases pins what happens for config keys that are not the // canonical, exactly-cased header names the implementation compares against. func corsCharGarbageKeyCases() []corsCharCase { @@ -722,27 +1149,6 @@ func Test_CORSContract_AllowMethodsJoin(t *testing.T) { // Test_CORSContract_RoutesReadAtRequestTime pins that the routes slice is // dereferenced per request, so routes registered after the middleware was // constructed do show up in Access-Control-Allow-Methods. -func Test_CORSContract_RoutesReadAtRequestTime(t *testing.T) { - routes := []string{http.MethodGet} - handler := CORS(nil, &routes)(&corsCharSpyHandler{}) - - first := httptest.NewRecorder() - handler.ServeHTTP(first, httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/hello", http.NoBody)) - require.Equal(t, "GET, OPTIONS", first.Header().Get(corsCharKeyMethods)) - - routes = []string{http.MethodGet, http.MethodPost} - - second := httptest.NewRecorder() - handler.ServeHTTP(second, httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/hello", http.NoBody)) - assert.Equal(t, "GET, POST, OPTIONS", second.Header().Get(corsCharKeyMethods)) - - // Replacing the whole slice through the same variable is also picked up. - routes = []string{http.MethodDelete} - - third := httptest.NewRecorder() - handler.ServeHTTP(third, httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/hello", http.NoBody)) - assert.Equal(t, "DELETE, OPTIONS", third.Header().Get(corsCharKeyMethods)) -} // Test_CORSContract_RoutesBackingArrayAliasing guards against writing through // the caller's route slice. The header used to be built with @@ -776,76 +1182,6 @@ func Test_CORSContract_RoutesBackingArrayAliasing(t *testing.T) { assert.Equal(t, "GET, POST, OPTIONS", w2.Header().Get(corsCharKeyMethods)) assert.Equal(t, "SENTINEL-2", backing[2], "second request must not clobber the array either") } - -// Test_CORSContract_ParseOriginsEvaluatedOnce pins that the allowed-origin set -// is computed ONCE at construction time, so mutating the config map afterwards -// does not change origin matching, even though the header-setting loop does -// read the map on every request. -func Test_CORSContract_ParseOriginsEvaluatedOnce(t *testing.T) { - cfg := map[string]string{corsCharKeyOrigin: corsCharOriginA} - routes := []string{http.MethodGet} - handler := CORS(cfg, &routes)(&corsCharSpyHandler{}) - - cfg[corsCharKeyOrigin] = corsCharOriginB - - // The stale set still matches the ORIGINAL origin. - stale := httptest.NewRecorder() - reqA := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/hello", http.NoBody) - reqA.Header.Set("Origin", corsCharOriginA) - handler.ServeHTTP(stale, reqA) - - assert.Equal(t, corsCharSorted([]string{ - corsCharAllowHeadersLine, corsCharMethodsLine("GET, OPTIONS"), - corsCharOriginLine(corsCharOriginA), corsCharVaryLine, - }), corsCharHeaderLines(stale.Header())) - - // The newly configured origin is NOT honored. - fresh := httptest.NewRecorder() - reqB := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/hello", http.NoBody) - reqB.Header.Set("Origin", corsCharOriginB) - handler.ServeHTTP(fresh, reqB) - - assert.Equal(t, corsCharSorted([]string{ - corsCharAllowHeadersLine, corsCharMethodsLine("GET, OPTIONS"), - }), corsCharHeaderLines(fresh.Header())) -} - -// Test_CORSContract_ConfigMutationIsIgnoredAfterConstruction pins the other -// half. The configuration is folded onto canonical header keys once, inside -// CORS, so a caller that mutates the map afterwards changes nothing. -// -// The custom-header loop used to read the map on every request, which made -// post-construction keys appear immediately. That was never a feature worth -// keeping: the map is read from every serving goroutine, so a caller mutating -// it while requests are in flight is a data race, and the origin allow-list had -// already been resolved once at construction — so the two halves of the same -// config disagreed about when it was read. -func Test_CORSContract_ConfigMutationIsIgnoredAfterConstruction(t *testing.T) { - cfg := map[string]string{} - routes := []string{http.MethodGet} - handler := CORS(cfg, &routes)(&corsCharSpyHandler{}) - - before := httptest.NewRecorder() - handler.ServeHTTP(before, httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/hello", http.NoBody)) - require.Equal(t, corsCharSorted([]string{ - corsCharAllowHeadersLine, corsCharMethodsLine("GET, OPTIONS"), corsCharOriginLine("*"), - }), corsCharHeaderLines(before.Header())) - - cfg["Access-Control-Max-Age"] = "42" - cfg[corsCharKeyHeaders] = "clientid" - cfg[corsCharKeyMethods] = "GET, PATCH" - - after := httptest.NewRecorder() - handler.ServeHTTP(after, httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/hello", http.NoBody)) - - assert.Equal(t, corsCharSorted([]string{ - corsCharAllowHeadersLine, corsCharMethodsLine("GET, OPTIONS"), corsCharOriginLine("*"), - }), corsCharHeaderLines(after.Header()), "the response must be identical to the one before the mutation") -} - -// Test_CORSContract_CustomHeaderLoopIsOrderIndependent pins that Go's random -// map iteration order over the custom-header loop cannot change the final -// header set. func Test_CORSContract_CustomHeaderLoopIsOrderIndependent(t *testing.T) { cfg := map[string]string{ corsCharKeyOrigin: corsCharOriginA, @@ -880,6 +1216,9 @@ func Test_CORSContract_CustomHeaderLoopIsOrderIndependent(t *testing.T) { } } +// Test_CORSContract_VaryIsAddedNotSet pins that Vary is added once per request +// and that repeated requests on fresh recorders never accumulate values. + // Test_CORSContract_VaryIsAddedNotSet pins that Vary is added once per request // and that repeated requests on fresh recorders never accumulate values. func Test_CORSContract_VaryIsAddedNotSet(t *testing.T) { @@ -897,6 +1236,10 @@ func Test_CORSContract_VaryIsAddedNotSet(t *testing.T) { } } +// Test_CORSContract_VaryAccumulatesOnSharedResponseWriter pins that the +// middleware uses Add (not Set) for Vary, so a pre-existing Vary value is +// preserved and appended to. + // Test_CORSContract_VaryAccumulatesOnSharedResponseWriter pins that the // middleware uses Add (not Set) for Vary, so a pre-existing Vary value is // preserved and appended to. @@ -948,6 +1291,9 @@ func Test_CORSContract_ParseOriginsExact(t *testing.T) { } } +// Test_CORSContract_WildcardBeatsExplicitMatch pins that a "*" entry anywhere in +// the list short-circuits dynamic matching and suppresses Vary entirely. + // Test_CORSContract_WildcardBeatsExplicitMatch pins that a "*" entry anywhere in // the list short-circuits dynamic matching and suppresses Vary entirely. func Test_CORSContract_WildcardBeatsExplicitMatch(t *testing.T) { @@ -962,6 +1308,9 @@ func Test_CORSContract_WildcardBeatsExplicitMatch(t *testing.T) { assert.Empty(t, w.Header().Values("Vary")) } +// Test_CORSContract_OptionsSkipsInnerHandlerForEveryConfig pins that OPTIONS +// short-circuits regardless of configuration or origin match. + // Test_CORSContract_OptionsSkipsInnerHandlerForEveryConfig pins that OPTIONS // short-circuits regardless of configuration or origin match. func Test_CORSContract_OptionsSkipsInnerHandlerForEveryConfig(t *testing.T) { @@ -988,6 +1337,9 @@ func Test_CORSContract_OptionsSkipsInnerHandlerForEveryConfig(t *testing.T) { } } +// Test_CORSContract_NonOptionsMethodsAlwaysReachInner pins that every +// non-OPTIONS method falls through to the inner handler unchanged. + // Test_CORSContract_NonOptionsMethodsAlwaysReachInner pins that every // non-OPTIONS method falls through to the inner handler unchanged. func Test_CORSContract_NonOptionsMethodsAlwaysReachInner(t *testing.T) { @@ -1012,125 +1364,6 @@ func Test_CORSContract_NonOptionsMethodsAlwaysReachInner(t *testing.T) { // Test_CORSContract_SetMiddlewareHeadersDirectSnapshot pins the unexported // helper directly, including the case where the passed allowedOrigins set // disagrees with the config map (which the exported CORS wrapper cannot do). -func Test_CORSContract_SetMiddlewareHeadersDirectSnapshot(t *testing.T) { - cases := []struct { - name string - config map[string]string - routes []string - origin string - allowed map[string]bool - expLines []string - }{ - { - name: "nil allowed origins set emits no origin header", config: map[string]string{}, - routes: []string{http.MethodGet}, origin: corsCharOriginA, allowed: nil, - expLines: []string{corsCharAllowHeadersLine, corsCharMethodsLine("GET, OPTIONS")}, - }, - { - name: "empty allowed origins set emits no origin header", config: map[string]string{}, - routes: []string{http.MethodGet}, origin: corsCharOriginA, allowed: map[string]bool{}, - expLines: []string{corsCharAllowHeadersLine, corsCharMethodsLine("GET, OPTIONS")}, - }, - { - name: "false valued entry does not match", config: map[string]string{}, - routes: []string{http.MethodGet}, origin: corsCharOriginA, - allowed: map[string]bool{corsCharOriginA: false}, - expLines: []string{corsCharAllowHeadersLine, corsCharMethodsLine("GET, OPTIONS")}, - }, - { - name: "empty string origin can be allowed and is echoed as an empty header", - config: map[string]string{}, routes: []string{http.MethodGet}, origin: "", - allowed: map[string]bool{"": true}, - expLines: []string{ - corsCharAllowHeadersLine, corsCharMethodsLine("GET, OPTIONS"), - corsCharKeyOrigin + ": ", corsCharVaryLine, - }, - }, - { - name: "allowed set overrides what the config map says", config: map[string]string{corsCharKeyOrigin: corsCharOriginA}, - routes: []string{http.MethodGet}, origin: corsCharOriginEvil, - allowed: map[string]bool{corsCharOriginEvil: true}, - expLines: []string{ - corsCharAllowHeadersLine, corsCharMethodsLine("GET, OPTIONS"), - corsCharOriginLine(corsCharOriginEvil), corsCharVaryLine, - }, - }, - } - - for i := range cases { - tc := &cases[i] - - t.Run(tc.name, func(t *testing.T) { - w := httptest.NewRecorder() - setMiddlewareHeaders(tc.config, tc.routes, w, tc.origin, tc.allowed) - - assert.Equal(t, corsCharSorted(tc.expLines), corsCharHeaderLines(w.Header())) - }) - } -} - -// TestCORS_OriginAllowListMatchedByCanonicalKey is the regression test for a config that restricted -// the origin being turned into one that echoed a wildcard. -// -// setMiddlewareHeaders classifies config entries by canonical header name, but the allow-list was -// read with a raw literal lookup. A caller spelling the key "access-control-allow-origin" — CORS is -// exported, so callers do build this map — had it dropped by the classifier and missed by -// parseOrigins, which then fell back to its wildcard default and sent "*" to an unlisted origin. -func TestCORS_OriginAllowListMatchedByCanonicalKey(t *testing.T) { - spellings := []string{ - "Access-Control-Allow-Origin", - "access-control-allow-origin", - "ACCESS-CONTROL-ALLOW-ORIGIN", - "Access-control-allow-origin", - } - - for _, spelling := range spellings { - t.Run(spelling, func(t *testing.T) { - routes := []string{http.MethodGet} - handler := CORS(map[string]string{spelling: "https://trusted.com"}, &routes)( - http.HandlerFunc(func(http.ResponseWriter, *http.Request) {})) - - unlisted := httptest.NewRecorder() - req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/", http.NoBody) - req.Header.Set("Origin", "https://evil.com") - handler.ServeHTTP(unlisted, req) - - assert.Empty(t, unlisted.Header().Get(headerAccessControlAllowOrigin), - "an unlisted origin must not be granted access under any spelling of the config key") - - listed := httptest.NewRecorder() - req = httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/", http.NoBody) - req.Header.Set("Origin", "https://trusted.com") - handler.ServeHTTP(listed, req) - - assert.Equal(t, "https://trusted.com", listed.Header().Get(headerAccessControlAllowOrigin)) - assert.Equal(t, "Origin", listed.Header().Get("Vary"), - "a negotiated origin must not be cached across origins") - }) - } -} - -// TestCORS_DuplicateSpellingsResolveDeterministically pins the precedence rule. Two spellings of one -// header are one header, and the map they arrive in has no order, so resolving the collision during -// the per-request walk let map iteration decide the winner — a different value could be sent on -// different requests within a single process. -func TestCORS_DuplicateSpellingsResolveDeterministically(t *testing.T) { - routes := []string{http.MethodGet} - handler := CORS(map[string]string{ - "Access-Control-Allow-Headers": "X-Canonical", - "access-control-allow-headers": "x-lower", - "ACCESS-CONTROL-ALLOW-HEADERS": "X-UPPER", - }, &routes)(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {})) - - // Many requests, because the bug this guards was probabilistic. - for range 50 { - w := httptest.NewRecorder() - handler.ServeHTTP(w, httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/", http.NoBody)) - - assert.Equal(t, allowedHeaders+", X-Canonical", w.Header().Get(headerAccessControlAllowHeaders), - "the exactly-canonical spelling must win, on every request") - } -} // TestCanonicalizeConfig_Precedence covers the fold directly, including the tie-break among // non-canonical spellings where no key is the canonical one. From 2f1f58dacb0b861563b62a53636eead7a35140db Mon Sep 17 00:00:00 2001 From: Aditya Kumar Mishra <154746713+adityakrmishra@users.noreply.github.com> Date: Fri, 4 Sep 2026 11:32:49 +0530 Subject: [PATCH 06/48] fix: prevent concurrent map panic during kafka client teardown (#3502) Co-authored-by: aryanmehrotra --- pkg/gofr/datasource/pubsub/kafka/conn.go | 37 ++- pkg/gofr/datasource/pubsub/kafka/errors.go | 1 + pkg/gofr/datasource/pubsub/kafka/health.go | 19 +- pkg/gofr/datasource/pubsub/kafka/helper.go | 19 +- pkg/gofr/datasource/pubsub/kafka/kafka.go | 64 ++++- .../datasource/pubsub/kafka/kafka_test.go | 18 +- .../pubsub/kafka/lock_order_test.go | 104 ++++++++ .../kafka/reader_map_integration_test.go | 227 ++++++++++++++++ .../pubsub/kafka/reader_map_race_test.go | 243 ++++++++++++++++++ .../kafka/reconnect_concurrency_test.go | 46 +++- .../pubsub/kafka/reconnect_success_test.go | 3 - .../pubsub/kafka/writer_race_test.go | 80 ++++++ 12 files changed, 829 insertions(+), 32 deletions(-) create mode 100644 pkg/gofr/datasource/pubsub/kafka/lock_order_test.go create mode 100644 pkg/gofr/datasource/pubsub/kafka/reader_map_integration_test.go create mode 100644 pkg/gofr/datasource/pubsub/kafka/reader_map_race_test.go create mode 100644 pkg/gofr/datasource/pubsub/kafka/writer_race_test.go diff --git a/pkg/gofr/datasource/pubsub/kafka/conn.go b/pkg/gofr/datasource/pubsub/kafka/conn.go index fb042ddd41..f46f8b7bbe 100644 --- a/pkg/gofr/datasource/pubsub/kafka/conn.go +++ b/pkg/gofr/datasource/pubsub/kafka/conn.go @@ -44,14 +44,43 @@ func (k *kafkaClient) initialize(ctx context.Context) error { k.logger.Logf("connected to %d Kafka brokers", len(conns)) k.connMu.Lock() + + // Close only signals the retry goroutine; it cannot interrupt a dial + // already in flight. Re-check under the same lock Close takes, so a + // retryConnect that got past its own check cannot revive a closed client + // and leak this conn pool and writer for the life of the process. + // A nil k.closed (a client built without New) never fires, so the + // default arm is the normal path. + select { + case <-k.closed: + k.connMu.Unlock() + + return errors.Join(errClientClosed, multi.Close(), writer.Close()) + default: + } + k.dialer = dialer k.conn = multi - k.connMu.Unlock() - // writer and reader are not guarded by connMu — k.mu protects the - // reader map; writer is set once and never swapped. + // writer is published under connMu alongside conn: retryConnect calls + // initialize from its own goroutine, so this is a pointer swap that + // Publish, Close and Health can all be reading concurrently. k.writer = writer - k.reader = reader + + k.connMu.Unlock() + + // retryConnect calls initialize from its own goroutine, so this swap can + // land while a Subscribe is reading or growing the map. Take k.mu for it, + // the same lock Subscribe uses, and keep any readers a concurrent + // Subscribe already created rather than dropping them on the floor — + // their committers are already handed out to callers. + k.mu.Lock() + + if k.reader == nil { + k.reader = reader + } + + k.mu.Unlock() return nil } diff --git a/pkg/gofr/datasource/pubsub/kafka/errors.go b/pkg/gofr/datasource/pubsub/kafka/errors.go index 188a0d53cc..0b424749af 100644 --- a/pkg/gofr/datasource/pubsub/kafka/errors.go +++ b/pkg/gofr/datasource/pubsub/kafka/errors.go @@ -19,4 +19,5 @@ var ( errClientCertLoad = errors.New("failed to load client certificate") errNotController = errors.New("not a controller") errUnreachable = errors.New("unreachable") + errClientClosed = errors.New("kafka client is closed") ) diff --git a/pkg/gofr/datasource/pubsub/kafka/health.go b/pkg/gofr/datasource/pubsub/kafka/health.go index 492afea436..aa37649c3e 100644 --- a/pkg/gofr/datasource/pubsub/kafka/health.go +++ b/pkg/gofr/datasource/pubsub/kafka/health.go @@ -15,8 +15,15 @@ func (k *kafkaClient) Health() datasource.Health { Details: make(map[string]any), } - // Hold connMu across the whole health probe so reconnectAdmin cannot - // swap and close the conn we are reading from underneath us. + // Snapshot the readers *before* taking connMu. Subscribe holds k.mu and + // then takes connMu inside getNewReader, so taking k.mu while holding + // connMu here would be a lock-order inversion: a pending connMu writer + // parks Subscribe's RLock, Subscribe still holds k.mu, and this probe + // waits on k.mu while holding the connMu read the writer needs. + readers := k.snapshotReaders() + + // Hold connMu across the rest of the health probe so reconnectAdmin + // cannot swap and close the conn we are reading from underneath us. k.connMu.RLock() defer k.connMu.RUnlock() @@ -37,7 +44,7 @@ func (k *kafkaClient) Health() datasource.Health { health.Details["brokers"] = brokerStatus health.Details["backend"] = "KAFKA" health.Details["writer"] = k.getWriterStatsAsMap() - health.Details["readers"] = k.getReaderStatsAsMap() + health.Details["readers"] = k.getReaderStatsAsMap(readers) return health } @@ -97,10 +104,10 @@ func checkBroker(conn Connection, controllerAddr *string) map[string]any { return status } -func (k *kafkaClient) getReaderStatsAsMap() []any { - readerStats := make([]any, 0) +func (k *kafkaClient) getReaderStatsAsMap(readers []Reader) []any { + readerStats := make([]any, 0, len(readers)) - for _, reader := range k.reader { + for _, reader := range readers { var readerStat map[string]any if err := convertStructToMap(reader.Stats(), &readerStat); err != nil { k.logger.Errorf("kafka Reader Stats processing failed: %v", err) diff --git a/pkg/gofr/datasource/pubsub/kafka/helper.go b/pkg/gofr/datasource/pubsub/kafka/helper.go index b6566f637b..27e55f3686 100644 --- a/pkg/gofr/datasource/pubsub/kafka/helper.go +++ b/pkg/gofr/datasource/pubsub/kafka/helper.go @@ -56,11 +56,28 @@ func validateRequiredFields(conf *Config) error { // retryConnect handles the retry mechanism for connecting to the Kafka broker. func (k *kafkaClient) retryConnect(ctx context.Context) { + timer := time.NewTimer(defaultRetryTimeout) + defer timer.Stop() + for { - time.Sleep(defaultRetryTimeout) + select { + case <-k.closed: + return + case <-ctx.Done(): + return + case <-timer.C: + timer.Reset(defaultRetryTimeout) + } err := k.initialize(ctx) if err != nil { + // Close landed while this dial was in flight. Nothing was + // published and the dialed conn is already shut; logging a + // connect failure here would be misleading. + if errors.Is(err, errClientClosed) { + return + } + var brokers any if len(k.config.Brokers) > 1 { diff --git a/pkg/gofr/datasource/pubsub/kafka/kafka.go b/pkg/gofr/datasource/pubsub/kafka/kafka.go index aef15658ba..99dbfef168 100644 --- a/pkg/gofr/datasource/pubsub/kafka/kafka.go +++ b/pkg/gofr/datasource/pubsub/kafka/kafka.go @@ -60,8 +60,10 @@ type kafkaClient struct { writer Writer reader map[string]Reader - // mu guards the reader map. - mu *sync.RWMutex + // mu guards the reader map. A value, not a pointer, so the zero + // kafkaClient is usable: Health and Close take it, and a nil pointer + // here panicked on any client built without New. + mu sync.RWMutex // connMu guards conn/dialer pointer swaps performed by reconnectAdmin. // Read-lock holders use the admin connection concurrently; the // write-lock holder swaps the pointer and closes the old multiConn. @@ -78,6 +80,13 @@ type kafkaClient struct { logger pubsub.Logger config Config metrics Metrics + + // closed is shut by Close to stop the retryConnect goroutine New starts + // when the first connect attempt fails. Without it that goroutine runs + // for the life of the process on a context nobody can cancel, retrying + // every defaultRetryTimeout long after the client was closed. + closed chan struct{} + closeOnce sync.Once } func New(conf *Config, logger pubsub.Logger, metrics Metrics) *kafkaClient { //nolint:revive // New allows @@ -99,7 +108,7 @@ func New(conf *Config, logger pubsub.Logger, metrics Metrics) *kafkaClient { //n logger: logger, config: *conf, metrics: metrics, - mu: &sync.RWMutex{}, + closed: make(chan struct{}), } ctx := context.Background() @@ -121,12 +130,13 @@ func (k *kafkaClient) Publish(ctx context.Context, topic string, message []byte) k.metrics.IncrementCounter(ctx, "app_pubsub_publish_total_count", "topic", topic) - if k.writer == nil || topic == "" { + writer := k.snapshotWriter() + if writer == nil || topic == "" { return errPublisherNotConfigured } start := time.Now() - err := k.writer.WriteMessages(ctx, + err := writer.WriteMessages(ctx, kafka.Message{ Topic: topic, Value: message, @@ -238,7 +248,7 @@ func (k *kafkaClient) Subscribe(ctx context.Context, topic string) (*pubsub.Mess m := pubsub.NewMessage(ctx) m.Value = msg.Value m.Topic = topic - m.Committer = newKafkaMessage(&msg, k.reader[topic], k.logger) + m.Committer = newKafkaMessage(&msg, reader, k.logger) end := time.Since(start) @@ -266,16 +276,25 @@ func (k *kafkaClient) Subscribe(ctx context.Context, topic string) (*pubsub.Mess } func (k *kafkaClient) Close() (err error) { - for _, r := range k.reader { + // Stop the retryConnect goroutine first, so it cannot dial or swap the + // conn out from under the teardown below. + k.closeOnce.Do(func() { + if k.closed != nil { + close(k.closed) + } + }) + + for _, r := range k.snapshotReaders() { err = errors.Join(err, r.Close()) } + k.connMu.Lock() + if k.writer != nil { err = errors.Join(err, k.writer.Close()) + k.writer = nil } - k.connMu.Lock() - if k.conn != nil { err = errors.Join(err, k.conn.Close()) k.conn = nil @@ -285,3 +304,30 @@ func (k *kafkaClient) Close() (err error) { return err } + +// snapshotWriter reads k.writer under connMu, which initialize takes when it +// publishes one. Callers use the returned value rather than k.writer so a +// retryConnect swapping the pointer cannot race the read, and so no network +// call is made while holding the lock. +func (k *kafkaClient) snapshotWriter() Writer { + k.connMu.RLock() + defer k.connMu.RUnlock() + + return k.writer +} + +// snapshotReaders copies the reader map under RLock so callers can work on the +// readers without holding it. Nothing that calls this may already hold connMu: +// Subscribe takes k.mu and then connMu inside getNewReader, so acquiring them +// the other way round is a lock-order inversion. +func (k *kafkaClient) snapshotReaders() []Reader { + k.mu.RLock() + defer k.mu.RUnlock() + + readers := make([]Reader, 0, len(k.reader)) + for _, r := range k.reader { + readers = append(readers, r) + } + + return readers +} diff --git a/pkg/gofr/datasource/pubsub/kafka/kafka_test.go b/pkg/gofr/datasource/pubsub/kafka/kafka_test.go index 4d672cf26e..70125d435e 100644 --- a/pkg/gofr/datasource/pubsub/kafka/kafka_test.go +++ b/pkg/gofr/datasource/pubsub/kafka/kafka_test.go @@ -318,7 +318,6 @@ func TestKafkaClient_SubscribeSuccess(t *testing.T) { Brokers: []string{"kafkabroker"}, OffSet: -1, }, - mu: &sync.RWMutex{}, metrics: mockMetrics, } @@ -415,7 +414,6 @@ func TestKafkaClient_SubscribeError(t *testing.T) { Brokers: []string{"kafkabroker"}, OffSet: -1, }, - mu: &sync.RWMutex{}, metrics: mockMetrics, } @@ -564,9 +562,17 @@ func TestNewKafkaClient(t *testing.T) { k := New(&tc.config, logging.NewMockLogger(logging.ERROR), NewMockMetrics(ctrl)) if tc.expectNil { assert.Nil(t, k) - } else { - assert.NotNil(t, k) + + return } + + assert.NotNil(t, k) + + // These configs point at brokers that do not resolve, so New + // leaves a retryConnect goroutine behind. Close stops it; without + // that it outlives the test and races the connectToBrokers stub + // that reconnect_success_test.go restores in its own cleanup. + t.Cleanup(func() { _ = k.Close() }) }) } } @@ -694,7 +700,6 @@ func TestKafkaClient_Subscribe_NotConnected(t *testing.T) { }, }, logger: logging.NewMockLogger(logging.DEBUG), - mu: &sync.RWMutex{}, } // ensureConnected probes Controller in the unlocked fast path and @@ -728,7 +733,6 @@ func TestEnsureConnected_ReconnectsAfterStaleAdminConn(t *testing.T) { conns: []Connection{staleConn}, }, logger: logging.NewMockLogger(logging.DEBUG), - mu: &sync.RWMutex{}, } // Stale conn is detected, reconnect is attempted, but the unresolvable @@ -763,7 +767,6 @@ func TestKafkaClient_Query_Failures(t *testing.T) { conns: []Connection{mockConnection}, }, logger: logging.NewMockLogger(logging.DEBUG), - mu: &sync.RWMutex{}, } }, topic: "test-topic", @@ -979,7 +982,6 @@ func TestKafkaClient_Subscribe_RaceDetector(t *testing.T) { logger: logging.NewMockLogger(logging.DEBUG), metrics: mockMetrics, reader: make(map[string]Reader), - mu: &sync.RWMutex{}, } // Create mock reader diff --git a/pkg/gofr/datasource/pubsub/kafka/lock_order_test.go b/pkg/gofr/datasource/pubsub/kafka/lock_order_test.go new file mode 100644 index 0000000000..23d8dfe03c --- /dev/null +++ b/pkg/gofr/datasource/pubsub/kafka/lock_order_test.go @@ -0,0 +1,104 @@ +package kafka + +import ( + "strconv" + "sync" + "testing" + "time" + + "github.com/segmentio/kafka-go" +) + +// TestHealthSubscribe_NoLockOrderInversion guards the order in which k.mu and +// connMu are taken. +// +// Subscribe holds k.mu across getNewReader, which takes connMu - so k.mu comes +// first, and every other path must use that order too. Health briefly broke it: +// it held connMu for the whole probe and then took k.mu inside +// getReaderStatsAsMap. Go's RWMutex parks new readers once a writer is waiting, +// so a concurrent connMu writer closes the cycle: +// +// Health holds connMu(R), wants k.mu +// Subscribe holds k.mu, wants connMu(R) - parked behind the writer +// writer wants connMu(W) - waits on Health +// +// The subscribe side is modeled rather than called: the real Subscribe builds +// a kafka.Reader against an unresolvable broker inside the lock, which makes +// the same test take tens of seconds and assert on a deadline. What matters +// here is only the acquisition order, so it is reproduced exactly and cheaply. +// The production paths themselves are covered by the *_ConcurrentSubscribe_ +// race tests. +func TestHealthSubscribe_NoLockOrderInversion(t *testing.T) { + const iterations = 2000 + + k := &kafkaClient{ + conn: &multiConn{ + conns: []Connection{&MockConn{addr: "127.0.0.1:9092", isHealthy: true, isControl: true}}, + }, + reader: make(map[string]Reader), + writer: &mockWriter{}, + logger: &mockLogger{}, + } + + for i := range 2 { + k.reader["seed-"+strconv.Itoa(i)] = &statsReader{} + } + + done := make(chan struct{}) + + go func() { + defer close(done) + + var wg sync.WaitGroup + + wg.Add(3) + + go func() { // Subscribe's order: k.mu -> connMu (via getNewReader) + defer wg.Done() + + for i := range iterations { + k.mu.Lock() + k.connMu.RLock() + // Rotate over a small key set: the map must keep being written, + // but Health converts every reader's Stats to a map on each + // probe, so an ever-growing map makes this O(n^2) work rather + // than a lock-contention test. + k.reader["t-"+strconv.Itoa(i%2)] = &statsReader{} + k.connMu.RUnlock() + k.mu.Unlock() + } + }() + + go func() { // Health's order: must not take k.mu while holding connMu + defer wg.Done() + + for range iterations { + _ = k.Health() + } + }() + + go func() { // the pending connMu writer that closes the cycle + defer wg.Done() + + for range iterations { + func() { + k.connMu.Lock() + defer k.connMu.Unlock() + }() + } + }() + + wg.Wait() + }() + + select { + case <-done: + case <-time.After(30 * time.Second): + t.Fatal("deadlock: Health took k.mu while holding connMu; Subscribe takes them the other way round") + } +} + +type statsReader struct{ Reader } + +func (*statsReader) Stats() kafka.ReaderStats { return kafka.ReaderStats{} } +func (*statsReader) Close() error { return nil } diff --git a/pkg/gofr/datasource/pubsub/kafka/reader_map_integration_test.go b/pkg/gofr/datasource/pubsub/kafka/reader_map_integration_test.go new file mode 100644 index 0000000000..3e726630f1 --- /dev/null +++ b/pkg/gofr/datasource/pubsub/kafka/reader_map_integration_test.go @@ -0,0 +1,227 @@ +//go:build integration + +// Package-level integration stress for the reader map, run against a real +// broker rather than mocks: +// +// KAFKA_BROKER=localhost:20086 go test -tags integration -race \ +// -run TestIntegration ./pkg/gofr/datasource/pubsub/kafka/ +// +// Build-tagged so the normal suite and CI stay hermetic. +package kafka + +import ( + "context" + "os" + "strconv" + "sync" + "sync/atomic" + "testing" + "time" + + "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" + + "gofr.dev/pkg/gofr/logging" +) + +func brokerFromEnv(t *testing.T) string { + t.Helper() + + broker := os.Getenv("KAFKA_BROKER") + if broker == "" { + t.Skip("KAFKA_BROKER not set") + } + + return broker +} + +func newLiveClient(t *testing.T, group string) *kafkaClient { + t.Helper() + + ctrl := gomock.NewController(t) + t.Cleanup(ctrl.Finish) + + metrics := NewMockMetrics(ctrl) + metrics.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + + cfg := &Config{ + Brokers: []string{brokerFromEnv(t)}, + ConsumerGroupID: group, + BatchSize: 1, + BatchBytes: 1048576, + BatchTimeout: 1, + } + + k := New(cfg, logging.NewMockLogger(logging.ERROR), metrics) + require.NotNil(t, k, "New returned nil - check the config and the broker address") + + require.Eventually(t, k.isConnected, 30*time.Second, 200*time.Millisecond, + "broker at %s never became reachable", cfg.Brokers[0]) + + return k +} + +// publishEventually retries the publish until the broker admits the topic +// exists. CreateTopic returns as soon as the controller accepts the request, +// but the topic's metadata takes a moment to propagate, and a publish issued +// in that window fails with "Unknown Topic Or Partition" - a property of the +// broker, not of the code under test. +func publishEventually(ctx context.Context, t *testing.T, k *kafkaClient, topic string) { + t.Helper() + + var lastErr error + + require.Eventually(t, func() bool { + lastErr = k.Publish(ctx, topic, []byte("v")) + + return lastErr == nil + }, 30*time.Second, 100*time.Millisecond, "publish to %s never succeeded: %v", topic, lastErr) +} + +// TestIntegration_PublishSubscribe_RoundTrip is the end-to-end sanity check: +// a message published through the GoFr client comes back out of Subscribe on +// the same topic, with the committer wired to the right reader. +func TestIntegration_PublishSubscribe_RoundTrip(t *testing.T) { + topic := "gofr-e2e-" + strconv.FormatInt(time.Now().UnixNano(), 10) + + k := newLiveClient(t, "gofr-e2e-group") + t.Cleanup(func() { _ = k.Close() }) + + ctx, cancel := context.WithTimeout(t.Context(), 60*time.Second) + defer cancel() + + require.NoError(t, k.CreateTopic(ctx, topic)) + + // Retry rather than publishing once: a broker that is still settling a + // previous test's topics can take a moment to admit this one, and the + // bare publish then fails with "Unknown Topic Or Partition". + require.Eventually(t, func() bool { + return k.Publish(ctx, topic, []byte("hello-gofr")) == nil + }, 30*time.Second, 100*time.Millisecond, "publish to %s never succeeded", topic) + + msg, err := k.Subscribe(ctx, topic) + require.NoError(t, err) + require.Equal(t, topic, msg.Topic) + require.Equal(t, "hello-gofr", string(msg.Value)) + require.NotNil(t, msg.Committer, "the committer must be wired to this topic's reader") + + msg.Commit() +} + +// TestIntegration_ConcurrentSubscribeAndClose is the stress case that the +// #3500 panic was reported from: many goroutines subscribing to distinct +// topics (each one growing the reader map) while teardown walks that map. +// +// Before the fix, either the unguarded range in Close or the unguarded +// re-read at the end of Subscribe could observe a map mid-write, which the +// runtime reports as "concurrent map read and map write" and -race reports +// as a data race on the map header. +func TestIntegration_ConcurrentSubscribeAndClose(t *testing.T) { + const ( + warmTopics = 3 + coldWriters = 8 + coldEach = 8 + ) + + prefix := "gofr-stress-" + strconv.FormatInt(time.Now().UnixNano(), 10) + "-" + + k := newLiveClient(t, "gofr-stress-group") + t.Cleanup(func() { _ = k.Close() }) + + ctx, cancel := context.WithTimeout(t.Context(), 5*time.Minute) + defer cancel() + + // Only a few topics get a message. Those prove delivery still works while + // the map is churning; the cold topics below exist purely to force the + // map writes, and a Subscribe that times out on an empty partition has + // already done the write by then. + // + // Each warm topic is subscribed once here, before any churn, so its + // reader has already joined the consumer group. Without that warm-up the + // group is still rebalancing when the cold topics pile in, and a first + // join can take longer than the read deadline - which measures Kafka's + // coordinator, not this package's locking. + for i := range warmTopics { + topic := prefix + "warm-" + strconv.Itoa(i) + require.NoError(t, k.CreateTopic(ctx, topic)) + publishEventually(ctx, t, k, topic) + + joinCtx, joinCancel := context.WithTimeout(ctx, 60*time.Second) + + msg, err := k.Subscribe(joinCtx, topic) + require.NoError(t, err, "warm-up subscribe on %s", topic) + require.Equal(t, topic, msg.Topic) + + joinCancel() + + // A second message for the concurrent phase below to consume. + publishEventually(ctx, t, k, topic) + } + + var ( + wg sync.WaitGroup + delivered atomic.Int64 + closes atomic.Int64 + ) + + for i := range warmTopics { + wg.Add(1) + + go func() { + defer wg.Done() + + topic := prefix + "warm-" + strconv.Itoa(i) + + readCtx, readCancel := context.WithTimeout(ctx, 60*time.Second) + defer readCancel() + + if msg, err := k.Subscribe(readCtx, topic); err == nil && msg.Topic == topic { + delivered.Add(1) + } + }() + } + + // Each cold writer walks its own set of fresh topics, so every iteration + // takes k.mu for write and grows the reader map underneath the warm + // subscribers above and the teardown goroutine below. + for w := range coldWriters { + wg.Add(1) + + go func() { + defer wg.Done() + + for i := range coldEach { + topic := prefix + "cold-" + strconv.Itoa(w) + "-" + strconv.Itoa(i) + + readCtx, readCancel := context.WithTimeout(ctx, 250*time.Millisecond) + _, _ = k.Subscribe(readCtx, topic) + + readCancel() + } + }() + } + + // Concurrent teardown of a client that is still growing its reader map. + // Health is read alongside it because it takes connMu, so this also + // covers the two mutexes being taken from different goroutines at once. + wg.Add(1) + + go func() { + defer wg.Done() + + for range coldWriters * coldEach { + _ = k.Health() + + closes.Add(1) + + time.Sleep(time.Millisecond) + } + }() + + wg.Wait() + + require.Equal(t, int64(warmTopics), delivered.Load(), + "every warm subscriber should have received its message despite the map churn") + t.Logf("delivered %d/%d warm messages while %d cold topics grew the reader map, %d health probes", + delivered.Load(), warmTopics, coldWriters*coldEach, closes.Load()) +} diff --git a/pkg/gofr/datasource/pubsub/kafka/reader_map_race_test.go b/pkg/gofr/datasource/pubsub/kafka/reader_map_race_test.go new file mode 100644 index 0000000000..2e056f1e3a --- /dev/null +++ b/pkg/gofr/datasource/pubsub/kafka/reader_map_race_test.go @@ -0,0 +1,243 @@ +package kafka + +import ( + "context" + "strconv" + "sync" + "sync/atomic" + "testing" + "time" + + "github.com/segmentio/kafka-go" + "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" + + "gofr.dev/pkg/gofr/logging" +) + +// newReaderMapClient builds a client whose admin probe succeeds, so Subscribe +// gets past ensureConnected and reaches the reader map, and whose broker is +// RFC 6761 ".invalid" so any reader built by getNewReader fails to dial fast +// instead of blocking the test. +// +// warmTopics are pre-populated with mock readers that return a message +// immediately: a Subscribe on one of those takes the "reader already exists" +// path and runs all the way to the end of the function without touching the +// network. A Subscribe on any other topic takes the "create it" path and +// writes the map. Racing the two is the whole point. +func newReaderMapClient(t *testing.T, warmTopics ...string) *kafkaClient { + t.Helper() + + ctrl := gomock.NewController(t) + t.Cleanup(ctrl.Finish) + + live := NewMockConnection(ctrl) + live.EXPECT().Controller().Return(kafka.Broker{}, nil).AnyTimes() + live.EXPECT().Close().Return(nil).AnyTimes() + + metrics := NewMockMetrics(ctrl) + metrics.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + + k := &kafkaClient{ + dialer: &kafka.Dialer{Timeout: time.Millisecond}, + config: Config{Brokers: []string{"broker.invalid:0"}, ConsumerGroupID: "reader-map-race"}, + conn: &multiConn{conns: []Connection{live}}, + logger: logging.NewMockLogger(logging.DEBUG), + metrics: metrics, + reader: make(map[string]Reader), + } + + for _, topic := range warmTopics { + r := NewMockReader(ctrl) + r.EXPECT().FetchMessage(gomock.Any()). + Return(kafka.Message{Topic: topic, Value: []byte("v")}, nil).AnyTimes() + r.EXPECT().Close().Return(nil).AnyTimes() + + k.reader[topic] = r + } + + // Subscribe on a cold topic builds a real kafka.Reader, which runs its own + // background goroutines until closed. Close them all rather than leaking + // one per topic into the rest of the package's tests. + t.Cleanup(func() { _ = k.Close() }) + + return k +} + +// TestSubscribe_ConcurrentNewTopic_NoRace pins the unguarded map read that +// used to sit at the end of Subscribe. +// +// Subscribe captures the reader into a local while holding k.mu, releases the +// lock, and then built the committer from k.reader[topic] a second time. That +// second read is outside the lock, so a concurrent Subscribe on a *different* +// topic taking the write lock to grow the map races it. +// +// The warm goroutine supplies the read (its topic already has a reader, so it +// runs to the committer line); the cold goroutines supply the write (each of +// their topics is new, so each one assigns into the map). Without the fix this +// fails under -race on the k.reader map. +func TestSubscribe_ConcurrentNewTopic_NoRace(t *testing.T) { + const ( + warmTopic = "warm-topic" + coldWriter = 4 + iterations = 60 + ) + + k := newReaderMapClient(t, warmTopic) + ctx := t.Context() + + var ( + wg sync.WaitGroup + warmErr error + warmSeen atomic.Int64 + ) + + wg.Add(1) + + go func() { + defer wg.Done() + + // Assert after Wait, not here: require calls FailNow, which is only + // legal on the goroutine running the test. + for range iterations { + msg, err := k.Subscribe(ctx, warmTopic) + if err != nil { + warmErr = err + + return + } + + if msg.Topic == warmTopic { + warmSeen.Add(1) + } + } + }() + + // The cold path builds a real kafka.Reader against an unresolvable broker, + // and kafka-go's FetchMessage retries until its context is done. Hand it + // one that is already canceled: ensureConnected short-circuits on the + // live admin conn without consulting ctx, so Subscribe still reaches the + // map write, and FetchMessage then returns immediately instead of hanging. + coldCtx, cancel := context.WithCancel(ctx) + cancel() + + for w := range coldWriter { + wg.Add(1) + + go func() { + defer wg.Done() + + for i := range iterations { + // A fresh topic every time, so every call takes the write + // lock and grows the map. + _, _ = k.Subscribe(coldCtx, "cold-"+strconv.Itoa(w)+"-"+strconv.Itoa(i)) + } + }() + } + + wg.Wait() + + require.NoError(t, warmErr, "the warm subscriber should never fail") + require.Equal(t, int64(iterations), warmSeen.Load(), + "every warm Subscribe should have returned a message for its own topic") +} + +// TestClose_ConcurrentSubscribe_NoRace pins the other half: Close ranged over +// k.reader with no lock at all, so a Subscribe growing the map during teardown +// produced the "concurrent map read and map write" panic from #3500. +// +// Close is called repeatedly rather than once because the panic needs the +// range to be in flight while the map is written, and a single teardown is a +// narrow window. +func TestClose_ConcurrentSubscribe_NoRace(t *testing.T) { + const iterations = 300 + + // Seeded with readers so the very first Close has a map worth ranging + // over. Starting from an empty map, the early iterations range over + // nothing and the detector needs the writer to get ahead first, which + // made this catch its own mutant only intermittently at -count=1. + k := newReaderMapClient(t, "seed-0", "seed-1", "seed-2", "seed-3") + // Close() takes connMu and closes conn; leave it unset so this test stays + // about the reader map. It also means Subscribe cannot be the writer here + // - ensureConnected would fail and sleep defaultRetryTimeout (10s) on + // every call - so the writer below performs the same locked assignment + // Subscribe does. Close, the code under test, is the real thing. + k.conn = nil + + var wg sync.WaitGroup + + wg.Add(2) + + go func() { + defer wg.Done() + + for i := range iterations { + // ensureConnected fails with conn nil, so drive the map write + // directly the way Subscribe does under k.mu. + k.mu.Lock() + k.reader["grow-"+strconv.Itoa(i)] = k.getNewReader("grow-" + strconv.Itoa(i)) + k.mu.Unlock() + } + }() + + go func() { + defer wg.Done() + + for range iterations { + _ = k.Close() + } + }() + + wg.Wait() +} + +// TestHealth_ConcurrentSubscribe_NoRace pins the third reader of the same map. +// +// getReaderStatsAsMap ranged over k.reader with no lock held, and Health sits +// on the probe path - every /.well-known/health request reaches it - so it +// races a Subscribe growing the map far more often than teardown ever could. +// Found by running the integration stress case against a real broker under +// -race, not by reading the code. +func TestHealth_ConcurrentSubscribe_NoRace(t *testing.T) { + const iterations = 60 + + k := &kafkaClient{ + dialer: &kafka.Dialer{Timeout: time.Millisecond}, + config: Config{Brokers: []string{"broker.invalid:0"}, ConsumerGroupID: "health-race"}, + conn: &multiConn{ + conns: []Connection{&MockConn{addr: "127.0.0.1:9092", isHealthy: true, isControl: true}}, + }, + reader: make(map[string]Reader), + writer: &mockWriter{}, + logger: &mockLogger{}, + } + + t.Cleanup(func() { _ = k.Close() }) + + var wg sync.WaitGroup + + wg.Add(2) + + go func() { + defer wg.Done() + + for i := range iterations { + topic := "grow-" + strconv.Itoa(i) + + // The same locked assignment Subscribe performs. + k.mu.Lock() + k.reader[topic] = k.getNewReader(topic) + k.mu.Unlock() + } + }() + + go func() { + defer wg.Done() + + for range iterations { + _ = k.Health() + } + }() + + wg.Wait() +} diff --git a/pkg/gofr/datasource/pubsub/kafka/reconnect_concurrency_test.go b/pkg/gofr/datasource/pubsub/kafka/reconnect_concurrency_test.go index eb3afc43f0..c49066ae35 100644 --- a/pkg/gofr/datasource/pubsub/kafka/reconnect_concurrency_test.go +++ b/pkg/gofr/datasource/pubsub/kafka/reconnect_concurrency_test.go @@ -1,6 +1,7 @@ package kafka import ( + "context" "net" "sync" "sync/atomic" @@ -9,8 +10,10 @@ import ( "github.com/segmentio/kafka-go" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "go.uber.org/mock/gomock" + "gofr.dev/pkg/gofr/datasource/pubsub" "gofr.dev/pkg/gofr/logging" ) @@ -33,7 +36,6 @@ func newStaleClient(t *testing.T) (*kafkaClient, *MockConnection) { conns: []Connection{stale}, }, logger: logging.NewMockLogger(logging.DEBUG), - mu: &sync.RWMutex{}, } return k, stale @@ -265,3 +267,45 @@ func TestClose_ConcurrentEnsureConnected_NoRace(t *testing.T) { assert.Nil(t, k.conn) } + +// TestClose_DuringInFlightReconnect_DoesNotRevive covers the window Close +// cannot signal its way out of: retryConnect has already passed its own +// closed check and is inside initialize, dialing. Without the re-check under +// connMu, that dial publishes k.conn and k.writer onto a client that is +// already closed, and both leak for the life of the process. +func TestClose_DuringInFlightReconnect_DoesNotRevive(t *testing.T) { + k := &kafkaClient{ + config: Config{Brokers: []string{"broker.invalid:0"}, BatchSize: 1, BatchBytes: 1, BatchTimeout: 1}, + logger: &mockLogger{}, + closed: make(chan struct{}), + } + + dialed := make(chan struct{}) + release := make(chan struct{}) + + original := connectToBrokers + + t.Cleanup(func() { connectToBrokers = original }) + + connectToBrokers = func(context.Context, []string, *kafka.Dialer, pubsub.Logger) ([]Connection, error) { + close(dialed) + <-release // hold the dial open until Close has run + + return []Connection{&MockConn{addr: "127.0.0.1:9092", isHealthy: true}}, nil + } + + errCh := make(chan error, 1) + go func() { errCh <- k.initialize(t.Context()) }() + + <-dialed + require.NoError(t, k.Close()) + close(release) + + require.ErrorIs(t, <-errCh, errClientClosed) + + k.connMu.RLock() + defer k.connMu.RUnlock() + + require.Nil(t, k.conn, "a closed client must not be revived by an in-flight reconnect") + require.Nil(t, k.writer, "the writer dialed after Close must not be published") +} diff --git a/pkg/gofr/datasource/pubsub/kafka/reconnect_success_test.go b/pkg/gofr/datasource/pubsub/kafka/reconnect_success_test.go index bf6176dd5b..0d5a8a8877 100644 --- a/pkg/gofr/datasource/pubsub/kafka/reconnect_success_test.go +++ b/pkg/gofr/datasource/pubsub/kafka/reconnect_success_test.go @@ -2,7 +2,6 @@ package kafka import ( "context" - "sync" "testing" "time" @@ -60,7 +59,6 @@ func TestEnsureConnected_ReconnectSuccess(t *testing.T) { conns: []Connection{stale}, }, logger: logging.NewMockLogger(logging.DEBUG), - mu: &sync.RWMutex{}, // Pre-arm the throttle so we can assert it gets reset on // successful reconnect. reconnectErrLogAt: time.Now().Add(time.Hour), @@ -113,7 +111,6 @@ func TestEnsureConnected_ReconnectFailureLogThrottled(t *testing.T) { conns: []Connection{stale}, }, logger: logging.NewMockLogger(logging.DEBUG), - mu: &sync.RWMutex{}, } // First failure: throttle is zero-value, so this must arm it. diff --git a/pkg/gofr/datasource/pubsub/kafka/writer_race_test.go b/pkg/gofr/datasource/pubsub/kafka/writer_race_test.go new file mode 100644 index 0000000000..76aa05f199 --- /dev/null +++ b/pkg/gofr/datasource/pubsub/kafka/writer_race_test.go @@ -0,0 +1,80 @@ +package kafka + +import ( + "context" + "sync" + "testing" + + "github.com/segmentio/kafka-go" + "go.uber.org/mock/gomock" + + "gofr.dev/pkg/gofr/datasource/pubsub" + "gofr.dev/pkg/gofr/logging" +) + +// TestWriter_ConcurrentReconnectAndPublish_NoRace pins k.writer. +// +// initialize publishes the writer, and retryConnect calls initialize from its +// own goroutine, so that pointer swap runs concurrently with Publish, Close +// and Health reading it. It used to be written and read with no lock at all - +// a single-pointer race rather than the reader-map panic, but a race all the +// same. Every access now goes through connMu, the lock that already guards +// the conn published beside it. +func TestWriter_ConcurrentReconnectAndPublish_NoRace(t *testing.T) { + const iterations = 200 + + ctrl := gomock.NewController(t) + t.Cleanup(ctrl.Finish) + + metrics := NewMockMetrics(ctrl) + metrics.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + + k := &kafkaClient{ + config: Config{Brokers: []string{"broker.invalid:0"}, BatchSize: 1, BatchBytes: 1, BatchTimeout: 1}, + logger: logging.NewMockLogger(logging.ERROR), + metrics: metrics, + reader: make(map[string]Reader), + writer: &mockWriter{}, + conn: &multiConn{conns: []Connection{&MockConn{addr: "127.0.0.1:9092", isHealthy: true}}}, + } + + original := connectToBrokers + + t.Cleanup(func() { connectToBrokers = original }) + + connectToBrokers = func(context.Context, []string, *kafka.Dialer, pubsub.Logger) ([]Connection, error) { + return []Connection{&MockConn{addr: "127.0.0.1:9092", isHealthy: true}}, nil + } + + ctx := t.Context() + + var wg sync.WaitGroup + + wg.Add(3) + + go func() { // the reconnect that swaps k.writer + defer wg.Done() + + for range iterations { + _ = k.initialize(ctx) + } + }() + + go func() { // Publish reads it + defer wg.Done() + + for range iterations { + _ = k.Publish(ctx, "topic", []byte("v")) + } + }() + + go func() { // Health reads it too + defer wg.Done() + + for range iterations { + _ = k.Health() + } + }() + + wg.Wait() +} From fcf49b984655450ec59497bf5501bd733dfce92e Mon Sep 17 00:00:00 2001 From: Pritesh jena Date: Sun, 6 Sep 2026 19:13:14 +0530 Subject: [PATCH 07/48] fix(sql): correct query duration logging unit to microseconds (#3878) --- pkg/gofr/datasource/sql/db.go | 7 ++++--- pkg/gofr/datasource/sql/db_test.go | 6 ++---- 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/pkg/gofr/datasource/sql/db.go b/pkg/gofr/datasource/sql/db.go index 4a8db1965c..5e1be27b51 100644 --- a/pkg/gofr/datasource/sql/db.go +++ b/pkg/gofr/datasource/sql/db.go @@ -54,20 +54,21 @@ func clean(query string) string { } func sendStats(logger datasource.Logger, metrics Metrics, config *DBConfig, start time.Time, queryType, query string, args ...any) { - duration := time.Since(start).Milliseconds() + duration := time.Since(start) if logger != nil { logger.Debug(&Log{ Type: queryType, Query: query, - Duration: duration, + Duration: duration.Microseconds(), Args: args, }) } // This contains the fix for the nil pointer dereference if metrics != nil { - metrics.RecordHistogram(context.Background(), "app_sql_stats", float64(duration), "hostname", config.HostName, + metrics.RecordHistogram(context.Background(), "app_sql_stats", + float64(duration)/float64(time.Millisecond), "hostname", config.HostName, "database", config.Database, "type", getOperationType(query)) } } diff --git a/pkg/gofr/datasource/sql/db_test.go b/pkg/gofr/datasource/sql/db_test.go index 7dc29f80e2..2e1d3a071e 100644 --- a/pkg/gofr/datasource/sql/db_test.go +++ b/pkg/gofr/datasource/sql/db_test.go @@ -772,14 +772,12 @@ func TestDB_sendOperationStats_RecordsMilliseconds(t *testing.T) { start := time.Now().Add(-1500 * time.Millisecond) // 1.5 seconds ago mockMetrics.EXPECT().RecordHistogram( - gomock.Any(), "app_sql_stats", float64(1500), + gomock.Any(), "app_sql_stats", + gomock.Cond(func(v float64) bool { return v >= 1500 && v < 1510 }), "hostname", "host", "database", "db", "type", "SELECT", ) db.sendOperationStats(start, "SELECT", "SELECT * FROM users") - - duration := time.Since(start).Milliseconds() - assert.Equal(t, int64(1500), duration) } // --- Tx method tests --- From 41fcf449fc434ebe98848f545c5cca06b1d792a1 Mon Sep 17 00:00:00 2001 From: Umang Mundhra Date: Mon, 7 Sep 2026 00:27:47 +0530 Subject: [PATCH 08/48] chore(deps): consolidate minor/patch dependency updates (2026-08-21) (#4048) --- examples/using-add-filestore/go.mod | 76 ++++--- examples/using-add-filestore/go.sum | 193 +++++++++--------- examples/using-s3-filestore/go.mod | 76 ++++--- examples/using-s3-filestore/go.sum | 195 +++++++++--------- go.mod | 7 +- go.sum | 16 +- go.work.sum | 15 +- pkg/gofr/datasource/arangodb/go.mod | 22 +- pkg/gofr/datasource/arangodb/go.sum | 52 ++--- pkg/gofr/datasource/cassandra/go.mod | 14 +- pkg/gofr/datasource/cassandra/go.sum | 31 ++- pkg/gofr/datasource/clickhouse/go.mod | 15 +- pkg/gofr/datasource/clickhouse/go.sum | 39 +--- pkg/gofr/datasource/cloudsql/go.mod | 26 ++- pkg/gofr/datasource/cloudsql/go.sum | 67 +++---- pkg/gofr/datasource/couchbase/go.mod | 26 +-- pkg/gofr/datasource/couchbase/go.sum | 69 +++---- pkg/gofr/datasource/dbresolver/go.mod | 74 ++++--- pkg/gofr/datasource/dbresolver/go.sum | 189 +++++++++--------- pkg/gofr/datasource/dgraph/go.mod | 25 ++- pkg/gofr/datasource/dgraph/go.sum | 65 +++--- pkg/gofr/datasource/elasticsearch/go.mod | 19 +- pkg/gofr/datasource/elasticsearch/go.sum | 49 ++--- pkg/gofr/datasource/file/azure/go.mod | 17 +- pkg/gofr/datasource/file/azure/go.sum | 57 ++---- pkg/gofr/datasource/file/ftp/go.mod | 13 +- pkg/gofr/datasource/file/ftp/go.sum | 47 ++--- pkg/gofr/datasource/file/gcs/go.mod | 32 ++- pkg/gofr/datasource/file/gcs/go.sum | 81 ++++---- pkg/gofr/datasource/file/s3/go.mod | 12 +- pkg/gofr/datasource/file/s3/go.sum | 39 +--- pkg/gofr/datasource/file/sftp/go.mod | 14 +- pkg/gofr/datasource/file/sftp/go.sum | 43 ++-- pkg/gofr/datasource/influxdb/go.mod | 16 +- pkg/gofr/datasource/influxdb/go.sum | 39 ++-- pkg/gofr/datasource/kv-store/badger/go.mod | 18 +- pkg/gofr/datasource/kv-store/badger/go.sum | 45 ++--- pkg/gofr/datasource/kv-store/dynamodb/go.mod | 17 +- pkg/gofr/datasource/kv-store/dynamodb/go.sum | 43 ++-- pkg/gofr/datasource/kv-store/nats/go.mod | 21 +- pkg/gofr/datasource/kv-store/nats/go.sum | 51 ++--- pkg/gofr/datasource/mongo/go.mod | 21 +- pkg/gofr/datasource/mongo/go.sum | 51 ++--- pkg/gofr/datasource/opentsdb/go.mod | 14 +- pkg/gofr/datasource/opentsdb/go.sum | 37 ++-- pkg/gofr/datasource/oracle/go.mod | 77 ++++--- pkg/gofr/datasource/oracle/go.sum | 200 +++++++++---------- pkg/gofr/datasource/pubsub/eventhub/go.mod | 21 +- pkg/gofr/datasource/pubsub/eventhub/go.sum | 61 +++--- pkg/gofr/datasource/pubsub/nats/go.mod | 18 +- pkg/gofr/datasource/pubsub/nats/go.sum | 49 ++--- pkg/gofr/datasource/pubsub/sqs/go.mod | 18 +- pkg/gofr/datasource/pubsub/sqs/go.sum | 49 ++--- pkg/gofr/datasource/scylladb/go.mod | 11 +- pkg/gofr/datasource/scylladb/go.sum | 22 +- pkg/gofr/datasource/solr/go.mod | 6 +- pkg/gofr/datasource/solr/go.sum | 21 +- pkg/gofr/datasource/surrealdb/go.mod | 16 +- pkg/gofr/datasource/surrealdb/go.sum | 41 ++-- 59 files changed, 1136 insertions(+), 1562 deletions(-) diff --git a/examples/using-add-filestore/go.mod b/examples/using-add-filestore/go.mod index b6fd30ce24..826f25528c 100644 --- a/examples/using-add-filestore/go.mod +++ b/examples/using-add-filestore/go.mod @@ -3,7 +3,7 @@ module gofr.dev/examples/using-add-filestore go 1.26.0 require ( - github.com/stretchr/testify v1.11.1 + github.com/stretchr/testify v1.12.1 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 gofr.dev/pkg/gofr/datasource/file/ftp v0.2.2 @@ -11,54 +11,52 @@ require ( require ( cloud.google.com/go v0.123.0 // indirect - cloud.google.com/go/auth v0.20.0 // indirect + cloud.google.com/go/auth v0.22.0 // indirect cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect cloud.google.com/go/compute/metadata v0.9.0 // indirect - cloud.google.com/go/iam v1.11.0 // indirect - cloud.google.com/go/pubsub v1.50.2 // indirect - cloud.google.com/go/pubsub/v2 v2.5.1 // indirect + cloud.google.com/go/iam v1.12.0 // indirect + cloud.google.com/go/pubsub v1.51.0 // indirect + cloud.google.com/go/pubsub/v2 v2.6.0 // indirect filippo.io/edwards25519 v1.2.0 // indirect github.com/DATA-DOG/go-sqlmock v1.5.2 // indirect - github.com/XSAM/otelsql v0.42.0 // indirect + github.com/XSAM/otelsql v0.43.0 // indirect github.com/agnivade/levenshtein v1.2.1 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/cenkalti/backoff/v5 v5.0.3 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/eclipse/paho.mqtt.golang v1.5.1 // indirect github.com/felixge/httpsnoop v1.1.0 // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-sql-driver/mysql v1.10.0 // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/golang-jwt/jwt/v5 v5.3.1 // indirect github.com/google/s2a-go v0.1.9 // indirect github.com/google/uuid v1.6.0 // indirect - github.com/googleapis/enterprise-certificate-proxy v0.3.17 // indirect - github.com/googleapis/gax-go/v2 v2.22.0 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.19 // indirect + github.com/googleapis/gax-go/v2 v2.23.0 // indirect github.com/gorilla/mux v1.8.1 // indirect github.com/gorilla/websocket v1.5.3 // indirect github.com/graphql-go/graphql v0.8.1 // indirect github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.3.3 // indirect github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 // indirect - github.com/jlaffaye/ftp v0.2.1 // indirect + github.com/jlaffaye/ftp v0.2.2 // indirect github.com/joho/godotenv v1.5.1 // indirect - github.com/klauspost/compress v1.18.6 // indirect + github.com/klauspost/compress v1.19.2 // indirect github.com/lib/pq v1.12.3 // indirect - github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-isatty v0.0.24 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/ncruces/go-strftime v1.0.0 // indirect github.com/openzipkin/zipkin-go v0.4.3 // indirect - github.com/pierrec/lz4/v4 v4.1.25 // indirect + github.com/pierrec/lz4/v4 v4.1.27 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/prometheus/client_golang v1.23.2 // indirect + github.com/prometheus/client_golang v1.24.1 // indirect github.com/prometheus/client_model v0.6.2 // indirect - github.com/prometheus/common v0.67.5 // indirect + github.com/prometheus/common v0.70.1 // indirect github.com/prometheus/otlptranslator v1.0.0 // indirect - github.com/prometheus/procfs v0.20.1 // indirect + github.com/prometheus/procfs v0.21.1 // indirect github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0 // indirect github.com/redis/go-redis/extra/redisotel/v9 v9.21.0 // indirect github.com/redis/go-redis/v9 v9.21.0 // indirect @@ -71,37 +69,37 @@ require ( go.opencensus.io v0.24.0 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 // indirect - go.opentelemetry.io/otel v1.44.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 // indirect + go.opentelemetry.io/otel v1.45.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 // indirect - go.opentelemetry.io/otel/exporters/prometheus v0.65.0 // indirect + go.opentelemetry.io/otel/exporters/prometheus v0.67.0 // indirect go.opentelemetry.io/otel/exporters/zipkin v1.44.0 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - go.opentelemetry.io/otel/sdk v1.44.0 // indirect - go.opentelemetry.io/otel/sdk/metric v1.44.0 // indirect - go.opentelemetry.io/otel/trace v1.44.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/sdk v1.45.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect + go.opentelemetry.io/otel/trace v1.45.0 // indirect go.opentelemetry.io/proto/otlp v1.10.0 // indirect go.uber.org/atomic v1.11.0 // indirect - go.yaml.in/yaml/v2 v2.4.4 // indirect - golang.org/x/crypto v0.53.0 // indirect - golang.org/x/net v0.56.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/crypto v0.55.0 // indirect + golang.org/x/net v0.57.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect - golang.org/x/sync v0.21.0 // indirect - golang.org/x/sys v0.46.0 // indirect - golang.org/x/term v0.44.0 // indirect - golang.org/x/text v0.38.0 // indirect + golang.org/x/sync v0.22.0 // indirect + golang.org/x/sys v0.47.0 // indirect + golang.org/x/term v0.45.0 // indirect + golang.org/x/text v0.41.0 // indirect golang.org/x/time v0.15.0 // indirect - google.golang.org/api v0.287.0 // indirect - google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20260615183401-62b3387ff324 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d // indirect + google.golang.org/api v0.291.0 // indirect + google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect google.golang.org/grpc v1.83.0 // indirect google.golang.org/protobuf v1.36.11 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect - modernc.org/libc v1.73.4 // indirect + modernc.org/libc v1.74.4 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.11.0 // indirect - modernc.org/sqlite v1.53.0 // indirect + modernc.org/sqlite v1.56.0 // indirect ) diff --git a/examples/using-add-filestore/go.sum b/examples/using-add-filestore/go.sum index 543c61c6d1..ef46665d3d 100644 --- a/examples/using-add-filestore/go.sum +++ b/examples/using-add-filestore/go.sum @@ -1,29 +1,29 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE= cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU= -cloud.google.com/go/auth v0.20.0 h1:kXTssoVb4azsVDoUiF8KvxAqrsQcQtB53DcSgta74CA= -cloud.google.com/go/auth v0.20.0/go.mod h1:942/yi/itH1SsmpyrbnTMDgGfdy2BUqIKyd0cyYLc5Q= +cloud.google.com/go/auth v0.22.0 h1:Xp9wAKkLoeaYb5pYZZoQGz4E9sdPxIbzS3gywZE3ciQ= +cloud.google.com/go/auth v0.22.0/go.mod h1:M9o2Oz+YI2jAfxewJgb1vyI3vceHF+eohmxyzmrl+9s= cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc= cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10= -cloud.google.com/go/iam v1.11.0 h1:KieQ9Pb+LLPak1O3Rv3GgCxhnmkYf7Xyh0P5HfF1jFM= -cloud.google.com/go/iam v1.11.0/go.mod h1:KP+nKGugNJW4LcLx1uEZcq1ok5sQHFaQehQNl4QDgV4= -cloud.google.com/go/kms v1.31.0 h1:LS8N92OxFDgOLg5NCo3OmbvjtQAIVT5gUHVLKIDHaFE= -cloud.google.com/go/kms v1.31.0/go.mod h1:YIyXZym11R5uovJJt4oN5eUL3oPmirF3yKeIh6QAf4U= -cloud.google.com/go/longrunning v1.0.0 h1:lwzWEYD8+NkYV7dhexOz6kmlvajZA70+bW/xMhRVVdY= -cloud.google.com/go/longrunning v1.0.0/go.mod h1:8nqFBPOO1U/XkhWl0I19AMZEphrHi73VNABIpKYaTwM= -cloud.google.com/go/pubsub v1.50.2 h1:54Up97HnThdP4H8jjWJSSQ/mnYG2EKon7ZSNETRq0tM= -cloud.google.com/go/pubsub v1.50.2/go.mod h1:jyCWeZdGFqd4mitSsBERnJcpqaHBsxQoPkNvjj4sp0w= -cloud.google.com/go/pubsub/v2 v2.5.1 h1:+TwXJr78P9RrMV3S8lKHIhJo2E99jI7ta65e+ujJjts= -cloud.google.com/go/pubsub/v2 v2.5.1/go.mod h1:Pd+qeabMX+576vQJhTN7TelE4k6kJh15dLU/ptOQ/UA= +cloud.google.com/go/iam v1.12.0 h1:Aki3bX9aHUDKPHfnRJfDcTdVedvy6quGBQcTqx3DRXk= +cloud.google.com/go/iam v1.12.0/go.mod h1:FEZ4lXpADAC2AIpQY7LANNjjwyQ2jK439CI2VaD+sLY= +cloud.google.com/go/kms v1.32.0 h1:s+rEluaaZKhLVjrIWG7uNBsnWbiitElzNzFGyp6+nIg= +cloud.google.com/go/kms v1.32.0/go.mod h1:CSGvW6GnMQbY+1nOHcIzhMtHSbExXlOmCKjWtYVjcpA= +cloud.google.com/go/longrunning v1.2.0 h1:WjYH3YHBGCxGJP9M4dWGHBfXr/cFIjMkNgWcJj7/iMM= +cloud.google.com/go/longrunning v1.2.0/go.mod h1:5KMQALFGOCtFoi2xSOA1u3H7WKlhmckgiyFw7+LGQp0= +cloud.google.com/go/pubsub v1.51.0 h1:XOaCejsqX7EEtUdQz+WPag66wWsUUGliyCOfGPKfo90= +cloud.google.com/go/pubsub v1.51.0/go.mod h1:NERXf11sd82UV3VnflcUj8POIyQUXT/QwrKlxD8di/I= +cloud.google.com/go/pubsub/v2 v2.6.0 h1:8pjR0id+GTB+krKx5G6AGJoYrHog58w2Q89PCOrfM64= +cloud.google.com/go/pubsub/v2 v2.6.0/go.mod h1:4anqvV/w8Pcgu2tO0qr2XgsF3GXHowzryfQ5gOnVmWY= filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo= filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU= github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= -github.com/XSAM/otelsql v0.42.0 h1:Li0xF4eJUxG2e0x3D4rvRlys1f27yJKvjTh7ljkUP5o= -github.com/XSAM/otelsql v0.42.0/go.mod h1:4mOrEv+cS1KmKzrvTktvJnstr5GtKSAK+QHvFR9OcpI= +github.com/XSAM/otelsql v0.43.0 h1:ZIhXqRoMhILXQwBQoq/Dl6Taap/KEFQXZrWjYV1L8X8= +github.com/XSAM/otelsql v0.43.0/go.mod h1:DJBGBvbtwf1OCBYRTjpRFxOqi6ONpdfb+htr4ncRWuw= github.com/agnivade/levenshtein v1.2.1 h1:EHBY3UOn1gwdy/VbFwgo4cxecRznFk7fKWN1KOX7eoM= github.com/agnivade/levenshtein v1.2.1/go.mod h1:QVVI16kDrtSuwcpd0p1+xMC6Z/VfhtCyDIjcwga4/DU= github.com/alicebob/miniredis/v2 v2.38.0 h1:nZAzCR+Lj+Vxk4ZXzm2NuKq2O33RXj1XxJ2e2uP9jiw= @@ -47,8 +47,6 @@ github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2 h1:aBangftG7EVZoUb69Os github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2/go.mod h1:qwXFYgsP6T7XnJtbKlf1HP8AjxZZyzxMmc+Lq5GjlU4= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d h1:abDbP7XBVgwda+h0J5Qra5p2OQpidU2FdkXvzCKL+H8= github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d/go.mod h1:wKFzULXAPj3U2BDAPWXhSbQQNC6FU1+1/5iika6IY7g= github.com/dgryski/trifles v0.0.0-20230903005119-f50d829f2e54 h1:SG7nF6SRlWhcT7cNTs5R6Hk4V2lcmLz2NsG2VnInyNo= @@ -69,8 +67,8 @@ github.com/envoyproxy/protoc-gen-validate v1.3.3/go.mod h1:TsndJ/ngyIdQRhMcVVGDD github.com/felixge/httpsnoop v1.1.0 h1:3YtUj32ZZkqZtt3sZZsClsymw/QDuVfpNhoA31zeORc= github.com/felixge/httpsnoop v1.1.0/go.mod h1:Zqxgdd+1Rkcz8euOqdr7lqgCRJztwr5hp9vDSi5UZCE= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-redis/redismock/v9 v9.2.0 h1:ZrMYQeKPECZPjOj5u9eyOjg8Nnb0BS9lkVIZ6IpsKLw= @@ -109,17 +107,17 @@ github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs= -github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA= +github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3 h1:LMLX+LgTNWpfvCBdFebv6EsYotImrt/Ppc5cXIriCSo= +github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3/go.mod h1:jl5iWTm0/hd5PjEYEOuwAJ57L/CibdZfrqZ5XA5GrCk= github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0= github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/enterprise-certificate-proxy v0.3.17 h1:73NfMHdiqo9JFU9+7a5ExpVa10/R29pXfZIaW559nrg= -github.com/googleapis/enterprise-certificate-proxy v0.3.17/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= -github.com/googleapis/gax-go/v2 v2.22.0 h1:PjIWBpgGIVKGoCXuiCoP64altEJCj3/Ei+kSU5vlZD4= -github.com/googleapis/gax-go/v2 v2.22.0/go.mod h1:irWBbALSr0Sk3qlqb9SyJ1h68WjgeFuiOzI4Rqw5+aY= +github.com/googleapis/enterprise-certificate-proxy v0.3.19 h1:mMOE7DN2+p76/EdIrmAy9B9bH+yC4563vmnJ34QR8i4= +github.com/googleapis/enterprise-certificate-proxy v0.3.19/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= +github.com/googleapis/gax-go/v2 v2.23.0 h1:Tchl7qkvE7Ip3y+ztvNufYFvkfqTe7NfLTYGIdJRLuE= +github.com/googleapis/gax-go/v2 v2.23.0/go.mod h1:rBQKOVJCdb8IFEzg+FCwlt1LP/xMDGuqUXhUG+XMXEg= github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= @@ -132,15 +130,15 @@ github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 h1:5VipnvEpbqr2gA2VbM+nYVbkIF2 github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0/go.mod h1:Hyl3n6Twe1hvtd9XUXDec4pTvgMSEixRuQKPTMH2bNs= github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= -github.com/jlaffaye/ftp v0.2.1 h1:AICcTYPMkaXlmjLMm9I+lB36f6jXCsCvBqVQc6EfC1Y= -github.com/jlaffaye/ftp v0.2.1/go.mod h1:gXSIr1pA9NhynDNigiFHs4+yL7o7I6bGF9Za9wi9tcE= +github.com/jlaffaye/ftp v0.2.2 h1:JwjrXCAIjN9ZYrF1/8qlmHFXDteh9MHYaiEIh/Oqtd8= +github.com/jlaffaye/ftp v0.2.2/go.mod h1:zuLAKdqFqFvNgkCrH0SC7K1XyUiydS7BFCmmoHUWWg0= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46/go.mod h1:yyMNCyc/Ib3bDTKd379tNMpB/7/H5TjM2Y9QJ5THLbE= -github.com/klauspost/compress v1.18.6 h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao= -github.com/klauspost/compress v1.18.6/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= +github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8= +github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE= github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= @@ -151,34 +149,32 @@ github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/lib/pq v1.12.3 h1:tTWxr2YLKwIvK90ZXEw8GP7UFHtcbTtty8zsI+YjrfQ= github.com/lib/pq v1.12.3/go.mod h1:/p+8NSbOcwzAEI7wiMXFlgydTwcgTr3OSKMsD2BitpA= -github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= -github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI= +github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w= github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= github.com/openzipkin/zipkin-go v0.4.3 h1:9EGwpqkgnwdEIJ+Od7QVSEIH+ocmm5nPat0G7sjsSdg= github.com/openzipkin/zipkin-go v0.4.3/go.mod h1:M9wCJZFWCo2RiY+o1eBCEMe0Dp2S5LDHcMZmk3RmK7c= -github.com/pierrec/lz4/v4 v4.1.25 h1:kocOqRffaIbU5djlIBr7Wh+cx82C0vtFb0fOurZHqD0= -github.com/pierrec/lz4/v4 v4.1.25/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4= +github.com/pierrec/lz4/v4 v4.1.27 h1:+PhzhWDrjRj89TH2sw43nE3+4+W8lSxIuQadEHZyjUk= +github.com/pierrec/lz4/v4 v4.1.27/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= -github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= +github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU= +github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= -github.com/prometheus/common v0.67.5 h1:pIgK94WWlQt1WLwAC5j2ynLaBRDiinoAb86HZHTUGI4= -github.com/prometheus/common v0.67.5/go.mod h1:SjE/0MzDEEAyrdr5Gqc6G+sXI67maCxzaT3A2+HqjUw= +github.com/prometheus/common v0.70.1 h1:1HvjP4D5oL3t8RsPlwxA9onvvStjtIHYE5XuuwOi/PY= +github.com/prometheus/common v0.70.1/go.mod h1:VdFUQDMZK3VLkurFUVhia6uys/0suUp86TJz5qbJRhc= github.com/prometheus/otlptranslator v1.0.0 h1:s0LJW/iN9dkIH+EnhiD3BlkkP5QVIUVEoIwkU+A6qos= github.com/prometheus/otlptranslator v1.0.0/go.mod h1:vRYWnXvI6aWGpsdY/mOT/cbeVRBlPWtBNDb7kGR3uKM= -github.com/prometheus/procfs v0.20.1 h1:XwbrGOIplXW/AU3YhIhLODXMJYyC1isLFfYCsTEycfc= -github.com/prometheus/procfs v0.20.1/go.mod h1:o9EMBZGRyvDrSPH1RqdxhojkuXstoe4UlK79eF5TGGo= +github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI= +github.com/prometheus/procfs v0.21.1/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY= github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0 h1:jsV3tyMeJrEoc2f3EhNf7qoBW3NEZW7l/4ziT3M+OJI= github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0/go.mod h1:e5t17bY9cEpVV+xw2U7jsPOKkXBtL5IQmNVABShnHUk= github.com/redis/go-redis/extra/redisotel/v9 v9.21.0 h1:36qq3rbF2If2CP0zGHHF8o/4XDluErn6DD0c9/L2iNI= @@ -194,13 +190,13 @@ github.com/segmentio/kafka-go v0.4.51/go.mod h1:Y1gn60kzLEEaW28YshXyk2+VCUKbJ3Qr github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/vektah/gqlparser/v2 v2.5.36 h1:CN9mKVHgMkc+XftdOWIhb4HEL8wKSYkFAqhf8booa7s= github.com/vektah/gqlparser/v2 v2.5.36/go.mod h1:cAJ9qwVgPaUkWv6Gn8vn0mqOE0Ui5Pn56wNy5396XWo= github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c= @@ -224,30 +220,30 @@ go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 h1:0Qx7VGBacMm9ZENQ7TnNObTYI4ShC+lHI16seduaxZo= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0/go.mod h1:Sje3i3MjSPKTSPvVWCaL8ugBzJwik3u4smCjUeuupqg= -go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0 h1:MCcYL7J6Vt/X0kjqbMZkekCmwsurbQRbL69vkiye2lk= -go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0/go.mod h1:3jnStNwSufK+f5ktjL4EPcwtig4rtd81NS70lqHuXl8= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 h1:8tvICD4vSTOOsNrsI4Ljf6C+6UKvpTEH5XY3JMoyPoo= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0/go.mod h1:z9+yiacE0IHRqM4qFfkbt/JYlmYXgss8GY/jXoNuPJI= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= +go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 h1:aVgLpGksz0vjoe6OynycqX8daNOAxJx5ZEhJXIXOVIU= +go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0/go.mod h1:kmJlX6WuTrAH1fOCSbPJFrSnUagB8c3SY3E87It3JD8= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 h1:LMuyCAyfalSjDyjdC65nK6N0zoTT63+E/u95X0JovZI= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0/go.mod h1:085m8qbm4hgc8rZWGDEa4vmyyo2c3nPxUslYUKUIU04= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0 h1:4YsVu3B8+3qtWYYrsUYgn0OG78pN0rnNPRGX4SbokQI= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0/go.mod h1:+wnlSn0mD1ADVMe3v9Z/WIaiz6q6gL2J/ejaAmdmv80= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 h1:qazEJlUOQzhCpzQpFETGby7EdqjI1wsd0W+6Gg1SCTU= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0/go.mod h1:fOD2Yefuxixkx3ahVNf0O/PERb6r4OlbxfATVnYvzCo= -go.opentelemetry.io/otel/exporters/prometheus v0.65.0 h1:jOveH/b4lU9HT7y+Gfamf18BqlOuz2PWEvs8yM7Q6XE= -go.opentelemetry.io/otel/exporters/prometheus v0.65.0/go.mod h1:i1P8pcumauPtUI4YNopea1dhzEMuEqWP1xoUZDylLHo= +go.opentelemetry.io/otel/exporters/prometheus v0.67.0 h1:7IefDa35e6V3NoiqIeLDMDxMFyZDk5qcoC0Ax4cC16E= +go.opentelemetry.io/otel/exporters/prometheus v0.67.0/go.mod h1:nsPI1awTg5Vmg1YrommL2mVarVGlqc4yXOoKAkPRD0c= go.opentelemetry.io/otel/exporters/zipkin v1.44.0 h1:zv7PRYGLrQHkdeZj0c5SNAZOJcw55XgaTezUkNpwA+w= go.opentelemetry.io/otel/exporters/zipkin v1.44.0/go.mod h1:3+VZyCi6hFW+UuxFF+wSOvwsOwncfBpQfP7Qdb3JXKg= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/metric/x v0.66.0 h1:YkCrx1zLOChi9ZcZ6euupOcsgzbVlec7D/xoEU1+cTA= -go.opentelemetry.io/otel/metric/x v0.66.0/go.mod h1:d1+BDj9t96do0/1LoU1ayfCv79ZgNE41qbhBvnMOBZk= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= -go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/metric/x v0.67.0 h1:PcicCNZFkZ4bXfSooXdo3WN7RBOVOtjVdo1wD358Uns= +go.opentelemetry.io/otel/metric/x v0.67.0/go.mod h1:FBjCWZe6wgcqxcMtjdGiClDKXb2YxxXii0CXftE4QtI= +go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= +go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= +go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= +go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.opentelemetry.io/proto/otlp v1.10.0 h1:IQRWgT5srOCYfiWnpqUYz9CVmbO8bFmKcwYxpuCSL2g= go.opentelemetry.io/proto/otlp v1.10.0/go.mod h1:/CV4QoCR/S9yaPj8utp3lvQPoqMtxXdzn7ozvvozVqk= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= @@ -258,8 +254,8 @@ go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= -go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= -go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= gofr.dev/pkg/gofr/datasource/file/ftp v0.2.2 h1:uiJqbPI5wEugsZ0b5wSxezFijETZ3K/tOfeKIFeM5F0= @@ -268,8 +264,8 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto= -golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= @@ -277,8 +273,8 @@ golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHl golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4= -golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ= +golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk= +golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -290,8 +286,8 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o= -golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= +golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= +golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= @@ -301,8 +297,8 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM= -golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= +golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek= +golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -311,19 +307,18 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw= -golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.44.0 h1:0rLvDRCtNj0gZkyIXhCyOb2OAzEhLVqc4B+hrsBhrmc= -golang.org/x/term v0.44.0/go.mod h1:7ze4MdzUzLXpSAoFP1H0bOI9aXDqveSvatT5vKcFh2Y= +golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= +golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= -golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE= -golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -335,27 +330,27 @@ golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8= -golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0= +golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE= +golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/api v0.287.0 h1:CQDMqUiqZZ0U/Yge3zyjAhNQ0OSYEH0PaA7l4xtEen4= -google.golang.org/api v0.287.0/go.mod h1:pPW85yt3Iuc3unkpaMhFtMmOqnTdCwCqEOaUlnuxRlQ= +google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= +google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= -google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94 h1:YJjbgu+dkp5kUJLfpMyCLfBIWZb/FcJyuLeo1gVBOuo= -google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94/go.mod h1:RRHjglSYABVCWpQ7USCpdfhcd9t4PkajvVwyynZizTc= -google.golang.org/genproto/googleapis/api v0.0.0-20260615183401-62b3387ff324 h1:g0RAkxK/smSu/iRwC/KIX1mwUoVJtk2OjbgaeS4DmUM= -google.golang.org/genproto/googleapis/api v0.0.0-20260615183401-62b3387ff324/go.mod h1:Z4WJ5pJOYWFWcHEQUelD5QaZDknIQkpIL/+fyJOT9+A= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d h1:mpAgMyM9vQHxycBlDq50y1VHpfSfVwzXvrQKtYbXuUY= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd h1:0GnSESHqea5EoaQgJyYxC3o5m0L191gCQdDgo2cxO5I= +google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= @@ -382,20 +377,20 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -modernc.org/cc/v4 v4.28.4 h1:Hd/4Es+MBj+/7hSdZaisNyu6bv3V0Dp2MdllyfqaH+c= -modernc.org/cc/v4 v4.28.4/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= -modernc.org/ccgo/v4 v4.34.4 h1:OVnSOWQjVKOYkFxoHYB+qQmSHK5gqMqARM+K9DpR/Ws= -modernc.org/ccgo/v4 v4.34.4/go.mod h1:qdKqE8FNIYyysougB1RX9MxCzp5oJOcQXSobANJ4TuE= +modernc.org/cc/v4 v4.29.1 h1:MKgdCV3WykTSPqpVrnxdEDS0HEd2FHpKZDzxzU5LyeI= +modernc.org/cc/v4 v4.29.1/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= +modernc.org/ccgo/v4 v4.34.6 h1:sBgfIwyN0TQ9C5hwIeuqyeAKyMWnbvj2fvpF4L11uzU= +modernc.org/ccgo/v4 v4.34.6/go.mod h1:SZ8YcN9NG7XVsQYdm6jYBvi8PQP1qi+kqB6OhjqI3Fk= modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM= modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU= modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI= modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito= -modernc.org/gc/v3 v3.1.3 h1:6QAplYyVO+KdPW3pGnqmJDUxtkec8ooEWvks/hhU3lc= -modernc.org/gc/v3 v3.1.3/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= +modernc.org/gc/v3 v3.1.4 h1:2g65LGVSmFQrXeITAw97x7hCRvZFcyE1uDP+7Vng7JI= +modernc.org/gc/v3 v3.1.4/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks= modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI= -modernc.org/libc v1.73.4 h1:+ra4Ui8ngyt8HDcO1FTDPWlkAh6yOdaO2yAoh8MddQA= -modernc.org/libc v1.73.4/go.mod h1:DXZ3eO8qMCNn2SnmTNCiC71nJ9Rcq3PsnpU6Vc4rWK8= +modernc.org/libc v1.74.4 h1:fX1Omw4o2/1C2iRkkIsrQTasJQldLhRmuPreXLoWs9k= +modernc.org/libc v1.74.4/go.mod h1:eeQAS9W3sZeKYMFubydxJpII9ybHWshk+7or7bLG9co= modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI= @@ -404,8 +399,8 @@ modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg= modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE= -modernc.org/sqlite v1.53.0 h1:20WG8N9q4ji/dEqGk4uiI0c6OPjSeLTNYGFCc3+7c1M= -modernc.org/sqlite v1.53.0/go.mod h1:xoEpOIpGrgT48H5iiyt/YXPCZPEzlfmfFwtk8Lklw8s= +modernc.org/sqlite v1.56.0 h1:/D8e2RfFqoy/Zc6PuC76U28zFwmI/sYx1Kjm4yEn9e0= +modernc.org/sqlite v1.56.0/go.mod h1:yCJ2cmAaIkHQ25oXWrF8H4O1lIfPYPR26yCEDj2P3pQ= modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= diff --git a/examples/using-s3-filestore/go.mod b/examples/using-s3-filestore/go.mod index d72d3f4271..84ba6723ff 100644 --- a/examples/using-s3-filestore/go.mod +++ b/examples/using-s3-filestore/go.mod @@ -7,22 +7,22 @@ require ( github.com/aws/aws-sdk-go-v2/config v1.32.37 github.com/aws/aws-sdk-go-v2/credentials v1.19.36 github.com/aws/aws-sdk-go-v2/service/s3 v1.107.2 - github.com/stretchr/testify v1.11.1 + github.com/stretchr/testify v1.12.1 gofr.dev v1.57.0 gofr.dev/pkg/gofr/datasource/file/s3 v0.3.0 ) require ( cloud.google.com/go v0.123.0 // indirect - cloud.google.com/go/auth v0.20.0 // indirect + cloud.google.com/go/auth v0.22.0 // indirect cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect cloud.google.com/go/compute/metadata v0.9.0 // indirect - cloud.google.com/go/iam v1.7.0 // indirect - cloud.google.com/go/pubsub v1.50.2 // indirect - cloud.google.com/go/pubsub/v2 v2.4.0 // indirect + cloud.google.com/go/iam v1.12.0 // indirect + cloud.google.com/go/pubsub v1.51.0 // indirect + cloud.google.com/go/pubsub/v2 v2.6.0 // indirect filippo.io/edwards25519 v1.2.0 // indirect github.com/DATA-DOG/go-sqlmock v1.5.2 // indirect - github.com/XSAM/otelsql v0.42.0 // indirect + github.com/XSAM/otelsql v0.43.0 // indirect github.com/agnivade/levenshtein v1.2.1 // indirect github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.18 // indirect github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.37 // indirect @@ -41,84 +41,82 @@ require ( github.com/beorn7/perks v1.0.1 // indirect github.com/cenkalti/backoff/v5 v5.0.3 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/eclipse/paho.mqtt.golang v1.5.1 // indirect - github.com/felixge/httpsnoop v1.0.4 // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/felixge/httpsnoop v1.1.0 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-sql-driver/mysql v1.10.0 // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/golang-jwt/jwt/v5 v5.3.1 // indirect github.com/google/s2a-go v0.1.9 // indirect github.com/google/uuid v1.6.0 // indirect - github.com/googleapis/enterprise-certificate-proxy v0.3.17 // indirect - github.com/googleapis/gax-go/v2 v2.22.0 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.19 // indirect + github.com/googleapis/gax-go/v2 v2.23.0 // indirect github.com/gorilla/mux v1.8.1 // indirect github.com/gorilla/websocket v1.5.3 // indirect github.com/graphql-go/graphql v0.8.1 // indirect github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.3.3 // indirect github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 // indirect github.com/joho/godotenv v1.5.1 // indirect - github.com/klauspost/compress v1.18.6 // indirect + github.com/klauspost/compress v1.19.2 // indirect github.com/lib/pq v1.12.3 // indirect - github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-isatty v0.0.24 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/ncruces/go-strftime v1.0.0 // indirect github.com/openzipkin/zipkin-go v0.4.3 // indirect - github.com/pierrec/lz4/v4 v4.1.25 // indirect + github.com/pierrec/lz4/v4 v4.1.27 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/prometheus/client_golang v1.23.2 // indirect + github.com/prometheus/client_golang v1.24.1 // indirect github.com/prometheus/client_model v0.6.2 // indirect - github.com/prometheus/common v0.67.5 // indirect + github.com/prometheus/common v0.70.1 // indirect github.com/prometheus/otlptranslator v1.0.0 // indirect - github.com/prometheus/procfs v0.20.1 // indirect + github.com/prometheus/procfs v0.21.1 // indirect github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0 // indirect github.com/redis/go-redis/extra/redisotel/v9 v9.21.0 // indirect github.com/redis/go-redis/v9 v9.21.0 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect github.com/segmentio/kafka-go v0.4.51 // indirect - github.com/vektah/gqlparser/v2 v2.5.33 // indirect + github.com/vektah/gqlparser/v2 v2.5.36 // indirect github.com/xdg-go/pbkdf2 v1.0.0 // indirect github.com/xdg-go/scram v1.1.2 // indirect github.com/xdg-go/stringprep v1.0.4 // indirect go.opencensus.io v0.24.0 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 // indirect - go.opentelemetry.io/otel v1.44.0 // indirect + go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 // indirect + go.opentelemetry.io/otel v1.45.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 // indirect - go.opentelemetry.io/otel/exporters/prometheus v0.65.0 // indirect + go.opentelemetry.io/otel/exporters/prometheus v0.67.0 // indirect go.opentelemetry.io/otel/exporters/zipkin v1.44.0 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - go.opentelemetry.io/otel/sdk v1.44.0 // indirect - go.opentelemetry.io/otel/sdk/metric v1.44.0 // indirect - go.opentelemetry.io/otel/trace v1.44.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/sdk v1.45.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect + go.opentelemetry.io/otel/trace v1.45.0 // indirect go.opentelemetry.io/proto/otlp v1.10.0 // indirect go.uber.org/atomic v1.11.0 // indirect go.uber.org/mock v0.6.0 // indirect - go.yaml.in/yaml/v2 v2.4.4 // indirect - golang.org/x/crypto v0.53.0 // indirect - golang.org/x/net v0.56.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/crypto v0.55.0 // indirect + golang.org/x/net v0.57.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect - golang.org/x/sync v0.21.0 // indirect + golang.org/x/sync v0.22.0 // indirect golang.org/x/sys v0.47.0 // indirect golang.org/x/term v0.45.0 // indirect - golang.org/x/text v0.38.0 // indirect + golang.org/x/text v0.41.0 // indirect golang.org/x/time v0.15.0 // indirect - google.golang.org/api v0.288.0 // indirect - google.golang.org/genproto v0.0.0-20260319201613-d00831a3d3e7 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260630182238-925bb5da69e7 // indirect + google.golang.org/api v0.291.0 // indirect + google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect google.golang.org/grpc v1.83.0 // indirect google.golang.org/protobuf v1.36.11 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect - modernc.org/libc v1.73.4 // indirect + modernc.org/libc v1.74.4 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.11.0 // indirect - modernc.org/sqlite v1.53.0 // indirect + modernc.org/sqlite v1.56.0 // indirect ) diff --git a/examples/using-s3-filestore/go.sum b/examples/using-s3-filestore/go.sum index 34a688874a..1b535d20c5 100644 --- a/examples/using-s3-filestore/go.sum +++ b/examples/using-s3-filestore/go.sum @@ -1,35 +1,33 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE= cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU= -cloud.google.com/go/auth v0.20.0 h1:kXTssoVb4azsVDoUiF8KvxAqrsQcQtB53DcSgta74CA= -cloud.google.com/go/auth v0.20.0/go.mod h1:942/yi/itH1SsmpyrbnTMDgGfdy2BUqIKyd0cyYLc5Q= +cloud.google.com/go/auth v0.22.0 h1:Xp9wAKkLoeaYb5pYZZoQGz4E9sdPxIbzS3gywZE3ciQ= +cloud.google.com/go/auth v0.22.0/go.mod h1:M9o2Oz+YI2jAfxewJgb1vyI3vceHF+eohmxyzmrl+9s= cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc= cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10= -cloud.google.com/go/iam v1.7.0 h1:JD3zh0C6LHl16aCn5Akff0+GELdp1+4hmh6ndoFLl8U= -cloud.google.com/go/iam v1.7.0/go.mod h1:tetWZW1PD/m6vcuY2Zj/aU0eCHNPuxedbnbRTyKXvdY= -cloud.google.com/go/kms v1.26.0 h1:cK9mN2cf+9V63D3H1f6koxTatWy39aTI/hCjz1I+adU= -cloud.google.com/go/kms v1.26.0/go.mod h1:pHKOdFJm63hxBsiPkYtowZPltu9dW0MWvBa6IA4HM58= -cloud.google.com/go/longrunning v0.9.0 h1:0EzbDEGsAvOZNbqXopgniY0w0a1phvu5IdUFq8grmqY= -cloud.google.com/go/longrunning v0.9.0/go.mod h1:pkTz846W7bF4o2SzdWJ40Hu0Re+UoNT6Q5t+igIcb8E= -cloud.google.com/go/pubsub v1.50.2 h1:54Up97HnThdP4H8jjWJSSQ/mnYG2EKon7ZSNETRq0tM= -cloud.google.com/go/pubsub v1.50.2/go.mod h1:jyCWeZdGFqd4mitSsBERnJcpqaHBsxQoPkNvjj4sp0w= -cloud.google.com/go/pubsub/v2 v2.4.0 h1:oMKNiBQpXImRWnHYla9uSU66ZzByZwBSCJOEs/pTKVg= -cloud.google.com/go/pubsub/v2 v2.4.0/go.mod h1:2lS/XQKq5qtOMs6kHBK+WX1ytUC36kLl2ig3zqsGUx8= +cloud.google.com/go/iam v1.12.0 h1:Aki3bX9aHUDKPHfnRJfDcTdVedvy6quGBQcTqx3DRXk= +cloud.google.com/go/iam v1.12.0/go.mod h1:FEZ4lXpADAC2AIpQY7LANNjjwyQ2jK439CI2VaD+sLY= +cloud.google.com/go/kms v1.32.0 h1:s+rEluaaZKhLVjrIWG7uNBsnWbiitElzNzFGyp6+nIg= +cloud.google.com/go/kms v1.32.0/go.mod h1:CSGvW6GnMQbY+1nOHcIzhMtHSbExXlOmCKjWtYVjcpA= +cloud.google.com/go/longrunning v1.2.0 h1:WjYH3YHBGCxGJP9M4dWGHBfXr/cFIjMkNgWcJj7/iMM= +cloud.google.com/go/longrunning v1.2.0/go.mod h1:5KMQALFGOCtFoi2xSOA1u3H7WKlhmckgiyFw7+LGQp0= +cloud.google.com/go/pubsub v1.51.0 h1:XOaCejsqX7EEtUdQz+WPag66wWsUUGliyCOfGPKfo90= +cloud.google.com/go/pubsub v1.51.0/go.mod h1:NERXf11sd82UV3VnflcUj8POIyQUXT/QwrKlxD8di/I= +cloud.google.com/go/pubsub/v2 v2.6.0 h1:8pjR0id+GTB+krKx5G6AGJoYrHog58w2Q89PCOrfM64= +cloud.google.com/go/pubsub/v2 v2.6.0/go.mod h1:4anqvV/w8Pcgu2tO0qr2XgsF3GXHowzryfQ5gOnVmWY= filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo= filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU= github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= -github.com/XSAM/otelsql v0.42.0 h1:Li0xF4eJUxG2e0x3D4rvRlys1f27yJKvjTh7ljkUP5o= -github.com/XSAM/otelsql v0.42.0/go.mod h1:4mOrEv+cS1KmKzrvTktvJnstr5GtKSAK+QHvFR9OcpI= +github.com/XSAM/otelsql v0.43.0 h1:ZIhXqRoMhILXQwBQoq/Dl6Taap/KEFQXZrWjYV1L8X8= +github.com/XSAM/otelsql v0.43.0/go.mod h1:DJBGBvbtwf1OCBYRTjpRFxOqi6ONpdfb+htr4ncRWuw= github.com/agnivade/levenshtein v1.2.1 h1:EHBY3UOn1gwdy/VbFwgo4cxecRznFk7fKWN1KOX7eoM= github.com/agnivade/levenshtein v1.2.1/go.mod h1:QVVI16kDrtSuwcpd0p1+xMC6Z/VfhtCyDIjcwga4/DU= github.com/alicebob/miniredis/v2 v2.38.0 h1:nZAzCR+Lj+Vxk4ZXzm2NuKq2O33RXj1XxJ2e2uP9jiw= github.com/alicebob/miniredis/v2 v2.38.0/go.mod h1:TcL7YfarKPGDAthEtl5NBeHZfeUQj6OXMm/+iu5cLMM= -github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883 h1:bvNMNQO63//z+xNgfBlViaCIJKLlCJ6/fmUseuG0wVQ= -github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8= github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0 h1:jfIu9sQUG6Ig+0+Ap1h4unLjW6YQJpKZVmUzxsD4E/Q= github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0/go.mod h1:t2tdKJDJF9BV14lnkjHmOQgcvEKgtqs5a1N3LNdJhGE= github.com/aws/aws-sdk-go-v2 v1.43.6 h1:RrmFcqCBxkJuf7g1axVo5krB4jM/AO8r5e5oujrgdoQ= @@ -85,8 +83,6 @@ github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2 h1:aBangftG7EVZoUb69Os github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2/go.mod h1:qwXFYgsP6T7XnJtbKlf1HP8AjxZZyzxMmc+Lq5GjlU4= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d h1:abDbP7XBVgwda+h0J5Qra5p2OQpidU2FdkXvzCKL+H8= github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d/go.mod h1:wKFzULXAPj3U2BDAPWXhSbQQNC6FU1+1/5iika6IY7g= github.com/dgryski/trifles v0.0.0-20230903005119-f50d829f2e54 h1:SG7nF6SRlWhcT7cNTs5R6Hk4V2lcmLz2NsG2VnInyNo= @@ -104,11 +100,11 @@ github.com/envoyproxy/go-control-plane/envoy v1.37.0/go.mod h1:DReE9MMrmecPy+YvQ github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/envoyproxy/protoc-gen-validate v1.3.3 h1:MVQghNeW+LZcmXe7SY1V36Z+WFMDjpqGAGacLe2T0ds= github.com/envoyproxy/protoc-gen-validate v1.3.3/go.mod h1:TsndJ/ngyIdQRhMcVVGDDHINPLWB7C82oDArY51KfB0= -github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= -github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/felixge/httpsnoop v1.1.0 h1:3YtUj32ZZkqZtt3sZZsClsymw/QDuVfpNhoA31zeORc= +github.com/felixge/httpsnoop v1.1.0/go.mod h1:Zqxgdd+1Rkcz8euOqdr7lqgCRJztwr5hp9vDSi5UZCE= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-redis/redismock/v9 v9.2.0 h1:ZrMYQeKPECZPjOj5u9eyOjg8Nnb0BS9lkVIZ6IpsKLw= @@ -143,17 +139,17 @@ github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs= -github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA= +github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3 h1:LMLX+LgTNWpfvCBdFebv6EsYotImrt/Ppc5cXIriCSo= +github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3/go.mod h1:jl5iWTm0/hd5PjEYEOuwAJ57L/CibdZfrqZ5XA5GrCk= github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0= github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/enterprise-certificate-proxy v0.3.17 h1:73NfMHdiqo9JFU9+7a5ExpVa10/R29pXfZIaW559nrg= -github.com/googleapis/enterprise-certificate-proxy v0.3.17/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= -github.com/googleapis/gax-go/v2 v2.22.0 h1:PjIWBpgGIVKGoCXuiCoP64altEJCj3/Ei+kSU5vlZD4= -github.com/googleapis/gax-go/v2 v2.22.0/go.mod h1:irWBbALSr0Sk3qlqb9SyJ1h68WjgeFuiOzI4Rqw5+aY= +github.com/googleapis/enterprise-certificate-proxy v0.3.19 h1:mMOE7DN2+p76/EdIrmAy9B9bH+yC4563vmnJ34QR8i4= +github.com/googleapis/enterprise-certificate-proxy v0.3.19/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= +github.com/googleapis/gax-go/v2 v2.23.0 h1:Tchl7qkvE7Ip3y+ztvNufYFvkfqTe7NfLTYGIdJRLuE= +github.com/googleapis/gax-go/v2 v2.23.0/go.mod h1:rBQKOVJCdb8IFEzg+FCwlt1LP/xMDGuqUXhUG+XMXEg= github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= @@ -171,8 +167,8 @@ github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwA github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46/go.mod h1:yyMNCyc/Ib3bDTKd379tNMpB/7/H5TjM2Y9QJ5THLbE= -github.com/klauspost/compress v1.18.6 h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao= -github.com/klauspost/compress v1.18.6/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= +github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8= +github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE= github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= @@ -183,34 +179,32 @@ github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/lib/pq v1.12.3 h1:tTWxr2YLKwIvK90ZXEw8GP7UFHtcbTtty8zsI+YjrfQ= github.com/lib/pq v1.12.3/go.mod h1:/p+8NSbOcwzAEI7wiMXFlgydTwcgTr3OSKMsD2BitpA= -github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= -github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI= +github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w= github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= github.com/openzipkin/zipkin-go v0.4.3 h1:9EGwpqkgnwdEIJ+Od7QVSEIH+ocmm5nPat0G7sjsSdg= github.com/openzipkin/zipkin-go v0.4.3/go.mod h1:M9wCJZFWCo2RiY+o1eBCEMe0Dp2S5LDHcMZmk3RmK7c= -github.com/pierrec/lz4/v4 v4.1.25 h1:kocOqRffaIbU5djlIBr7Wh+cx82C0vtFb0fOurZHqD0= -github.com/pierrec/lz4/v4 v4.1.25/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4= +github.com/pierrec/lz4/v4 v4.1.27 h1:+PhzhWDrjRj89TH2sw43nE3+4+W8lSxIuQadEHZyjUk= +github.com/pierrec/lz4/v4 v4.1.27/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= -github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= +github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU= +github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= -github.com/prometheus/common v0.67.5 h1:pIgK94WWlQt1WLwAC5j2ynLaBRDiinoAb86HZHTUGI4= -github.com/prometheus/common v0.67.5/go.mod h1:SjE/0MzDEEAyrdr5Gqc6G+sXI67maCxzaT3A2+HqjUw= +github.com/prometheus/common v0.70.1 h1:1HvjP4D5oL3t8RsPlwxA9onvvStjtIHYE5XuuwOi/PY= +github.com/prometheus/common v0.70.1/go.mod h1:VdFUQDMZK3VLkurFUVhia6uys/0suUp86TJz5qbJRhc= github.com/prometheus/otlptranslator v1.0.0 h1:s0LJW/iN9dkIH+EnhiD3BlkkP5QVIUVEoIwkU+A6qos= github.com/prometheus/otlptranslator v1.0.0/go.mod h1:vRYWnXvI6aWGpsdY/mOT/cbeVRBlPWtBNDb7kGR3uKM= -github.com/prometheus/procfs v0.20.1 h1:XwbrGOIplXW/AU3YhIhLODXMJYyC1isLFfYCsTEycfc= -github.com/prometheus/procfs v0.20.1/go.mod h1:o9EMBZGRyvDrSPH1RqdxhojkuXstoe4UlK79eF5TGGo= +github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI= +github.com/prometheus/procfs v0.21.1/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY= github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0 h1:jsV3tyMeJrEoc2f3EhNf7qoBW3NEZW7l/4ziT3M+OJI= github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0/go.mod h1:e5t17bY9cEpVV+xw2U7jsPOKkXBtL5IQmNVABShnHUk= github.com/redis/go-redis/extra/redisotel/v9 v9.21.0 h1:36qq3rbF2If2CP0zGHHF8o/4XDluErn6DD0c9/L2iNI= @@ -223,20 +217,18 @@ github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0t github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/segmentio/kafka-go v0.4.51 h1:JgDPPG75tC1rWIS2Me6MwcvXJ6f49UQ4HjAOef71Hno= github.com/segmentio/kafka-go v0.4.51/go.mod h1:Y1gn60kzLEEaW28YshXyk2+VCUKbJ3Qr6DrnT3i4+9E= -github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8= -github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= -github.com/vektah/gqlparser/v2 v2.5.33 h1:lRp8aIeNUNbimf/axZd7ETg24q06hBtPaas+TcvI/7E= -github.com/vektah/gqlparser/v2 v2.5.33/go.mod h1:c1I28gSOVNzlfc4WuDlqU7voQnsqI6OG2amkBAFmgts= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= +github.com/vektah/gqlparser/v2 v2.5.36 h1:CN9mKVHgMkc+XftdOWIhb4HEL8wKSYkFAqhf8booa7s= +github.com/vektah/gqlparser/v2 v2.5.36/go.mod h1:cAJ9qwVgPaUkWv6Gn8vn0mqOE0Ui5Pn56wNy5396XWo= github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c= github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI= github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY= @@ -256,32 +248,32 @@ go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0= go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0 h1:yI1/OhfEPy7J9eoa6Sj051C7n5dvpj0QX8g4sRchg04= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0/go.mod h1:NoUCKYWK+3ecatC4HjkRktREheMeEtrXoQxrqYFeHSc= -go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0 h1:MCcYL7J6Vt/X0kjqbMZkekCmwsurbQRbL69vkiye2lk= -go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0/go.mod h1:3jnStNwSufK+f5ktjL4EPcwtig4rtd81NS70lqHuXl8= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 h1:8tvICD4vSTOOsNrsI4Ljf6C+6UKvpTEH5XY3JMoyPoo= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0/go.mod h1:z9+yiacE0IHRqM4qFfkbt/JYlmYXgss8GY/jXoNuPJI= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 h1:0Qx7VGBacMm9ZENQ7TnNObTYI4ShC+lHI16seduaxZo= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0/go.mod h1:Sje3i3MjSPKTSPvVWCaL8ugBzJwik3u4smCjUeuupqg= +go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 h1:aVgLpGksz0vjoe6OynycqX8daNOAxJx5ZEhJXIXOVIU= +go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0/go.mod h1:kmJlX6WuTrAH1fOCSbPJFrSnUagB8c3SY3E87It3JD8= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 h1:LMuyCAyfalSjDyjdC65nK6N0zoTT63+E/u95X0JovZI= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0/go.mod h1:085m8qbm4hgc8rZWGDEa4vmyyo2c3nPxUslYUKUIU04= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0 h1:4YsVu3B8+3qtWYYrsUYgn0OG78pN0rnNPRGX4SbokQI= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0/go.mod h1:+wnlSn0mD1ADVMe3v9Z/WIaiz6q6gL2J/ejaAmdmv80= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 h1:qazEJlUOQzhCpzQpFETGby7EdqjI1wsd0W+6Gg1SCTU= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0/go.mod h1:fOD2Yefuxixkx3ahVNf0O/PERb6r4OlbxfATVnYvzCo= -go.opentelemetry.io/otel/exporters/prometheus v0.65.0 h1:jOveH/b4lU9HT7y+Gfamf18BqlOuz2PWEvs8yM7Q6XE= -go.opentelemetry.io/otel/exporters/prometheus v0.65.0/go.mod h1:i1P8pcumauPtUI4YNopea1dhzEMuEqWP1xoUZDylLHo= +go.opentelemetry.io/otel/exporters/prometheus v0.67.0 h1:7IefDa35e6V3NoiqIeLDMDxMFyZDk5qcoC0Ax4cC16E= +go.opentelemetry.io/otel/exporters/prometheus v0.67.0/go.mod h1:nsPI1awTg5Vmg1YrommL2mVarVGlqc4yXOoKAkPRD0c= go.opentelemetry.io/otel/exporters/zipkin v1.44.0 h1:zv7PRYGLrQHkdeZj0c5SNAZOJcw55XgaTezUkNpwA+w= go.opentelemetry.io/otel/exporters/zipkin v1.44.0/go.mod h1:3+VZyCi6hFW+UuxFF+wSOvwsOwncfBpQfP7Qdb3JXKg= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/metric/x v0.66.0 h1:YkCrx1zLOChi9ZcZ6euupOcsgzbVlec7D/xoEU1+cTA= -go.opentelemetry.io/otel/metric/x v0.66.0/go.mod h1:d1+BDj9t96do0/1LoU1ayfCv79ZgNE41qbhBvnMOBZk= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= -go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/metric/x v0.67.0 h1:PcicCNZFkZ4bXfSooXdo3WN7RBOVOtjVdo1wD358Uns= +go.opentelemetry.io/otel/metric/x v0.67.0/go.mod h1:FBjCWZe6wgcqxcMtjdGiClDKXb2YxxXii0CXftE4QtI= +go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= +go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= +go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= +go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.opentelemetry.io/proto/otlp v1.10.0 h1:IQRWgT5srOCYfiWnpqUYz9CVmbO8bFmKcwYxpuCSL2g= go.opentelemetry.io/proto/otlp v1.10.0/go.mod h1:/CV4QoCR/S9yaPj8utp3lvQPoqMtxXdzn7ozvvozVqk= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= @@ -292,6 +284,8 @@ go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= gofr.dev/pkg/gofr/datasource/file/s3 v0.3.0 h1:HK9qb5sDUOy9OQTzAZ8StTRWkgfI9TRv+dzPEJJzjeQ= @@ -300,8 +294,8 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto= -golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= @@ -309,8 +303,8 @@ golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHl golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4= -golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ= +golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk= +golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -322,8 +316,8 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o= -golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= +golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= +golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= @@ -333,8 +327,8 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM= -golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= +golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek= +golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -343,7 +337,6 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= @@ -354,8 +347,8 @@ golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= -golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE= -golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -367,27 +360,27 @@ golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8= -golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0= +golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE= +golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/api v0.288.0 h1:glhO/J88obKP5I269W3hB73dvBKrjU56ZfmNlNXpgTU= -google.golang.org/api v0.288.0/go.mod h1:lM2kYRzYUCBY91P9h6VF1PYmvhxii3O5hji37qRvIcY= +google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= +google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= -google.golang.org/genproto v0.0.0-20260319201613-d00831a3d3e7 h1:XzmzkmB14QhVhgnawEVsOn6OFsnpyxNPRY9QV01dNB0= -google.golang.org/genproto v0.0.0-20260319201613-d00831a3d3e7/go.mod h1:L43LFes82YgSonw6iTXTxXUX1OlULt4AQtkik4ULL/I= -google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa h1:Kjn0N0tCrDgiAFW+lGO4JZ3ck44CehvJQMAwj9QF0G8= -google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa/go.mod h1:q4lMZS6kskjT5HvCPrnnypcDPVJqT/f4nfxmkE7gryY= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260630182238-925bb5da69e7 h1:eM/YSd5bBFagF51o1E745Ta7RwzpW0h+z+QDNZOgmQ8= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260630182238-925bb5da69e7/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd h1:0GnSESHqea5EoaQgJyYxC3o5m0L191gCQdDgo2cxO5I= +google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= @@ -414,20 +407,20 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -modernc.org/cc/v4 v4.28.4 h1:Hd/4Es+MBj+/7hSdZaisNyu6bv3V0Dp2MdllyfqaH+c= -modernc.org/cc/v4 v4.28.4/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= -modernc.org/ccgo/v4 v4.34.4 h1:OVnSOWQjVKOYkFxoHYB+qQmSHK5gqMqARM+K9DpR/Ws= -modernc.org/ccgo/v4 v4.34.4/go.mod h1:qdKqE8FNIYyysougB1RX9MxCzp5oJOcQXSobANJ4TuE= +modernc.org/cc/v4 v4.29.1 h1:MKgdCV3WykTSPqpVrnxdEDS0HEd2FHpKZDzxzU5LyeI= +modernc.org/cc/v4 v4.29.1/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= +modernc.org/ccgo/v4 v4.34.6 h1:sBgfIwyN0TQ9C5hwIeuqyeAKyMWnbvj2fvpF4L11uzU= +modernc.org/ccgo/v4 v4.34.6/go.mod h1:SZ8YcN9NG7XVsQYdm6jYBvi8PQP1qi+kqB6OhjqI3Fk= modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM= modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU= modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI= modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito= -modernc.org/gc/v3 v3.1.3 h1:6QAplYyVO+KdPW3pGnqmJDUxtkec8ooEWvks/hhU3lc= -modernc.org/gc/v3 v3.1.3/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= +modernc.org/gc/v3 v3.1.4 h1:2g65LGVSmFQrXeITAw97x7hCRvZFcyE1uDP+7Vng7JI= +modernc.org/gc/v3 v3.1.4/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks= modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI= -modernc.org/libc v1.73.4 h1:+ra4Ui8ngyt8HDcO1FTDPWlkAh6yOdaO2yAoh8MddQA= -modernc.org/libc v1.73.4/go.mod h1:DXZ3eO8qMCNn2SnmTNCiC71nJ9Rcq3PsnpU6Vc4rWK8= +modernc.org/libc v1.74.4 h1:fX1Omw4o2/1C2iRkkIsrQTasJQldLhRmuPreXLoWs9k= +modernc.org/libc v1.74.4/go.mod h1:eeQAS9W3sZeKYMFubydxJpII9ybHWshk+7or7bLG9co= modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI= @@ -436,8 +429,8 @@ modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg= modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE= -modernc.org/sqlite v1.53.0 h1:20WG8N9q4ji/dEqGk4uiI0c6OPjSeLTNYGFCc3+7c1M= -modernc.org/sqlite v1.53.0/go.mod h1:xoEpOIpGrgT48H5iiyt/YXPCZPEzlfmfFwtk8Lklw8s= +modernc.org/sqlite v1.56.0 h1:/D8e2RfFqoy/Zc6PuC76U28zFwmI/sYx1Kjm4yEn9e0= +modernc.org/sqlite v1.56.0/go.mod h1:yCJ2cmAaIkHQ25oXWrF8H4O1lIfPYPR26yCEDj2P3pQ= modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= diff --git a/go.mod b/go.mod index 70c8bdaab3..f3d4b52ac9 100644 --- a/go.mod +++ b/go.mod @@ -26,7 +26,7 @@ require ( github.com/redis/go-redis/extra/redisotel/v9 v9.21.0 github.com/redis/go-redis/v9 v9.22.0 github.com/segmentio/kafka-go v0.4.51 - github.com/stretchr/testify v1.11.1 + github.com/stretchr/testify v1.12.1 github.com/vektah/gqlparser/v2 v2.5.36 go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 go.opentelemetry.io/otel v1.45.0 @@ -66,7 +66,6 @@ require ( github.com/beorn7/perks v1.0.1 // indirect github.com/cenkalti/backoff/v5 v5.0.3 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/felixge/httpsnoop v1.1.0 // indirect github.com/fsnotify/fsnotify v1.6.0 // indirect @@ -84,13 +83,12 @@ require ( github.com/ncruces/go-strftime v1.0.0 // indirect github.com/openzipkin/zipkin-go v0.4.3 // indirect github.com/pierrec/lz4/v4 v4.1.27 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/prometheus/client_model v0.6.2 // indirect github.com/prometheus/common v0.70.1 // indirect github.com/prometheus/procfs v0.21.1 // indirect github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect - github.com/stretchr/objx v0.5.2 // indirect + github.com/stretchr/objx v0.5.3 // indirect github.com/xdg-go/pbkdf2 v1.0.0 // indirect github.com/xdg-go/scram v1.1.2 // indirect github.com/xdg-go/stringprep v1.0.4 // indirect @@ -103,6 +101,7 @@ require ( go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0 // indirect go.opentelemetry.io/proto/otlp v1.10.0 // indirect go.uber.org/atomic v1.11.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/crypto v0.55.0 // indirect golang.org/x/net v0.57.0 // indirect golang.org/x/sys v0.47.0 // indirect diff --git a/go.sum b/go.sum index f6ec1e7426..22dcf51d92 100644 --- a/go.sum +++ b/go.sum @@ -47,8 +47,6 @@ github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2 h1:aBangftG7EVZoUb69Os github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2/go.mod h1:qwXFYgsP6T7XnJtbKlf1HP8AjxZZyzxMmc+Lq5GjlU4= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d h1:abDbP7XBVgwda+h0J5Qra5p2OQpidU2FdkXvzCKL+H8= github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d/go.mod h1:wKFzULXAPj3U2BDAPWXhSbQQNC6FU1+1/5iika6IY7g= github.com/dgryski/trifles v0.0.0-20230903005119-f50d829f2e54 h1:SG7nF6SRlWhcT7cNTs5R6Hk4V2lcmLz2NsG2VnInyNo= @@ -168,8 +166,6 @@ github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU= github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= @@ -196,13 +192,13 @@ github.com/segmentio/kafka-go v0.4.51/go.mod h1:Y1gn60kzLEEaW28YshXyk2+VCUKbJ3Qr github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/vektah/gqlparser/v2 v2.5.36 h1:CN9mKVHgMkc+XftdOWIhb4HEL8wKSYkFAqhf8booa7s= github.com/vektah/gqlparser/v2 v2.5.36/go.mod h1:cAJ9qwVgPaUkWv6Gn8vn0mqOE0Ui5Pn56wNy5396XWo= github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c= @@ -264,8 +260,8 @@ go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= -go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= -go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= diff --git a/go.work.sum b/go.work.sum index 09eeca8bc4..eb80590586 100644 --- a/go.work.sum +++ b/go.work.sum @@ -554,6 +554,7 @@ cloud.google.com/go/gsuiteaddons v1.7.8/go.mod h1:DBKNHH4YXAdd/rd6zVvtOGAJNGo0ek cloud.google.com/go/gsuiteaddons v1.12.0 h1:kz9DyBk84wZCda2Rdha1MOIf7/9x6R+N+LuH9B3zYFs= cloud.google.com/go/gsuiteaddons v1.12.0/go.mod h1:rm/XT7wmwOFGn7jmWtVV65QmZCakzTbHLSojIC4Hskg= cloud.google.com/go/iam v1.5.2/go.mod h1:SE1vg0N81zQqLzQEwxL2WI6yhetBdbNQuTvIKCSkUHE= +cloud.google.com/go/iam v1.7.0/go.mod h1:tetWZW1PD/m6vcuY2Zj/aU0eCHNPuxedbnbRTyKXvdY= cloud.google.com/go/iap v1.11.2 h1:VIioCrYsyWiRGx7Y8RDNylpI6d4t1Qx5ZgSLUVmWWPo= cloud.google.com/go/iap v1.11.2/go.mod h1:Bh99DMUpP5CitL9lK0BC8MYgjjYO4b3FbyhgW1VHJvg= cloud.google.com/go/iap v1.11.3 h1:Nheb77nO0/pECm/thoE3wHVAbkQSI+G8KBWviqBepiA= @@ -591,8 +592,6 @@ cloud.google.com/go/lifesciences v0.15.0/go.mod h1:FwS+QkqPdVWl4SmKUCFozFvsTVWTL cloud.google.com/go/lifesciences v0.16.0 h1:T+7N3oVHK8a7BhX6HJLrBW8xEbMV9iY8Mb+aOl7r6+A= cloud.google.com/go/lifesciences v0.16.0/go.mod h1:axEwGa3A63+vCXIis+0Zkseu8KecqtNoSn7x0zyjJfM= cloud.google.com/go/logging v1.13.0/go.mod h1:36CoKh6KA/M0PbhPKMq6/qety2DCAErbhXT62TuXALA= -cloud.google.com/go/logging v1.19.0 h1:NCqhdVUg3wQ8Cobdf16FDSuTGi3+6+hdSBHrY5TsR6Q= -cloud.google.com/go/logging v1.19.0/go.mod h1:i40NZCHC9Gqvod4yE+yQfDWwlgwW/SrshkkGibCHxcA= cloud.google.com/go/longrunning v0.6.6/go.mod h1:hyeGJUrPHcx0u2Uu1UFSoYZLn4lkMrccJig0t4FI7yw= cloud.google.com/go/longrunning v0.6.7/go.mod h1:EAFV3IZAKmM56TyiE6VAP3VoTzhZzySwI/YI1s/nRsY= cloud.google.com/go/longrunning v0.7.0/go.mod h1:ySn2yXmjbK9Ba0zsQqunhDkYi0+9rlXIwnoAf+h+TPY= @@ -642,8 +641,6 @@ cloud.google.com/go/metastore v1.20.0 h1:kz0XBkP531MB1IR9jTY6/DB33UFP5Df1vFpPNgW cloud.google.com/go/metastore v1.20.0/go.mod h1:/bhZoizjM5iOrqWJeAFDw7c16C783wEftqofnJgKKYI= cloud.google.com/go/monitoring v1.24.0/go.mod h1:Bd1PRK5bmQBQNnuGwHBfUamAV1ys9049oEPHnn4pcsc= cloud.google.com/go/monitoring v1.24.2/go.mod h1:x7yzPWcgDRnPEv3sI+jJGBkwl5qINf+6qY4eq0I9B4U= -cloud.google.com/go/monitoring v1.30.0 h1:r/d+JUbyKmJ8b07iznuKfzVzrIXTWxHQ3lBRm3x2LlY= -cloud.google.com/go/monitoring v1.30.0/go.mod h1:htlUR0QWVMrjFzZmN4LGnMAve9xB/eduwjmINxVZ8RM= cloud.google.com/go/networkconnectivity v1.17.1 h1:RQcG1rZNCNV5Dn3tnINs4TYswDXk2hKH+85eh+JvoWU= cloud.google.com/go/networkconnectivity v1.17.1/go.mod h1:DTZCq8POTkHgAlOAAEDQF3cMEr/B9k1ZbpklqvHEBtg= cloud.google.com/go/networkconnectivity v1.19.1 h1:n0IzhdgSNzIKQygWwDV8yKRXkZpX3FsjCYFbO9iNHPU= @@ -1212,6 +1209,7 @@ github.com/envoyproxy/protoc-gen-validate v1.1.0/go.mod h1:sXRDRVmzEbkM7CVcM06s9 github.com/envoyproxy/protoc-gen-validate v1.2.1/go.mod h1:d/C80l/jxXLdfEIhX1W2TmLfsJ31lvEjwamM4DxlWXU= github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo= github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/flosch/pongo2/v4 v4.0.2 h1:gv+5Pe3vaSVmiJvh/BZa82b7/00YUGm0PIyVVLop0Hw= github.com/flosch/pongo2/v4 v4.0.2/go.mod h1:B5ObFANs/36VwxxlgKpdchIJHMvHB562PW+BWPhwZD8= github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU= @@ -1323,6 +1321,7 @@ github.com/googleapis/enterprise-certificate-proxy v0.3.6/go.mod h1:MkHOF77EYAE7 github.com/googleapis/enterprise-certificate-proxy v0.3.7/go.mod h1:MkHOF77EYAE7qfSuSS9PU6g4Nt4e11cnsDUowfwewLA= github.com/googleapis/enterprise-certificate-proxy v0.3.11/go.mod h1:RFV7MUdlb7AgEq2v7FmMCfeSMCllAzWxFgRdusoGks8= github.com/googleapis/enterprise-certificate-proxy v0.3.14/go.mod h1:vqVt9yG9480NtzREnTlmGSBmFrA+bzb0yl0TxoBQXOg= +github.com/googleapis/enterprise-certificate-proxy v0.3.18/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= github.com/googleapis/gax-go/v2 v2.14.1/go.mod h1:Hb/NubMaVM88SrNkvl8X/o8XWwDJEPqouaLeN2IUxoA= @@ -1420,6 +1419,7 @@ github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46 h1:veS9QfglfvqAw github.com/klauspost/compress v1.15.9/go.mod h1:PhcZ0MbTNciWF3rruxRgKxI5NkcHHrHUDtV4Yw2GlzU= github.com/klauspost/compress v1.18.2/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4= github.com/klauspost/compress v1.18.5/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= +github.com/klauspost/compress v1.19.1/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk= github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= github.com/kr/pty v1.1.1 h1:VkoXIwSboBpnk99O/KFauAEILuNHv5DVFKZMBN/gUgw= @@ -1620,6 +1620,7 @@ go.opentelemetry.io/contrib/detectors/gcp v1.36.0/go.mod h1:IbBN8uAIIx734PTonTPx go.opentelemetry.io/contrib/detectors/gcp v1.38.0/go.mod h1:SU+iU7nu5ud4oCb3LQOhIZ3nRLj6FNVrKgtflbaf2ts= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.60.0/go.mod h1:rg+RlpR5dKwaS95IyyZqj5Wd4E13lk/msnTS0Xl9lJM= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.61.0/go.mod h1:snMWehoOh2wsEwnvvwtDyFCxVeDAODenXHtn5vzrKjo= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0/go.mod h1:NoUCKYWK+3ecatC4HjkRktREheMeEtrXoQxrqYFeHSc= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.60.0/go.mod h1:69uWxva0WgAA/4bu2Yy70SLDBwZXuQ6PbBpbsa5iZrQ= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.61.0/go.mod h1:UHB22Z8QsdRDrnAtX4PntOl36ajSxcdUMt1sF7Y6E7Q= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.67.0/go.mod h1:C2NGBr+kAB4bk3xtMXfZ94gqFDtg/GkI7e9zqGh5Beg= @@ -1672,8 +1673,6 @@ go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw= go.uber.org/automaxprocs v1.6.0 h1:O3y2/QNTOdbF+e/dpXNNW7Rx2hZ4sTIPyybbxyNqTUs= go.uber.org/automaxprocs v1.6.0/go.mod h1:ifeIMSnPZuznNm6jmdzmU3/bfk01Fe2fotchwEFJ8r8= go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= -go.uber.org/zap v1.28.0 h1:IZzaP1Fv73/T/pBMLk4VutPl36uNC+OSUh3JLG3FIjo= -go.uber.org/zap v1.28.0/go.mod h1:rDLpOi171uODNm/mxFcuYWxDsqWSAVkFdX4XojSKg/Q= golang.org/x/arch v0.4.0 h1:A8WCeEWhLwPBKNbFi5Wv5UTCBx5zzubnXDlMOFAzFMc= golang.org/x/arch v0.4.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= @@ -2001,6 +2000,7 @@ google.golang.org/api v0.272.0/go.mod h1:wKjowi5LNJc5qarNvDCvNQBn3rVK8nSy6jg2SwR google.golang.org/api v0.273.1/go.mod h1:JbAt7mF+XVmWu6xNP8/+CTiGH30ofmCmk9nM8d8fHew= google.golang.org/api v0.274.0/go.mod h1:JbAt7mF+XVmWu6xNP8/+CTiGH30ofmCmk9nM8d8fHew= google.golang.org/api v0.287.1/go.mod h1:lM2kYRzYUCBY91P9h6VF1PYmvhxii3O5hji37qRvIcY= +google.golang.org/api v0.290.0/go.mod h1:weJZ3lldHFYI0DBFNKpJelUDNnusTt5YaOEgxvt8ci8= google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= @@ -2047,6 +2047,7 @@ google.golang.org/genproto v0.0.0-20250603155806-513f23925822/go.mod h1:HubltRL7 google.golang.org/genproto v0.0.0-20250922171735-9219d122eba9/go.mod h1:QFOrLhdAe2PsTp3vQY4quuLKTi9j3XG3r6JPPaw7MSc= google.golang.org/genproto v0.0.0-20251202230838-ff82c1b0f217/go.mod h1:yJ2HH4EHEDTd3JiLmhds6NkJ17ITVYOdV3m3VKOnws0= google.golang.org/genproto v0.0.0-20260217215200-42d3e9bedb6d/go.mod h1:0oz9d7g9QLSdv9/lgbIjowW1JoxMbxmBVNe8i6tORJI= +google.golang.org/genproto v0.0.0-20260319201613-d00831a3d3e7/go.mod h1:L43LFes82YgSonw6iTXTxXUX1OlULt4AQtkik4ULL/I= google.golang.org/genproto/googleapis/api v0.0.0-20230822172742-b8732ec3820d/go.mod h1:KjSP20unUpOx5kyQUFa7k4OJg0qeJ7DEZflGDu2p6Bk= google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142/go.mod h1:d6be+8HhtEtucleCbxpPW9PA9XwISACu8nvpPqF0BVo= google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:qpvKtACPCQhAdu3PyQgV4l3LMXZEtft7y8QcarRsp9I= @@ -2080,6 +2081,7 @@ google.golang.org/genproto/googleapis/api v0.0.0-20260401001100-f93e5f3e9f0f/go. google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9/go.mod h1:7QBABkRtR8z+TEnmXTqIqwJLlzrZKVfAUm7tY3yGv0M= google.golang.org/genproto/googleapis/api v0.0.0-20260414002931-afd174a4e478/go.mod h1:C6ADNqOxbgdUUeRTU+LCHDPB9ttAMCTff6auwCVa4uc= google.golang.org/genproto/googleapis/api v0.0.0-20260511170946-3700d4141b60/go.mod h1:7yoXV7RIh5gblj/xVYoogxAWvA9wUeVbpsK/M694l00= +google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa/go.mod h1:q4lMZS6kskjT5HvCPrnnypcDPVJqT/f4nfxmkE7gryY= google.golang.org/genproto/googleapis/bytestream v0.0.0-20250929231259-57b25ae835d4/go.mod h1:YUQUKndxDbAanQC0ln4pZ3Sis3N5sqgDte2XQqufkJc= google.golang.org/genproto/googleapis/bytestream v0.0.0-20251103181224-f26f9409b101 h1:yPJt1QyhbMgVYk1uHU1fzFDusVK69zmYfO7uupO0/QE= google.golang.org/genproto/googleapis/bytestream v0.0.0-20251103181224-f26f9409b101/go.mod h1:ejCb7yLmK6GCVHp5qpeKbm4KZew/ldg+9b8kq5MONgk= @@ -2155,6 +2157,7 @@ google.golang.org/genproto/googleapis/rpc v0.0.0-20260523011958-0a33c5d7ca68/go. google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/genproto/googleapis/rpc v0.0.0-20260610212136-7ab31c22f7ad/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/genproto/googleapis/rpc v0.0.0-20260720155508-bb71a54f79dc/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260723164925-7274b71286bd/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= diff --git a/pkg/gofr/datasource/arangodb/go.mod b/pkg/gofr/datasource/arangodb/go.mod index 809c93559c..519e5bbf18 100644 --- a/pkg/gofr/datasource/arangodb/go.mod +++ b/pkg/gofr/datasource/arangodb/go.mod @@ -4,30 +4,28 @@ go 1.26.0 require ( github.com/arangodb/go-driver/v2 v2.3.1 - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 ) require ( github.com/arangodb/go-velocypack v0.0.0-20200318135517-5af53c29c67e // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/dchest/siphash v1.2.3 // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/google/uuid v1.6.0 // indirect github.com/kkdai/maglev v0.2.0 // indirect github.com/mattn/go-colorable v0.1.13 // indirect - github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-isatty v0.0.24 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/rs/zerolog v1.34.0 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - golang.org/x/net v0.56.0 // indirect - golang.org/x/sys v0.46.0 // indirect - golang.org/x/text v0.38.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/net v0.57.0 // indirect + golang.org/x/sys v0.47.0 // indirect + golang.org/x/text v0.41.0 // indirect ) diff --git a/pkg/gofr/datasource/arangodb/go.sum b/pkg/gofr/datasource/arangodb/go.sum index 01b5f86022..18513833df 100644 --- a/pkg/gofr/datasource/arangodb/go.sum +++ b/pkg/gofr/datasource/arangodb/go.sum @@ -6,14 +6,12 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UF github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dchest/siphash v1.2.2/go.mod h1:q+IRvb2gOSrUnYoPqHiyHXS0FOBBOdl6tONBlVnOnt4= github.com/dchest/siphash v1.2.3 h1:QXwFc8cFOR2dSa/gE6o/HokBMWtLUaNDVd+22aKHeEA= github.com/dchest/siphash v1.2.3/go.mod h1:0NvQU092bT0ipiFN++/rXm69QG9tVxLAlQHIXMPAkHc= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= @@ -23,52 +21,42 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/kkdai/maglev v0.2.0 h1:w6DCW0kAA6fstZqXkrBrlgIC3jeIRXkjOYea/m6EK/Y= github.com/kkdai/maglev v0.2.0/go.mod h1:d+mt8Lmt3uqi9aRb/BnPjzD0fy+ETs1vVXiGRnqHVZ4= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= -github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= -github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI= +github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY= github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= -golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o= -golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= +golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw= -golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE= -golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/datasource/cassandra/go.mod b/pkg/gofr/datasource/cassandra/go.mod index f9e561265e..15257f8d1a 100644 --- a/pkg/gofr/datasource/cassandra/go.mod +++ b/pkg/gofr/datasource/cassandra/go.mod @@ -4,22 +4,20 @@ go 1.26.0 require ( github.com/gocql/gocql v1.7.0 - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 ) require ( github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/golang/snappy v1.0.0 // indirect github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect gopkg.in/inf.v0 v0.9.1 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/pkg/gofr/datasource/cassandra/go.sum b/pkg/gofr/datasource/cassandra/go.sum index 737378c3bf..fbaf766d1b 100644 --- a/pkg/gofr/datasource/cassandra/go.sum +++ b/pkg/gofr/datasource/cassandra/go.sum @@ -5,11 +5,9 @@ github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dR github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/gocql/gocql v1.7.0 h1:O+7U7/1gSN7QTEAaMEsJc1Oq2QHXvCWoF3DFK9HDHus= @@ -29,28 +27,23 @@ github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/datasource/clickhouse/go.mod b/pkg/gofr/datasource/clickhouse/go.mod index d51b18e209..a07ba1d3dc 100644 --- a/pkg/gofr/datasource/clickhouse/go.mod +++ b/pkg/gofr/datasource/clickhouse/go.mod @@ -4,9 +4,9 @@ go 1.26.0 require ( github.com/ClickHouse/clickhouse-go/v2 v2.48.0 - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 ) @@ -14,19 +14,14 @@ require ( github.com/ClickHouse/ch-go v0.74.0 // indirect github.com/andybalholm/brotli v1.2.2 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/go-faster/city v1.0.1 // indirect github.com/go-faster/errors v0.7.1 // indirect github.com/google/uuid v1.6.0 // indirect - github.com/klauspost/compress v1.19.1 // indirect - github.com/kr/pretty v0.3.1 // indirect + github.com/klauspost/compress v1.19.2 // indirect github.com/paulmach/orb v0.13.0 // indirect github.com/pierrec/lz4/v4 v4.1.27 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/rogpeppe/go-internal v1.14.1 // indirect github.com/segmentio/asm v1.2.1 // indirect github.com/shopspring/decimal v1.4.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/sys v0.47.0 // indirect - gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/pkg/gofr/datasource/clickhouse/go.sum b/pkg/gofr/datasource/clickhouse/go.sum index 344751d6a5..2d1e00cee5 100644 --- a/pkg/gofr/datasource/clickhouse/go.sum +++ b/pkg/gofr/datasource/clickhouse/go.sum @@ -6,9 +6,6 @@ github.com/andybalholm/brotli v1.2.2 h1:HzTuoo2ErYQqf5qvcJInB8uvqSVxRttzkFexPWtn github.com/andybalholm/brotli v1.2.2/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-faster/city v1.0.1 h1:4WAxSZ3V2Ws4QRDrscLEDcibJY8uf41H6AhXDrNDcGw= github.com/go-faster/city v1.0.1/go.mod h1:jKcUJId49qdW3L1qKHH/3wPeUstCVpVSXTM6vO3VcTw= github.com/go-faster/errors v0.7.1 h1:MkJTnDoEdi9pDabt1dpWf7AA8/BaSYZqibYyhZ20AYg= @@ -17,43 +14,27 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/klauspost/compress v1.19.1 h1:VsB4HPswih7mmZ8WleSFQ75c/Ui1M4trX5oAsJnhSlk= -github.com/klauspost/compress v1.19.1/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= -github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8= +github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= github.com/paulmach/orb v0.13.0 h1:r7n7mQGGF+cj/CbcivEj9J3HGK+XR+yXnvzRdq9saIw= github.com/paulmach/orb v0.13.0/go.mod h1:6scRWINywA2Jf05dcjOfLfxrUIMECvTSG2MVbRLxu/k= github.com/pierrec/lz4/v4 v4.1.27 h1:+PhzhWDrjRj89TH2sw43nE3+4+W8lSxIuQadEHZyjUk= github.com/pierrec/lz4/v4 v4.1.27/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4= -github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/segmentio/asm v1.2.1 h1:DTNbBqs57ioxAD4PrArqftgypG4/qNpXoJx8TVXxPR0= github.com/segmentio/asm v1.2.1/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs= github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU= github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/datasource/cloudsql/go.mod b/pkg/gofr/datasource/cloudsql/go.mod index 25b7976b8f..0a15290894 100644 --- a/pkg/gofr/datasource/cloudsql/go.mod +++ b/pkg/gofr/datasource/cloudsql/go.mod @@ -6,7 +6,7 @@ require ( cloud.google.com/go/cloudsqlconn v1.25.1 github.com/go-sql-driver/mysql v1.10.0 github.com/jackc/pgx/v5 v5.10.0 - github.com/stretchr/testify v1.11.1 + github.com/stretchr/testify v1.12.1 ) require ( @@ -16,38 +16,36 @@ require ( cloud.google.com/go/sql v0.1.0 // indirect filippo.io/edwards25519 v1.2.0 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/felixge/httpsnoop v1.1.0 // indirect github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect github.com/google/s2a-go v0.1.9 // indirect github.com/google/uuid v1.6.0 // indirect - github.com/googleapis/enterprise-certificate-proxy v0.3.18 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.19 // indirect github.com/googleapis/gax-go/v2 v2.23.0 // indirect github.com/jackc/pgpassfile v1.0.0 // indirect github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect github.com/jackc/puddle/v2 v2.2.2 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect go.opencensus.io v0.24.0 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 // indirect - go.opentelemetry.io/otel v1.44.0 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - go.opentelemetry.io/otel/trace v1.44.0 // indirect - golang.org/x/crypto v0.54.0 // indirect + go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 // indirect + go.opentelemetry.io/otel v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/trace v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/crypto v0.55.0 // indirect golang.org/x/net v0.57.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect golang.org/x/sync v0.22.0 // indirect golang.org/x/sys v0.47.0 // indirect - golang.org/x/text v0.40.0 // indirect + golang.org/x/text v0.41.0 // indirect golang.org/x/time v0.15.0 // indirect - google.golang.org/api v0.290.0 // indirect + google.golang.org/api v0.291.0 // indirect google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260723164925-7274b71286bd // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect google.golang.org/grpc v1.83.0 // indirect google.golang.org/protobuf v1.36.11 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/pkg/gofr/datasource/cloudsql/go.sum b/pkg/gofr/datasource/cloudsql/go.sum index f8c17833f8..b864e50d12 100644 --- a/pkg/gofr/datasource/cloudsql/go.sum +++ b/pkg/gofr/datasource/cloudsql/go.sum @@ -21,8 +21,6 @@ github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2 h1:aBangftG7EVZoUb69Os github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2/go.mod h1:qwXFYgsP6T7XnJtbKlf1HP8AjxZZyzxMmc+Lq5GjlU4= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= @@ -74,8 +72,8 @@ github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/enterprise-certificate-proxy v0.3.18 h1:hvVi34VucdrV1IIsiWuqYM8kutw/92MxNEFxCJZEh0k= -github.com/googleapis/enterprise-certificate-proxy v0.3.18/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= +github.com/googleapis/enterprise-certificate-proxy v0.3.19 h1:mMOE7DN2+p76/EdIrmAy9B9bH+yC4563vmnJ34QR8i4= +github.com/googleapis/enterprise-certificate-proxy v0.3.19/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= github.com/googleapis/gax-go/v2 v2.23.0 h1:Tchl7qkvE7Ip3y+ztvNufYFvkfqTe7NfLTYGIdJRLuE= github.com/googleapis/gax-go/v2 v2.23.0/go.mod h1:rBQKOVJCdb8IFEzg+FCwlt1LP/xMDGuqUXhUG+XMXEg= github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= @@ -86,20 +84,12 @@ github.com/jackc/pgx/v5 v5.10.0 h1:VhSvgU2jSli8o3AqIEOTJr7rZwAEUVo4E4XhR94Zfr0= github.com/jackc/pgx/v5 v5.10.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/microsoft/go-mssqldb v1.10.0 h1:pHEt+Qz6YFPWqREq10mqSE524QQo+/QremwTCQht7TY= github.com/microsoft/go-mssqldb v1.10.0/go.mod h1:mnG7lGa9iYJbzJqGCXyuQCegStKMr3kogDLD6+bmggg= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= @@ -110,30 +100,32 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0= go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0 h1:yI1/OhfEPy7J9eoa6Sj051C7n5dvpj0QX8g4sRchg04= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0/go.mod h1:NoUCKYWK+3ecatC4HjkRktREheMeEtrXoQxrqYFeHSc= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 h1:8tvICD4vSTOOsNrsI4Ljf6C+6UKvpTEH5XY3JMoyPoo= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0/go.mod h1:z9+yiacE0IHRqM4qFfkbt/JYlmYXgss8GY/jXoNuPJI= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= -go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 h1:0Qx7VGBacMm9ZENQ7TnNObTYI4ShC+lHI16seduaxZo= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0/go.mod h1:Sje3i3MjSPKTSPvVWCaL8ugBzJwik3u4smCjUeuupqg= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 h1:LMuyCAyfalSjDyjdC65nK6N0zoTT63+E/u95X0JovZI= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0/go.mod h1:085m8qbm4hgc8rZWGDEa4vmyyo2c3nPxUslYUKUIU04= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= +go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= +go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= +go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw= -golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= @@ -162,8 +154,8 @@ golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs= -golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -174,8 +166,8 @@ golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBn golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/api v0.290.0 h1:eMw0Xo+IfbbMlKmW7aHvpyQRv9RCXuWx/vs8AD+0x9A= -google.golang.org/api v0.290.0/go.mod h1:weJZ3lldHFYI0DBFNKpJelUDNnusTt5YaOEgxvt8ci8= +google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= +google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= @@ -185,8 +177,8 @@ google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd h1:0GnSESHqea5EoaQ google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260723164925-7274b71286bd h1:kPm/AOyXSYAcNdY53xxeI0SJa5xuS+Z5op/stkZMTcA= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260723164925-7274b71286bd/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= @@ -206,10 +198,7 @@ google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlba google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= diff --git a/pkg/gofr/datasource/couchbase/go.mod b/pkg/gofr/datasource/couchbase/go.mod index 3e18b123e6..78f8b865ab 100644 --- a/pkg/gofr/datasource/couchbase/go.mod +++ b/pkg/gofr/datasource/couchbase/go.mod @@ -4,9 +4,9 @@ go 1.26.0 require ( github.com/couchbase/gocb/v2 v2.12.4 - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 ) @@ -16,23 +16,23 @@ require ( github.com/couchbase/gocbcoreps v0.1.5-0.20260107140814-1c3a03f888f8 // indirect github.com/couchbase/goprotostellar v1.0.6-0.20260407143512-d7af25156dcc // indirect github.com/couchbaselabs/gocbconnstr/v2 v2.0.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/golang/snappy v1.0.0 // indirect github.com/google/uuid v1.6.0 // indirect github.com/gorilla/websocket v1.5.3 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/sdk v1.45.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect go.uber.org/multierr v1.11.0 // indirect - go.uber.org/zap v1.27.1 // indirect - golang.org/x/net v0.56.0 // indirect - golang.org/x/sys v0.46.0 // indirect - golang.org/x/text v0.38.0 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d // indirect + go.uber.org/zap v1.28.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/net v0.57.0 // indirect + golang.org/x/sys v0.47.0 // indirect + golang.org/x/text v0.41.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect google.golang.org/grpc v1.83.0 // indirect google.golang.org/protobuf v1.36.11 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/pkg/gofr/datasource/couchbase/go.sum b/pkg/gofr/datasource/couchbase/go.sum index 3d370dca9b..2e5cc34dc1 100644 --- a/pkg/gofr/datasource/couchbase/go.sum +++ b/pkg/gofr/datasource/couchbase/go.sum @@ -12,11 +12,9 @@ github.com/couchbaselabs/gocaves/client v0.0.0-20250107114554-f96479220ae8 h1:MQ github.com/couchbaselabs/gocaves/client v0.0.0-20250107114554-f96479220ae8/go.mod h1:AVekAZwIY2stsJOMWLAS/0uA/+qdp7pjO8EHnl61QkY= github.com/couchbaselabs/gocbconnstr/v2 v2.0.0 h1:HU9DlAYYWR69jQnLN6cpg0fh0hxW/8d5hnglCXXjW78= github.com/couchbaselabs/gocbconnstr/v2 v2.0.0/go.mod h1:o7T431UOfFVHDNvMBUmUxpHnhivwv7BziUao/nMl81E= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= @@ -29,56 +27,45 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 h1:0Qx7VGBacMm9ZENQ7TnNObTYI4ShC+lHI16seduaxZo= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0/go.mod h1:Sje3i3MjSPKTSPvVWCaL8ugBzJwik3u4smCjUeuupqg= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= -go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= +go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= +go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= +go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= -go.uber.org/zap v1.27.1 h1:08RqriUEv8+ArZRYSTXy1LeBScaMpVSTBhCeaZYfMYc= -go.uber.org/zap v1.27.1/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= -golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o= -golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= -golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw= -golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE= -golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4= +go.uber.org/zap v1.28.0 h1:IZzaP1Fv73/T/pBMLk4VutPl36uNC+OSUh3JLG3FIjo= +go.uber.org/zap v1.28.0/go.mod h1:rDLpOi171uODNm/mxFcuYWxDsqWSAVkFdX4XojSKg/Q= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= +golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d h1:mpAgMyM9vQHxycBlDq50y1VHpfSfVwzXvrQKtYbXuUY= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/datasource/dbresolver/go.mod b/pkg/gofr/datasource/dbresolver/go.mod index dc2a43310a..bfbde827bc 100644 --- a/pkg/gofr/datasource/dbresolver/go.mod +++ b/pkg/gofr/datasource/dbresolver/go.mod @@ -3,62 +3,60 @@ module gofr.dev/pkg/gofr/datasource/dbresolver go 1.26.0 require ( - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 ) require ( cloud.google.com/go v0.123.0 // indirect - cloud.google.com/go/auth v0.20.0 // indirect + cloud.google.com/go/auth v0.22.0 // indirect cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect cloud.google.com/go/compute/metadata v0.9.0 // indirect - cloud.google.com/go/iam v1.11.0 // indirect - cloud.google.com/go/pubsub v1.50.2 // indirect - cloud.google.com/go/pubsub/v2 v2.5.1 // indirect + cloud.google.com/go/iam v1.12.0 // indirect + cloud.google.com/go/pubsub v1.51.0 // indirect + cloud.google.com/go/pubsub/v2 v2.6.0 // indirect filippo.io/edwards25519 v1.2.0 // indirect github.com/DATA-DOG/go-sqlmock v1.5.2 // indirect - github.com/XSAM/otelsql v0.42.0 // indirect + github.com/XSAM/otelsql v0.43.0 // indirect github.com/agnivade/levenshtein v1.2.1 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/cenkalti/backoff/v5 v5.0.3 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/eclipse/paho.mqtt.golang v1.5.1 // indirect github.com/felixge/httpsnoop v1.1.0 // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-sql-driver/mysql v1.10.0 // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/golang-jwt/jwt/v5 v5.3.1 // indirect github.com/google/s2a-go v0.1.9 // indirect github.com/google/uuid v1.6.0 // indirect - github.com/googleapis/enterprise-certificate-proxy v0.3.17 // indirect - github.com/googleapis/gax-go/v2 v2.22.0 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.19 // indirect + github.com/googleapis/gax-go/v2 v2.23.0 // indirect github.com/gorilla/mux v1.8.1 // indirect github.com/gorilla/websocket v1.5.3 // indirect github.com/graphql-go/graphql v0.8.1 // indirect github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.3.3 // indirect github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 // indirect github.com/joho/godotenv v1.5.1 // indirect - github.com/klauspost/compress v1.18.6 // indirect + github.com/klauspost/compress v1.19.2 // indirect github.com/lib/pq v1.12.3 // indirect - github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-isatty v0.0.24 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/ncruces/go-strftime v1.0.0 // indirect github.com/openzipkin/zipkin-go v0.4.3 // indirect - github.com/pierrec/lz4/v4 v4.1.25 // indirect + github.com/pierrec/lz4/v4 v4.1.27 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/prometheus/client_golang v1.23.2 // indirect + github.com/prometheus/client_golang v1.24.1 // indirect github.com/prometheus/client_model v0.6.2 // indirect - github.com/prometheus/common v0.67.5 // indirect + github.com/prometheus/common v0.70.1 // indirect github.com/prometheus/otlptranslator v1.0.0 // indirect - github.com/prometheus/procfs v0.20.1 // indirect + github.com/prometheus/procfs v0.21.1 // indirect github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0 // indirect github.com/redis/go-redis/extra/redisotel/v9 v9.21.0 // indirect github.com/redis/go-redis/v9 v9.21.0 // indirect @@ -71,35 +69,35 @@ require ( go.opencensus.io v0.24.0 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 // indirect - go.opentelemetry.io/otel/exporters/prometheus v0.65.0 // indirect + go.opentelemetry.io/otel/exporters/prometheus v0.67.0 // indirect go.opentelemetry.io/otel/exporters/zipkin v1.44.0 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - go.opentelemetry.io/otel/sdk v1.44.0 // indirect - go.opentelemetry.io/otel/sdk/metric v1.44.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/sdk v1.45.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect go.opentelemetry.io/proto/otlp v1.10.0 // indirect go.uber.org/atomic v1.11.0 // indirect - go.yaml.in/yaml/v2 v2.4.4 // indirect - golang.org/x/crypto v0.53.0 // indirect - golang.org/x/net v0.56.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/crypto v0.55.0 // indirect + golang.org/x/net v0.57.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect - golang.org/x/sync v0.21.0 // indirect - golang.org/x/sys v0.46.0 // indirect - golang.org/x/term v0.44.0 // indirect - golang.org/x/text v0.38.0 // indirect + golang.org/x/sync v0.22.0 // indirect + golang.org/x/sys v0.47.0 // indirect + golang.org/x/term v0.45.0 // indirect + golang.org/x/text v0.41.0 // indirect golang.org/x/time v0.15.0 // indirect - google.golang.org/api v0.287.0 // indirect - google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20260615183401-62b3387ff324 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d // indirect + google.golang.org/api v0.291.0 // indirect + google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect google.golang.org/grpc v1.83.0 // indirect google.golang.org/protobuf v1.36.11 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect - modernc.org/libc v1.73.4 // indirect + modernc.org/libc v1.74.4 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.11.0 // indirect - modernc.org/sqlite v1.53.0 // indirect + modernc.org/sqlite v1.56.0 // indirect ) diff --git a/pkg/gofr/datasource/dbresolver/go.sum b/pkg/gofr/datasource/dbresolver/go.sum index f5f394bef0..4eb0840ca6 100644 --- a/pkg/gofr/datasource/dbresolver/go.sum +++ b/pkg/gofr/datasource/dbresolver/go.sum @@ -1,29 +1,29 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE= cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU= -cloud.google.com/go/auth v0.20.0 h1:kXTssoVb4azsVDoUiF8KvxAqrsQcQtB53DcSgta74CA= -cloud.google.com/go/auth v0.20.0/go.mod h1:942/yi/itH1SsmpyrbnTMDgGfdy2BUqIKyd0cyYLc5Q= +cloud.google.com/go/auth v0.22.0 h1:Xp9wAKkLoeaYb5pYZZoQGz4E9sdPxIbzS3gywZE3ciQ= +cloud.google.com/go/auth v0.22.0/go.mod h1:M9o2Oz+YI2jAfxewJgb1vyI3vceHF+eohmxyzmrl+9s= cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc= cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10= -cloud.google.com/go/iam v1.11.0 h1:KieQ9Pb+LLPak1O3Rv3GgCxhnmkYf7Xyh0P5HfF1jFM= -cloud.google.com/go/iam v1.11.0/go.mod h1:KP+nKGugNJW4LcLx1uEZcq1ok5sQHFaQehQNl4QDgV4= -cloud.google.com/go/kms v1.31.0 h1:LS8N92OxFDgOLg5NCo3OmbvjtQAIVT5gUHVLKIDHaFE= -cloud.google.com/go/kms v1.31.0/go.mod h1:YIyXZym11R5uovJJt4oN5eUL3oPmirF3yKeIh6QAf4U= -cloud.google.com/go/longrunning v1.0.0 h1:lwzWEYD8+NkYV7dhexOz6kmlvajZA70+bW/xMhRVVdY= -cloud.google.com/go/longrunning v1.0.0/go.mod h1:8nqFBPOO1U/XkhWl0I19AMZEphrHi73VNABIpKYaTwM= -cloud.google.com/go/pubsub v1.50.2 h1:54Up97HnThdP4H8jjWJSSQ/mnYG2EKon7ZSNETRq0tM= -cloud.google.com/go/pubsub v1.50.2/go.mod h1:jyCWeZdGFqd4mitSsBERnJcpqaHBsxQoPkNvjj4sp0w= -cloud.google.com/go/pubsub/v2 v2.5.1 h1:+TwXJr78P9RrMV3S8lKHIhJo2E99jI7ta65e+ujJjts= -cloud.google.com/go/pubsub/v2 v2.5.1/go.mod h1:Pd+qeabMX+576vQJhTN7TelE4k6kJh15dLU/ptOQ/UA= +cloud.google.com/go/iam v1.12.0 h1:Aki3bX9aHUDKPHfnRJfDcTdVedvy6quGBQcTqx3DRXk= +cloud.google.com/go/iam v1.12.0/go.mod h1:FEZ4lXpADAC2AIpQY7LANNjjwyQ2jK439CI2VaD+sLY= +cloud.google.com/go/kms v1.32.0 h1:s+rEluaaZKhLVjrIWG7uNBsnWbiitElzNzFGyp6+nIg= +cloud.google.com/go/kms v1.32.0/go.mod h1:CSGvW6GnMQbY+1nOHcIzhMtHSbExXlOmCKjWtYVjcpA= +cloud.google.com/go/longrunning v1.2.0 h1:WjYH3YHBGCxGJP9M4dWGHBfXr/cFIjMkNgWcJj7/iMM= +cloud.google.com/go/longrunning v1.2.0/go.mod h1:5KMQALFGOCtFoi2xSOA1u3H7WKlhmckgiyFw7+LGQp0= +cloud.google.com/go/pubsub v1.51.0 h1:XOaCejsqX7EEtUdQz+WPag66wWsUUGliyCOfGPKfo90= +cloud.google.com/go/pubsub v1.51.0/go.mod h1:NERXf11sd82UV3VnflcUj8POIyQUXT/QwrKlxD8di/I= +cloud.google.com/go/pubsub/v2 v2.6.0 h1:8pjR0id+GTB+krKx5G6AGJoYrHog58w2Q89PCOrfM64= +cloud.google.com/go/pubsub/v2 v2.6.0/go.mod h1:4anqvV/w8Pcgu2tO0qr2XgsF3GXHowzryfQ5gOnVmWY= filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo= filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU= github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= -github.com/XSAM/otelsql v0.42.0 h1:Li0xF4eJUxG2e0x3D4rvRlys1f27yJKvjTh7ljkUP5o= -github.com/XSAM/otelsql v0.42.0/go.mod h1:4mOrEv+cS1KmKzrvTktvJnstr5GtKSAK+QHvFR9OcpI= +github.com/XSAM/otelsql v0.43.0 h1:ZIhXqRoMhILXQwBQoq/Dl6Taap/KEFQXZrWjYV1L8X8= +github.com/XSAM/otelsql v0.43.0/go.mod h1:DJBGBvbtwf1OCBYRTjpRFxOqi6ONpdfb+htr4ncRWuw= github.com/agnivade/levenshtein v1.2.1 h1:EHBY3UOn1gwdy/VbFwgo4cxecRznFk7fKWN1KOX7eoM= github.com/agnivade/levenshtein v1.2.1/go.mod h1:QVVI16kDrtSuwcpd0p1+xMC6Z/VfhtCyDIjcwga4/DU= github.com/alicebob/miniredis/v2 v2.38.0 h1:nZAzCR+Lj+Vxk4ZXzm2NuKq2O33RXj1XxJ2e2uP9jiw= @@ -47,8 +47,6 @@ github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2 h1:aBangftG7EVZoUb69Os github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2/go.mod h1:qwXFYgsP6T7XnJtbKlf1HP8AjxZZyzxMmc+Lq5GjlU4= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d h1:abDbP7XBVgwda+h0J5Qra5p2OQpidU2FdkXvzCKL+H8= github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d/go.mod h1:wKFzULXAPj3U2BDAPWXhSbQQNC6FU1+1/5iika6IY7g= github.com/dgryski/trifles v0.0.0-20230903005119-f50d829f2e54 h1:SG7nF6SRlWhcT7cNTs5R6Hk4V2lcmLz2NsG2VnInyNo= @@ -69,8 +67,8 @@ github.com/envoyproxy/protoc-gen-validate v1.3.3/go.mod h1:TsndJ/ngyIdQRhMcVVGDD github.com/felixge/httpsnoop v1.1.0 h1:3YtUj32ZZkqZtt3sZZsClsymw/QDuVfpNhoA31zeORc= github.com/felixge/httpsnoop v1.1.0/go.mod h1:Zqxgdd+1Rkcz8euOqdr7lqgCRJztwr5hp9vDSi5UZCE= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-redis/redismock/v9 v9.2.0 h1:ZrMYQeKPECZPjOj5u9eyOjg8Nnb0BS9lkVIZ6IpsKLw= @@ -105,17 +103,17 @@ github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs= -github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA= +github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3 h1:LMLX+LgTNWpfvCBdFebv6EsYotImrt/Ppc5cXIriCSo= +github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3/go.mod h1:jl5iWTm0/hd5PjEYEOuwAJ57L/CibdZfrqZ5XA5GrCk= github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0= github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/enterprise-certificate-proxy v0.3.17 h1:73NfMHdiqo9JFU9+7a5ExpVa10/R29pXfZIaW559nrg= -github.com/googleapis/enterprise-certificate-proxy v0.3.17/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= -github.com/googleapis/gax-go/v2 v2.22.0 h1:PjIWBpgGIVKGoCXuiCoP64altEJCj3/Ei+kSU5vlZD4= -github.com/googleapis/gax-go/v2 v2.22.0/go.mod h1:irWBbALSr0Sk3qlqb9SyJ1h68WjgeFuiOzI4Rqw5+aY= +github.com/googleapis/enterprise-certificate-proxy v0.3.19 h1:mMOE7DN2+p76/EdIrmAy9B9bH+yC4563vmnJ34QR8i4= +github.com/googleapis/enterprise-certificate-proxy v0.3.19/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= +github.com/googleapis/gax-go/v2 v2.23.0 h1:Tchl7qkvE7Ip3y+ztvNufYFvkfqTe7NfLTYGIdJRLuE= +github.com/googleapis/gax-go/v2 v2.23.0/go.mod h1:rBQKOVJCdb8IFEzg+FCwlt1LP/xMDGuqUXhUG+XMXEg= github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= @@ -133,8 +131,8 @@ github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwA github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46/go.mod h1:yyMNCyc/Ib3bDTKd379tNMpB/7/H5TjM2Y9QJ5THLbE= -github.com/klauspost/compress v1.18.6 h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao= -github.com/klauspost/compress v1.18.6/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= +github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8= +github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE= github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= @@ -145,34 +143,32 @@ github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/lib/pq v1.12.3 h1:tTWxr2YLKwIvK90ZXEw8GP7UFHtcbTtty8zsI+YjrfQ= github.com/lib/pq v1.12.3/go.mod h1:/p+8NSbOcwzAEI7wiMXFlgydTwcgTr3OSKMsD2BitpA= -github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= -github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI= +github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w= github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= github.com/openzipkin/zipkin-go v0.4.3 h1:9EGwpqkgnwdEIJ+Od7QVSEIH+ocmm5nPat0G7sjsSdg= github.com/openzipkin/zipkin-go v0.4.3/go.mod h1:M9wCJZFWCo2RiY+o1eBCEMe0Dp2S5LDHcMZmk3RmK7c= -github.com/pierrec/lz4/v4 v4.1.25 h1:kocOqRffaIbU5djlIBr7Wh+cx82C0vtFb0fOurZHqD0= -github.com/pierrec/lz4/v4 v4.1.25/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4= +github.com/pierrec/lz4/v4 v4.1.27 h1:+PhzhWDrjRj89TH2sw43nE3+4+W8lSxIuQadEHZyjUk= +github.com/pierrec/lz4/v4 v4.1.27/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= -github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= +github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU= +github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= -github.com/prometheus/common v0.67.5 h1:pIgK94WWlQt1WLwAC5j2ynLaBRDiinoAb86HZHTUGI4= -github.com/prometheus/common v0.67.5/go.mod h1:SjE/0MzDEEAyrdr5Gqc6G+sXI67maCxzaT3A2+HqjUw= +github.com/prometheus/common v0.70.1 h1:1HvjP4D5oL3t8RsPlwxA9onvvStjtIHYE5XuuwOi/PY= +github.com/prometheus/common v0.70.1/go.mod h1:VdFUQDMZK3VLkurFUVhia6uys/0suUp86TJz5qbJRhc= github.com/prometheus/otlptranslator v1.0.0 h1:s0LJW/iN9dkIH+EnhiD3BlkkP5QVIUVEoIwkU+A6qos= github.com/prometheus/otlptranslator v1.0.0/go.mod h1:vRYWnXvI6aWGpsdY/mOT/cbeVRBlPWtBNDb7kGR3uKM= -github.com/prometheus/procfs v0.20.1 h1:XwbrGOIplXW/AU3YhIhLODXMJYyC1isLFfYCsTEycfc= -github.com/prometheus/procfs v0.20.1/go.mod h1:o9EMBZGRyvDrSPH1RqdxhojkuXstoe4UlK79eF5TGGo= +github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI= +github.com/prometheus/procfs v0.21.1/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY= github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0 h1:jsV3tyMeJrEoc2f3EhNf7qoBW3NEZW7l/4ziT3M+OJI= github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0/go.mod h1:e5t17bY9cEpVV+xw2U7jsPOKkXBtL5IQmNVABShnHUk= github.com/redis/go-redis/extra/redisotel/v9 v9.21.0 h1:36qq3rbF2If2CP0zGHHF8o/4XDluErn6DD0c9/L2iNI= @@ -188,13 +184,13 @@ github.com/segmentio/kafka-go v0.4.51/go.mod h1:Y1gn60kzLEEaW28YshXyk2+VCUKbJ3Qr github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/vektah/gqlparser/v2 v2.5.36 h1:CN9mKVHgMkc+XftdOWIhb4HEL8wKSYkFAqhf8booa7s= github.com/vektah/gqlparser/v2 v2.5.36/go.mod h1:cAJ9qwVgPaUkWv6Gn8vn0mqOE0Ui5Pn56wNy5396XWo= github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c= @@ -218,30 +214,30 @@ go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 h1:0Qx7VGBacMm9ZENQ7TnNObTYI4ShC+lHI16seduaxZo= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0/go.mod h1:Sje3i3MjSPKTSPvVWCaL8ugBzJwik3u4smCjUeuupqg= -go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0 h1:MCcYL7J6Vt/X0kjqbMZkekCmwsurbQRbL69vkiye2lk= -go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0/go.mod h1:3jnStNwSufK+f5ktjL4EPcwtig4rtd81NS70lqHuXl8= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 h1:8tvICD4vSTOOsNrsI4Ljf6C+6UKvpTEH5XY3JMoyPoo= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0/go.mod h1:z9+yiacE0IHRqM4qFfkbt/JYlmYXgss8GY/jXoNuPJI= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= +go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 h1:aVgLpGksz0vjoe6OynycqX8daNOAxJx5ZEhJXIXOVIU= +go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0/go.mod h1:kmJlX6WuTrAH1fOCSbPJFrSnUagB8c3SY3E87It3JD8= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 h1:LMuyCAyfalSjDyjdC65nK6N0zoTT63+E/u95X0JovZI= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0/go.mod h1:085m8qbm4hgc8rZWGDEa4vmyyo2c3nPxUslYUKUIU04= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0 h1:4YsVu3B8+3qtWYYrsUYgn0OG78pN0rnNPRGX4SbokQI= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0/go.mod h1:+wnlSn0mD1ADVMe3v9Z/WIaiz6q6gL2J/ejaAmdmv80= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 h1:qazEJlUOQzhCpzQpFETGby7EdqjI1wsd0W+6Gg1SCTU= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0/go.mod h1:fOD2Yefuxixkx3ahVNf0O/PERb6r4OlbxfATVnYvzCo= -go.opentelemetry.io/otel/exporters/prometheus v0.65.0 h1:jOveH/b4lU9HT7y+Gfamf18BqlOuz2PWEvs8yM7Q6XE= -go.opentelemetry.io/otel/exporters/prometheus v0.65.0/go.mod h1:i1P8pcumauPtUI4YNopea1dhzEMuEqWP1xoUZDylLHo= +go.opentelemetry.io/otel/exporters/prometheus v0.67.0 h1:7IefDa35e6V3NoiqIeLDMDxMFyZDk5qcoC0Ax4cC16E= +go.opentelemetry.io/otel/exporters/prometheus v0.67.0/go.mod h1:nsPI1awTg5Vmg1YrommL2mVarVGlqc4yXOoKAkPRD0c= go.opentelemetry.io/otel/exporters/zipkin v1.44.0 h1:zv7PRYGLrQHkdeZj0c5SNAZOJcw55XgaTezUkNpwA+w= go.opentelemetry.io/otel/exporters/zipkin v1.44.0/go.mod h1:3+VZyCi6hFW+UuxFF+wSOvwsOwncfBpQfP7Qdb3JXKg= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/metric/x v0.66.0 h1:YkCrx1zLOChi9ZcZ6euupOcsgzbVlec7D/xoEU1+cTA= -go.opentelemetry.io/otel/metric/x v0.66.0/go.mod h1:d1+BDj9t96do0/1LoU1ayfCv79ZgNE41qbhBvnMOBZk= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= -go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/metric/x v0.67.0 h1:PcicCNZFkZ4bXfSooXdo3WN7RBOVOtjVdo1wD358Uns= +go.opentelemetry.io/otel/metric/x v0.67.0/go.mod h1:FBjCWZe6wgcqxcMtjdGiClDKXb2YxxXii0CXftE4QtI= +go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= +go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= +go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= +go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.opentelemetry.io/proto/otlp v1.10.0 h1:IQRWgT5srOCYfiWnpqUYz9CVmbO8bFmKcwYxpuCSL2g= go.opentelemetry.io/proto/otlp v1.10.0/go.mod h1:/CV4QoCR/S9yaPj8utp3lvQPoqMtxXdzn7ozvvozVqk= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= @@ -252,16 +248,16 @@ go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= -go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= -go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto= -golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= @@ -269,8 +265,8 @@ golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHl golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4= -golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ= +golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk= +golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -282,8 +278,8 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o= -golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= +golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= +golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= @@ -293,8 +289,8 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM= -golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= +golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek= +golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -303,19 +299,18 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw= -golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.44.0 h1:0rLvDRCtNj0gZkyIXhCyOb2OAzEhLVqc4B+hrsBhrmc= -golang.org/x/term v0.44.0/go.mod h1:7ze4MdzUzLXpSAoFP1H0bOI9aXDqveSvatT5vKcFh2Y= +golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= +golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= -golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE= -golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -327,27 +322,27 @@ golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8= -golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0= +golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE= +golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/api v0.287.0 h1:CQDMqUiqZZ0U/Yge3zyjAhNQ0OSYEH0PaA7l4xtEen4= -google.golang.org/api v0.287.0/go.mod h1:pPW85yt3Iuc3unkpaMhFtMmOqnTdCwCqEOaUlnuxRlQ= +google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= +google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= -google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94 h1:YJjbgu+dkp5kUJLfpMyCLfBIWZb/FcJyuLeo1gVBOuo= -google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94/go.mod h1:RRHjglSYABVCWpQ7USCpdfhcd9t4PkajvVwyynZizTc= -google.golang.org/genproto/googleapis/api v0.0.0-20260615183401-62b3387ff324 h1:g0RAkxK/smSu/iRwC/KIX1mwUoVJtk2OjbgaeS4DmUM= -google.golang.org/genproto/googleapis/api v0.0.0-20260615183401-62b3387ff324/go.mod h1:Z4WJ5pJOYWFWcHEQUelD5QaZDknIQkpIL/+fyJOT9+A= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d h1:mpAgMyM9vQHxycBlDq50y1VHpfSfVwzXvrQKtYbXuUY= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd h1:0GnSESHqea5EoaQgJyYxC3o5m0L191gCQdDgo2cxO5I= +google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= @@ -374,20 +369,20 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -modernc.org/cc/v4 v4.28.4 h1:Hd/4Es+MBj+/7hSdZaisNyu6bv3V0Dp2MdllyfqaH+c= -modernc.org/cc/v4 v4.28.4/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= -modernc.org/ccgo/v4 v4.34.4 h1:OVnSOWQjVKOYkFxoHYB+qQmSHK5gqMqARM+K9DpR/Ws= -modernc.org/ccgo/v4 v4.34.4/go.mod h1:qdKqE8FNIYyysougB1RX9MxCzp5oJOcQXSobANJ4TuE= +modernc.org/cc/v4 v4.29.1 h1:MKgdCV3WykTSPqpVrnxdEDS0HEd2FHpKZDzxzU5LyeI= +modernc.org/cc/v4 v4.29.1/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= +modernc.org/ccgo/v4 v4.34.6 h1:sBgfIwyN0TQ9C5hwIeuqyeAKyMWnbvj2fvpF4L11uzU= +modernc.org/ccgo/v4 v4.34.6/go.mod h1:SZ8YcN9NG7XVsQYdm6jYBvi8PQP1qi+kqB6OhjqI3Fk= modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM= modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU= modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI= modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito= -modernc.org/gc/v3 v3.1.3 h1:6QAplYyVO+KdPW3pGnqmJDUxtkec8ooEWvks/hhU3lc= -modernc.org/gc/v3 v3.1.3/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= +modernc.org/gc/v3 v3.1.4 h1:2g65LGVSmFQrXeITAw97x7hCRvZFcyE1uDP+7Vng7JI= +modernc.org/gc/v3 v3.1.4/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks= modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI= -modernc.org/libc v1.73.4 h1:+ra4Ui8ngyt8HDcO1FTDPWlkAh6yOdaO2yAoh8MddQA= -modernc.org/libc v1.73.4/go.mod h1:DXZ3eO8qMCNn2SnmTNCiC71nJ9Rcq3PsnpU6Vc4rWK8= +modernc.org/libc v1.74.4 h1:fX1Omw4o2/1C2iRkkIsrQTasJQldLhRmuPreXLoWs9k= +modernc.org/libc v1.74.4/go.mod h1:eeQAS9W3sZeKYMFubydxJpII9ybHWshk+7or7bLG9co= modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI= @@ -396,8 +391,8 @@ modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg= modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE= -modernc.org/sqlite v1.53.0 h1:20WG8N9q4ji/dEqGk4uiI0c6OPjSeLTNYGFCc3+7c1M= -modernc.org/sqlite v1.53.0/go.mod h1:xoEpOIpGrgT48H5iiyt/YXPCZPEzlfmfFwtk8Lklw8s= +modernc.org/sqlite v1.56.0 h1:/D8e2RfFqoy/Zc6PuC76U28zFwmI/sYx1Kjm4yEn9e0= +modernc.org/sqlite v1.56.0/go.mod h1:yCJ2cmAaIkHQ25oXWrF8H4O1lIfPYPR26yCEDj2P3pQ= modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= diff --git a/pkg/gofr/datasource/dgraph/go.mod b/pkg/gofr/datasource/dgraph/go.mod index 14aa9c5f03..112a05c178 100644 --- a/pkg/gofr/datasource/dgraph/go.mod +++ b/pkg/gofr/datasource/dgraph/go.mod @@ -4,10 +4,10 @@ go 1.26.0 require ( github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d - github.com/prometheus/client_golang v1.24.0 - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/prometheus/client_golang v1.24.1 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 google.golang.org/grpc v1.83.0 ) @@ -15,22 +15,21 @@ require ( require ( github.com/beorn7/perks v1.0.1 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/prometheus/client_model v0.6.2 // indirect - github.com/prometheus/common v0.70.0 // indirect + github.com/prometheus/common v0.70.1 // indirect github.com/prometheus/procfs v0.21.1 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - golang.org/x/net v0.56.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/net v0.57.0 // indirect golang.org/x/sys v0.47.0 // indirect - golang.org/x/text v0.38.0 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d // indirect + golang.org/x/text v0.41.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect google.golang.org/protobuf v1.36.11 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/pkg/gofr/datasource/dgraph/go.sum b/pkg/gofr/datasource/dgraph/go.sum index cbebeb26eb..91dd13087f 100644 --- a/pkg/gofr/datasource/dgraph/go.sum +++ b/pkg/gofr/datasource/dgraph/go.sum @@ -2,13 +2,11 @@ github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d h1:abDbP7XBVgwda+h0J5Qra5p2OQpidU2FdkXvzCKL+H8= github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d/go.mod h1:wKFzULXAPj3U2BDAPWXhSbQQNC6FU1+1/5iika6IY7g= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= @@ -21,48 +19,42 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v1.24.0 h1:5XStIklKuAtJSNpdD3s8XJj/Yv78IQmE1kbNk87JrAI= -github.com/prometheus/client_golang v1.24.0/go.mod h1:QcsNdotprC2nS4BTM2ucbcqxd2CeXTEa9jW7zHO9iDE= +github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU= +github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE= github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= -github.com/prometheus/common v0.70.0 h1:bcpru3tWPVnxGnETLgOV5jbp/JRXgYEyv65CuBLAMMI= -github.com/prometheus/common v0.70.0/go.mod h1:S/SFasQmgGiYH6C81LKCtYa8QACgthGg5zxL2udV7SY= +github.com/prometheus/common v0.70.1 h1:1HvjP4D5oL3t8RsPlwxA9onvvStjtIHYE5XuuwOi/PY= +github.com/prometheus/common v0.70.1/go.mod h1:VdFUQDMZK3VLkurFUVhia6uys/0suUp86TJz5qbJRhc= github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI= github.com/prometheus/procfs v0.21.1/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= -go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= +go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= +go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= +go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= @@ -72,8 +64,8 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o= -golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= +golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= +golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -84,8 +76,8 @@ golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE= -golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= @@ -96,14 +88,9 @@ golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8T golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d h1:mpAgMyM9vQHxycBlDq50y1VHpfSfVwzXvrQKtYbXuUY= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/datasource/elasticsearch/go.mod b/pkg/gofr/datasource/elasticsearch/go.mod index a40457e954..8a721f25ba 100644 --- a/pkg/gofr/datasource/elasticsearch/go.mod +++ b/pkg/gofr/datasource/elasticsearch/go.mod @@ -3,23 +3,20 @@ module gofr.dev/pkg/gofr/datasource/elasticsearch go 1.26.0 require ( - github.com/elastic/go-elasticsearch/v8 v8.19.6 - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/elastic/go-elasticsearch/v8 v8.19.7 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 ) require ( github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/elastic/elastic-transport-go/v8 v8.9.0 // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - go.opentelemetry.io/otel/sdk v1.44.0 // indirect - golang.org/x/sys v0.46.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/sdk v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect ) diff --git a/pkg/gofr/datasource/elasticsearch/go.sum b/pkg/gofr/datasource/elasticsearch/go.sum index cda4e8ccff..17fdd3c076 100644 --- a/pkg/gofr/datasource/elasticsearch/go.sum +++ b/pkg/gofr/datasource/elasticsearch/go.sum @@ -1,46 +1,33 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/elastic/elastic-transport-go/v8 v8.9.0 h1:KeT/2P54F0xS0S8Y3Pf+tFDg4HmBgReQMB+BMz8dDAs= github.com/elastic/elastic-transport-go/v8 v8.9.0/go.mod h1:ssMTvNS2hwf7CaiGsRRsx4gQHFZ/jS/DkLcISxekWzc= -github.com/elastic/go-elasticsearch/v8 v8.19.6 h1:4qa7ecJkr5rLsoHKIVGbaqcFt2o57CnOHQJi9Pts/rk= -github.com/elastic/go-elasticsearch/v8 v8.19.6/go.mod h1:jeWebApE1oFEW/hKZqx/IRYmP/aa2+WMJkOfk+AduSI= +github.com/elastic/go-elasticsearch/v8 v8.19.7 h1:fMsWcVgPDJMtyptspSmn4SDHykovo4ppaAbBNLK9mKE= +github.com/elastic/go-elasticsearch/v8 v8.19.7/go.mod h1:jeWebApE1oFEW/hKZqx/IRYmP/aa2+WMJkOfk+AduSI= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= +go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= -golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw= -golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= diff --git a/pkg/gofr/datasource/file/azure/go.mod b/pkg/gofr/datasource/file/azure/go.mod index fee4cfb5d9..ec5f928c00 100644 --- a/pkg/gofr/datasource/file/azure/go.mod +++ b/pkg/gofr/datasource/file/azure/go.mod @@ -3,9 +3,9 @@ module gofr.dev/pkg/gofr/datasource/file/azure go 1.26.0 require ( - github.com/Azure/azure-sdk-for-go/sdk/azcore v1.22.0 + github.com/Azure/azure-sdk-for-go/sdk/azcore v1.23.0 github.com/Azure/azure-sdk-for-go/sdk/storage/azfile v1.7.0 - github.com/stretchr/testify v1.11.1 + github.com/stretchr/testify v1.12.1 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 ) @@ -13,13 +13,12 @@ require ( require ( github.com/Azure/azure-sdk-for-go/sdk/internal v1.12.0 // indirect github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.8.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/joho/godotenv v1.5.1 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/rogpeppe/go-internal v1.14.1 // indirect - golang.org/x/net v0.56.0 // indirect - golang.org/x/text v0.38.0 // indirect - google.golang.org/api v0.287.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect + go.opentelemetry.io/otel/trace v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/crypto v0.55.0 // indirect + golang.org/x/net v0.57.0 // indirect + golang.org/x/text v0.41.0 // indirect + google.golang.org/api v0.291.0 // indirect ) diff --git a/pkg/gofr/datasource/file/azure/go.sum b/pkg/gofr/datasource/file/azure/go.sum index 94efccda70..bff5f124ee 100644 --- a/pkg/gofr/datasource/file/azure/go.sum +++ b/pkg/gofr/datasource/file/azure/go.sum @@ -1,5 +1,5 @@ -github.com/Azure/azure-sdk-for-go/sdk/azcore v1.22.0 h1:aokoqcHvaGjiM3VpjKDfMMnF/8epJ+Q1HLJ7CudztqE= -github.com/Azure/azure-sdk-for-go/sdk/azcore v1.22.0/go.mod h1:/WYEx9pcM9Y+Dd/APJaNlSvVSvzl54rrMdZT5+Oi2LM= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.23.0 h1:4gRPBpN1f6xt88yi4WR26m7XaD9OlWtVT6bWPdGUIok= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.23.0/go.mod h1:G7QVLxw1j1JVyrO1MA95S8m8HStaaleDZYTcfGgjB2o= github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1 h1:Hk5QBxZQC1jb2Fwj6mpzme37xbCDdNTxU7O9eb5+LB4= github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1/go.mod h1:IYus9qsFobWIc2YVwe/WPjcnyCkPKtnHAqUYeebc8z0= github.com/Azure/azure-sdk-for-go/sdk/internal v1.12.0 h1:fhqpLE3UEXi9lPaBRpQ6XuRW0nU7hgg4zlmZZa+a9q4= @@ -12,52 +12,39 @@ github.com/AzureAD/microsoft-authentication-library-for-go v1.7.2 h1:RHK7bS+HQMs github.com/AzureAD/microsoft-authentication-library-for-go v1.7.2/go.mod h1:HKpQxkWaGLJ+D/5H8QRpyQXA1eKjxkFlOMwck5+33Jk= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY= github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= -golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto= -golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio= -golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o= -golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= -golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw= -golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -golang.org/x/term v0.44.0 h1:0rLvDRCtNj0gZkyIXhCyOb2OAzEhLVqc4B+hrsBhrmc= -golang.org/x/term v0.44.0/go.mod h1:7ze4MdzUzLXpSAoFP1H0bOI9aXDqveSvatT5vKcFh2Y= -golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE= -golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4= -google.golang.org/api v0.287.0 h1:CQDMqUiqZZ0U/Yge3zyjAhNQ0OSYEH0PaA7l4xtEen4= -google.golang.org/api v0.287.0/go.mod h1:pPW85yt3Iuc3unkpaMhFtMmOqnTdCwCqEOaUlnuxRlQ= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= +golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= +golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= +golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= +google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= +google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= diff --git a/pkg/gofr/datasource/file/ftp/go.mod b/pkg/gofr/datasource/file/ftp/go.mod index 5c0c60c799..827e931c73 100644 --- a/pkg/gofr/datasource/file/ftp/go.mod +++ b/pkg/gofr/datasource/file/ftp/go.mod @@ -6,19 +6,16 @@ require ( github.com/goftp/file-driver v0.0.0-20180502053751-5d604a0fc0c9 github.com/goftp/server v0.0.0-20200708154336-f64f7c2d8a42 github.com/jlaffaye/ftp v0.2.2 - github.com/stretchr/testify v1.11.1 + github.com/stretchr/testify v1.12.1 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 ) require ( - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/joho/godotenv v1.5.1 // indirect - github.com/kr/pretty v0.3.1 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/rogpeppe/go-internal v1.14.1 // indirect - google.golang.org/api v0.287.0 // indirect - gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect + go.opentelemetry.io/otel/trace v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/term v0.45.0 // indirect + google.golang.org/api v0.291.0 // indirect ) diff --git a/pkg/gofr/datasource/file/ftp/go.sum b/pkg/gofr/datasource/file/ftp/go.sum index 23f580e872..17c679d24a 100644 --- a/pkg/gofr/datasource/file/ftp/go.sum +++ b/pkg/gofr/datasource/file/ftp/go.sum @@ -1,8 +1,5 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/goftp/file-driver v0.0.0-20180502053751-5d604a0fc0c9 h1:cC0Hbb+18DJ4i6ybqDybvj4wdIDS4vnD0QEci98PgM8= github.com/goftp/file-driver v0.0.0-20180502053751-5d604a0fc0c9/go.mod h1:GpOj6zuVBG3Inr9qjEnuVTgBlk2lZ1S9DcoFiXWyKss= github.com/goftp/server v0.0.0-20200708154336-f64f7c2d8a42 h1:JdOp2qR5PF4O75tzHeqrwnDDv8oHDptWyTbyYS4fD8E= @@ -11,39 +8,23 @@ github.com/jlaffaye/ftp v0.2.2 h1:JwjrXCAIjN9ZYrF1/8qlmHFXDteh9MHYaiEIh/Oqtd8= github.com/jlaffaye/ftp v0.2.2/go.mod h1:zuLAKdqFqFvNgkCrH0SC7K1XyUiydS7BFCmmoHUWWg0= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= -github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= -golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw= -golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -golang.org/x/term v0.44.0 h1:0rLvDRCtNj0gZkyIXhCyOb2OAzEhLVqc4B+hrsBhrmc= -golang.org/x/term v0.44.0/go.mod h1:7ze4MdzUzLXpSAoFP1H0bOI9aXDqveSvatT5vKcFh2Y= -google.golang.org/api v0.287.0 h1:CQDMqUiqZZ0U/Yge3zyjAhNQ0OSYEH0PaA7l4xtEen4= -google.golang.org/api v0.287.0/go.mod h1:pPW85yt3Iuc3unkpaMhFtMmOqnTdCwCqEOaUlnuxRlQ= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= +golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= +google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= +google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= diff --git a/pkg/gofr/datasource/file/gcs/go.mod b/pkg/gofr/datasource/file/gcs/go.mod index 705a406165..a38e09031b 100644 --- a/pkg/gofr/datasource/file/gcs/go.mod +++ b/pkg/gofr/datasource/file/gcs/go.mod @@ -4,7 +4,7 @@ go 1.26.0 require ( cloud.google.com/go/storage v1.64.0 - github.com/stretchr/testify v1.11.1 + github.com/stretchr/testify v1.12.1 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 golang.org/x/oauth2 v0.36.0 @@ -17,19 +17,18 @@ require ( cloud.google.com/go/auth v0.22.0 // indirect cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect cloud.google.com/go/compute/metadata v0.9.0 // indirect - cloud.google.com/go/iam v1.11.0 // indirect - cloud.google.com/go/monitoring v1.29.0 // indirect + cloud.google.com/go/iam v1.12.0 // indirect + cloud.google.com/go/monitoring v1.30.0 // indirect github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.33.0 // indirect github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.57.0 // indirect github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.57.0 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/envoyproxy/go-control-plane/envoy v1.37.0 // indirect github.com/envoyproxy/protoc-gen-validate v1.3.3 // indirect github.com/felixge/httpsnoop v1.1.0 // indirect github.com/go-jose/go-jose/v4 v4.1.4 // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/google/s2a-go v0.1.9 // indirect github.com/google/uuid v1.6.0 // indirect @@ -38,27 +37,26 @@ require ( github.com/joho/godotenv v1.5.1 // indirect github.com/pkg/errors v0.9.1 // indirect github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/spiffe/go-spiffe/v2 v2.7.0 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect go.opentelemetry.io/contrib/detectors/gcp v1.44.0 // indirect go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 // indirect - go.opentelemetry.io/otel v1.44.0 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - go.opentelemetry.io/otel/sdk v1.44.0 // indirect - go.opentelemetry.io/otel/sdk/metric v1.44.0 // indirect - go.opentelemetry.io/otel/trace v1.44.0 // indirect - golang.org/x/crypto v0.54.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 // indirect + go.opentelemetry.io/otel v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/sdk v1.45.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect + go.opentelemetry.io/otel/trace v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/crypto v0.55.0 // indirect golang.org/x/net v0.57.0 // indirect golang.org/x/sync v0.22.0 // indirect golang.org/x/sys v0.47.0 // indirect - golang.org/x/text v0.40.0 // indirect + golang.org/x/text v0.41.0 // indirect golang.org/x/time v0.15.0 // indirect - google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20260630182238-925bb5da69e7 // indirect + google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect google.golang.org/grpc v1.83.0 // indirect google.golang.org/protobuf v1.36.11 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/pkg/gofr/datasource/file/gcs/go.sum b/pkg/gofr/datasource/file/gcs/go.sum index 285b31141e..5fa0155300 100644 --- a/pkg/gofr/datasource/file/gcs/go.sum +++ b/pkg/gofr/datasource/file/gcs/go.sum @@ -8,14 +8,14 @@ cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIi cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10= -cloud.google.com/go/iam v1.11.0 h1:KieQ9Pb+LLPak1O3Rv3GgCxhnmkYf7Xyh0P5HfF1jFM= -cloud.google.com/go/iam v1.11.0/go.mod h1:KP+nKGugNJW4LcLx1uEZcq1ok5sQHFaQehQNl4QDgV4= -cloud.google.com/go/logging v1.18.0 h1:KhzZq+1cSkPH9YUaKLLhLtQxIHitVayBmk0sGfoM9+k= -cloud.google.com/go/logging v1.18.0/go.mod h1:ZGKnpBaURITh+g/uom2VhbiFoFWvejcrHPDhxFtU/gI= +cloud.google.com/go/iam v1.12.0 h1:Aki3bX9aHUDKPHfnRJfDcTdVedvy6quGBQcTqx3DRXk= +cloud.google.com/go/iam v1.12.0/go.mod h1:FEZ4lXpADAC2AIpQY7LANNjjwyQ2jK439CI2VaD+sLY= +cloud.google.com/go/logging v1.19.0 h1:NCqhdVUg3wQ8Cobdf16FDSuTGi3+6+hdSBHrY5TsR6Q= +cloud.google.com/go/logging v1.19.0/go.mod h1:i40NZCHC9Gqvod4yE+yQfDWwlgwW/SrshkkGibCHxcA= cloud.google.com/go/longrunning v1.2.0 h1:WjYH3YHBGCxGJP9M4dWGHBfXr/cFIjMkNgWcJj7/iMM= cloud.google.com/go/longrunning v1.2.0/go.mod h1:5KMQALFGOCtFoi2xSOA1u3H7WKlhmckgiyFw7+LGQp0= -cloud.google.com/go/monitoring v1.29.0 h1:AHhDsFaSax1/4k+qlIDX/SDGe6hggnfXJ9dkgD9qBPY= -cloud.google.com/go/monitoring v1.29.0/go.mod h1:72NOVjJXHY/HBfoLT0+qlCZBT059+9VXLeAnL2PeeVM= +cloud.google.com/go/monitoring v1.30.0 h1:r/d+JUbyKmJ8b07iznuKfzVzrIXTWxHQ3lBRm3x2LlY= +cloud.google.com/go/monitoring v1.30.0/go.mod h1:htlUR0QWVMrjFzZmN4LGnMAve9xB/eduwjmINxVZ8RM= cloud.google.com/go/storage v1.64.0 h1:KLpxI/oX9LxeRsNqn877d2WyeT3ryiEwnGt8pwcSPZg= cloud.google.com/go/storage v1.64.0/go.mod h1:lWyAtwvDZHdL3k68WVKbESP6bmWaV23ZJJ/JEVw/ZaQ= cloud.google.com/go/trace v1.16.0 h1:GmQovzFc5F0CNfl0VLgL64aoTtu7xsM0YajW2GlG9+E= @@ -32,8 +32,6 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UF github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2 h1:aBangftG7EVZoUb69Os8IaYg++6uMOdKK83QtkkvJik= github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2/go.mod h1:qwXFYgsP6T7XnJtbKlf1HP8AjxZZyzxMmc+Lq5GjlU4= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/envoyproxy/go-control-plane v0.14.0 h1:hbG2kr4RuFj222B6+7T83thSPqLjwBIfQawTkC++2HA= github.com/envoyproxy/go-control-plane v0.14.0/go.mod h1:NcS5X47pLl/hfqxU70yPwL9ZMkUlwlKxtAohpi2wBEU= github.com/envoyproxy/go-control-plane/envoy v1.37.0 h1:u3riX6BoYRfF4Dr7dwSOroNfdSbEPe9Yyl09/B6wBrQ= @@ -47,8 +45,8 @@ github.com/felixge/httpsnoop v1.1.0/go.mod h1:Zqxgdd+1Rkcz8euOqdr7lqgCRJztwr5hp9 github.com/go-jose/go-jose/v4 v4.1.4 h1:moDMcTHmvE6Groj34emNPLs/qtYXRVcd6S7NHbHz3kA= github.com/go-jose/go-jose/v4 v4.1.4/go.mod h1:x4oUasVrzR7071A4TnHLGSPpNOm2a21K9Kf04k1rs08= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= @@ -67,50 +65,44 @@ github.com/googleapis/gax-go/v2 v2.23.0 h1:Tchl7qkvE7Ip3y+ztvNufYFvkfqTe7NfLTYGI github.com/googleapis/gax-go/v2 v2.23.0/go.mod h1:rBQKOVJCdb8IFEzg+FCwlt1LP/xMDGuqUXhUG+XMXEg= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/spiffe/go-spiffe/v2 v2.7.0 h1:uXe1MflJoHw58wAUvxVlcM7WpKtijWG7I1UidcGh6g4= github.com/spiffe/go-spiffe/v2 v2.7.0/go.mod h1:47Q0Q9/AqGha8QLHp+kxpH4Wca7X7EnOtlIJy3mxZ3U= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/contrib/detectors/gcp v1.44.0 h1:NmLfL734pJhM0JKaYd2Y28+nY9dPRWYAAbxhRCrKXPw= go.opentelemetry.io/contrib/detectors/gcp v1.44.0/go.mod h1:tNAsgd8avTGke1+MndXlU5Cru4PQ9Ai/cCNWQv/ZJ/s= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 h1:0Qx7VGBacMm9ZENQ7TnNObTYI4ShC+lHI16seduaxZo= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0/go.mod h1:Sje3i3MjSPKTSPvVWCaL8ugBzJwik3u4smCjUeuupqg= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 h1:8tvICD4vSTOOsNrsI4Ljf6C+6UKvpTEH5XY3JMoyPoo= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0/go.mod h1:z9+yiacE0IHRqM4qFfkbt/JYlmYXgss8GY/jXoNuPJI= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 h1:LMuyCAyfalSjDyjdC65nK6N0zoTT63+E/u95X0JovZI= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0/go.mod h1:085m8qbm4hgc8rZWGDEa4vmyyo2c3nPxUslYUKUIU04= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.44.0 h1:hqxVTu/GtBF+vJ8d1fzW7fRxZFvgoDjWcxwwCaFDYpU= go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.44.0/go.mod h1:z5fVEF4X5v0ESvlJqBrrFlBVoj5EQuefZpzsu7R+x5Q= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/metric/x v0.66.0 h1:YkCrx1zLOChi9ZcZ6euupOcsgzbVlec7D/xoEU1+cTA= -go.opentelemetry.io/otel/metric/x v0.66.0/go.mod h1:d1+BDj9t96do0/1LoU1ayfCv79ZgNE41qbhBvnMOBZk= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= -go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/metric/x v0.67.0 h1:PcicCNZFkZ4bXfSooXdo3WN7RBOVOtjVdo1wD358Uns= +go.opentelemetry.io/otel/metric/x v0.67.0/go.mod h1:FBjCWZe6wgcqxcMtjdGiClDKXb2YxxXii0CXftE4QtI= +go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= +go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= +go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= +go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= -golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw= -golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= @@ -121,26 +113,21 @@ golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= -golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs= -golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= -google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94 h1:YJjbgu+dkp5kUJLfpMyCLfBIWZb/FcJyuLeo1gVBOuo= -google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94/go.mod h1:RRHjglSYABVCWpQ7USCpdfhcd9t4PkajvVwyynZizTc= -google.golang.org/genproto/googleapis/api v0.0.0-20260630182238-925bb5da69e7 h1:jQ9p21COKWjP3VwuFrNRiiOTMh3mPpN45R7SLrH/HUU= -google.golang.org/genproto/googleapis/api v0.0.0-20260630182238-925bb5da69e7/go.mod h1:KqHwBx2upmfa1XSi1WuRvC+2VGCLtooKkfmyvRbUmqA= +google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd h1:0GnSESHqea5EoaQgJyYxC3o5m0L191gCQdDgo2cxO5I= +google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/datasource/file/s3/go.mod b/pkg/gofr/datasource/file/s3/go.mod index fd059fc432..182d1fe8af 100644 --- a/pkg/gofr/datasource/file/s3/go.mod +++ b/pkg/gofr/datasource/file/s3/go.mod @@ -7,7 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/config v1.32.37 github.com/aws/aws-sdk-go-v2/credentials v1.19.36 github.com/aws/aws-sdk-go-v2/service/s3 v1.107.2 - github.com/stretchr/testify v1.11.1 + github.com/stretchr/testify v1.12.1 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 ) @@ -27,14 +27,10 @@ require ( github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.6 // indirect github.com/aws/aws-sdk-go-v2/service/sts v1.45.6 // indirect github.com/aws/smithy-go v1.27.8 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/joho/godotenv v1.5.1 // indirect - github.com/kr/pretty v0.3.1 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/rogpeppe/go-internal v1.14.1 // indirect + go.opentelemetry.io/otel/trace v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/term v0.45.0 // indirect - google.golang.org/api v0.288.0 // indirect - gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect + google.golang.org/api v0.291.0 // indirect ) diff --git a/pkg/gofr/datasource/file/s3/go.sum b/pkg/gofr/datasource/file/s3/go.sum index 1596698d99..a0c9d78545 100644 --- a/pkg/gofr/datasource/file/s3/go.sum +++ b/pkg/gofr/datasource/file/s3/go.sum @@ -36,44 +36,25 @@ github.com/aws/smithy-go v1.27.8 h1:FR0dxZfIlV7Z8eh2iHfIofdunw382XsDV3Mxt9nUvRY= github.com/aws/smithy-go v1.27.8/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= -github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= -google.golang.org/api v0.288.0 h1:glhO/J88obKP5I269W3hB73dvBKrjU56ZfmNlNXpgTU= -google.golang.org/api v0.288.0/go.mod h1:lM2kYRzYUCBY91P9h6VF1PYmvhxii3O5hji37qRvIcY= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= +google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= diff --git a/pkg/gofr/datasource/file/sftp/go.mod b/pkg/gofr/datasource/file/sftp/go.mod index b31c7ddb32..8575eed554 100644 --- a/pkg/gofr/datasource/file/sftp/go.mod +++ b/pkg/gofr/datasource/file/sftp/go.mod @@ -3,23 +3,19 @@ module gofr.dev/pkg/gofr/datasource/file/sftp go 1.26.0 require ( - github.com/pkg/sftp v1.13.10 - github.com/stretchr/testify v1.11.1 + github.com/pkg/sftp v1.13.11 + github.com/stretchr/testify v1.12.1 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 golang.org/x/crypto v0.55.0 ) require ( - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/joho/godotenv v1.5.1 // indirect github.com/kr/fs v0.1.0 // indirect - github.com/kr/pretty v0.3.1 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/rogpeppe/go-internal v1.14.1 // indirect + go.opentelemetry.io/otel/trace v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/sys v0.47.0 // indirect - google.golang.org/api v0.287.0 // indirect - gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect + google.golang.org/api v0.291.0 // indirect ) diff --git a/pkg/gofr/datasource/file/sftp/go.sum b/pkg/gofr/datasource/file/sftp/go.sum index b0aa18de43..a733433c2b 100644 --- a/pkg/gofr/datasource/file/sftp/go.sum +++ b/pkg/gofr/datasource/file/sftp/go.sum @@ -1,37 +1,23 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= github.com/kr/fs v0.1.0 h1:Jskdu9ieNAYnjxsi0LbQp1ulIKZV1LAFgK1tWhpZgl8= github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= -github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pkg/sftp v1.13.10 h1:+5FbKNTe5Z9aspU88DPIKJ9z2KZoaGCu6Sr6kKR/5mU= -github.com/pkg/sftp v1.13.10/go.mod h1:bJ1a7uDhrX/4OII+agvy28lzRvQrmIQuaHrcI1HbeGA= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +github.com/pkg/sftp v1.13.11 h1:0N92SLTB8JqASJB14ZLHHzFnBV8mG9zw4K7jghEFWuE= +github.com/pkg/sftp v1.13.11/go.mod h1:uNkH9roSXglNJqM+glJJi+TQXQUm0fXFWqCFmT8hsN0= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= @@ -40,10 +26,5 @@ golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= -google.golang.org/api v0.287.0 h1:CQDMqUiqZZ0U/Yge3zyjAhNQ0OSYEH0PaA7l4xtEen4= -google.golang.org/api v0.287.0/go.mod h1:pPW85yt3Iuc3unkpaMhFtMmOqnTdCwCqEOaUlnuxRlQ= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= +google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= diff --git a/pkg/gofr/datasource/influxdb/go.mod b/pkg/gofr/datasource/influxdb/go.mod index dc806145a7..b3aed6875d 100644 --- a/pkg/gofr/datasource/influxdb/go.mod +++ b/pkg/gofr/datasource/influxdb/go.mod @@ -5,25 +5,23 @@ go 1.26.0 require ( github.com/golang/mock v1.7.0-rc.1 github.com/influxdata/influxdb-client-go/v2 v2.14.0 - github.com/stretchr/testify v1.11.1 + github.com/stretchr/testify v1.12.1 go.opencensus.io v0.24.0 - go.opentelemetry.io/otel v1.44.0 + go.opentelemetry.io/otel v1.45.0 ) require ( github.com/apapsch/go-jsonmerge/v2 v2.0.0 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect github.com/google/uuid v1.6.0 // indirect github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839 // indirect github.com/oapi-codegen/runtime v1.0.0 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - go.opentelemetry.io/otel/trace v1.44.0 // indirect - golang.org/x/net v0.56.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/trace v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/net v0.57.0 // indirect ) diff --git a/pkg/gofr/datasource/influxdb/go.sum b/pkg/gofr/datasource/influxdb/go.sum index f8c951efc1..c444013c55 100644 --- a/pkg/gofr/datasource/influxdb/go.sum +++ b/pkg/gofr/datasource/influxdb/go.sum @@ -11,15 +11,13 @@ github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDk github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= @@ -54,18 +52,10 @@ github.com/influxdata/influxdb-client-go/v2 v2.14.0/go.mod h1:Ahpm3QXKMJslpXl3If github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839 h1:W9WBk7wlPfJLvMCdtV4zPulc4uCPrlywQOmbFOhgQNU= github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo= github.com/juju/gnuflag v0.0.0-20171113085948-2ce1bb71843d/go.mod h1:2PavIy+JPciBPrBUjwbNvtwB6RQlve+hkpll6QSNmOE= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/oapi-codegen/runtime v1.0.0 h1:P4rqFX5fMFWqRzY9M/3YF9+aPSPPB06IzP2P7oOxrWo= github.com/oapi-codegen/runtime v1.0.0/go.mod h1:LmCUMQuPB4M/nLXilQXhHw+BLZdDb18B34OO356yJ/A= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKkMo8ZTx3f+BZEkzsRUY10Xsm2mwU0= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= @@ -74,19 +64,21 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0= go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= @@ -103,8 +95,8 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o= -golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= +golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= +golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -153,10 +145,7 @@ google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2 google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= diff --git a/pkg/gofr/datasource/kv-store/badger/go.mod b/pkg/gofr/datasource/kv-store/badger/go.mod index 0ed8b0bc2e..697418bc39 100644 --- a/pkg/gofr/datasource/kv-store/badger/go.mod +++ b/pkg/gofr/datasource/kv-store/badger/go.mod @@ -4,25 +4,23 @@ go 1.26.0 require ( github.com/dgraph-io/badger/v4 v4.9.4 - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 ) require ( github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/dgraph-io/ristretto/v2 v2.2.0 // indirect github.com/dustin/go-humanize v1.0.1 // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/google/flatbuffers v25.2.10+incompatible // indirect - github.com/klauspost/compress v1.18.6 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect + github.com/klauspost/compress v1.19.2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - golang.org/x/sys v0.46.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/sys v0.47.0 // indirect google.golang.org/protobuf v1.36.11 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/pkg/gofr/datasource/kv-store/badger/go.sum b/pkg/gofr/datasource/kv-store/badger/go.sum index 106618db27..45f33a84a9 100644 --- a/pkg/gofr/datasource/kv-store/badger/go.sum +++ b/pkg/gofr/datasource/kv-store/badger/go.sum @@ -1,7 +1,5 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dgraph-io/badger/v4 v4.9.4 h1:bcw+waCpzRZ2nmcSPbnPvDVhiEsn98TKmvnAhK7r7LM= github.com/dgraph-io/badger/v4 v4.9.4/go.mod h1:nJjaJTUOSsQEBhsq209FmwCvMJzEA3e74RjZw6V2pQI= github.com/dgraph-io/ristretto/v2 v2.2.0 h1:bkY3XzJcXoMuELV8F+vS8kzNgicwQFAaGINAEJdWGOM= @@ -11,42 +9,31 @@ github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da/go.mod h1:SqUrOPUn github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/google/flatbuffers v25.2.10+incompatible h1:F3vclr7C3HpB1k9mxCGRMXq6FdUalZ6H/pNX4FP1v0Q= github.com/google/flatbuffers v25.2.10+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/klauspost/compress v1.18.6 h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao= -github.com/klauspost/compress v1.18.6/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8= +github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= -golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw= -golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/datasource/kv-store/dynamodb/go.mod b/pkg/gofr/datasource/kv-store/dynamodb/go.mod index adae56f1da..1937f12d6c 100644 --- a/pkg/gofr/datasource/kv-store/dynamodb/go.mod +++ b/pkg/gofr/datasource/kv-store/dynamodb/go.mod @@ -5,10 +5,10 @@ go 1.26.0 require ( github.com/aws/aws-sdk-go-v2 v1.43.6 github.com/aws/aws-sdk-go-v2/config v1.32.37 - github.com/aws/aws-sdk-go-v2/service/dynamodb v1.60.1 - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/aws/aws-sdk-go-v2/service/dynamodb v1.63.3 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 ) @@ -19,7 +19,7 @@ require ( github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37 // indirect github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38 // indirect github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.12.7 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.12.14 // indirect github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37 // indirect github.com/aws/aws-sdk-go-v2/service/signin v1.5.6 // indirect github.com/aws/aws-sdk-go-v2/service/sso v1.33.6 // indirect @@ -27,10 +27,5 @@ require ( github.com/aws/aws-sdk-go-v2/service/sts v1.45.6 // indirect github.com/aws/smithy-go v1.27.8 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect - github.com/kr/pretty v0.3.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/rogpeppe/go-internal v1.14.1 // indirect - gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect ) diff --git a/pkg/gofr/datasource/kv-store/dynamodb/go.sum b/pkg/gofr/datasource/kv-store/dynamodb/go.sum index a1188342ad..778c5de6f1 100644 --- a/pkg/gofr/datasource/kv-store/dynamodb/go.sum +++ b/pkg/gofr/datasource/kv-store/dynamodb/go.sum @@ -12,12 +12,12 @@ github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37 h1:zCEORWo0eU0gDjG+Iy github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37/go.mod h1:i6c0PEl3TNOWxRbQ++KQcVenPWS/GoQeiklKhNuqzJ8= github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38 h1:A3UAuCmx7LyUcrixBTzKJYYIUZ2yTvn6ZhT8PB+7APk= github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38/go.mod h1:1PDUYG9Z+JrbbsobsAZHjWOm9QBT/djiK3QbykTL5Z4= -github.com/aws/aws-sdk-go-v2/service/dynamodb v1.60.1 h1:JX6naxruLi55bTc6XGz7t/FK6zBAF/on9P1eBvSdo44= -github.com/aws/aws-sdk-go-v2/service/dynamodb v1.60.1/go.mod h1:HnWoC3m6VmjUSg+kBL6OgQsXdyRAGzBYWb7B3J2f+JM= +github.com/aws/aws-sdk-go-v2/service/dynamodb v1.63.3 h1:cVfESNZmZ8L9TkOeNo6u/eNR0ZphBuS1J2GjLBLmEdA= +github.com/aws/aws-sdk-go-v2/service/dynamodb v1.63.3/go.mod h1:n9exrC9k5S+0t6X6LQKHcv7ap1jAEAHY2Sbqhu9mS34= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17 h1:OvYZOB3qA6zvfdRFiRFRzVSiElMYrz3GdntkXZxlp1o= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17/go.mod h1:JgR/2Ew50ACfIWau1oeMRX59tMtC0kM+PYQGEaT04cY= -github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.12.7 h1:uqsKxr7kJp9DXVj2m8KbVeZcYMuwsNEwvoVrYl2Vpf8= -github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.12.7/go.mod h1:Js/P8Zbwe1mRejnD+OpFLyQiJ8ioQlo3GMAg7Dfxk7w= +github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.12.14 h1:fiayMFWJ04EbPboTzc97F4ii4o6bAi0b6Sk8oXUHRUQ= +github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.12.14/go.mod h1:Ki93kowJvAQpSDjMR+QfntVks2FIj2TWdV3jGIWWm10= github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37 h1:a3D4AjrOrTrP8+d9ILBthqrElf0z1JNol09Xvnwcys8= github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37/go.mod h1:ky0gTu+ukvUTuUKFIpp6Wid4oninrkCyvbFkVs0kpHM= github.com/aws/aws-sdk-go-v2/service/signin v1.5.6 h1:i68sFvXidKlkiSvI7d7Ilc1/UvW4CtBOaivH7jhG4fs= @@ -32,34 +32,15 @@ github.com/aws/smithy-go v1.27.8 h1:FR0dxZfIlV7Z8eh2iHfIofdunw382XsDV3Mxt9nUvRY= github.com/aws/smithy-go v1.27.8/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= diff --git a/pkg/gofr/datasource/kv-store/nats/go.mod b/pkg/gofr/datasource/kv-store/nats/go.mod index 797d4df77e..9cdfbc21b1 100644 --- a/pkg/gofr/datasource/kv-store/nats/go.mod +++ b/pkg/gofr/datasource/kv-store/nats/go.mod @@ -3,24 +3,19 @@ module gofr.dev/pkg/gofr/datasource/kv-store/nats go 1.26.0 require ( - github.com/nats-io/nats.go v1.52.0 - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/nats-io/nats.go v1.53.1 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 ) require ( github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect - github.com/klauspost/compress v1.18.6 // indirect - github.com/kr/pretty v0.3.1 // indirect + github.com/klauspost/compress v1.19.2 // indirect github.com/nats-io/nkeys v0.4.16 // indirect github.com/nats-io/nuid v1.0.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/rogpeppe/go-internal v1.14.1 // indirect - golang.org/x/crypto v0.53.0 // indirect - golang.org/x/sys v0.46.0 // indirect - gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/crypto v0.55.0 // indirect + golang.org/x/sys v0.47.0 // indirect ) diff --git a/pkg/gofr/datasource/kv-store/nats/go.sum b/pkg/gofr/datasource/kv-store/nats/go.sum index bdb37e3207..9641c9e01b 100644 --- a/pkg/gofr/datasource/kv-store/nats/go.sum +++ b/pkg/gofr/datasource/kv-store/nats/go.sum @@ -1,45 +1,26 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/klauspost/compress v1.18.6 h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao= -github.com/klauspost/compress v1.18.6/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= -github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/nats-io/nats.go v1.52.0 h1:n3avV4VBsCgsdwh71TppsTwtv+QdPs7ntSKM8qJLGsc= -github.com/nats-io/nats.go v1.52.0/go.mod h1:26HypzazeOkyO3/mqd1zZd53STJN0EjCYF9Uy2ZOBno= +github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8= +github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= +github.com/nats-io/nats.go v1.53.1 h1:Otsq3uLc/kLdjmkNHkXH0jBqwUquwdKFoe3fq6/3/Xo= +github.com/nats-io/nats.go v1.53.1/go.mod h1:26HypzazeOkyO3/mqd1zZd53STJN0EjCYF9Uy2ZOBno= github.com/nats-io/nkeys v0.4.16 h1:rd5oAuLOb8mnAycB0xleuEBNS1pVVnN0fv/FF34Eypg= github.com/nats-io/nkeys v0.4.16/go.mod h1:llLgWoI0o4z/Q57q2R1kHfmocyhGV6VG/U18Glg1Afs= github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw= github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= -github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= -golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto= -golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio= -golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw= -golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= diff --git a/pkg/gofr/datasource/mongo/go.mod b/pkg/gofr/datasource/mongo/go.mod index afca68b8d2..1865219900 100644 --- a/pkg/gofr/datasource/mongo/go.mod +++ b/pkg/gofr/datasource/mongo/go.mod @@ -3,30 +3,29 @@ module gofr.dev/pkg/gofr/datasource/mongo go 1.26.0 require ( - github.com/stretchr/testify v1.11.1 + github.com/stretchr/testify v1.12.1 go.mongodb.org/mongo-driver v1.17.9 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 ) require ( github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/golang/snappy v1.0.0 // indirect - github.com/klauspost/compress v1.18.6 // indirect + github.com/klauspost/compress v1.19.2 // indirect github.com/montanaflynn/stats v0.7.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/xdg-go/pbkdf2 v1.0.0 // indirect github.com/xdg-go/scram v1.1.2 // indirect github.com/xdg-go/stringprep v1.0.4 // indirect github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - golang.org/x/crypto v0.53.0 // indirect - golang.org/x/sync v0.21.0 // indirect - golang.org/x/text v0.38.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/crypto v0.55.0 // indirect + golang.org/x/sync v0.22.0 // indirect + golang.org/x/text v0.41.0 // indirect ) diff --git a/pkg/gofr/datasource/mongo/go.sum b/pkg/gofr/datasource/mongo/go.sum index 982ba5db04..352311ba97 100644 --- a/pkg/gofr/datasource/mongo/go.sum +++ b/pkg/gofr/datasource/mongo/go.sum @@ -3,28 +3,20 @@ github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XL github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs= github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/klauspost/compress v1.18.6 h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao= -github.com/klauspost/compress v1.18.6/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8= +github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE= github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c= github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI= github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY= @@ -38,26 +30,28 @@ go.mongodb.org/mongo-driver v1.17.9 h1:IexDdCuuNJ3BHrELgBlyaH9p60JXAvdzWR128q+U5 go.mongodb.org/mongo-driver v1.17.9/go.mod h1:LlOhpH5NUEfhxcAwG0UEkMqwYcc4JU18gtCdGudk/tQ= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto= -golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM= -golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= +golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek= +golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -69,14 +63,9 @@ golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= -golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE= -golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/datasource/opentsdb/go.mod b/pkg/gofr/datasource/opentsdb/go.mod index 8dc373e038..da862713d8 100644 --- a/pkg/gofr/datasource/opentsdb/go.mod +++ b/pkg/gofr/datasource/opentsdb/go.mod @@ -3,19 +3,17 @@ module gofr.dev/pkg/gofr/datasource/opentsdb go 1.26.0 require ( - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 ) require ( github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect ) diff --git a/pkg/gofr/datasource/opentsdb/go.sum b/pkg/gofr/datasource/opentsdb/go.sum index 9724dc9398..3622e32887 100644 --- a/pkg/gofr/datasource/opentsdb/go.sum +++ b/pkg/gofr/datasource/opentsdb/go.sum @@ -1,36 +1,23 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= diff --git a/pkg/gofr/datasource/oracle/go.mod b/pkg/gofr/datasource/oracle/go.mod index 2175916c82..02bf86c96c 100644 --- a/pkg/gofr/datasource/oracle/go.mod +++ b/pkg/gofr/datasource/oracle/go.mod @@ -4,57 +4,55 @@ go 1.26.0 require ( github.com/DATA-DOG/go-sqlmock v1.5.2 - github.com/godror/godror v0.51.0 - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/godror/godror v0.51.4 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 ) require ( cloud.google.com/go v0.123.0 // indirect - cloud.google.com/go/auth v0.20.0 // indirect + cloud.google.com/go/auth v0.22.0 // indirect cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect cloud.google.com/go/compute/metadata v0.9.0 // indirect - cloud.google.com/go/iam v1.11.0 // indirect - cloud.google.com/go/pubsub v1.50.2 // indirect - cloud.google.com/go/pubsub/v2 v2.5.1 // indirect + cloud.google.com/go/iam v1.12.0 // indirect + cloud.google.com/go/pubsub v1.51.0 // indirect + cloud.google.com/go/pubsub/v2 v2.6.0 // indirect filippo.io/edwards25519 v1.2.0 // indirect github.com/VictoriaMetrics/easyproto v0.1.4 // indirect - github.com/XSAM/otelsql v0.42.0 // indirect + github.com/XSAM/otelsql v0.43.0 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/eclipse/paho.mqtt.golang v1.5.1 // indirect github.com/felixge/httpsnoop v1.1.0 // indirect github.com/go-logfmt/logfmt v0.6.0 // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-sql-driver/mysql v1.10.0 // indirect github.com/godror/knownpb v0.3.0 // indirect github.com/golang-jwt/jwt/v5 v5.3.1 // indirect github.com/google/s2a-go v0.1.9 // indirect github.com/google/uuid v1.6.0 // indirect - github.com/googleapis/enterprise-certificate-proxy v0.3.17 // indirect - github.com/googleapis/gax-go/v2 v2.22.0 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.19 // indirect + github.com/googleapis/gax-go/v2 v2.23.0 // indirect github.com/gorilla/mux v1.8.1 // indirect github.com/gorilla/websocket v1.5.3 // indirect github.com/joho/godotenv v1.5.1 // indirect - github.com/klauspost/compress v1.18.6 // indirect + github.com/klauspost/compress v1.19.2 // indirect github.com/lib/pq v1.12.3 // indirect - github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-isatty v0.0.24 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/ncruces/go-strftime v1.0.0 // indirect - github.com/pierrec/lz4/v4 v4.1.25 // indirect + github.com/pierrec/lz4/v4 v4.1.27 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/prometheus/client_golang v1.23.2 // indirect + github.com/prometheus/client_golang v1.24.1 // indirect github.com/prometheus/client_model v0.6.2 // indirect - github.com/prometheus/common v0.67.5 // indirect + github.com/prometheus/common v0.70.1 // indirect github.com/prometheus/otlptranslator v1.0.0 // indirect - github.com/prometheus/procfs v0.20.1 // indirect + github.com/prometheus/procfs v0.21.1 // indirect github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0 // indirect github.com/redis/go-redis/extra/redisotel/v9 v9.21.0 // indirect github.com/redis/go-redis/v9 v9.21.0 // indirect @@ -66,32 +64,31 @@ require ( go.opencensus.io v0.24.0 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 // indirect - go.opentelemetry.io/otel/exporters/prometheus v0.65.0 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - go.opentelemetry.io/otel/sdk v1.44.0 // indirect - go.opentelemetry.io/otel/sdk/metric v1.44.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 // indirect + go.opentelemetry.io/otel/exporters/prometheus v0.67.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/sdk v1.45.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect go.uber.org/atomic v1.11.0 // indirect - go.yaml.in/yaml/v2 v2.4.4 // indirect - golang.org/x/crypto v0.53.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/crypto v0.55.0 // indirect golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 // indirect - golang.org/x/net v0.56.0 // indirect + golang.org/x/net v0.57.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect - golang.org/x/sync v0.21.0 // indirect - golang.org/x/sys v0.46.0 // indirect - golang.org/x/term v0.44.0 // indirect - golang.org/x/text v0.38.0 // indirect + golang.org/x/sync v0.22.0 // indirect + golang.org/x/sys v0.47.0 // indirect + golang.org/x/term v0.45.0 // indirect + golang.org/x/text v0.41.0 // indirect golang.org/x/time v0.15.0 // indirect - google.golang.org/api v0.287.0 // indirect - google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20260615183401-62b3387ff324 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d // indirect + google.golang.org/api v0.291.0 // indirect + google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect google.golang.org/grpc v1.83.0 // indirect google.golang.org/protobuf v1.36.11 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect - modernc.org/libc v1.73.4 // indirect + modernc.org/libc v1.74.4 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.11.0 // indirect - modernc.org/sqlite v1.53.0 // indirect + modernc.org/sqlite v1.56.0 // indirect ) diff --git a/pkg/gofr/datasource/oracle/go.sum b/pkg/gofr/datasource/oracle/go.sum index 7a71241ed7..54f057fc98 100644 --- a/pkg/gofr/datasource/oracle/go.sum +++ b/pkg/gofr/datasource/oracle/go.sum @@ -1,22 +1,22 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE= cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU= -cloud.google.com/go/auth v0.20.0 h1:kXTssoVb4azsVDoUiF8KvxAqrsQcQtB53DcSgta74CA= -cloud.google.com/go/auth v0.20.0/go.mod h1:942/yi/itH1SsmpyrbnTMDgGfdy2BUqIKyd0cyYLc5Q= +cloud.google.com/go/auth v0.22.0 h1:Xp9wAKkLoeaYb5pYZZoQGz4E9sdPxIbzS3gywZE3ciQ= +cloud.google.com/go/auth v0.22.0/go.mod h1:M9o2Oz+YI2jAfxewJgb1vyI3vceHF+eohmxyzmrl+9s= cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc= cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10= -cloud.google.com/go/iam v1.11.0 h1:KieQ9Pb+LLPak1O3Rv3GgCxhnmkYf7Xyh0P5HfF1jFM= -cloud.google.com/go/iam v1.11.0/go.mod h1:KP+nKGugNJW4LcLx1uEZcq1ok5sQHFaQehQNl4QDgV4= -cloud.google.com/go/kms v1.31.0 h1:LS8N92OxFDgOLg5NCo3OmbvjtQAIVT5gUHVLKIDHaFE= -cloud.google.com/go/kms v1.31.0/go.mod h1:YIyXZym11R5uovJJt4oN5eUL3oPmirF3yKeIh6QAf4U= -cloud.google.com/go/longrunning v1.0.0 h1:lwzWEYD8+NkYV7dhexOz6kmlvajZA70+bW/xMhRVVdY= -cloud.google.com/go/longrunning v1.0.0/go.mod h1:8nqFBPOO1U/XkhWl0I19AMZEphrHi73VNABIpKYaTwM= -cloud.google.com/go/pubsub v1.50.2 h1:54Up97HnThdP4H8jjWJSSQ/mnYG2EKon7ZSNETRq0tM= -cloud.google.com/go/pubsub v1.50.2/go.mod h1:jyCWeZdGFqd4mitSsBERnJcpqaHBsxQoPkNvjj4sp0w= -cloud.google.com/go/pubsub/v2 v2.5.1 h1:+TwXJr78P9RrMV3S8lKHIhJo2E99jI7ta65e+ujJjts= -cloud.google.com/go/pubsub/v2 v2.5.1/go.mod h1:Pd+qeabMX+576vQJhTN7TelE4k6kJh15dLU/ptOQ/UA= +cloud.google.com/go/iam v1.12.0 h1:Aki3bX9aHUDKPHfnRJfDcTdVedvy6quGBQcTqx3DRXk= +cloud.google.com/go/iam v1.12.0/go.mod h1:FEZ4lXpADAC2AIpQY7LANNjjwyQ2jK439CI2VaD+sLY= +cloud.google.com/go/kms v1.32.0 h1:s+rEluaaZKhLVjrIWG7uNBsnWbiitElzNzFGyp6+nIg= +cloud.google.com/go/kms v1.32.0/go.mod h1:CSGvW6GnMQbY+1nOHcIzhMtHSbExXlOmCKjWtYVjcpA= +cloud.google.com/go/longrunning v1.2.0 h1:WjYH3YHBGCxGJP9M4dWGHBfXr/cFIjMkNgWcJj7/iMM= +cloud.google.com/go/longrunning v1.2.0/go.mod h1:5KMQALFGOCtFoi2xSOA1u3H7WKlhmckgiyFw7+LGQp0= +cloud.google.com/go/pubsub v1.51.0 h1:XOaCejsqX7EEtUdQz+WPag66wWsUUGliyCOfGPKfo90= +cloud.google.com/go/pubsub v1.51.0/go.mod h1:NERXf11sd82UV3VnflcUj8POIyQUXT/QwrKlxD8di/I= +cloud.google.com/go/pubsub/v2 v2.6.0 h1:8pjR0id+GTB+krKx5G6AGJoYrHog58w2Q89PCOrfM64= +cloud.google.com/go/pubsub/v2 v2.6.0/go.mod h1:4anqvV/w8Pcgu2tO0qr2XgsF3GXHowzryfQ5gOnVmWY= filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo= filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= @@ -26,8 +26,8 @@ github.com/UNO-SOFT/zlog v0.8.1 h1:TEFkGJHtUfTRgMkLZiAjLSHALjwSBdw6/zByMC5GJt4= github.com/UNO-SOFT/zlog v0.8.1/go.mod h1:yqFOjn3OhvJ4j7ArJqQNA+9V+u6t9zSAyIZdWdMweWc= github.com/VictoriaMetrics/easyproto v0.1.4 h1:r8cNvo8o6sR4QShBXQd1bKw/VVLSQma/V2KhTBPf+Sc= github.com/VictoriaMetrics/easyproto v0.1.4/go.mod h1:QlGlzaJnDfFd8Lk6Ci/fuLxfTo3/GThPs2KH23mv710= -github.com/XSAM/otelsql v0.42.0 h1:Li0xF4eJUxG2e0x3D4rvRlys1f27yJKvjTh7ljkUP5o= -github.com/XSAM/otelsql v0.42.0/go.mod h1:4mOrEv+cS1KmKzrvTktvJnstr5GtKSAK+QHvFR9OcpI= +github.com/XSAM/otelsql v0.43.0 h1:ZIhXqRoMhILXQwBQoq/Dl6Taap/KEFQXZrWjYV1L8X8= +github.com/XSAM/otelsql v0.43.0/go.mod h1:DJBGBvbtwf1OCBYRTjpRFxOqi6ONpdfb+htr4ncRWuw= github.com/alicebob/miniredis/v2 v2.38.0 h1:nZAzCR+Lj+Vxk4ZXzm2NuKq2O33RXj1XxJ2e2uP9jiw= github.com/alicebob/miniredis/v2 v2.38.0/go.mod h1:TcL7YfarKPGDAthEtl5NBeHZfeUQj6OXMm/+iu5cLMM= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= @@ -45,8 +45,6 @@ github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2 h1:aBangftG7EVZoUb69Os github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2/go.mod h1:qwXFYgsP6T7XnJtbKlf1HP8AjxZZyzxMmc+Lq5GjlU4= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/eclipse/paho.mqtt.golang v1.5.1 h1:/VSOv3oDLlpqR2Epjn1Q7b2bSTplJIeV2ISgCl2W7nE= @@ -65,16 +63,16 @@ github.com/felixge/httpsnoop v1.1.0/go.mod h1:Zqxgdd+1Rkcz8euOqdr7lqgCRJztwr5hp9 github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4= github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-redis/redismock/v9 v9.2.0 h1:ZrMYQeKPECZPjOj5u9eyOjg8Nnb0BS9lkVIZ6IpsKLw= github.com/go-redis/redismock/v9 v9.2.0/go.mod h1:18KHfGDK4Y6c2R0H38EUGWAdc7ZQS9gfYxc94k7rWT0= github.com/go-sql-driver/mysql v1.10.0 h1:Q+1LV8DkHJvSYAdR83XzuhDaTykuDx0l6fkXxoWCWfw= github.com/go-sql-driver/mysql v1.10.0/go.mod h1:M+cqaI7+xxXGG9swrdeUIoPG3Y3KCkF0pZej+SK+nWk= -github.com/godror/godror v0.51.0 h1:lowQJLgaRxTpWIUK0ozB9xdVC0Ar8bdzdPM+8lHjOUc= -github.com/godror/godror v0.51.0/go.mod h1:dnzB1y3mXcHH81sFbnB2N+MXR05sL7CDiIkiaHBpwvA= +github.com/godror/godror v0.51.4 h1:YAkSW4c4zTQlnDHGmi0Q8FM9f2JWz/ufwx3qGWeAtAA= +github.com/godror/godror v0.51.4/go.mod h1:+KoBDSBRHogZIik9a3SpvH0pS7iK+G8K42YEjtunqfQ= github.com/godror/knownpb v0.3.0 h1:+caUdy8hTtl7X05aPl3tdL540TvCcaQA6woZQroLZMw= github.com/godror/knownpb v0.3.0/go.mod h1:PpTyfJwiOEAzQl7NtVCM8kdPCnp3uhxsZYIzZ5PV4zU= github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY= @@ -103,17 +101,17 @@ github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs= -github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA= +github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3 h1:LMLX+LgTNWpfvCBdFebv6EsYotImrt/Ppc5cXIriCSo= +github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3/go.mod h1:jl5iWTm0/hd5PjEYEOuwAJ57L/CibdZfrqZ5XA5GrCk= github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0= github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/enterprise-certificate-proxy v0.3.17 h1:73NfMHdiqo9JFU9+7a5ExpVa10/R29pXfZIaW559nrg= -github.com/googleapis/enterprise-certificate-proxy v0.3.17/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= -github.com/googleapis/gax-go/v2 v2.22.0 h1:PjIWBpgGIVKGoCXuiCoP64altEJCj3/Ei+kSU5vlZD4= -github.com/googleapis/gax-go/v2 v2.22.0/go.mod h1:irWBbALSr0Sk3qlqb9SyJ1h68WjgeFuiOzI4Rqw5+aY= +github.com/googleapis/enterprise-certificate-proxy v0.3.19 h1:mMOE7DN2+p76/EdIrmAy9B9bH+yC4563vmnJ34QR8i4= +github.com/googleapis/enterprise-certificate-proxy v0.3.19/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= +github.com/googleapis/gax-go/v2 v2.23.0 h1:Tchl7qkvE7Ip3y+ztvNufYFvkfqTe7NfLTYGIdJRLuE= +github.com/googleapis/gax-go/v2 v2.23.0/go.mod h1:rBQKOVJCdb8IFEzg+FCwlt1LP/xMDGuqUXhUG+XMXEg= github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= @@ -123,46 +121,40 @@ github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyf github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46/go.mod h1:yyMNCyc/Ib3bDTKd379tNMpB/7/H5TjM2Y9QJ5THLbE= -github.com/klauspost/compress v1.18.6 h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao= -github.com/klauspost/compress v1.18.6/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= +github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8= +github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE= github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/lib/pq v1.12.3 h1:tTWxr2YLKwIvK90ZXEw8GP7UFHtcbTtty8zsI+YjrfQ= github.com/lib/pq v1.12.3/go.mod h1:/p+8NSbOcwzAEI7wiMXFlgydTwcgTr3OSKMsD2BitpA= -github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= -github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI= +github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w= github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= github.com/oklog/ulid/v2 v2.0.2 h1:r4fFzBm+bv0wNKNh5eXTwU7i85y5x+uwkxCUTNVQqLc= github.com/oklog/ulid/v2 v2.0.2/go.mod h1:mtBL0Qe/0HAx6/a4Z30qxVIAL1eQDweXq5lxOEiwQ68= -github.com/pierrec/lz4/v4 v4.1.25 h1:kocOqRffaIbU5djlIBr7Wh+cx82C0vtFb0fOurZHqD0= -github.com/pierrec/lz4/v4 v4.1.25/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4= +github.com/pierrec/lz4/v4 v4.1.27 h1:+PhzhWDrjRj89TH2sw43nE3+4+W8lSxIuQadEHZyjUk= +github.com/pierrec/lz4/v4 v4.1.27/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= -github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= +github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU= +github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= -github.com/prometheus/common v0.67.5 h1:pIgK94WWlQt1WLwAC5j2ynLaBRDiinoAb86HZHTUGI4= -github.com/prometheus/common v0.67.5/go.mod h1:SjE/0MzDEEAyrdr5Gqc6G+sXI67maCxzaT3A2+HqjUw= +github.com/prometheus/common v0.70.1 h1:1HvjP4D5oL3t8RsPlwxA9onvvStjtIHYE5XuuwOi/PY= +github.com/prometheus/common v0.70.1/go.mod h1:VdFUQDMZK3VLkurFUVhia6uys/0suUp86TJz5qbJRhc= github.com/prometheus/otlptranslator v1.0.0 h1:s0LJW/iN9dkIH+EnhiD3BlkkP5QVIUVEoIwkU+A6qos= github.com/prometheus/otlptranslator v1.0.0/go.mod h1:vRYWnXvI6aWGpsdY/mOT/cbeVRBlPWtBNDb7kGR3uKM= -github.com/prometheus/procfs v0.20.1 h1:XwbrGOIplXW/AU3YhIhLODXMJYyC1isLFfYCsTEycfc= -github.com/prometheus/procfs v0.20.1/go.mod h1:o9EMBZGRyvDrSPH1RqdxhojkuXstoe4UlK79eF5TGGo= +github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI= +github.com/prometheus/procfs v0.21.1/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY= github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0 h1:jsV3tyMeJrEoc2f3EhNf7qoBW3NEZW7l/4ziT3M+OJI= github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0/go.mod h1:e5t17bY9cEpVV+xw2U7jsPOKkXBtL5IQmNVABShnHUk= github.com/redis/go-redis/extra/redisotel/v9 v9.21.0 h1:36qq3rbF2If2CP0zGHHF8o/4XDluErn6DD0c9/L2iNI= @@ -171,20 +163,18 @@ github.com/redis/go-redis/v9 v9.21.0 h1:FPBE4hhbAke+TLmcY3WkpbDffJEomdqPn3HYiqAt github.com/redis/go-redis/v9 v9.21.0/go.mod h1:v/M13XI1PVCDcm01VtPFOADfZtHf8YW3baQf57KlIkA= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/segmentio/kafka-go v0.4.51 h1:JgDPPG75tC1rWIS2Me6MwcvXJ6f49UQ4HjAOef71Hno= github.com/segmentio/kafka-go v0.4.51/go.mod h1:Y1gn60kzLEEaW28YshXyk2+VCUKbJ3Qr6DrnT3i4+9E= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c= github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI= github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY= @@ -204,24 +194,24 @@ go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 h1:0Qx7VGBacMm9ZENQ7TnNObTYI4ShC+lHI16seduaxZo= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0/go.mod h1:Sje3i3MjSPKTSPvVWCaL8ugBzJwik3u4smCjUeuupqg= -go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0 h1:MCcYL7J6Vt/X0kjqbMZkekCmwsurbQRbL69vkiye2lk= -go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0/go.mod h1:3jnStNwSufK+f5ktjL4EPcwtig4rtd81NS70lqHuXl8= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 h1:8tvICD4vSTOOsNrsI4Ljf6C+6UKvpTEH5XY3JMoyPoo= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0/go.mod h1:z9+yiacE0IHRqM4qFfkbt/JYlmYXgss8GY/jXoNuPJI= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/exporters/prometheus v0.65.0 h1:jOveH/b4lU9HT7y+Gfamf18BqlOuz2PWEvs8yM7Q6XE= -go.opentelemetry.io/otel/exporters/prometheus v0.65.0/go.mod h1:i1P8pcumauPtUI4YNopea1dhzEMuEqWP1xoUZDylLHo= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/metric/x v0.66.0 h1:YkCrx1zLOChi9ZcZ6euupOcsgzbVlec7D/xoEU1+cTA= -go.opentelemetry.io/otel/metric/x v0.66.0/go.mod h1:d1+BDj9t96do0/1LoU1ayfCv79ZgNE41qbhBvnMOBZk= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= -go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 h1:aVgLpGksz0vjoe6OynycqX8daNOAxJx5ZEhJXIXOVIU= +go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0/go.mod h1:kmJlX6WuTrAH1fOCSbPJFrSnUagB8c3SY3E87It3JD8= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 h1:LMuyCAyfalSjDyjdC65nK6N0zoTT63+E/u95X0JovZI= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0/go.mod h1:085m8qbm4hgc8rZWGDEa4vmyyo2c3nPxUslYUKUIU04= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/exporters/prometheus v0.67.0 h1:7IefDa35e6V3NoiqIeLDMDxMFyZDk5qcoC0Ax4cC16E= +go.opentelemetry.io/otel/exporters/prometheus v0.67.0/go.mod h1:nsPI1awTg5Vmg1YrommL2mVarVGlqc4yXOoKAkPRD0c= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/metric/x v0.67.0 h1:PcicCNZFkZ4bXfSooXdo3WN7RBOVOtjVdo1wD358Uns= +go.opentelemetry.io/otel/metric/x v0.67.0/go.mod h1:FBjCWZe6wgcqxcMtjdGiClDKXb2YxxXii0CXftE4QtI= +go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= +go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= +go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= +go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= @@ -230,13 +220,15 @@ go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto= -golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 h1:mgKeJMpvi0yx/sU5GsxQ7p6s2wtOnGAHZWCHUM4KGzY= golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546/go.mod h1:j/pmGrbnkbPtQfxEe5D0VQhZC6qKbfKifgD0oM7sR70= @@ -244,8 +236,8 @@ golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTk golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4= -golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ= +golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk= +golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -255,8 +247,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o= -golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= +golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= +golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= @@ -264,8 +256,8 @@ golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM= -golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= +golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek= +golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -274,19 +266,18 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw= -golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.44.0 h1:0rLvDRCtNj0gZkyIXhCyOb2OAzEhLVqc4B+hrsBhrmc= -golang.org/x/term v0.44.0/go.mod h1:7ze4MdzUzLXpSAoFP1H0bOI9aXDqveSvatT5vKcFh2Y= +golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= +golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= -golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE= -golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -296,25 +287,25 @@ golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3 golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8= -golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0= +golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE= +golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/api v0.287.0 h1:CQDMqUiqZZ0U/Yge3zyjAhNQ0OSYEH0PaA7l4xtEen4= -google.golang.org/api v0.287.0/go.mod h1:pPW85yt3Iuc3unkpaMhFtMmOqnTdCwCqEOaUlnuxRlQ= +google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= +google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= -google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94 h1:YJjbgu+dkp5kUJLfpMyCLfBIWZb/FcJyuLeo1gVBOuo= -google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94/go.mod h1:RRHjglSYABVCWpQ7USCpdfhcd9t4PkajvVwyynZizTc= -google.golang.org/genproto/googleapis/api v0.0.0-20260615183401-62b3387ff324 h1:g0RAkxK/smSu/iRwC/KIX1mwUoVJtk2OjbgaeS4DmUM= -google.golang.org/genproto/googleapis/api v0.0.0-20260615183401-62b3387ff324/go.mod h1:Z4WJ5pJOYWFWcHEQUelD5QaZDknIQkpIL/+fyJOT9+A= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d h1:mpAgMyM9vQHxycBlDq50y1VHpfSfVwzXvrQKtYbXuUY= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd h1:0GnSESHqea5EoaQgJyYxC3o5m0L191gCQdDgo2cxO5I= +google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= @@ -334,27 +325,24 @@ google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlba google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -modernc.org/cc/v4 v4.28.4 h1:Hd/4Es+MBj+/7hSdZaisNyu6bv3V0Dp2MdllyfqaH+c= -modernc.org/cc/v4 v4.28.4/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= -modernc.org/ccgo/v4 v4.34.4 h1:OVnSOWQjVKOYkFxoHYB+qQmSHK5gqMqARM+K9DpR/Ws= -modernc.org/ccgo/v4 v4.34.4/go.mod h1:qdKqE8FNIYyysougB1RX9MxCzp5oJOcQXSobANJ4TuE= +modernc.org/cc/v4 v4.29.1 h1:MKgdCV3WykTSPqpVrnxdEDS0HEd2FHpKZDzxzU5LyeI= +modernc.org/cc/v4 v4.29.1/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= +modernc.org/ccgo/v4 v4.34.6 h1:sBgfIwyN0TQ9C5hwIeuqyeAKyMWnbvj2fvpF4L11uzU= +modernc.org/ccgo/v4 v4.34.6/go.mod h1:SZ8YcN9NG7XVsQYdm6jYBvi8PQP1qi+kqB6OhjqI3Fk= modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM= modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU= modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI= modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito= -modernc.org/gc/v3 v3.1.3 h1:6QAplYyVO+KdPW3pGnqmJDUxtkec8ooEWvks/hhU3lc= -modernc.org/gc/v3 v3.1.3/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= +modernc.org/gc/v3 v3.1.4 h1:2g65LGVSmFQrXeITAw97x7hCRvZFcyE1uDP+7Vng7JI= +modernc.org/gc/v3 v3.1.4/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks= modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI= -modernc.org/libc v1.73.4 h1:+ra4Ui8ngyt8HDcO1FTDPWlkAh6yOdaO2yAoh8MddQA= -modernc.org/libc v1.73.4/go.mod h1:DXZ3eO8qMCNn2SnmTNCiC71nJ9Rcq3PsnpU6Vc4rWK8= +modernc.org/libc v1.74.4 h1:fX1Omw4o2/1C2iRkkIsrQTasJQldLhRmuPreXLoWs9k= +modernc.org/libc v1.74.4/go.mod h1:eeQAS9W3sZeKYMFubydxJpII9ybHWshk+7or7bLG9co= modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI= @@ -363,8 +351,8 @@ modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg= modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE= -modernc.org/sqlite v1.53.0 h1:20WG8N9q4ji/dEqGk4uiI0c6OPjSeLTNYGFCc3+7c1M= -modernc.org/sqlite v1.53.0/go.mod h1:xoEpOIpGrgT48H5iiyt/YXPCZPEzlfmfFwtk8Lklw8s= +modernc.org/sqlite v1.56.0 h1:/D8e2RfFqoy/Zc6PuC76U28zFwmI/sYx1Kjm4yEn9e0= +modernc.org/sqlite v1.56.0/go.mod h1:yCJ2cmAaIkHQ25oXWrF8H4O1lIfPYPR26yCEDj2P3pQ= modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= diff --git a/pkg/gofr/datasource/pubsub/eventhub/go.mod b/pkg/gofr/datasource/pubsub/eventhub/go.mod index ce9bc46166..5baf7e6786 100644 --- a/pkg/gofr/datasource/pubsub/eventhub/go.mod +++ b/pkg/gofr/datasource/pubsub/eventhub/go.mod @@ -3,13 +3,13 @@ module gofr.dev/pkg/gofr/datasource/pubsub/eventhub go 1.26.0 require ( - github.com/Azure/azure-sdk-for-go/sdk/azcore v1.22.0 + github.com/Azure/azure-sdk-for-go/sdk/azcore v1.23.0 github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs v1.4.0 github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.8.0 github.com/coder/websocket v1.8.15 - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 ) @@ -18,16 +18,15 @@ require ( github.com/Azure/azure-sdk-for-go/sdk/internal v1.12.0 // indirect github.com/Azure/go-amqp v1.4.0 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/golang/mock v1.7.0-rc.1 // indirect github.com/joho/godotenv v1.5.1 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - golang.org/x/net v0.56.0 // indirect - golang.org/x/text v0.38.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/crypto v0.55.0 // indirect + golang.org/x/net v0.57.0 // indirect + golang.org/x/text v0.41.0 // indirect ) diff --git a/pkg/gofr/datasource/pubsub/eventhub/go.sum b/pkg/gofr/datasource/pubsub/eventhub/go.sum index bed7873d13..4ac1e362e5 100644 --- a/pkg/gofr/datasource/pubsub/eventhub/go.sum +++ b/pkg/gofr/datasource/pubsub/eventhub/go.sum @@ -1,5 +1,5 @@ -github.com/Azure/azure-sdk-for-go/sdk/azcore v1.22.0 h1:aokoqcHvaGjiM3VpjKDfMMnF/8epJ+Q1HLJ7CudztqE= -github.com/Azure/azure-sdk-for-go/sdk/azcore v1.22.0/go.mod h1:/WYEx9pcM9Y+Dd/APJaNlSvVSvzl54rrMdZT5+Oi2LM= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.23.0 h1:4gRPBpN1f6xt88yi4WR26m7XaD9OlWtVT6bWPdGUIok= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.23.0/go.mod h1:G7QVLxw1j1JVyrO1MA95S8m8HStaaleDZYTcfGgjB2o= github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1 h1:Hk5QBxZQC1jb2Fwj6mpzme37xbCDdNTxU7O9eb5+LB4= github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1/go.mod h1:IYus9qsFobWIc2YVwe/WPjcnyCkPKtnHAqUYeebc8z0= github.com/Azure/azure-sdk-for-go/sdk/internal v1.12.0 h1:fhqpLE3UEXi9lPaBRpQ6XuRW0nU7hgg4zlmZZa+a9q4= @@ -20,13 +20,11 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UF github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/coder/websocket v1.8.15 h1:6B2JPeOGlpff2Uz6vOEH1Vzpi0iUz20A+lPVhPHtNUA= github.com/coder/websocket v1.8.15/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw= github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY= @@ -39,45 +37,39 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto= -golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o= -golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= +golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= +golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -85,24 +77,19 @@ golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw= -golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.44.0 h1:0rLvDRCtNj0gZkyIXhCyOb2OAzEhLVqc4B+hrsBhrmc= -golang.org/x/term v0.44.0/go.mod h1:7ze4MdzUzLXpSAoFP1H0bOI9aXDqveSvatT5vKcFh2Y= +golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= +golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE= -golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.1.8/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/datasource/pubsub/nats/go.mod b/pkg/gofr/datasource/pubsub/nats/go.mod index 5229895be8..0d75484b3f 100644 --- a/pkg/gofr/datasource/pubsub/nats/go.mod +++ b/pkg/gofr/datasource/pubsub/nats/go.mod @@ -4,11 +4,11 @@ go 1.26.0 require ( github.com/nats-io/nats-server/v2 v2.14.5 - github.com/nats-io/nats.go v1.52.0 - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/sdk v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/nats-io/nats.go v1.53.1 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/sdk v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 ) @@ -16,8 +16,7 @@ require ( require ( github.com/antithesishq/antithesis-sdk-go v0.7.2-default-no-op // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/google/go-tpm v0.9.8 // indirect github.com/google/uuid v1.6.0 // indirect @@ -28,12 +27,11 @@ require ( github.com/nats-io/nkeys v0.4.16 // indirect github.com/nats-io/nuid v1.0.1 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/crypto v0.55.0 // indirect golang.org/x/sys v0.47.0 // indirect golang.org/x/term v0.45.0 // indirect golang.org/x/time v0.15.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/pkg/gofr/datasource/pubsub/nats/go.sum b/pkg/gofr/datasource/pubsub/nats/go.sum index e72dd2d362..c67c58fee8 100644 --- a/pkg/gofr/datasource/pubsub/nats/go.sum +++ b/pkg/gofr/datasource/pubsub/nats/go.sum @@ -2,11 +2,9 @@ github.com/antithesishq/antithesis-sdk-go v0.7.2-default-no-op h1:p2zFsAzvhIpFya github.com/antithesishq/antithesis-sdk-go v0.7.2-default-no-op/go.mod h1:FQyySiasQQM8735Ddel3MRojmy4dA1IqCeyJ5jmPMbI= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= @@ -19,46 +17,40 @@ github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8= github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/minio/highwayhash v1.0.4 h1:asJizugGgchQod2ja9NJlGOWq4s7KsAWr5XUc9Clgl4= github.com/minio/highwayhash v1.0.4/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ= github.com/nats-io/jwt/v2 v2.8.2 h1:XXRgB60MSTnqsRwejQurVDs/hcv2dkt+86GjI+I/bMc= github.com/nats-io/jwt/v2 v2.8.2/go.mod h1:Ag/56sq9OblL4JgdYufDd16Egb17Kr/8WwwuO/forVc= github.com/nats-io/nats-server/v2 v2.14.5 h1:M6yeo/Xb7khi97RSEVELof3DForDqmYza3P4tHCPFWw= github.com/nats-io/nats-server/v2 v2.14.5/go.mod h1:1D3iocrisKvWaD1B/imqarTqmaGrWMqALMLbEDo3v7Q= -github.com/nats-io/nats.go v1.52.0 h1:n3avV4VBsCgsdwh71TppsTwtv+QdPs7ntSKM8qJLGsc= -github.com/nats-io/nats.go v1.52.0/go.mod h1:26HypzazeOkyO3/mqd1zZd53STJN0EjCYF9Uy2ZOBno= +github.com/nats-io/nats.go v1.53.1 h1:Otsq3uLc/kLdjmkNHkXH0jBqwUquwdKFoe3fq6/3/Xo= +github.com/nats-io/nats.go v1.53.1/go.mod h1:26HypzazeOkyO3/mqd1zZd53STJN0EjCYF9Uy2ZOBno= github.com/nats-io/nkeys v0.4.16 h1:rd5oAuLOb8mnAycB0xleuEBNS1pVVnN0fv/FF34Eypg= github.com/nats-io/nkeys v0.4.16/go.mod h1:llLgWoI0o4z/Q57q2R1kHfmocyhGV6VG/U18Glg1Afs= github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw= github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= -go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= +go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= +go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= +go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= @@ -70,8 +62,3 @@ golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/datasource/pubsub/sqs/go.mod b/pkg/gofr/datasource/pubsub/sqs/go.mod index 05256595d2..2e9562b5fa 100644 --- a/pkg/gofr/datasource/pubsub/sqs/go.mod +++ b/pkg/gofr/datasource/pubsub/sqs/go.mod @@ -6,11 +6,11 @@ require ( github.com/aws/aws-sdk-go-v2 v1.43.6 github.com/aws/aws-sdk-go-v2/config v1.32.37 github.com/aws/aws-sdk-go-v2/credentials v1.19.36 - github.com/aws/aws-sdk-go-v2/service/sqs v1.45.1 - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/sdk v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/aws/aws-sdk-go-v2/service/sqs v1.46.6 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/sdk v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 gofr.dev v1.57.0 ) @@ -27,16 +27,14 @@ require ( github.com/aws/aws-sdk-go-v2/service/sts v1.45.6 // indirect github.com/aws/smithy-go v1.27.8 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/google/uuid v1.6.0 // indirect github.com/joho/godotenv v1.5.1 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/sys v0.47.0 // indirect golang.org/x/term v0.45.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/pkg/gofr/datasource/pubsub/sqs/go.sum b/pkg/gofr/datasource/pubsub/sqs/go.sum index f89d0421d4..28a1ad4df2 100644 --- a/pkg/gofr/datasource/pubsub/sqs/go.sum +++ b/pkg/gofr/datasource/pubsub/sqs/go.sum @@ -18,8 +18,8 @@ github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37 h1:a3D4AjrO github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37/go.mod h1:ky0gTu+ukvUTuUKFIpp6Wid4oninrkCyvbFkVs0kpHM= github.com/aws/aws-sdk-go-v2/service/signin v1.5.6 h1:i68sFvXidKlkiSvI7d7Ilc1/UvW4CtBOaivH7jhG4fs= github.com/aws/aws-sdk-go-v2/service/signin v1.5.6/go.mod h1:/h7Obr9WTtzbjTHGASRQwLN7Bupw+TC3x8x7fyx39hE= -github.com/aws/aws-sdk-go-v2/service/sqs v1.45.1 h1:J4/Py6AKAWeaLqQnvQ8L9fq3AQsVgpuGCQ7D8rDDMBg= -github.com/aws/aws-sdk-go-v2/service/sqs v1.45.1/go.mod h1:JISE0m3JPVhirZEVIAUyK4C62n87tU4BZmUa9Ozc2to= +github.com/aws/aws-sdk-go-v2/service/sqs v1.46.6 h1:OQf7U6UgDnByANgeCIJjnC71LRrpuKt2gNa3Pth996s= +github.com/aws/aws-sdk-go-v2/service/sqs v1.46.6/go.mod h1:cPDi+P56aAfYJVwVocZmiiVf8dJR1hSzPz/nqsV/b00= github.com/aws/aws-sdk-go-v2/service/sso v1.33.6 h1:tpfGChmjUmv3W9WlRvy+stwKDTbFFdq8Zk9DbFPrfMU= github.com/aws/aws-sdk-go-v2/service/sso v1.33.6/go.mod h1:CSjiDzmG/lsKkTOYjbkM+duLmRlW+LOxD64Na44ijnI= github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.6 h1:49BBtY68A+KJCQ3a2F3eUe6ROsKucxUdfHKoqorc0wI= @@ -30,11 +30,9 @@ github.com/aws/smithy-go v1.27.8 h1:FR0dxZfIlV7Z8eh2iHfIofdunw382XsDV3Mxt9nUvRY= github.com/aws/smithy-go v1.27.8/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= @@ -43,40 +41,29 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= -go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= +go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= +go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= +go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/datasource/scylladb/go.mod b/pkg/gofr/datasource/scylladb/go.mod index 35ca5b7567..01cd783842 100644 --- a/pkg/gofr/datasource/scylladb/go.mod +++ b/pkg/gofr/datasource/scylladb/go.mod @@ -5,21 +5,18 @@ go 1.26.0 require ( github.com/gocql/gocql v1.7.0 github.com/stoewer/go-strcase v1.3.1 - github.com/stretchr/testify v1.11.1 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + github.com/stretchr/testify v1.12.1 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 ) require ( github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/golang/snappy v1.0.0 // indirect github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed // indirect github.com/kr/pretty v0.3.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/rogpeppe/go-internal v1.14.1 // indirect - gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect gopkg.in/inf.v0 v0.9.1 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/pkg/gofr/datasource/scylladb/go.sum b/pkg/gofr/datasource/scylladb/go.sum index 6b6215a088..8f2b9c4e8f 100644 --- a/pkg/gofr/datasource/scylladb/go.sum +++ b/pkg/gofr/datasource/scylladb/go.sum @@ -7,8 +7,6 @@ github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XL github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/gocql/gocql v1.7.0 h1:O+7U7/1gSN7QTEAaMEsJc1Oq2QHXvCWoF3DFK9HDHus= github.com/gocql/gocql v1.7.0/go.mod h1:vnlvXyFZeLBF0Wy+RS8hrOdbn0UWsWtdg07XJnFxZ+4= github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= @@ -19,7 +17,6 @@ github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed h1:5upAirOpQc1Q53c0bnx2ufif5kANL7bfZWcc6VJWJd8= github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed/go.mod h1:tMWxXQ9wFIaZeTI9F+hmhFiGpFmhOHzyShyFUhRm0H4= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= -github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= @@ -28,8 +25,6 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= @@ -42,19 +37,18 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/datasource/solr/go.mod b/pkg/gofr/datasource/solr/go.mod index e247268604..8b4a084d0d 100644 --- a/pkg/gofr/datasource/solr/go.mod +++ b/pkg/gofr/datasource/solr/go.mod @@ -3,7 +3,7 @@ module gofr.dev/pkg/gofr/datasource/solr go 1.26.0 require ( - github.com/stretchr/testify v1.11.1 + github.com/stretchr/testify v1.12.1 go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 go.opentelemetry.io/otel v1.45.0 go.opentelemetry.io/otel/trace v1.45.0 @@ -12,11 +12,9 @@ require ( require ( github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect go.opentelemetry.io/otel/metric v1.45.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect ) diff --git a/pkg/gofr/datasource/solr/go.sum b/pkg/gofr/datasource/solr/go.sum index aca6ada8c3..306244c0a1 100644 --- a/pkg/gofr/datasource/solr/go.sum +++ b/pkg/gofr/datasource/solr/go.sum @@ -1,7 +1,5 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/felixge/httpsnoop v1.1.0 h1:3YtUj32ZZkqZtt3sZZsClsymw/QDuVfpNhoA31zeORc= github.com/felixge/httpsnoop v1.1.0/go.mod h1:Zqxgdd+1Rkcz8euOqdr7lqgCRJztwr5hp9vDSi5UZCE= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= @@ -13,16 +11,8 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 h1:aVgLpGksz0vjoe6OynycqX8daNOAxJx5ZEhJXIXOVIU= @@ -41,10 +31,7 @@ go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOy go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/datasource/surrealdb/go.mod b/pkg/gofr/datasource/surrealdb/go.mod index 3ac8f9dd66..41d4209576 100644 --- a/pkg/gofr/datasource/surrealdb/go.mod +++ b/pkg/gofr/datasource/surrealdb/go.mod @@ -3,26 +3,24 @@ module gofr.dev/pkg/gofr/datasource/surrealdb go 1.26.0 require ( - github.com/stretchr/testify v1.11.1 + github.com/stretchr/testify v1.12.1 github.com/surrealdb/surrealdb.go v1.6.0 - go.opentelemetry.io/otel v1.44.0 - go.opentelemetry.io/otel/trace v1.44.0 + go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 ) require ( github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/fxamacker/cbor/v2 v2.9.2 // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/gofrs/uuid v4.4.0+incompatible // indirect github.com/golang-jwt/jwt/v5 v5.3.1 // indirect github.com/gorilla/websocket v1.5.3 // indirect - github.com/klauspost/compress v1.18.6 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect + github.com/klauspost/compress v1.19.2 // indirect github.com/x448/float16 v0.8.4 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect ) diff --git a/pkg/gofr/datasource/surrealdb/go.sum b/pkg/gofr/datasource/surrealdb/go.sum index b4a136d512..1c10dc0a68 100644 --- a/pkg/gofr/datasource/surrealdb/go.sum +++ b/pkg/gofr/datasource/surrealdb/go.sum @@ -1,14 +1,12 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dolthub/maphash v0.1.0 h1:bsQ7JsF4FkkWyrP3oCnFJgrCUAFbFf3kOl4L/QxPDyQ= github.com/dolthub/maphash v0.1.0/go.mod h1:gkg4Ch4CdCDu5h6PMriVLawB7koZ+5ijb9puGMV50a4= github.com/fxamacker/cbor/v2 v2.9.2 h1:X4Ksno9+x3cz0TZv69ec1hxP/+tymuR8PXQJyDwfh78= github.com/fxamacker/cbor/v2 v2.9.2/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA= @@ -19,36 +17,25 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/klauspost/compress v1.18.6 h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao= -github.com/klauspost/compress v1.18.6/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8= +github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= github.com/lxzan/gws v1.8.9 h1:VU3SGUeWlQrEwfUSfokcZep8mdg/BrUF+y73YYshdBM= github.com/lxzan/gws v1.8.9/go.mod h1:d9yHaR1eDTBHagQC6KY7ycUOaz5KWeqQtP3xu7aMK8Y= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/surrealdb/surrealdb.go v1.6.0 h1:x88b/W0gDQN7FAtHRsBTEcHLr8UBKNV0uo2MjNKR52s= github.com/surrealdb/surrealdb.go v1.6.0/go.mod h1:mKSZxow8ZN2tkR2p/fWzjIbinRFXWOGCOpfIdiYYZzc= github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM= github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= From 82a8f8762d9018e4029207cb146133d2b9b77ad2 Mon Sep 17 00:00:00 2001 From: Ronan Donnelly Date: Mon, 7 Sep 2026 05:17:49 +0100 Subject: [PATCH 09/48] fix(tools): require a path separator in the framework route check (#4102) Co-authored-by: Umang Mundhra Co-authored-by: Aryan Mehrotra --- pkg/gofr/tools.go | 2 +- pkg/gofr/tools_test.go | 32 ++++++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+), 1 deletion(-) create mode 100644 pkg/gofr/tools_test.go diff --git a/pkg/gofr/tools.go b/pkg/gofr/tools.go index 53a3763fa5..cdfcb1846b 100644 --- a/pkg/gofr/tools.go +++ b/pkg/gofr/tools.go @@ -330,7 +330,7 @@ func splitArgs(pathTemplate string, fields map[string]json.RawMessage, // isFrameworkRoute reports whether a route is registered by the framework itself (health/liveness // probes, the favicon) rather than the application, so it is never exposed as an agent tool. func isFrameworkRoute(pathTemplate string) bool { - return pathTemplate == "/favicon.ico" || strings.HasPrefix(pathTemplate, "/.well-known") + return pathTemplate == "/favicon.ico" || pathTemplate == "/.well-known" || strings.HasPrefix(pathTemplate, "/.well-known/") } // safePathSegment reports whether a value is a single path segment safe to substitute into a route: diff --git a/pkg/gofr/tools_test.go b/pkg/gofr/tools_test.go new file mode 100644 index 0000000000..0539550bb6 --- /dev/null +++ b/pkg/gofr/tools_test.go @@ -0,0 +1,32 @@ +package gofr + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func Test_isFrameworkRoute(t *testing.T) { + tests := []struct { + desc string + pathTemplate string + resp bool + }{ + {"empty path", "", false}, + {"application route", "/sample", false}, + {"favicon", "/favicon.ico", true}, + {"well-known root", "/.well-known", true}, + {"alive endpoint", "/.well-known/alive", true}, + {"health endpoint", "/.well-known/health", true}, + {"swagger endpoint", "/.well-known/swagger", true}, + {"prefixed route without separator", "/.well-knownstuff", false}, + {"prefixed route with sub path", "/.well-knownstuff/data", false}, + {"well-known not at the start of the path", "/api/.well-known/alive", false}, + } + + for i, tc := range tests { + resp := isFrameworkRoute(tc.pathTemplate) + + assert.Equal(t, tc.resp, resp, "TEST[%d], Failed.\n%s", i, tc.desc) + } +} From 434a20738e5b721bcabf522d65baa540253cd492 Mon Sep 17 00:00:00 2001 From: Yash Israni <118755067+yashisrani@users.noreply.github.com> Date: Mon, 7 Sep 2026 10:25:00 +0530 Subject: [PATCH 10/48] perf(container): run health checks concurrently, and collapse concurrent probes (#3496) --- docs/references/configs/page.md | 11 + pkg/gofr/container/container.go | 6 + pkg/gofr/container/health.go | 369 +++++++++-- pkg/gofr/container/health_concurrency_test.go | 580 ++++++++++++++++++ pkg/gofr/container/health_config.go | 56 ++ pkg/gofr/container/health_probe.go | 125 ++++ pkg/gofr/container/health_probe_test.go | 140 +++++ pkg/gofr/datasource/health.go | 3 + pkg/gofr/health.go | 5 +- 9 files changed, 1229 insertions(+), 66 deletions(-) create mode 100644 pkg/gofr/container/health_concurrency_test.go create mode 100644 pkg/gofr/container/health_config.go create mode 100644 pkg/gofr/container/health_probe.go create mode 100644 pkg/gofr/container/health_probe_test.go diff --git a/docs/references/configs/page.md b/docs/references/configs/page.md index cabe947a2a..8a734b1c00 100644 --- a/docs/references/configs/page.md +++ b/docs/references/configs/page.md @@ -192,6 +192,17 @@ This document lists all the configuration options supported by the GoFr framewor - Enable gRPC server reflection - false +--- + +- HEALTH_CACHE_TTL +- How long a health result may be served without re-checking the backends, as a duration (`5s`, `10s`, `1m`). Unset, `0` or `disabled` turns caching off, which is the default: within a TTL a recovered backend still reports DOWN and a failed one still reports UP, so it is a trade to opt into rather than inherit. +- disabled + +--- + +- HEALTH_CHECK_TIMEOUT +- Upper bound on one round of health checks, as a duration (`2s`). Backends that have not answered by then are left out of the response and the aggregate status is DEGRADED. A check that is still running when the round is abandoned keeps running, so a probe arriving before it finishes reports DEGRADED with no per-dependency detail rather than starting a second round against the same unresponsive backend. Unset or `0` means the round is bounded only by each backend client's own timeout. +- disabled {% /table %} diff --git a/pkg/gofr/container/container.go b/pkg/gofr/container/container.go index 5db2b0963e..032c3149b5 100644 --- a/pkg/gofr/container/container.go +++ b/pkg/gofr/container/container.go @@ -91,6 +91,10 @@ type Container struct { llms map[string]ai.LLM // instrumented models by name ("" = default); a mock sets the default directly llmModels map[string]ai.Model // raw providers by name, for uninstrumented health probes tools ai.Tools // set by app.EnableMCP so ctx.LLM().Tools() exposes the service's own handlers + + // health carries the health endpoint's TTL cache, its singleflight and its timeout. It is a + // pointer because Container is copied by value by injectContainer; see healthProbe. + health *healthProbe } func NewContainer(conf config.Config) *Container { @@ -156,6 +160,8 @@ func (c *Container) Create(conf config.Config) { c.File = file.NewLocalFileSystem(c.Logger) c.WSManager = websocket.New() + + c.health = newHealthProbe(c.healthDuration(conf, healthCacheTTLKey), c.healthDuration(conf, healthCheckTimeoutKey)) } func (c *Container) createPubSub(conf config.Config) { diff --git a/pkg/gofr/container/health.go b/pkg/gofr/container/health.go index 488ee244c7..15d098d25a 100644 --- a/pkg/gofr/container/health.go +++ b/pkg/gofr/container/health.go @@ -2,102 +2,330 @@ package container import ( "context" + "fmt" "reflect" + "sync" + "time" + + "gofr.dev/pkg/gofr/datasource" +) + +// Keys under which each backend reports into the health map. They are the field names of the +// health response body, so renaming one breaks every consumer parsing it. +const ( + sqlKey = "sql" + redisKey = "redis" + pubsubKey = "pubsub" + llmKey = "llm" + + mongoKey = "mongo" + cassandraKey = "cassandra" + clickHouseKey = "clickHouse" + kvStoreKey = "kv-store" + dgraphKey = "dgraph" + openTSDBKey = "opentsdb" + elasticsearchKey = "elasticsearch" + oracleKey = "oracle" + couchbaseKey = "couchbase" + influxKey = "influx" ) +// aggregateKeyCount is how many keys appHealth adds on top of the per-backend ones: name and +// version. Only the snapshot buffer size depends on it. +const aggregateKeyCount = 2 + +// errorDetailKey is the key under which a health detail carries its failure reason, matching the +// spelling datasources already use in their own Health details. +const errorDetailKey = "error" + +// healthSingleflightKey names the single in-flight round of checks. There is only ever one, so the +// key is a constant; it exists only because singleflight is keyed by design. +const healthSingleflightKey = "health" + +// Health probes every configured backend and returns the aggregate as a map[string]any. +// +// The checks run concurrently, so the call takes as long as the slowest backend rather than the sum +// of all of them. Concurrent calls are collapsed into one round of checks, so probe traffic cannot +// stampede a slow backend, and the result is cached for HEALTH_CACHE_TTL when that is configured. +// +// The returned map is a fresh one, so adding, removing or replacing keys cannot disturb the cached +// result or another caller holding it. The values inside are shared, not copied — reading them is +// safe from any number of callers, writing through one is not, and nothing in GoFr does. func (c *Container) Health(ctx context.Context) any { - var ( - healthMap = make(map[string]any) - downCount int - ) + if c.health == nil { + // A Container built without Create — a zero value, or a test double — has no cache and no + // singleflight to share. The checks themselves still run, unbounded, as they always have, + // and WithoutCancel keeps a disconnecting caller from turning them into a partial result. + healthMap, _ := c.runHealthChecks(context.WithoutCancel(ctx), 0) - const statusDown = "DOWN" + return healthMap + } - if !isNil(c.SQL) { - health := c.SQL.HealthCheck() - if health.Status == statusDown { - downCount++ + if cached, ok := c.health.get(); ok { + return cloneHealth(cached) + } + + // context.WithoutCancel: one round of checks is shared by every caller waiting on the + // singleflight, so whichever caller happens to lead must not cancel the work the others are + // waiting on by disconnecting. Values — trace and correlation ids — still propagate. + res, _, _ := c.health.group.Do(healthSingleflightKey, func() (any, error) { + if cached, ok := c.health.get(); ok { + return cached, nil } - healthMap["sql"] = health - } + if !c.health.beginRound() { + // A previous round timed out and its checks are still running against a backend that + // has not answered. Report that rather than piling a second set of checks onto it. + return c.stalledHealth(), nil + } - if !isNil(c.Redis) { - health := c.Redis.HealthCheck() - if health.Status == statusDown { - downCount++ + healthMap, complete := c.runHealthChecks(context.WithoutCancel(ctx), c.health.timeout) + + // A partial result is never cached: the backends that did not answer are unknown, not healthy. + if complete { + c.health.set(healthMap) } - healthMap["redis"] = health + return healthMap, nil + }) + + healthMap, _ := res.(map[string]any) + + return cloneHealth(healthMap) +} + +// runHealthChecks fans out to every configured backend and waits for them. It reports whether every +// check finished; a false means the timeout elapsed first and the map holds only what had been +// recorded by then. +// +// It releases the round claim that Health took with beginRound — split deliberately, because only +// this function knows when the abandoned checks are done, and releasing at the timeout is what the +// guard exists to prevent. The one other caller, Health's no-probe path, has a nil probe, so the +// release is a no-op there rather than a claim it never took. +func (c *Container) runHealthChecks(ctx context.Context, timeout time.Duration) (healthMap map[string]any, complete bool) { + if timeout > 0 { + var cancel context.CancelFunc + + ctx, cancel = context.WithTimeout(ctx, timeout) + defer cancel() } - if c.PubSub != nil { - health := c.PubSub.Health() - if health.Status == statusDown { - downCount++ - } + collector := &healthCollector{results: make(map[string]any)} - healthMap["pubsub"] = health + var wg sync.WaitGroup + + c.checkPrimaryDatasources(ctx, collector, &wg) + c.checkExternalDatasources(ctx, collector, &wg) + c.checkServices(ctx, collector, &wg) + + complete, finished := waitForChecks(ctx, &wg) + + if complete { + c.health.endRound() + } else { + // The abandoned checks are still writing into the collector, so the round is not over even + // though this caller is done with it. Release it only once they finish, which is what keeps + // the next probe from starting a second set against the same hung backend. This rides the + // waiter waitForChecks already started rather than blocking on the same WaitGroup twice. + go func() { + <-finished + c.health.endRound() + }() } - for name, model := range c.llmModels { - health := model.HealthCheck(ctx) - if health.Status == statusDown { - downCount++ - } + healthMap, downCount := collector.snapshot() - key := "llm" - if name != "" { - key = "llm_" + name + if !complete { + // The backends that did not answer count as one aggregate failure, so the app reports + // DEGRADED rather than a confident UP built out of a partial map. + downCount++ + + if c.Logger != nil { + c.Logger.Warnf("health check timed out after %s, reporting %d of the configured backends", + timeout, len(healthMap)) } + } + + c.appHealth(healthMap, downCount) - healthMap[key] = health + return healthMap, complete +} + +// waitForChecks blocks until every check has finished or until ctx is done, and reports which of the +// two happened. Checks still outstanding at a timeout are abandoned rather than canceled: the +// health methods of SQL, Redis and PubSub take no context, so there is nothing to cancel them with. +// They keep writing into the collector afterwards, which is why only a snapshot ever leaves it. +// On a timeout it also returns a channel closed when those abandoned checks eventually do finish, +// so the caller can release the round claim then rather than starting a second goroutine of its own +// to wait for the same WaitGroup. It is nil whenever there is nothing left to wait for. +func waitForChecks(ctx context.Context, wg *sync.WaitGroup) (complete bool, finished <-chan struct{}) { + if ctx.Done() == nil { + // Nothing can interrupt this round, which is the case whenever no timeout is configured — + // the default. Wait for it directly rather than making the common path pay for a goroutine + // and a channel that only the timeout path can use. + wg.Wait() + + return true, nil } - downCount += checkExternalDBHealth(ctx, c, healthMap) + done := make(chan struct{}) - for name, svc := range c.Services { - health := svc.HealthCheck(ctx) - if health.Status == statusDown { - downCount++ - } + go func() { + wg.Wait() + close(done) + }() - healthMap[name] = health + select { + case <-done: + return true, nil + case <-ctx.Done(): + return false, done } +} - c.appHealth(healthMap, downCount) +func (c *Container) checkPrimaryDatasources(ctx context.Context, collector *healthCollector, wg *sync.WaitGroup) { + if !isNil(c.SQL) { + runCheck(wg, collector, sqlKey, func() { + health := c.SQL.HealthCheck() + collector.record(sqlKey, health, health.Status == datasource.StatusDown) + }) + } - return healthMap + if !isNil(c.Redis) { + runCheck(wg, collector, redisKey, func() { + health := c.Redis.HealthCheck() + collector.record(redisKey, health, health.Status == datasource.StatusDown) + }) + } + + if c.PubSub != nil { + runCheck(wg, collector, pubsubKey, func() { + health := c.PubSub.Health() + collector.record(pubsubKey, health, health.Status == datasource.StatusDown) + }) + } + + for name, model := range c.llmModels { + key := llmKey + if name != "" { + key = llmKey + "_" + name + } + + runCheck(wg, collector, key, func() { + health := model.HealthCheck(ctx) + collector.record(key, health, health.Status == datasource.StatusDown) + }) + } } -func checkExternalDBHealth(ctx context.Context, c *Container, healthMap map[string]any) (downCount int) { - services := map[string]interface { +func (c *Container) checkExternalDatasources(ctx context.Context, collector *healthCollector, wg *sync.WaitGroup) { + datasources := map[string]interface { HealthCheck(context.Context) (any, error) }{ - "mongo": c.Mongo, - "cassandra": c.Cassandra, - "clickHouse": c.Clickhouse, - "kv-store": c.KVStore, - "dgraph": c.DGraph, - "opentsdb": c.OpenTSDB, - "elasticsearch": c.Elasticsearch, - "oracle": c.Oracle, - "couchbase": c.Couchbase, - "influx": c.InfluxDB, - } - - for name, service := range services { - if !isNil(service) { - health, err := service.HealthCheck(ctx) - if err != nil { - downCount++ - } + mongoKey: c.Mongo, + cassandraKey: c.Cassandra, + clickHouseKey: c.Clickhouse, + kvStoreKey: c.KVStore, + dgraphKey: c.DGraph, + openTSDBKey: c.OpenTSDB, + elasticsearchKey: c.Elasticsearch, + oracleKey: c.Oracle, + couchbaseKey: c.Couchbase, + influxKey: c.InfluxDB, + } - healthMap[name] = health + for name, ds := range datasources { + if isNil(ds) { + continue } + + runCheck(wg, collector, name, func() { + health, err := ds.HealthCheck(ctx) + collector.record(name, health, err != nil) + }) + } +} + +func (c *Container) checkServices(ctx context.Context, collector *healthCollector, wg *sync.WaitGroup) { + for name, svc := range c.Services { + runCheck(wg, collector, name, func() { + health := svc.HealthCheck(ctx) + collector.record(name, health, health.Status == datasource.StatusDown) + }) } +} + +// runCheck runs one backend check on its own goroutine, registered with wg. +// +// The recover is load-bearing, not defensive habit. When these checks ran inline they were under +// the panic-recovery middleware of whichever handler called Health, so a driver that panicked cost +// one request; from a goroutine of our own the same panic takes the process down with it. A backend +// that panics is reported DOWN, which is what it is. +func runCheck(wg *sync.WaitGroup, collector *healthCollector, name string, check func()) { + wg.Add(1) + + go func() { + defer wg.Done() + + defer func() { + if r := recover(); r != nil { + collector.record(name, datasource.Health{ + Status: datasource.StatusDown, + Details: map[string]any{errorDetailKey: fmt.Sprintf("health check panicked: %v", r)}, + }, true) + } + }() - return downCount + check() + }() +} + +// healthCollector gathers the results of the concurrent checks. Everything is guarded by mu because +// a check abandoned at a timeout keeps writing here after the caller has taken its snapshot. +type healthCollector struct { + mu sync.Mutex + results map[string]any + downCount int +} + +func (h *healthCollector) record(name string, result any, down bool) { + h.mu.Lock() + defer h.mu.Unlock() + + h.results[name] = result + + if down { + h.downCount++ + } +} + +// snapshot copies what has been recorded so far. The copy is what leaves the collector; the +// collector's own map stays private to whichever checks are still writing into it. +func (h *healthCollector) snapshot() (results map[string]any, downCount int) { + h.mu.Lock() + defer h.mu.Unlock() + + results = make(map[string]any, len(h.results)+aggregateKeyCount) + for name, result := range h.results { + results[name] = result + } + + return results, h.downCount +} + +// cloneHealth copies the health map so that neither the cached result nor a result shared between +// singleflight waiters can be re-keyed by one caller underneath another. +// +// The copy is one level deep, which is the level that matters: the map is what a caller is liable to +// add to. The values stay shared — some are pointers, and each datasource decides its own type, so +// copying them would mean a type switch that silently stops copying whatever is added next. +func cloneHealth(healthMap map[string]any) map[string]any { + out := make(map[string]any, len(healthMap)) + for name, result := range healthMap { + out[name] = result + } + + return out } // appHealth writes the aggregate keys onto the map. The "status" key is read back out by @@ -108,9 +336,9 @@ func (c *Container) appHealth(healthMap map[string]any, downCount int) { healthMap["version"] = c.GetAppVersion() if downCount == 0 { - healthMap["status"] = "UP" + healthMap["status"] = datasource.StatusUp } else { - healthMap["status"] = "DEGRADED" + healthMap["status"] = datasource.StatusDegraded } } @@ -121,3 +349,16 @@ func isNil(i any) bool { // If the interface is not assigned or is nil, return true return !val.IsValid() || val.IsNil() } + +// stalledHealth is the body returned while a previous round's checks are still outstanding. It +// carries no per-backend keys: what those backends are doing is exactly what is unknown, and +// reporting the last round's values would present stale results as fresh ones. +func (c *Container) stalledHealth() map[string]any { + healthMap := make(map[string]any, aggregateKeyCount+1) + + // downCount is 1 rather than 0 so the aggregate is DEGRADED: the app is serving, but at least + // one dependency has not answered within the timeout. + c.appHealth(healthMap, 1) + + return healthMap +} diff --git a/pkg/gofr/container/health_concurrency_test.go b/pkg/gofr/container/health_concurrency_test.go new file mode 100644 index 0000000000..5475f45938 --- /dev/null +++ b/pkg/gofr/container/health_concurrency_test.go @@ -0,0 +1,580 @@ +package container + +import ( + "context" + "net/http" + "net/http/httptest" + "runtime" + "sync" + "sync/atomic" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" + + "gofr.dev/pkg/gofr/ai" + "gofr.dev/pkg/gofr/datasource" + "gofr.dev/pkg/gofr/logging" + "gofr.dev/pkg/gofr/service" +) + +// barrierTimeout bounds how long a check waits at the barrier. It only elapses when the checks are +// not actually concurrent, which is the failure the barrier exists to catch. +const barrierTimeout = 5 * time.Second + +// checkBarrier releases only once n checks are inside it at the same moment. A sequential +// implementation can never assemble n of them, so the barrier times out and the test reports it +// rather than hanging the suite. +// +// It proves concurrency by construction, which a wall-clock upper bound does not: a loaded CI box +// makes this assertion easier to satisfy, never harder. +type checkBarrier struct { + pending atomic.Int64 + release chan struct{} + timedOut atomic.Bool +} + +func newCheckBarrier(n int) *checkBarrier { + b := &checkBarrier{release: make(chan struct{})} + b.pending.Store(int64(n)) + + return b +} + +func (b *checkBarrier) arrive() { + if b.pending.Add(-1) == 0 { + close(b.release) + } + + select { + case <-b.release: + case <-time.After(barrierTimeout): + b.timedOut.Store(true) + } +} + +// expectHealthyBackends sets an UP expectation on every backend a mock container carries. hook runs +// inside the Redis, PubSub and Mongo checks — one from each of the three fan-out groups — so a test +// can observe those three running together. +// +// The SQL mock queues its health results, pops one per call and asserts at cleanup that the queue +// came out empty, so rounds must be exactly the number of check rounds the test performs. +func expectHealthyBackends(mocks *Mocks, rounds int, hook func()) { + up := datasource.Health{Status: datasource.StatusUp} + + for range rounds { + mocks.SQL.ExpectHealthCheck().WillReturnHealthCheck(&datasource.Health{Status: datasource.StatusUp}) + } + + mocks.Redis.EXPECT().HealthCheck().DoAndReturn(func() datasource.Health { + hook() + + return up + }).AnyTimes() + + mocks.PubSub.EXPECT().Health().DoAndReturn(func() datasource.Health { + hook() + + return up + }).AnyTimes() + + mocks.Mongo.EXPECT().HealthCheck(gomock.Any()).DoAndReturn(func(context.Context) (any, error) { + hook() + + return up, nil + }).AnyTimes() + + mocks.Cassandra.EXPECT().HealthCheck(gomock.Any()).Return(up, nil).AnyTimes() + mocks.Clickhouse.EXPECT().HealthCheck(gomock.Any()).Return(up, nil).AnyTimes() + mocks.Oracle.EXPECT().HealthCheck(gomock.Any()).Return(up, nil).AnyTimes() + mocks.KVStore.EXPECT().HealthCheck(gomock.Any()).Return(up, nil).AnyTimes() + mocks.DGraph.EXPECT().HealthCheck(gomock.Any()).Return(up, nil).AnyTimes() + mocks.OpenTSDB.EXPECT().HealthCheck(gomock.Any()).Return(up, nil).AnyTimes() + mocks.Elasticsearch.EXPECT().HealthCheck(gomock.Any()).Return(up, nil).AnyTimes() + mocks.Couchbase.EXPECT().HealthCheck(gomock.Any()).Return(up, nil).AnyTimes() +} + +// The point of the change: checks from all three fan-out groups are in flight at once. Sequential +// execution cannot fill the barrier and the test says so. +func TestContainer_Health_ChecksRunConcurrently(t *testing.T) { + c, mocks := NewMockContainer(t) + c.appName, c.appVersion = "test-app", "test" + + barrier := newCheckBarrier(3) + expectHealthyBackends(mocks, 1, barrier.arrive) + + result, ok := c.Health(t.Context()).(map[string]any) + require.True(t, ok) + + assert.False(t, barrier.timedOut.Load(), + "redis, pubsub and mongo never ran at the same time — the checks are still sequential") + assert.Equal(t, datasource.StatusUp, result["status"]) +} + +// Concurrent probes must collapse into one round of checks, so a slow backend cannot be stampeded +// by probe traffic. This is what the cache alone does not give: it only helps after a round has +// already finished. +func TestContainer_Health_CollapsesConcurrentCalls(t *testing.T) { + const callers = 8 + + c, mocks := NewMockContainer(t) + c.appName, c.appVersion = "test-app", "test" + c.health = newHealthProbe(0, 0) // caching off, so only the singleflight can collapse these + + // The SQL mock queues a fixed number of results and panics past the end. Dropping it keeps a + // failure here reported as the round count it is, rather than as a nil dereference. + c.SQL = nil + + var ( + rounds atomic.Int64 + entered atomic.Int64 + ) + + // The leading round holds until every caller has entered Health and had a moment to reach the + // singleflight, so a straggler cannot start a second round for reasons of scheduling. + expectHealthyBackends(mocks, 0, func() { + if rounds.Add(1) != 1 { + return + } + + deadline := time.Now().Add(barrierTimeout) + for entered.Load() < callers && time.Now().Before(deadline) { + time.Sleep(time.Millisecond) + } + + time.Sleep(50 * time.Millisecond) + }) + + var wg sync.WaitGroup + + results := make([]map[string]any, callers) + + for i := range callers { + wg.Add(1) + + go func() { + defer wg.Done() + + entered.Add(1) + + results[i], _ = c.Health(t.Context()).(map[string]any) + }() + } + + wg.Wait() + + // Three hooked backends, one round each. + assert.Equal(t, int64(3), rounds.Load(), "%d concurrent calls ran more than one round of checks", callers) + + for i, result := range results { + assert.Equal(t, datasource.StatusUp, result["status"], "caller %d got no result", i) + } +} + +// Every caller must get its own map. Handing out the cached one lets any consumer mutate what the +// next caller reads, and race the reader while doing it. +func TestContainer_Health_ReturnsIndependentCopies(t *testing.T) { + c, mocks := NewMockContainer(t) + c.appName, c.appVersion = "test-app", "test" + c.health = newHealthProbe(time.Minute, 0) + + expectHealthyBackends(mocks, 1, func() {}) + + first, ok := c.Health(t.Context()).(map[string]any) + require.True(t, ok) + + first["status"] = "TAMPERED" + delete(first, "redis") + + second, ok := c.Health(t.Context()).(map[string]any) + require.True(t, ok) + + assert.Equal(t, datasource.StatusUp, second["status"], "a caller mutated the cached result") + assert.Contains(t, second, "redis", "a caller deleted a key from the cached result") +} + +// A cache hit must not touch the backends at all. +func TestContainer_Health_ServesFromCacheWithinTTL(t *testing.T) { + c, mocks := NewMockContainer(t) + c.appName, c.appVersion = "test-app", "test" + c.health = newHealthProbe(time.Minute, 0) + + var checks atomic.Int64 + + expectHealthyBackends(mocks, 1, func() { checks.Add(1) }) + + for range 5 { + result, ok := c.Health(t.Context()).(map[string]any) + require.True(t, ok) + assert.Equal(t, datasource.StatusUp, result["status"]) + } + + assert.Equal(t, int64(3), checks.Load(), "the cache did not spare the backends on repeat calls") +} + +// An expired entry must fall through to a fresh round rather than being served forever. +func TestContainer_Health_RechecksAfterTTL(t *testing.T) { + c, mocks := NewMockContainer(t) + c.appName, c.appVersion = "test-app", "test" + c.health = newHealthProbe(time.Minute, 0) + + var checks atomic.Int64 + + expectHealthyBackends(mocks, 2, func() { checks.Add(1) }) + + c.Health(t.Context()) + + // Age the entry past its TTL instead of waiting one out. + c.health.mu.Lock() + c.health.storedAt = time.Now().Add(-time.Hour) + c.health.mu.Unlock() + + c.Health(t.Context()) + + assert.Equal(t, int64(6), checks.Load(), "an expired entry was served instead of re-checking") +} + +// Caching is off unless configured, so an upgrade never silently starts serving a stale body. +func TestContainer_Health_NotCachedByDefault(t *testing.T) { + c, mocks := NewMockContainer(t) + c.appName, c.appVersion = "test-app", "test" + c.health = newHealthProbe( + c.healthDuration(healthConfig{}, healthCacheTTLKey), + c.healthDuration(healthConfig{}, healthCheckTimeoutKey), + ) + + var checks atomic.Int64 + + expectHealthyBackends(mocks, 2, func() { checks.Add(1) }) + + c.Health(t.Context()) + c.Health(t.Context()) + + assert.Equal(t, int64(6), checks.Load(), "health was cached without HEALTH_CACHE_TTL being set") +} + +// A Container that never went through Create has no probe. The checks still have to run. +func TestContainer_Health_WithoutProbe(t *testing.T) { + c, mocks := NewMockContainer(t) + c.appName, c.appVersion = "test-app", "test" + + require.Nil(t, c.health, "NewMockContainer is expected to leave the probe unset") + + expectHealthyBackends(mocks, 1, func() {}) + + result, ok := c.Health(t.Context()).(map[string]any) + require.True(t, ok) + + assert.Equal(t, datasource.StatusUp, result["status"]) + assert.Contains(t, result, "redis") +} + +// HEALTH_CHECK_TIMEOUT bounds one round. What did not answer is missing from the body, and the +// aggregate is DEGRADED rather than a confident UP built out of a partial map. +func TestContainer_Health_TimesOutSlowBackend(t *testing.T) { + released := make(chan struct{}) + + slow := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + <-released + w.WriteHeader(http.StatusOK) + })) + + // Close releases the handler first, so the abandoned check finishes before the server goes. + t.Cleanup(func() { + close(released) + slow.Close() + }) + + logger := logging.NewMockLogger(logging.ERROR) + + c := &Container{ + Logger: logger, + appName: "test-app", + appVersion: "test", + health: newHealthProbe(time.Minute, 50*time.Millisecond), + Services: map[string]service.HTTP{ + "slow-service": service.NewHTTPService(slow.URL, logger, nil), + }, + } + + result, ok := c.Health(t.Context()).(map[string]any) + require.True(t, ok) + + assert.Equal(t, datasource.StatusDegraded, result["status"], "a timed-out round must not report UP") + assert.NotContains(t, result, "slow-service", "a backend that never answered must not appear") + + _, cached := c.health.get() + assert.False(t, cached, "a partial result must never be cached") +} + +// With no timeout configured the round is bounded only by each backend client's own timeout, which +// is how GoFr has always behaved. +func TestContainer_Health_NoTimeoutByDefault(t *testing.T) { + c, mocks := NewMockContainer(t) + c.appName, c.appVersion = "test-app", "test" + c.health = newHealthProbe(0, 0) + + expectHealthyBackends(mocks, 1, func() { time.Sleep(100 * time.Millisecond) }) + + result, ok := c.Health(t.Context()).(map[string]any) + require.True(t, ok) + + assert.Equal(t, datasource.StatusUp, result["status"], "a slow but successful round was cut short") + assert.Contains(t, result, "redis") +} + +// A caller disconnecting must not cancel the round of checks — the other waiters on the +// singleflight are sharing it, and even alone a half-finished map is worse than a slow one. Both +// paths through Health have to hold to that, including the one without a probe. +func TestContainer_Health_SurvivesCallerCancellation(t *testing.T) { + tests := []struct { + desc string + probe *healthProbe + }{ + {"with a probe", newHealthProbe(0, 0)}, + {"without a probe", nil}, + } + + for _, tc := range tests { + t.Run(tc.desc, func(t *testing.T) { + c, mocks := NewMockContainer(t) + c.appName, c.appVersion = "test-app", "test" + c.health = tc.probe + + ctx, cancel := context.WithCancel(t.Context()) + + // The calling request goes away while the round is still running. + expectHealthyBackends(mocks, 1, cancel) + + result, ok := c.Health(ctx).(map[string]any) + require.True(t, ok) + + assert.Equal(t, datasource.StatusUp, result["status"], + "canceling the calling request aborted the round of checks") + assert.Contains(t, result, "mongo", + "a context-aware check was canceled by the caller going away") + }) + } +} + +// Models added with AddLLM report alongside the datasources: the default under "llm", a named one +// under "llm_". A model that is down degrades the aggregate like any other dependency. +func TestContainer_Health_IncludesLLMModels(t *testing.T) { + tests := []struct { + desc string + status string + expected string + }{ + {"a healthy model", datasource.StatusUp, datasource.StatusUp}, + {"a model that is down", datasource.StatusDown, datasource.StatusDegraded}, + } + + for _, tc := range tests { + t.Run(tc.desc, func(t *testing.T) { + c, mocks := NewMockContainer(t) + c.appName, c.appVersion = "test-app", "test" + + ctrl := gomock.NewController(t) + + defaultModel := ai.NewMockModel(ctrl) + defaultModel.EXPECT().HealthCheck(gomock.Any()).Return(datasource.Health{Status: tc.status}) + + namedModel := ai.NewMockModel(ctrl) + namedModel.EXPECT().HealthCheck(gomock.Any()).Return(datasource.Health{Status: datasource.StatusUp}) + + c.llmModels = map[string]ai.Model{"": defaultModel, "claude": namedModel} + + expectHealthyBackends(mocks, 1, func() {}) + + result, ok := c.Health(t.Context()).(map[string]any) + require.True(t, ok) + + assert.Equal(t, datasource.Health{Status: tc.status}, result[llmKey]) + assert.Equal(t, datasource.Health{Status: datasource.StatusUp}, result["llm_claude"]) + assert.Equal(t, tc.expected, result["status"]) + }) + } +} + +// panicHTTPService is a service.HTTP whose health check panics, standing in for a driver that +// panics on a malformed response or a nil dependency. +type panicHTTPService struct { + service.HTTP +} + +func (*panicHTTPService) HealthCheck(context.Context) *service.Health { + panic("boom") +} + +// A panicking backend used to be contained by the handler's panic-recovery middleware, because the +// checks ran inline on the request goroutine. Running them concurrently moved them out from under +// it, where the same panic takes the process down instead of one request. +func TestContainer_Health_PanickingBackendIsReportedDown(t *testing.T) { + c := &Container{ + Logger: logging.NewMockLogger(logging.ERROR), + appName: "test-app", + appVersion: "test", + health: newHealthProbe(0, 0), + Services: map[string]service.HTTP{ + "panicking-service": &panicHTTPService{}, + }, + } + + // The assertion is as much that this line is reached at all: without the recover the panic + // unwinds a goroutine of ours and the test binary dies rather than failing. + result, ok := c.Health(t.Context()).(map[string]any) + require.True(t, ok) + + assert.Equal(t, datasource.StatusDegraded, result["status"], "a panicking backend must not report UP") + + reported, ok := result["panicking-service"].(datasource.Health) + require.True(t, ok, "the panicking backend must still appear in the body") + assert.Equal(t, datasource.StatusDown, reported.Status) + assert.Contains(t, reported.Details["error"], "panicked") +} + +// After a timeout the outstanding checks are abandoned rather than canceled, so they are still +// running when the next probe arrives. That probe must not start a second set against the same +// unanswering backend: under Kubernetes probe traffic that is one more leaked goroutine every +// probe interval, for as long as the backend stays hung. +func TestContainer_Health_DoesNotStackRoundsAfterTimeout(t *testing.T) { + var started atomic.Int64 + + released := make(chan struct{}) + + hung := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + started.Add(1) + <-released + w.WriteHeader(http.StatusOK) + })) + + t.Cleanup(func() { + close(released) + hung.Close() + }) + + logger := logging.NewMockLogger(logging.ERROR) + + c := &Container{ + Logger: logger, + appName: "test-app", + appVersion: "test", + health: newHealthProbe(0, 50*time.Millisecond), + Services: map[string]service.HTTP{ + "hung-service": service.NewHTTPService(hung.URL, logger, nil), + }, + } + + // Several sequential probes, each of which times out. Sequential rather than concurrent on + // purpose: singleflight already collapses concurrent callers, so only separate rounds can + // expose the stacking. + const probes = 4 + + for range probes { + result, ok := c.Health(t.Context()).(map[string]any) + require.True(t, ok) + assert.Equal(t, datasource.StatusDegraded, result["status"]) + } + + assert.Equal(t, int64(1), started.Load(), + "each probe started another check against a backend that had not answered the first") +} + +// The in-flight guard must not be a one-way door. Once the abandoned checks finally answer, the +// claim is released and the next probe runs a fresh round — otherwise a single slow backend would +// pin the endpoint to DEGRADED for the life of the process. +func TestContainer_Health_RecoversAfterHungBackendAnswers(t *testing.T) { + release := make(chan struct{}) + + var calls atomic.Int64 + + hung := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + calls.Add(1) + <-release + w.WriteHeader(http.StatusOK) + })) + t.Cleanup(hung.Close) + + logger := logging.NewMockLogger(logging.ERROR) + + c := &Container{ + Logger: logger, + appName: "test-app", + appVersion: "test", + health: newHealthProbe(0, 50*time.Millisecond), + Services: map[string]service.HTTP{ + "hung": service.NewHTTPService(hung.URL, logger, nil), + }, + } + + for i := range 3 { + m, ok := c.Health(t.Context()).(map[string]any) + require.True(t, ok) + require.Equal(t, datasource.StatusDegraded, m["status"], "probe %d while the backend hung", i) + } + + require.Equal(t, int64(1), calls.Load(), "rounds stacked while the backend was hung") + + close(release) + + require.Eventually(t, func() bool { + m, ok := c.Health(t.Context()).(map[string]any) + + return ok && m["status"] == datasource.StatusUp + }, 10*time.Second, 50*time.Millisecond, + "health never recovered after the hung backend answered — the round claim leaked") +} + +// The point of the in-flight guard is that goroutines do not accumulate. Counting them directly is +// the only assertion that actually proves it: the round count could stay at one while each timed-out +// round still left a waiter behind. +func TestContainer_Health_TimeoutsDoNotAccumulateGoroutines(t *testing.T) { + release := make(chan struct{}) + + hung := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + <-release + w.WriteHeader(http.StatusOK) + })) + + t.Cleanup(func() { + close(release) + hung.Close() + }) + + logger := logging.NewMockLogger(logging.ERROR) + + c := &Container{ + Logger: logger, + appName: "test-app", + appVersion: "test", + health: newHealthProbe(0, 20*time.Millisecond), + Services: map[string]service.HTTP{ + "hung": service.NewHTTPService(hung.URL, logger, nil), + }, + } + + // One probe first, so the goroutines a single timed-out round legitimately keeps — the + // abandoned check and the waiter that releases the claim — are already in the baseline. + _ = c.Health(t.Context()) + + time.Sleep(50 * time.Millisecond) + + baseline := runtime.NumGoroutine() + + for range 25 { + _ = c.Health(t.Context()) + } + + time.Sleep(50 * time.Millisecond) + + growth := runtime.NumGoroutine() - baseline + + // Without the guard each probe leaves behind its own check plus a waiter, so 25 probes grow + // the count by roughly 50. A couple of goroutines of slack absorbs the runtime's own churn. + assert.LessOrEqual(t, growth, 5, + "25 timed-out probes grew the goroutine count by %d; rounds are accumulating", growth) + + t.Logf("25 timed-out probes: goroutine growth %d (baseline %d)", growth, baseline) +} diff --git a/pkg/gofr/container/health_config.go b/pkg/gofr/container/health_config.go new file mode 100644 index 0000000000..85d4f9173c --- /dev/null +++ b/pkg/gofr/container/health_config.go @@ -0,0 +1,56 @@ +package container + +import ( + "strings" + "time" + + "gofr.dev/pkg/gofr/config" +) + +const ( + // healthCacheTTLKey configures how long a health result may be served without re-checking the + // backends. Unset means no caching, so upgrading GoFr never silently starts serving a stale + // health body; 5s is the value to set for a service whose probes outpace its backends. + healthCacheTTLKey = "HEALTH_CACHE_TTL" + + // healthCheckTimeoutKey bounds one round of checks. Unset means the round is bounded only by + // each backend client's own timeout, which is how GoFr has always behaved. + healthCheckTimeoutKey = "HEALTH_CHECK_TIMEOUT" +) + +// healthDuration reads one of the health duration settings. Both default to disabled, so anything +// that is not a usable positive duration -- unset, "0", "disabled", unparsable, or negative -- +// turns the feature off. The two malformed cases are logged, because they are almost always a typo +// in a config file rather than an intent to disable. +func (c *Container) healthDuration(conf config.Config, key string) time.Duration { + value := strings.TrimSpace(conf.Get(key)) + + if value == "" || value == "0" || strings.EqualFold(value, "disabled") { + return 0 + } + + d, err := time.ParseDuration(value) + if err != nil { + c.logHealthConfigWarningf("invalid %s value %q, disabling it", key, value) + + return 0 + } + + if d < 0 { + c.logHealthConfigWarningf("negative %s value %q, disabling it", key, value) + + return 0 + } + + return d +} + +// logHealthConfigWarning tolerates a nil Logger: healthDuration is reachable from a Container built +// in a test without one. +func (c *Container) logHealthConfigWarningf(format string, args ...any) { + if c.Logger == nil { + return + } + + c.Logger.Warnf(format, args...) +} diff --git a/pkg/gofr/container/health_probe.go b/pkg/gofr/container/health_probe.go new file mode 100644 index 0000000000..0ba89a1fe6 --- /dev/null +++ b/pkg/gofr/container/health_probe.go @@ -0,0 +1,125 @@ +package container + +import ( + "sync" + "time" + + "golang.org/x/sync/singleflight" +) + +// healthProbe owns everything the health endpoint needs beyond the datasources themselves: the TTL +// cache, the singleflight that collapses concurrent probes into one round of checks, and the bound +// on how long that round may take. +// +// It hangs off Container behind a pointer deliberately, and every method tolerates a nil receiver. +// Container is copied by value on a supported path — injectContainer in package gofr sets a +// container.Container field on a user's gRPC server struct — so a mutex may not live in Container +// itself, and a Container built without Create has no probe at all. +// +// Caching is off unless HEALTH_CACHE_TTL is set. Serving a health body up to a TTL old is a trade an +// operator opts into: inside that window a recovered backend still reports DOWN, and one that has +// just failed still reports UP. +type healthProbe struct { + // Set once by newHealthProbe and never written again, so get and set read ttl before taking + // the lock. Making the TTL reloadable at runtime means moving it below and locking those reads. + group singleflight.Group + timeout time.Duration + ttl time.Duration + + // Guarded by mu. + mu sync.RWMutex + result map[string]any + storedAt time.Time + running bool +} + +// beginRound reports whether a fresh round of checks may start, and claims the round if so. +// +// It returns false only after a timeout: the leader abandons the outstanding checks rather than +// canceling them — SQL, Redis and PubSub health methods take no context — and singleflight +// releases its key as soon as that leader returns. Without this guard the next probe would start a +// second set of goroutines against the same unanswering backend, and under Kubernetes probe traffic +// that is one more leaked goroutine every probe interval, indefinitely. +func (p *healthProbe) beginRound() bool { + if p == nil { + return true + } + + p.mu.Lock() + defer p.mu.Unlock() + + if p.running { + return false + } + + p.running = true + + return true +} + +// endRound releases the claim taken by beginRound. After a timeout it must not be called until the +// abandoned checks have actually finished, or the guard would let a second set start anyway. +func (p *healthProbe) endRound() { + if p == nil { + return + } + + p.mu.Lock() + defer p.mu.Unlock() + + p.running = false +} + +// newHealthProbe returns a probe with the given cache TTL and per-round timeout. Zero disables +// either one; a disabled cache is a working cache that never hits, not an absent one. +func newHealthProbe(ttl, timeout time.Duration) *healthProbe { + if ttl < 0 { + ttl = 0 + } + + if timeout < 0 { + timeout = 0 + } + + return &healthProbe{ttl: ttl, timeout: timeout} +} + +// get returns the stored map itself rather than a copy. Container.Health is its only caller and +// clones before the result leaves the package; nothing else may read from it. +func (p *healthProbe) get() (map[string]any, bool) { + if p == nil || p.ttl == 0 { + return nil, false + } + + p.mu.RLock() + defer p.mu.RUnlock() + + if p.result == nil || time.Since(p.storedAt) > p.ttl { + return nil, false + } + + return p.result, true +} + +func (p *healthProbe) set(result map[string]any) { + if p == nil || p.ttl == 0 { + return + } + + p.mu.Lock() + defer p.mu.Unlock() + + p.result = result + p.storedAt = time.Now() +} + +func (p *healthProbe) clear() { + if p == nil { + return + } + + p.mu.Lock() + defer p.mu.Unlock() + + p.result = nil +} diff --git a/pkg/gofr/container/health_probe_test.go b/pkg/gofr/container/health_probe_test.go new file mode 100644 index 0000000000..54f0b7fbb0 --- /dev/null +++ b/pkg/gofr/container/health_probe_test.go @@ -0,0 +1,140 @@ +package container + +import ( + "testing" + "time" + + "github.com/stretchr/testify/assert" + + "gofr.dev/pkg/gofr/logging" +) + +// healthConfig is a config.Config that only knows about the keys a test hands it. +type healthConfig map[string]string + +func (h healthConfig) Get(key string) string { return h[key] } + +func (h healthConfig) GetOrDefault(key, defaultVal string) string { + if v, ok := h[key]; ok && v != "" { + return v + } + + return defaultVal +} + +func TestHealthProbe_CachesWithinTTL(t *testing.T) { + p := newHealthProbe(time.Minute, 0) + + _, ok := p.get() + assert.False(t, ok, "an empty cache must miss") + + p.set(map[string]any{"status": "UP"}) + + got, ok := p.get() + assert.True(t, ok, "a cache set within the TTL must hit") + assert.Equal(t, map[string]any{"status": "UP"}, got) +} + +func TestHealthProbe_ExpiresAfterTTL(t *testing.T) { + p := newHealthProbe(20*time.Millisecond, 0) + + p.set(map[string]any{"status": "UP"}) + + // Reach past the TTL by rewriting the timestamp rather than sleeping: the test then asserts + // the expiry rule itself and cannot flake on a loaded machine. + p.mu.Lock() + p.storedAt = time.Now().Add(-time.Second) + p.mu.Unlock() + + _, ok := p.get() + assert.False(t, ok, "a result older than the TTL must miss") +} + +func TestHealthProbe_ZeroTTLNeverCaches(t *testing.T) { + p := newHealthProbe(0, 0) + + p.set(map[string]any{"status": "UP"}) + + _, ok := p.get() + assert.False(t, ok, "a disabled cache must never hit, and set must be a no-op") +} + +func TestHealthProbe_NegativeTTLIsDisabled(t *testing.T) { + p := newHealthProbe(-time.Second, -time.Second) + + assert.Equal(t, time.Duration(0), p.ttl, "a negative TTL disables the cache") + assert.Equal(t, time.Duration(0), p.timeout, "a negative timeout disables the bound") +} + +func TestHealthProbe_Clear(t *testing.T) { + p := newHealthProbe(time.Minute, 0) + + p.set(map[string]any{"status": "UP"}) + p.clear() + + _, ok := p.get() + assert.False(t, ok, "a cleared cache must miss") +} + +// A Container built without Create has no probe at all, so every method has to survive a nil +// receiver rather than the caller having to check. +func TestHealthProbe_NilReceiver(t *testing.T) { + var p *healthProbe + + assert.NotPanics(t, func() { + _, ok := p.get() + assert.False(t, ok) + + p.set(map[string]any{"status": "UP"}) + p.clear() + }) +} + +func TestContainer_healthDuration(t *testing.T) { + tests := []struct { + desc string + value string + expected time.Duration + }{ + {"unset", "", 0}, + {"explicit zero", "0", 0}, + {"disabled keyword", "disabled", 0}, + {"disabled keyword, any case", "DiSaBlEd", 0}, + {"surrounding whitespace", " 10s ", 10 * time.Second}, + {"a valid duration", "5s", 5 * time.Second}, + {"sub-second", "250ms", 250 * time.Millisecond}, + {"unparsable falls back to disabled", "soon", 0}, + {"negative falls back to disabled", "-1s", 0}, + } + + c := &Container{Logger: logging.NewMockLogger(logging.ERROR)} + + for _, tc := range tests { + t.Run(tc.desc, func(t *testing.T) { + got := c.healthDuration(healthConfig{healthCacheTTLKey: tc.value}, healthCacheTTLKey) + + assert.Equal(t, tc.expected, got) + }) + } +} + +// healthDuration is reachable from a Container that never got a Logger, so it must not assume one. +func TestContainer_healthDuration_NoLogger(t *testing.T) { + c := &Container{} + + assert.NotPanics(t, func() { + assert.Equal(t, time.Duration(0), c.healthDuration(healthConfig{healthCacheTTLKey: "nonsense"}, healthCacheTTLKey)) + }) +} + +func TestContainer_Create_WiresHealthProbe(t *testing.T) { + c := &Container{Logger: logging.NewMockLogger(logging.ERROR)} + + c.health = newHealthProbe( + c.healthDuration(healthConfig{healthCacheTTLKey: "7s"}, healthCacheTTLKey), + c.healthDuration(healthConfig{healthCheckTimeoutKey: "2s"}, healthCheckTimeoutKey), + ) + + assert.Equal(t, 7*time.Second, c.health.ttl) + assert.Equal(t, 2*time.Second, c.health.timeout) +} diff --git a/pkg/gofr/datasource/health.go b/pkg/gofr/datasource/health.go index 11bd4f5fac..f509cdd039 100644 --- a/pkg/gofr/datasource/health.go +++ b/pkg/gofr/datasource/health.go @@ -3,6 +3,9 @@ package datasource const ( StatusUp = "UP" StatusDown = "DOWN" + // StatusDegraded is the aggregate an application reports when it is itself serving but at + // least one of its dependencies is down. It is never the status of an individual datasource. + StatusDegraded = "DEGRADED" ) type Health struct { diff --git a/pkg/gofr/health.go b/pkg/gofr/health.go index 0f1c71243f..257ec32c70 100644 --- a/pkg/gofr/health.go +++ b/pkg/gofr/health.go @@ -22,8 +22,9 @@ func healthHandler(c *Context) (any, error) { // unreachable case where the aggregate key is missing or not a string. // // This stays unexported here rather than being a method on Container: Context embeds -// *container.Container, so an exported method would be promoted onto every handler's ctx, and -// Health does no caching — a per-request call would sweep every datasource in the hot path. +// *container.Container, so an exported method would be promoted onto every handler's ctx, and a +// per-request call sweeps every datasource unless HEALTH_CACHE_TTL is set, which it is not by +// default. func aggregateStatus(c *Context) string { const statusDown = "DOWN" From 9b9698fe1592e85c189b559e8a9b7d006f41a486 Mon Sep 17 00:00:00 2001 From: Sujan Vulasala <154114096+SujanVulasala@users.noreply.github.com> Date: Mon, 7 Sep 2026 10:48:31 +0530 Subject: [PATCH 11/48] feat(mqtt): add span links for pub/sub tracing (#3595) --- .../using-publisher-subscriber/page.md | 10 +- pkg/gofr/datasource/pubsub/mqtt/helper.go | 21 +- pkg/gofr/datasource/pubsub/mqtt/mqtt.go | 24 ++- pkg/gofr/datasource/pubsub/mqtt/mqtt_test.go | 55 ++--- pkg/gofr/datasource/pubsub/mqtt/tracing.go | 80 +++++++ .../datasource/pubsub/mqtt/tracing_test.go | 200 ++++++++++++++++++ 6 files changed, 335 insertions(+), 55 deletions(-) create mode 100644 pkg/gofr/datasource/pubsub/mqtt/tracing.go create mode 100644 pkg/gofr/datasource/pubsub/mqtt/tracing_test.go diff --git a/docs/advanced-guide/using-publisher-subscriber/page.md b/docs/advanced-guide/using-publisher-subscriber/page.md index 7459a87994..51f8c107e0 100644 --- a/docs/advanced-guide/using-publisher-subscriber/page.md +++ b/docs/advanced-guide/using-publisher-subscriber/page.md @@ -823,7 +823,7 @@ func order(ctx *gofr.Context) (any, error) { ## Distributed Tracing -GoFr automatically traces every publish and subscribe call across Kafka, NATS JetStream, Google Pub/Sub, and Amazon SQS. **No user code is required**: as long as `TRACE_EXPORTER` is configured (see {% new-tab-link newtab=false title="Observability → Tracing" href="/docs/quick-start/observability#tracing" /%}), the framework wires everything in. +GoFr automatically traces every publish and subscribe call across Kafka, NATS JetStream, Google Pub/Sub, Amazon SQS and MQTT. **No user code is required**: as long as `TRACE_EXPORTER` is configured (see {% new-tab-link newtab=false title="Observability → Tracing" href="/docs/quick-start/observability#tracing" /%}), the framework wires everything in. ### How it works @@ -848,6 +848,14 @@ The result is that an end-to-end flow such as `HTTP → publish → subscribe [notification-service ] kafka-subscribe child of order-service's publish [+1 link] ``` +### MQTT + +MQTT is traced too, but it cannot join the two ends into one trace, and the difference is worth knowing before you go looking for a broken exporter. + +The backends above all have a slot on the wire for the W3C `traceparent` — Kafka and NATS headers, SQS and Google Pub/Sub message attributes. An MQTT 3.1.1 PUBLISH packet has only a topic, a QoS, a retain flag and a payload, and `paho.mqtt.golang` (the client GoFr uses) does not implement MQTT 5 user properties. There is nowhere to put it. Carrying it in the payload instead would corrupt the message for every non-GoFr subscriber on the topic, so GoFr does not. + +So `mqtt-publish` and `mqtt-subscribe` each carry `SpanKind`, `messaging.system`, `messaging.destination.name` and `messaging.operation` exactly as the others do, and each sits in the trace of the request that called it — but the consumer span links to no producer, and the two are separate traces. To follow a message across an MQTT broker, correlate on your own message identifier at the application level. + ### Sampling and scale GoFr's tracer uses `ParentBased(TraceIDRatioBased(TRACER_RATIO))` (see `pkg/gofr/otel.go`). Because the consumer span inherits the producer's sampling decision, head-based sampling via `TRACER_RATIO` is consistent across the entire chain — if the producer is sampled out, every downstream consumer span is dropped at creation as well. diff --git a/pkg/gofr/datasource/pubsub/mqtt/helper.go b/pkg/gofr/datasource/pubsub/mqtt/helper.go index c0f83ed293..07c9f09d6d 100644 --- a/pkg/gofr/datasource/pubsub/mqtt/helper.go +++ b/pkg/gofr/datasource/pubsub/mqtt/helper.go @@ -11,7 +11,6 @@ import ( "time" mqtt "github.com/eclipse/paho.mqtt.golang" - "go.opentelemetry.io/otel" "gofr.dev/pkg/gofr/datasource/pubsub" ) @@ -134,14 +133,13 @@ func (*MQTT) handleContextDone(queryCtx context.Context, topicName string, buffe return buffer, collected, nil } -func (m *MQTT) createMqttHandler(_ context.Context, topic string, msgs chan *pubsub.Message) mqtt.MessageHandler { + +// createMqttHandler builds the paho callback that converts an arriving MQTT message into a +// pubsub.Message and queues it. Instrumentation lives in Subscribe, at the point the message is +// actually handed to a caller, so nothing here needs the topic or a context. +func (*MQTT) createMqttHandler(msgs chan *pubsub.Message) mqtt.MessageHandler { return func(_ mqtt.Client, msg mqtt.Message) { ctx := context.Background() - ctx, span := otel.GetTracerProvider().Tracer("gofr").Start(ctx, "mqtt-subscribe") - - defer span.End() - - m.metrics.IncrementCounter(ctx, "app_pubsub_subscribe_total_count", "topic", topic) var messg = pubsub.NewMessage(context.WithoutCancel(ctx)) @@ -157,15 +155,6 @@ func (m *MQTT) createMqttHandler(_ context.Context, topic string, msgs chan *pub // store the message in the channel msgs <- messg - - m.logger.Debug(&pubsub.Log{ - Mode: "SUB", - CorrelationID: span.SpanContext().TraceID().String(), - MessageValue: string(msg.Payload()), - Topic: msg.Topic(), - Host: m.config.Hostname, - PubSubBackend: "MQTT", - }) } } diff --git a/pkg/gofr/datasource/pubsub/mqtt/mqtt.go b/pkg/gofr/datasource/pubsub/mqtt/mqtt.go index d90f0abbbc..2ea542a087 100644 --- a/pkg/gofr/datasource/pubsub/mqtt/mqtt.go +++ b/pkg/gofr/datasource/pubsub/mqtt/mqtt.go @@ -7,7 +7,6 @@ import ( "time" mqtt "github.com/eclipse/paho.mqtt.golang" - "go.opentelemetry.io/otel" "gofr.dev/pkg/gofr/datasource" "gofr.dev/pkg/gofr/datasource/pubsub" @@ -21,6 +20,7 @@ const ( defaultQueryMessageLimit = 10 defaultQueryCollectTimeout = 5 * time.Second unsubscribeOpTimeout = 2 * time.Second + mqttBackend = "MQTT" ) var ( @@ -109,7 +109,7 @@ func (m *MQTT) Subscribe(ctx context.Context, topic string) (*pubsub.Message, er subs, ok := m.subscriptions[topic] if !ok { subs.msgs = make(chan *pubsub.Message, messageBuffer) - subs.handler = m.createMqttHandler(ctx, topic, subs.msgs) + subs.handler = m.createMqttHandler(subs.msgs) token := m.Client.Subscribe(topic, m.config.QoS, subs.handler) if token.Wait() && token.Error() != nil { @@ -124,10 +124,24 @@ func (m *MQTT) Subscribe(ctx context.Context, topic string) (*pubsub.Message, er m.mu.Unlock() + m.metrics.IncrementCounter(ctx, "app_pubsub_subscribe_total_count", "topic", topic) + select { // blocks if there are no messages in the channel case msg := <-subs.msgs: - m.metrics.IncrementCounter(msg.Context(), "app_pubsub_subscribe_success_count", "topic", msg.Topic) + spanCtx, span := startSubscribeSpan(ctx, topic) + defer span.End() + + m.metrics.IncrementCounter(spanCtx, "app_pubsub_subscribe_success_count", "topic", msg.Topic) + + m.logger.Debug(&pubsub.Log{ + Mode: "SUB", + CorrelationID: span.SpanContext().TraceID().String(), + MessageValue: string(msg.Value), + Topic: msg.Topic, + Host: m.config.Hostname, + PubSubBackend: mqttBackend, + }) return msg, nil case <-ctx.Done(): @@ -177,7 +191,7 @@ func (m *MQTT) Query(ctx context.Context, query string, args ...any) ([]byte, er } func (m *MQTT) Publish(ctx context.Context, topic string, message []byte) error { - _, span := otel.GetTracerProvider().Tracer("gofr").Start(ctx, "mqtt-publish") + ctx, span := startPublishSpan(ctx, topic) defer span.End() m.metrics.IncrementCounter(ctx, "app_pubsub_publish_total_count", "topic", topic) @@ -202,7 +216,7 @@ func (m *MQTT) Publish(ctx context.Context, topic string, message []byte) error MessageValue: string(message), Topic: topic, Host: m.config.Hostname, - PubSubBackend: "MQTT", + PubSubBackend: mqttBackend, Time: t.Microseconds(), }) diff --git a/pkg/gofr/datasource/pubsub/mqtt/mqtt_test.go b/pkg/gofr/datasource/pubsub/mqtt/mqtt_test.go index c634d00d69..919ad054b2 100644 --- a/pkg/gofr/datasource/pubsub/mqtt/mqtt_test.go +++ b/pkg/gofr/datasource/pubsub/mqtt/mqtt_test.go @@ -128,7 +128,7 @@ func TestMQTT_Disconnect(t *testing.T) { ctx := t.Context() mockMetrics.EXPECT(). - IncrementCounter(ctx, "app_pubsub_publish_total_count", "topic", "test") + IncrementCounter(gomock.Any(), "app_pubsub_publish_total_count", "topic", "test") mockClient.EXPECT().Disconnect(uint(1)) @@ -177,9 +177,9 @@ func TestMQTT_PublishSuccess(t *testing.T) { ctx := t.Context() mockMetrics.EXPECT(). - IncrementCounter(ctx, "app_pubsub_publish_total_count", "topic", "test/topic") + IncrementCounter(gomock.Any(), "app_pubsub_publish_total_count", "topic", "test/topic") mockMetrics.EXPECT(). - IncrementCounter(ctx, "app_pubsub_publish_success_count", "topic", "test/topic") + IncrementCounter(gomock.Any(), "app_pubsub_publish_success_count", "topic", "test/topic") mockClient.EXPECT().Publish("test/topic", mockConfigs.QoS, mockConfigs.RetrieveRetained, msg). Return(mockToken) @@ -205,7 +205,7 @@ func TestMQTT_PublishFailure(t *testing.T) { ctx := t.Context() // case where the client has been disconnected, resulting in a Publishing failure mockMetrics.EXPECT(). - IncrementCounter(ctx, "app_pubsub_publish_total_count", "topic", "test/topic") + IncrementCounter(gomock.Any(), "app_pubsub_publish_total_count", "topic", "test/topic") mockClient.EXPECT().Disconnect(uint(1)) // Disconnect the client @@ -227,6 +227,8 @@ func TestMQTT_SubscribeSuccess(t *testing.T) { ctx := t.Context() + mockMetrics.EXPECT(). + IncrementCounter(gomock.Any(), "app_pubsub_subscribe_total_count", "topic", "test/topic") mockMetrics.EXPECT(). IncrementCounter(gomock.Any(), "app_pubsub_subscribe_success_count", "topic", "test/topic") mockClient.EXPECT().IsConnected().Return(true) @@ -525,41 +527,28 @@ func TestReconnectHandler(t *testing.T) { } func TestMQTT_createMqttHandler(t *testing.T) { - var ( - out string - msgs = make(chan *pubsub.Message) - wg = sync.WaitGroup{} - ) - - wg.Add(1) + // The handler now only converts an incoming MQTT message into a pubsub.Message and pushes it + // onto the channel. The span, the metrics and the "SUB" log moved to Subscribe — the point the + // message is handed to a caller, and so the point that belongs in the caller's trace — and are + // covered by TestMQTT_SubscribeSuccess and the tracing tests. + msgs := make(chan *pubsub.Message, 1) - go func() { - defer wg.Done() + // createMqttHandler no longer reads any client state, so a bare *MQTT is enough here. + handler := (&MQTT{}).createMqttHandler(msgs) - out = testutil.StdoutOutputForFunc(func() { - ctrl, client, _, mockMetrics, _ := getMockMQTT(t, mockConfigs) - defer ctrl.Finish() - - mockMetrics.EXPECT().IncrementCounter(gomock.Any(), "app_pubsub_subscribe_total_count", "topic", "test/topic") - - handler := client.createMqttHandler(t.Context(), "test/topic", msgs) - - handler(nil, mockMessage{false, 1, false, "test/topic", 123, "hello world"}) - }) - }() + handler(nil, mockMessage{false, 1, false, "test/topic", 123, "hello world"}) m := <-msgs - close(msgs) - assert.NotNil(t, m) - assert.Equal(t, m.Value, msg) + require.NotNil(t, m) + assert.Equal(t, "test/topic", m.Topic) + assert.Equal(t, msg, m.Value) + assert.NotNil(t, m.Committer) - // wait for the goroutine test to finish writing log to out - wg.Wait() - assert.Contains(t, out, "SUB") - assert.Contains(t, out, "hello world") - assert.Contains(t, out, "test/topic") - assert.Contains(t, out, "MQTT") + meta, ok := m.MetaData.(map[string]string) + require.True(t, ok, "MetaData should be a map[string]string") + assert.Equal(t, "123", meta["messageID"]) + assert.Equal(t, "false", meta["retained"]) } func getMockMQTT(t *testing.T, conf *Config) (*gomock.Controller, *MQTT, *MockClient, *MockMetrics, *MockToken) { diff --git a/pkg/gofr/datasource/pubsub/mqtt/tracing.go b/pkg/gofr/datasource/pubsub/mqtt/tracing.go new file mode 100644 index 0000000000..8cb3f8d1da --- /dev/null +++ b/pkg/gofr/datasource/pubsub/mqtt/tracing.go @@ -0,0 +1,80 @@ +package mqtt + +import ( + "context" + + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/trace" +) + +const tracerName = "gofr-mqtt" + +// MQTT is the one pub/sub backend GoFr instruments that cannot carry a trace context across the +// broker, so its spans are structured differently from Kafka, NATS, SQS and Google Pub/Sub. +// +// Those four have a header or attribute slot on the wire, so the producer injects W3C traceparent +// and the consumer extracts it, making the two ends one trace. An MQTT 3.1.1 PUBLISH packet has +// only a topic, a QoS, a retain flag and a payload — there is no slot for it. Carrying traceparent +// would mean either MQTT 5 user properties, which paho.mqtt.golang v1.5.1 does not implement, or +// wrapping the payload in an envelope, which would break every non-GoFr subscriber on the topic. +// +// So the consume span is rooted in the caller's context instead. That is the right shape here +// regardless: GoFr's MQTT Subscribe is pull-style — a caller asks for the next message — so the +// work the span measures genuinely belongs to the consuming request's trace, not the producer's. +// What is lost is only the edge between the two, and nothing may claim otherwise: an extract that +// can never find anything reports "no link" identically to a broker that dropped the context, and +// that is the failure this file exists to not have. + +// Hoisted because Start is variadic: a slice literal at each call site is 2 heap allocations per +// published message, measured, on a path that is otherwise 2 allocations deep in total. They are +// read-only after init and never escape to a caller. +// +//nolint:gochecknoglobals // hoisted to keep the publish path at development's 144 B/2 allocs +var ( + producerSpanOpts = []trace.SpanStartOption{trace.WithSpanKind(trace.SpanKindProducer)} + consumerSpanOpts = []trace.SpanStartOption{trace.WithSpanKind(trace.SpanKindConsumer)} +) + +// startPublishSpan starts the producer span for one Publish. +func startPublishSpan(ctx context.Context, topic string) (context.Context, trace.Span) { + ctx, span := otel.GetTracerProvider().Tracer(tracerName).Start(ctx, "mqtt-publish", producerSpanOpts...) + + setMessagingAttributes(span, topic, "publish") + + return ctx, span +} + +// startSubscribeSpan starts the consumer span for one Subscribe, under whatever span the caller is +// already in. See the note above for why it has no producer to link to. +func startSubscribeSpan(ctx context.Context, topic string) (context.Context, trace.Span) { + ctx, span := otel.GetTracerProvider().Tracer(tracerName).Start(ctx, "mqtt-subscribe", consumerSpanOpts...) + + setMessagingAttributes(span, topic, "receive") + + return ctx, span +} + +// setMessagingAttributes applies the messaging semantic-convention attributes, but only to a span +// that is actually recording. +// +// The guard is what keeps this off the hot path of the default deployment. With no TRACE_EXPORTER +// configured GoFr still installs an SDK provider, sampling NeverSample, so every publish reaches +// here and builds attributes the SDK immediately discards — 456 bytes and 5 allocations per +// message, measured, against a publish that is otherwise 144 bytes and 2. Passing them to Start +// instead would be the more usual spelling and would pay that cost unconditionally. +// +// Setting them after Start rather than at it is safe for GoFr because its sampler is +// ParentBased(TraceIDRatioBased) (see pkg/gofr/otel.go), which decides on trace ID and parent +// alone. A sampler that inspected attributes would need them passed to Start. +func setMessagingAttributes(span trace.Span, topic, operation string) { + if !span.IsRecording() { + return + } + + span.SetAttributes( + attribute.String("messaging.system", "mqtt"), + attribute.String("messaging.destination.name", topic), + attribute.String("messaging.operation", operation), + ) +} diff --git a/pkg/gofr/datasource/pubsub/mqtt/tracing_test.go b/pkg/gofr/datasource/pubsub/mqtt/tracing_test.go new file mode 100644 index 0000000000..3b61f5de09 --- /dev/null +++ b/pkg/gofr/datasource/pubsub/mqtt/tracing_test.go @@ -0,0 +1,200 @@ +package mqtt + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/attribute" + sdktrace "go.opentelemetry.io/otel/sdk/trace" + "go.opentelemetry.io/otel/sdk/trace/tracetest" + "go.opentelemetry.io/otel/trace" +) + +// recorder installs a tracer provider that keeps every finished span, and returns it. +func recorder(t *testing.T) *tracetest.SpanRecorder { + t.Helper() + + rec := tracetest.NewSpanRecorder() + tp := sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(rec)) + otel.SetTracerProvider(tp) + + t.Cleanup(func() { + require.NoError(t, tp.Shutdown(context.Background())) + }) + + return rec +} + +func attrOf(t *testing.T, s sdktrace.ReadOnlySpan, key string) string { + t.Helper() + + for _, kv := range s.Attributes() { + if kv.Key == attribute.Key(key) { + return kv.Value.AsString() + } + } + + return "" +} + +func TestStartPublishSpan(t *testing.T) { + rec := recorder(t) + + tracer := otel.GetTracerProvider().Tracer("caller") + callerCtx, caller := tracer.Start(context.Background(), "caller-request") + + ctx, span := startPublishSpan(callerCtx, "test-topic") + span.End() + caller.End() + + require.NotNil(t, ctx) + + spans := rec.Ended() + require.Len(t, spans, 2) + + pub := spans[0] + assert.Equal(t, "mqtt-publish", pub.Name()) + assert.Equal(t, trace.SpanKindProducer, pub.SpanKind()) + assert.Equal(t, "mqtt", attrOf(t, pub, "messaging.system")) + assert.Equal(t, "test-topic", attrOf(t, pub, "messaging.destination.name")) + assert.Equal(t, "publish", attrOf(t, pub, "messaging.operation")) + + // The producer span belongs to whatever request asked for the publish. + assert.Equal(t, caller.SpanContext().TraceID(), pub.SpanContext().TraceID()) + assert.Equal(t, caller.SpanContext().SpanID(), pub.Parent().SpanID()) +} + +func TestStartSubscribeSpan_JoinsCallersTrace(t *testing.T) { + rec := recorder(t) + + tracer := otel.GetTracerProvider().Tracer("caller") + callerCtx, caller := tracer.Start(context.Background(), "consumer-request") + + _, span := startSubscribeSpan(callerCtx, "test-topic") + span.End() + caller.End() + + spans := rec.Ended() + require.Len(t, spans, 2) + + sub := spans[0] + assert.Equal(t, "mqtt-subscribe", sub.Name()) + assert.Equal(t, trace.SpanKindConsumer, sub.SpanKind()) + assert.Equal(t, "mqtt", attrOf(t, sub, "messaging.system")) + assert.Equal(t, "test-topic", attrOf(t, sub, "messaging.destination.name")) + assert.Equal(t, "receive", attrOf(t, sub, "messaging.operation")) + + // GoFr's MQTT Subscribe is pull-style, so the consume belongs to the caller's trace. + assert.Equal(t, caller.SpanContext().TraceID(), sub.SpanContext().TraceID()) + assert.Equal(t, caller.SpanContext().SpanID(), sub.Parent().SpanID()) +} + +func TestStartSubscribeSpan_WithoutCallerSpanIsRoot(t *testing.T) { + rec := recorder(t) + + _, span := startSubscribeSpan(context.Background(), "test-topic") + span.End() + + spans := rec.Ended() + require.Len(t, spans, 1) + + assert.True(t, spans[0].SpanContext().IsValid()) + assert.False(t, spans[0].Parent().IsValid()) +} + +// TestSubscribeSpan_HasNoProducerLink pins the documented limitation in tracing.go: an MQTT 3.1.1 +// PUBLISH has nowhere to carry traceparent, so there is no producer context to link to and the +// consume span must not claim one. An earlier revision of this package extracted from +// pubsub.Message.MetaData, which only ever holds qos, retained and messageID — the extract could +// never succeed, and the tests passed only because they fed it attributes the broker never saw. +// +// If MQTT 5 user properties are added later this test should be replaced by one asserting the link +// survives a real round trip, not deleted to make a green build. +func TestSubscribeSpan_HasNoProducerLink(t *testing.T) { + rec := recorder(t) + + tracer := otel.GetTracerProvider().Tracer("producer") + prodCtx, producer := tracer.Start(context.Background(), "producer-request") + + _, pub := startPublishSpan(prodCtx, "test-topic") + pub.End() + producer.End() + + // A consumer in a different trace, which is what a separate process is. + _, sub := startSubscribeSpan(context.Background(), "test-topic") + sub.End() + + var subSpan sdktrace.ReadOnlySpan + + for _, s := range rec.Ended() { + if s.Name() == "mqtt-subscribe" { + subSpan = s + } + } + + require.NotNil(t, subSpan) + assert.Empty(t, subSpan.Links()) + assert.NotEqual(t, producer.SpanContext().TraceID(), subSpan.SpanContext().TraceID()) +} + +// TestSpanAttributes_SkippedWhenNotRecording covers the NeverSample path that a GoFr app with no +// TRACE_EXPORTER runs in: the span is real and carries a valid ID (correlation IDs depend on that), +// but it records nothing, so the attributes are skipped rather than built and discarded. +func TestSpanAttributes_SkippedWhenNotRecording(t *testing.T) { + tp := sdktrace.NewTracerProvider(sdktrace.WithSampler(sdktrace.NeverSample())) + otel.SetTracerProvider(tp) + + t.Cleanup(func() { + require.NoError(t, tp.Shutdown(context.Background())) + }) + + for name, start := range map[string]func(context.Context, string) (context.Context, trace.Span){ + "publish": startPublishSpan, + "subscribe": startSubscribeSpan, + } { + t.Run(name, func(t *testing.T) { + _, span := start(context.Background(), "test-topic") + defer span.End() + + assert.False(t, span.IsRecording()) + assert.True(t, span.SpanContext().IsValid(), "correlation IDs depend on a valid span context") + }) + } +} + +// BenchmarkStartPublishSpan guards the allocation cost of instrumenting a publish. +// +// TracingOff is the default deployment — an SDK provider sampling NeverSample — and is the one that +// matters: it is on the path of every published message whether or not the app traces anything. +// Building the messaging attributes unconditionally costs 456 B and 5 allocations more per message +// there, all of it discarded at the sampler, which is why setMessagingAttributes guards on +// IsRecording. Against a live broker one publish is ~7.9 us at QoS 0, so this is invisible in +// latency and shows up only as garbage. +func BenchmarkStartPublishSpan(b *testing.B) { + for name, sampler := range map[string]sdktrace.Sampler{ + "TracingOff": sdktrace.NeverSample(), + "TracingOn": sdktrace.AlwaysSample(), + } { + b.Run(name, func(b *testing.B) { + tp := sdktrace.NewTracerProvider(sdktrace.WithSampler(sampler)) + otel.SetTracerProvider(tp) + + b.Cleanup(func() { + require.NoError(b, tp.Shutdown(context.Background())) + }) + + ctx := context.Background() + + b.ReportAllocs() + b.ResetTimer() + + for range b.N { + _, span := startPublishSpan(ctx, "bench-topic") + span.End() + } + }) + } +} From 110d1244678f70ee0742c8a06d0a979352143784 Mon Sep 17 00:00:00 2001 From: Suhas-zs <110016885+Suhas-zs@users.noreply.github.com> Date: Mon, 7 Sep 2026 12:34:09 +0530 Subject: [PATCH 12/48] fix(pubsub/google): guard shared subscription maps against concurrent writes (#4054) (#4055) --------- Co-authored-by: Umang Mundhra Co-authored-by: Aryan Mehrotra --- pkg/gofr/datasource/pubsub/google/google.go | 119 +++++++++++------- .../datasource/pubsub/google/google_test.go | 58 +++++++++ 2 files changed, 135 insertions(+), 42 deletions(-) diff --git a/pkg/gofr/datasource/pubsub/google/google.go b/pkg/gofr/datasource/pubsub/google/google.go index d11a47d06d..c7d67f51c7 100644 --- a/pkg/gofr/datasource/pubsub/google/google.go +++ b/pkg/gofr/datasource/pubsub/google/google.go @@ -168,51 +168,13 @@ func (g *googleClient) Subscribe(ctx context.Context, topic string) (*pubsub.Mes g.metrics.IncrementCounter(ctx, "app_pubsub_subscribe_total_count", "topic", topic, "subscription_name", g.Config.SubscriptionName) - if _, ok := g.subStarted[topic]; !ok { - t, err := g.getTopic(ctx, topic) - if err != nil { - return nil, err - } - - subscription, err := g.getSubscription(ctx, t) - if err != nil { - return nil, err - } - - start := time.Now() - - processMessage := func(ctx context.Context, msg *gcPubSub.Message) { - m := pubsub.NewMessage(ctx) - end = time.Since(start) - - m.Topic = topic - m.Value = msg.Data - m.MetaData = msg.Attributes - m.Committer = newGoogleMessage(msg) - - g.mu.Lock() - defer g.mu.Unlock() - - g.receiveChan[topic] <- m - } - - // initialize the channel before we can start receiving on it - g.mu.Lock() - g.receiveChan[topic] = make(chan *pubsub.Message) - g.mu.Unlock() - - go func() { - err = subscription.Receive(ctx, processMessage) - if err != nil { - g.logger.Errorf("error getting a message from google: %s", err.Error()) - } - }() - - g.subStarted[topic] = struct{}{} + receiveChan, err := g.startTopicSubscriber(ctx, topic, &end) + if err != nil { + return nil, err } select { - case m := <-g.receiveChan[topic]: + case m := <-receiveChan: // Create span with links to producer span from message attributes spanCtx, span := startSubscribeSpan(ctx, topic, extractMessageAttrs(m.MetaData)) defer span.End() @@ -236,6 +198,76 @@ func (g *googleClient) Subscribe(ctx context.Context, topic string) (*pubsub.Mes } } +// startTopicSubscriber lazily starts a receiver goroutine for the topic and returns its channel. +// Access to the shared receiveChan and subStarted maps is guarded by g.mu so that concurrent +// subscribers for different topics do not trigger a "concurrent map writes" fatal error. +func (g *googleClient) startTopicSubscriber(ctx context.Context, topic string, end *time.Duration) (chan *pubsub.Message, error) { + g.mu.RLock() + receiveChan, started := g.receiveChan[topic], false + + if _, ok := g.subStarted[topic]; ok { + started = true + } + + g.mu.RUnlock() + + if started { + return receiveChan, nil + } + + t, err := g.getTopic(ctx, topic) + if err != nil { + return nil, err + } + + subscription, err := g.getSubscription(ctx, t) + if err != nil { + return nil, err + } + + start := time.Now() + + receiveChan = make(chan *pubsub.Message) + + g.mu.Lock() + + // Recheck under the write lock: if another goroutine started this topic between the RLock + // check and here, reuse its channel instead of starting a second receiver. + if _, ok := g.subStarted[topic]; ok { + receiveChan = g.receiveChan[topic] + g.mu.Unlock() + + return receiveChan, nil + } + + g.receiveChan[topic] = receiveChan + g.subStarted[topic] = struct{}{} + g.mu.Unlock() + + processMessage := func(ctx context.Context, msg *gcPubSub.Message) { + m := pubsub.NewMessage(ctx) + *end = time.Since(start) + + m.Topic = topic + m.Value = msg.Data + m.MetaData = msg.Attributes + m.Committer = newGoogleMessage(msg) + + select { + case receiveChan <- m: + case <-ctx.Done(): + } + } + + go func() { + if recErr := subscription.Receive(ctx, processMessage); recErr != nil { + g.logger.Errorf("error getting a message from google: %s", recErr.Error()) + } + }() + + return receiveChan, nil +} + func (g *googleClient) Query(ctx context.Context, query string, args ...any) ([]byte, error) { if !g.isConnected() { return nil, errClientNotConnected @@ -369,6 +401,9 @@ func (g *googleClient) Close() error { return g.client.Close() } + g.mu.Lock() + defer g.mu.Unlock() + for _, c := range g.receiveChan { close(c) } diff --git a/pkg/gofr/datasource/pubsub/google/google_test.go b/pkg/gofr/datasource/pubsub/google/google_test.go index 6d009f0126..5673dd0c96 100644 --- a/pkg/gofr/datasource/pubsub/google/google_test.go +++ b/pkg/gofr/datasource/pubsub/google/google_test.go @@ -5,6 +5,7 @@ import ( "errors" "fmt" "strings" + "sync" "testing" "time" @@ -1416,3 +1417,60 @@ func TestCollectMessages_SingleMessage(t *testing.T) { assert.Equal(t, []byte("single"), result) } + +func TestGoogleClient_Subscribe_ConcurrentTopics(t *testing.T) { + client := getGoogleClient(t) + + defer client.Close() + + ctrl := gomock.NewController(t) + + defer ctrl.Finish() + + mockMetrics := NewMockMetrics(ctrl) + + g := &googleClient{ + client: client, + logger: logging.NewMockLogger(logging.DEBUG), + metrics: mockMetrics, + Config: Config{ + ProjectID: "test", + SubscriptionName: "sub", + }, + receiveChan: make(map[string]chan *pubsub.Message), + subStarted: make(map[string]struct{}), + } + + topics := []string{"race-topic-a", "race-topic-b", "race-topic-c", "race-topic-d", "race-topic-e"} + + for _, topic := range topics { + _, err := client.CreateTopic(t.Context(), topic) + require.NoError(t, err) + + mockMetrics.EXPECT().IncrementCounter(gomock.Any(), "app_pubsub_subscribe_total_count", + "topic", topic, "subscription_name", g.Config.SubscriptionName).Times(1) + } + + ctx, cancel := context.WithTimeout(t.Context(), 200*time.Millisecond) + defer cancel() + + var wg sync.WaitGroup + + for _, topic := range topics { + wg.Add(1) + + go func() { + defer wg.Done() + + _, _ = g.Subscribe(ctx, topic) + }() + } + + wg.Wait() + + g.mu.RLock() + defer g.mu.RUnlock() + + assert.Len(t, g.subStarted, len(topics)) + assert.Len(t, g.receiveChan, len(topics)) +} From 5812ba9db1ff694e62707fbf3c2d779a6e1947a3 Mon Sep 17 00:00:00 2001 From: Lokesh Malik Date: Mon, 7 Sep 2026 13:15:08 +0530 Subject: [PATCH 13/48] feat: implement EventHub Health check (#3649) --- .../datasource/pubsub/eventhub/eventhub.go | 90 ++++++- .../pubsub/eventhub/eventhub_test.go | 219 +++++++++++++++++- 2 files changed, 297 insertions(+), 12 deletions(-) diff --git a/pkg/gofr/datasource/pubsub/eventhub/eventhub.go b/pkg/gofr/datasource/pubsub/eventhub/eventhub.go index 1dd7c1c1d0..bc65b0fb77 100644 --- a/pkg/gofr/datasource/pubsub/eventhub/eventhub.go +++ b/pkg/gofr/datasource/pubsub/eventhub/eventhub.go @@ -48,9 +48,26 @@ type Config struct { ProducerOptions *azeventhubs.ProducerClientOptions } +// consumerClient is the part of *azeventhubs.ConsumerClient this package uses. It exists so the +// health probe can be exercised without a live namespace -- the same seam the SQS client uses for +// its own health tests. The partition READS cannot: NewPartitionClient hands back the concrete +// *azeventhubs.PartitionClient and ReceiveEvents is called on that, and the zero value of that +// type nil-derefs. So a fake can decide which partition IDs come back and whether opening a +// partition client fails, but not what reading one returns. +type consumerClient interface { + GetEventHubProperties(ctx context.Context, options *azeventhubs.GetEventHubPropertiesOptions) (azeventhubs.EventHubProperties, error) + NewPartitionClient(partitionID string, options *azeventhubs.PartitionClientOptions) (*azeventhubs.PartitionClient, error) + Close(ctx context.Context) error +} + type Client struct { producer *azeventhubs.ProducerClient - consumer *azeventhubs.ConsumerClient + // consumer is written once by Connect and read without synchronization by Health, Subscribe + // and Close, so Connect must happen-before any of them -- which is what AddPubSub does. Note + // that as an interface this is two words, so a concurrent Connect can be observed half-written + // and pass a "!= nil" guard with a nil value behind it; as a pointer it could only be observed + // nil or whole. Synchronizing the field is a separate change. + consumer consumerClient // we are using a processor such that to keep consuming the events from all the different partitions. processor *azeventhubs.Processor // a checkpoint is being called while committing the event received from the event. @@ -176,7 +193,7 @@ func (c *Client) Connect() { c.logger.Debug("Event Hub blobstore client setup success") // create a consumer client using a connection string to the namespace and the event hub - consumerClient, err := azeventhubs.NewConsumerClientFromConnectionString(c.cfg.ConnectionString, c.cfg.EventhubName, + consumer, err := azeventhubs.NewConsumerClientFromConnectionString(c.cfg.ConnectionString, c.cfg.EventhubName, c.cfg.ConsumerGroup, c.cfg.ConsumerOptions) if err != nil { c.logger.Errorf("error occurred while creating consumer client %v", err) @@ -187,7 +204,7 @@ func (c *Client) Connect() { c.logger.Debug("Event Hub consumer client setup success") // create a processor to receive and process events - processor, err := azeventhubs.NewProcessor(consumerClient, checkpointStore, nil) + processor, err := azeventhubs.NewProcessor(consumer, checkpointStore, nil) if err != nil { c.logger.Errorf("error occurred while creating processor %v", err) @@ -212,7 +229,7 @@ func (c *Client) Connect() { c.processor = processor c.producer = producerClient - c.consumer = consumerClient + c.consumer = consumer c.checkPoint = checkpointStore c.logger.Debug("Event Hub client initialization complete") @@ -460,10 +477,71 @@ func (c *Client) Publish(ctx context.Context, topic string, message []byte) erro return nil } +// eventHubProps is the result of one probe, carried back off the goroutine that ran it. +type eventHubProps struct { + props azeventhubs.EventHubProperties + err error +} + func (c *Client) Health() datasource.Health { - c.logger.Error("health-check not implemented for Event Hub") + health := datasource.Health{ + Status: datasource.StatusDown, + Details: map[string]any{ + "backend": "EVENT_HUB", + "eventHub": c.cfg.EventhubName, + }, + } + + if c.consumer == nil { + health.Details["error"] = errClientNotConnected.Error() + + return health + } - return datasource.Health{} + ctx, cancel := context.WithTimeout(context.Background(), eventHubPropsTimeout) + defer cancel() + + props, err := c.probeWithin(ctx) + if err != nil { + health.Details["error"] = err.Error() + + return health + } + + health.Status = datasource.StatusUp + health.Details["partitionCount"] = len(props.PartitionIDs) + + return health +} + +// probeWithin runs the connectivity probe and returns when ctx expires whether or not the probe +// has. +// +// Passing ctx to GetEventHubProperties is not enough to bound it. In azeventhubs v1.4.0 that +// method hands context.Background() to rpcLink.RPC (mgmt.go:67), and the wait for the reply +// selects on *that* context (internal/rpc.go:263), so our deadline never fires there. The same +// Background context also has no deadline to derive the AMQP "server-timeout" property from +// (internal/rpc.go:244), so the broker-side bound is absent too. What ctx does bound is link +// acquisition and the sleeps between retries -- which is why an unresolvable host still returns +// promptly, and why the bound looks correct until a broker accepts a request and never answers. +// +// Running the call on its own goroutine and selecting here makes the deadline ours. The cost is +// that an abandoned probe stays parked until the SDK returns; the channel is buffered so it can +// always finish and exit rather than blocking forever on the send. +func (c *Client) probeWithin(ctx context.Context) (azeventhubs.EventHubProperties, error) { + done := make(chan eventHubProps, 1) + + go func() { + props, err := c.consumer.GetEventHubProperties(ctx, nil) + done <- eventHubProps{props: props, err: err} + }() + + select { + case res := <-done: + return res.props, res.err + case <-ctx.Done(): + return azeventhubs.EventHubProperties{}, ctx.Err() + } } func (c *Client) CreateTopic(_ context.Context, name string) error { diff --git a/pkg/gofr/datasource/pubsub/eventhub/eventhub_test.go b/pkg/gofr/datasource/pubsub/eventhub/eventhub_test.go index 512578dc4a..37357a2bc4 100644 --- a/pkg/gofr/datasource/pubsub/eventhub/eventhub_test.go +++ b/pkg/gofr/datasource/pubsub/eventhub/eventhub_test.go @@ -2,6 +2,7 @@ package eventhub import ( "context" + "errors" "net" "testing" "time" @@ -15,6 +16,13 @@ import ( "gofr.dev/pkg/gofr/testutil" ) +// errHealthProbe stands in for whatever the Event Hub SDK returns when the probe fails. +var errHealthProbe = errors.New("event hub unreachable") + +// errPartitionClientUnavailable is what the fake consumer returns instead of a partition client, +// which is a concrete type it cannot construct. +var errPartitionClientUnavailable = errors.New("partition client unavailable in tests") + func TestConnect(t *testing.T) { ctrl := gomock.NewController(t) @@ -228,16 +236,35 @@ func Test_HealthCheck(t *testing.T) { mockLogger.EXPECT().Debug("Event Hub processor running successfully").AnyTimes() mockLogger.EXPECT().Debugf("Using default consumer group: %s", azeventhubs.DefaultConsumerGroup) mockLogger.EXPECT().Debug("Event Hub client initialization complete") - mockLogger.EXPECT().Error("health-check not implemented for Event Hub") client.UseLogger(mockLogger) client.UseMetrics(mockMetrics) client.Connect() - _ = client.Health() + // getTestConfigs points at ".servicebus.windows.net", which is not a legal + // hostname and so can never resolve -- the probe fails the same way on a runner with or + // without network access. + start := time.Now() - require.True(t, mockLogger.ctrl.Satisfied(), "Event Hub Topic Deletion not allowed failed") + health := client.Health() + + elapsed := time.Since(start) + + // The connectivity probe must stay bounded. Without that bound a health endpoint backed by an + // unreachable namespace blocks on the SDK's own retry schedule, which is what makes a liveness + // probe time out instead of answering. The assertion allows 2x eventHubPropsTimeout rather than + // the timeout itself: the point is that the probe returns on its own deadline instead of the + // SDK's, and a margin that tight would flake on a loaded runner. Measured, it returns in 1x. + require.Less(t, elapsed, 2*eventHubPropsTimeout, + "Health must return within 2x eventHubPropsTimeout (%v), took %v", 2*eventHubPropsTimeout, elapsed) + + require.Equal(t, datasource.StatusDown, health.Status, "Event Hub health should be down when the namespace is unreachable") + require.Equal(t, "EVENT_HUB", health.Details["backend"]) + require.Equal(t, client.cfg.EventhubName, health.Details["eventHub"]) + require.Contains(t, health.Details, "error", "an unreachable Event Hub should report the probe error") + + require.True(t, mockLogger.ctrl.Satisfied(), "Event Hub Health Check Failed") } func getTestConfigs() Config { @@ -393,11 +420,14 @@ func Test_Health(t *testing.T) { client := New(getTestConfigs()) client.UseLogger(mockLogger) - mockLogger.EXPECT().Error("health-check not implemented for Event Hub") - + // Without Connect() the consumer is nil, so the health check should short-circuit to down. health := client.Health() - require.Equal(t, datasource.Health{}, health, "Health should return an empty datasource.Health struct") + require.Equal(t, datasource.StatusDown, health.Status, "Health should be down when the client is not connected") + require.Equal(t, "EVENT_HUB", health.Details["backend"]) + require.Equal(t, client.cfg.EventhubName, health.Details["eventHub"]) + require.Equal(t, errClientNotConnected.Error(), health.Details["error"]) + require.NotContains(t, health.Details, "partitionCount", "an unconnected client has no partitions to report") } func TestCreateTopic_ForMigrations(t *testing.T) { @@ -469,3 +499,180 @@ func TestConnect_ConsumerGroupProvided(t *testing.T) { require.Equal(t, expectedGroup, client.cfg.ConsumerGroup, "Client should respect the provided consumer group") } + +// mockConsumerClient is a hand-written stand-in for *azeventhubs.ConsumerClient, in the same +// shape as the SQS client's mockSQSClient: the call under test is scripted through a func field +// and the others answer with a fixed value. Close reports success; NewPartitionClient reports an +// error, for the reason given on it below. +type mockConsumerClient struct { + getPropsFunc func(ctx context.Context, + options *azeventhubs.GetEventHubPropertiesOptions) (azeventhubs.EventHubProperties, error) +} + +func (m *mockConsumerClient) GetEventHubProperties(ctx context.Context, + options *azeventhubs.GetEventHubPropertiesOptions) (azeventhubs.EventHubProperties, error) { + if m.getPropsFunc != nil { + return m.getPropsFunc(ctx, options) + } + + return azeventhubs.EventHubProperties{}, nil +} + +// NewPartitionClient returns an error rather than (nil, nil). The concrete return type can be +// constructed -- &azeventhubs.PartitionClient{} compiles -- but not into anything usable: every +// field is unexported, so ReceiveEvents nil-derefs on it. And handing back a nil client would +// nil-deref on the deferred Close in the first test that reached tryReadFromPartition. +func (*mockConsumerClient) NewPartitionClient(string, + *azeventhubs.PartitionClientOptions) (*azeventhubs.PartitionClient, error) { + return nil, errPartitionClientUnavailable +} + +func (*mockConsumerClient) Close(context.Context) error { return nil } + +// newHealthTestClient returns a client that looks connected to Health without a live namespace. +func newHealthTestClient(t *testing.T, consumer consumerClient) *Client { + t.Helper() + + client := New(getTestConfigs()) + client.UseLogger(NewMockLogger(gomock.NewController(t))) + client.consumer = consumer + + return client +} + +// Test_Health_Connected covers the only branch that reports the backend as usable. Nothing in +// the down paths can reach it, so without a stubbed consumer StatusUp and partitionCount are +// never executed by the suite at all. +func Test_Health_Connected(t *testing.T) { + client := newHealthTestClient(t, &mockConsumerClient{ + getPropsFunc: func(context.Context, + *azeventhubs.GetEventHubPropertiesOptions) (azeventhubs.EventHubProperties, error) { + return azeventhubs.EventHubProperties{ + Name: "event-hub-name", + PartitionIDs: []string{"0", "1", "2", "3"}, + }, nil + }, + }) + + health := client.Health() + + require.Equal(t, datasource.StatusUp, health.Status, "a reachable Event Hub must report up") + require.Equal(t, "EVENT_HUB", health.Details["backend"]) + require.Equal(t, client.cfg.EventhubName, health.Details["eventHub"]) + require.Equal(t, 4, health.Details["partitionCount"], "partitionCount must be the number of partitions reported") + require.NotContains(t, health.Details, "error", "a healthy Event Hub must not report an error") +} + +// Test_Health_ProbeError pins the message an operator actually reads when the probe fails. The +// live-namespace test below can only ever produce "context deadline exceeded", so the error is +// passed through verbatim only here. +func Test_Health_ProbeError(t *testing.T) { + client := newHealthTestClient(t, &mockConsumerClient{ + getPropsFunc: func(context.Context, + *azeventhubs.GetEventHubPropertiesOptions) (azeventhubs.EventHubProperties, error) { + return azeventhubs.EventHubProperties{}, errHealthProbe + }, + }) + + health := client.Health() + + require.Equal(t, datasource.StatusDown, health.Status, "a failing probe must report down") + require.Equal(t, errHealthProbe.Error(), health.Details["error"], "the probe error must reach the caller verbatim") + require.NotContains(t, health.Details, "partitionCount", "a failed probe has no partition count to report") +} + +// Test_Health_NotConnectedDoesNotProbe pins the short-circuit itself: an unconnected client must +// report down without dialing, so a probe on a dead pod costs nothing and cannot block. +func Test_Health_NotConnectedDoesNotProbe(t *testing.T) { + // A nil consumer, not a scripted mock. There is no seam that can observe a call which must not + // happen -- a mock passed here is discarded by the nil assignment, so its t.Error could never + // fire. If the short-circuit is removed, Health calls GetEventHubProperties on a nil interface + // and this test panics; that is the failure signal. + client := newHealthTestClient(t, nil) + + health := client.Health() + + require.Equal(t, datasource.StatusDown, health.Status) + require.Equal(t, errClientNotConnected.Error(), health.Details["error"]) +} + +// Test_Health_BoundsAProbeThatIgnoresContext is the case the Azure SDK actually creates. +// GetEventHubProperties passes context.Background() to the AMQP round-trip, so handing our +// deadline to the SDK does not bound it; only selecting on the deadline ourselves does. The fake +// here blocks without ever reading ctx, which is what the SDK does once a management link exists +// and the broker stops answering. +// +// Without probeWithin's select this test does not fail -- it hangs until the go test timeout. +func Test_Health_BoundsAProbeThatIgnoresContext(t *testing.T) { + release := make(chan struct{}) + defer close(release) + + client := newHealthTestClient(t, &mockConsumerClient{ + getPropsFunc: func(context.Context, + *azeventhubs.GetEventHubPropertiesOptions) (azeventhubs.EventHubProperties, error) { + <-release + + return azeventhubs.EventHubProperties{}, nil + }, + }) + + start := time.Now() + health := client.Health() + elapsed := time.Since(start) + + require.Less(t, elapsed, 2*eventHubPropsTimeout, + "Health must return on its own deadline even when the probe ignores the context, took %v", elapsed) + require.Equal(t, datasource.StatusDown, health.Status, "an unanswered probe must report down") + require.Equal(t, context.DeadlineExceeded.Error(), health.Details["error"], + "the caller must see the deadline, not a nil error") + require.NotContains(t, health.Details, "partitionCount", "an unanswered probe has no partition count") +} + +// Test_Health_PartitionCountIsTheRealCount pins partitionCount to the length the probe reported. +// The only other connected test uses four partitions, so a mutation replacing len(props.PartitionIDs) +// with the constant 4 -- or wrapping the assignment in a len > 0 guard -- passed the whole suite. +func Test_Health_PartitionCountIsTheRealCount(t *testing.T) { + for _, partitions := range [][]string{{}, {"0"}, {"0", "1", "2"}} { + client := newHealthTestClient(t, &mockConsumerClient{ + getPropsFunc: func(context.Context, + *azeventhubs.GetEventHubPropertiesOptions) (azeventhubs.EventHubProperties, error) { + return azeventhubs.EventHubProperties{PartitionIDs: partitions}, nil + }, + }) + + health := client.Health() + + require.Equal(t, datasource.StatusUp, health.Status) + require.Equal(t, len(partitions), health.Details["partitionCount"], + "partitionCount must be the reported count, including zero") + } +} + +// Test_Health_ProbeDeadlineIsTwoSeconds pins the deadline itself. The elapsed-time assertion in +// Test_HealthCheck is bounded by 2*eventHubPropsTimeout, so both the deadline and the bound move +// together and raising the constant to 30s passes. This reads the deadline the probe was actually +// given and compares it against a literal, so the constant cannot drift unnoticed -- and it costs +// no wall clock. +func Test_Health_ProbeDeadlineIsTwoSeconds(t *testing.T) { + var ( + gotDeadline bool + remaining time.Duration + ) + + client := newHealthTestClient(t, &mockConsumerClient{ + getPropsFunc: func(ctx context.Context, + _ *azeventhubs.GetEventHubPropertiesOptions) (azeventhubs.EventHubProperties, error) { + deadline, ok := ctx.Deadline() + gotDeadline = ok + remaining = time.Until(deadline) + + return azeventhubs.EventHubProperties{}, nil + }, + }) + + client.Health() + + require.True(t, gotDeadline, "the probe must be given a deadline") + require.Greater(t, remaining, 1500*time.Millisecond, "deadline is shorter than expected, got %v", remaining) + require.LessOrEqual(t, remaining, 2*time.Second, "deadline is longer than expected, got %v", remaining) +} From dacb55c9d7261101bbdb4d03ab34e4b25e8af530 Mon Sep 17 00:00:00 2001 From: Hari Antara Date: Mon, 7 Sep 2026 15:57:20 +0800 Subject: [PATCH 14/48] test(terminal): add unit tests for SetColor and ResetColor (#3648) --- pkg/gofr/cmd/terminal/colors_test.go | 67 ++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 pkg/gofr/cmd/terminal/colors_test.go diff --git a/pkg/gofr/cmd/terminal/colors_test.go b/pkg/gofr/cmd/terminal/colors_test.go new file mode 100644 index 0000000000..88058797ba --- /dev/null +++ b/pkg/gofr/cmd/terminal/colors_test.go @@ -0,0 +1,67 @@ +package terminal + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestSetColor(t *testing.T) { + tests := []struct { + name string + colorCode int + expected string + }{ + {"black", Black, "\x1b[38;5;0m"}, + {"red", Red, "\x1b[38;5;1m"}, + {"green", Green, "\x1b[38;5;2m"}, + {"white", White, "\x1b[38;5;7m"}, + {"bright white", BrightWhite, "\x1b[38;5;15m"}, + // SetColor does not validate its argument: any 256-color palette index is written + // through as-is, which is what callers reaching past the named constants rely on. + {"unnamed 256-color index", 208, "\x1b[38;5;208m"}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + o := tempOutput(t) + o.SetColor(tc.colorCode) + + validate(t, o, tc.expected) + }) + } +} + +func TestResetColor(t *testing.T) { + o := tempOutput(t) + o.ResetColor() + + validate(t, o, "\x1b[0m") +} + +// TestSetColorResetColor covers the pairing as it is actually used -- color on, write, color +// off -- which is the only place ResetColor's job of undoing SetColor is observable. +func TestSetColorResetColor(t *testing.T) { + o := tempOutput(t) + + o.SetColor(Green) + o.Print("gofr") + o.ResetColor() + + validate(t, o, "\x1b[38;5;2mgofr\x1b[0m") +} + +// TestColorConstants pins the color codes to their ANSI 256-color palette indices. They are +// written straight into the escape sequence, so inserting or reordering a constant repaints +// every caller's output with no other signal that anything changed. +func TestColorConstants(t *testing.T) { + got := []int{ + Black, Red, Green, Yellow, Blue, Magenta, Cyan, White, + BrightBlack, BrightRed, BrightGreen, BrightYellow, + BrightBlue, BrightMagenta, BrightCyan, BrightWhite, + } + + want := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15} + + assert.Equal(t, want, got, "color constants must keep their ANSI 256-color palette indices") +} From eb0336ab737416e851c19195dc3382f4d6828942 Mon Sep 17 00:00:00 2001 From: Krishna Potdar Date: Mon, 7 Sep 2026 15:57:06 +0530 Subject: [PATCH 15/48] fix: add transaction support for dgraph migration (#3186) --- pkg/gofr/migration/dgraph.go | 102 +++++++++++++++++-------- pkg/gofr/migration/dgraph_test.go | 122 +++++++++++++++++++++++------- 2 files changed, 163 insertions(+), 61 deletions(-) diff --git a/pkg/gofr/migration/dgraph.go b/pkg/gofr/migration/dgraph.go index e4d6e918b5..1a48f136d0 100644 --- a/pkg/gofr/migration/dgraph.go +++ b/pkg/gofr/migration/dgraph.go @@ -3,6 +3,7 @@ package migration import ( "context" "encoding/json" + "errors" "fmt" "time" @@ -11,6 +12,19 @@ import ( "gofr.dev/pkg/gofr/container" ) +var errInvalidDgraphTxn = errors.New("invalid Dgraph transaction") + +// migrationMethodUP is the method recorded for an applied (UP) migration. +const migrationMethodUP = "UP" + +// dgraphTxn is the subset of the Dgraph transaction used to record migrations. +// The value returned by Dgraph.NewTxn satisfies it at runtime. +type dgraphTxn interface { + Mutate(ctx context.Context, mu *api.Mutation) (*api.Response, error) + Commit(ctx context.Context) error + Discard(ctx context.Context) error +} + // dgraphDS is the adapter struct that implements migration operations. type dgraphDS struct { client DGraph @@ -38,10 +52,12 @@ const ( ` // getLastMigrationQuery fetches the most recent migration version. + // The version predicate is aliased to "version" so it decodes into the + // response struct below. getLastMigrationQuery = ` { migrations(func: type(Migration), orderdesc: migrations.version, first: 1) { - migrations.version + version: migrations.version } } ` @@ -106,16 +122,9 @@ func (dm dgraphMigrator) getLastMigration(c *container.Container) (int64, error) return -1, fmt.Errorf("dgraph: %w", err) } - if resp != nil { - var b []byte - - b, err = json.Marshal(resp) - if err != nil { - return 0, fmt.Errorf("dgraph: %w", err) - } - - err = json.Unmarshal(b, &response) - if err != nil { + // Query returns an *api.Response whose Json field holds the actual result. + if r, ok := resp.(*api.Response); ok && len(r.Json) > 0 { + if err = json.Unmarshal(r.Json, &response); err != nil { return 0, fmt.Errorf("dgraph: %w", err) } } @@ -142,36 +151,63 @@ func (dm dgraphMigrator) beginTransaction(c *container.Container) transactionDat return data } -// commitMigration commits the migration and records its metadata. +// commitMigration records the migration metadata in a Dgraph transaction so the +// version record is committed atomically, then chains to the next migrator. func (dm dgraphMigrator) commitMigration(c *container.Container, data transactionData) error { - if data.UsedDatasources[dsDGraph] { - // Build the JSON payload for the migration record. - payload := map[string]any{ - "migrations": []map[string]any{ - { - "migrations.version": data.MigrationNumber, - "migrations.method": "UP", - "migrations.start_time": data.StartTime.Format(time.RFC3339), - "migrations.duration": time.Since(data.StartTime).Milliseconds(), - }, + if !data.UsedDatasources[dsDGraph] { + return dm.migrator.commitMigration(c, data) + } + + payload := map[string]any{ + "migrations": []map[string]any{ + { + // dgraph.type must match the schema type so getLastMigration + // (func: type(Migration)) can find this record on later runs. + "dgraph.type": "Migration", + "migrations.version": data.MigrationNumber, + "migrations.method": migrationMethodUP, + "migrations.start_time": data.StartTime.Format(time.RFC3339), + "migrations.duration": time.Since(data.StartTime).Milliseconds(), }, - } + }, + } - jsonPayload, err := json.Marshal(payload) - if err != nil { - return err - } + jsonPayload, err := json.Marshal(payload) + if err != nil { + return err + } + + ctx := context.Background() - _, err = c.DGraph.Mutate(context.Background(), &api.Mutation{ - SetJson: jsonPayload, - }) - if err != nil { - return err + // isNil also rejects a typed-nil txn, which would satisfy the assertion but + // panic on Discard. + tx, ok := c.DGraph.NewTxn().(dgraphTxn) + if !ok || isNil(tx) { + return errInvalidDgraphTxn + } + + defer func() { + if discardErr := tx.Discard(ctx); discardErr != nil { + c.Errorf("dgraph: migration transaction discard failed: %v", discardErr) } + }() + + // The txn write bypasses Client.Mutate, so log duration and errors here to + // keep the migration record write observable. + start := time.Now() - c.Debugf("Inserted record for migration %v in Dgraph migrations", data.MigrationNumber) + if _, err = tx.Mutate(ctx, &api.Mutation{SetJson: jsonPayload}); err != nil { + c.Errorf("dgraph: migration %v mutation failed: %v", data.MigrationNumber, err) + return err } + if err := tx.Commit(ctx); err != nil { + c.Errorf("dgraph: migration %v commit failed: %v", data.MigrationNumber, err) + return err + } + + c.Debugf("recorded migration %v in Dgraph in %v", data.MigrationNumber, time.Since(start)) + return dm.migrator.commitMigration(c, data) } diff --git a/pkg/gofr/migration/dgraph_test.go b/pkg/gofr/migration/dgraph_test.go index c79ad6622a..dfbe402ead 100644 --- a/pkg/gofr/migration/dgraph_test.go +++ b/pkg/gofr/migration/dgraph_test.go @@ -5,6 +5,7 @@ import ( "testing" "time" + "github.com/dgraph-io/dgo/v210/protos/api" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "go.uber.org/mock/gomock" @@ -13,6 +14,33 @@ import ( "gofr.dev/pkg/gofr/testutil" ) +// fakeDgraphTxn is a minimal dgraphTxn used to drive commitMigration in tests. +type fakeDgraphTxn struct { + mutateErr error + commitErr error + setJSON []byte + mutated bool + committed bool + discarded bool +} + +func (f *fakeDgraphTxn) Mutate(_ context.Context, mu *api.Mutation) (*api.Response, error) { + f.mutated = true + f.setJSON = mu.SetJson + + return nil, f.mutateErr +} + +func (f *fakeDgraphTxn) Commit(context.Context) error { + f.committed = true + return f.commitErr +} + +func (f *fakeDgraphTxn) Discard(context.Context) error { + f.discarded = true + return nil +} + func dgraphSetup(t *testing.T) (migrator, *container.MockDgraph, *container.Container) { t.Helper() @@ -45,19 +73,13 @@ func Test_DGraphGetLastMigration(t *testing.T) { testCases := []struct { desc string err error - mockResp map[string]any + mockResp *api.Response expected int64 }{ { - desc: "success", - err: nil, - mockResp: map[string]any{ - "migrations": []map[string]any{ - { - "version": float64(10), - }, - }, - }, + desc: "success", + err: nil, + mockResp: &api.Response{Json: []byte(`{"migrations":[{"version":10}]}`)}, expected: 10, }, { @@ -69,7 +91,7 @@ func Test_DGraphGetLastMigration(t *testing.T) { { desc: "empty response", err: nil, - mockResp: map[string]any{}, + mockResp: &api.Response{Json: []byte(`{"migrations":[]}`)}, expected: 0, }, } @@ -94,31 +116,75 @@ func Test_DGraphGetLastMigration(t *testing.T) { } func Test_DGraphCommitMigration(t *testing.T) { - migratorWithDGraph, mockDGraph, mockContainer := dgraphSetup(t) - - timeNow := time.Now() - - testCases := []struct { - desc string - err error - }{ - {"success", nil}, - {"mutation failed", context.DeadlineExceeded}, - } - td := transactionData{ - StartTime: timeNow, + StartTime: time.Now(), MigrationNumber: 10, UsedDatasources: map[string]bool{dsDGraph: true}, } - for i, tc := range testCases { - mockDGraph.EXPECT().Mutate(gomock.Any(), gomock.Any()).Return(nil, tc.err) + t.Run("success commits the record", func(t *testing.T) { + migratorWithDGraph, mockDGraph, mockContainer := dgraphSetup(t) + txn := &fakeDgraphTxn{} + mockDGraph.EXPECT().NewTxn().Return(txn) err := migratorWithDGraph.commitMigration(mockContainer, td) - assert.Equal(t, tc.err, err, "TEST[%v]\n %v Failed!", i, tc.desc) - } + require.NoError(t, err) + assert.True(t, txn.mutated && txn.committed && txn.discarded) + // The record must be typed as Migration and carry the version so + // getLastMigration can find it on subsequent runs. + assert.Contains(t, string(txn.setJSON), `"dgraph.type":"Migration"`) + assert.Contains(t, string(txn.setJSON), `"migrations.version":10`) + }) + + t.Run("mutate error is returned without commit", func(t *testing.T) { + migratorWithDGraph, mockDGraph, mockContainer := dgraphSetup(t) + txn := &fakeDgraphTxn{mutateErr: context.DeadlineExceeded} + mockDGraph.EXPECT().NewTxn().Return(txn) + + err := migratorWithDGraph.commitMigration(mockContainer, td) + + require.ErrorIs(t, err, context.DeadlineExceeded) + assert.False(t, txn.committed) + assert.True(t, txn.discarded) + }) + + t.Run("commit error is returned", func(t *testing.T) { + migratorWithDGraph, mockDGraph, mockContainer := dgraphSetup(t) + txn := &fakeDgraphTxn{commitErr: context.DeadlineExceeded} + mockDGraph.EXPECT().NewTxn().Return(txn) + + err := migratorWithDGraph.commitMigration(mockContainer, td) + + require.ErrorIs(t, err, context.DeadlineExceeded) + }) + + t.Run("invalid transaction type", func(t *testing.T) { + migratorWithDGraph, mockDGraph, mockContainer := dgraphSetup(t) + mockDGraph.EXPECT().NewTxn().Return("not a txn") + + err := migratorWithDGraph.commitMigration(mockContainer, td) + + require.ErrorIs(t, err, errInvalidDgraphTxn) + }) + + t.Run("typed-nil transaction does not panic", func(t *testing.T) { + migratorWithDGraph, mockDGraph, mockContainer := dgraphSetup(t) + mockDGraph.EXPECT().NewTxn().Return((*fakeDgraphTxn)(nil)) + + err := migratorWithDGraph.commitMigration(mockContainer, td) + + require.ErrorIs(t, err, errInvalidDgraphTxn) + }) + + t.Run("skips record when dgraph not used", func(t *testing.T) { + migratorWithDGraph, _, mockContainer := dgraphSetup(t) + unused := transactionData{StartTime: time.Now(), MigrationNumber: 10} + + err := migratorWithDGraph.commitMigration(mockContainer, unused) + + require.NoError(t, err) + }) } func Test_DGraphBeginTransaction(t *testing.T) { From c181874856e5a2e49539c98f060a107a6b2f094d Mon Sep 17 00:00:00 2001 From: umar ahad uddin ahmed usmani <150610336+umarahad2005@users.noreply.github.com> Date: Mon, 7 Sep 2026 16:38:23 +0500 Subject: [PATCH 16/48] fix(crud): keep digits intact in toSnakeCase for auto-generated SQL (#3676) --- pkg/gofr/crud_helpers.go | 50 +++++++++++++++++++++- pkg/gofr/crud_helpers_test.go | 79 +++++++++++++++++++++++++++++++++++ 2 files changed, 127 insertions(+), 2 deletions(-) diff --git a/pkg/gofr/crud_helpers.go b/pkg/gofr/crud_helpers.go index 4bbb83bf5d..606fd98c2f 100644 --- a/pkg/gofr/crud_helpers.go +++ b/pkg/gofr/crud_helpers.go @@ -60,19 +60,58 @@ func parseSQLTag(inputTags reflect.StructTag) (sql.FieldConstraints, error) { return constraints, nil } +// snakeCaseHeadroom is how much room over the input length toSnakeCase reserves for the +// underscores it inserts. +// +// Grow rounds the capacity it takes up to a size class (8, 16, 24, 32, ...), so Grow(len(str)) +// already carries up to seven spare bytes and most names never regrow without this. What the +// headroom rescues is a name whose LENGTH lands exactly on a size class and whose output does +// not fit: "IsActive" is 8 bytes in and 9 out, so Grow(8) takes an 8-byte class and reallocates, +// while Grow(8+4) takes 16 and does not. Measured with testing.AllocsPerRun over a corpus of +// realistic field names, Grow(len) needs a second allocation for three of them and Grow(len+4) +// for none. +const snakeCaseHeadroom = 4 + +// toSnakeCase converts a Go identifier to the snake_case name used for a table or column. +// +// Only uppercase ASCII letters are special: they are lowercased, and -- when they begin a new +// word -- separated from what comes before with an underscore. Not every capital does: "IDCard" +// is "id_card", where the D begins no word and takes no underscore. +// +// Every other rune -- digits, underscores, punctuation, non-ASCII -- passes through untouched. +// The rule is stated positively on purpose. The earlier guard was +// `char >= 'a'`, which relies on an ordering accident, and everything below 'a' fell into the +// uppercase branch and had 32 added to it: "User1" became "user_Q", and "Field_1" became +// "field_\x7fQ", with a DEL control character in a SQL identifier. +// +// For ASCII identifiers the output matches the two regex-based converters -- datasource/sql +// ToSnakeCase, which this package already imports and which DB.Select uses to map result +// columns, and the Cassandra one. Non-ASCII is not covered: those lowercase with unicode rules +// and this loop only touches A-Z, so "MULLER" with an umlaut still keeps its capital. func toSnakeCase(str string) string { diff := 'a' - 'A' length := len(str) var builder strings.Builder + // Runs per request, per field: twice per field on a create (bindAndValidateEntity and + // extractFields) and once on an update, in crud_handlers.go. + builder.Grow(length + snakeCaseHeadroom) + for i, char := range str { - if char >= 'a' { + if char < 'A' || char > 'Z' { builder.WriteRune(char) continue } - if (i != 0 || i == length-1) && ((i > 0 && rune(str[i-1]) >= 'a') || (i < length-1 && rune(str[i+1]) >= 'a')) { + // An underscore goes in when the uppercase letter starts a new word: after a lowercase + // letter or a digit ("user2Name", "x509Cert"), or before a lowercase letter, which is + // what separates the last capital of an acronym from the word it begins ("userID" stays + // whole, "IDCard" splits). A digit only counts on the left -- "AB2" is one word. + prevStartsWord := i > 0 && isLowerOrDigit(rune(str[i-1])) + nextStartsWord := i < length-1 && isLower(rune(str[i+1])) + + if i != 0 && (prevStartsWord || nextStartsWord) { builder.WriteRune('_') } @@ -81,3 +120,10 @@ func toSnakeCase(str string) string { return builder.String() } + +// isLower reports whether r is a lowercase ASCII letter. Written out rather than reusing the +// `>= 'a'` shorthand this function used to rely on: that is true for every rune above 'a', +// including every non-ASCII one. +func isLower(r rune) bool { return r >= 'a' && r <= 'z' } + +func isLowerOrDigit(r rune) bool { return isLower(r) || (r >= '0' && r <= '9') } diff --git a/pkg/gofr/crud_helpers_test.go b/pkg/gofr/crud_helpers_test.go index 6c947d2abe..4cfce73d6f 100644 --- a/pkg/gofr/crud_helpers_test.go +++ b/pkg/gofr/crud_helpers_test.go @@ -26,6 +26,47 @@ func Test_toSnakeCase(t *testing.T) { {desc: "single lowercase char", input: "a", expected: "a"}, {desc: "single uppercase char", input: "A", expected: "a"}, {desc: "multiple uppercase sequence", input: "UserID", expected: "user_id"}, + {desc: "trailing digit", input: "User1", expected: "user1"}, + {desc: "digit after leading acronym", input: "S3Bucket", expected: "s3_bucket"}, + {desc: "digits within a word", input: "Base64Encoder", expected: "base64_encoder"}, + {desc: "digit between words", input: "User2Name", expected: "user2_name"}, + // The `char >= 'a'` guard corrupted every rune below 'a', not only digits: '_' (95) + // became DEL (127), putting a control character in a SQL identifier. + {desc: "underscore already present", input: "Field_1", expected: "field_1"}, + {desc: "leading underscore", input: "_User", expected: "__user"}, + // A digit ends a word, so an uppercase letter following one starts a new one. All five + // disagreed with the regex-based converters on development. Only the first two still did + // after the digit passthrough alone -- the other three were already right by then, and are + // here to hold the rule rather than to record a past difference. + {desc: "digit then acronym", input: "Order2FA", expected: "order2_fa"}, + {desc: "digit between single capitals", input: "A2B", expected: "a2_b"}, + {desc: "digit then lowercase word", input: "X509Cert", expected: "x509_cert"}, + {desc: "acronym then digit", input: "HTTP2Server", expected: "http2_server"}, + {desc: "mixed caps, digit, word", input: "OAuth2Client", expected: "o_auth2_client"}, + // ...but only on the left. A trailing digit does not split a leading acronym. + {desc: "acronym with trailing digit", input: "AB2", expected: "ab2"}, + {desc: "single capital then digit", input: "A1", expected: "a1"}, + {desc: "acronym then digit, no word", input: "ID2", expected: "id2"}, + // Non-ASCII passes through untouched; it is neither uppercase ASCII nor a word boundary. + {desc: "non-ASCII leading rune", input: "Ünicode", expected: "Ünicode"}, + // The bounds the two helpers turn on. Each is a single comparison, and a mutation that + // moves one is invisible unless a case sits exactly on it -- verified by moving all five + // and checking which cases fail. + // + // "ABé" pins the `r <= 'z'` half of isLower against being dropped, which is the whole + // reason isLower is written out rather than left as the old `r >= 'a'`. The byte read at + // str[i+1] there is 0xC3, the UTF-8 LEAD byte of 'é' -- numerically above 'a', so the old + // guard called it lowercase and inserted a word break that is not there. (A continuation + // byte, 0x80-0xBF, reaches the same wrong answer through str[i-1]; "CaféB" is that case.) + {desc: "capital before non-ASCII, isLower upper bound not dropped", input: "ABé", expected: "abé"}, + {desc: "capital after 'z', isLower upper bound", input: "AzB", expected: "az_b"}, + {desc: "capital after 'a', isLower lower bound", input: "AaB", expected: "aa_b"}, + {desc: "capital after '0', digit range lower bound", input: "A0B", expected: "a0_b"}, + {desc: "capital after '9', digit range upper bound", input: "X509CERT", expected: "x509_cert"}, + // The loop ranges over runes but indexes bytes, so `length` must stay len(str). With a + // multi-byte rune before the capital the two disagree: here the 'A' sits at byte index 2 of + // four, and a rune length of three would put it at the end and suppress the underscore. + {desc: "multi-byte rune before a capital, byte length", input: "éAb", expected: "é_ab"}, } for _, tc := range tests { @@ -36,6 +77,44 @@ func Test_toSnakeCase(t *testing.T) { } } +// Test_toSnakeCase_MatchesSQLConverter pins the agreement between this loop and the exported +// sql.ToSnakeCase, which DB.Select uses to map result columns back onto struct fields. The two +// are separate implementations of the same rule, and nothing but this test stops them drifting: +// before the digit fix they disagreed on 26,260 of the identifiers below, which meant an INSERT +// wrote one column name and a Select looked for another. +// +// ASCII only. The regex converter finishes with a Unicode-aware strings.ToLower and this loop +// only touches A-Z, so a non-ASCII capital still diverges -- a known gap, not a drift. +func Test_toSnakeCase_MatchesSQLConverter(t *testing.T) { + const alphabet = "abzABZ019_" + + n := len(alphabet) + identifiers := make([]string, 0, n+n*n+n*n*n) + + for _, a := range alphabet { + identifiers = append(identifiers, string(a)) + + for _, b := range alphabet { + identifiers = append(identifiers, string(a)+string(b)) + + for _, c := range alphabet { + identifiers = append(identifiers, string(a)+string(b)+string(c)) + } + } + } + + identifiers = append(identifiers, + "UserID", "HTTPServer", "OAuth2Client", "X509Cert", "Order2FA", "Base64Encoder", + "BillingAddressLine1", "SubscriptionExpiryTimestamp", "IsActive", "CreatedAt") + + for _, id := range identifiers { + if got, want := toSnakeCase(id), sql.ToSnakeCase(id); got != want { + t.Errorf("toSnakeCase(%q) = %q, sql.ToSnakeCase = %q -- the two converters have drifted", + id, got, want) + } + } +} + func Test_parseSQLTag(t *testing.T) { tests := []struct { desc string From 1a7882897afd58753b34ace40562874d2f85ba9b Mon Sep 17 00:00:00 2001 From: Om Kulkarni <127368012+om7057@users.noreply.github.com> Date: Tue, 8 Sep 2026 10:13:28 +0530 Subject: [PATCH 17/48] feat(metrics): add app_server_error/app_circuit_open_count counters + global metrics accessor (#3856) --- pkg/gofr/container/container.go | 1 + pkg/gofr/container/container_test.go | 1 + pkg/gofr/service/circuit_breaker.go | 11 ++++ pkg/gofr/service/circuit_breaker_test.go | 79 ++++++++++++++++++++++++ pkg/gofr/service/health_config_test.go | 1 + 5 files changed, 93 insertions(+) diff --git a/pkg/gofr/container/container.go b/pkg/gofr/container/container.go index 032c3149b5..2f8719d7ae 100644 --- a/pkg/gofr/container/container.go +++ b/pkg/gofr/container/container.go @@ -403,6 +403,7 @@ func (c *Container) registerFrameworkMetrics() { c.Metrics().NewHistogram("app_http_service_response", "Response time of HTTP service requests in seconds.", httpBuckets...) c.Metrics().NewCounter("app_http_retry_count", "Total number of retry events") c.Metrics().NewGauge("app_http_circuit_breaker_state", "Current state of the circuit breaker (0 for Closed, 1 for Open)") + c.Metrics().NewCounter("app_circuit_open_count", "Total number of times a service circuit breaker has opened.") } { // Redis metrics diff --git a/pkg/gofr/container/container_test.go b/pkg/gofr/container/container_test.go index df23fd0174..8ae51fd676 100644 --- a/pkg/gofr/container/container_test.go +++ b/pkg/gofr/container/container_test.go @@ -480,6 +480,7 @@ func TestContainer_registerFrameworkMetrics_RegistersExpectedMetrics(t *testing. "app_pubsub_subscribe_total_count", "app_pubsub_subscribe_success_count", "app_http_retry_count", + "app_circuit_open_count", } for _, counter := range counters { mockMetrics.EXPECT().NewCounter(counter, gomock.Any()).Times(1) diff --git a/pkg/gofr/service/circuit_breaker.go b/pkg/gofr/service/circuit_breaker.go index a579fec19e..18228d4eae 100644 --- a/pkg/gofr/service/circuit_breaker.go +++ b/pkg/gofr/service/circuit_breaker.go @@ -130,11 +130,22 @@ func (cb *circuitBreaker) startHealthChecks() { // openCircuit transitions the circuit breaker to the open state. func (cb *circuitBreaker) openCircuit() { + wasOpen := cb.state == OpenState cb.state = OpenState cb.lastChecked = time.Now() if cb.metrics != nil { cb.metrics.SetGauge("app_http_circuit_breaker_state", 1, "service", cb.serviceName) + + // Only count a real Closed -> Open transition. openCircuit is reached + // from handleFailure whenever failureCount > threshold, and every + // concurrent request that passed the isOpen check before the trip + // falls through to handleFailure and re-enters here — without this + // guard, a burst of N concurrent failures records N-threshold + // "openings" for what is a single transition. + if !wasOpen { + cb.metrics.IncrementCounter(context.Background(), "app_circuit_open_count", "service", cb.serviceName) + } } } diff --git a/pkg/gofr/service/circuit_breaker_test.go b/pkg/gofr/service/circuit_breaker_test.go index 9f5deaaf95..dfa9f9964a 100644 --- a/pkg/gofr/service/circuit_breaker_test.go +++ b/pkg/gofr/service/circuit_breaker_test.go @@ -41,6 +41,7 @@ func setupHTTPServiceTestServerForCircuitBreaker(t *testing.T) (*httptest.Server mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() // Initialize HTTP service with custom transport, URL, tracer, logger, and metrics service := httpService{ @@ -75,6 +76,7 @@ func TestHttpService_GetSuccessRequests(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, @@ -100,6 +102,7 @@ func TestHttpService_GetWithHeaderSuccessRequests(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, @@ -187,6 +190,7 @@ func TestHttpService_PutSuccessRequests(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, @@ -212,6 +216,7 @@ func TestHttpService_PutWithHeaderSuccessRequests(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, @@ -299,6 +304,7 @@ func TestHttpService_PatchSuccessRequests(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, @@ -324,6 +330,7 @@ func TestHttpService_PatchWithHeaderSuccessRequests(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, @@ -411,6 +418,7 @@ func TestHttpService_PostSuccessRequests(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, @@ -436,6 +444,7 @@ func TestHttpService_PostWithHeaderSuccessRequests(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, @@ -523,6 +532,7 @@ func TestHttpService_DeleteSuccessRequests(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, @@ -548,6 +558,7 @@ func TestHttpService_DeleteWithHeaderSuccessRequests(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, @@ -636,6 +647,9 @@ func TestCircuitBreaker_Metrics(t *testing.T) { mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge("app_http_circuit_breaker_state", 1.0, "service", "test-service").MinTimes(1) mockMetric.EXPECT().SetGauge("app_http_circuit_breaker_state", 0.0, "service", "test-service").AnyTimes() + // Exact count, not MinTimes: app_circuit_open_count must fire once for the + // Closed -> Open transition, not once per failing request that observes it. + mockMetric.EXPECT().IncrementCounter(gomock.Any(), "app_circuit_open_count", "service", "test-service").Times(1) service := httpService{ Client: &http.Client{Transport: &customTransport{}}, @@ -662,6 +676,64 @@ func TestCircuitBreaker_Metrics(t *testing.T) { } } +// TestCircuitBreaker_OpenCircuit_CountsTransitionNotFailures pins the fix for +// an app_circuit_open_count over-count found in review of #3856: openCircuit +// is reached from handleFailure whenever failureCount > threshold, and every +// concurrent request that passed the isOpen check before the trip falls +// through to handleFailure and re-enters openCircuit. Without a +// wasOpen guard, a burst of N concurrent failures recorded N-threshold +// "openings" for what is a single Closed -> Open transition — exactly +// concurrency-threshold, deterministic, and invisible to a MinTimes(1) +// assertion (or to sequential traffic, which happens to trigger the trip +// only once and so looks correct either way). +func TestCircuitBreaker_OpenCircuit_CountsTransitionNotFailures(t *testing.T) { + ctrl := gomock.NewController(t) + mockMetric := NewMockMetrics(ctrl) + + mockMetric.EXPECT().RecordHistogram(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), "app_circuit_open_count", "service", "test-service").Times(1) + + service := httpService{ + Client: &http.Client{Transport: &customTransport{}}, + url: "http://example.invalid", + name: "test-service", + Tracer: otel.Tracer("gofr-http-client"), + Logger: logging.NewMockLogger(logging.DEBUG), + Metrics: mockMetric, + } + + cbConfig := CircuitBreakerConfig{ + Threshold: 2, + // Long enough that the async health-check recovery goroutine cannot + // fire mid-test and interfere with the open-count assertion. + Interval: time.Minute, + } + + httpServiceWithCB := cbConfig.AddOption(&service) + + const concurrency = 30 + + var wg sync.WaitGroup + + for range concurrency { + wg.Add(1) + + go func() { + defer wg.Done() + + resp, _ := httpServiceWithCB.Get(t.Context(), "invalid", nil) + if resp != nil && resp.Body != nil { + _ = resp.Body.Close() + } + }() + } + + wg.Wait() +} + func TestCircuitBreaker_HTTP500_TripsCircuit(t *testing.T) { server := testServer() defer server.Close() @@ -674,6 +746,7 @@ func TestCircuitBreaker_HTTP500_TripsCircuit(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() service := httpService{ Client: &http.Client{Transport: &customTransport{}}, @@ -762,6 +835,7 @@ func TestCircuitBreaker_CustomHealthEndpoint_Recovery(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() httpSvc := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), @@ -825,6 +899,7 @@ func TestCircuitBreaker_DefaultHealthEndpoint_NoRecoveryWhenMissing(t *testing.T mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() // No HealthConfig - will use default /.well-known/alive which returns 404 httpSvc := NewHTTPService(server.URL, @@ -889,6 +964,7 @@ func TestCircuitBreaker_HealthEndpointWithTimeout(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() httpSvc := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), @@ -956,6 +1032,7 @@ func TestCircuitBreaker_ParallelExecution(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() httpSvc := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ @@ -1033,6 +1110,7 @@ func TestCircuitBreaker_ConcurrentFailures(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() httpSvc := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ @@ -1075,6 +1153,7 @@ func TestCircuitBreaker_MixedHTTPMethods(t *testing.T) { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() httpSvc := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ diff --git a/pkg/gofr/service/health_config_test.go b/pkg/gofr/service/health_config_test.go index cfede6f248..fa3c7c8855 100644 --- a/pkg/gofr/service/health_config_test.go +++ b/pkg/gofr/service/health_config_test.go @@ -23,6 +23,7 @@ func setupMockMetrics(t *testing.T) *MockMetrics { mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().IncrementCounter(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() return mockMetric } From e42b52e8f1a2c5b9a0cbb9db5b0dd84566311bcc Mon Sep 17 00:00:00 2001 From: Aditya Kumar Mishra <154746713+adityakrmishra@users.noreply.github.com> Date: Tue, 8 Sep 2026 11:02:16 +0530 Subject: [PATCH 18/48] test(service): fix flaky CB test intervals and add deterministic concurrent recovery test (#3755) --- pkg/gofr/service/circuit_breaker_test.go | 159 +++++++++++++++++++++-- 1 file changed, 148 insertions(+), 11 deletions(-) diff --git a/pkg/gofr/service/circuit_breaker_test.go b/pkg/gofr/service/circuit_breaker_test.go index dfa9f9964a..2807c5fc6c 100644 --- a/pkg/gofr/service/circuit_breaker_test.go +++ b/pkg/gofr/service/circuit_breaker_test.go @@ -7,6 +7,7 @@ import ( "net/http" "net/http/httptest" "sync" + "sync/atomic" "testing" "time" @@ -19,6 +20,27 @@ import ( "gofr.dev/pkg/gofr/testutil" ) +// The recovery interval these tests configure, and the wait a test does when it needs that +// interval to have elapsed. They are a pair: cbTestRecoveryWait must exceed +// cbTestInterval or a request that is supposed to find the circuit recoverable finds it +// still open, so neither can be tuned alone. +// +// The interval must also stay well above zero. CircuitBreakerConfig.Interval is a +// time.Duration, so the `Interval: 1` these tests used to carry meant one NANOSECOND, and +// NewCircuitBreaker feeds it straight to time.NewTicker in a background goroutine -- a +// ticker firing as fast as the runtime can deliver, for the life of the process, and going on +// firing after the test that created it has returned. +// +// Running the CBOpenRequests tests at -count=20 costs about 2s of CPU with these constants. +// The same run on the nanosecond interval costs tens of seconds to a few minutes -- one to two +// orders of magnitude more, and the figure swings by 5x between runs because it is a function +// of how much idle CPU the ticker finds. Only the small side of that comparison is stable, so +// it is the one quoted here. +const ( + cbTestInterval = 50 * time.Millisecond + cbTestRecoveryWait = 60 * time.Millisecond +) + func testServer() *httptest.Server { h := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusOK) @@ -56,7 +78,7 @@ func setupHTTPServiceTestServerForCircuitBreaker(t *testing.T) (*httptest.Server // Circuit breaker configuration cbConfig := CircuitBreakerConfig{ Threshold: 1, - Interval: 1, + Interval: cbTestInterval, } // Apply circuit breaker option to the HTTP service @@ -80,7 +102,7 @@ func TestHttpService_GetSuccessRequests(t *testing.T) { service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, - Interval: 1, + Interval: cbTestInterval, }) resp, err := service.Get(t.Context(), "test", nil) @@ -106,7 +128,7 @@ func TestHttpService_GetWithHeaderSuccessRequests(t *testing.T) { service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, - Interval: 1, + Interval: cbTestInterval, }) resp, err := service.GetWithHeaders(t.Context(), "test", nil, nil) @@ -135,6 +157,10 @@ func TestHttpService_GetCBOpenRequests(t *testing.T) { // Perform test cases for _, tc := range testCases { + if !tc.expectErr { + time.Sleep(cbTestRecoveryWait) + } + resp, err := service.Get(t.Context(), tc.path, nil) if tc.expectErr { @@ -166,6 +192,10 @@ func TestHttpService_GetWithHeaderCBOpenRequests(t *testing.T) { // Perform test cases for _, tc := range testCases { + if !tc.expectErr { + time.Sleep(cbTestRecoveryWait) + } + resp, err := service.GetWithHeaders(t.Context(), tc.path, nil, nil) if tc.expectErr { @@ -194,7 +224,7 @@ func TestHttpService_PutSuccessRequests(t *testing.T) { service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, - Interval: 1, + Interval: cbTestInterval, }) resp, err := service.Put(t.Context(), "test", nil, nil) @@ -220,7 +250,7 @@ func TestHttpService_PutWithHeaderSuccessRequests(t *testing.T) { service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, - Interval: 1, + Interval: cbTestInterval, }) resp, err := service.PutWithHeaders(t.Context(), "test", nil, nil, nil) @@ -249,6 +279,10 @@ func TestHttpService_PutCBOpenRequests(t *testing.T) { // Perform test cases for _, tc := range testCases { + if !tc.expectErr { + time.Sleep(cbTestRecoveryWait) + } + resp, err := service.Put(t.Context(), tc.path, nil, nil) if tc.expectErr { @@ -280,6 +314,10 @@ func TestHttpService_PutWithHeaderCBOpenRequests(t *testing.T) { // Perform test cases for _, tc := range testCases { + if !tc.expectErr { + time.Sleep(cbTestRecoveryWait) + } + resp, err := service.PutWithHeaders(t.Context(), tc.path, nil, nil, nil) if tc.expectErr { @@ -308,7 +346,7 @@ func TestHttpService_PatchSuccessRequests(t *testing.T) { service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, - Interval: 1, + Interval: cbTestInterval, }) resp, err := service.Get(t.Context(), "test", nil) @@ -334,7 +372,7 @@ func TestHttpService_PatchWithHeaderSuccessRequests(t *testing.T) { service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, - Interval: 1, + Interval: cbTestInterval, }) resp, err := service.GetWithHeaders(t.Context(), "test", nil, nil) @@ -363,6 +401,10 @@ func TestHttpService_PatchCBOpenRequests(t *testing.T) { // Perform test cases for _, tc := range testCases { + if !tc.expectErr { + time.Sleep(cbTestRecoveryWait) + } + resp, err := service.Patch(t.Context(), tc.path, nil, nil) if tc.expectErr { @@ -394,6 +436,10 @@ func TestHttpService_PatchWithHeaderCBOpenRequests(t *testing.T) { // Perform test cases for _, tc := range testCases { + if !tc.expectErr { + time.Sleep(cbTestRecoveryWait) + } + resp, err := service.PatchWithHeaders(t.Context(), tc.path, nil, nil, nil) if tc.expectErr { @@ -422,7 +468,7 @@ func TestHttpService_PostSuccessRequests(t *testing.T) { service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, - Interval: 1, + Interval: cbTestInterval, }) resp, err := service.Post(t.Context(), "test", nil, nil) @@ -448,7 +494,7 @@ func TestHttpService_PostWithHeaderSuccessRequests(t *testing.T) { service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, - Interval: 1, + Interval: cbTestInterval, }) resp, err := service.PostWithHeaders(t.Context(), "test", nil, nil, nil) @@ -477,6 +523,10 @@ func TestHttpService_PostCBOpenRequests(t *testing.T) { // Perform test cases for _, tc := range testCases { + if !tc.expectErr { + time.Sleep(cbTestRecoveryWait) + } + resp, err := service.Post(t.Context(), tc.path, nil, nil) if tc.expectErr { @@ -508,6 +558,10 @@ func TestHttpService_PostWithHeaderCBOpenRequests(t *testing.T) { // Perform test cases for _, tc := range testCases { + if !tc.expectErr { + time.Sleep(cbTestRecoveryWait) + } + resp, err := service.PostWithHeaders(t.Context(), tc.path, nil, nil, nil) if tc.expectErr { @@ -536,7 +590,7 @@ func TestHttpService_DeleteSuccessRequests(t *testing.T) { service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, - Interval: 1, + Interval: cbTestInterval, }) resp, err := service.Delete(t.Context(), "test", nil) @@ -562,7 +616,7 @@ func TestHttpService_DeleteWithHeaderSuccessRequests(t *testing.T) { service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ Threshold: 1, - Interval: 1, + Interval: cbTestInterval, }) resp, err := service.DeleteWithHeaders(t.Context(), "test", nil, nil) @@ -591,6 +645,10 @@ func TestHttpService_DeleteCBOpenRequests(t *testing.T) { // Perform test cases for _, tc := range testCases { + if !tc.expectErr { + time.Sleep(cbTestRecoveryWait) + } + resp, err := service.Delete(t.Context(), tc.path, nil) if tc.expectErr { @@ -622,6 +680,10 @@ func TestHttpService_DeleteWithHeaderCBOpenRequests(t *testing.T) { // Perform test cases for _, tc := range testCases { + if !tc.expectErr { + time.Sleep(cbTestRecoveryWait) + } + resp, err := service.DeleteWithHeaders(t.Context(), tc.path, nil, nil) if tc.expectErr { @@ -1285,3 +1347,78 @@ func TestCircuitBreaker_SlowHealthCheckDoesNotBlock(t *testing.T) { cb.mu.RUnlock() assert.Equal(t, ClosedState, state, "circuit should be closed after successful recovery") } + +// TestCircuitBreaker_ConcurrentRecovery_OnlyOneResetsCircuit verifies that when N +// goroutines simultaneously discover the circuit is open and the recovery interval has +// elapsed, exactly ONE goroutine fires the health check and resets the circuit. +// The test is deterministic: the mock health check blocks until all N-1 "loser" +// goroutines have returned from tryCircuitRecovery, proving they were turned away +// without calling HealthCheck. If two goroutines won the race the othersDone channel +// would never close and the test would fail with a timeout error. +func TestCircuitBreaker_ConcurrentRecovery_OnlyOneResetsCircuit(t *testing.T) { + const numGoroutines = 20 + + var healthCallCount int64 + + var returned int64 + + othersDone := make(chan struct{}) + + var once sync.Once + + ctrl := gomock.NewController(t) + mockHTTP := NewMockHTTP(ctrl) + + mockHTTP.EXPECT(). + HealthCheck(gomock.Any()). + DoAndReturn(func(_ context.Context) *Health { + atomic.AddInt64(&healthCallCount, 1) + + select { + case <-othersDone: + case <-time.After(2 * time.Second): // Bounded wait so the test fails instead of hanging on mutants + t.Error("test timed out waiting for losers to finish") + } + + return &Health{Status: serviceUp} + }). + AnyTimes() + + cb := &circuitBreaker{ + state: OpenState, + threshold: 1, + interval: time.Hour, + lastChecked: time.Now().Add(-2 * time.Hour), // Force interval to have elapsed + HTTP: mockHTTP, + } + + startCh := make(chan struct{}) + + var wg sync.WaitGroup + wg.Add(numGoroutines) + + for i := 0; i < numGoroutines; i++ { + go func() { + defer wg.Done() + + <-startCh + + cb.tryCircuitRecovery() + + if atomic.AddInt64(&returned, 1) == numGoroutines-1 { + once.Do(func() { close(othersDone) }) + } + }() + } + + close(startCh) + + wg.Wait() + + assert.Equal(t, int64(1), atomic.LoadInt64(&healthCallCount), "health check should be called exactly once") + + cb.mu.RLock() + state := cb.state + cb.mu.RUnlock() + assert.Equal(t, ClosedState, state, "circuit should be closed after successful recovery") +} From c3583094d4a96faf0a0d8375328209302ae87e0b Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 8 Sep 2026 15:50:39 +0530 Subject: [PATCH 19/48] chore(deps): bump the go_modules group across 12 directories with 1 update (#4153) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Aryan Mehrotra --- examples/using-add-filestore/go.mod | 2 +- examples/using-add-filestore/go.sum | 4 +- examples/using-cloudsql/go.mod | 58 ++++---- examples/using-cloudsql/go.sum | 142 +++++++++---------- examples/using-gcp-metrics/go.mod | 65 ++++----- examples/using-gcp-metrics/go.sum | 157 ++++++++++----------- examples/using-s3-filestore/go.mod | 2 +- examples/using-s3-filestore/go.sum | 4 +- go.mod | 6 +- go.sum | 12 +- pkg/gofr/datasource/cloudsql/go.mod | 6 +- pkg/gofr/datasource/cloudsql/go.sum | 12 +- pkg/gofr/datasource/couchbase/go.mod | 6 +- pkg/gofr/datasource/couchbase/go.sum | 12 +- pkg/gofr/datasource/dbresolver/go.mod | 6 +- pkg/gofr/datasource/dbresolver/go.sum | 12 +- pkg/gofr/datasource/dgraph/go.mod | 6 +- pkg/gofr/datasource/dgraph/go.sum | 12 +- pkg/gofr/datasource/file/gcs/go.mod | 6 +- pkg/gofr/datasource/file/gcs/go.sum | 12 +- pkg/gofr/datasource/kv-store/badger/go.mod | 2 +- pkg/gofr/datasource/kv-store/badger/go.sum | 4 +- pkg/gofr/datasource/oracle/go.mod | 6 +- pkg/gofr/datasource/oracle/go.sum | 12 +- pkg/gofr/metrics/exporters/gcp/go.mod | 7 +- pkg/gofr/metrics/exporters/gcp/go.sum | 24 ++-- 26 files changed, 296 insertions(+), 301 deletions(-) diff --git a/examples/using-add-filestore/go.mod b/examples/using-add-filestore/go.mod index 826f25528c..c7ff5f4e7e 100644 --- a/examples/using-add-filestore/go.mod +++ b/examples/using-add-filestore/go.mod @@ -95,7 +95,7 @@ require ( google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect - google.golang.org/grpc v1.83.0 // indirect + google.golang.org/grpc v1.83.1 // indirect google.golang.org/protobuf v1.36.11 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect modernc.org/libc v1.74.4 // indirect diff --git a/examples/using-add-filestore/go.sum b/examples/using-add-filestore/go.sum index ef46665d3d..7649b4057d 100644 --- a/examples/using-add-filestore/go.sum +++ b/examples/using-add-filestore/go.sum @@ -356,8 +356,8 @@ google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyac google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= -google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= +google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= diff --git a/examples/using-cloudsql/go.mod b/examples/using-cloudsql/go.mod index c162016b0b..19f87d5581 100644 --- a/examples/using-cloudsql/go.mod +++ b/examples/using-cloudsql/go.mod @@ -9,13 +9,14 @@ require ( require ( cloud.google.com/go v0.123.0 // indirect - cloud.google.com/go/auth v0.20.0 // indirect + cloud.google.com/go/auth v0.22.0 // indirect cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect - cloud.google.com/go/cloudsqlconn v1.22.1 // indirect + cloud.google.com/go/cloudsqlconn v1.25.1 // indirect cloud.google.com/go/compute/metadata v0.9.0 // indirect - cloud.google.com/go/iam v1.11.0 // indirect - cloud.google.com/go/pubsub v1.50.2 // indirect - cloud.google.com/go/pubsub/v2 v2.5.1 // indirect + cloud.google.com/go/iam v1.12.0 // indirect + cloud.google.com/go/pubsub v1.51.0 // indirect + cloud.google.com/go/pubsub/v2 v2.6.0 // indirect + cloud.google.com/go/sql v0.1.0 // indirect filippo.io/edwards25519 v1.2.0 // indirect github.com/DATA-DOG/go-sqlmock v1.5.2 // indirect github.com/XSAM/otelsql v0.42.0 // indirect @@ -23,12 +24,11 @@ require ( github.com/beorn7/perks v1.0.1 // indirect github.com/cenkalti/backoff/v5 v5.0.3 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/eclipse/paho.mqtt.golang v1.5.1 // indirect github.com/felixge/httpsnoop v1.1.0 // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-sql-driver/mysql v1.10.0 // indirect github.com/gogo/protobuf v1.3.2 // indirect @@ -36,8 +36,8 @@ require ( github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect github.com/google/s2a-go v0.1.9 // indirect github.com/google/uuid v1.6.0 // indirect - github.com/googleapis/enterprise-certificate-proxy v0.3.17 // indirect - github.com/googleapis/gax-go/v2 v2.22.0 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.19 // indirect + github.com/googleapis/gax-go/v2 v2.23.0 // indirect github.com/gorilla/mux v1.8.1 // indirect github.com/gorilla/websocket v1.5.3 // indirect github.com/graphql-go/graphql v0.8.1 // indirect @@ -56,7 +56,6 @@ require ( github.com/openzipkin/zipkin-go v0.4.3 // indirect github.com/pierrec/lz4/v4 v4.1.25 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/prometheus/client_golang v1.23.2 // indirect github.com/prometheus/client_model v0.6.2 // indirect github.com/prometheus/common v0.67.5 // indirect @@ -67,7 +66,7 @@ require ( github.com/redis/go-redis/v9 v9.21.0 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect github.com/segmentio/kafka-go v0.4.51 // indirect - github.com/stretchr/testify v1.11.1 // indirect + github.com/stretchr/testify v1.12.1 // indirect github.com/vektah/gqlparser/v2 v2.5.36 // indirect github.com/xdg-go/pbkdf2 v1.0.0 // indirect github.com/xdg-go/scram v1.1.2 // indirect @@ -76,34 +75,35 @@ require ( go.opentelemetry.io/auto/sdk v1.2.1 // indirect go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 // indirect go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 // indirect - go.opentelemetry.io/otel v1.44.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 // indirect + go.opentelemetry.io/otel v1.45.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 // indirect go.opentelemetry.io/otel/exporters/prometheus v0.65.0 // indirect go.opentelemetry.io/otel/exporters/zipkin v1.44.0 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - go.opentelemetry.io/otel/sdk v1.44.0 // indirect - go.opentelemetry.io/otel/sdk/metric v1.44.0 // indirect - go.opentelemetry.io/otel/trace v1.44.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/sdk v1.45.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect + go.opentelemetry.io/otel/trace v1.45.0 // indirect go.opentelemetry.io/proto/otlp v1.10.0 // indirect go.uber.org/atomic v1.11.0 // indirect go.uber.org/mock v0.6.0 // indirect go.yaml.in/yaml/v2 v2.4.4 // indirect - golang.org/x/crypto v0.53.0 // indirect - golang.org/x/net v0.56.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/crypto v0.55.0 // indirect + golang.org/x/net v0.57.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect - golang.org/x/sync v0.21.0 // indirect - golang.org/x/sys v0.46.0 // indirect - golang.org/x/term v0.44.0 // indirect - golang.org/x/text v0.38.0 // indirect + golang.org/x/sync v0.22.0 // indirect + golang.org/x/sys v0.47.0 // indirect + golang.org/x/term v0.45.0 // indirect + golang.org/x/text v0.41.0 // indirect golang.org/x/time v0.15.0 // indirect - google.golang.org/api v0.287.0 // indirect - google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20260615183401-62b3387ff324 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d // indirect - google.golang.org/grpc v1.83.0 // indirect - google.golang.org/protobuf v1.36.11 // indirect + google.golang.org/api v0.291.0 // indirect + google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect + google.golang.org/grpc v1.83.1 // indirect + google.golang.org/protobuf v1.36.12 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect modernc.org/libc v1.73.4 // indirect modernc.org/mathutil v1.7.1 // indirect diff --git a/examples/using-cloudsql/go.sum b/examples/using-cloudsql/go.sum index 78de11c736..917e84f4e2 100644 --- a/examples/using-cloudsql/go.sum +++ b/examples/using-cloudsql/go.sum @@ -1,24 +1,26 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE= cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU= -cloud.google.com/go/auth v0.20.0 h1:kXTssoVb4azsVDoUiF8KvxAqrsQcQtB53DcSgta74CA= -cloud.google.com/go/auth v0.20.0/go.mod h1:942/yi/itH1SsmpyrbnTMDgGfdy2BUqIKyd0cyYLc5Q= +cloud.google.com/go/auth v0.22.0 h1:Xp9wAKkLoeaYb5pYZZoQGz4E9sdPxIbzS3gywZE3ciQ= +cloud.google.com/go/auth v0.22.0/go.mod h1:M9o2Oz+YI2jAfxewJgb1vyI3vceHF+eohmxyzmrl+9s= cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc= cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= -cloud.google.com/go/cloudsqlconn v1.22.1 h1:c4HkWMSV4pDL8kJid+nIuF+6iE07pR5Mn/sRVY17wf4= -cloud.google.com/go/cloudsqlconn v1.22.1/go.mod h1:p7l+u0ThOzSvC5a4fkywi1hEyD8S709X1zEqux9tsq0= +cloud.google.com/go/cloudsqlconn v1.25.1 h1:NSm9zyFySRjFivbOSGi0Mv5VS59SNel7OnWkkMmKUa8= +cloud.google.com/go/cloudsqlconn v1.25.1/go.mod h1:yBjHpKuIGsmVTrqgMqfAvs1o3V0f8ee+wCiCkM61UjI= cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10= -cloud.google.com/go/iam v1.11.0 h1:KieQ9Pb+LLPak1O3Rv3GgCxhnmkYf7Xyh0P5HfF1jFM= -cloud.google.com/go/iam v1.11.0/go.mod h1:KP+nKGugNJW4LcLx1uEZcq1ok5sQHFaQehQNl4QDgV4= -cloud.google.com/go/kms v1.31.0 h1:LS8N92OxFDgOLg5NCo3OmbvjtQAIVT5gUHVLKIDHaFE= -cloud.google.com/go/kms v1.31.0/go.mod h1:YIyXZym11R5uovJJt4oN5eUL3oPmirF3yKeIh6QAf4U= -cloud.google.com/go/longrunning v1.0.0 h1:lwzWEYD8+NkYV7dhexOz6kmlvajZA70+bW/xMhRVVdY= -cloud.google.com/go/longrunning v1.0.0/go.mod h1:8nqFBPOO1U/XkhWl0I19AMZEphrHi73VNABIpKYaTwM= -cloud.google.com/go/pubsub v1.50.2 h1:54Up97HnThdP4H8jjWJSSQ/mnYG2EKon7ZSNETRq0tM= -cloud.google.com/go/pubsub v1.50.2/go.mod h1:jyCWeZdGFqd4mitSsBERnJcpqaHBsxQoPkNvjj4sp0w= -cloud.google.com/go/pubsub/v2 v2.5.1 h1:+TwXJr78P9RrMV3S8lKHIhJo2E99jI7ta65e+ujJjts= -cloud.google.com/go/pubsub/v2 v2.5.1/go.mod h1:Pd+qeabMX+576vQJhTN7TelE4k6kJh15dLU/ptOQ/UA= +cloud.google.com/go/iam v1.12.0 h1:Aki3bX9aHUDKPHfnRJfDcTdVedvy6quGBQcTqx3DRXk= +cloud.google.com/go/iam v1.12.0/go.mod h1:FEZ4lXpADAC2AIpQY7LANNjjwyQ2jK439CI2VaD+sLY= +cloud.google.com/go/kms v1.32.0 h1:s+rEluaaZKhLVjrIWG7uNBsnWbiitElzNzFGyp6+nIg= +cloud.google.com/go/kms v1.32.0/go.mod h1:CSGvW6GnMQbY+1nOHcIzhMtHSbExXlOmCKjWtYVjcpA= +cloud.google.com/go/longrunning v1.2.0 h1:WjYH3YHBGCxGJP9M4dWGHBfXr/cFIjMkNgWcJj7/iMM= +cloud.google.com/go/longrunning v1.2.0/go.mod h1:5KMQALFGOCtFoi2xSOA1u3H7WKlhmckgiyFw7+LGQp0= +cloud.google.com/go/pubsub v1.51.0 h1:XOaCejsqX7EEtUdQz+WPag66wWsUUGliyCOfGPKfo90= +cloud.google.com/go/pubsub v1.51.0/go.mod h1:NERXf11sd82UV3VnflcUj8POIyQUXT/QwrKlxD8di/I= +cloud.google.com/go/pubsub/v2 v2.6.0 h1:8pjR0id+GTB+krKx5G6AGJoYrHog58w2Q89PCOrfM64= +cloud.google.com/go/pubsub/v2 v2.6.0/go.mod h1:4anqvV/w8Pcgu2tO0qr2XgsF3GXHowzryfQ5gOnVmWY= +cloud.google.com/go/sql v0.1.0 h1:WNRz/Xe/jeR7ChgaQ8vahbX7zAF/mRPZshvVlMtkbws= +cloud.google.com/go/sql v0.1.0/go.mod h1:LZWBMAQhN4oBgqz3GRcpNTom8+U2v97D7d5qLiZmZlg= filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo= filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= @@ -49,8 +51,6 @@ github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2 h1:aBangftG7EVZoUb69Os github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2/go.mod h1:qwXFYgsP6T7XnJtbKlf1HP8AjxZZyzxMmc+Lq5GjlU4= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d h1:abDbP7XBVgwda+h0J5Qra5p2OQpidU2FdkXvzCKL+H8= github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d/go.mod h1:wKFzULXAPj3U2BDAPWXhSbQQNC6FU1+1/5iika6IY7g= github.com/dgryski/trifles v0.0.0-20230903005119-f50d829f2e54 h1:SG7nF6SRlWhcT7cNTs5R6Hk4V2lcmLz2NsG2VnInyNo= @@ -71,8 +71,8 @@ github.com/envoyproxy/protoc-gen-validate v1.3.3/go.mod h1:TsndJ/ngyIdQRhMcVVGDD github.com/felixge/httpsnoop v1.1.0 h1:3YtUj32ZZkqZtt3sZZsClsymw/QDuVfpNhoA31zeORc= github.com/felixge/httpsnoop v1.1.0/go.mod h1:Zqxgdd+1Rkcz8euOqdr7lqgCRJztwr5hp9vDSi5UZCE= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-redis/redismock/v9 v9.2.0 h1:ZrMYQeKPECZPjOj5u9eyOjg8Nnb0BS9lkVIZ6IpsKLw= @@ -118,10 +118,10 @@ github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/enterprise-certificate-proxy v0.3.17 h1:73NfMHdiqo9JFU9+7a5ExpVa10/R29pXfZIaW559nrg= -github.com/googleapis/enterprise-certificate-proxy v0.3.17/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= -github.com/googleapis/gax-go/v2 v2.22.0 h1:PjIWBpgGIVKGoCXuiCoP64altEJCj3/Ei+kSU5vlZD4= -github.com/googleapis/gax-go/v2 v2.22.0/go.mod h1:irWBbALSr0Sk3qlqb9SyJ1h68WjgeFuiOzI4Rqw5+aY= +github.com/googleapis/enterprise-certificate-proxy v0.3.19 h1:mMOE7DN2+p76/EdIrmAy9B9bH+yC4563vmnJ34QR8i4= +github.com/googleapis/enterprise-certificate-proxy v0.3.19/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= +github.com/googleapis/gax-go/v2 v2.23.0 h1:Tchl7qkvE7Ip3y+ztvNufYFvkfqTe7NfLTYGIdJRLuE= +github.com/googleapis/gax-go/v2 v2.23.0/go.mod h1:rBQKOVJCdb8IFEzg+FCwlt1LP/xMDGuqUXhUG+XMXEg= github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= @@ -176,8 +176,6 @@ github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= @@ -206,15 +204,15 @@ github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+D github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/vektah/gqlparser/v2 v2.5.36 h1:CN9mKVHgMkc+XftdOWIhb4HEL8wKSYkFAqhf8booa7s= github.com/vektah/gqlparser/v2 v2.5.36/go.mod h1:cAJ9qwVgPaUkWv6Gn8vn0mqOE0Ui5Pn56wNy5396XWo= github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c= @@ -240,10 +238,10 @@ go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.6 go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0/go.mod h1:Sje3i3MjSPKTSPvVWCaL8ugBzJwik3u4smCjUeuupqg= go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0 h1:MCcYL7J6Vt/X0kjqbMZkekCmwsurbQRbL69vkiye2lk= go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0/go.mod h1:3jnStNwSufK+f5ktjL4EPcwtig4rtd81NS70lqHuXl8= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 h1:8tvICD4vSTOOsNrsI4Ljf6C+6UKvpTEH5XY3JMoyPoo= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0/go.mod h1:z9+yiacE0IHRqM4qFfkbt/JYlmYXgss8GY/jXoNuPJI= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 h1:LMuyCAyfalSjDyjdC65nK6N0zoTT63+E/u95X0JovZI= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0/go.mod h1:085m8qbm4hgc8rZWGDEa4vmyyo2c3nPxUslYUKUIU04= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0 h1:4YsVu3B8+3qtWYYrsUYgn0OG78pN0rnNPRGX4SbokQI= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0/go.mod h1:+wnlSn0mD1ADVMe3v9Z/WIaiz6q6gL2J/ejaAmdmv80= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 h1:qazEJlUOQzhCpzQpFETGby7EdqjI1wsd0W+6Gg1SCTU= @@ -252,16 +250,16 @@ go.opentelemetry.io/otel/exporters/prometheus v0.65.0 h1:jOveH/b4lU9HT7y+Gfamf18 go.opentelemetry.io/otel/exporters/prometheus v0.65.0/go.mod h1:i1P8pcumauPtUI4YNopea1dhzEMuEqWP1xoUZDylLHo= go.opentelemetry.io/otel/exporters/zipkin v1.44.0 h1:zv7PRYGLrQHkdeZj0c5SNAZOJcw55XgaTezUkNpwA+w= go.opentelemetry.io/otel/exporters/zipkin v1.44.0/go.mod h1:3+VZyCi6hFW+UuxFF+wSOvwsOwncfBpQfP7Qdb3JXKg= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/metric/x v0.66.0 h1:YkCrx1zLOChi9ZcZ6euupOcsgzbVlec7D/xoEU1+cTA= -go.opentelemetry.io/otel/metric/x v0.66.0/go.mod h1:d1+BDj9t96do0/1LoU1ayfCv79ZgNE41qbhBvnMOBZk= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= -go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/metric/x v0.67.0 h1:PcicCNZFkZ4bXfSooXdo3WN7RBOVOtjVdo1wD358Uns= +go.opentelemetry.io/otel/metric/x v0.67.0/go.mod h1:FBjCWZe6wgcqxcMtjdGiClDKXb2YxxXii0CXftE4QtI= +go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= +go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= +go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= +go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.opentelemetry.io/proto/otlp v1.10.0 h1:IQRWgT5srOCYfiWnpqUYz9CVmbO8bFmKcwYxpuCSL2g= go.opentelemetry.io/proto/otlp v1.10.0/go.mod h1:/CV4QoCR/S9yaPj8utp3lvQPoqMtxXdzn7ozvvozVqk= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= @@ -272,16 +270,16 @@ go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= -go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= -go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto= -golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= @@ -289,8 +287,8 @@ golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHl golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4= -golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ= +golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk= +golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -302,8 +300,8 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o= -golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= +golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= +golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= @@ -313,8 +311,8 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM= -golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= +golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek= +golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -324,18 +322,18 @@ golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw= -golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.44.0 h1:0rLvDRCtNj0gZkyIXhCyOb2OAzEhLVqc4B+hrsBhrmc= -golang.org/x/term v0.44.0/go.mod h1:7ze4MdzUzLXpSAoFP1H0bOI9aXDqveSvatT5vKcFh2Y= +golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= +golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= -golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE= -golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -347,34 +345,34 @@ golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8= -golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0= +golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE= +golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/api v0.287.0 h1:CQDMqUiqZZ0U/Yge3zyjAhNQ0OSYEH0PaA7l4xtEen4= -google.golang.org/api v0.287.0/go.mod h1:pPW85yt3Iuc3unkpaMhFtMmOqnTdCwCqEOaUlnuxRlQ= +google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= +google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= -google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94 h1:YJjbgu+dkp5kUJLfpMyCLfBIWZb/FcJyuLeo1gVBOuo= -google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94/go.mod h1:RRHjglSYABVCWpQ7USCpdfhcd9t4PkajvVwyynZizTc= -google.golang.org/genproto/googleapis/api v0.0.0-20260615183401-62b3387ff324 h1:g0RAkxK/smSu/iRwC/KIX1mwUoVJtk2OjbgaeS4DmUM= -google.golang.org/genproto/googleapis/api v0.0.0-20260615183401-62b3387ff324/go.mod h1:Z4WJ5pJOYWFWcHEQUelD5QaZDknIQkpIL/+fyJOT9+A= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d h1:mpAgMyM9vQHxycBlDq50y1VHpfSfVwzXvrQKtYbXuUY= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260622175928-b703f567277d/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd h1:0GnSESHqea5EoaQgJyYxC3o5m0L191gCQdDgo2cxO5I= +google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= -google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= +google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -384,8 +382,8 @@ google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= -google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= -google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= diff --git a/examples/using-gcp-metrics/go.mod b/examples/using-gcp-metrics/go.mod index 2e984db114..1ceb46b737 100644 --- a/examples/using-gcp-metrics/go.mod +++ b/examples/using-gcp-metrics/go.mod @@ -3,38 +3,38 @@ module gofr.dev/examples/using-gcp-metrics go 1.26.0 require ( - gofr.dev v1.57.0 + gofr.dev v1.60.1 gofr.dev/pkg/gofr/metrics/exporters/gcp v0.0.0 ) require ( cloud.google.com/go v0.123.0 // indirect - cloud.google.com/go/auth v0.20.0 // indirect + cloud.google.com/go/auth v0.22.0 // indirect cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect cloud.google.com/go/compute/metadata v0.9.0 // indirect - cloud.google.com/go/iam v1.11.0 // indirect + cloud.google.com/go/iam v1.12.0 // indirect cloud.google.com/go/pubsub v1.51.0 // indirect cloud.google.com/go/pubsub/v2 v2.6.0 // indirect filippo.io/edwards25519 v1.2.0 // indirect github.com/DATA-DOG/go-sqlmock v1.5.2 // indirect + github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.33.0 // indirect github.com/XSAM/otelsql v0.43.0 // indirect github.com/agnivade/levenshtein v1.2.1 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/cenkalti/backoff/v5 v5.0.3 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/eclipse/paho.mqtt.golang v1.5.1 // indirect github.com/felixge/httpsnoop v1.1.0 // indirect - github.com/go-logr/logr v1.4.3 // indirect + github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-sql-driver/mysql v1.10.0 // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/golang-jwt/jwt/v5 v5.3.1 // indirect github.com/google/s2a-go v0.1.9 // indirect github.com/google/uuid v1.6.0 // indirect - github.com/googleapis/enterprise-certificate-proxy v0.3.17 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.19 // indirect github.com/googleapis/gax-go/v2 v2.23.0 // indirect github.com/gorilla/mux v1.8.1 // indirect github.com/gorilla/websocket v1.5.3 // indirect @@ -42,68 +42,69 @@ require ( github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.3.3 // indirect github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 // indirect github.com/joho/godotenv v1.5.1 // indirect - github.com/klauspost/compress v1.19.0 // indirect + github.com/klauspost/compress v1.19.2 // indirect github.com/lib/pq v1.12.3 // indirect - github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-isatty v0.0.24 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/ncruces/go-strftime v1.0.0 // indirect github.com/openzipkin/zipkin-go v0.4.3 // indirect github.com/pierrec/lz4/v4 v4.1.27 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/prometheus/client_golang v1.24.0 // indirect + github.com/prometheus/client_golang v1.24.1 // indirect github.com/prometheus/client_model v0.6.2 // indirect - github.com/prometheus/common v0.70.0 // indirect + github.com/prometheus/common v0.70.1 // indirect github.com/prometheus/otlptranslator v1.0.0 // indirect github.com/prometheus/procfs v0.21.1 // indirect github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0 // indirect github.com/redis/go-redis/extra/redisotel/v9 v9.21.0 // indirect - github.com/redis/go-redis/v9 v9.21.0 // indirect + github.com/redis/go-redis/v9 v9.22.0 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect github.com/segmentio/kafka-go v0.4.51 // indirect - github.com/stretchr/testify v1.11.1 // indirect + github.com/stretchr/testify v1.12.1 // indirect github.com/vektah/gqlparser/v2 v2.5.36 // indirect github.com/xdg-go/pbkdf2 v1.0.0 // indirect github.com/xdg-go/scram v1.1.2 // indirect github.com/xdg-go/stringprep v1.0.4 // indirect go.opencensus.io v0.24.0 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect + go.opentelemetry.io/contrib/detectors/gcp v1.44.0 // indirect go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0 // indirect - go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 // indirect - go.opentelemetry.io/otel v1.44.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 // indirect + go.opentelemetry.io/otel v1.45.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.44.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 // indirect - go.opentelemetry.io/otel/exporters/prometheus v0.65.0 // indirect + go.opentelemetry.io/otel/exporters/prometheus v0.67.0 // indirect go.opentelemetry.io/otel/exporters/zipkin v1.44.0 // indirect - go.opentelemetry.io/otel/metric v1.44.0 // indirect - go.opentelemetry.io/otel/sdk v1.44.0 // indirect - go.opentelemetry.io/otel/sdk/metric v1.44.0 // indirect - go.opentelemetry.io/otel/trace v1.44.0 // indirect + go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/sdk v1.45.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect + go.opentelemetry.io/otel/trace v1.45.0 // indirect go.opentelemetry.io/proto/otlp v1.10.0 // indirect go.uber.org/atomic v1.11.0 // indirect go.uber.org/mock v0.6.0 // indirect - golang.org/x/crypto v0.54.0 // indirect - golang.org/x/net v0.56.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/crypto v0.55.0 // indirect + golang.org/x/net v0.57.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect golang.org/x/sync v0.22.0 // indirect golang.org/x/sys v0.47.0 // indirect golang.org/x/term v0.45.0 // indirect - golang.org/x/text v0.40.0 // indirect + golang.org/x/text v0.41.0 // indirect golang.org/x/time v0.15.0 // indirect - google.golang.org/api v0.288.0 // indirect - google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20260630182238-925bb5da69e7 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260630182238-925bb5da69e7 // indirect - google.golang.org/grpc v1.82.1 // indirect - google.golang.org/protobuf v1.36.11 // indirect + google.golang.org/api v0.291.0 // indirect + google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect + google.golang.org/grpc v1.83.1 // indirect + google.golang.org/protobuf v1.36.12 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect - modernc.org/libc v1.74.1 // indirect + modernc.org/libc v1.74.4 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.11.0 // indirect - modernc.org/sqlite v1.54.0 // indirect + modernc.org/sqlite v1.56.0 // indirect ) replace gofr.dev => ../../ diff --git a/examples/using-gcp-metrics/go.sum b/examples/using-gcp-metrics/go.sum index 52d59a5bd2..3336e317d9 100644 --- a/examples/using-gcp-metrics/go.sum +++ b/examples/using-gcp-metrics/go.sum @@ -1,16 +1,16 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE= cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU= -cloud.google.com/go/auth v0.20.0 h1:kXTssoVb4azsVDoUiF8KvxAqrsQcQtB53DcSgta74CA= -cloud.google.com/go/auth v0.20.0/go.mod h1:942/yi/itH1SsmpyrbnTMDgGfdy2BUqIKyd0cyYLc5Q= +cloud.google.com/go/auth v0.22.0 h1:Xp9wAKkLoeaYb5pYZZoQGz4E9sdPxIbzS3gywZE3ciQ= +cloud.google.com/go/auth v0.22.0/go.mod h1:M9o2Oz+YI2jAfxewJgb1vyI3vceHF+eohmxyzmrl+9s= cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc= cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10= -cloud.google.com/go/iam v1.11.0 h1:KieQ9Pb+LLPak1O3Rv3GgCxhnmkYf7Xyh0P5HfF1jFM= -cloud.google.com/go/iam v1.11.0/go.mod h1:KP+nKGugNJW4LcLx1uEZcq1ok5sQHFaQehQNl4QDgV4= -cloud.google.com/go/kms v1.31.0 h1:LS8N92OxFDgOLg5NCo3OmbvjtQAIVT5gUHVLKIDHaFE= -cloud.google.com/go/kms v1.31.0/go.mod h1:YIyXZym11R5uovJJt4oN5eUL3oPmirF3yKeIh6QAf4U= +cloud.google.com/go/iam v1.12.0 h1:Aki3bX9aHUDKPHfnRJfDcTdVedvy6quGBQcTqx3DRXk= +cloud.google.com/go/iam v1.12.0/go.mod h1:FEZ4lXpADAC2AIpQY7LANNjjwyQ2jK439CI2VaD+sLY= +cloud.google.com/go/kms v1.32.0 h1:s+rEluaaZKhLVjrIWG7uNBsnWbiitElzNzFGyp6+nIg= +cloud.google.com/go/kms v1.32.0/go.mod h1:CSGvW6GnMQbY+1nOHcIzhMtHSbExXlOmCKjWtYVjcpA= cloud.google.com/go/longrunning v1.2.0 h1:WjYH3YHBGCxGJP9M4dWGHBfXr/cFIjMkNgWcJj7/iMM= cloud.google.com/go/longrunning v1.2.0/go.mod h1:5KMQALFGOCtFoi2xSOA1u3H7WKlhmckgiyFw7+LGQp0= cloud.google.com/go/pubsub v1.51.0 h1:XOaCejsqX7EEtUdQz+WPag66wWsUUGliyCOfGPKfo90= @@ -22,6 +22,8 @@ filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU= github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.33.0 h1:l7+6kwRMJNwdCvYdDl7Eax+wzEYHSnNY7zrrfbhDdTA= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.33.0/go.mod h1:pJTkW8hEUIIi3Pf65lPZOnn4Y81yCllX6IWk2jNXdkM= github.com/XSAM/otelsql v0.43.0 h1:ZIhXqRoMhILXQwBQoq/Dl6Taap/KEFQXZrWjYV1L8X8= github.com/XSAM/otelsql v0.43.0/go.mod h1:DJBGBvbtwf1OCBYRTjpRFxOqi6ONpdfb+htr4ncRWuw= github.com/agnivade/levenshtein v1.2.1 h1:EHBY3UOn1gwdy/VbFwgo4cxecRznFk7fKWN1KOX7eoM= @@ -47,8 +49,6 @@ github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2 h1:aBangftG7EVZoUb69Os github.com/cncf/xds/go v0.0.0-20260202195803-dba9d589def2/go.mod h1:qwXFYgsP6T7XnJtbKlf1HP8AjxZZyzxMmc+Lq5GjlU4= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d h1:abDbP7XBVgwda+h0J5Qra5p2OQpidU2FdkXvzCKL+H8= github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d/go.mod h1:wKFzULXAPj3U2BDAPWXhSbQQNC6FU1+1/5iika6IY7g= github.com/dgryski/trifles v0.0.0-20230903005119-f50d829f2e54 h1:SG7nF6SRlWhcT7cNTs5R6Hk4V2lcmLz2NsG2VnInyNo= @@ -69,8 +69,8 @@ github.com/envoyproxy/protoc-gen-validate v1.3.3/go.mod h1:TsndJ/ngyIdQRhMcVVGDD github.com/felixge/httpsnoop v1.1.0 h1:3YtUj32ZZkqZtt3sZZsClsymw/QDuVfpNhoA31zeORc= github.com/felixge/httpsnoop v1.1.0/go.mod h1:Zqxgdd+1Rkcz8euOqdr7lqgCRJztwr5hp9vDSi5UZCE= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= -github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= +github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-redis/redismock/v9 v9.2.0 h1:ZrMYQeKPECZPjOj5u9eyOjg8Nnb0BS9lkVIZ6IpsKLw= @@ -105,15 +105,15 @@ github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs= -github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA= +github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3 h1:LMLX+LgTNWpfvCBdFebv6EsYotImrt/Ppc5cXIriCSo= +github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3/go.mod h1:jl5iWTm0/hd5PjEYEOuwAJ57L/CibdZfrqZ5XA5GrCk= github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0= github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/enterprise-certificate-proxy v0.3.17 h1:73NfMHdiqo9JFU9+7a5ExpVa10/R29pXfZIaW559nrg= -github.com/googleapis/enterprise-certificate-proxy v0.3.17/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= +github.com/googleapis/enterprise-certificate-proxy v0.3.19 h1:mMOE7DN2+p76/EdIrmAy9B9bH+yC4563vmnJ34QR8i4= +github.com/googleapis/enterprise-certificate-proxy v0.3.19/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= github.com/googleapis/gax-go/v2 v2.23.0 h1:Tchl7qkvE7Ip3y+ztvNufYFvkfqTe7NfLTYGIdJRLuE= github.com/googleapis/gax-go/v2 v2.23.0/go.mod h1:rBQKOVJCdb8IFEzg+FCwlt1LP/xMDGuqUXhUG+XMXEg= github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= @@ -133,8 +133,8 @@ github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwA github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46/go.mod h1:yyMNCyc/Ib3bDTKd379tNMpB/7/H5TjM2Y9QJ5THLbE= -github.com/klauspost/compress v1.19.0 h1:sXLILfc9jV2QYWkzFOPWStmcUVH2RHEB1JCdY2oVvCQ= -github.com/klauspost/compress v1.19.0/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= +github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8= +github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE= github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= @@ -145,8 +145,8 @@ github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/lib/pq v1.12.3 h1:tTWxr2YLKwIvK90ZXEw8GP7UFHtcbTtty8zsI+YjrfQ= github.com/lib/pq v1.12.3/go.mod h1:/p+8NSbOcwzAEI7wiMXFlgydTwcgTr3OSKMsD2BitpA= -github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= -github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI= +github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w= @@ -160,15 +160,13 @@ github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v1.24.0 h1:5XStIklKuAtJSNpdD3s8XJj/Yv78IQmE1kbNk87JrAI= -github.com/prometheus/client_golang v1.24.0/go.mod h1:QcsNdotprC2nS4BTM2ucbcqxd2CeXTEa9jW7zHO9iDE= +github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU= +github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= -github.com/prometheus/common v0.70.0 h1:bcpru3tWPVnxGnETLgOV5jbp/JRXgYEyv65CuBLAMMI= -github.com/prometheus/common v0.70.0/go.mod h1:S/SFasQmgGiYH6C81LKCtYa8QACgthGg5zxL2udV7SY= +github.com/prometheus/common v0.70.1 h1:1HvjP4D5oL3t8RsPlwxA9onvvStjtIHYE5XuuwOi/PY= +github.com/prometheus/common v0.70.1/go.mod h1:VdFUQDMZK3VLkurFUVhia6uys/0suUp86TJz5qbJRhc= github.com/prometheus/otlptranslator v1.0.0 h1:s0LJW/iN9dkIH+EnhiD3BlkkP5QVIUVEoIwkU+A6qos= github.com/prometheus/otlptranslator v1.0.0/go.mod h1:vRYWnXvI6aWGpsdY/mOT/cbeVRBlPWtBNDb7kGR3uKM= github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI= @@ -177,8 +175,8 @@ github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0 h1:jsV3tyMeJrEoc2f3EhNf7qoBW github.com/redis/go-redis/extra/rediscmd/v9 v9.21.0/go.mod h1:e5t17bY9cEpVV+xw2U7jsPOKkXBtL5IQmNVABShnHUk= github.com/redis/go-redis/extra/redisotel/v9 v9.21.0 h1:36qq3rbF2If2CP0zGHHF8o/4XDluErn6DD0c9/L2iNI= github.com/redis/go-redis/extra/redisotel/v9 v9.21.0/go.mod h1:7y2cVB/LXXLHqHOO2jCVzBqimIQk1w7Rp9WSpyVY/o8= -github.com/redis/go-redis/v9 v9.21.0 h1:FPBE4hhbAke+TLmcY3WkpbDffJEomdqPn3HYiqAtL9E= -github.com/redis/go-redis/v9 v9.21.0/go.mod h1:v/M13XI1PVCDcm01VtPFOADfZtHf8YW3baQf57KlIkA= +github.com/redis/go-redis/v9 v9.22.0 h1:laDvpYXTJtZLloinw1fA5Kqd6HAEH2XKxOkG/PDq2F0= +github.com/redis/go-redis/v9 v9.22.0/go.mod h1:y2g0Wj8rQvuK0ELM+oxSudcLtC09JScs98I/X9gRWY4= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= @@ -188,13 +186,13 @@ github.com/segmentio/kafka-go v0.4.51/go.mod h1:Y1gn60kzLEEaW28YshXyk2+VCUKbJ3Qr github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/vektah/gqlparser/v2 v2.5.36 h1:CN9mKVHgMkc+XftdOWIhb4HEL8wKSYkFAqhf8booa7s= github.com/vektah/gqlparser/v2 v2.5.36/go.mod h1:cAJ9qwVgPaUkWv6Gn8vn0mqOE0Ui5Pn56wNy5396XWo= github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c= @@ -216,14 +214,16 @@ go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0= go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= +go.opentelemetry.io/contrib/detectors/gcp v1.44.0 h1:NmLfL734pJhM0JKaYd2Y28+nY9dPRWYAAbxhRCrKXPw= +go.opentelemetry.io/contrib/detectors/gcp v1.44.0/go.mod h1:tNAsgd8avTGke1+MndXlU5Cru4PQ9Ai/cCNWQv/ZJ/s= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 h1:0Qx7VGBacMm9ZENQ7TnNObTYI4ShC+lHI16seduaxZo= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0/go.mod h1:Sje3i3MjSPKTSPvVWCaL8ugBzJwik3u4smCjUeuupqg= -go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0 h1:MCcYL7J6Vt/X0kjqbMZkekCmwsurbQRbL69vkiye2lk= -go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.69.0/go.mod h1:3jnStNwSufK+f5ktjL4EPcwtig4rtd81NS70lqHuXl8= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0 h1:8tvICD4vSTOOsNrsI4Ljf6C+6UKvpTEH5XY3JMoyPoo= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.69.0/go.mod h1:z9+yiacE0IHRqM4qFfkbt/JYlmYXgss8GY/jXoNuPJI= -go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= -go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= +go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 h1:aVgLpGksz0vjoe6OynycqX8daNOAxJx5ZEhJXIXOVIU= +go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0/go.mod h1:kmJlX6WuTrAH1fOCSbPJFrSnUagB8c3SY3E87It3JD8= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 h1:LMuyCAyfalSjDyjdC65nK6N0zoTT63+E/u95X0JovZI= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0/go.mod h1:085m8qbm4hgc8rZWGDEa4vmyyo2c3nPxUslYUKUIU04= +go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= +go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0 h1:SUplec5dp06reu1zaXmOXdvqH398taqrDXqUl99jxSc= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0/go.mod h1:ho2g4N+ane+swq5I/VBkKWnRDY4kUINH3FuqyZqX/Ug= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.44.0 h1:RuynHbfU8JUEw7DyONgkVYg2SVtsoF28y0LGIr69jgA= @@ -232,20 +232,20 @@ go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0 h1:4YsVu3B8+3qtWYYrsUY go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0/go.mod h1:+wnlSn0mD1ADVMe3v9Z/WIaiz6q6gL2J/ejaAmdmv80= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 h1:qazEJlUOQzhCpzQpFETGby7EdqjI1wsd0W+6Gg1SCTU= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0/go.mod h1:fOD2Yefuxixkx3ahVNf0O/PERb6r4OlbxfATVnYvzCo= -go.opentelemetry.io/otel/exporters/prometheus v0.65.0 h1:jOveH/b4lU9HT7y+Gfamf18BqlOuz2PWEvs8yM7Q6XE= -go.opentelemetry.io/otel/exporters/prometheus v0.65.0/go.mod h1:i1P8pcumauPtUI4YNopea1dhzEMuEqWP1xoUZDylLHo= +go.opentelemetry.io/otel/exporters/prometheus v0.67.0 h1:7IefDa35e6V3NoiqIeLDMDxMFyZDk5qcoC0Ax4cC16E= +go.opentelemetry.io/otel/exporters/prometheus v0.67.0/go.mod h1:nsPI1awTg5Vmg1YrommL2mVarVGlqc4yXOoKAkPRD0c= go.opentelemetry.io/otel/exporters/zipkin v1.44.0 h1:zv7PRYGLrQHkdeZj0c5SNAZOJcw55XgaTezUkNpwA+w= go.opentelemetry.io/otel/exporters/zipkin v1.44.0/go.mod h1:3+VZyCi6hFW+UuxFF+wSOvwsOwncfBpQfP7Qdb3JXKg= -go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= -go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= -go.opentelemetry.io/otel/metric/x v0.66.0 h1:YkCrx1zLOChi9ZcZ6euupOcsgzbVlec7D/xoEU1+cTA= -go.opentelemetry.io/otel/metric/x v0.66.0/go.mod h1:d1+BDj9t96do0/1LoU1ayfCv79ZgNE41qbhBvnMOBZk= -go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= -go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= -go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= -go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= -go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= -go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= +go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/metric/x v0.67.0 h1:PcicCNZFkZ4bXfSooXdo3WN7RBOVOtjVdo1wD358Uns= +go.opentelemetry.io/otel/metric/x v0.67.0/go.mod h1:FBjCWZe6wgcqxcMtjdGiClDKXb2YxxXii0CXftE4QtI= +go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= +go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= +go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= +go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= +go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= +go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= go.opentelemetry.io/proto/otlp v1.10.0 h1:IQRWgT5srOCYfiWnpqUYz9CVmbO8bFmKcwYxpuCSL2g= go.opentelemetry.io/proto/otlp v1.10.0/go.mod h1:/CV4QoCR/S9yaPj8utp3lvQPoqMtxXdzn7ozvvozVqk= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= @@ -256,14 +256,14 @@ go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= -go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= -go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw= -golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk= +golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= +golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= @@ -271,8 +271,8 @@ golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHl golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.37.0 h1:vF1DjpVEshcIqoEaauuHebaLk1O1forxjxBaVn884JQ= -golang.org/x/mod v0.37.0/go.mod h1:m8S8VeM9r4dzDwjrKO0a1sZP3YjeMamRRlD+fmR2Q/0= +golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk= +golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -284,8 +284,8 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o= -golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= +golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= +golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= @@ -305,7 +305,6 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= @@ -316,8 +315,8 @@ golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= -golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs= -golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -329,34 +328,34 @@ golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.47.0 h1:7Kn5x/d1svx/PzryTsqeoZN4TZwqeH5pGWjefhLi/1Q= -golang.org/x/tools v0.47.0/go.mod h1:dFHnyTvFWY212G+h7ZY4Vsp/K3U4/7W9TyVaAul8uCA= +golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE= +golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/api v0.288.0 h1:glhO/J88obKP5I269W3hB73dvBKrjU56ZfmNlNXpgTU= -google.golang.org/api v0.288.0/go.mod h1:lM2kYRzYUCBY91P9h6VF1PYmvhxii3O5hji37qRvIcY= +google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= +google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= -google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94 h1:YJjbgu+dkp5kUJLfpMyCLfBIWZb/FcJyuLeo1gVBOuo= -google.golang.org/genproto v0.0.0-20260519071638-aa98bba5eb94/go.mod h1:RRHjglSYABVCWpQ7USCpdfhcd9t4PkajvVwyynZizTc= -google.golang.org/genproto/googleapis/api v0.0.0-20260630182238-925bb5da69e7 h1:jQ9p21COKWjP3VwuFrNRiiOTMh3mPpN45R7SLrH/HUU= -google.golang.org/genproto/googleapis/api v0.0.0-20260630182238-925bb5da69e7/go.mod h1:KqHwBx2upmfa1XSi1WuRvC+2VGCLtooKkfmyvRbUmqA= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260630182238-925bb5da69e7 h1:eM/YSd5bBFagF51o1E745Ta7RwzpW0h+z+QDNZOgmQ8= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260630182238-925bb5da69e7/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd h1:0GnSESHqea5EoaQgJyYxC3o5m0L191gCQdDgo2cxO5I= +google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= +google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.82.1 h1:NnAxzGRA0677vCa4BUkOAnO5+FfQqVl9iUXeD0IqcGE= -google.golang.org/grpc v1.82.1/go.mod h1:yzTZ1TB1Z3SG+LIYaI+WiE8D5+PZ3ArnrSp8zF3+/ZA= +google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= +google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -366,8 +365,8 @@ google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= -google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= -google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= @@ -376,8 +375,8 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -modernc.org/cc/v4 v4.29.0 h1:CXgwL8cvxmyzBQZzbSl/6xFtMCryb6u8IOqDci39cgc= -modernc.org/cc/v4 v4.29.0/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= +modernc.org/cc/v4 v4.29.1 h1:MKgdCV3WykTSPqpVrnxdEDS0HEd2FHpKZDzxzU5LyeI= +modernc.org/cc/v4 v4.29.1/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= modernc.org/ccgo/v4 v4.34.6 h1:sBgfIwyN0TQ9C5hwIeuqyeAKyMWnbvj2fvpF4L11uzU= modernc.org/ccgo/v4 v4.34.6/go.mod h1:SZ8YcN9NG7XVsQYdm6jYBvi8PQP1qi+kqB6OhjqI3Fk= modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM= @@ -388,8 +387,8 @@ modernc.org/gc/v3 v3.1.4 h1:2g65LGVSmFQrXeITAw97x7hCRvZFcyE1uDP+7Vng7JI= modernc.org/gc/v3 v3.1.4/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks= modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI= -modernc.org/libc v1.74.1 h1:bdR4VTKFMC4966QSNZ05XLGI/VwzVa2kTUX51Dm0riQ= -modernc.org/libc v1.74.1/go.mod h1:uH4t5bOx3G3g9Xcmj10YKlTcVISlRDwv8VoQJG9n8Os= +modernc.org/libc v1.74.4 h1:fX1Omw4o2/1C2iRkkIsrQTasJQldLhRmuPreXLoWs9k= +modernc.org/libc v1.74.4/go.mod h1:eeQAS9W3sZeKYMFubydxJpII9ybHWshk+7or7bLG9co= modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI= @@ -398,8 +397,8 @@ modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg= modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE= -modernc.org/sqlite v1.54.0 h1:JCxR4qwkJvOaqAoYcgDoO25Nc+ROg6EJ2LfBVzdrgog= -modernc.org/sqlite v1.54.0/go.mod h1:4ntCLuNmnH8+GNqjka1wNg7KJd5/Hi5FYp8K+XQ7GZw= +modernc.org/sqlite v1.56.0 h1:/D8e2RfFqoy/Zc6PuC76U28zFwmI/sYx1Kjm4yEn9e0= +modernc.org/sqlite v1.56.0/go.mod h1:yCJ2cmAaIkHQ25oXWrF8H4O1lIfPYPR26yCEDj2P3pQ= modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= diff --git a/examples/using-s3-filestore/go.mod b/examples/using-s3-filestore/go.mod index 84ba6723ff..5f39f04298 100644 --- a/examples/using-s3-filestore/go.mod +++ b/examples/using-s3-filestore/go.mod @@ -112,7 +112,7 @@ require ( google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect - google.golang.org/grpc v1.83.0 // indirect + google.golang.org/grpc v1.83.1 // indirect google.golang.org/protobuf v1.36.11 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect modernc.org/libc v1.74.4 // indirect diff --git a/examples/using-s3-filestore/go.sum b/examples/using-s3-filestore/go.sum index 1b535d20c5..2d7784bedb 100644 --- a/examples/using-s3-filestore/go.sum +++ b/examples/using-s3-filestore/go.sum @@ -386,8 +386,8 @@ google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyac google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= -google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= +google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= diff --git a/go.mod b/go.mod index f3d4b52ac9..d10f923468 100644 --- a/go.mod +++ b/go.mod @@ -47,9 +47,9 @@ require ( golang.org/x/text v0.41.0 golang.org/x/time v0.15.0 google.golang.org/api v0.291.0 - google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df - google.golang.org/grpc v1.83.0 - google.golang.org/protobuf v1.36.11 + google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 + google.golang.org/grpc v1.83.1 + google.golang.org/protobuf v1.36.12 gopkg.in/yaml.v3 v3.0.1 modernc.org/sqlite v1.56.0 ) diff --git a/go.sum b/go.sum index 22dcf51d92..3a70b288dd 100644 --- a/go.sum +++ b/go.sum @@ -352,15 +352,15 @@ google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd h1:0GnSESHqea5EoaQ google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= -google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= +google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -370,8 +370,8 @@ google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= -google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= -google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= diff --git a/pkg/gofr/datasource/cloudsql/go.mod b/pkg/gofr/datasource/cloudsql/go.mod index 0a15290894..77e6fa0caf 100644 --- a/pkg/gofr/datasource/cloudsql/go.mod +++ b/pkg/gofr/datasource/cloudsql/go.mod @@ -45,7 +45,7 @@ require ( google.golang.org/api v0.291.0 // indirect google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect - google.golang.org/grpc v1.83.0 // indirect - google.golang.org/protobuf v1.36.11 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect + google.golang.org/grpc v1.83.1 // indirect + google.golang.org/protobuf v1.36.12 // indirect ) diff --git a/pkg/gofr/datasource/cloudsql/go.sum b/pkg/gofr/datasource/cloudsql/go.sum index b864e50d12..c3cbc2f5e0 100644 --- a/pkg/gofr/datasource/cloudsql/go.sum +++ b/pkg/gofr/datasource/cloudsql/go.sum @@ -177,15 +177,15 @@ google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd h1:0GnSESHqea5EoaQ google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= -google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= +google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -195,8 +195,8 @@ google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= -google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= -google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/datasource/couchbase/go.mod b/pkg/gofr/datasource/couchbase/go.mod index 78f8b865ab..8fc30df8f4 100644 --- a/pkg/gofr/datasource/couchbase/go.mod +++ b/pkg/gofr/datasource/couchbase/go.mod @@ -32,7 +32,7 @@ require ( golang.org/x/net v0.57.0 // indirect golang.org/x/sys v0.47.0 // indirect golang.org/x/text v0.41.0 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect - google.golang.org/grpc v1.83.0 // indirect - google.golang.org/protobuf v1.36.11 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect + google.golang.org/grpc v1.83.1 // indirect + google.golang.org/protobuf v1.36.12 // indirect ) diff --git a/pkg/gofr/datasource/couchbase/go.sum b/pkg/gofr/datasource/couchbase/go.sum index 2e5cc34dc1..9b0a84cf51 100644 --- a/pkg/gofr/datasource/couchbase/go.sum +++ b/pkg/gofr/datasource/couchbase/go.sum @@ -63,9 +63,9 @@ golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= -google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= -google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= -google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= -google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= +google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= +google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= diff --git a/pkg/gofr/datasource/dbresolver/go.mod b/pkg/gofr/datasource/dbresolver/go.mod index bfbde827bc..bfbca2c37d 100644 --- a/pkg/gofr/datasource/dbresolver/go.mod +++ b/pkg/gofr/datasource/dbresolver/go.mod @@ -92,9 +92,9 @@ require ( google.golang.org/api v0.291.0 // indirect google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect - google.golang.org/grpc v1.83.0 // indirect - google.golang.org/protobuf v1.36.11 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect + google.golang.org/grpc v1.83.1 // indirect + google.golang.org/protobuf v1.36.12 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect modernc.org/libc v1.74.4 // indirect modernc.org/mathutil v1.7.1 // indirect diff --git a/pkg/gofr/datasource/dbresolver/go.sum b/pkg/gofr/datasource/dbresolver/go.sum index 4eb0840ca6..0720af8b21 100644 --- a/pkg/gofr/datasource/dbresolver/go.sum +++ b/pkg/gofr/datasource/dbresolver/go.sum @@ -341,15 +341,15 @@ google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd h1:0GnSESHqea5EoaQ google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= -google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= +google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -359,8 +359,8 @@ google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= -google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= -google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= diff --git a/pkg/gofr/datasource/dgraph/go.mod b/pkg/gofr/datasource/dgraph/go.mod index 112a05c178..f2902bed7b 100644 --- a/pkg/gofr/datasource/dgraph/go.mod +++ b/pkg/gofr/datasource/dgraph/go.mod @@ -9,7 +9,7 @@ require ( go.opentelemetry.io/otel v1.45.0 go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 - google.golang.org/grpc v1.83.0 + google.golang.org/grpc v1.83.1 ) require ( @@ -30,6 +30,6 @@ require ( golang.org/x/net v0.57.0 // indirect golang.org/x/sys v0.47.0 // indirect golang.org/x/text v0.41.0 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect - google.golang.org/protobuf v1.36.11 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect + google.golang.org/protobuf v1.36.12 // indirect ) diff --git a/pkg/gofr/datasource/dgraph/go.sum b/pkg/gofr/datasource/dgraph/go.sum index 91dd13087f..8ef496b7d4 100644 --- a/pkg/gofr/datasource/dgraph/go.sum +++ b/pkg/gofr/datasource/dgraph/go.sum @@ -88,9 +88,9 @@ golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8T golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= -google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= -google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= -google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= -google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= +google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= +google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= diff --git a/pkg/gofr/datasource/file/gcs/go.mod b/pkg/gofr/datasource/file/gcs/go.mod index a38e09031b..dab6dd8738 100644 --- a/pkg/gofr/datasource/file/gcs/go.mod +++ b/pkg/gofr/datasource/file/gcs/go.mod @@ -56,7 +56,7 @@ require ( golang.org/x/time v0.15.0 // indirect google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect - google.golang.org/grpc v1.83.0 // indirect - google.golang.org/protobuf v1.36.11 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect + google.golang.org/grpc v1.83.1 // indirect + google.golang.org/protobuf v1.36.12 // indirect ) diff --git a/pkg/gofr/datasource/file/gcs/go.sum b/pkg/gofr/datasource/file/gcs/go.sum index 5fa0155300..bc49bea4ef 100644 --- a/pkg/gofr/datasource/file/gcs/go.sum +++ b/pkg/gofr/datasource/file/gcs/go.sum @@ -125,9 +125,9 @@ google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd h1:0GnSESHqea5EoaQ google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= -google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= -google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= -google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= -google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= +google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= +google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= diff --git a/pkg/gofr/datasource/kv-store/badger/go.mod b/pkg/gofr/datasource/kv-store/badger/go.mod index 697418bc39..b2e01cf242 100644 --- a/pkg/gofr/datasource/kv-store/badger/go.mod +++ b/pkg/gofr/datasource/kv-store/badger/go.mod @@ -22,5 +22,5 @@ require ( go.opentelemetry.io/otel/metric v1.45.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/sys v0.47.0 // indirect - google.golang.org/protobuf v1.36.11 // indirect + google.golang.org/protobuf v1.36.12 // indirect ) diff --git a/pkg/gofr/datasource/kv-store/badger/go.sum b/pkg/gofr/datasource/kv-store/badger/go.sum index 45f33a84a9..f495cab75e 100644 --- a/pkg/gofr/datasource/kv-store/badger/go.sum +++ b/pkg/gofr/datasource/kv-store/badger/go.sum @@ -35,5 +35,5 @@ go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= -google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= diff --git a/pkg/gofr/datasource/oracle/go.mod b/pkg/gofr/datasource/oracle/go.mod index 02bf86c96c..0e9a5870f3 100644 --- a/pkg/gofr/datasource/oracle/go.mod +++ b/pkg/gofr/datasource/oracle/go.mod @@ -84,9 +84,9 @@ require ( google.golang.org/api v0.291.0 // indirect google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect - google.golang.org/grpc v1.83.0 // indirect - google.golang.org/protobuf v1.36.11 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect + google.golang.org/grpc v1.83.1 // indirect + google.golang.org/protobuf v1.36.12 // indirect modernc.org/libc v1.74.4 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.11.0 // indirect diff --git a/pkg/gofr/datasource/oracle/go.sum b/pkg/gofr/datasource/oracle/go.sum index 54f057fc98..3211972588 100644 --- a/pkg/gofr/datasource/oracle/go.sum +++ b/pkg/gofr/datasource/oracle/go.sum @@ -304,15 +304,15 @@ google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd h1:0GnSESHqea5EoaQ google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= -google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= +google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -322,8 +322,8 @@ google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= -google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= -google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/gofr/metrics/exporters/gcp/go.mod b/pkg/gofr/metrics/exporters/gcp/go.mod index 4c1ff08324..9ed6e9c885 100644 --- a/pkg/gofr/metrics/exporters/gcp/go.mod +++ b/pkg/gofr/metrics/exporters/gcp/go.mod @@ -10,7 +10,7 @@ require ( go.opentelemetry.io/otel/sdk/metric v1.45.0 gofr.dev v1.60.1 golang.org/x/oauth2 v0.36.0 - google.golang.org/grpc v1.83.0 + google.golang.org/grpc v1.83.1 ) require ( @@ -29,6 +29,7 @@ require ( github.com/prometheus/common v0.70.1 // indirect github.com/prometheus/otlptranslator v1.0.0 // indirect github.com/prometheus/procfs v0.21.1 // indirect + github.com/stretchr/testify v1.12.1 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.44.0 // indirect go.opentelemetry.io/otel/exporters/prometheus v0.67.0 // indirect @@ -39,6 +40,6 @@ require ( golang.org/x/sys v0.47.0 // indirect golang.org/x/text v0.41.0 // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect - google.golang.org/protobuf v1.36.11 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect + google.golang.org/protobuf v1.36.12 // indirect ) diff --git a/pkg/gofr/metrics/exporters/gcp/go.sum b/pkg/gofr/metrics/exporters/gcp/go.sum index 1d752c4776..7a805c94d1 100644 --- a/pkg/gofr/metrics/exporters/gcp/go.sum +++ b/pkg/gofr/metrics/exporters/gcp/go.sum @@ -8,8 +8,6 @@ github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1x github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= @@ -27,8 +25,6 @@ github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU= github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE= github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= @@ -39,8 +35,8 @@ github.com/prometheus/otlptranslator v1.0.0 h1:s0LJW/iN9dkIH+EnhiD3BlkkP5QVIUVEo github.com/prometheus/otlptranslator v1.0.0/go.mod h1:vRYWnXvI6aWGpsdY/mOT/cbeVRBlPWtBNDb7kGR3uKM= github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI= github.com/prometheus/procfs v0.21.1/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY= -github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= -github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/contrib/detectors/gcp v1.44.0 h1:NmLfL734pJhM0JKaYd2Y28+nY9dPRWYAAbxhRCrKXPw= @@ -69,6 +65,8 @@ go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.60.1 h1:tgUCh33369oDSQNmcSxVNM+xgFxtCXxA9LZLgUK2m6k= gofr.dev v1.60.1/go.mod h1:5b56VoXF2ImEkDnYV69ExzRS586o2juu96zJKaRuZL4= golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= @@ -85,11 +83,9 @@ gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df h1:O3ig1i5WDDzsVzRp+cCdgelT9vXnlnOFdlEeFtL4HCc= -google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= -google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ= -google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= -google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= -google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= +google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= +google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= From 7a5bdfc994d2ba8f7e741283b00255fa45669679 Mon Sep 17 00:00:00 2001 From: Umang Mundhra Date: Tue, 8 Sep 2026 16:59:34 +0530 Subject: [PATCH 20/48] feat(metrics): configurable per-instrument cardinality limit (#4160) --- docs/quick-start/observability/page.md | 11 ++++ docs/references/configs/page.md | 6 ++ pkg/gofr/container/metrics_exporter.go | 43 +++++++++++--- pkg/gofr/container/metrics_exporter_test.go | 51 ++++++++++++++++ pkg/gofr/metrics/exporters/config.go | 9 +++ pkg/gofr/metrics/exporters/provider.go | 6 ++ pkg/gofr/metrics/exporters/provider_test.go | 65 +++++++++++++++++++++ 7 files changed, 182 insertions(+), 9 deletions(-) diff --git a/docs/quick-start/observability/page.md b/docs/quick-start/observability/page.md index a30ae69d8a..b92dfe13e0 100644 --- a/docs/quick-start/observability/page.md +++ b/docs/quick-start/observability/page.md @@ -290,6 +290,17 @@ To disable the metrics server entirely, set the `METRICS_PORT` environment varia METRICS_PORT=0 ``` +### Limiting Metric Cardinality + +Each metric instrument keeps a bounded number of distinct label sets per collection cycle; the remaining series +collapse into a single `otel.metric.overflow` series, protecting the backend from a cardinality explosion. The +limit is inclusive of that overflow slot, so a value of `n` keeps up to `n-1` real label sets. The default is +`2000`; override it with `METRICS_CARDINALITY_LIMIT` (set `0` or a negative value for unlimited): + +```dotenv +METRICS_CARDINALITY_LIMIT=5000 +``` + ### Example Dashboard These metrics can be easily consumed by monitoring systems like {% new-tab-link title="Prometheus" href="https://prometheus.io/" /%} diff --git a/docs/references/configs/page.md b/docs/references/configs/page.md index 8a734b1c00..d2e7328ae2 100644 --- a/docs/references/configs/page.md +++ b/docs/references/configs/page.md @@ -104,6 +104,12 @@ This document lists all the configuration options supported by the GoFr framewor --- +- METRICS_CARDINALITY_LIMIT +- Per-instrument attribute-set limit, inclusive of the overflow slot: an instrument keeps up to one fewer than this many distinct label sets per collection cycle, and the remaining series collapse into a single otel.metric.overflow series (so a value of n keeps n-1 real label sets). Set 0 or negative for unlimited. When unset, the OpenTelemetry SDK default applies (2000, or OTEL_GO_X_CARDINALITY_LIMIT if set); a set value takes precedence over OTEL_GO_X_CARDINALITY_LIMIT. +- 2000 + +--- + - OTEL_RESOURCE_ATTRIBUTES - Standard OpenTelemetry resource attributes, comma-separated key=value. Merged into the resource attached to every exported metric. Required for the gcp exporter outside Google Cloud: its ingest rejects any point whose prometheus_target has no location (e.g. "location=us-central1"). diff --git a/pkg/gofr/container/metrics_exporter.go b/pkg/gofr/container/metrics_exporter.go index c098741555..9b675f8e27 100644 --- a/pkg/gofr/container/metrics_exporter.go +++ b/pkg/gofr/container/metrics_exporter.go @@ -48,18 +48,43 @@ func metricsExporterConfig(conf config.Config, appName, appVersion string, logge } return exporters.Config{ - AppName: appName, - AppVersion: appVersion, - Exporter: strings.TrimSpace(conf.Get("METRICS_EXPORTER")), - Endpoint: strings.TrimSpace(conf.Get("METRICS_URL")), - Protocol: conf.GetOrDefault("METRICS_PROTOCOL", "grpc"), - Interval: metricsExportInterval(conf, logger), - Temporality: metricsTemporality(conf), - Headers: headers, - Insecure: insecure, + AppName: appName, + AppVersion: appVersion, + Exporter: strings.TrimSpace(conf.Get("METRICS_EXPORTER")), + Endpoint: strings.TrimSpace(conf.Get("METRICS_URL")), + Protocol: conf.GetOrDefault("METRICS_PROTOCOL", "grpc"), + Interval: metricsExportInterval(conf, logger), + Temporality: metricsTemporality(conf), + Headers: headers, + Insecure: insecure, + CardinalityLimit: metricsCardinalityLimit(conf, logger), } } +// metricsCardinalityLimit resolves the per-instrument cardinality limit from +// METRICS_CARDINALITY_LIMIT. It returns nil when unset (leaving the SDK default +// of 2000, or OTEL_GO_X_CARDINALITY_LIMIT, in place) or when the value is not an +// integer. A parsed value (including zero or negative, meaning unlimited) is +// returned as an explicit override. The raw value is never logged. +func metricsCardinalityLimit(conf config.Config, logger exporters.Logger) *int { + v := strings.TrimSpace(conf.Get("METRICS_CARDINALITY_LIMIT")) + if v == "" { + return nil + } + + n, err := strconv.Atoi(v) + if err != nil { + if logger != nil { + logger.Warnf("invalid METRICS_CARDINALITY_LIMIT: expected an integer; " + + "using the default cardinality limit") + } + + return nil + } + + return &n +} + // metricsExportInterval resolves the push interval, preferring the GoFr-native // METRICS_EXPORT_INTERVAL (seconds), then the OpenTelemetry standard // OTEL_METRIC_EXPORT_INTERVAL (milliseconds, per spec), then the default. diff --git a/pkg/gofr/container/metrics_exporter_test.go b/pkg/gofr/container/metrics_exporter_test.go index 02d5c27295..aed399b6f2 100644 --- a/pkg/gofr/container/metrics_exporter_test.go +++ b/pkg/gofr/container/metrics_exporter_test.go @@ -27,6 +27,18 @@ func Test_metricsExporterConfig(t *testing.T) { Protocol: "grpc", Interval: 30 * time.Second, Temporality: "cumulative", Insecure: false, }, }, + { + // Covers the wiring seam: removing the CardinalityLimit line from + // metricsExporterConfig makes the feature a silent no-op, and this is + // the only case that would catch it. + name: "cardinality limit is wired into the config", + env: map[string]string{"METRICS_CARDINALITY_LIMIT": "500"}, + want: exporters.Config{ + AppName: "app", AppVersion: "v1", + Protocol: "grpc", Interval: 30 * time.Second, Temporality: "cumulative", Insecure: false, + CardinalityLimit: func() *int { n := 500; return &n }(), + }, + }, { name: "full otlp config", env: map[string]string{ @@ -82,6 +94,45 @@ func Test_metricsExporterConfig(t *testing.T) { } } +func Test_metricsCardinalityLimit(t *testing.T) { + ptr := func(n int) *int { return &n } + + tests := []struct { + name string + env map[string]string + want *int + }{ + {"unset leaves SDK default", map[string]string{}, nil}, + {"positive limit", map[string]string{"METRICS_CARDINALITY_LIMIT": "500"}, ptr(500)}, + {"zero means unlimited", map[string]string{"METRICS_CARDINALITY_LIMIT": "0"}, ptr(0)}, + {"negative means unlimited", map[string]string{"METRICS_CARDINALITY_LIMIT": "-1"}, ptr(-1)}, + {"whitespace is trimmed", map[string]string{"METRICS_CARDINALITY_LIMIT": " 100 "}, ptr(100)}, + {"invalid falls back to default", map[string]string{"METRICS_CARDINALITY_LIMIT": "abc"}, nil}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got := metricsCardinalityLimit(config.NewMockConfig(tc.env), logging.NewMockLogger(logging.ERROR)) + if !reflect.DeepEqual(got, tc.want) { + t.Errorf("metricsCardinalityLimit() = %v, want %v", got, tc.want) + } + }) + } +} + +// Test_metricsCardinalityLimit_invalidDoesNotLogValue ensures an invalid value is +// not echoed into logs (CodeQL: clear-text logging of externally controlled input). +func Test_metricsCardinalityLimit_invalidDoesNotLogValue(t *testing.T) { + out := testutil.StdoutOutputForFunc(func() { + l := logging.NewMockLogger(logging.WARN) + metricsCardinalityLimit(config.NewMockConfig(map[string]string{"METRICS_CARDINALITY_LIMIT": "sneaky-value"}), l) + }) + + if strings.Contains(out, "sneaky-value") { + t.Errorf("raw METRICS_CARDINALITY_LIMIT value leaked into logs: %q", out) + } +} + // Test_metricsExporterConfig_otelFallback covers interval/temporality falling // back to the OpenTelemetry standard env vars, with METRICS_* taking precedence. func Test_metricsExporterConfig_otelFallback(t *testing.T) { diff --git a/pkg/gofr/metrics/exporters/config.go b/pkg/gofr/metrics/exporters/config.go index d9e5a0169d..194cc4f8af 100644 --- a/pkg/gofr/metrics/exporters/config.go +++ b/pkg/gofr/metrics/exporters/config.go @@ -39,6 +39,15 @@ type Config struct { // builders that manage their own transport security (e.g. gcp). Insecure bool + // CardinalityLimit overrides the per-instrument attribute-set limit applied + // to every meter. A non-nil value calls metricSdk.WithCardinalityLimit: a + // positive value caps distinct series per instrument per collection cycle + // (further series collapse into a single otel.metric.overflow series), while + // zero or negative disables the limit (unlimited). nil leaves the SDK default + // in place (2000, or OTEL_GO_X_CARDINALITY_LIMIT). Populated from + // METRICS_CARDINALITY_LIMIT. + CardinalityLimit *int + // Resource is the resource attached to every exported metric, resolved by // Build before any Builder runs. Builders read it to check whether the // attributes their backend requires were actually populated -- Google drops diff --git a/pkg/gofr/metrics/exporters/provider.go b/pkg/gofr/metrics/exporters/provider.go index dcfda31072..6ffa3d2a9d 100644 --- a/pkg/gofr/metrics/exporters/provider.go +++ b/pkg/gofr/metrics/exporters/provider.go @@ -44,6 +44,12 @@ func Build(ctx context.Context, cfg *Config, logger Logger) (ShutdownFunc, metri opts := []metricSdk.Option{metricSdk.WithResource(cfg.Resource)} + // Only override when explicitly configured, so an unset METRICS_CARDINALITY_LIMIT + // leaves the SDK default (2000, or OTEL_GO_X_CARDINALITY_LIMIT) untouched. + if cfg.CardinalityLimit != nil { + opts = append(opts, metricSdk.WithCardinalityLimit(*cfg.CardinalityLimit)) + } + if r := prometheusReader(logger); r != nil { opts = append(opts, metricSdk.WithReader(r)) } diff --git a/pkg/gofr/metrics/exporters/provider_test.go b/pkg/gofr/metrics/exporters/provider_test.go index cea62caf1b..c64a57ba16 100644 --- a/pkg/gofr/metrics/exporters/provider_test.go +++ b/pkg/gofr/metrics/exporters/provider_test.go @@ -7,7 +7,9 @@ import ( "testing" "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/metric" metricSdk "go.opentelemetry.io/otel/sdk/metric" + "go.opentelemetry.io/otel/sdk/metric/metricdata" "go.opentelemetry.io/otel/sdk/resource" "gofr.dev/pkg/gofr/logging" @@ -16,6 +18,69 @@ import ( var errBuilderFailed = errors.New("builder failed") +// TestBuild_appliesCardinalityLimit verifies Build wires cfg.CardinalityLimit +// into the MeterProvider: recording more distinct attribute sets than the limit +// collapses the excess into a single overflow series. A ManualReader registered +// as a custom exporter shares the provider, so it observes the same limit. +func TestBuild_appliesCardinalityLimit(t *testing.T) { + reader := metricSdk.NewManualReader() + + Register("card-test", func(_ context.Context, _ *Config, _ Logger) (metricSdk.Reader, error) { + return reader, nil + }) + + limit := 2 + cfg := Config{AppName: "app", AppVersion: "v1", Exporter: "card-test", CardinalityLimit: &limit} + + shutdown, meter := Build(context.Background(), &cfg, logging.NewMockLogger(logging.ERROR)) + + defer func() { _ = shutdown(context.Background()) }() + + counter, err := meter.Int64Counter("card_counter") + if err != nil { + t.Fatalf("failed to create counter: %v", err) + } + + const distinct = 5 + for i := 0; i < distinct; i++ { + counter.Add(context.Background(), 1, metric.WithAttributes(attribute.Int("i", i))) + } + + var rm metricdata.ResourceMetrics + if err := reader.Collect(context.Background(), &rm); err != nil { + t.Fatalf("collect failed: %v", err) + } + + points := countDataPoints(t, &rm, "card_counter") + + // limit distinct series are kept; the rest collapse into one overflow series. + if points == 0 { + t.Fatal("card_counter not found in collected metrics") + } + + if points >= distinct || points > limit+1 { + t.Errorf("cardinality limit not applied: got %d data points, want <= %d", points, limit+1) + } +} + +func countDataPoints(t *testing.T, rm *metricdata.ResourceMetrics, name string) int { + t.Helper() + + for _, sm := range rm.ScopeMetrics { + for _, m := range sm.Metrics { + if m.Name != name { + continue + } + + if sum, ok := m.Data.(metricdata.Sum[int64]); ok { + return len(sum.DataPoints) + } + } + } + + return 0 +} + func TestBuild(t *testing.T) { Register("build-custom", func(_ context.Context, _ *Config, _ Logger) (metricSdk.Reader, error) { return metricSdk.NewManualReader(), nil From 2d78c40d0ca270fbeb2b2f2c85167fb58df70008 Mon Sep 17 00:00:00 2001 From: Om Kulkarni <127368012+om7057@users.noreply.github.com> Date: Tue, 8 Sep 2026 17:21:54 +0530 Subject: [PATCH 21/48] fix(websocket): don't panic on a plain HTTP request to a WebSocket route (#3932) --- pkg/gofr/websocket.go | 10 ++++++-- pkg/gofr/websocket/websocket.go | 18 +++++++++++++++ pkg/gofr/websocket_test.go | 41 +++++++++++++++++++++++++++++++++ 3 files changed, 67 insertions(+), 2 deletions(-) diff --git a/pkg/gofr/websocket.go b/pkg/gofr/websocket.go index d418c42a94..c9e032f3d9 100644 --- a/pkg/gofr/websocket.go +++ b/pkg/gofr/websocket.go @@ -29,10 +29,16 @@ func (a *App) OverrideWebsocketUpgrader(wsUpgrader websocket.Upgrader) { // within the handler context. User can access the underlying WebSocket connection using `ctx.GetWebsocketConnection()`. func (a *App) WebSocket(route string, handler Handler) { a.GET(route, func(ctx *Context) (any, error) { - connID := ctx.Request.Context().Value(websocket.WSConnectionKey).(string) + connID, ok := ctx.Request.Context().Value(websocket.WSConnectionKey).(string) + if !ok { + // The request never went through the WebSocket upgrade middleware + // (e.g. a plain HTTP GET with no Upgrade headers), so no + // WSConnectionKey was ever set on the context. + return nil, websocket.ErrorNotWebSocketUpgrade{} + } conn := a.httpServer.ws.GetWebsocketConnection(connID) - if conn.Conn == nil { + if conn == nil || conn.Conn == nil { return nil, websocket.ErrorConnection } diff --git a/pkg/gofr/websocket/websocket.go b/pkg/gofr/websocket/websocket.go index 52e5bbf6ac..dbfaa6cf13 100644 --- a/pkg/gofr/websocket/websocket.go +++ b/pkg/gofr/websocket/websocket.go @@ -28,6 +28,24 @@ type Connection struct { // ErrorConnection is the connection error that occurs when websocket connection cannot be established. var ErrorConnection = errors.New("couldn't establish connection to web socket") +// ErrorNotWebSocketUpgrade is returned by a WebSocket route handler when the request never went +// through the WebSocket upgrade handshake (no WSConnectionKey on its context), as opposed to +// ErrorConnection, which means the upgrade happened but the resulting connection is missing or +// already closed. The former is a client error - the client simply never attempted an upgrade - +// while the latter is a server-side fault, so the two carry different HTTP status codes: this type +// implements StatusCode() to map to 400 (RFC 6455 4.2.1 calls for "an appropriate error code (such +// as 400 Bad Request)" on a failed handshake attempt), while ErrorConnection has no StatusCode() +// method and falls back to gofr's default 500. +type ErrorNotWebSocketUpgrade struct{} + +func (ErrorNotWebSocketUpgrade) Error() string { + return "request did not include a WebSocket upgrade" +} + +func (ErrorNotWebSocketUpgrade) StatusCode() int { + return http.StatusBadRequest +} + // The message types are defined in RFC 6455, section 11.8. const ( // TextMessage denotes a text data message. The text message payload is diff --git a/pkg/gofr/websocket_test.go b/pkg/gofr/websocket_test.go index e91db53a09..c8cef6d9e0 100644 --- a/pkg/gofr/websocket_test.go +++ b/pkg/gofr/websocket_test.go @@ -4,6 +4,7 @@ import ( "encoding/json" "errors" "fmt" + "io" "net/http" "net/http/httptest" "reflect" @@ -70,6 +71,46 @@ func Test_WebSocket_Success(t *testing.T) { require.NoError(t, err) } +// Test_WebSocket_PlainHTTPRequestDoesNotPanic pins the fix for #3862: a plain +// HTTP request to a route registered via app.WebSocket (no Upgrade headers, +// so no WSConnectionKey is ever set on the request context) must get a clean +// 400 error response instead of panicking. Before the fix, the unsafe type +// assertion on WSConnectionKey panicked; the panic-recovery middleware then +// converted that into a generic 500 "Internal Server Error" response, which +// is indistinguishable by status code alone from a naive fix that also +// returned 500. The response is checked for both the 400 status (per RFC +// 6455 4.2.1 - a request that never attempted an upgrade is a client error, +// same as a request whose upgrade attempt failed, handled a few lines away +// in middleware/web_socket.go) and the specific message, since only the +// panic-recovery path produces the generic one. +func Test_WebSocket_PlainHTTPRequestDoesNotPanic(t *testing.T) { + testutil.NewServerConfigs(t) + + app := New() + + server := httptest.NewServer(app.httpServer.router) + defer server.Close() + + app.WebSocket("/ws", func(*Context) (any, error) { + return "unreachable: handler must not run without a WebSocket connection", nil + }) + + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, server.URL+"/ws", http.NoBody) + require.NoError(t, err) + + resp, err := http.DefaultClient.Do(req) + require.NoError(t, err) + + defer resp.Body.Close() + + body, err := io.ReadAll(resp.Body) + require.NoError(t, err) + + assert.Equal(t, http.StatusBadRequest, resp.StatusCode) + assert.Contains(t, string(body), "request did not include a WebSocket upgrade", + "expected the websocket.ErrorNotWebSocketUpgrade message, not a panic-recovery response") +} + func Test_AddWSService(t *testing.T) { port := testutil.GetFreePort(t) t.Setenv("HTTP_PORT", fmt.Sprint(port)) From a841d422e38525fbde4a585ec8fa2e8931861da0 Mon Sep 17 00:00:00 2001 From: Aryan Mehrotra Date: Wed, 9 Sep 2026 11:32:29 +0530 Subject: [PATCH 22/48] ci: run the full pipeline and a website build on docs-only PRs (#4195) --- .github/workflows/go.yml | 11 ++-- .github/workflows/website-pr.yml | 98 ++++++++++++++++++++++++++++++++ 2 files changed, 105 insertions(+), 4 deletions(-) create mode 100644 .github/workflows/website-pr.yml diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index 3eabb6da33..e7bf547883 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -10,17 +10,20 @@ on: branches: - main - development + # Kept on `push` only. A docs merge cannot change Go coverage or lint + # results, and re-running the pipeline on development would publish a + # duplicate qlty point via upload_coverage and queue behind other merges + # (push runs are deliberately never cancelled — see the concurrency note + # below). The gating that matters happens on `pull_request`, which + # deliberately has no filter so docs-only PRs run the full required set. paths-ignore: - - 'docs/**' # Ignore changes to docs folder + - 'docs/**' - '**/*.md' # Run on pull requests to main or development branches pull_request: branches: - main - development - paths-ignore: - - 'docs/**' # Ignore changes to docs folder - - '**/*.md' # One in-flight run per ref. Pushing twice to a PR branch otherwise starts a # second full 14-job matrix — including the Kafka/Redis/MySQL services and the diff --git a/.github/workflows/website-pr.yml b/.github/workflows/website-pr.yml new file mode 100644 index 0000000000..2af0030ab8 --- /dev/null +++ b/.github/workflows/website-pr.yml @@ -0,0 +1,98 @@ +name: Website Build Check +permissions: + contents: read + +# Why this exists +# --------------- +# `docs/Dockerfile` overlays this repo's docs/ onto the gofr-dev/website +# source bundle and runs `npm run build` (Next.js static export). Until now +# that build was only ever exercised by website-stage.yml, which triggers on +# `push: development` — i.e. *after* a docs PR is merged. A broken +# navigation.js, a malformed events.json/team.json, or an MDX file next can't +# parse therefore reached development and was discovered by a failed stage +# deploy rather than by the PR that caused it. +# +# This runs the same two builds at PR time and stops there. +on: + pull_request: + branches: + - main + - development + # Everything docs/Dockerfile consumes lives under docs/ — including the + # Dockerfile itself. A PR that touches no docs/ file cannot change the + # website build, so it is not worth ~8 minutes of runner time. + # + # NOTE: because of this filter the check does not report on non-docs PRs, + # so it cannot be made a *required* status check without deadlocking them. + # Gate it in branch protection only if this filter is removed first. + paths: + - 'docs/**' + - '.github/workflows/website-pr.yml' + workflow_dispatch: + +# Deliberately the opposite of website-prod.yml / website-stage.yml, which set +# `cancel-in-progress: false` because a half-finished *deploy* is worse than a +# queued one. This workflow deploys nothing, so a superseded run is pure waste. +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + website_build: + name: 🌐 Website Build + runs-on: ubuntu-latest + # Two docker builds, each doing its own npm install. website-stage.yml + # budgets 45m for the same pair plus yarn install, refresh-data and a + # registry push; without those 30m is ample. + timeout-minutes: 30 + steps: + - name: Checkout framework code + uses: actions/checkout@v7 + + # gofr-dev/website is public, so the default GITHUB_TOKEN is enough and + # this step works on pull requests from forks. + # + # fetch-depth is left at the default 1, unlike website-stage.yml: the + # full history there is only needed by utils/generate-doc-mtimes.mjs, + # which runs as part of `yarn refresh-data` — a step this workflow + # deliberately skips (see below). + - name: Checkout website source + uses: actions/checkout@v7 + with: + repository: gofr-dev/website + ref: main + path: website-src + + # No `yarn refresh-data` here, on purpose. It is `continue-on-error: true` + # in website-stage.yml — i.e. already not load-bearing for build success — + # and each of its scripts falls back to the snapshot committed under + # src/data. Those snapshots are exactly what this build uses. Skipping it + # keeps the check hermetic (no GitHub API calls, nothing to rate-limit) + # and removes the need for Node on the runner: both npm installs happen + # inside the docker builds below. + + # Stage 1: the website "shell" — source + node_modules + npm. Identical + # invocation to website-stage.yml, including `--target builder`: the + # website Dockerfile's final stage is nginx and has no npm, so the + # framework's docs/Dockerfile could not run `npm run build` against it. + # + # Tagged ghcr.io/gofr-dev/website:stage for the *local* daemon only, so + # that docs/Dockerfile's `FROM ghcr.io/gofr-dev/website:${WEBSITE_TAG}` + # resolves here instead of pulling. Nothing is pushed. + - name: Build website source-bundle + run: | + docker build \ + --target builder \ + -t ghcr.io/gofr-dev/website:stage \ + -f ./website-src/Dockerfile \ + ./website-src/ + + # Stage 2: the actual check. Overlays this PR's docs/ and runs + # `npm run build`. This is the step that fails on broken docs. + - name: Build framework docs image + run: | + docker build \ + --build-arg WEBSITE_TAG=stage \ + -t gofr-website:pr \ + -f ./docs/Dockerfile \ + . From 250c2fb4fe864d6e9391823e4a62bcf48c33823b Mon Sep 17 00:00:00 2001 From: Nivaas V Date: Wed, 9 Sep 2026 11:44:23 +0530 Subject: [PATCH 23/48] Fix CONTRIBUTING.md wording (#3647) Co-authored-by: Aryan Mehrotra Co-authored-by: Umang Mundhra --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 44e8faa978..a58b2a2cfb 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -126,7 +126,7 @@ docker run -it --rm -p 4443:4443 -e STORAGE_EMULATOR_HOST=0.0.0.0:4443 fsouza/fa conflict. * External Library uses: - A little copying is better than a little dependency. - - All external dependencies should go through the same careful consideration, we would have done to our own written + - All external dependencies should go through the same careful consideration, we would have done for our own written code. We need to test the functionality we are going to use from an external library, as sometimes library implementation may change. - All dependencies must be abstracted as an interface. This will make it easier to switch libraries at later point From b8633ef6c271987512135ccf63625dc8a0eb802e Mon Sep 17 00:00:00 2001 From: Ryanisyyds <129717677+RyanisyydsTT@users.noreply.github.com> Date: Wed, 9 Sep 2026 16:52:39 +0800 Subject: [PATCH 24/48] fix: broken links in README and CONTRIBUTING (#3798) Co-authored-by: Aryan Mehrotra --- CONTRIBUTING.md | 4 ++-- README.md | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index a58b2a2cfb..dcb5fb7ba6 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -135,7 +135,7 @@ docker run -it --rm -p 4443:4443 -e STORAGE_EMULATOR_HOST=0.0.0.0:4443 fsouza/fa ### Documentation * After adding or modifying existing code, update the documentation too - [development/docs](https://github.com/gofr-dev/gofr/tree/development/docs). -* When you consider a new documentation page is needed, start by adding a new file and writing your new documentation. Then - add a reference to it in [navigation.js](https://gofr.dev/docs/navigation.js). +* When you consider a new documentation page is needed, start by adding a new file and writing your new documentation. Then - add a reference to it in [navigation.js](https://github.com/gofr-dev/gofr/blob/development/docs/navigation.js). * If needed, update or add proper code examples for your changes. * In case images are needed, add it to [docs/public](./docs/public) folder. * Make sure you don't break existing links and references. @@ -144,4 +144,4 @@ docker run -it --rm -p 4443:4443 -e STORAGE_EMULATOR_HOST=0.0.0.0:4443 fsouza/fa - Use trailing white space or the
HTML tag at the end of the line. - Use "`" sign to add single line code and "```" to add multi-line code block. - Use relative references to images (in `public` folder as mentioned above.) -* The [gofr.dev documentation](https://gofr.dev/docs) site is updated upon push to `/docs` path in the repo. Verify your changes are live after next GoFr version. \ No newline at end of file +* The [gofr.dev documentation](https://gofr.dev/docs) site is updated upon push to `/docs` path in the repo. Verify your changes are live after next GoFr version. diff --git a/README.md b/README.md index e70a51a4b8..6776772756 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ GoFr is designed to **simplify microservice development**, with a key focus on * 2. **REST Standards by Default** 3. **Configuration Management** 4. **[Observability](https://gofr.dev/docs/quick-start/observability)** (Logs, Traces, Metrics) -5. **Inbuilt [Auth Middleware](https://gofr.dev/docs/advanced-guide/http-authentication)** & Custom Middleware Support +5. **Inbuilt [Auth Middleware](https://gofr.dev/docs/advanced-guide/authentication)** & Custom Middleware Support 6. **[gRPC Support](https://gofr.dev/docs/advanced-guide/grpc)** 7. **[HTTP Service](https://gofr.dev/docs/advanced-guide/http-communication)** with Circuit Breaker Support 8. **[Pub/Sub](https://gofr.dev/docs/advanced-guide/using-publisher-subscriber)** From 2893f5c837370dfcbf571dd901b8b6cb3c95b342 Mon Sep 17 00:00:00 2001 From: Umang Mundhra Date: Wed, 9 Sep 2026 14:43:13 +0530 Subject: [PATCH 25/48] chore(deps): bump crate-ci/typos from 1.50.0 to 1.50.1 in the actions group (#4197) Closes: #4171 Co-authored-by: Aryan Mehrotra --- .github/workflows/typos.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/typos.yml b/.github/workflows/typos.yml index 7ad41dc116..8a64824ab0 100644 --- a/.github/workflows/typos.yml +++ b/.github/workflows/typos.yml @@ -27,4 +27,4 @@ jobs: - name: Checkout Code uses: actions/checkout@v7 - name: typos-action - uses: crate-ci/typos@4d9c206a77c041268485162b8e2579ad7a5cb9a3 # v1.50.0 + uses: crate-ci/typos@d43b6c087ac471e2ea7b8af622ff15f05c0c365b # v1.50.1 From ae523ba87a9b90627548ddc803f1326e839a3689 Mon Sep 17 00:00:00 2001 From: Umang Mundhra Date: Wed, 9 Sep 2026 14:50:11 +0530 Subject: [PATCH 26/48] chore(deps): consolidate minor/patch dependency updates (2026-09-09) (#4196) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Applied surgically per direct-dependency module (per-module go get + go mod tidy; no go work sync). All bumps are minor/patch/security — no majors, no go-redis mock regen needed (miniredis is a test double, not go-redis). Updates: - go.opentelemetry.io/otel/sdk 1.45.0 -> 1.46.0 (root, metrics/exporters/gcp, pubsub/nats, pubsub/sqs) - go.opentelemetry.io/otel/exporters/zipkin 1.44.0 -> 1.46.0 (root) - go.opentelemetry.io/contrib/detectors/gcp 1.44.0 -> 1.46.0 (metrics/exporters/gcp) - github.com/aws/aws-sdk-go-v2/config 1.32.37 -> 1.33.3 (file/s3, kv-store/dynamodb, pubsub/sqs, examples/using-s3-filestore) - github.com/aws/aws-sdk-go-v2/service/dynamodb 1.63.3 -> 1.67.0 (kv-store/dynamodb) - github.com/aws/aws-sdk-go-v2/service/sqs 1.46.6 -> 1.51.0 (pubsub/sqs) - github.com/nats-io/nats-server/v2 2.14.5 -> 2.14.6 (pubsub/nats) - golang.org/x/sync 0.22.0 -> 0.23.0 (root) - modernc.org/sqlite 1.56.0 -> 1.58.0 (root) - github.com/alicebob/miniredis/v2 2.38.0 -> 2.39.0 (root, test) - google.golang.org/grpc 1.83.1 -> 1.83.2 security (root + library modules + examples; pulls golang.org/x/net 0.57.0 -> 0.58.0). examples/using-gcp-metrics is excluded: it is baseline-untidy (excluded from the CI tidy gate) and tidying it to apply grpc would settle unrelated versions. Closes: #4172, #4173, #4174, #4175, #4176, #4177, #4178, #4179, #4180, #4181, #4182, #4183, #4184, #4185, #4186, #4187, #4188, #4189, #4190, #4191, #4192, #4194 Co-authored-by: Aryan Mehrotra --- examples/using-add-filestore/go.mod | 4 +- examples/using-add-filestore/go.sum | 8 +- examples/using-cloudsql/go.mod | 4 +- examples/using-cloudsql/go.sum | 8 +- examples/using-s3-filestore/go.mod | 32 ++++---- examples/using-s3-filestore/go.sum | 64 ++++++++-------- go.mod | 26 +++---- go.sum | 68 ++++++++--------- go.work.sum | 22 ++++++ pkg/gofr/datasource/arangodb/go.mod | 2 +- pkg/gofr/datasource/arangodb/go.sum | 4 +- pkg/gofr/datasource/cloudsql/go.mod | 4 +- pkg/gofr/datasource/cloudsql/go.sum | 8 +- pkg/gofr/datasource/couchbase/go.mod | 4 +- pkg/gofr/datasource/couchbase/go.sum | 8 +- pkg/gofr/datasource/dbresolver/go.mod | 4 +- pkg/gofr/datasource/dbresolver/go.sum | 8 +- pkg/gofr/datasource/dgraph/go.mod | 4 +- pkg/gofr/datasource/dgraph/go.sum | 8 +- pkg/gofr/datasource/file/azure/go.mod | 3 +- pkg/gofr/datasource/file/azure/go.sum | 4 +- pkg/gofr/datasource/file/gcs/go.mod | 4 +- pkg/gofr/datasource/file/gcs/go.sum | 8 +- pkg/gofr/datasource/file/s3/go.mod | 28 +++---- pkg/gofr/datasource/file/s3/go.sum | 56 +++++++------- pkg/gofr/datasource/influxdb/go.mod | 2 +- pkg/gofr/datasource/influxdb/go.sum | 4 +- pkg/gofr/datasource/kv-store/dynamodb/go.mod | 32 ++++---- pkg/gofr/datasource/kv-store/dynamodb/go.sum | 64 ++++++++-------- pkg/gofr/datasource/oracle/go.mod | 4 +- pkg/gofr/datasource/oracle/go.sum | 8 +- pkg/gofr/datasource/pubsub/eventhub/go.mod | 3 +- pkg/gofr/datasource/pubsub/eventhub/go.sum | 4 +- pkg/gofr/datasource/pubsub/nats/go.mod | 10 +-- pkg/gofr/datasource/pubsub/nats/go.sum | 24 +++--- pkg/gofr/datasource/pubsub/sqs/go.mod | 38 +++++----- pkg/gofr/datasource/pubsub/sqs/go.sum | 80 ++++++++++---------- pkg/gofr/metrics/exporters/gcp/go.mod | 19 +++-- pkg/gofr/metrics/exporters/gcp/go.sum | 40 +++++----- 39 files changed, 372 insertions(+), 353 deletions(-) diff --git a/examples/using-add-filestore/go.mod b/examples/using-add-filestore/go.mod index c7ff5f4e7e..672545de74 100644 --- a/examples/using-add-filestore/go.mod +++ b/examples/using-add-filestore/go.mod @@ -84,7 +84,7 @@ require ( go.uber.org/atomic v1.11.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/crypto v0.55.0 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect golang.org/x/sync v0.22.0 // indirect golang.org/x/sys v0.47.0 // indirect @@ -95,7 +95,7 @@ require ( google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect - google.golang.org/grpc v1.83.1 // indirect + google.golang.org/grpc v1.83.2 // indirect google.golang.org/protobuf v1.36.11 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect modernc.org/libc v1.74.4 // indirect diff --git a/examples/using-add-filestore/go.sum b/examples/using-add-filestore/go.sum index 7649b4057d..05d11c6faf 100644 --- a/examples/using-add-filestore/go.sum +++ b/examples/using-add-filestore/go.sum @@ -286,8 +286,8 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= @@ -356,8 +356,8 @@ google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyac google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= -google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= +google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= diff --git a/examples/using-cloudsql/go.mod b/examples/using-cloudsql/go.mod index 19f87d5581..440d24e957 100644 --- a/examples/using-cloudsql/go.mod +++ b/examples/using-cloudsql/go.mod @@ -91,7 +91,7 @@ require ( go.yaml.in/yaml/v2 v2.4.4 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/crypto v0.55.0 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect golang.org/x/sync v0.22.0 // indirect golang.org/x/sys v0.47.0 // indirect @@ -102,7 +102,7 @@ require ( google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect - google.golang.org/grpc v1.83.1 // indirect + google.golang.org/grpc v1.83.2 // indirect google.golang.org/protobuf v1.36.12 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect modernc.org/libc v1.73.4 // indirect diff --git a/examples/using-cloudsql/go.sum b/examples/using-cloudsql/go.sum index 917e84f4e2..c80933626b 100644 --- a/examples/using-cloudsql/go.sum +++ b/examples/using-cloudsql/go.sum @@ -300,8 +300,8 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= @@ -371,8 +371,8 @@ google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyac google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= -google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= +google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= diff --git a/examples/using-s3-filestore/go.mod b/examples/using-s3-filestore/go.mod index 5f39f04298..e36996b73a 100644 --- a/examples/using-s3-filestore/go.mod +++ b/examples/using-s3-filestore/go.mod @@ -3,9 +3,9 @@ module gofr.dev/examples/using-s3-filestore go 1.26.0 require ( - github.com/aws/aws-sdk-go-v2 v1.43.6 - github.com/aws/aws-sdk-go-v2/config v1.32.37 - github.com/aws/aws-sdk-go-v2/credentials v1.19.36 + github.com/aws/aws-sdk-go-v2 v1.46.0 + github.com/aws/aws-sdk-go-v2/config v1.33.3 + github.com/aws/aws-sdk-go-v2/credentials v1.20.3 github.com/aws/aws-sdk-go-v2/service/s3 v1.107.2 github.com/stretchr/testify v1.12.1 gofr.dev v1.57.0 @@ -25,19 +25,19 @@ require ( github.com/XSAM/otelsql v0.43.0 // indirect github.com/agnivade/levenshtein v1.2.1 // indirect github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.18 // indirect - github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.37 // indirect - github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.37 // indirect - github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37 // indirect - github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2 // indirect + github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 // indirect github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.30 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2 // indirect github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.38 // indirect - github.com/aws/aws-sdk-go-v2/service/signin v1.5.6 // indirect - github.com/aws/aws-sdk-go-v2/service/sso v1.33.6 // indirect - github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.6 // indirect - github.com/aws/aws-sdk-go-v2/service/sts v1.45.6 // indirect - github.com/aws/smithy-go v1.27.8 // indirect + github.com/aws/aws-sdk-go-v2/service/signin v1.9.0 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.37.0 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.42.0 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.49.0 // indirect + github.com/aws/smithy-go v1.28.1 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/cenkalti/backoff/v5 v5.0.3 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect @@ -101,7 +101,7 @@ require ( go.uber.org/mock v0.6.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/crypto v0.55.0 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect golang.org/x/sync v0.22.0 // indirect golang.org/x/sys v0.47.0 // indirect @@ -112,7 +112,7 @@ require ( google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260724162435-b2f20204f0df // indirect - google.golang.org/grpc v1.83.1 // indirect + google.golang.org/grpc v1.83.2 // indirect google.golang.org/protobuf v1.36.11 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect modernc.org/libc v1.74.4 // indirect diff --git a/examples/using-s3-filestore/go.sum b/examples/using-s3-filestore/go.sum index 2d7784bedb..fbd103eb60 100644 --- a/examples/using-s3-filestore/go.sum +++ b/examples/using-s3-filestore/go.sum @@ -30,42 +30,42 @@ github.com/alicebob/miniredis/v2 v2.38.0 h1:nZAzCR+Lj+Vxk4ZXzm2NuKq2O33RXj1XxJ2e github.com/alicebob/miniredis/v2 v2.38.0/go.mod h1:TcL7YfarKPGDAthEtl5NBeHZfeUQj6OXMm/+iu5cLMM= github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0 h1:jfIu9sQUG6Ig+0+Ap1h4unLjW6YQJpKZVmUzxsD4E/Q= github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0/go.mod h1:t2tdKJDJF9BV14lnkjHmOQgcvEKgtqs5a1N3LNdJhGE= -github.com/aws/aws-sdk-go-v2 v1.43.6 h1:RrmFcqCBxkJuf7g1axVo5krB4jM/AO8r5e5oujrgdoQ= -github.com/aws/aws-sdk-go-v2 v1.43.6/go.mod h1:tXpPM+v0D1lndmga+HqqLDIzUFJlEeR21aspVklHF00= +github.com/aws/aws-sdk-go-v2 v1.46.0 h1:1kt7m/EKcEHt5mlyyxx9cSlMddRPIKbjb6DIQsu4HPk= +github.com/aws/aws-sdk-go-v2 v1.46.0/go.mod h1:bttEH6JqnUL8LepvDVfdrds/fZ5bCIxzpe3abyUrhDU= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.18 h1:LAfOuhAH331fmOjTQpAaOlH+Ftn7RzSDJ2VFwjdMMy4= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.18/go.mod h1:4e5xhuXHx1e4U9EthvbPP1r/DIMp5c2823OL8karzcM= -github.com/aws/aws-sdk-go-v2/config v1.32.37 h1:Ljl7LOJB6ym0liuEl0+TZ3d7f5I8MEZN1Cj9PINlj/g= -github.com/aws/aws-sdk-go-v2/config v1.32.37/go.mod h1:WJ7pe7ZPpmG8Q5kKS53zeypIV4FBGACxmte8Uc6SgUc= -github.com/aws/aws-sdk-go-v2/credentials v1.19.36 h1:84s5xMme6ENYEdKG8rsbSFFg/8+lbHBeM9QYSO0gnDk= -github.com/aws/aws-sdk-go-v2/credentials v1.19.36/go.mod h1:c46BLdagDLIswjgt+GeQOslXgeS0E6wCacs5yZbxPGk= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.37 h1:b5tb+CZItBkydC7r3hTNdSO3pszG1R2EtnA+7TePQPk= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.37/go.mod h1:ZQ+6SU9X0oz6+7MUCSswv9Mjci4eaqZr21HI2RVy/yA= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.37 h1:lznzIOvvbqjfe8UAaciCRJgBgJsxuTROKlhZuXQWfv8= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.37/go.mod h1:otfkzyfQeMMLZAqX59GSXTL3o22BR/l6HFaRzzbWSqA= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37 h1:zCEORWo0eU0gDjG+IyApE/2B+ZGG1m+GU7B263XV8ds= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37/go.mod h1:i6c0PEl3TNOWxRbQ++KQcVenPWS/GoQeiklKhNuqzJ8= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38 h1:A3UAuCmx7LyUcrixBTzKJYYIUZ2yTvn6ZhT8PB+7APk= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38/go.mod h1:1PDUYG9Z+JrbbsobsAZHjWOm9QBT/djiK3QbykTL5Z4= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17 h1:OvYZOB3qA6zvfdRFiRFRzVSiElMYrz3GdntkXZxlp1o= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17/go.mod h1:JgR/2Ew50ACfIWau1oeMRX59tMtC0kM+PYQGEaT04cY= +github.com/aws/aws-sdk-go-v2/config v1.33.3 h1:h090b3O5S17bF87/0ysHZuIT/7DCb4EBRFQX2PMVPCw= +github.com/aws/aws-sdk-go-v2/config v1.33.3/go.mod h1:YYDB1kTejxbfAbEVUqgCtkVp26xvNCHev9cLKABMGAk= +github.com/aws/aws-sdk-go-v2/credentials v1.20.3 h1:tToOYM/LXev4NpfWlIYGDvBvjHmJ3HXpRU9ppl+pM6k= +github.com/aws/aws-sdk-go-v2/credentials v1.20.3/go.mod h1:wfGneWyncO7p67wqXV2IQhPk14JqIc25woKlaArT3WI= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2 h1:Ldv7RPHs7qwwTscRjAl3YBud32f3BvdAGRmSvAx5L38= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2/go.mod h1:XyK6UV8xbo66ysVqLd2783C09pBYHOm8aKTRV5DVJ30= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2 h1:q/PSLGuRWCChWg+dLnb9dWOnrCxJtnboXbBtFoqqRrI= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2/go.mod h1:TD1jvU2LvXkJexct5vBqcd8QlNXh5EmRUeL/Z32p0n4= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2 h1:6fl86IPqKEXoySqiOWdfgbEp9OVbn44zTfEICNEBDhY= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2/go.mod h1:63HDfhFkdzBpI8WGXTSKUHPKS6mqldj4u3LJW7RZtSU= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2 h1:XMgIRS+uW9F3yFKnXGRrI9pkHi99CXTmoz2kz2/TGBA= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2/go.mod h1:vorxDzK+n3jiv9a5ST/LG0Eu9cSv1CRdKTpG6pDMs+M= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 h1:bAdDl/HkGCcGPoe25ToSHEw23VIxt6CT5fLcg111BKg= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19/go.mod h1:KaUzbLxv4CeSxh6ZCl9B4m7CuFenS8kUEaDs+f/DQr4= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.30 h1:5437eMoOwqqQpZn2XJy74mlDCuPYL81texMT3mXqgtU= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.30/go.mod h1:xfu2m3dOpvW8lj98wQYa8V9ku/Rta59hsbireGzhh3A= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37 h1:a3D4AjrOrTrP8+d9ILBthqrElf0z1JNol09Xvnwcys8= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37/go.mod h1:ky0gTu+ukvUTuUKFIpp6Wid4oninrkCyvbFkVs0kpHM= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2 h1:ZtHYnumr6QyxhzEzNZwzQTFJEXOswrZqTTkRxthwvr4= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2/go.mod h1:a1NXrYpBd311gBzn1UI5UzJyyvXktM4xNh/ydPiPpqY= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.38 h1:gX8B8y3Ho30B1LPxefDKMi/HZqWEb47U9ogs3DtSG0M= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.38/go.mod h1:l5WblZlcmGPe4/O7JY2HO25Z+xqTBvyfTyFbRMf8gYw= github.com/aws/aws-sdk-go-v2/service/s3 v1.107.2 h1:GNU0/xtPEXMKilJZ/a8BedeuQnvu+Usi6qVm9EFfncc= github.com/aws/aws-sdk-go-v2/service/s3 v1.107.2/go.mod h1:4jYWUecEsQtE73jPl7p3jrbYXH5ffcR4gegyCygagfg= -github.com/aws/aws-sdk-go-v2/service/signin v1.5.6 h1:i68sFvXidKlkiSvI7d7Ilc1/UvW4CtBOaivH7jhG4fs= -github.com/aws/aws-sdk-go-v2/service/signin v1.5.6/go.mod h1:/h7Obr9WTtzbjTHGASRQwLN7Bupw+TC3x8x7fyx39hE= -github.com/aws/aws-sdk-go-v2/service/sso v1.33.6 h1:tpfGChmjUmv3W9WlRvy+stwKDTbFFdq8Zk9DbFPrfMU= -github.com/aws/aws-sdk-go-v2/service/sso v1.33.6/go.mod h1:CSjiDzmG/lsKkTOYjbkM+duLmRlW+LOxD64Na44ijnI= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.6 h1:49BBtY68A+KJCQ3a2F3eUe6ROsKucxUdfHKoqorc0wI= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.6/go.mod h1:ptG2hbs7QltE1GcQY0MpS4bfrc51KCnBXUr7OT1EEfE= -github.com/aws/aws-sdk-go-v2/service/sts v1.45.6 h1:JvExZWabChDM0qJAirQYGfOYo0ndT3edXj+fqSPNjkE= -github.com/aws/aws-sdk-go-v2/service/sts v1.45.6/go.mod h1:XZcaQkV2cItp6yEkrwljyaPOf22RuX7T43jxap/FOmM= -github.com/aws/smithy-go v1.27.8 h1:FR0dxZfIlV7Z8eh2iHfIofdunw382XsDV3Mxt9nUvRY= -github.com/aws/smithy-go v1.27.8/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= +github.com/aws/aws-sdk-go-v2/service/signin v1.9.0 h1:c3k+k/CS4L+sAIH6fxikL+g5g2LpeNczaoyjjw1iMKI= +github.com/aws/aws-sdk-go-v2/service/signin v1.9.0/go.mod h1:AGIoQg99fBrOIQnF78TLx4lj18mc4gZ0hJx1UaLIFM4= +github.com/aws/aws-sdk-go-v2/service/sso v1.37.0 h1:+rqBaOq7jzInjY8M12hr+zEe85JpRll9BjMx38r33Ok= +github.com/aws/aws-sdk-go-v2/service/sso v1.37.0/go.mod h1:XFlVwUsw3sYh8Hw37umYVJnrcWrwXWRxbNw/JY0bblw= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.42.0 h1:hzM3GslEAOBcLn3DHH6ENToFi+vXP+n02W+x6zejAIM= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.42.0/go.mod h1:588e7skMkYIYkSUseT8E3WKFfbAfrA1bj3Zf+qxJtJY= +github.com/aws/aws-sdk-go-v2/service/sts v1.49.0 h1:N7Ey8obY3uSui+cxl0OUzFlFmkxSucoJnrniFhw+cLc= +github.com/aws/aws-sdk-go-v2/service/sts v1.49.0/go.mod h1:zMBwjSf4Pt8a1OHYiZ5rPD0PJRK1kQrUaxhS/Dbld8E= +github.com/aws/smithy-go v1.28.1 h1:R/nXH00c8qcfCzQVELtRw+eLQWtzv+VAIEFJ1/xxXlQ= +github.com/aws/smithy-go v1.28.1/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= @@ -316,8 +316,8 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= @@ -386,8 +386,8 @@ google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyac google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= -google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= +google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= diff --git a/go.mod b/go.mod index d10f923468..ecf08b6bd9 100644 --- a/go.mod +++ b/go.mod @@ -6,7 +6,7 @@ require ( cloud.google.com/go/pubsub v1.51.0 github.com/DATA-DOG/go-sqlmock v1.5.2 github.com/XSAM/otelsql v0.43.0 - github.com/alicebob/miniredis/v2 v2.38.0 + github.com/alicebob/miniredis/v2 v2.39.0 github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d github.com/eclipse/paho.mqtt.golang v1.5.1 github.com/go-redis/redismock/v9 v9.2.0 @@ -29,29 +29,29 @@ require ( github.com/stretchr/testify v1.12.1 github.com/vektah/gqlparser/v2 v2.5.36 go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 - go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/otel v1.46.0 go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0 go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.44.0 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 go.opentelemetry.io/otel/exporters/prometheus v0.67.0 - go.opentelemetry.io/otel/exporters/zipkin v1.44.0 - go.opentelemetry.io/otel/metric v1.45.0 - go.opentelemetry.io/otel/sdk v1.45.0 - go.opentelemetry.io/otel/sdk/metric v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel/exporters/zipkin v1.46.0 + go.opentelemetry.io/otel/metric v1.46.0 + go.opentelemetry.io/otel/sdk v1.46.0 + go.opentelemetry.io/otel/sdk/metric v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/goleak v1.3.0 go.uber.org/mock v0.6.0 golang.org/x/oauth2 v0.36.0 - golang.org/x/sync v0.22.0 + golang.org/x/sync v0.23.0 golang.org/x/term v0.45.0 golang.org/x/text v0.41.0 golang.org/x/time v0.15.0 google.golang.org/api v0.291.0 google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 - google.golang.org/grpc v1.83.1 + google.golang.org/grpc v1.83.2 google.golang.org/protobuf v1.36.12 gopkg.in/yaml.v3 v3.0.1 - modernc.org/sqlite v1.56.0 + modernc.org/sqlite v1.58.0 ) require ( @@ -103,11 +103,11 @@ require ( go.uber.org/atomic v1.11.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/crypto v0.55.0 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/sys v0.47.0 // indirect google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect - modernc.org/libc v1.74.4 // indirect + modernc.org/libc v1.75.6 // indirect modernc.org/mathutil v1.7.1 // indirect - modernc.org/memory v1.11.0 // indirect + modernc.org/memory v1.12.1 // indirect ) diff --git a/go.sum b/go.sum index 3a70b288dd..f433e34749 100644 --- a/go.sum +++ b/go.sum @@ -26,8 +26,8 @@ github.com/XSAM/otelsql v0.43.0 h1:ZIhXqRoMhILXQwBQoq/Dl6Taap/KEFQXZrWjYV1L8X8= github.com/XSAM/otelsql v0.43.0/go.mod h1:DJBGBvbtwf1OCBYRTjpRFxOqi6ONpdfb+htr4ncRWuw= github.com/agnivade/levenshtein v1.2.1 h1:EHBY3UOn1gwdy/VbFwgo4cxecRznFk7fKWN1KOX7eoM= github.com/agnivade/levenshtein v1.2.1/go.mod h1:QVVI16kDrtSuwcpd0p1+xMC6Z/VfhtCyDIjcwga4/DU= -github.com/alicebob/miniredis/v2 v2.38.0 h1:nZAzCR+Lj+Vxk4ZXzm2NuKq2O33RXj1XxJ2e2uP9jiw= -github.com/alicebob/miniredis/v2 v2.38.0/go.mod h1:TcL7YfarKPGDAthEtl5NBeHZfeUQj6OXMm/+iu5cLMM= +github.com/alicebob/miniredis/v2 v2.39.0 h1:M7WbmV5BmV56L8KTG0rw6vEQ+woTOghpDgin2xv4A0g= +github.com/alicebob/miniredis/v2 v2.39.0/go.mod h1:TcL7YfarKPGDAthEtl5NBeHZfeUQj6OXMm/+iu5cLMM= github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0 h1:jfIu9sQUG6Ig+0+Ap1h4unLjW6YQJpKZVmUzxsD4E/Q= github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0/go.mod h1:t2tdKJDJF9BV14lnkjHmOQgcvEKgtqs5a1N3LNdJhGE= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= @@ -226,8 +226,8 @@ go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0. go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0/go.mod h1:kmJlX6WuTrAH1fOCSbPJFrSnUagB8c3SY3E87It3JD8= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 h1:LMuyCAyfalSjDyjdC65nK6N0zoTT63+E/u95X0JovZI= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0/go.mod h1:085m8qbm4hgc8rZWGDEa4vmyyo2c3nPxUslYUKUIU04= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0 h1:SUplec5dp06reu1zaXmOXdvqH398taqrDXqUl99jxSc= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0/go.mod h1:ho2g4N+ane+swq5I/VBkKWnRDY4kUINH3FuqyZqX/Ug= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.44.0 h1:RuynHbfU8JUEw7DyONgkVYg2SVtsoF28y0LGIr69jgA= @@ -238,18 +238,18 @@ go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 h1:qazEJ go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0/go.mod h1:fOD2Yefuxixkx3ahVNf0O/PERb6r4OlbxfATVnYvzCo= go.opentelemetry.io/otel/exporters/prometheus v0.67.0 h1:7IefDa35e6V3NoiqIeLDMDxMFyZDk5qcoC0Ax4cC16E= go.opentelemetry.io/otel/exporters/prometheus v0.67.0/go.mod h1:nsPI1awTg5Vmg1YrommL2mVarVGlqc4yXOoKAkPRD0c= -go.opentelemetry.io/otel/exporters/zipkin v1.44.0 h1:zv7PRYGLrQHkdeZj0c5SNAZOJcw55XgaTezUkNpwA+w= -go.opentelemetry.io/otel/exporters/zipkin v1.44.0/go.mod h1:3+VZyCi6hFW+UuxFF+wSOvwsOwncfBpQfP7Qdb3JXKg= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= -go.opentelemetry.io/otel/metric/x v0.67.0 h1:PcicCNZFkZ4bXfSooXdo3WN7RBOVOtjVdo1wD358Uns= -go.opentelemetry.io/otel/metric/x v0.67.0/go.mod h1:FBjCWZe6wgcqxcMtjdGiClDKXb2YxxXii0CXftE4QtI= -go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= -go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= -go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= -go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel/exporters/zipkin v1.46.0 h1:7y0nqfbwuPdaYKwm35PRMRMOa8iYu1SXxnAJNNR2o1M= +go.opentelemetry.io/otel/exporters/zipkin v1.46.0/go.mod h1:MGmDLXGsdDzWBOt0y5VcW2u5hRsFV4MzylPvvNkQ9qw= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/metric/x v0.68.0 h1:TA/cBT23D3MnxYPwHL7YFOdYGdx0A0v+s7Mzotpd1dU= +go.opentelemetry.io/otel/metric/x v0.68.0/go.mod h1:agudOmvWhwUTjgibWDzxD2PoWYnpw5Ht5jISYOD2Hd4= +go.opentelemetry.io/otel/sdk v1.46.0 h1:h5CNQQjEbuQXY/JfZtgt3i7HVFV3aHPO2OAwO2eTYPI= +go.opentelemetry.io/otel/sdk v1.46.0/go.mod h1:GAERFXFt5SYCEB+YiKUbMBeza6UaDH7GmGOZEfh2gSM= +go.opentelemetry.io/otel/sdk/metric v1.46.0 h1:0piZ26EG4RBfebb2jhDH6ERCYHoVWduc3kLgPCwSnSE= +go.opentelemetry.io/otel/sdk/metric v1.46.0/go.mod h1:I1PbKrdVc8Qu8HYVDNtqVIwLwjNrhsV/uFuxfwg8mO4= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.opentelemetry.io/proto/otlp v1.10.0 h1:IQRWgT5srOCYfiWnpqUYz9CVmbO8bFmKcwYxpuCSL2g= go.opentelemetry.io/proto/otlp v1.10.0/go.mod h1:/CV4QoCR/S9yaPj8utp3lvQPoqMtxXdzn7ozvvozVqk= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= @@ -288,8 +288,8 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= @@ -299,8 +299,8 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek= -golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= +golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk= +golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -359,8 +359,8 @@ google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyac google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= -google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= +google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -384,30 +384,30 @@ gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q= gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -modernc.org/cc/v4 v4.29.1 h1:MKgdCV3WykTSPqpVrnxdEDS0HEd2FHpKZDzxzU5LyeI= -modernc.org/cc/v4 v4.29.1/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= -modernc.org/ccgo/v4 v4.34.6 h1:sBgfIwyN0TQ9C5hwIeuqyeAKyMWnbvj2fvpF4L11uzU= -modernc.org/ccgo/v4 v4.34.6/go.mod h1:SZ8YcN9NG7XVsQYdm6jYBvi8PQP1qi+kqB6OhjqI3Fk= +modernc.org/cc/v4 v4.29.2 h1:h6+9ciCnPKutf4I03CvheAvDLX7+IHlqR6Iy6J+cgd8= +modernc.org/cc/v4 v4.29.2/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= +modernc.org/ccgo/v4 v4.35.0 h1:F+TUsmw09QxLzmi3aeYYGxjAXarmZaKgj3mKQHNaA8w= +modernc.org/ccgo/v4 v4.35.0/go.mod h1:qrVGs9S3Sr2Ztcg9ve+kTAYMp5a3YvWjo+SoN06kJ5I= modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM= modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU= modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI= modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito= -modernc.org/gc/v3 v3.1.4 h1:2g65LGVSmFQrXeITAw97x7hCRvZFcyE1uDP+7Vng7JI= -modernc.org/gc/v3 v3.1.4/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= +modernc.org/gc/v3 v3.1.5 h1:21ldfPfRYE31Tb7B3mwAK8gy1AxP4+dKjrOQPfqakoc= +modernc.org/gc/v3 v3.1.5/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks= modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI= -modernc.org/libc v1.74.4 h1:fX1Omw4o2/1C2iRkkIsrQTasJQldLhRmuPreXLoWs9k= -modernc.org/libc v1.74.4/go.mod h1:eeQAS9W3sZeKYMFubydxJpII9ybHWshk+7or7bLG9co= +modernc.org/libc v1.75.6 h1:yKk8qo+Di4gkmvRboK8ocCqH22FiUCR6jRy2OwtCRus= +modernc.org/libc v1.75.6/go.mod h1:bO5o2ztHxBb2rjz0PgdHN0sSMw57CgxGFLZ3Qd/QpVQ= modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= -modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI= -modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw= +modernc.org/memory v1.12.1 h1:nFMiWrpStgZczNl6XI9GnIk/rWhYIyHGUaR04pGbp9g= +modernc.org/memory v1.12.1/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw= modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg= modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE= -modernc.org/sqlite v1.56.0 h1:/D8e2RfFqoy/Zc6PuC76U28zFwmI/sYx1Kjm4yEn9e0= -modernc.org/sqlite v1.56.0/go.mod h1:yCJ2cmAaIkHQ25oXWrF8H4O1lIfPYPR26yCEDj2P3pQ= +modernc.org/sqlite v1.58.0 h1:38u40/bwkfM7f0Myhosl+SEMltSDxnGdQf8o6Kjmys0= +modernc.org/sqlite v1.58.0/go.mod h1:rsD2CckafgObKC4DhBlGBf+RiHxkc3hINGt1Xw32tVY= modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= diff --git a/go.work.sum b/go.work.sum index eb80590586..342cd78fa8 100644 --- a/go.work.sum +++ b/go.work.sum @@ -274,6 +274,7 @@ cloud.google.com/go/compute v1.49.1 h1:KYKIG0+pfpAWaAYayFkE/KPrAVCge0Hu82bPraAms cloud.google.com/go/compute v1.49.1/go.mod h1:1uoZvP8Avyfhe3Y4he7sMOR16ZiAm2Q+Rc2P5rrJM28= cloud.google.com/go/compute v1.54.0 h1:4CKmnpO+40z44bKG5bdcKxQ7ocNpRtOc9SCLLUzze1w= cloud.google.com/go/compute v1.54.0/go.mod h1:RfBj0L1x/pIM84BrzNX2V21oEv16EKRPBiTcBRRH1Ww= +cloud.google.com/go/compute v1.62.0 h1:tJ7lKJ8YEVa6vZX03Jc8o1YePbjKDOQhDw1BscMZ1bs= cloud.google.com/go/compute v1.62.0/go.mod h1:Xm6PbsLgBpAg4va77ljbBdpMjzuU+uPp5Ze2dnZq7lw= cloud.google.com/go/compute v1.63.0 h1:KsBourH0wajM4RhzwPwRMKbxHVdvzGsk7StvACoWXD8= cloud.google.com/go/compute v1.63.0/go.mod h1:Xm6PbsLgBpAg4va77ljbBdpMjzuU+uPp5Ze2dnZq7lw= @@ -1230,6 +1231,7 @@ github.com/go-jose/go-jose/v4 v4.1.3/go.mod h1:x4oUasVrzR7071A4TnHLGSPpNOm2a21K9 github.com/go-kit/log v0.1.0 h1:DGJh0Sm43HbOeYDNnVZFl8BvcYVvjD5bqYJvp0REbwQ= github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY= github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= @@ -1321,6 +1323,7 @@ github.com/googleapis/enterprise-certificate-proxy v0.3.6/go.mod h1:MkHOF77EYAE7 github.com/googleapis/enterprise-certificate-proxy v0.3.7/go.mod h1:MkHOF77EYAE7qfSuSS9PU6g4Nt4e11cnsDUowfwewLA= github.com/googleapis/enterprise-certificate-proxy v0.3.11/go.mod h1:RFV7MUdlb7AgEq2v7FmMCfeSMCllAzWxFgRdusoGks8= github.com/googleapis/enterprise-certificate-proxy v0.3.14/go.mod h1:vqVt9yG9480NtzREnTlmGSBmFrA+bzb0yl0TxoBQXOg= +github.com/googleapis/enterprise-certificate-proxy v0.3.17/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= github.com/googleapis/enterprise-certificate-proxy v0.3.18/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= @@ -1421,6 +1424,7 @@ github.com/klauspost/compress v1.18.2/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxh github.com/klauspost/compress v1.18.5/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= github.com/klauspost/compress v1.19.1/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= github.com/kr/pty v1.1.1 h1:VkoXIwSboBpnk99O/KFauAEILuNHv5DVFKZMBN/gUgw= github.com/labstack/echo/v4 v4.11.1 h1:dEpLU2FLg4UVmvCGPuk/APjlH6GDpbEPti61srUUUs4= @@ -1509,6 +1513,7 @@ github.com/pierrec/lz4/v4 v4.1.15/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFu github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8/go.mod h1:HKlIX3XHQyzLZPlr7++PzdhaXEj94dEiJgZDTsxEqUI= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e h1:aoZm08cpOy4WuID//EZDgcC4zIxODThtZNPirFr42+A= github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c h1:ncq/mPwQF4JjgDlrVEn3C11VoGHZN7m8qihwgMEtzYw= github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU= @@ -1557,10 +1562,12 @@ github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An github.com/spiffe/go-spiffe/v2 v2.5.0/go.mod h1:P+NxobPc6wXhVtINNtFjNWGBTreew1GBUCwT2wPmb7g= github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad h1:fiWzISvDn0Csy5H0iwgAuJGQTUpVfEMJJd4nRFXogbc= github.com/stoewer/go-strcase v1.3.0/go.mod h1:fAH5hQ5pehh+j3nZfvwdk2RgEgQjAoM8wodgtPmh1xo= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= github.com/tdewolff/minify/v2 v2.12.8 h1:Q2BqOTmlMjoutkuD/OPCnJUpIqrzT3nRPkw+q+KpXS0= github.com/tdewolff/minify/v2 v2.12.8/go.mod h1:YRgk7CC21LZnbuke2fmYnCTq+zhCgpb0yJACOTUNJ1E= github.com/tdewolff/parse/v2 v2.6.7 h1:WrFllrqmzAcrKHzoYgMupqgUBIfBVOb0yscFzDf8bBg= @@ -1635,6 +1642,7 @@ go.opentelemetry.io/otel v1.39.0/go.mod h1:kLlFTywNWrFyEdH0oj2xK0bFYZtHRYUdv1Nkl go.opentelemetry.io/otel v1.40.0/go.mod h1:IMb+uXZUKkMXdPddhwAHm6UfOwJyh4ct1ybIlV14J0g= go.opentelemetry.io/otel v1.42.0/go.mod h1:lJNsdRMxCUIWuMlVJWzecSMuNjE7dOYyWlqOXWkdqCc= go.opentelemetry.io/otel v1.43.0/go.mod h1:JuG+u74mvjvcm8vj8pI5XiHy1zDeoCS2LB1spIq7Ay0= +go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= go.opentelemetry.io/otel/metric v1.22.0/go.mod h1:evJGjVpZv0mQ5QBRJoBF64yMuOf4xCWdXjK8pzFvliY= go.opentelemetry.io/otel/metric v1.35.0/go.mod h1:nKVFgxBZ2fReX6IlyW28MgZojkoAkJGaE8CpgeAU3oE= go.opentelemetry.io/otel/metric v1.36.0/go.mod h1:zC7Ks+yeyJt4xig9DEw9kuUFe5C3zLbVjV2PzT6qzbs= @@ -1644,6 +1652,7 @@ go.opentelemetry.io/otel/metric v1.39.0/go.mod h1:jrZSWL33sD7bBxg1xjrqyDjnuzTUB0 go.opentelemetry.io/otel/metric v1.40.0/go.mod h1:ib/crwQH7N3r5kfiBZQbwrTge743UDc7DTFVZrrXnqc= go.opentelemetry.io/otel/metric v1.42.0/go.mod h1:RlUN/7vTU7Ao/diDkEpQpnz3/92J9ko05BIwxYa2SSI= go.opentelemetry.io/otel/metric v1.43.0/go.mod h1:RDnPtIxvqlgO8GRW18W6Z/4P462ldprJtfxHxyKd2PY= +go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= go.opentelemetry.io/otel/sdk v1.22.0/go.mod h1:iu7luyVGYovrRpe2fmj3CVKouQNdTOkxtLzPvPz1DOc= go.opentelemetry.io/otel/sdk v1.35.0/go.mod h1:+ga1bZliga3DxJ3CQGg3updiaAJoNECOgJREo9KHGQg= go.opentelemetry.io/otel/sdk v1.36.0/go.mod h1:+lC+mTgD+MUWfjJubi2vvXWcVxyr9rmlshZni72pXeY= @@ -1651,12 +1660,14 @@ go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+ go.opentelemetry.io/otel/sdk v1.39.0/go.mod h1:vDojkC4/jsTJsE+kh+LXYQlbL8CgrEcwmt1ENZszdJE= go.opentelemetry.io/otel/sdk v1.42.0/go.mod h1:rGHCAxd9DAph0joO4W6OPwxjNTYWghRWmkHuGbayMts= go.opentelemetry.io/otel/sdk v1.43.0/go.mod h1:P+IkVU3iWukmiit/Yf9AWvpyRDlUeBaRg6Y+C58QHzg= +go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= go.opentelemetry.io/otel/sdk/metric v1.35.0/go.mod h1:is6XYCUMpcKi+ZsOvfluY5YstFnhW0BidkR+gL+qN+w= go.opentelemetry.io/otel/sdk/metric v1.36.0/go.mod h1:qTNOhFDfKRwX0yXOqJYegL5WRaW376QbB7P4Pb0qva4= go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA= go.opentelemetry.io/otel/sdk/metric v1.39.0/go.mod h1:xq9HEVH7qeX69/JnwEfp6fVq5wosJsY1mt4lLfYdVew= go.opentelemetry.io/otel/sdk/metric v1.42.0/go.mod h1:Ua6AAlDKdZ7tdvaQKfSmnFTdHx37+J4ba8MwVCYM5hc= go.opentelemetry.io/otel/sdk/metric v1.43.0/go.mod h1:C/RJtwSEJ5hzTiUz5pXF1kILHStzb9zFlIEe85bhj6A= +go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= go.opentelemetry.io/otel/trace v1.22.0/go.mod h1:RbbHXVqKES9QhzZq/fE5UnOSILqRt40a21sPw2He1xo= go.opentelemetry.io/otel/trace v1.35.0/go.mod h1:WUk7DtFp1Aw2MkvqGdwiXYDZZNvA/1J8o6xRXLrIkyc= go.opentelemetry.io/otel/trace v1.36.0/go.mod h1:gQ+OnDZzrybY4k4seLzPAWNwVBBVlF2szhehOBB/tGA= @@ -1666,6 +1677,7 @@ go.opentelemetry.io/otel/trace v1.39.0/go.mod h1:88w4/PnZSazkGzz/w84VHpQafiU4Etq go.opentelemetry.io/otel/trace v1.40.0/go.mod h1:zeAhriXecNGP/s2SEG3+Y8X9ujcJOTqQ5RgdEJcawiA= go.opentelemetry.io/otel/trace v1.42.0/go.mod h1:f3K9S+IFqnumBkKhRJMeaZeNk9epyhnCmQh/EysQCdc= go.opentelemetry.io/otel/trace v1.43.0/go.mod h1:/QJhyVBUUswCphDVxq+8mld+AvhXZLhe+8WVFxiFff0= +go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= go.opentelemetry.io/proto/otlp v1.7.0/go.mod h1:fSKjH6YJ7HDlwzltzyMj036AJ3ejJLCgCSHGj4efDDo= go.opentelemetry.io/proto/otlp v1.7.1/go.mod h1:b2rVh6rfI/s2pHWNlB7ILJcRALpcNDzKhACevjI+ZnE= go.opentelemetry.io/proto/otlp v1.9.0/go.mod h1:xE+Cx5E/eEHw+ISFkwPLwCZefwVjY+pqKg1qcK03+/4= @@ -1696,6 +1708,8 @@ golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4 golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA= golang.org/x/crypto v0.51.0/go.mod h1:8AdwkbraGNABw2kOX6YFPs3WM22XqI4EXEd8g+x7Oc8= golang.org/x/crypto v0.52.0/go.mod h1:1QgfPxDqh0T2M/elOJtp9RvuR95kVjir0e6/BvEmGbc= +golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio= +golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= @@ -1777,6 +1791,7 @@ golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw= golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs= golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ= golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww= +golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -1803,6 +1818,7 @@ golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= +golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1852,6 +1868,7 @@ golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/sys v0.44.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/telemetry v0.0.0-20250807160809-1a19826ec488/go.mod h1:fGb/2+tgXXjhjHsTNdVEEMZNWA0quBnfrO+AfoDSAKw= golang.org/x/telemetry v0.0.0-20251008203120-078029d740a8 h1:LvzTn0GQhWuvKH/kVRS3R3bVAsdQWI7hvfLHGgh9+lU= golang.org/x/telemetry v0.0.0-20251008203120-078029d740a8/go.mod h1:Pi4ztBfryZoJEkyFTI5/Ocsu2jXyDr6iSdgJiYE/uwE= @@ -1895,6 +1912,8 @@ golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA= golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA= golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164= golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38= +golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4= +golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= @@ -2082,6 +2101,7 @@ google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9/go. google.golang.org/genproto/googleapis/api v0.0.0-20260414002931-afd174a4e478/go.mod h1:C6ADNqOxbgdUUeRTU+LCHDPB9ttAMCTff6auwCVa4uc= google.golang.org/genproto/googleapis/api v0.0.0-20260511170946-3700d4141b60/go.mod h1:7yoXV7RIh5gblj/xVYoogxAWvA9wUeVbpsK/M694l00= google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa/go.mod h1:q4lMZS6kskjT5HvCPrnnypcDPVJqT/f4nfxmkE7gryY= +google.golang.org/genproto/googleapis/api v0.0.0-20260630182238-925bb5da69e7/go.mod h1:KqHwBx2upmfa1XSi1WuRvC+2VGCLtooKkfmyvRbUmqA= google.golang.org/genproto/googleapis/bytestream v0.0.0-20250929231259-57b25ae835d4/go.mod h1:YUQUKndxDbAanQC0ln4pZ3Sis3N5sqgDte2XQqufkJc= google.golang.org/genproto/googleapis/bytestream v0.0.0-20251103181224-f26f9409b101 h1:yPJt1QyhbMgVYk1uHU1fzFDusVK69zmYfO7uupO0/QE= google.golang.org/genproto/googleapis/bytestream v0.0.0-20251103181224-f26f9409b101/go.mod h1:ejCb7yLmK6GCVHp5qpeKbm4KZew/ldg+9b8kq5MONgk= @@ -2156,6 +2176,7 @@ google.golang.org/genproto/googleapis/rpc v0.0.0-20260511170946-3700d4141b60/go. google.golang.org/genproto/googleapis/rpc v0.0.0-20260523011958-0a33c5d7ca68/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/genproto/googleapis/rpc v0.0.0-20260610212136-7ab31c22f7ad/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260630182238-925bb5da69e7/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/genproto/googleapis/rpc v0.0.0-20260720155508-bb71a54f79dc/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/genproto/googleapis/rpc v0.0.0-20260723164925-7274b71286bd/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= @@ -2188,6 +2209,7 @@ google.golang.org/grpc v1.79.2/go.mod h1:KmT0Kjez+0dde/v2j9vzwoAScgEPx/Bw1CYChhH google.golang.org/grpc v1.79.3/go.mod h1:KmT0Kjez+0dde/v2j9vzwoAScgEPx/Bw1CYChhHLrHQ= google.golang.org/grpc v1.80.0/go.mod h1:ho/dLnxwi3EDJA4Zghp7k2Ec1+c2jqup0bFkw07bwF4= google.golang.org/grpc v1.82.0/go.mod h1:yzTZ1TB1Z3SG+LIYaI+WiE8D5+PZ3ArnrSp8zF3+/ZA= +google.golang.org/grpc v1.82.1/go.mod h1:yzTZ1TB1Z3SG+LIYaI+WiE8D5+PZ3ArnrSp8zF3+/ZA= google.golang.org/grpc/examples v0.0.0-20230224211313-3775f633ce20 h1:MLBCGN1O7GzIx+cBiwfYPwtmZ41U3Mn/cotLJciaArI= google.golang.org/grpc/examples v0.0.0-20230224211313-3775f633ce20/go.mod h1:Nr5H8+MlGWr5+xX/STzdoEqJrO+YteqFbMyCsrb6mH0= google.golang.org/grpc/examples v0.0.0-20250407062114-b368379ef8f6 h1:ExN12ndbJ608cboPYflpTny6mXSzPrDLh0iTaVrRrds= diff --git a/pkg/gofr/datasource/arangodb/go.mod b/pkg/gofr/datasource/arangodb/go.mod index 519e5bbf18..8b75889cea 100644 --- a/pkg/gofr/datasource/arangodb/go.mod +++ b/pkg/gofr/datasource/arangodb/go.mod @@ -25,7 +25,7 @@ require ( go.opentelemetry.io/auto/sdk v1.2.1 // indirect go.opentelemetry.io/otel/metric v1.45.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/sys v0.47.0 // indirect golang.org/x/text v0.41.0 // indirect ) diff --git a/pkg/gofr/datasource/arangodb/go.sum b/pkg/gofr/datasource/arangodb/go.sum index 18513833df..22b28c7331 100644 --- a/pkg/gofr/datasource/arangodb/go.sum +++ b/pkg/gofr/datasource/arangodb/go.sum @@ -49,8 +49,8 @@ go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= diff --git a/pkg/gofr/datasource/cloudsql/go.mod b/pkg/gofr/datasource/cloudsql/go.mod index 77e6fa0caf..8b223e0a6a 100644 --- a/pkg/gofr/datasource/cloudsql/go.mod +++ b/pkg/gofr/datasource/cloudsql/go.mod @@ -36,7 +36,7 @@ require ( go.opentelemetry.io/otel/trace v1.45.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/crypto v0.55.0 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect golang.org/x/sync v0.22.0 // indirect golang.org/x/sys v0.47.0 // indirect @@ -46,6 +46,6 @@ require ( google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect - google.golang.org/grpc v1.83.1 // indirect + google.golang.org/grpc v1.83.2 // indirect google.golang.org/protobuf v1.36.12 // indirect ) diff --git a/pkg/gofr/datasource/cloudsql/go.sum b/pkg/gofr/datasource/cloudsql/go.sum index c3cbc2f5e0..990fbc6934 100644 --- a/pkg/gofr/datasource/cloudsql/go.sum +++ b/pkg/gofr/datasource/cloudsql/go.sum @@ -136,8 +136,8 @@ golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73r golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= @@ -184,8 +184,8 @@ google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyac google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= -google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= +google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= diff --git a/pkg/gofr/datasource/couchbase/go.mod b/pkg/gofr/datasource/couchbase/go.mod index 8fc30df8f4..ba486e63b7 100644 --- a/pkg/gofr/datasource/couchbase/go.mod +++ b/pkg/gofr/datasource/couchbase/go.mod @@ -29,10 +29,10 @@ require ( go.uber.org/multierr v1.11.0 // indirect go.uber.org/zap v1.28.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/sys v0.47.0 // indirect golang.org/x/text v0.41.0 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect - google.golang.org/grpc v1.83.1 // indirect + google.golang.org/grpc v1.83.2 // indirect google.golang.org/protobuf v1.36.12 // indirect ) diff --git a/pkg/gofr/datasource/couchbase/go.sum b/pkg/gofr/datasource/couchbase/go.sum index 9b0a84cf51..342a7b22a8 100644 --- a/pkg/gofr/datasource/couchbase/go.sum +++ b/pkg/gofr/datasource/couchbase/go.sum @@ -55,8 +55,8 @@ go.uber.org/zap v1.28.0 h1:IZzaP1Fv73/T/pBMLk4VutPl36uNC+OSUh3JLG3FIjo= go.uber.org/zap v1.28.0/go.mod h1:rDLpOi171uODNm/mxFcuYWxDsqWSAVkFdX4XojSKg/Q= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= @@ -65,7 +65,7 @@ gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws= google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= -google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= -google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= +google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= diff --git a/pkg/gofr/datasource/dbresolver/go.mod b/pkg/gofr/datasource/dbresolver/go.mod index bfbca2c37d..e658cccbc6 100644 --- a/pkg/gofr/datasource/dbresolver/go.mod +++ b/pkg/gofr/datasource/dbresolver/go.mod @@ -82,7 +82,7 @@ require ( go.uber.org/atomic v1.11.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/crypto v0.55.0 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect golang.org/x/sync v0.22.0 // indirect golang.org/x/sys v0.47.0 // indirect @@ -93,7 +93,7 @@ require ( google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect - google.golang.org/grpc v1.83.1 // indirect + google.golang.org/grpc v1.83.2 // indirect google.golang.org/protobuf v1.36.12 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect modernc.org/libc v1.74.4 // indirect diff --git a/pkg/gofr/datasource/dbresolver/go.sum b/pkg/gofr/datasource/dbresolver/go.sum index 0720af8b21..5ab0cad076 100644 --- a/pkg/gofr/datasource/dbresolver/go.sum +++ b/pkg/gofr/datasource/dbresolver/go.sum @@ -278,8 +278,8 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= @@ -348,8 +348,8 @@ google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyac google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= -google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= +google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= diff --git a/pkg/gofr/datasource/dgraph/go.mod b/pkg/gofr/datasource/dgraph/go.mod index f2902bed7b..a083388be3 100644 --- a/pkg/gofr/datasource/dgraph/go.mod +++ b/pkg/gofr/datasource/dgraph/go.mod @@ -9,7 +9,7 @@ require ( go.opentelemetry.io/otel v1.45.0 go.opentelemetry.io/otel/trace v1.45.0 go.uber.org/mock v0.6.0 - google.golang.org/grpc v1.83.1 + google.golang.org/grpc v1.83.2 ) require ( @@ -27,7 +27,7 @@ require ( go.opentelemetry.io/otel/metric v1.45.0 // indirect go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/sys v0.47.0 // indirect golang.org/x/text v0.41.0 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect diff --git a/pkg/gofr/datasource/dgraph/go.sum b/pkg/gofr/datasource/dgraph/go.sum index 8ef496b7d4..d698155294 100644 --- a/pkg/gofr/datasource/dgraph/go.sum +++ b/pkg/gofr/datasource/dgraph/go.sum @@ -64,8 +64,8 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -90,7 +90,7 @@ gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws= google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= -google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= -google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= +google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= diff --git a/pkg/gofr/datasource/file/azure/go.mod b/pkg/gofr/datasource/file/azure/go.mod index ec5f928c00..4dcef9f9c6 100644 --- a/pkg/gofr/datasource/file/azure/go.mod +++ b/pkg/gofr/datasource/file/azure/go.mod @@ -17,8 +17,7 @@ require ( github.com/pkg/errors v0.9.1 // indirect go.opentelemetry.io/otel/trace v1.45.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect - golang.org/x/crypto v0.55.0 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/text v0.41.0 // indirect google.golang.org/api v0.291.0 // indirect ) diff --git a/pkg/gofr/datasource/file/azure/go.sum b/pkg/gofr/datasource/file/azure/go.sum index bff5f124ee..c6339b5a87 100644 --- a/pkg/gofr/datasource/file/azure/go.sum +++ b/pkg/gofr/datasource/file/azure/go.sum @@ -38,8 +38,8 @@ gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= diff --git a/pkg/gofr/datasource/file/gcs/go.mod b/pkg/gofr/datasource/file/gcs/go.mod index dab6dd8738..572634c64a 100644 --- a/pkg/gofr/datasource/file/gcs/go.mod +++ b/pkg/gofr/datasource/file/gcs/go.mod @@ -49,7 +49,7 @@ require ( go.opentelemetry.io/otel/trace v1.45.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/crypto v0.55.0 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/sync v0.22.0 // indirect golang.org/x/sys v0.47.0 // indirect golang.org/x/text v0.41.0 // indirect @@ -57,6 +57,6 @@ require ( google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect - google.golang.org/grpc v1.83.1 // indirect + google.golang.org/grpc v1.83.2 // indirect google.golang.org/protobuf v1.36.12 // indirect ) diff --git a/pkg/gofr/datasource/file/gcs/go.sum b/pkg/gofr/datasource/file/gcs/go.sum index bc49bea4ef..b8fcbce290 100644 --- a/pkg/gofr/datasource/file/gcs/go.sum +++ b/pkg/gofr/datasource/file/gcs/go.sum @@ -103,8 +103,8 @@ gofr.dev v1.57.0 h1:4rsJ6VI3Yk7febCFtszhpKU46H8vJWTLmeICwGgZh64= gofr.dev v1.57.0/go.mod h1:bnPTbwKQbUZAMb4bZNWOjNE+LZJP1WdayrZuSakTUXk= golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek= @@ -127,7 +127,7 @@ google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1: google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws= google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= -google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= -google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= +google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= diff --git a/pkg/gofr/datasource/file/s3/go.mod b/pkg/gofr/datasource/file/s3/go.mod index 182d1fe8af..4bde046444 100644 --- a/pkg/gofr/datasource/file/s3/go.mod +++ b/pkg/gofr/datasource/file/s3/go.mod @@ -3,9 +3,9 @@ module gofr.dev/pkg/gofr/datasource/file/s3 go 1.26.0 require ( - github.com/aws/aws-sdk-go-v2 v1.43.6 - github.com/aws/aws-sdk-go-v2/config v1.32.37 - github.com/aws/aws-sdk-go-v2/credentials v1.19.36 + github.com/aws/aws-sdk-go-v2 v1.46.0 + github.com/aws/aws-sdk-go-v2/config v1.33.3 + github.com/aws/aws-sdk-go-v2/credentials v1.20.3 github.com/aws/aws-sdk-go-v2/service/s3 v1.107.2 github.com/stretchr/testify v1.12.1 go.uber.org/mock v0.6.0 @@ -14,19 +14,19 @@ require ( require ( github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.18 // indirect - github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.37 // indirect - github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.37 // indirect - github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37 // indirect - github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2 // indirect + github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 // indirect github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.30 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2 // indirect github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.38 // indirect - github.com/aws/aws-sdk-go-v2/service/signin v1.5.6 // indirect - github.com/aws/aws-sdk-go-v2/service/sso v1.33.6 // indirect - github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.6 // indirect - github.com/aws/aws-sdk-go-v2/service/sts v1.45.6 // indirect - github.com/aws/smithy-go v1.27.8 // indirect + github.com/aws/aws-sdk-go-v2/service/signin v1.9.0 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.37.0 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.42.0 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.49.0 // indirect + github.com/aws/smithy-go v1.28.1 // indirect github.com/joho/godotenv v1.5.1 // indirect github.com/pkg/errors v0.9.1 // indirect go.opentelemetry.io/otel/trace v1.45.0 // indirect diff --git a/pkg/gofr/datasource/file/s3/go.sum b/pkg/gofr/datasource/file/s3/go.sum index a0c9d78545..8d9bad34ad 100644 --- a/pkg/gofr/datasource/file/s3/go.sum +++ b/pkg/gofr/datasource/file/s3/go.sum @@ -1,39 +1,39 @@ -github.com/aws/aws-sdk-go-v2 v1.43.6 h1:RrmFcqCBxkJuf7g1axVo5krB4jM/AO8r5e5oujrgdoQ= -github.com/aws/aws-sdk-go-v2 v1.43.6/go.mod h1:tXpPM+v0D1lndmga+HqqLDIzUFJlEeR21aspVklHF00= +github.com/aws/aws-sdk-go-v2 v1.46.0 h1:1kt7m/EKcEHt5mlyyxx9cSlMddRPIKbjb6DIQsu4HPk= +github.com/aws/aws-sdk-go-v2 v1.46.0/go.mod h1:bttEH6JqnUL8LepvDVfdrds/fZ5bCIxzpe3abyUrhDU= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.18 h1:LAfOuhAH331fmOjTQpAaOlH+Ftn7RzSDJ2VFwjdMMy4= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.18/go.mod h1:4e5xhuXHx1e4U9EthvbPP1r/DIMp5c2823OL8karzcM= -github.com/aws/aws-sdk-go-v2/config v1.32.37 h1:Ljl7LOJB6ym0liuEl0+TZ3d7f5I8MEZN1Cj9PINlj/g= -github.com/aws/aws-sdk-go-v2/config v1.32.37/go.mod h1:WJ7pe7ZPpmG8Q5kKS53zeypIV4FBGACxmte8Uc6SgUc= -github.com/aws/aws-sdk-go-v2/credentials v1.19.36 h1:84s5xMme6ENYEdKG8rsbSFFg/8+lbHBeM9QYSO0gnDk= -github.com/aws/aws-sdk-go-v2/credentials v1.19.36/go.mod h1:c46BLdagDLIswjgt+GeQOslXgeS0E6wCacs5yZbxPGk= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.37 h1:b5tb+CZItBkydC7r3hTNdSO3pszG1R2EtnA+7TePQPk= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.37/go.mod h1:ZQ+6SU9X0oz6+7MUCSswv9Mjci4eaqZr21HI2RVy/yA= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.37 h1:lznzIOvvbqjfe8UAaciCRJgBgJsxuTROKlhZuXQWfv8= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.37/go.mod h1:otfkzyfQeMMLZAqX59GSXTL3o22BR/l6HFaRzzbWSqA= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37 h1:zCEORWo0eU0gDjG+IyApE/2B+ZGG1m+GU7B263XV8ds= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37/go.mod h1:i6c0PEl3TNOWxRbQ++KQcVenPWS/GoQeiklKhNuqzJ8= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38 h1:A3UAuCmx7LyUcrixBTzKJYYIUZ2yTvn6ZhT8PB+7APk= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38/go.mod h1:1PDUYG9Z+JrbbsobsAZHjWOm9QBT/djiK3QbykTL5Z4= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17 h1:OvYZOB3qA6zvfdRFiRFRzVSiElMYrz3GdntkXZxlp1o= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17/go.mod h1:JgR/2Ew50ACfIWau1oeMRX59tMtC0kM+PYQGEaT04cY= +github.com/aws/aws-sdk-go-v2/config v1.33.3 h1:h090b3O5S17bF87/0ysHZuIT/7DCb4EBRFQX2PMVPCw= +github.com/aws/aws-sdk-go-v2/config v1.33.3/go.mod h1:YYDB1kTejxbfAbEVUqgCtkVp26xvNCHev9cLKABMGAk= +github.com/aws/aws-sdk-go-v2/credentials v1.20.3 h1:tToOYM/LXev4NpfWlIYGDvBvjHmJ3HXpRU9ppl+pM6k= +github.com/aws/aws-sdk-go-v2/credentials v1.20.3/go.mod h1:wfGneWyncO7p67wqXV2IQhPk14JqIc25woKlaArT3WI= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2 h1:Ldv7RPHs7qwwTscRjAl3YBud32f3BvdAGRmSvAx5L38= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2/go.mod h1:XyK6UV8xbo66ysVqLd2783C09pBYHOm8aKTRV5DVJ30= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2 h1:q/PSLGuRWCChWg+dLnb9dWOnrCxJtnboXbBtFoqqRrI= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2/go.mod h1:TD1jvU2LvXkJexct5vBqcd8QlNXh5EmRUeL/Z32p0n4= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2 h1:6fl86IPqKEXoySqiOWdfgbEp9OVbn44zTfEICNEBDhY= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2/go.mod h1:63HDfhFkdzBpI8WGXTSKUHPKS6mqldj4u3LJW7RZtSU= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2 h1:XMgIRS+uW9F3yFKnXGRrI9pkHi99CXTmoz2kz2/TGBA= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2/go.mod h1:vorxDzK+n3jiv9a5ST/LG0Eu9cSv1CRdKTpG6pDMs+M= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 h1:bAdDl/HkGCcGPoe25ToSHEw23VIxt6CT5fLcg111BKg= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19/go.mod h1:KaUzbLxv4CeSxh6ZCl9B4m7CuFenS8kUEaDs+f/DQr4= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.30 h1:5437eMoOwqqQpZn2XJy74mlDCuPYL81texMT3mXqgtU= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.30/go.mod h1:xfu2m3dOpvW8lj98wQYa8V9ku/Rta59hsbireGzhh3A= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37 h1:a3D4AjrOrTrP8+d9ILBthqrElf0z1JNol09Xvnwcys8= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37/go.mod h1:ky0gTu+ukvUTuUKFIpp6Wid4oninrkCyvbFkVs0kpHM= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2 h1:ZtHYnumr6QyxhzEzNZwzQTFJEXOswrZqTTkRxthwvr4= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2/go.mod h1:a1NXrYpBd311gBzn1UI5UzJyyvXktM4xNh/ydPiPpqY= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.38 h1:gX8B8y3Ho30B1LPxefDKMi/HZqWEb47U9ogs3DtSG0M= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.38/go.mod h1:l5WblZlcmGPe4/O7JY2HO25Z+xqTBvyfTyFbRMf8gYw= github.com/aws/aws-sdk-go-v2/service/s3 v1.107.2 h1:GNU0/xtPEXMKilJZ/a8BedeuQnvu+Usi6qVm9EFfncc= github.com/aws/aws-sdk-go-v2/service/s3 v1.107.2/go.mod h1:4jYWUecEsQtE73jPl7p3jrbYXH5ffcR4gegyCygagfg= -github.com/aws/aws-sdk-go-v2/service/signin v1.5.6 h1:i68sFvXidKlkiSvI7d7Ilc1/UvW4CtBOaivH7jhG4fs= -github.com/aws/aws-sdk-go-v2/service/signin v1.5.6/go.mod h1:/h7Obr9WTtzbjTHGASRQwLN7Bupw+TC3x8x7fyx39hE= -github.com/aws/aws-sdk-go-v2/service/sso v1.33.6 h1:tpfGChmjUmv3W9WlRvy+stwKDTbFFdq8Zk9DbFPrfMU= -github.com/aws/aws-sdk-go-v2/service/sso v1.33.6/go.mod h1:CSjiDzmG/lsKkTOYjbkM+duLmRlW+LOxD64Na44ijnI= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.6 h1:49BBtY68A+KJCQ3a2F3eUe6ROsKucxUdfHKoqorc0wI= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.6/go.mod h1:ptG2hbs7QltE1GcQY0MpS4bfrc51KCnBXUr7OT1EEfE= -github.com/aws/aws-sdk-go-v2/service/sts v1.45.6 h1:JvExZWabChDM0qJAirQYGfOYo0ndT3edXj+fqSPNjkE= -github.com/aws/aws-sdk-go-v2/service/sts v1.45.6/go.mod h1:XZcaQkV2cItp6yEkrwljyaPOf22RuX7T43jxap/FOmM= -github.com/aws/smithy-go v1.27.8 h1:FR0dxZfIlV7Z8eh2iHfIofdunw382XsDV3Mxt9nUvRY= -github.com/aws/smithy-go v1.27.8/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= +github.com/aws/aws-sdk-go-v2/service/signin v1.9.0 h1:c3k+k/CS4L+sAIH6fxikL+g5g2LpeNczaoyjjw1iMKI= +github.com/aws/aws-sdk-go-v2/service/signin v1.9.0/go.mod h1:AGIoQg99fBrOIQnF78TLx4lj18mc4gZ0hJx1UaLIFM4= +github.com/aws/aws-sdk-go-v2/service/sso v1.37.0 h1:+rqBaOq7jzInjY8M12hr+zEe85JpRll9BjMx38r33Ok= +github.com/aws/aws-sdk-go-v2/service/sso v1.37.0/go.mod h1:XFlVwUsw3sYh8Hw37umYVJnrcWrwXWRxbNw/JY0bblw= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.42.0 h1:hzM3GslEAOBcLn3DHH6ENToFi+vXP+n02W+x6zejAIM= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.42.0/go.mod h1:588e7skMkYIYkSUseT8E3WKFfbAfrA1bj3Zf+qxJtJY= +github.com/aws/aws-sdk-go-v2/service/sts v1.49.0 h1:N7Ey8obY3uSui+cxl0OUzFlFmkxSucoJnrniFhw+cLc= +github.com/aws/aws-sdk-go-v2/service/sts v1.49.0/go.mod h1:zMBwjSf4Pt8a1OHYiZ5rPD0PJRK1kQrUaxhS/Dbld8E= +github.com/aws/smithy-go v1.28.1 h1:R/nXH00c8qcfCzQVELtRw+eLQWtzv+VAIEFJ1/xxXlQ= +github.com/aws/smithy-go v1.28.1/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= diff --git a/pkg/gofr/datasource/influxdb/go.mod b/pkg/gofr/datasource/influxdb/go.mod index b3aed6875d..d6683f9a1a 100644 --- a/pkg/gofr/datasource/influxdb/go.mod +++ b/pkg/gofr/datasource/influxdb/go.mod @@ -23,5 +23,5 @@ require ( go.opentelemetry.io/otel/metric v1.45.0 // indirect go.opentelemetry.io/otel/trace v1.45.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect ) diff --git a/pkg/gofr/datasource/influxdb/go.sum b/pkg/gofr/datasource/influxdb/go.sum index c444013c55..6bef2a719b 100644 --- a/pkg/gofr/datasource/influxdb/go.sum +++ b/pkg/gofr/datasource/influxdb/go.sum @@ -95,8 +95,8 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= diff --git a/pkg/gofr/datasource/kv-store/dynamodb/go.mod b/pkg/gofr/datasource/kv-store/dynamodb/go.mod index 1937f12d6c..4ffb32a859 100644 --- a/pkg/gofr/datasource/kv-store/dynamodb/go.mod +++ b/pkg/gofr/datasource/kv-store/dynamodb/go.mod @@ -3,9 +3,9 @@ module gofr.dev/pkg/gofr/datasource/kv-store/dynamodb go 1.26.0 require ( - github.com/aws/aws-sdk-go-v2 v1.43.6 - github.com/aws/aws-sdk-go-v2/config v1.32.37 - github.com/aws/aws-sdk-go-v2/service/dynamodb v1.63.3 + github.com/aws/aws-sdk-go-v2 v1.46.0 + github.com/aws/aws-sdk-go-v2/config v1.33.3 + github.com/aws/aws-sdk-go-v2/service/dynamodb v1.67.0 github.com/stretchr/testify v1.12.1 go.opentelemetry.io/otel v1.45.0 go.opentelemetry.io/otel/trace v1.45.0 @@ -13,19 +13,19 @@ require ( ) require ( - github.com/aws/aws-sdk-go-v2/credentials v1.19.36 // indirect - github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.37 // indirect - github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.37 // indirect - github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37 // indirect - github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.12.14 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37 // indirect - github.com/aws/aws-sdk-go-v2/service/signin v1.5.6 // indirect - github.com/aws/aws-sdk-go-v2/service/sso v1.33.6 // indirect - github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.6 // indirect - github.com/aws/aws-sdk-go-v2/service/sts v1.45.6 // indirect - github.com/aws/smithy-go v1.27.8 // indirect + github.com/aws/aws-sdk-go-v2/credentials v1.20.3 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2 // indirect + github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.13.2 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2 // indirect + github.com/aws/aws-sdk-go-v2/service/signin v1.9.0 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.37.0 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.42.0 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.49.0 // indirect + github.com/aws/smithy-go v1.28.1 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect ) diff --git a/pkg/gofr/datasource/kv-store/dynamodb/go.sum b/pkg/gofr/datasource/kv-store/dynamodb/go.sum index 778c5de6f1..8cd0eda93d 100644 --- a/pkg/gofr/datasource/kv-store/dynamodb/go.sum +++ b/pkg/gofr/datasource/kv-store/dynamodb/go.sum @@ -1,35 +1,35 @@ -github.com/aws/aws-sdk-go-v2 v1.43.6 h1:RrmFcqCBxkJuf7g1axVo5krB4jM/AO8r5e5oujrgdoQ= -github.com/aws/aws-sdk-go-v2 v1.43.6/go.mod h1:tXpPM+v0D1lndmga+HqqLDIzUFJlEeR21aspVklHF00= -github.com/aws/aws-sdk-go-v2/config v1.32.37 h1:Ljl7LOJB6ym0liuEl0+TZ3d7f5I8MEZN1Cj9PINlj/g= -github.com/aws/aws-sdk-go-v2/config v1.32.37/go.mod h1:WJ7pe7ZPpmG8Q5kKS53zeypIV4FBGACxmte8Uc6SgUc= -github.com/aws/aws-sdk-go-v2/credentials v1.19.36 h1:84s5xMme6ENYEdKG8rsbSFFg/8+lbHBeM9QYSO0gnDk= -github.com/aws/aws-sdk-go-v2/credentials v1.19.36/go.mod h1:c46BLdagDLIswjgt+GeQOslXgeS0E6wCacs5yZbxPGk= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.37 h1:b5tb+CZItBkydC7r3hTNdSO3pszG1R2EtnA+7TePQPk= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.37/go.mod h1:ZQ+6SU9X0oz6+7MUCSswv9Mjci4eaqZr21HI2RVy/yA= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.37 h1:lznzIOvvbqjfe8UAaciCRJgBgJsxuTROKlhZuXQWfv8= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.37/go.mod h1:otfkzyfQeMMLZAqX59GSXTL3o22BR/l6HFaRzzbWSqA= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37 h1:zCEORWo0eU0gDjG+IyApE/2B+ZGG1m+GU7B263XV8ds= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37/go.mod h1:i6c0PEl3TNOWxRbQ++KQcVenPWS/GoQeiklKhNuqzJ8= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38 h1:A3UAuCmx7LyUcrixBTzKJYYIUZ2yTvn6ZhT8PB+7APk= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38/go.mod h1:1PDUYG9Z+JrbbsobsAZHjWOm9QBT/djiK3QbykTL5Z4= -github.com/aws/aws-sdk-go-v2/service/dynamodb v1.63.3 h1:cVfESNZmZ8L9TkOeNo6u/eNR0ZphBuS1J2GjLBLmEdA= -github.com/aws/aws-sdk-go-v2/service/dynamodb v1.63.3/go.mod h1:n9exrC9k5S+0t6X6LQKHcv7ap1jAEAHY2Sbqhu9mS34= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17 h1:OvYZOB3qA6zvfdRFiRFRzVSiElMYrz3GdntkXZxlp1o= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17/go.mod h1:JgR/2Ew50ACfIWau1oeMRX59tMtC0kM+PYQGEaT04cY= -github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.12.14 h1:fiayMFWJ04EbPboTzc97F4ii4o6bAi0b6Sk8oXUHRUQ= -github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.12.14/go.mod h1:Ki93kowJvAQpSDjMR+QfntVks2FIj2TWdV3jGIWWm10= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37 h1:a3D4AjrOrTrP8+d9ILBthqrElf0z1JNol09Xvnwcys8= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37/go.mod h1:ky0gTu+ukvUTuUKFIpp6Wid4oninrkCyvbFkVs0kpHM= -github.com/aws/aws-sdk-go-v2/service/signin v1.5.6 h1:i68sFvXidKlkiSvI7d7Ilc1/UvW4CtBOaivH7jhG4fs= -github.com/aws/aws-sdk-go-v2/service/signin v1.5.6/go.mod h1:/h7Obr9WTtzbjTHGASRQwLN7Bupw+TC3x8x7fyx39hE= -github.com/aws/aws-sdk-go-v2/service/sso v1.33.6 h1:tpfGChmjUmv3W9WlRvy+stwKDTbFFdq8Zk9DbFPrfMU= -github.com/aws/aws-sdk-go-v2/service/sso v1.33.6/go.mod h1:CSjiDzmG/lsKkTOYjbkM+duLmRlW+LOxD64Na44ijnI= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.6 h1:49BBtY68A+KJCQ3a2F3eUe6ROsKucxUdfHKoqorc0wI= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.6/go.mod h1:ptG2hbs7QltE1GcQY0MpS4bfrc51KCnBXUr7OT1EEfE= -github.com/aws/aws-sdk-go-v2/service/sts v1.45.6 h1:JvExZWabChDM0qJAirQYGfOYo0ndT3edXj+fqSPNjkE= -github.com/aws/aws-sdk-go-v2/service/sts v1.45.6/go.mod h1:XZcaQkV2cItp6yEkrwljyaPOf22RuX7T43jxap/FOmM= -github.com/aws/smithy-go v1.27.8 h1:FR0dxZfIlV7Z8eh2iHfIofdunw382XsDV3Mxt9nUvRY= -github.com/aws/smithy-go v1.27.8/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= +github.com/aws/aws-sdk-go-v2 v1.46.0 h1:1kt7m/EKcEHt5mlyyxx9cSlMddRPIKbjb6DIQsu4HPk= +github.com/aws/aws-sdk-go-v2 v1.46.0/go.mod h1:bttEH6JqnUL8LepvDVfdrds/fZ5bCIxzpe3abyUrhDU= +github.com/aws/aws-sdk-go-v2/config v1.33.3 h1:h090b3O5S17bF87/0ysHZuIT/7DCb4EBRFQX2PMVPCw= +github.com/aws/aws-sdk-go-v2/config v1.33.3/go.mod h1:YYDB1kTejxbfAbEVUqgCtkVp26xvNCHev9cLKABMGAk= +github.com/aws/aws-sdk-go-v2/credentials v1.20.3 h1:tToOYM/LXev4NpfWlIYGDvBvjHmJ3HXpRU9ppl+pM6k= +github.com/aws/aws-sdk-go-v2/credentials v1.20.3/go.mod h1:wfGneWyncO7p67wqXV2IQhPk14JqIc25woKlaArT3WI= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2 h1:Ldv7RPHs7qwwTscRjAl3YBud32f3BvdAGRmSvAx5L38= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2/go.mod h1:XyK6UV8xbo66ysVqLd2783C09pBYHOm8aKTRV5DVJ30= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2 h1:q/PSLGuRWCChWg+dLnb9dWOnrCxJtnboXbBtFoqqRrI= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2/go.mod h1:TD1jvU2LvXkJexct5vBqcd8QlNXh5EmRUeL/Z32p0n4= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2 h1:6fl86IPqKEXoySqiOWdfgbEp9OVbn44zTfEICNEBDhY= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2/go.mod h1:63HDfhFkdzBpI8WGXTSKUHPKS6mqldj4u3LJW7RZtSU= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2 h1:XMgIRS+uW9F3yFKnXGRrI9pkHi99CXTmoz2kz2/TGBA= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2/go.mod h1:vorxDzK+n3jiv9a5ST/LG0Eu9cSv1CRdKTpG6pDMs+M= +github.com/aws/aws-sdk-go-v2/service/dynamodb v1.67.0 h1:Qs5KY7LC+/lMasuJOujgDtl3In6MHxnceULr2+V/Ldc= +github.com/aws/aws-sdk-go-v2/service/dynamodb v1.67.0/go.mod h1:xZ68tXuET4F9jrz4kQCXN6JIex933g0Izh6FM+YtFsg= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 h1:bAdDl/HkGCcGPoe25ToSHEw23VIxt6CT5fLcg111BKg= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19/go.mod h1:KaUzbLxv4CeSxh6ZCl9B4m7CuFenS8kUEaDs+f/DQr4= +github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.13.2 h1:Ulv5rW95wuDrA/ToJ/KidTwvlJU/w4M6BD0AU+gIm7s= +github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.13.2/go.mod h1:8cB2IyKwy9nkqDonPGTRlTCQdZgxVwqjvjsn3t5xCQg= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2 h1:ZtHYnumr6QyxhzEzNZwzQTFJEXOswrZqTTkRxthwvr4= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2/go.mod h1:a1NXrYpBd311gBzn1UI5UzJyyvXktM4xNh/ydPiPpqY= +github.com/aws/aws-sdk-go-v2/service/signin v1.9.0 h1:c3k+k/CS4L+sAIH6fxikL+g5g2LpeNczaoyjjw1iMKI= +github.com/aws/aws-sdk-go-v2/service/signin v1.9.0/go.mod h1:AGIoQg99fBrOIQnF78TLx4lj18mc4gZ0hJx1UaLIFM4= +github.com/aws/aws-sdk-go-v2/service/sso v1.37.0 h1:+rqBaOq7jzInjY8M12hr+zEe85JpRll9BjMx38r33Ok= +github.com/aws/aws-sdk-go-v2/service/sso v1.37.0/go.mod h1:XFlVwUsw3sYh8Hw37umYVJnrcWrwXWRxbNw/JY0bblw= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.42.0 h1:hzM3GslEAOBcLn3DHH6ENToFi+vXP+n02W+x6zejAIM= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.42.0/go.mod h1:588e7skMkYIYkSUseT8E3WKFfbAfrA1bj3Zf+qxJtJY= +github.com/aws/aws-sdk-go-v2/service/sts v1.49.0 h1:N7Ey8obY3uSui+cxl0OUzFlFmkxSucoJnrniFhw+cLc= +github.com/aws/aws-sdk-go-v2/service/sts v1.49.0/go.mod h1:zMBwjSf4Pt8a1OHYiZ5rPD0PJRK1kQrUaxhS/Dbld8E= +github.com/aws/smithy-go v1.28.1 h1:R/nXH00c8qcfCzQVELtRw+eLQWtzv+VAIEFJ1/xxXlQ= +github.com/aws/smithy-go v1.28.1/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= diff --git a/pkg/gofr/datasource/oracle/go.mod b/pkg/gofr/datasource/oracle/go.mod index 0e9a5870f3..f8317a9bdd 100644 --- a/pkg/gofr/datasource/oracle/go.mod +++ b/pkg/gofr/datasource/oracle/go.mod @@ -74,7 +74,7 @@ require ( go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/crypto v0.55.0 // indirect golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect golang.org/x/sync v0.22.0 // indirect golang.org/x/sys v0.47.0 // indirect @@ -85,7 +85,7 @@ require ( google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect - google.golang.org/grpc v1.83.1 // indirect + google.golang.org/grpc v1.83.2 // indirect google.golang.org/protobuf v1.36.12 // indirect modernc.org/libc v1.74.4 // indirect modernc.org/mathutil v1.7.1 // indirect diff --git a/pkg/gofr/datasource/oracle/go.sum b/pkg/gofr/datasource/oracle/go.sum index 3211972588..6cd0401e89 100644 --- a/pkg/gofr/datasource/oracle/go.sum +++ b/pkg/gofr/datasource/oracle/go.sum @@ -247,8 +247,8 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= @@ -311,8 +311,8 @@ google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyac google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= -google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= +google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= diff --git a/pkg/gofr/datasource/pubsub/eventhub/go.mod b/pkg/gofr/datasource/pubsub/eventhub/go.mod index 5baf7e6786..06777e9fd2 100644 --- a/pkg/gofr/datasource/pubsub/eventhub/go.mod +++ b/pkg/gofr/datasource/pubsub/eventhub/go.mod @@ -26,7 +26,6 @@ require ( go.opentelemetry.io/auto/sdk v1.2.1 // indirect go.opentelemetry.io/otel/metric v1.45.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect - golang.org/x/crypto v0.55.0 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/text v0.41.0 // indirect ) diff --git a/pkg/gofr/datasource/pubsub/eventhub/go.sum b/pkg/gofr/datasource/pubsub/eventhub/go.sum index 4ac1e362e5..bb43dd52d6 100644 --- a/pkg/gofr/datasource/pubsub/eventhub/go.sum +++ b/pkg/gofr/datasource/pubsub/eventhub/go.sum @@ -68,8 +68,8 @@ golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= diff --git a/pkg/gofr/datasource/pubsub/nats/go.mod b/pkg/gofr/datasource/pubsub/nats/go.mod index 0d75484b3f..0288ee95d9 100644 --- a/pkg/gofr/datasource/pubsub/nats/go.mod +++ b/pkg/gofr/datasource/pubsub/nats/go.mod @@ -3,12 +3,12 @@ module gofr.dev/pkg/gofr/datasource/pubsub/nats go 1.26.0 require ( - github.com/nats-io/nats-server/v2 v2.14.5 + github.com/nats-io/nats-server/v2 v2.14.6 github.com/nats-io/nats.go v1.53.1 github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/sdk v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/sdk v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 ) @@ -28,7 +28,7 @@ require ( github.com/nats-io/nuid v1.0.1 // indirect github.com/pkg/errors v0.9.1 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/crypto v0.55.0 // indirect golang.org/x/sys v0.47.0 // indirect diff --git a/pkg/gofr/datasource/pubsub/nats/go.sum b/pkg/gofr/datasource/pubsub/nats/go.sum index c67c58fee8..9486c47ed6 100644 --- a/pkg/gofr/datasource/pubsub/nats/go.sum +++ b/pkg/gofr/datasource/pubsub/nats/go.sum @@ -21,8 +21,8 @@ github.com/minio/highwayhash v1.0.4 h1:asJizugGgchQod2ja9NJlGOWq4s7KsAWr5XUc9Clg github.com/minio/highwayhash v1.0.4/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ= github.com/nats-io/jwt/v2 v2.8.2 h1:XXRgB60MSTnqsRwejQurVDs/hcv2dkt+86GjI+I/bMc= github.com/nats-io/jwt/v2 v2.8.2/go.mod h1:Ag/56sq9OblL4JgdYufDd16Egb17Kr/8WwwuO/forVc= -github.com/nats-io/nats-server/v2 v2.14.5 h1:M6yeo/Xb7khi97RSEVELof3DForDqmYza3P4tHCPFWw= -github.com/nats-io/nats-server/v2 v2.14.5/go.mod h1:1D3iocrisKvWaD1B/imqarTqmaGrWMqALMLbEDo3v7Q= +github.com/nats-io/nats-server/v2 v2.14.6 h1:dHjEHa49lUTxIb5jrsk5kz/AmOyOQ4T9ti8djcBumDQ= +github.com/nats-io/nats-server/v2 v2.14.6/go.mod h1:u/0bNBzN/m5orQGz7q2NNzxCQ6PWdwaOSwPNDADZn/A= github.com/nats-io/nats.go v1.53.1 h1:Otsq3uLc/kLdjmkNHkXH0jBqwUquwdKFoe3fq6/3/Xo= github.com/nats-io/nats.go v1.53.1/go.mod h1:26HypzazeOkyO3/mqd1zZd53STJN0EjCYF9Uy2ZOBno= github.com/nats-io/nkeys v0.4.16 h1:rd5oAuLOb8mnAycB0xleuEBNS1pVVnN0fv/FF34Eypg= @@ -35,16 +35,16 @@ github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWD github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= -go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= -go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= -go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= -go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/sdk v1.46.0 h1:h5CNQQjEbuQXY/JfZtgt3i7HVFV3aHPO2OAwO2eTYPI= +go.opentelemetry.io/otel/sdk v1.46.0/go.mod h1:GAERFXFt5SYCEB+YiKUbMBeza6UaDH7GmGOZEfh2gSM= +go.opentelemetry.io/otel/sdk/metric v1.46.0 h1:0piZ26EG4RBfebb2jhDH6ERCYHoVWduc3kLgPCwSnSE= +go.opentelemetry.io/otel/sdk/metric v1.46.0/go.mod h1:I1PbKrdVc8Qu8HYVDNtqVIwLwjNrhsV/uFuxfwg8mO4= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= diff --git a/pkg/gofr/datasource/pubsub/sqs/go.mod b/pkg/gofr/datasource/pubsub/sqs/go.mod index 2e9562b5fa..8e2e71b070 100644 --- a/pkg/gofr/datasource/pubsub/sqs/go.mod +++ b/pkg/gofr/datasource/pubsub/sqs/go.mod @@ -3,29 +3,29 @@ module gofr.dev/pkg/gofr/datasource/pubsub/sqs go 1.26.0 require ( - github.com/aws/aws-sdk-go-v2 v1.43.6 - github.com/aws/aws-sdk-go-v2/config v1.32.37 - github.com/aws/aws-sdk-go-v2/credentials v1.19.36 - github.com/aws/aws-sdk-go-v2/service/sqs v1.46.6 + github.com/aws/aws-sdk-go-v2 v1.46.0 + github.com/aws/aws-sdk-go-v2/config v1.33.3 + github.com/aws/aws-sdk-go-v2/credentials v1.20.3 + github.com/aws/aws-sdk-go-v2/service/sqs v1.51.0 github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/sdk v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/sdk v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 gofr.dev v1.57.0 ) require ( - github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.37 // indirect - github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.37 // indirect - github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37 // indirect - github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37 // indirect - github.com/aws/aws-sdk-go-v2/service/signin v1.5.6 // indirect - github.com/aws/aws-sdk-go-v2/service/sso v1.33.6 // indirect - github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.6 // indirect - github.com/aws/aws-sdk-go-v2/service/sts v1.45.6 // indirect - github.com/aws/smithy-go v1.27.8 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2 // indirect + github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2 // indirect + github.com/aws/aws-sdk-go-v2/service/signin v1.9.0 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.37.0 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.42.0 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.49.0 // indirect + github.com/aws/smithy-go v1.28.1 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect @@ -33,7 +33,7 @@ require ( github.com/joho/godotenv v1.5.1 // indirect github.com/pkg/errors v0.9.1 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/sys v0.47.0 // indirect golang.org/x/term v0.45.0 // indirect diff --git a/pkg/gofr/datasource/pubsub/sqs/go.sum b/pkg/gofr/datasource/pubsub/sqs/go.sum index 28a1ad4df2..8ab0bea686 100644 --- a/pkg/gofr/datasource/pubsub/sqs/go.sum +++ b/pkg/gofr/datasource/pubsub/sqs/go.sum @@ -1,33 +1,33 @@ -github.com/aws/aws-sdk-go-v2 v1.43.6 h1:RrmFcqCBxkJuf7g1axVo5krB4jM/AO8r5e5oujrgdoQ= -github.com/aws/aws-sdk-go-v2 v1.43.6/go.mod h1:tXpPM+v0D1lndmga+HqqLDIzUFJlEeR21aspVklHF00= -github.com/aws/aws-sdk-go-v2/config v1.32.37 h1:Ljl7LOJB6ym0liuEl0+TZ3d7f5I8MEZN1Cj9PINlj/g= -github.com/aws/aws-sdk-go-v2/config v1.32.37/go.mod h1:WJ7pe7ZPpmG8Q5kKS53zeypIV4FBGACxmte8Uc6SgUc= -github.com/aws/aws-sdk-go-v2/credentials v1.19.36 h1:84s5xMme6ENYEdKG8rsbSFFg/8+lbHBeM9QYSO0gnDk= -github.com/aws/aws-sdk-go-v2/credentials v1.19.36/go.mod h1:c46BLdagDLIswjgt+GeQOslXgeS0E6wCacs5yZbxPGk= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.37 h1:b5tb+CZItBkydC7r3hTNdSO3pszG1R2EtnA+7TePQPk= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.37/go.mod h1:ZQ+6SU9X0oz6+7MUCSswv9Mjci4eaqZr21HI2RVy/yA= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.37 h1:lznzIOvvbqjfe8UAaciCRJgBgJsxuTROKlhZuXQWfv8= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.37/go.mod h1:otfkzyfQeMMLZAqX59GSXTL3o22BR/l6HFaRzzbWSqA= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37 h1:zCEORWo0eU0gDjG+IyApE/2B+ZGG1m+GU7B263XV8ds= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.37/go.mod h1:i6c0PEl3TNOWxRbQ++KQcVenPWS/GoQeiklKhNuqzJ8= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38 h1:A3UAuCmx7LyUcrixBTzKJYYIUZ2yTvn6ZhT8PB+7APk= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.38/go.mod h1:1PDUYG9Z+JrbbsobsAZHjWOm9QBT/djiK3QbykTL5Z4= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17 h1:OvYZOB3qA6zvfdRFiRFRzVSiElMYrz3GdntkXZxlp1o= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.17/go.mod h1:JgR/2Ew50ACfIWau1oeMRX59tMtC0kM+PYQGEaT04cY= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37 h1:a3D4AjrOrTrP8+d9ILBthqrElf0z1JNol09Xvnwcys8= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.37/go.mod h1:ky0gTu+ukvUTuUKFIpp6Wid4oninrkCyvbFkVs0kpHM= -github.com/aws/aws-sdk-go-v2/service/signin v1.5.6 h1:i68sFvXidKlkiSvI7d7Ilc1/UvW4CtBOaivH7jhG4fs= -github.com/aws/aws-sdk-go-v2/service/signin v1.5.6/go.mod h1:/h7Obr9WTtzbjTHGASRQwLN7Bupw+TC3x8x7fyx39hE= -github.com/aws/aws-sdk-go-v2/service/sqs v1.46.6 h1:OQf7U6UgDnByANgeCIJjnC71LRrpuKt2gNa3Pth996s= -github.com/aws/aws-sdk-go-v2/service/sqs v1.46.6/go.mod h1:cPDi+P56aAfYJVwVocZmiiVf8dJR1hSzPz/nqsV/b00= -github.com/aws/aws-sdk-go-v2/service/sso v1.33.6 h1:tpfGChmjUmv3W9WlRvy+stwKDTbFFdq8Zk9DbFPrfMU= -github.com/aws/aws-sdk-go-v2/service/sso v1.33.6/go.mod h1:CSjiDzmG/lsKkTOYjbkM+duLmRlW+LOxD64Na44ijnI= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.6 h1:49BBtY68A+KJCQ3a2F3eUe6ROsKucxUdfHKoqorc0wI= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.6/go.mod h1:ptG2hbs7QltE1GcQY0MpS4bfrc51KCnBXUr7OT1EEfE= -github.com/aws/aws-sdk-go-v2/service/sts v1.45.6 h1:JvExZWabChDM0qJAirQYGfOYo0ndT3edXj+fqSPNjkE= -github.com/aws/aws-sdk-go-v2/service/sts v1.45.6/go.mod h1:XZcaQkV2cItp6yEkrwljyaPOf22RuX7T43jxap/FOmM= -github.com/aws/smithy-go v1.27.8 h1:FR0dxZfIlV7Z8eh2iHfIofdunw382XsDV3Mxt9nUvRY= -github.com/aws/smithy-go v1.27.8/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= +github.com/aws/aws-sdk-go-v2 v1.46.0 h1:1kt7m/EKcEHt5mlyyxx9cSlMddRPIKbjb6DIQsu4HPk= +github.com/aws/aws-sdk-go-v2 v1.46.0/go.mod h1:bttEH6JqnUL8LepvDVfdrds/fZ5bCIxzpe3abyUrhDU= +github.com/aws/aws-sdk-go-v2/config v1.33.3 h1:h090b3O5S17bF87/0ysHZuIT/7DCb4EBRFQX2PMVPCw= +github.com/aws/aws-sdk-go-v2/config v1.33.3/go.mod h1:YYDB1kTejxbfAbEVUqgCtkVp26xvNCHev9cLKABMGAk= +github.com/aws/aws-sdk-go-v2/credentials v1.20.3 h1:tToOYM/LXev4NpfWlIYGDvBvjHmJ3HXpRU9ppl+pM6k= +github.com/aws/aws-sdk-go-v2/credentials v1.20.3/go.mod h1:wfGneWyncO7p67wqXV2IQhPk14JqIc25woKlaArT3WI= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2 h1:Ldv7RPHs7qwwTscRjAl3YBud32f3BvdAGRmSvAx5L38= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2/go.mod h1:XyK6UV8xbo66ysVqLd2783C09pBYHOm8aKTRV5DVJ30= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2 h1:q/PSLGuRWCChWg+dLnb9dWOnrCxJtnboXbBtFoqqRrI= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2/go.mod h1:TD1jvU2LvXkJexct5vBqcd8QlNXh5EmRUeL/Z32p0n4= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2 h1:6fl86IPqKEXoySqiOWdfgbEp9OVbn44zTfEICNEBDhY= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2/go.mod h1:63HDfhFkdzBpI8WGXTSKUHPKS6mqldj4u3LJW7RZtSU= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2 h1:XMgIRS+uW9F3yFKnXGRrI9pkHi99CXTmoz2kz2/TGBA= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2/go.mod h1:vorxDzK+n3jiv9a5ST/LG0Eu9cSv1CRdKTpG6pDMs+M= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 h1:bAdDl/HkGCcGPoe25ToSHEw23VIxt6CT5fLcg111BKg= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19/go.mod h1:KaUzbLxv4CeSxh6ZCl9B4m7CuFenS8kUEaDs+f/DQr4= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2 h1:ZtHYnumr6QyxhzEzNZwzQTFJEXOswrZqTTkRxthwvr4= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2/go.mod h1:a1NXrYpBd311gBzn1UI5UzJyyvXktM4xNh/ydPiPpqY= +github.com/aws/aws-sdk-go-v2/service/signin v1.9.0 h1:c3k+k/CS4L+sAIH6fxikL+g5g2LpeNczaoyjjw1iMKI= +github.com/aws/aws-sdk-go-v2/service/signin v1.9.0/go.mod h1:AGIoQg99fBrOIQnF78TLx4lj18mc4gZ0hJx1UaLIFM4= +github.com/aws/aws-sdk-go-v2/service/sqs v1.51.0 h1:FghdY9ebeZf9iIan9J0xfBEID8arYibNBeZ1XHvs4oA= +github.com/aws/aws-sdk-go-v2/service/sqs v1.51.0/go.mod h1:wu7uOJ/2nAdenjvhHikeF6j0al99kfPVG6ZDU4e76OY= +github.com/aws/aws-sdk-go-v2/service/sso v1.37.0 h1:+rqBaOq7jzInjY8M12hr+zEe85JpRll9BjMx38r33Ok= +github.com/aws/aws-sdk-go-v2/service/sso v1.37.0/go.mod h1:XFlVwUsw3sYh8Hw37umYVJnrcWrwXWRxbNw/JY0bblw= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.42.0 h1:hzM3GslEAOBcLn3DHH6ENToFi+vXP+n02W+x6zejAIM= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.42.0/go.mod h1:588e7skMkYIYkSUseT8E3WKFfbAfrA1bj3Zf+qxJtJY= +github.com/aws/aws-sdk-go-v2/service/sts v1.49.0 h1:N7Ey8obY3uSui+cxl0OUzFlFmkxSucoJnrniFhw+cLc= +github.com/aws/aws-sdk-go-v2/service/sts v1.49.0/go.mod h1:zMBwjSf4Pt8a1OHYiZ5rPD0PJRK1kQrUaxhS/Dbld8E= +github.com/aws/smithy-go v1.28.1 h1:R/nXH00c8qcfCzQVELtRw+eLQWtzv+VAIEFJ1/xxXlQ= +github.com/aws/smithy-go v1.28.1/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= @@ -47,16 +47,16 @@ github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWD github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= -go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= -go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= -go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= -go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/sdk v1.46.0 h1:h5CNQQjEbuQXY/JfZtgt3i7HVFV3aHPO2OAwO2eTYPI= +go.opentelemetry.io/otel/sdk v1.46.0/go.mod h1:GAERFXFt5SYCEB+YiKUbMBeza6UaDH7GmGOZEfh2gSM= +go.opentelemetry.io/otel/sdk/metric v1.46.0 h1:0piZ26EG4RBfebb2jhDH6ERCYHoVWduc3kLgPCwSnSE= +go.opentelemetry.io/otel/sdk/metric v1.46.0/go.mod h1:I1PbKrdVc8Qu8HYVDNtqVIwLwjNrhsV/uFuxfwg8mO4= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= diff --git a/pkg/gofr/metrics/exporters/gcp/go.mod b/pkg/gofr/metrics/exporters/gcp/go.mod index 9ed6e9c885..3c3a8c0e74 100644 --- a/pkg/gofr/metrics/exporters/gcp/go.mod +++ b/pkg/gofr/metrics/exporters/gcp/go.mod @@ -3,19 +3,19 @@ module gofr.dev/pkg/gofr/metrics/exporters/gcp go 1.26.0 require ( - go.opentelemetry.io/contrib/detectors/gcp v1.44.0 - go.opentelemetry.io/otel v1.45.0 + go.opentelemetry.io/contrib/detectors/gcp v1.46.0 + go.opentelemetry.io/otel v1.46.0 go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0 - go.opentelemetry.io/otel/sdk v1.45.0 - go.opentelemetry.io/otel/sdk/metric v1.45.0 + go.opentelemetry.io/otel/sdk v1.46.0 + go.opentelemetry.io/otel/sdk/metric v1.46.0 gofr.dev v1.60.1 golang.org/x/oauth2 v0.36.0 - google.golang.org/grpc v1.83.1 + google.golang.org/grpc v1.83.2 ) require ( cloud.google.com/go/compute/metadata v0.9.0 // indirect - github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.33.0 // indirect + github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.36.0 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/cenkalti/backoff/v5 v5.0.3 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect @@ -29,14 +29,13 @@ require ( github.com/prometheus/common v0.70.1 // indirect github.com/prometheus/otlptranslator v1.0.0 // indirect github.com/prometheus/procfs v0.21.1 // indirect - github.com/stretchr/testify v1.12.1 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.44.0 // indirect go.opentelemetry.io/otel/exporters/prometheus v0.67.0 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect - go.opentelemetry.io/otel/trace v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect + go.opentelemetry.io/otel/trace v1.46.0 // indirect go.opentelemetry.io/proto/otlp v1.10.0 // indirect - golang.org/x/net v0.57.0 // indirect + golang.org/x/net v0.58.0 // indirect golang.org/x/sys v0.47.0 // indirect golang.org/x/text v0.41.0 // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect diff --git a/pkg/gofr/metrics/exporters/gcp/go.sum b/pkg/gofr/metrics/exporters/gcp/go.sum index 7a805c94d1..1a9212a93b 100644 --- a/pkg/gofr/metrics/exporters/gcp/go.sum +++ b/pkg/gofr/metrics/exporters/gcp/go.sum @@ -1,7 +1,7 @@ cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10= -github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.33.0 h1:l7+6kwRMJNwdCvYdDl7Eax+wzEYHSnNY7zrrfbhDdTA= -github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.33.0/go.mod h1:pJTkW8hEUIIi3Pf65lPZOnn4Y81yCllX6IWk2jNXdkM= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.36.0 h1:3SdxXLkgAfiHRWcGTq6fneq9jgoJzneiY0yPQnjoT2E= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.36.0/go.mod h1:1iIdl0k+ppn9wT0wzR9H7HkSvIui/4qgtnKW10cQtds= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM= @@ -39,26 +39,26 @@ github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWD github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/contrib/detectors/gcp v1.44.0 h1:NmLfL734pJhM0JKaYd2Y28+nY9dPRWYAAbxhRCrKXPw= -go.opentelemetry.io/contrib/detectors/gcp v1.44.0/go.mod h1:tNAsgd8avTGke1+MndXlU5Cru4PQ9Ai/cCNWQv/ZJ/s= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/contrib/detectors/gcp v1.46.0 h1:PI8dGkqDaQkwJ8kOopqMhDTbrnK3UIeG/RCHH4HErbo= +go.opentelemetry.io/contrib/detectors/gcp v1.46.0/go.mod h1:nsrN5c/sOLoY2vsPxN/rQ0V0nvGrWJCqcW4UXLtqNG8= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0 h1:SUplec5dp06reu1zaXmOXdvqH398taqrDXqUl99jxSc= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0/go.mod h1:ho2g4N+ane+swq5I/VBkKWnRDY4kUINH3FuqyZqX/Ug= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.44.0 h1:RuynHbfU8JUEw7DyONgkVYg2SVtsoF28y0LGIr69jgA= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.44.0/go.mod h1:qZF+/lBs71APw8mlnEZcqZHMzqrYrsFiJOv83lX1OGo= go.opentelemetry.io/otel/exporters/prometheus v0.67.0 h1:7IefDa35e6V3NoiqIeLDMDxMFyZDk5qcoC0Ax4cC16E= go.opentelemetry.io/otel/exporters/prometheus v0.67.0/go.mod h1:nsPI1awTg5Vmg1YrommL2mVarVGlqc4yXOoKAkPRD0c= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= -go.opentelemetry.io/otel/metric/x v0.67.0 h1:PcicCNZFkZ4bXfSooXdo3WN7RBOVOtjVdo1wD358Uns= -go.opentelemetry.io/otel/metric/x v0.67.0/go.mod h1:FBjCWZe6wgcqxcMtjdGiClDKXb2YxxXii0CXftE4QtI= -go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= -go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= -go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= -go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/metric/x v0.68.0 h1:TA/cBT23D3MnxYPwHL7YFOdYGdx0A0v+s7Mzotpd1dU= +go.opentelemetry.io/otel/metric/x v0.68.0/go.mod h1:agudOmvWhwUTjgibWDzxD2PoWYnpw5Ht5jISYOD2Hd4= +go.opentelemetry.io/otel/sdk v1.46.0 h1:h5CNQQjEbuQXY/JfZtgt3i7HVFV3aHPO2OAwO2eTYPI= +go.opentelemetry.io/otel/sdk v1.46.0/go.mod h1:GAERFXFt5SYCEB+YiKUbMBeza6UaDH7GmGOZEfh2gSM= +go.opentelemetry.io/otel/sdk/metric v1.46.0 h1:0piZ26EG4RBfebb2jhDH6ERCYHoVWduc3kLgPCwSnSE= +go.opentelemetry.io/otel/sdk/metric v1.46.0/go.mod h1:I1PbKrdVc8Qu8HYVDNtqVIwLwjNrhsV/uFuxfwg8mO4= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.opentelemetry.io/proto/otlp v1.10.0 h1:IQRWgT5srOCYfiWnpqUYz9CVmbO8bFmKcwYxpuCSL2g= go.opentelemetry.io/proto/otlp v1.10.0/go.mod h1:/CV4QoCR/S9yaPj8utp3lvQPoqMtxXdzn7ozvvozVqk= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= @@ -69,8 +69,8 @@ go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= gofr.dev v1.60.1 h1:tgUCh33369oDSQNmcSxVNM+xgFxtCXxA9LZLgUK2m6k= gofr.dev v1.60.1/go.mod h1:5b56VoXF2ImEkDnYV69ExzRS586o2juu96zJKaRuZL4= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= @@ -85,7 +85,7 @@ google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1: google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws= google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= -google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= -google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= +google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= From e92a78b951d1085b9c9b50dff31be3714eb66f73 Mon Sep 17 00:00:00 2001 From: Salvatore Damon Date: Wed, 9 Sep 2026 16:04:47 +0530 Subject: [PATCH 27/48] docs: fix American English spelling of canceled (#3651) Co-authored-by: Umang Mundhra Co-authored-by: Aryan Mehrotra --- docs/guides/graceful-shutdown/page.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/guides/graceful-shutdown/page.md b/docs/guides/graceful-shutdown/page.md index d077a19662..ce6b9cfefc 100644 --- a/docs/guides/graceful-shutdown/page.md +++ b/docs/guides/graceful-shutdown/page.md @@ -38,7 +38,7 @@ The container's `Close` is what commits Pub/Sub offsets and lets SQL drivers fin ## OnStart hooks vs shutdown hooks -GoFr exposes [OnStart hooks](/docs/advanced-guide/startup-hooks) for synchronous startup work (cache warmup, seeding). There is no public `OnShutdown` hook today; `App.Shutdown` is what gets called and it operates on the framework's own resources. If you need cleanup on exit for resources you own (custom goroutines, file handles, third-party clients), use context-cancellation: pass a `context.Context` derived from `signal.NotifyContext(...)` into your goroutines and have each goroutine `defer` its own cleanup when that context is cancelled. The framework's `App.Shutdown` runs concurrently with this, so total wind-down stays within `SHUTDOWN_GRACE_PERIOD`. +GoFr exposes [OnStart hooks](/docs/advanced-guide/startup-hooks) for synchronous startup work (cache warmup, seeding). There is no public `OnShutdown` hook today; `App.Shutdown` is what gets called and it operates on the framework's own resources. If you need cleanup on exit for resources you own (custom goroutines, file handles, third-party clients), use context-cancellation: pass a `context.Context` derived from `signal.NotifyContext(...)` into your goroutines and have each goroutine `defer` its own cleanup when that context is canceled. The framework's `App.Shutdown` runs concurrently with this, so total wind-down stays within `SHUTDOWN_GRACE_PERIOD`. ## The Kubernetes termination flow @@ -89,7 +89,7 @@ For a service with 2s P99, that's 5s + 30s + 10s = 45–60s. - **SQL.** `database/sql` waits for active queries to finish on `Close()`. Long-running transactions can extend shutdown — keep request timeouts shorter than `SHUTDOWN_GRACE_PERIOD`. - **Redis / NoSQL.** Clients close idle connections immediately and wait for in-flight commands. - **Pub/Sub.** GoFr's subscription manager respects the shutdown context — consumers stop polling and commit current offsets where the broker supports it (Kafka, NATS JetStream). -- **Cron jobs.** `App.Shutdown` stops the cron scheduler and waits for jobs that are already running before it closes datasource connections, so a job mid-write is not cut off by `container.Close()`. The wait is bounded by the shutdown deadline (`SHUTDOWN_GRACE_PERIOD`): if a job is still running when that expires, `Shutdown` returns and the job is abandoned. The jobs themselves run with `context.Background()`, so a job's own `ctx` is never cancelled — anything that needs to be interruptible has to watch something else. For cron work that routinely outlasts `SHUTDOWN_GRACE_PERIOD`, run it as a Kubernetes `CronJob` in its own pod rather than inside the service. +- **Cron jobs.** `App.Shutdown` stops the cron scheduler and waits for jobs that are already running before it closes datasource connections, so a job mid-write is not cut off by `container.Close()`. The wait is bounded by the shutdown deadline (`SHUTDOWN_GRACE_PERIOD`): if a job is still running when that expires, `Shutdown` returns and the job is abandoned. The jobs themselves run with `context.Background()`, so a job's own `ctx` is never canceled — anything that needs to be interruptible has to watch something else. For cron work that routinely outlasts `SHUTDOWN_GRACE_PERIOD`, run it as a Kubernetes `CronJob` in its own pod rather than inside the service. ## Verification From 8ab74fd2d9261a4b255f286fcd529868bb8a40ce Mon Sep 17 00:00:00 2001 From: Akshat Singhal <65562230+akshat-kumar-singhal@users.noreply.github.com> Date: Wed, 9 Sep 2026 17:23:18 +0530 Subject: [PATCH 28/48] docs(cron): correct the minimum-interval claim and the "every 5 hours" example (#3876) (#3977) Co-authored-by: Aryan Mehrotra --- docs/advanced-guide/using-cron/page.md | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/docs/advanced-guide/using-cron/page.md b/docs/advanced-guide/using-cron/page.md index 37f8f19d0f..92365ceded 100644 --- a/docs/advanced-guide/using-cron/page.md +++ b/docs/advanced-guide/using-cron/page.md @@ -36,8 +36,10 @@ range of values for which the cron should run and `*/n` to define number of time ## Adding cron jobs in GoFr applications Adding cron jobs to GoFr applications is made easy with a simple injection of user's function to the cron table maintained -by the GoFr. The minimum time difference between cron job's two consecutive runs is a minute as it is the least significant -scheduling time parameter. +by the GoFr. With the 5-field format the minimum time difference between a cron job's two consecutive runs is a minute, +since minute is then the least significant scheduling parameter — the job fires once per minute, at second 0. Adding the +optional leading `second` field lowers that to a second, as GoFr's scheduler evaluates every registered schedule once per +second. Cron job with generic format: ```go @@ -68,8 +70,8 @@ import ( func main() { app := gofr.New() - // Run the cron job every 5 hours(*/5) - app.AddCronJob("* */5 * * *", "", func(ctx *gofr.Context) { + // Run the cron job every 5 hours(*/5), at minute 0 + app.AddCronJob("0 */5 * * *", "", func(ctx *gofr.Context) { ctx.Logger.Infof("current time is %v", time.Now()) }) From c613403b6f9931ded1c1279a336e686dde6ad661 Mon Sep 17 00:00:00 2001 From: Napat Rungruangbangchan Date: Thu, 10 Sep 2026 13:18:33 +0700 Subject: [PATCH 29/48] docs(readme): link Custom Middleware and update the Go version prerequisite (#3461) The broken Auth Middleware link this PR also carried has since landed via #3798, so what remains is: - "Custom Middleware" was plain text next to the linked Auth Middleware; it now points at docs/advanced-guide/middlewares. - The prerequisite said Go 1.24. Every go.mod in the repo declares go 1.26.0, and CI's 1.24/1.25 matrix entries only pass because a setup-go-toolchain step auto-upgrades them, so 1.26 is the real floor. Co-authored-by: Aryan Mehrotra Co-authored-by: Umang Mundhra --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 6776772756..09a7308f49 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ GoFr is designed to **simplify microservice development**, with a key focus on * 2. **REST Standards by Default** 3. **Configuration Management** 4. **[Observability](https://gofr.dev/docs/quick-start/observability)** (Logs, Traces, Metrics) -5. **Inbuilt [Auth Middleware](https://gofr.dev/docs/advanced-guide/authentication)** & Custom Middleware Support +5. **Inbuilt [Auth Middleware](https://gofr.dev/docs/advanced-guide/authentication)** & [Custom Middleware](https://gofr.dev/docs/advanced-guide/middlewares) Support 6. **[gRPC Support](https://gofr.dev/docs/advanced-guide/grpc)** 7. **[HTTP Service](https://gofr.dev/docs/advanced-guide/http-communication)** with Circuit Breaker Support 8. **[Pub/Sub](https://gofr.dev/docs/advanced-guide/using-publisher-subscriber)** @@ -47,7 +47,7 @@ GoFr is designed to **simplify microservice development**, with a key focus on * ## 🚀 **Getting Started** ### **Prerequisites** -- GoFr requires **[Go](https://go.dev/)** version **[1.24](https://go.dev/doc/devel/release#go1.24.0)** or above. +- GoFr requires **[Go](https://go.dev/)** version **[1.26](https://go.dev/doc/devel/release#go1.26.0)** or above. ### **Installation** To get started with GoFr, add the following import to your code and use Go’s module support to automatically fetch dependencies: From a04c0e3ece8229016511ed46755286de76ae24a5 Mon Sep 17 00:00:00 2001 From: Rohit Nair P Date: Thu, 10 Sep 2026 12:07:14 +0530 Subject: [PATCH 30/48] fix(file): correct SFTP/S3 observability defects and stale comments (#3227) Co-authored-by: Umang Mundhra Co-authored-by: Aryan Mehrotra --- pkg/gofr/datasource/file/s3/fs.go | 8 +- pkg/gofr/datasource/file/s3/fs_test.go | 25 ++++++ pkg/gofr/datasource/file/sftp/fs.go | 39 ++++++---- pkg/gofr/datasource/file/sftp/fs_test.go | 98 +++++++++++++++++++++++- 4 files changed, 152 insertions(+), 18 deletions(-) diff --git a/pkg/gofr/datasource/file/s3/fs.go b/pkg/gofr/datasource/file/s3/fs.go index f51622776e..d5c02c94a1 100644 --- a/pkg/gofr/datasource/file/s3/fs.go +++ b/pkg/gofr/datasource/file/s3/fs.go @@ -77,7 +77,7 @@ func New(config *Config) file.CloudFileSystem { return &FileSystem{config: config} } -// UseLogger sets the Logger interface for the FTP file system. +// UseLogger sets the Logger interface for the S3 file system. func (f *FileSystem) UseLogger(logger any) { if l, ok := logger.(Logger); ok { f.logger = l @@ -94,7 +94,7 @@ func (f *FileSystem) UseMetrics(metrics any) { // Connect initializes and validates the connection to the S3 service. // // This method sets up the S3 client using the provided configuration, including access key, secret key, region, and base endpoint. -// It loads the AWS configuration and creates an S3 client, which is then assigns it to the `fileSystem` struct. +// It loads the AWS configuration and creates an S3 client and assigns it to the `fileSystem` struct. // This method also logs the outcome of the connection attempt. func (f *FileSystem) Connect() { var msg string @@ -337,7 +337,11 @@ func (f *FileSystem) Rename(oldname, newname string) error { // check if they have the same name or not if oldname == newname { + st = statusSuccess + msg = "Old and new names are identical, no operation performed" + f.logger.Logf("%q & %q are same", oldname, newname) + return nil } diff --git a/pkg/gofr/datasource/file/s3/fs_test.go b/pkg/gofr/datasource/file/s3/fs_test.go index fa389915b1..157985bfa9 100644 --- a/pkg/gofr/datasource/file/s3/fs_test.go +++ b/pkg/gofr/datasource/file/s3/fs_test.go @@ -723,3 +723,28 @@ func Test_Stat_ListObjectsV2Fails_Error(t *testing.T) { require.Error(t, err, "Expected error when ListObjectsV2 fails") require.Contains(t, err.Error(), "mocked error", "Expected error to contain mocked error") } + +// Test_RenameFile_ToSameName_LogsSuccess guards against the same-name no-op +// being reported as an ERROR by observability while returning nil to the caller. +func Test_RenameFile_ToSameName_LogsSuccess(t *testing.T) { + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mocks := setupTestMocks(ctrl) + fs := setupTestFileSystem(mocks, nil) + + logs := make([]FileLog, 0) + + mocks.mockLogger.EXPECT().Logf(gomock.Any(), gomock.Any()).AnyTimes() + mocks.mockLogger.EXPECT().Debug(gomock.Any()).AnyTimes().Do(func(args ...any) { + if fl, ok := args[0].(*FileLog); ok { + logs = append(logs, *fl) + } + }) + + require.NoError(t, fs.Rename("abcd.json", "abcd.json")) + + require.Len(t, logs, 1) + require.Equal(t, "RENAME", logs[0].Operation) + require.Equal(t, statusSuccess, *logs[0].Status) +} diff --git a/pkg/gofr/datasource/file/sftp/fs.go b/pkg/gofr/datasource/file/sftp/fs.go index 3536c27b0a..90a7974ec7 100644 --- a/pkg/gofr/datasource/file/sftp/fs.go +++ b/pkg/gofr/datasource/file/sftp/fs.go @@ -1,6 +1,7 @@ package sftp import ( + "errors" "fmt" "os" "time" @@ -15,6 +16,9 @@ const ( statusError = "ERROR" ) +// errChDirNotSupported is returned by ChDir, which the SFTP client does not implement. +var errChDirNotSupported = errors.New("changing directory is not supported for SFTP") + type FileSystem struct { logger Logger metrics Metrics @@ -48,7 +52,7 @@ func (f *FileSystem) UseMetrics(metrics any) { } } -// Connect establishes a connection to FileSystem and registers metrics using the provided configuration when the client was Created. +// Connect establishes a connection to the SFTP server using the provided configuration. func (f *FileSystem) Connect() { f.logger.Debugf("connecting to SFTP server with host `%v` and port `%v`", f.config.Host, f.config.Port) @@ -81,7 +85,7 @@ func (f *FileSystem) Create(name string) (file.File, error) { status := statusError defer f.sendOperationStats(&FileLog{ - Operation: "CREATE", + Operation: file.OpCreate, Location: name, Status: &status, }, time.Now()) @@ -102,7 +106,7 @@ func (f *FileSystem) Create(name string) (file.File, error) { func (f *FileSystem) Mkdir(name string, _ os.FileMode) error { status := statusSuccess - defer f.sendOperationStats(&FileLog{Operation: "MKDIR", Location: name, Status: &status}, time.Now()) + defer f.sendOperationStats(&FileLog{Operation: file.OpMkdir, Location: name, Status: &status}, time.Now()) err := f.client.Mkdir(name) if err != nil { @@ -116,7 +120,7 @@ func (f *FileSystem) Mkdir(name string, _ os.FileMode) error { func (f *FileSystem) MkdirAll(path string, _ os.FileMode) error { status := statusSuccess - defer f.sendOperationStats(&FileLog{Operation: "MKDIR", Location: path, Status: &status}, time.Now()) + defer f.sendOperationStats(&FileLog{Operation: file.OpMkdirAll, Location: path, Status: &status}, time.Now()) err := f.client.MkdirAll(path) if err != nil { @@ -130,7 +134,7 @@ func (f *FileSystem) MkdirAll(path string, _ os.FileMode) error { func (f *FileSystem) Open(name string) (file.File, error) { status := statusSuccess - defer f.sendOperationStats(&FileLog{Operation: "OPEN", Location: name, Status: &status}, time.Now()) + defer f.sendOperationStats(&FileLog{Operation: file.OpOpen, Location: name, Status: &status}, time.Now()) openedFile, err := f.client.Open(name) if err != nil { @@ -148,11 +152,11 @@ func (f *FileSystem) Open(name string) (file.File, error) { func (f *FileSystem) OpenFile(name string, flag int, _ os.FileMode) (file.File, error) { status := statusSuccess - defer f.sendOperationStats(&FileLog{Operation: "OPENFILE", Location: name, Status: &status}, time.Now()) + defer f.sendOperationStats(&FileLog{Operation: file.OpOpenFile, Location: name, Status: &status}, time.Now()) openedFile, err := f.client.OpenFile(name, flag) if err != nil { - status = statusSuccess + status = statusError return nil, err } @@ -166,7 +170,7 @@ func (f *FileSystem) OpenFile(name string, flag int, _ os.FileMode) (file.File, func (f *FileSystem) Remove(name string) error { status := statusSuccess - defer f.sendOperationStats(&FileLog{Operation: "REMOVE", Location: name, Status: &status}, time.Now()) + defer f.sendOperationStats(&FileLog{Operation: file.OpRemove, Location: name, Status: &status}, time.Now()) err := f.client.Remove(name) if err != nil { @@ -180,7 +184,7 @@ func (f *FileSystem) Remove(name string) error { func (f *FileSystem) RemoveAll(path string) error { status := statusSuccess - defer f.sendOperationStats(&FileLog{Operation: "REMOVEALL", Location: path, Status: &status}, time.Now()) + defer f.sendOperationStats(&FileLog{Operation: file.OpRemoveAll, Location: path, Status: &status}, time.Now()) err := f.client.RemoveAll(path) if err != nil { @@ -194,7 +198,7 @@ func (f *FileSystem) RemoveAll(path string) error { func (f *FileSystem) Rename(oldname, newname string) error { status := statusSuccess - defer f.sendOperationStats(&FileLog{Operation: "RENAME", Location: fmt.Sprintf("%v to %v", oldname, newname), + defer f.sendOperationStats(&FileLog{Operation: file.OpRename, Location: fmt.Sprintf("%v to %v", oldname, newname), Status: &status}, time.Now()) err := f.client.Rename(oldname, newname) @@ -209,7 +213,7 @@ func (f *FileSystem) Rename(oldname, newname string) error { func (f *FileSystem) ReadDir(dir string) ([]file.FileInfo, error) { status := statusSuccess - defer f.sendOperationStats(&FileLog{Operation: "READDIR", Location: dir, Status: &status}, time.Now()) + defer f.sendOperationStats(&FileLog{Operation: file.OpReadDir, Location: dir, Status: &status}, time.Now()) dirs, err := f.client.ReadDir(dir) if err != nil { @@ -229,7 +233,7 @@ func (f *FileSystem) ReadDir(dir string) ([]file.FileInfo, error) { func (f *FileSystem) Stat(name string) (file.FileInfo, error) { status := statusSuccess - defer f.sendOperationStats(&FileLog{Operation: "STAT", Location: name, Status: &status}, time.Now()) + defer f.sendOperationStats(&FileLog{Operation: file.OpStat, Location: name, Status: &status}, time.Now()) fileInfo, err := f.client.Stat(name) if err != nil { @@ -241,14 +245,19 @@ func (f *FileSystem) Stat(name string) (file.FileInfo, error) { } func (f *FileSystem) ChDir(_ string) error { + status := statusError + + defer f.sendOperationStats(&FileLog{Operation: file.OpChDir, Location: "", Status: &status}, time.Now()) + f.logger.Errorf("Chdir is not implemented for SFTP") - return nil + + return errChDirNotSupported } func (f *FileSystem) Getwd() (string, error) { status := statusSuccess - defer f.sendOperationStats(&FileLog{Operation: "STAT", Location: "", Status: &status}, time.Now()) + defer f.sendOperationStats(&FileLog{Operation: file.OpGetwd, Location: "", Status: &status}, time.Now()) name, err := f.client.Getwd() if err != nil { @@ -256,7 +265,7 @@ func (f *FileSystem) Getwd() (string, error) { return "", err } - return name, err + return name, nil } // TODO : Implement metrics. diff --git a/pkg/gofr/datasource/file/sftp/fs_test.go b/pkg/gofr/datasource/file/sftp/fs_test.go index bf378960a8..d2acf99053 100644 --- a/pkg/gofr/datasource/file/sftp/fs_test.go +++ b/pkg/gofr/datasource/file/sftp/fs_test.go @@ -152,7 +152,7 @@ func TestFiles_ChDir(t *testing.T) { err := files.ChDir("test.csv") - require.NoError(t, err, "TEST[%d] Failed. Desc %v") + require.ErrorIs(t, err, errChDirNotSupported, "TEST[%d] Failed. Desc %v") } func TestFiles_GetWd(t *testing.T) { @@ -309,3 +309,99 @@ func TestFiles_Stat(t *testing.T) { require.Equal(t, tc.expError, err, "Test[%d] Failed.\n DESC %v", i, tc.desc) } } + +// captureOperationLogs returns a FileSystem whose logger records every FileLog +// emitted by sendOperationStats, so tests can assert the operation name and the +// success/error status that observability actually reports. +func captureOperationLogs(t *testing.T) (FileSystem, *MocksftpClient, *[]FileLog) { + t.Helper() + + ctrl := gomock.NewController(t) + + mockClient := NewMocksftpClient(ctrl) + mockLogger := NewMockLogger(ctrl) + + logs := make([]FileLog, 0) + + mockLogger.EXPECT().Debug(gomock.Any()).AnyTimes().Do(func(args ...any) { + if fl, ok := args[0].(*FileLog); ok { + logs = append(logs, *fl) + } + }) + mockLogger.EXPECT().Errorf(gomock.Any(), gomock.Any()).AnyTimes() + mockLogger.EXPECT().Errorf(gomock.Any()).AnyTimes() + + return FileSystem{logger: mockLogger, client: mockClient}, mockClient, &logs +} + +// TestFiles_OperationLogs_NameAndStatus pins the operation name and status that +// each method reports. It regression-guards three defects: Getwd reported STAT, +// MkdirAll reported MKDIR, and a failed OpenFile reported SUCCESS. +func TestFiles_OperationLogs_NameAndStatus(t *testing.T) { + testCases := []struct { + desc string + setup func(c *MocksftpClient) + call func(f FileSystem) + expOp string + expStatus string + }{ + { + desc: "Getwd reports GETWD, not STAT", + setup: func(c *MocksftpClient) { c.EXPECT().Getwd().Return("/home", nil) }, + call: func(f FileSystem) { _, _ = f.Getwd() }, + expOp: File.OpGetwd, + expStatus: statusSuccess, + }, + { + desc: "MkdirAll reports MKDIR_ALL, not MKDIR", + setup: func(c *MocksftpClient) { c.EXPECT().MkdirAll("/a/b").Return(nil) }, + call: func(f FileSystem) { _ = f.MkdirAll("/a/b", 0) }, + expOp: File.OpMkdirAll, + expStatus: statusSuccess, + }, + { + desc: "Mkdir still reports MKDIR", + setup: func(c *MocksftpClient) { c.EXPECT().Mkdir("/a").Return(nil) }, + call: func(f FileSystem) { _ = f.Mkdir("/a", 0) }, + expOp: File.OpMkdir, + expStatus: statusSuccess, + }, + { + desc: "failed OpenFile reports ERROR, not SUCCESS", + setup: func(c *MocksftpClient) { + c.EXPECT().OpenFile("x.csv", 0).Return(nil, errOpenFile) + }, + call: func(f FileSystem) { _, _ = f.OpenFile("x.csv", 0, 0) }, + expOp: File.OpOpenFile, + expStatus: statusError, + }, + { + desc: "ChDir reports CHDIR with ERROR", + setup: func(_ *MocksftpClient) {}, + call: func(f FileSystem) { _ = f.ChDir("/a") }, + expOp: File.OpChDir, + expStatus: statusError, + }, + } + + for i, tc := range testCases { + fs, client, logs := captureOperationLogs(t) + + tc.setup(client) + tc.call(fs) + + require.Len(t, *logs, 1, "TEST[%d] Failed. Desc %v", i, tc.desc) + require.Equal(t, tc.expOp, (*logs)[0].Operation, "TEST[%d] Failed. Desc %v", i, tc.desc) + require.Equal(t, tc.expStatus, *(*logs)[0].Status, "TEST[%d] Failed. Desc %v", i, tc.desc) + } +} + +// TestFiles_ChDir_ReturnsError guards against ChDir silently reporting success +// for an operation the SFTP client does not implement. +func TestFiles_ChDir_ReturnsError(t *testing.T) { + files, mocks := getMocks(t) + + mocks.logger.EXPECT().Errorf("Chdir is not implemented for SFTP") + + require.ErrorIs(t, files.ChDir("any"), errChDirNotSupported) +} From e8b38e40a2325f1961c490bab036017948088d13 Mon Sep 17 00:00:00 2001 From: umar ahad uddin ahmed usmani <150610336+umarahad2005@users.noreply.github.com> Date: Thu, 10 Sep 2026 11:53:27 +0500 Subject: [PATCH 31/48] fix(sql): validate unsigned int not-null fields without panicking (#3677) --- pkg/gofr/datasource/sql/query_builder.go | 68 ++++++-- pkg/gofr/datasource/sql/query_builder_test.go | 155 ++++++++++++++++++ 2 files changed, 213 insertions(+), 10 deletions(-) diff --git a/pkg/gofr/datasource/sql/query_builder.go b/pkg/gofr/datasource/sql/query_builder.go index 35b204d5bb..5195d0c9fd 100644 --- a/pkg/gofr/datasource/sql/query_builder.go +++ b/pkg/gofr/datasource/sql/query_builder.go @@ -88,25 +88,36 @@ func DeleteByQuery(dialect, tableName, field string) string { bindVar(dialect, 1)) } +// validateNotNull rejects a value that cannot satisfy a NOT NULL column. +// +// Dispatch is on reflect.Kind rather than on the concrete type. A type switch only matches the +// predeclared types exactly, so a named type -- `type Count uint`, which is ordinary in an entity +// struct -- misses every case and lands in the default path. On the kind, Count and uint are the +// same thing and get the same answer. +// +//nolint:exhaustive // every remaining kind is deliberately handled by validateDefaultNotNull. func validateNotNull(fieldName string, value any, isNotNull bool) error { if !isNotNull { return nil } - switch v := value.(type) { - case string: - return validateStringNotNull(fieldName, v) - case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64: - return validateIntNotNull(fieldName, v) - case float32, float64: - return validateFloatNotNull(fieldName, v) + switch reflect.ValueOf(value).Kind() { + case reflect.String: + return validateStringNotNull(fieldName, value) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return validateIntNotNull(fieldName, value) + // reflect.Value.Int panics on unsigned kinds, so these read through Uint instead. + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: + return validateUintNotNull(fieldName, value) + case reflect.Float32, reflect.Float64: + return validateFloatNotNull(fieldName, value) default: return validateDefaultNotNull(fieldName, value) } } -func validateStringNotNull(fieldName, value string) error { - if value == "" { +func validateStringNotNull(fieldName string, value any) error { + if reflect.ValueOf(value).String() == "" { return fmt.Errorf("%w: %s", errFieldCannotBeEmpty, fieldName) } @@ -121,6 +132,16 @@ func validateIntNotNull(fieldName string, value any) error { return nil } +// validateUintNotNull handles the unsigned integer kinds. reflect.Value.Int() +// panics for unsigned values, so these must use reflect.Value.Uint(). +func validateUintNotNull(fieldName string, value any) error { + if reflect.ValueOf(value).Uint() == 0 { + return fmt.Errorf("%w: %s", errFieldCannotBeZero, fieldName) + } + + return nil +} + func validateFloatNotNull(fieldName string, value any) error { if reflect.ValueOf(value).Float() == 0.0 { return fmt.Errorf("%w: %s", errFieldCannotBeZero, fieldName) @@ -130,9 +151,36 @@ func validateFloatNotNull(fieldName string, value any) error { } func validateDefaultNotNull(fieldName string, value any) error { - if reflect.ValueOf(value).IsNil() { + v := reflect.ValueOf(value) + + // An untyped-nil interface has no underlying value at all, which for a + // NOT NULL column is a null. + if v.Kind() == reflect.Invalid { + return fmt.Errorf("%w: %s", errFieldCannotBeNull, fieldName) + } + + // reflect.Value.IsNil panics on non-nillable kinds (bool, struct such as + // time.Time, array, uintptr, complex, ...). Those can never be nil, so the + // nil check only runs for the kinds where IsNil is defined. + if isNillableKind(v.Kind()) && v.IsNil() { return fmt.Errorf("%w: %s", errFieldCannotBeNull, fieldName) } return nil } + +// isNillableKind reports whether reflect.Value.IsNil is defined for k. Calling IsNil on any +// other kind panics. reflect.Value.IsNil documents six kinds; the implementation accepts +// UnsafePointer as well, so it is listed here too -- otherwise a nil unsafe.Pointer reaches +// the default and is accepted for a NOT NULL column. +// +//nolint:exhaustive // every non-nillable kind is intentionally handled by the default. +func isNillableKind(k reflect.Kind) bool { + switch k { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice, + reflect.UnsafePointer: + return true + default: + return false + } +} diff --git a/pkg/gofr/datasource/sql/query_builder_test.go b/pkg/gofr/datasource/sql/query_builder_test.go index 71f365856a..ab877c5557 100644 --- a/pkg/gofr/datasource/sql/query_builder_test.go +++ b/pkg/gofr/datasource/sql/query_builder_test.go @@ -2,6 +2,8 @@ package sql import ( "testing" + "time" + "unsafe" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -95,6 +97,16 @@ func Test_InsertQuery_Error(t *testing.T) { "age": {NotNull: true}, }, }, + { + name: "NotNull Validation Error (unsigned int)", + dialect: "mysql", + tableName: "user", + fieldNames: []string{"views"}, + values: []any{uint(0)}, + constraints: map[string]FieldConstraints{ + "views": {NotNull: true}, + }, + }, } for _, tc := range tests { @@ -246,3 +258,146 @@ func Test_validateNotNull_Error(t *testing.T) { }) } } + +func Test_validateNotNull_UnsignedInt(t *testing.T) { + // reflect.Value.Int() panics on unsigned kinds, so unsigned integers must be + // validated via reflect.Value.Uint(). These calls previously panicked. Every + // uint width listed in the type switch is exercised so none regress to the + // default path. + require.NoError(t, validateNotNull("views", uint(5), true)) + require.NoError(t, validateNotNull("views", uint8(5), true)) + require.NoError(t, validateNotNull("views", uint16(5), true)) + require.NoError(t, validateNotNull("views", uint32(5), true)) + require.NoError(t, validateNotNull("views", uint64(5), true)) + + require.EqualError(t, validateNotNull("views", uint(0), true), "field cannot be zero: views") + require.EqualError(t, validateNotNull("views", uint8(0), true), "field cannot be zero: views") + require.EqualError(t, validateNotNull("views", uint16(0), true), "field cannot be zero: views") + require.EqualError(t, validateNotNull("views", uint32(0), true), "field cannot be zero: views") + require.EqualError(t, validateNotNull("views", uint64(0), true), "field cannot be zero: views") +} + +func Test_validateNotNull_NonNillableKinds(t *testing.T) { + // reflect.Value.IsNil() panics on non-nillable kinds, so the default path + // must guard against them. These kinds can never be null and previously + // panicked; they are now accepted for a NOT NULL field. + require.NoError(t, validateNotNull("active", true, true)) + require.NoError(t, validateNotNull("active", false, true)) + require.NoError(t, validateNotNull("createdAt", time.Time{}, true)) + require.NoError(t, validateNotNull("offset", uintptr(0), true)) + + // A genuinely nil value for a NOT NULL field is still reported as null. + require.EqualError(t, validateNotNull("data", []byte(nil), true), "field cannot be null: data") + require.EqualError(t, validateNotNull("meta", map[string]int(nil), true), "field cannot be null: meta") + require.EqualError(t, validateNotNull("value", nil, true), "field cannot be null: value") + + // reflect.Value.IsNil is documented for six kinds but accepts UnsafePointer as well, so a nil + // one is reported as null instead of reaching the default path and being accepted. + var nilUnsafe unsafe.Pointer + + require.EqualError(t, validateNotNull("ptr", nilUnsafe, true), "field cannot be null: ptr") + require.NoError(t, validateNotNull("ptr", unsafe.Pointer(&nilUnsafe), true)) +} + +// namedCount and namedName stand in for the named types an entity struct normally uses. A type +// switch matches only the predeclared types, so before the dispatch moved to reflect.Kind these +// missed every case and fell through to the default path. On development that path called IsNil +// on them and panicked; once the default path was guarded they stopped panicking but were +// silently ACCEPTED, so a named zero passed a NOT NULL column that its underlying kind rejects. +// Dispatching on the kind is what makes Count and uint answer the same. +type ( + namedCount uint + namedAge int + namedName string +) + +func Test_validateNotNull_NamedTypes(t *testing.T) { + tests := []struct { + name string + value any + wantErr string + }{ + {"named uint, zero", namedCount(0), "field cannot be zero: f"}, + {"named uint, set", namedCount(7), ""}, + {"named int, zero", namedAge(0), "field cannot be zero: f"}, + {"named int, set", namedAge(30), ""}, + {"named string, empty", namedName(""), "field cannot be empty: f"}, + {"named string, set", namedName("gofr"), ""}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + err := validateNotNull("f", tc.value, true) + + if tc.wantErr == "" { + require.NoError(t, err, "a named type must validate like its underlying kind") + + return + } + + require.EqualError(t, err, tc.wantErr, "a named type must validate like its underlying kind") + }) + } +} + +// Test_validateNotNull_Floats closes the non-zero float branch, which no other test reached. +func Test_validateNotNull_Floats(t *testing.T) { + require.NoError(t, validateNotNull("price", float32(1.5), true)) + require.NoError(t, validateNotNull("price", 1.5, true)) + require.EqualError(t, validateNotNull("price", float32(0), true), "field cannot be zero: price") + require.EqualError(t, validateNotNull("price", 0.0, true), "field cannot be zero: price") + + // isNotNull false short-circuits before any reflection, whatever the value. + require.NoError(t, validateNotNull("price", nil, false)) +} + +// Test_validateNotNull_SignedWidthsAndNegatives closes three gaps the other tests leave open. +// +// Only plain int was exercised, so dropping any of int8/16/32 from the dispatch went unnoticed -- +// they would fall to validateDefaultNotNull and a zero would be accepted for a NOT NULL column. +// +// And no negative value was tested anywhere, so the zero check could be relaxed from `== 0` to +// `<= 0` with the suite still green. That mutation is not hypothetical-looking: `<= 0` reads like +// a reasonable "must be positive" rule, and it would silently reject every negative value in a +// column that is perfectly entitled to hold one. +func Test_validateNotNull_SignedWidthsAndNegatives(t *testing.T) { + tests := []struct { + name string + value any + wantErr string + }{ + {"int8 zero", int8(0), "field cannot be zero: f"}, + {"int16 zero", int16(0), "field cannot be zero: f"}, + {"int32 zero", int32(0), "field cannot be zero: f"}, + {"int64 zero", int64(0), "field cannot be zero: f"}, + {"int8 negative", int8(-5), ""}, + {"int16 negative", int16(-5), ""}, + {"int32 negative", int32(-5), ""}, + {"int64 negative", int64(-5), ""}, + {"int negative", -5, ""}, + {"float negative", -0.5, ""}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + err := validateNotNull("f", tc.value, true) + + if tc.wantErr == "" { + require.NoError(t, err, "a negative value is not a zero value and must be accepted") + + return + } + + require.EqualError(t, err, tc.wantErr, "every signed width must reach validateIntNotNull") + }) + } +} + +// Test_validateNotNull_NilFunc covers the reflect.Func arm of isNillableKind, which no other test +// reaches. A nil func in a NOT NULL field is a null like any other nillable kind. +func Test_validateNotNull_NilFunc(t *testing.T) { + var fn func() + + require.EqualError(t, validateNotNull("cb", fn, true), "field cannot be null: cb") + require.NoError(t, validateNotNull("cb", func() {}, true)) +} From 9304f0dea7933397afe788ea5bed7fbff781a581 Mon Sep 17 00:00:00 2001 From: Piyush Singh Date: Thu, 10 Sep 2026 15:54:59 +0530 Subject: [PATCH 32/48] ci(website-prod): move prod build and deploy to asia-south1 zopdev-tech (#4198) Point the prod website image build/push at the asia-south1 zopdev Artifact Registry and deploy to the zopdev-tech cluster (asia-south1), replacing the us-central1 kops-dev registry and raramuri-tech cluster. Namespace, app name, and image tagging are unchanged. --- .github/workflows/website-prod.yml | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/.github/workflows/website-prod.yml b/.github/workflows/website-prod.yml index 5151b3e876..3d39227b3c 100644 --- a/.github/workflows/website-prod.yml +++ b/.github/workflows/website-prod.yml @@ -19,8 +19,9 @@ env: APP_NAME: gofr-website WEBSITE_REGISTRY: ghcr.io GAR_PROJECT: raramuri-tech - GAR_REGISTRY: kops-dev - CLUSTER_NAME: raramuri-tech + GAR_REGISTRY: zopdev + CLUSTER_NAME: zopdev-tech + CLUSTER_REGION: asia-south1 CLUSTER_PROJECT: raramuri-tech NAMESPACE: gofr-dev NAMESPACE_STAGE: gofr-dev-stg @@ -85,7 +86,7 @@ jobs: - name: Login to GAR uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0 with: - registry: us-central1-docker.pkg.dev + registry: asia-south1-docker.pkg.dev username: _json_key password: ${{ secrets.GOFR_WEBSITE_GOFR_DEV_DEPLOYMENT_KEY }} @@ -123,15 +124,15 @@ jobs: run: | docker build \ --build-arg WEBSITE_TAG=latest \ - -t us-central1-docker.pkg.dev/${{ env.GAR_PROJECT }}/${{ env.GAR_REGISTRY }}/${{ env.APP_NAME }}:${{ env.TAG }} \ + -t asia-south1-docker.pkg.dev/${{ env.GAR_PROJECT }}/${{ env.GAR_REGISTRY }}/${{ env.APP_NAME }}:${{ env.TAG }} \ -f ./docs/Dockerfile \ . - name: Push framework docs image to GAR - run: docker push us-central1-docker.pkg.dev/${{ env.GAR_PROJECT }}/${{ env.GAR_REGISTRY }}/${{ env.APP_NAME }}:${{ env.TAG }} + run: docker push asia-south1-docker.pkg.dev/${{ env.GAR_PROJECT }}/${{ env.GAR_REGISTRY }}/${{ env.APP_NAME }}:${{ env.TAG }} - id: output-image - run: echo "image=`echo us-central1-docker.pkg.dev/${{ env.GAR_PROJECT }}/${{ env.GAR_REGISTRY }}/${{ env.APP_NAME }}:${{ env.TAG }}`" >> "$GITHUB_OUTPUT" + run: echo "image=`echo asia-south1-docker.pkg.dev/${{ env.GAR_PROJECT }}/${{ env.GAR_REGISTRY }}/${{ env.APP_NAME }}:${{ env.TAG }}`" >> "$GITHUB_OUTPUT" deployment: runs-on: ubuntu-latest @@ -154,7 +155,7 @@ jobs: credentials_json: ${{ secrets.GOFR_WEBSITE_GOFR_DEV_DEPLOYMENT_KEY }} - name: Set GCloud Project and Fetch Cluster Credentials - run: gcloud container clusters get-credentials ${{ env.CLUSTER_NAME }} --region=us-central1 --project=${{ env.CLUSTER_PROJECT }} + run: gcloud container clusters get-credentials ${{ env.CLUSTER_NAME }} --region=${{ env.CLUSTER_REGION }} --project=${{ env.CLUSTER_PROJECT }} - name: Update Deployment Image run: kubectl set image deployment/${{ env.APP_NAME }} ${{ env.APP_NAME }}=${{ env.image }} --namespace ${{ env.NAMESPACE }} From 7425f5790dd40e8f2ff6b6ff6ca6b39932979bde Mon Sep 17 00:00:00 2001 From: Akshat Singhal <65562230+akshat-kumar-singhal@users.noreply.github.com> Date: Thu, 10 Sep 2026 16:08:45 +0530 Subject: [PATCH 33/48] feat(health): optional readiness check for /.well-known/health (#3857) (#3858) --- .../monitoring-service-health/page.md | 183 ++++++++++- docs/guides/deploying-to-kubernetes/page.md | 2 +- docs/guides/helm-chart-starter/page.md | 2 +- pkg/gofr/gofr.go | 9 +- pkg/gofr/handler_test.go | 309 +++++++++++++++++- pkg/gofr/health.go | 225 ++++++++++++- 6 files changed, 718 insertions(+), 12 deletions(-) diff --git a/docs/advanced-guide/monitoring-service-health/page.md b/docs/advanced-guide/monitoring-service-health/page.md index c586149d52..e5c888c904 100644 --- a/docs/advanced-guide/monitoring-service-health/page.md +++ b/docs/advanced-guide/monitoring-service-health/page.md @@ -45,7 +45,9 @@ aggregates the health of every registered datasource and service into a single s Note that the endpoint answers `200` in both cases: a `DEGRADED` aggregate does **not** produce a non-2xx response, so a probe wired directly to the status code will always see the service as ready. -A caller that wants to act on degradation must read the `status` field itself. +A caller that wants to act on degradation must read the `status` field itself, or register a +[readiness check](#controlling-readiness-with-a-readiness-check) so the endpoint answers `503` when +the service is not ready to serve traffic. To avoid leaking infrastructure details on an unauthenticated port, this endpoint intentionally does **not** expose per-dependency information (hosts, ports, database/keyspace/bucket names, connection @@ -69,6 +71,185 @@ Sample response when the service is ready (HTTP 200): } ``` +#### Controlling readiness with a readiness check + +By default the endpoint always responds with HTTP `200` (existing probes keep working unchanged). +To hold a pod out of service until it can actually serve traffic, register a readiness check: + +```go +type ReadinessCheck func(ctx *gofr.Context) error + +func (a *App) AddReadinessCheck(check ReadinessCheck, opts ...ReadinessOption) +func ReplaceFrameworkChecks() ReadinessOption +``` + +Return `nil` when ready, any error when not — in which case the endpoint answers `503` and +Kubernetes stops routing traffic to the pod. The error is logged, never written to the response: +the endpoint is unauthenticated and must not leak dependency details. + +Checks accumulate, so two independent modules can each register one; they are evaluated in +registration order and the first not-ready verdict wins. + +The check receives the probe request's context, which is canceled when the probe is abandoned — +`readinessProbe.timeoutSeconds` is small, so a slower check is abandoned on every probe. A check +that waits on anything must select on `ctx.Done()` or pass `ctx` down to whatever it calls; +otherwise it leaks a goroutine per probe for the life of the pod. + +##### Requiring GoFr's checks in addition to your own + +This is the default: GoFr's own verdict on every registered datasource and service is evaluated +first, and your check runs only if it passes. Because the check is a closure it can probe +dependencies GoFr never registered — a datasource you opened yourself, a third-party SDK client, an +in-process warm-up flag: + +```go +package main + +import ( + "database/sql" + "errors" + "sync/atomic" + + _ "github.com/lib/pq" // driver for the app-managed datasource below + + "gofr.dev/pkg/gofr" +) + +// cacheWarm is flipped once the in-process cache has been populated. +var cacheWarm atomic.Bool + +var errCacheNotWarm = errors.New("cache not warm") + +func main() { + app := gofr.New() + + // A downstream HTTP dependency — already covered by GoFr's own checks, which gate readiness + // before the check below is called. + app.AddHTTPService("payment", "https://payment.internal") + + // An external datasource the app connects to itself: GoFr's container has no handle on it, + // so readiness can only account for it through a check that captures it. + licenseDB := openLicenseStore(app) + + app.AddReadinessCheck(func(ctx *gofr.Context) error { + if err := licenseDB.PingContext(ctx); err != nil { + return err + } + + if !cacheWarm.Load() { + return errCacheNotWarm + } + + return nil + }) + + app.Run() +} + +// openLicenseStore connects to a datasource the application manages directly, outside GoFr. +func openLicenseStore(app *gofr.App) *sql.DB { + db, err := sql.Open("postgres", app.Config.Get("LICENSE_DB_DSN")) + if err != nil { + app.Logger().Fatalf("license store: %v", err) + } + + return db +} +``` + +##### Replacing GoFr's verdict + +Pass `gofr.ReplaceFrameworkChecks()` and readiness is exactly what your checks say. This is what +readiness that is a *relationship between* dependencies needs, which a conjunction of independently +evaluated checks cannot express. For example, when the service can serve from either backing store: + +```go +app.AddReadinessCheck(func(ctx *gofr.Context) error { + if redisUp(ctx) || sqlUp(ctx) { + return nil + } + + return errNoBackingStore +}, gofr.ReplaceFrameworkChecks()) +``` + +The same shape narrows readiness when only one of several registered datasources is critical: + +```go +app.AddReadinessCheck(func(ctx *gofr.Context) error { + if h := ctx.SQL.HealthCheck(); h == nil || h.Status != "UP" { + return errors.New("postgres not reachable") + } + + return nil +}, gofr.ReplaceFrameworkChecks()) +``` + +The option is a property of readiness as a whole, not of one registration: passing it on any single +`AddReadinessCheck` call turns framework gating off for the endpoint, and GoFr says which mode is in +force at startup rather than leaving it to be inferred from a call site. + +Because GoFr then knows its own checks no longer decide anything, it **skips the datasource sweep +entirely** — a probe costs only what your checks cost. That matters when a dependency is slow or +hanging, which is exactly when the sweep is expensive and the readiness probe earns its keep: +`readinessProbe.timeoutSeconds` is small (the +[Kubernetes guide](/docs/guides/deploying-to-kubernetes) ships `2`), so a check that disclaims those +dependencies should not be timed out by them. + +A check that wants GoFr's verdict as one input among others — tolerating `DEGRADED` during a warm-up +window, or requiring it only when its own dependency is also down — can ask for it explicitly: + +```go +app.AddReadinessCheck(func(ctx *gofr.Context) error { + if err := gofr.FrameworkReadiness(ctx); err != nil && time.Since(started) > warmup { + return err + } + + return nil +}, gofr.ReplaceFrameworkChecks()) +``` + +`gofr.FrameworkReadiness` returns `nil` when every registered datasource and service is up, and +otherwise an error naming the aggregate status only — never the per-dependency detail behind it, so +a check that returns it unchanged still cannot leak anything to the unauthenticated response. It +runs a full datasource sweep, so call it at most once per probe — and never from a default-mode +check, where GoFr has already run that sweep before the check and calling it again roughly doubles +the probe's cost. + +##### What you see at startup and at runtime + +When a check is registered, GoFr says so at startup — including which of the two policies is in +force, so a `503` from this endpoint, or a `200` with a dependency down, is never a surprise about +where the verdict came from: + +``` +INFO readiness: 1 app check(s) registered - framework checks: enabled, evaluated before the app checks +INFO readiness: 2 app check(s) registered - framework checks: replaced by the app checks +``` + +A not-ready result responds `503` with `{"error":{"message":"DOWN"}}`. The reason — the error your +check returned — is logged at `WARN`, not `ERROR`: a `503` here is expected during startup and +rolling deploys, and Kubernetes probes it repeatedly. + +The **request log** is a separate line and is keyed off the status code alone, so it reports every +probe `503` at `ERROR`. During a rolling deploy that is a burst of `ERROR`-level lines for an +expected condition, which a level-keyed alert will pick up. Set `LOG_DISABLE_PROBES=true` to silence +the request log for `/.well-known/health` and `/.well-known/alive`; the `WARN` line carrying the +reason is unaffected. + +##### Readiness does not propagate to GoFr callers + +`AddReadinessCheck` gates the load balancer, and nothing else. When another GoFr application depends +on this one through `AddHTTPService`, its dependency check probes `/.well-known/alive`, not +`/.well-known/health` — so a caller reports this service `UP` even while its readiness check is +answering `503`. + +That is deliberate: `/.well-known/alive` answers immediately, whereas `/.well-known/health` runs the +callee's own dependency sweep, which would make every caller re-run its downstream's sweep and +report as down any downstream slower than the health-check timeout — while it is serving traffic +normally. Readiness is a signal for the orchestrator routing traffic to this pod, not for +application-level dependency checks. + > **Note:** The detailed per-dependency health map is being moved to the metrics server > (`METRICS_PORT`), behind the same network boundary as `/metrics` and `/debug/pprof`. Track that > work in #3806. diff --git a/docs/guides/deploying-to-kubernetes/page.md b/docs/guides/deploying-to-kubernetes/page.md index 182f202321..f8b7f98f4b 100644 --- a/docs/guides/deploying-to-kubernetes/page.md +++ b/docs/guides/deploying-to-kubernetes/page.md @@ -23,7 +23,7 @@ You have a GoFr service already containerized (see {% new-tab-link newtab=false | GoFr feature | Kubernetes object | Notes | |---|---|---| | `/.well-known/alive` | `livenessProbe.httpGet` | Restart unhealthy pods | -| `/.well-known/health` | `readinessProbe.httpGet` | Gate traffic until datasources are reachable | +| `/.well-known/health` | `readinessProbe.httpGet` | Gates traffic only once a [readiness check](/docs/advanced-guide/monitoring-service-health) is registered — by default it always answers `200` | | `OnStart` hooks | `startupProbe` | Long warm-ups (cache fill, migrations) | | Graceful shutdown on SIGTERM | `terminationGracePeriodSeconds` | Drain in-flight requests | | `configs/.env` keys | `ConfigMap` + `envFrom` | Non-secret config | diff --git a/docs/guides/helm-chart-starter/page.md b/docs/guides/helm-chart-starter/page.md index daf9d1c3af..04fcf0b151 100644 --- a/docs/guides/helm-chart-starter/page.md +++ b/docs/guides/helm-chart-starter/page.md @@ -201,7 +201,7 @@ spec: A few choices worth calling out: -- The probe paths are GoFr's built-in endpoints. `/.well-known/alive` is cheap and exempt from auth by default; `/.well-known/health` reflects dependency status in its aggregate and is more truthful for readiness. +- The probe paths are GoFr's built-in endpoints. `/.well-known/alive` is cheap and exempt from auth by default. `/.well-known/health` reports dependency status in its aggregate, but answers `200` either way unless the application registers a [readiness check](/docs/advanced-guide/monitoring-service-health) — until it does, this `readinessProbe` gates nothing. - Env vars `HTTP_PORT`, `GRPC_PORT`, `METRICS_PORT` are set explicitly so the container ports and probe ports always agree with what GoFr actually binds. - The Prometheus scrape annotations point to `metricsPort`. If your platform uses ServiceMonitor/PodMonitor instead, drop the annotations and add a separate template. - `terminationGracePeriodSeconds: 30` gives GoFr's graceful shutdown time to drain in-flight requests. diff --git a/pkg/gofr/gofr.go b/pkg/gofr/gofr.go index d2d4a57b29..ef7051dc63 100644 --- a/pkg/gofr/gofr.go +++ b/pkg/gofr/gofr.go @@ -54,6 +54,11 @@ type App struct { graphqlManager *graphQLManager onStartHooks []func(ctx *Context) error mu sync.Mutex + + // readinessChecks are the application-registered readiness checks for /.well-known/health, + // evaluated in registration order; empty means the endpoint keeps its default behavior. + // Guarded by mu: registration is documented as pre-Run, but probes run concurrently. + readinessChecks []readinessCheck } func (a *App) runOnStartHooks(ctx context.Context) error { @@ -158,7 +163,7 @@ func (a *App) httpServerSetup() { } // Register default routes - these are only added when HTTP server is actually starting - a.add(http.MethodGet, service.HealthPath, healthHandler) + a.add(http.MethodGet, service.HealthPath, a.healthHandler) a.add(http.MethodGet, service.AlivePath, liveHandler) a.add(http.MethodGet, "/favicon.ico", faviconHandler) @@ -176,6 +181,8 @@ func (a *App) httpServerSetup() { a.setupGraphQL() + a.logReadiness() + if a.container.Logger != nil { a.container.Logger.Infof("Registered HTTP server on port: %d", a.httpServer.port) } diff --git a/pkg/gofr/handler_test.go b/pkg/gofr/handler_test.go index cd7f0c238b..37b965ca23 100644 --- a/pkg/gofr/handler_test.go +++ b/pkg/gofr/handler_test.go @@ -263,7 +263,7 @@ func TestHandler_healthHandler(t *testing.T) { ctx := newContext(nil, r, a.container) - h, err := healthHandler(ctx) + h, err := a.healthHandler(ctx) require.NoError(t, err) require.NotNil(t, h) @@ -319,6 +319,313 @@ func TestHandler_aggregateStatus(t *testing.T) { } } +// downstream returns a dependency URL that makes GoFr's own dependency checks report DEGRADED +// (500) or UP (200), so readiness can be exercised against both framework verdicts. +func downstream(t *testing.T, healthy bool) string { + t.Helper() + + code := http.StatusInternalServerError + if healthy { + code = http.StatusOK + } + + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(code) + })) + t.Cleanup(srv.Close) + + return srv.URL +} + +// assertReadiness drives healthHandler and asserts the outcome. wantStatus is the status expected in +// the redacted {name, status} body of a 200; an empty wantStatus expects a not-ready result instead — +// no body and a 503 whose message is only "DOWN", the reason staying in the logs. +func assertReadiness(t *testing.T, a *App, ctx *Context, wantStatus, msg string) { + t.Helper() + + h, err := a.healthHandler(ctx) + + if wantStatus != "" { + require.NoError(t, err, msg) + + resp, ok := h.(healthResponse) + require.True(t, ok, "%s: expected healthResponse, got %T", msg, h) + assert.Equal(t, wantStatus, resp.Status, msg) + + return + } + + require.Nil(t, h, msg) + + var sc interface{ StatusCode() int } + + require.ErrorAs(t, err, &sc, msg) + assert.Equal(t, http.StatusServiceUnavailable, sc.StatusCode(), msg) + assert.Equal(t, statusDown, err.Error(), msg) +} + +// errCheck is the failure a registered readiness check reports in these tests. +var errCheck = errors.New("dependency unavailable") + +// readinessApp returns an app with one registered dependency, healthy or not, together with a +// context to drive healthHandler with — so readiness is exercised against a real framework verdict. +func readinessApp(t *testing.T, depHealthy bool) (*App, *Context) { + t.Helper() + + testutil.NewServerConfigs(t) + + a := New() + a.AddHTTPService("test-service", downstream(t, depHealthy)) + + req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "", http.NoBody) + + return a, newContext(nil, gofrHTTP.NewRequest(req), a.container) +} + +// check returns a readiness check that always reports err. +func check(err error) ReadinessCheck { + return func(*Context) error { return err } +} + +func TestApp_AddReadinessCheck(t *testing.T) { + tests := []struct { + desc string + depHealthy bool + register func(a *App) + // wantStatus is the status reported with a 200; empty means a not-ready 503 is expected. + wantStatus string + }{ + {"no check registered still answers 200 with the aggregate", false, nil, "DEGRADED"}, + {"a nil check is ignored", false, func(a *App) { a.AddReadinessCheck(nil) }, "DEGRADED"}, + { + "default check is ready when both sides pass", true, + func(a *App) { a.AddReadinessCheck(check(nil)) }, statusUp, + }, + { + "default check fails on the framework verdict", false, + func(a *App) { a.AddReadinessCheck(check(nil)) }, "", + }, + { + "default check fails on its own verdict", true, + func(a *App) { a.AddReadinessCheck(check(errCheck)) }, "", + }, + { + "replacing check ignores a degraded framework", false, + func(a *App) { a.AddReadinessCheck(check(nil), ReplaceFrameworkChecks()) }, statusUp, + }, + { + "replacing check still gates readiness", true, + func(a *App) { a.AddReadinessCheck(check(errCheck), ReplaceFrameworkChecks()) }, "", + }, + { + "checks accumulate - all must pass", true, + func(a *App) { a.AddReadinessCheck(check(nil)); a.AddReadinessCheck(check(nil)) }, statusUp, + }, + { + "checks accumulate - the second is not lost", true, + func(a *App) { a.AddReadinessCheck(check(nil)); a.AddReadinessCheck(check(errCheck)) }, "", + }, + { + "a nil check drops its options too, rather than half-applying a bug", false, + func(a *App) { + a.AddReadinessCheck(nil, ReplaceFrameworkChecks()) + a.AddReadinessCheck(check(nil)) + }, + "", + }, + { + "a nil check with options still leaves the default behavior", false, + func(a *App) { a.AddReadinessCheck(nil, ReplaceFrameworkChecks()) }, "DEGRADED", + }, + { + "the option on any one registration replaces the framework checks", false, + func(a *App) { + a.AddReadinessCheck(check(nil)) + a.AddReadinessCheck(check(nil), ReplaceFrameworkChecks()) + }, + statusUp, + }, + } + + for i, tc := range tests { + a, ctx := readinessApp(t, tc.depHealthy) + + if tc.register != nil { + tc.register(a) + } + + assertReadiness(t, a, ctx, tc.wantStatus, fmt.Sprintf("TEST[%d], Failed.\n%s", i, tc.desc)) + } +} + +// TestApp_healthHandler_logsReason pins the only record of why a probe failed: the response body is +// deliberately just "DOWN", so if this line regresses an operator has a 503 and no reason anywhere. +func TestApp_healthHandler_logsReason(t *testing.T) { + logs := testutil.StdoutOutputForFunc(func() { + a, ctx := readinessApp(t, true) + a.AddReadinessCheck(check(errCheck), ReplaceFrameworkChecks()) + + _, err := a.healthHandler(ctx) + require.Error(t, err) + }) + + assert.Contains(t, logs, "readiness: not ready") + assert.Contains(t, logs, errCheck.Error()) +} + +// TestApp_AddReadinessCheck_nilIsLogged pins that a dropped registration is reported: a nil check is +// a programming error, and dropping it silently is what made the option-carrying case ambiguous. +func TestApp_AddReadinessCheck_nilIsLogged(t *testing.T) { + logs := testutil.StderrOutputForFunc(func() { + testutil.NewServerConfigs(t) + + a := New() + a.AddReadinessCheck(nil, ReplaceFrameworkChecks()) + }) + + assert.Contains(t, logs, "invalid readiness check") +} + +// TestApp_healthHandler_evaluationOrder pins that GoFr's own checks are evaluated before the +// application's, which is only observable in which reason reaches the log when both sides fail. +func TestApp_healthHandler_evaluationOrder(t *testing.T) { + logs := testutil.StdoutOutputForFunc(func() { + a, ctx := readinessApp(t, false) + a.AddReadinessCheck(check(errCheck)) + + _, err := a.healthHandler(ctx) + require.Error(t, err) + }) + + assert.Contains(t, logs, errFrameworkChecks.Error()) + assert.NotContains(t, logs, errCheck.Error()) +} + +// TestApp_errNotReady pins what a not-ready result reports: only "DOWN", a 503, and WARN — the +// level #3857 asked for, since a 503 here is expected during startup and rolling deploys. +func TestApp_errNotReady(t *testing.T) { + assert.Equal(t, statusDown, errNotReady{}.Error()) + assert.Equal(t, http.StatusServiceUnavailable, errNotReady{}.StatusCode()) + assert.Equal(t, logging.WARN, errNotReady{}.LogLevel()) +} + +func TestApp_FrameworkReadiness(t *testing.T) { + tests := []struct { + desc string + depHealthy bool + wantErr bool + }{ + {"all dependencies healthy", true, false}, + {"a dependency down", false, true}, + } + + for i, tc := range tests { + _, ctx := readinessApp(t, tc.depHealthy) + + err := FrameworkReadiness(ctx) + + if !tc.wantErr { + require.NoError(t, err, "TEST[%d], Failed.\n%s", i, tc.desc) + continue + } + + require.ErrorIs(t, err, errFrameworkChecks, "TEST[%d], Failed.\n%s", i, tc.desc) + // The aggregate status may be reported, but never the per-dependency detail behind it. + assert.Contains(t, err.Error(), "DEGRADED", "TEST[%d], Failed.\n%s", i, tc.desc) + } +} + +func TestApp_logReadiness(t *testing.T) { + tests := []struct { + desc string + register func(a *App) + want string + }{ + {"nothing logged without an app check", nil, ""}, + { + "the default mode says the framework checks still gate", + func(a *App) { a.AddReadinessCheck(check(nil)) }, + "readiness: 1 app check(s) registered - framework checks: enabled", + }, + { + "the replacing mode says so, rather than being inferred from a call site", + func(a *App) { + a.AddReadinessCheck(check(nil)) + a.AddReadinessCheck(check(nil), ReplaceFrameworkChecks()) + }, + "readiness: 2 app check(s) registered - framework checks: replaced by the app checks", + }, + } + + for i, tc := range tests { + logs := testutil.StdoutOutputForFunc(func() { + testutil.NewServerConfigs(t) + + a := New() + if tc.register != nil { + tc.register(a) + } + + a.logReadiness() + }) + + if tc.want == "" { + assert.NotContains(t, logs, "readiness:", "TEST[%d], Failed.\n%s", i, tc.desc) + continue + } + + assert.Contains(t, logs, tc.want, "TEST[%d], Failed.\n%s", i, tc.desc) + } +} + +// TestApp_AddReadinessCheck_concurrent registers checks while probes and the startup announcement +// are in flight. Registration is documented as pre-Run, but nothing enforces it — httpServerSetup +// runs on whichever goroutine called Run — and the endpoint is probed at Kubernetes frequency, so +// the field is guarded on every path: this fails under -race if any of those guards is dropped. +func TestApp_AddReadinessCheck_concurrent(t *testing.T) { + a, ctx := readinessApp(t, true) + + var wg sync.WaitGroup + + for range 10 { + wg.Add(3) + + go func() { + defer wg.Done() + + a.AddReadinessCheck(check(nil)) + }() + + go func() { + defer wg.Done() + + _, _ = a.healthHandler(ctx) + }() + + go func() { + defer wg.Done() + + a.logReadiness() + }() + } + + wg.Wait() +} + +// TestApp_httpServerSetup_logsReadiness tests the wiring, not the function: TestApp_logReadiness +// calls the method directly, so it stays green if the call is dropped from httpServerSetup. +func TestApp_httpServerSetup_logsReadiness(t *testing.T) { + logs := testutil.StdoutOutputForFunc(func() { + testutil.NewServerConfigs(t) + + a := New() + a.AddReadinessCheck(check(nil)) + a.httpServerSetup() + }) + + assert.Contains(t, logs, "readiness: 1 app check(s) registered") +} + func TestHandler_ServeHTTP_ContextCanceled(t *testing.T) { w := httptest.NewRecorder() r := httptest.NewRequest(http.MethodGet, "/", http.NoBody) diff --git a/pkg/gofr/health.go b/pkg/gofr/health.go index 257ec32c70..91be895d2b 100644 --- a/pkg/gofr/health.go +++ b/pkg/gofr/health.go @@ -1,5 +1,107 @@ package gofr +import ( + "errors" + "fmt" + "net/http" + + "gofr.dev/pkg/gofr/logging" +) + +const ( + statusUp = "UP" + statusDown = "DOWN" +) + +// ReadinessCheck decides whether the application is ready to serve traffic, for the public, +// unauthenticated /.well-known/health endpoint. It receives the request context, which carries the +// container, so datasources such as ctx.Redis or ctx.SQL can be probed. +// +// That context is the probe request's, and is canceled when the probe is abandoned — the +// Kubernetes guide ships readinessProbe.timeoutSeconds: 2, so a slower check is abandoned on every +// probe. A check that waits on anything must select on ctx.Done() or pass ctx down, or it leaks a +// goroutine per probe for the life of the pod. +// +// Returning nil means ready; returning any error means not ready, and the endpoint answers 503 so a +// Kubernetes readiness probe keeps the pod out of service. The returned error is logged but never +// written to the response: the endpoint is unauthenticated and must not leak dependency details. +type ReadinessCheck func(ctx *Context) error + +// ReadinessOption configures how a readiness check registered with AddReadinessCheck is evaluated. +type ReadinessOption func(*readinessCheck) + +// readinessCheck is one registered check together with how it was registered. +type readinessCheck struct { + check ReadinessCheck + + // replaceFramework records that this check was registered with ReplaceFrameworkChecks, so + // GoFr's own dependency checks no longer gate readiness — and, since they no longer decide + // anything, are not run at all. + replaceFramework bool +} + +// ReplaceFrameworkChecks makes the checks registered with it the whole readiness verdict: GoFr's own +// dependency checks stop gating the endpoint, and the datasource sweep behind them is skipped +// entirely, so a probe costs only what the application's checks cost. +// +// Use it when readiness is a relationship between dependencies rather than a conjunction of them — +// "ready if either backing store is up" — or when only some of the registered datasources are +// critical. A check that still wants GoFr's verdict as one input among others can call +// FrameworkReadiness itself. +// +// It is a property of readiness as a whole, not of a single registration: passing it on any one +// AddReadinessCheck call turns framework gating off for the endpoint. GoFr says which mode is in +// force at startup, so this is never inferred from a call site nobody has read. +func ReplaceFrameworkChecks() ReadinessOption { + return func(r *readinessCheck) { r.replaceFramework = true } +} + +// AddReadinessCheck registers a readiness check for /.well-known/health. Without one the endpoint +// behaves exactly as before — HTTP 200 with the aggregate {name, status}, DEGRADED included, since +// which dependencies are critical is an application decision. +// +// By default the check is AND-ed with GoFr's own dependency checks, which are evaluated first: +// +// app.AddReadinessCheck(func(ctx *gofr.Context) error { +// return licenseDB.PingContext(ctx) +// }) +// +// Pass ReplaceFrameworkChecks to make the application's checks the whole verdict: +// +// app.AddReadinessCheck(func(ctx *gofr.Context) error { +// if redisUp(ctx) || sqlUp(ctx) { +// return nil +// } +// +// return errNoBackingStore +// }, gofr.ReplaceFrameworkChecks()) +// +// Checks accumulate — two independent modules can each register one — and are evaluated in +// registration order, stopping at the first that reports not ready. Register before App.Run. +// +// A nil check is a programming error, so the whole registration is dropped and logged rather than +// half-applied: keeping its options would let ReplaceFrameworkChecks — a property of readiness as a +// whole — turn framework gating off for every other module's check on the strength of a bug. +func (a *App) AddReadinessCheck(check ReadinessCheck, opts ...ReadinessOption) { + if check == nil { + if a.container != nil && a.container.Logger != nil { + a.container.Errorf("invalid readiness check: check must not be nil - registration ignored") + } + + return + } + + r := readinessCheck{check: check} + for _, opt := range opts { + opt(&r) + } + + a.mu.Lock() + defer a.mu.Unlock() + + a.readinessChecks = append(a.readinessChecks, r) +} + // healthResponse is the minimal, non-sensitive body returned by /.well-known/health. It carries // only the application name and the aggregate status — never per-dependency inventory. type healthResponse struct { @@ -7,13 +109,124 @@ type healthResponse struct { Status string `json:"status"` } +// errNotReady is the only thing a failed readiness reports to the caller: the status string and a +// 503. The reason — which check failed and why — goes to the logs, never to this unauthenticated +// endpoint. +type errNotReady struct{} + +func (errNotReady) Error() string { return statusDown } +func (errNotReady) StatusCode() int { return http.StatusServiceUnavailable } + +// LogLevel keeps a not-ready readiness at WARN rather than ERROR. A 503 is expected during startup +// and rolling deploys — Kubernetes probes it repeatedly — so it should not flood logs as an error. +// +// This governs the handler's own log line. The request log written by the logging middleware is +// keyed off the status code alone, so it still reports a probe 503 at ERROR; LOG_DISABLE_PROBES=true +// silences the request log for the probe paths. +func (errNotReady) LogLevel() logging.Level { return logging.WARN } + +var _ logging.LogLevelResponder = errNotReady{} + +// errFrameworkChecks marks a not-ready result that came from GoFr's own dependency checks rather +// than from an application check, so the log line says which side failed. +var errFrameworkChecks = errors.New("framework dependency checks") + // healthHandler serves the public, unauthenticated /.well-known/health endpoint. It reports only // the application name and aggregate status — no hosts, ports, credentials, or connection stats. -// No HTTP route serves the full detailed map after this change; Container.Health still computes it -// for in-process ops tooling, and #3806 tracks exposing it on the metrics server (METRICS_PORT), -// behind the same network boundary as /metrics and /debug/pprof. -func healthHandler(c *Context) (any, error) { - return healthResponse{Name: c.GetAppName(), Status: aggregateStatus(c)}, nil +// No HTTP route serves the full detailed map; Container.Health still computes it for in-process ops +// tooling, and #3806 tracks exposing it on the metrics server (METRICS_PORT), behind the same +// network boundary as /metrics and /debug/pprof. +func (a *App) healthHandler(c *Context) (any, error) { + a.mu.Lock() + checks := a.readinessChecks + a.mu.Unlock() + + // Default behavior, unchanged: with no application check registered the endpoint reports the + // aggregate dependency status with a 200 — DEGRADED is informational, not a readiness verdict. + if len(checks) == 0 { + return healthResponse{Name: c.GetAppName(), Status: aggregateStatus(c)}, nil + } + + if err := runReadinessChecks(c, checks); err != nil { + c.Warnf("readiness: not ready: %v", err) + + return nil, errNotReady{} + } + + return healthResponse{Name: c.GetAppName(), Status: statusUp}, nil +} + +// runReadinessChecks evaluates GoFr's own dependency checks — unless they have been replaced — and +// then every registered application check in order, stopping at the first not-ready verdict. +func runReadinessChecks(c *Context, checks []readinessCheck) error { + if !frameworkReplaced(checks) { + if err := FrameworkReadiness(c); err != nil { + return err + } + } + + for _, r := range checks { + if err := r.check(c); err != nil { + return err + } + } + + return nil +} + +// frameworkReplaced reports whether any registration disclaimed GoFr's dependency checks. +func frameworkReplaced(checks []readinessCheck) bool { + for _, r := range checks { + if r.replaceFramework { + return true + } + } + + return false +} + +// FrameworkReadiness renders GoFr's own dependency checks as an error: nil when every registered +// datasource and service is up, and otherwise an error naming the aggregate status — never the +// per-dependency detail behind it, which must not reach the unauthenticated response even by way of +// a check that returns this error unchanged. +// +// A default check never needs it: GoFr evaluates it before the check runs, so calling it there is a +// second full sweep and roughly doubles the probe's cost. It is for a check registered with +// ReplaceFrameworkChecks that wants the framework's verdict as one input among others rather than +// as an unconditional gate — tolerating DEGRADED during a warm-up window, say, or requiring it only +// when the application's own dependency is also down. Calling it runs a full datasource sweep, so +// call it once per probe. +// +// It is a function rather than a method on Container because Context embeds *container.Container: a +// method would be promoted onto every handler's ctx, where it would sweep every datasource in the +// hot path. +func FrameworkReadiness(c *Context) error { + if status := aggregateStatus(c); status != statusUp { + return fmt.Errorf("%w: reported %s", errFrameworkChecks, status) + } + + return nil +} + +// logReadiness states at startup that readiness is no longer the default, and which of the two +// policies is in force, so a 503 from this endpoint — or a 200 with a dependency down — is never a +// surprise about where the verdict came from. +func (a *App) logReadiness() { + a.mu.Lock() + checks := a.readinessChecks + a.mu.Unlock() + + if a.container.Logger == nil || len(checks) == 0 { + return + } + + mode := "enabled, evaluated before the app checks" + if frameworkReplaced(checks) { + mode = "replaced by the app checks" + } + + a.container.Logger.Infof("readiness: %d app check(s) registered - framework checks: %s", + len(checks), mode) } // aggregateStatus runs the full health check and keeps only the overall status, discarding every @@ -26,8 +239,6 @@ func healthHandler(c *Context) (any, error) { // per-request call sweeps every datasource unless HEALTH_CACHE_TTL is set, which it is not by // default. func aggregateStatus(c *Context) string { - const statusDown = "DOWN" - m, ok := c.Health(c).(map[string]any) if !ok { return statusDown From 6f104ebfd88c9d5b6a3bdccc9cbce281f7171ce8 Mon Sep 17 00:00:00 2001 From: Piyush Singh Date: Thu, 10 Sep 2026 16:53:34 +0530 Subject: [PATCH 34/48] ci(website-stage): move stage build and deploy to asia-south1 zopdev-tech (#4199) Co-authored-by: Aryan Mehrotra --- .github/workflows/website-stage.yml | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/.github/workflows/website-stage.yml b/.github/workflows/website-stage.yml index c49c459193..d9847e0b72 100644 --- a/.github/workflows/website-stage.yml +++ b/.github/workflows/website-stage.yml @@ -22,8 +22,9 @@ env: APP_NAME: gofr-website WEBSITE_REGISTRY: ghcr.io GAR_PROJECT: raramuri-tech - GAR_REGISTRY: kops-dev - CLUSTER_NAME: raramuri-tech + GAR_REGISTRY: zopdev + CLUSTER_NAME: zopdev-tech + CLUSTER_REGION: asia-south1 CLUSTER_PROJECT: raramuri-tech NAMESPACE: gofr-dev NAMESPACE_STAGE: gofr-dev-stg @@ -86,7 +87,7 @@ jobs: - name: Login to GAR uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0 with: - registry: us-central1-docker.pkg.dev + registry: asia-south1-docker.pkg.dev username: _json_key password: ${{ secrets.GOFR_WEBSITE_GOFR_DEV_STG_DEPLOYMENT_KEY }} @@ -129,15 +130,15 @@ jobs: run: | docker build \ --build-arg WEBSITE_TAG=stage \ - -t us-central1-docker.pkg.dev/${{ env.GAR_PROJECT }}/${{ env.GAR_REGISTRY }}/${{ env.APP_NAME }}:${{ env.TAG }} \ + -t asia-south1-docker.pkg.dev/${{ env.GAR_PROJECT }}/${{ env.GAR_REGISTRY }}/${{ env.APP_NAME }}:${{ env.TAG }} \ -f ./docs/Dockerfile \ . - name: Push framework docs image to GAR - run: docker push us-central1-docker.pkg.dev/${{ env.GAR_PROJECT }}/${{ env.GAR_REGISTRY }}/${{ env.APP_NAME }}:${{ env.TAG }} + run: docker push asia-south1-docker.pkg.dev/${{ env.GAR_PROJECT }}/${{ env.GAR_REGISTRY }}/${{ env.APP_NAME }}:${{ env.TAG }} - id: output-image - run: echo "image=`echo us-central1-docker.pkg.dev/${{ env.GAR_PROJECT }}/${{ env.GAR_REGISTRY }}/${{ env.APP_NAME }}:${{ env.TAG }}`" >> "$GITHUB_OUTPUT" + run: echo "image=`echo asia-south1-docker.pkg.dev/${{ env.GAR_PROJECT }}/${{ env.GAR_REGISTRY }}/${{ env.APP_NAME }}:${{ env.TAG }}`" >> "$GITHUB_OUTPUT" deployment_stage: runs-on: ubuntu-latest @@ -160,7 +161,7 @@ jobs: credentials_json: ${{ secrets.GOFR_WEBSITE_GOFR_DEV_STG_DEPLOYMENT_KEY }} - name: Set GCloud Project and Fetch Cluster Credentials - run: gcloud container clusters get-credentials ${{ env.CLUSTER_NAME }} --region=us-central1 --project=${{ env.CLUSTER_PROJECT }} + run: gcloud container clusters get-credentials ${{ env.CLUSTER_NAME }} --region=${{ env.CLUSTER_REGION }} --project=${{ env.CLUSTER_PROJECT }} - name: Update Deployment Image run: kubectl set image deployment/${{ env.APP_NAME }} ${{ env.APP_NAME }}=${{ env.image }} --namespace ${{ env.NAMESPACE_STAGE }} From 7d17930fe32dd68c5eebc29279dc2ad7458b5d44 Mon Sep 17 00:00:00 2001 From: Umang Mundhra Date: Thu, 10 Sep 2026 17:24:10 +0530 Subject: [PATCH 35/48] chore(deps): bump zopdev/static-server v0.0.9 -> v1.0.0 in (#4050) Major version bump (v0 -> v1) of the docs static-server base image. Consolidated from Dependabot #3990. Closes: #3990 Co-authored-by: Aryan Mehrotra --- docs/Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/Dockerfile b/docs/Dockerfile index 67b2bc27fc..40f1fd8164 100644 --- a/docs/Dockerfile +++ b/docs/Dockerfile @@ -49,7 +49,7 @@ RUN npm install RUN npm run build # Stage 2: Serve with Static Server -FROM zopdev/static-server:v0.0.9 +FROM zopdev/static-server:v1.0.0 # Copy static files from the builder stage COPY --from=builder /app/out static From db0a267a0724a97c6bc2ed19ea158f3ff94e3e90 Mon Sep 17 00:00:00 2001 From: Gajendra Malviya Date: Thu, 10 Sep 2026 17:44:25 +0530 Subject: [PATCH 36/48] Add HTTP QUERY Method Support (RFC 10008) (#3760) --- .../advanced-guide/http-communication/page.md | 10 +- docs/advanced-guide/mcp/page.md | 10 +- docs/quick-start/introduction/page.md | 2 + examples/http-server/main.go | 53 +++++ examples/http-server/main_test.go | 60 ++++++ pkg/gofr/gofr_test.go | 155 +++++++++++++++ pkg/gofr/http/errors.go | 25 +++ pkg/gofr/http/middleware/cors.go | 8 + pkg/gofr/http/middleware/routecache.go | 4 +- pkg/gofr/http/middleware/tracer_test.go | 32 +++ pkg/gofr/http/request.go | 157 +++++++++++---- pkg/gofr/http/request_test.go | 88 +++++++++ pkg/gofr/http/responder.go | 12 +- pkg/gofr/http/responder_test.go | 41 ++++ pkg/gofr/mcp.go | 10 +- pkg/gofr/mcp_test.go | 69 +++++++ pkg/gofr/rest.go | 86 +++++++- pkg/gofr/rest_test.go | 115 +++++++++++ pkg/gofr/service/auth.go | 15 ++ pkg/gofr/service/auth_test.go | 6 +- pkg/gofr/service/circuit_breaker.go | 27 +++ pkg/gofr/service/circuit_breaker_test.go | 185 ++++++++++++++++++ pkg/gofr/service/custom_header.go | 12 ++ pkg/gofr/service/custom_header_test.go | 29 +++ pkg/gofr/service/file_token_auth.go | 15 ++ pkg/gofr/service/file_token_auth_test.go | 1 + pkg/gofr/service/mock_http_service.go | 60 ++++++ pkg/gofr/service/new.go | 27 +++ pkg/gofr/service/new_test.go | 73 +++++++ pkg/gofr/service/rate_limiter.go | 26 +++ pkg/gofr/service/rate_limiter_test.go | 30 +++ pkg/gofr/service/retry.go | 14 ++ pkg/gofr/service/retry_test.go | 38 ++++ pkg/gofr/tools.go | 80 ++++++-- 34 files changed, 1514 insertions(+), 61 deletions(-) create mode 100644 pkg/gofr/rest_test.go diff --git a/docs/advanced-guide/http-communication/page.md b/docs/advanced-guide/http-communication/page.md index d57e2ac4a5..6db2208821 100644 --- a/docs/advanced-guide/http-communication/page.md +++ b/docs/advanced-guide/http-communication/page.md @@ -12,7 +12,7 @@ GoFr promotes microservice architecture and to facilitate the same, it provides at application level using `AddHTTPService()` method. Support for inter-service HTTP calls provide the following benefits: -1. Access to the methods from container - GET, PUT, POST, PATCH, DELETE. +1. Access to the methods from container - GET, PUT, POST, PATCH, DELETE, QUERY. 2. Logs and traces for the request. 3. {% new-tab-link newtab=false title="Circuit breaking" href="/docs/advanced-guide/circuit-breaker" /%} for enhanced resilience and fault tolerance. 4. {% new-tab-link newtab=false title="Custom Health Check" href="/docs/advanced-guide/monitoring-service-health" /%} Endpoints @@ -83,6 +83,8 @@ The HTTP service client provides methods for making requests to downstream servi - `Delete(ctx, path, body)` +- `Query(ctx, path, queryParams, body)` + **For scenarios requiring custom header propagation (authentication, multi-tenancy, user identity propagation), use the `WithHeaders` variants:** - `GetWithHeaders(ctx, path, queryParams, headers)` @@ -95,6 +97,12 @@ The HTTP service client provides methods for making requests to downstream servi - `DeleteWithHeaders(ctx, path, body, headers)` +- `QueryWithHeaders(ctx, path, queryParams, body, headers)` + +> **QUERY** (RFC 10008) is a safe, idempotent method that carries the query in the +> request body — bridging the gap between GET (no body) and POST (not safe/idempotent). +> Like GET, QUERY calls are wrapped by the circuit-breaker and retry options when configured. + ```go func Customer(ctx *gofr.Context) (any, error) { // Get the payment service client diff --git a/docs/advanced-guide/mcp/page.md b/docs/advanced-guide/mcp/page.md index e9904f8c63..fec4543474 100644 --- a/docs/advanced-guide/mcp/page.md +++ b/docs/advanced-guide/mcp/page.md @@ -40,12 +40,14 @@ route and the remaining arguments become query values. ### Read-only -Only safe-to-retry handlers (`GET`, `HEAD`, `OPTIONS`) are exposed as tools. Write handlers -(`POST`/`PUT`/`PATCH`/`DELETE`) are never exposed, so an agent cannot mutate state through this -surface. +Only safe, non-mutating handlers are exposed as tools: the read-only methods (`GET`, `HEAD`, +`OPTIONS`) and `QUERY` ([RFC 10008](https://www.rfc-editor.org/rfc/rfc10008.html)), which is safe and +idempotent and carries its input in the request body. A `QUERY` tool therefore takes a required `body` +argument alongside any path parameters. Write handlers (`POST`/`PUT`/`PATCH`/`DELETE`) are never +exposed, so an agent cannot mutate state through this surface. Drop specific routes with `gofr.WithExcludedRoutes("/internal/{id}")`. Framework `/.well-known/*` probes are -never exposed. The read-only rule is enforced at call time, not just in the tool listing — a write +never exposed. The safe-method rule is enforced at call time, not just in the tool listing — a write route cannot be invoked by guessing its tool name. ### Safety diff --git a/docs/quick-start/introduction/page.md b/docs/quick-start/introduction/page.md index e1c6b317fd..cbdbaeb5c0 100644 --- a/docs/quick-start/introduction/page.md +++ b/docs/quick-start/introduction/page.md @@ -88,6 +88,8 @@ The `hello-world` server involves three essential steps: In this step, the server is instructed to associate an HTTP request with a specific handler function. This is achieved through `app.GET("/greet", HandlerFunction)`, where _GET /greet_ maps to HandlerFunction. Likewise, `app.POST("/todo", ToDoCreationHandler)` links a _POST_ request to the `/todo` endpoint with _ToDoCreationHandler_. + The full set of verbs is `app.GET`, `app.POST`, `app.PUT`, `app.PATCH`, `app.DELETE`, and `app.QUERY`. `QUERY` is the HTTP QUERY method (RFC 10008) — a safe, idempotent verb whose search criteria live in the request body; a `QUERY` request MUST carry a `Content-Type` GoFr can decode (`application/json`, form, multipart, or octet-stream), and GoFr rejects a missing one with 400 and an unsupported one with 415 before your handler runs. + **Good To Know** > In Go, functions are first-class citizens, allowing easy handler definition and reference. diff --git a/examples/http-server/main.go b/examples/http-server/main.go index 65868b83a6..49f1f8c1e9 100644 --- a/examples/http-server/main.go +++ b/examples/http-server/main.go @@ -28,6 +28,14 @@ func main() { a.GET("/trace", TraceHandler) a.GET("/mysql", MysqlHandler) + // QUERY (RFC 10008): a safe, idempotent method that carries the query in the + // request body. Read the body via ctx.Bind, the same as a POST. + a.QUERY("/search", SearchHandler) + + // Outbound QUERY: same method available on the HTTP service client. Mirrors + // GET/POST/etc. — takes a body and returns the raw response for you to decode. + a.GET("/proxy-search", ProxySearchHandler) + // Run the application a.Run() } @@ -46,6 +54,51 @@ func ErrorHandler(c *gofr.Context) (any, error) { return nil, errors.New("some error occurred") } +// SearchHandler demonstrates the HTTP QUERY method: the search criteria arrive in +// the request body and are echoed back as the query result. +func SearchHandler(c *gofr.Context) (any, error) { + criteria := struct { + Filter string `json:"filter"` + }{} + + if err := c.Bind(&criteria); err != nil { + return nil, err + } + + return map[string]string{"matched": criteria.Filter}, nil +} + +// ProxySearchHandler demonstrates the outbound HTTP QUERY method: it forwards +// a filter to the downstream `anotherService` at `/search` via svc.Query and +// returns whatever the downstream matched. Mirrors the inbound SearchHandler +// on the other side of the wire. +func ProxySearchHandler(c *gofr.Context) (any, error) { + body := []byte(`{"filter":"golang"}`) + + resp, err := c.GetHTTPService("anotherService"). + QueryWithHeaders(c, "search", nil, body, map[string]string{"Content-Type": "application/json"}) + if err != nil { + return nil, err + } + + defer resp.Body.Close() + + var out struct { + Data map[string]string `json:"data"` + } + + b, err := io.ReadAll(resp.Body) + if err != nil { + return nil, err + } + + if err := json.Unmarshal(b, &out); err != nil { + return nil, err + } + + return out.Data, nil +} + func RedisHandler(c *gofr.Context) (any, error) { val, err := c.Redis.Get(c, "test").Result() if err != nil && err != redis.Nil { // If key is not found, we are not considering this an error and returning "". diff --git a/examples/http-server/main_test.go b/examples/http-server/main_test.go index 796fa38d8b..4fa963087e 100644 --- a/examples/http-server/main_test.go +++ b/examples/http-server/main_test.go @@ -95,6 +95,38 @@ func TestIntegration_SimpleAPIServer(t *testing.T) { } } +func TestIntegration_QueryHandler(t *testing.T) { + httpPort := testutil.GetFreePort(t) + port := testutil.GetFreePort(t) + + t.Setenv("HTTP_PORT", strconv.Itoa(httpPort)) + t.Setenv("METRICS_PORT", strconv.Itoa(port)) + + host := fmt.Sprintf("http://localhost:%d", httpPort) + + go main() + testutil.WaitForHTTPServer(t, host) + + req, _ := http.NewRequestWithContext(t.Context(), gofr.MethodQuery, host+"/search", strings.NewReader(`{"filter":"golang"}`)) + req.Header.Set("content-type", "application/json") + + resp, err := http.DefaultClient.Do(req) + require.NoError(t, err) + + defer resp.Body.Close() + + assert.Equal(t, http.StatusOK, resp.StatusCode) + + b, err := io.ReadAll(resp.Body) + require.NoError(t, err) + + data := struct { + Data map[string]string `json:"data"` + }{} + require.NoError(t, json.Unmarshal(b, &data)) + assert.Equal(t, "golang", data.Data["matched"]) +} + func TestIntegration_SimpleAPIServer_Errors(t *testing.T) { httpPort := testutil.GetFreePort(t) port := testutil.GetFreePort(t) @@ -338,6 +370,34 @@ func TestMysqlHandler(t *testing.T) { assert.Equal(t, 4, resp) } +func TestProxySearchHandler(t *testing.T) { + // Exercises the outbound HTTP QUERY path: ProxySearchHandler calls + // c.GetHTTPService("anotherService").QueryWithHeaders(...), so the assertion + // pins that the downstream is invoked with method QUERY (via the mock's + // QueryWithHeaders binding), the "search" path, no query params, the JSON + // body the handler emits, and Content-Type: application/json. + mockContainer, mocks := container.NewMockContainer(t, container.WithMockHTTPService("anotherService")) + + ctx := createTestContext(http.MethodGet, "/proxy-search", mockContainer) + + mockResp := &http.Response{ + StatusCode: http.StatusOK, + Body: io.NopCloser(strings.NewReader(`{"data":{"matched":"golang"}}`)), + } + + mocks.HTTPServices["anotherService"].EXPECT().QueryWithHeaders( + gomock.Any(), + "search", + nil, + []byte(`{"filter":"golang"}`), + map[string]string{"Content-Type": "application/json"}, + ).Return(mockResp, nil) + + resp, err := ProxySearchHandler(ctx) + require.NoError(t, err) + assert.Equal(t, map[string]string{"matched": "golang"}, resp) +} + func TestTraceHandler(t *testing.T) { // Register HTTP service - each service gets its own separate mock instance mockContainer, mocks := container.NewMockContainer(t, container.WithMockHTTPService("anotherService")) diff --git a/pkg/gofr/gofr_test.go b/pkg/gofr/gofr_test.go index 23d0a8de37..17f3b2f174 100644 --- a/pkg/gofr/gofr_test.go +++ b/pkg/gofr/gofr_test.go @@ -12,6 +12,7 @@ import ( "os" "path/filepath" "strconv" + "strings" "sync" "testing" "time" @@ -1965,3 +1966,157 @@ func Test_HTTPMethods(t *testing.T) { }) } } + +// Test_QUERY_Registration verifies that app.QUERY registers a route for the HTTP +// QUERY method (RFC 10008) and that the handler can read the request body via Bind. +func Test_QUERY_Registration(t *testing.T) { + port := testutil.GetFreePort(t) + + c := container.NewContainer(config.NewMockConfig(nil)) + + app := &App{ + httpServer: &httpServer{ + router: gofrHTTP.NewRouter(), + port: port, + }, + container: c, + Config: config.NewMockConfig(map[string]string{ + "REQUEST_TIMEOUT": "5", + "SHUTDOWN_GRACE_PERIOD": "1s", + }), + } + + app.QUERY("/search", func(ctx *Context) (any, error) { + body := struct { + Filter string `json:"filter"` + }{} + if err := ctx.Bind(&body); err != nil { + return nil, err + } + + return map[string]string{"filter": body.Filter}, nil + }) + + go app.Run() + + testutil.WaitForHTTPServer(t, fmt.Sprintf("http://localhost:%d", port)) + + netClient := &http.Client{Timeout: 500 * time.Millisecond} + + req, _ := http.NewRequestWithContext(t.Context(), "QUERY", + fmt.Sprintf("http://localhost:%d/search", port), strings.NewReader(`{"filter":"title"}`)) + req.Header.Set("Content-Type", "application/json") + + resp, err := netClient.Do(req) + require.NoError(t, err) + + defer resp.Body.Close() + + assert.Equal(t, http.StatusOK, resp.StatusCode) + + respBody, err := io.ReadAll(resp.Body) + require.NoError(t, err) + assert.Contains(t, string(respBody), `"filter":"title"`) +} + +// TestQueryContentTypeGuardWiring pins that the RFC 10008 Content-Type guard is +// actually wired to registered QUERY routes and not to the router's catch-all. +// Removing the `if method == MethodQuery` block in rest.go would make all three +// sub-tests fail — the 200 path proves the guard passes a valid request, the +// rejection paths prove it runs before the handler, and the 404 path proves it +// does NOT run for unregistered paths (so a QUERY to an unknown route gets 404, +// not a spurious 400 or 415). +func TestQueryContentTypeGuardWiring(t *testing.T) { + port := testutil.GetFreePort(t) + + c := container.NewContainer(config.NewMockConfig(nil)) + + app := &App{ + httpServer: &httpServer{ + router: gofrHTTP.NewRouter(), + port: port, + }, + container: c, + Config: config.NewMockConfig(map[string]string{ + "REQUEST_TIMEOUT": "5", + "SHUTDOWN_GRACE_PERIOD": "1s", + }), + } + + app.QUERY("/guarded", func(_ *Context) (any, error) { + return "ok", nil + }) + + go app.Run() + + base := fmt.Sprintf("http://localhost:%d", port) + testutil.WaitForHTTPServer(t, base) + + netClient := &http.Client{Timeout: 500 * time.Millisecond} + + tests := []struct { + desc string + path string + contentType string + body string + wantStatus int + wantAcceptQuery bool + }{ + { + desc: "valid JSON body reaches the handler", + path: "/guarded", + contentType: "application/json", + body: `{}`, + wantStatus: http.StatusOK, + }, + { + desc: "missing Content-Type is rejected before the handler (guard wired)", + path: "/guarded", + body: `{}`, + wantStatus: http.StatusBadRequest, + }, + { + desc: "unsupported Content-Type is rejected with Accept-Query header (RFC 10008 §3.1)", + path: "/guarded", + contentType: "text/plain", + body: "hello", + wantStatus: http.StatusUnsupportedMediaType, + wantAcceptQuery: true, + }, + { + desc: "QUERY to an unregistered path is 404, not 400/415 (guard not on catch-all)", + path: "/no-such-route", + contentType: "application/json", + body: `{}`, + wantStatus: http.StatusNotFound, + }, + } + + for _, tc := range tests { + t.Run(tc.desc, func(t *testing.T) { + req, _ := http.NewRequestWithContext(t.Context(), MethodQuery, + base+tc.path, strings.NewReader(tc.body)) + if tc.contentType != "" { + req.Header.Set("Content-Type", tc.contentType) + } + + resp, err := netClient.Do(req) + require.NoError(t, err) + + acceptQuery := resp.Header.Get("Accept-Query") + + resp.Body.Close() + + assert.Equal(t, tc.wantStatus, resp.StatusCode) + + if tc.wantAcceptQuery { + // Advertised set must be exactly the media types the guard would + // have accepted, so a client cannot ask for a type Bind refuses. + assert.Equal(t, gofrHTTP.AcceptedQueryMediaTypes(), acceptQuery, + "415 must carry Accept-Query listing the accepted media types (RFC 10008 §3.1)") + } else { + assert.Empty(t, acceptQuery, "Accept-Query is only advertised on 415, not on %d", resp.StatusCode) + } + }) + } +} diff --git a/pkg/gofr/http/errors.go b/pkg/gofr/http/errors.go index 24b177cf9a..dbc63ecbcc 100644 --- a/pkg/gofr/http/errors.go +++ b/pkg/gofr/http/errors.go @@ -65,6 +65,29 @@ func (ErrorInvalidParam) LogLevel() logging.Level { return logging.INFO } +// ErrorUnsupportedMediaType represents an error for a request whose Content-Type +// the endpoint cannot interpret (HTTP 415). Used by the QUERY (RFC 10008) path, +// which MUST reject an unsupported media type rather than bind to a zero value. +type ErrorUnsupportedMediaType struct { + ContentType string `json:"contentType,omitempty"` // ContentType is the rejected media type. +} + +func (e ErrorUnsupportedMediaType) Error() string { + if e.ContentType == "" { + return "unsupported media type" + } + + return fmt.Sprintf("unsupported media type: %s", e.ContentType) +} + +func (ErrorUnsupportedMediaType) StatusCode() int { + return http.StatusUnsupportedMediaType +} + +func (ErrorUnsupportedMediaType) LogLevel() logging.Level { + return logging.INFO +} + // ErrorMissingParam represents an error for missing parameters in a request. type ErrorMissingParam struct { Params []string `json:"param,omitempty"` @@ -184,6 +207,7 @@ var ( _ StatusCodeResponder = ErrorEntityAlreadyExist{} _ StatusCodeResponder = ErrorInvalidParam{} _ StatusCodeResponder = ErrorMissingParam{} + _ StatusCodeResponder = ErrorUnsupportedMediaType{} _ StatusCodeResponder = ErrorInvalidRoute{} _ StatusCodeResponder = ErrorRequestTimeout{} _ StatusCodeResponder = ErrorPanicRecovery{} @@ -196,6 +220,7 @@ var ( _ logging.LogLevelResponder = ErrorEntityAlreadyExist{} _ logging.LogLevelResponder = ErrorInvalidParam{} _ logging.LogLevelResponder = ErrorMissingParam{} + _ logging.LogLevelResponder = ErrorUnsupportedMediaType{} _ logging.LogLevelResponder = ErrorInvalidRoute{} _ logging.LogLevelResponder = ErrorRequestTimeout{} _ logging.LogLevelResponder = ErrorPanicRecovery{} diff --git a/pkg/gofr/http/middleware/cors.go b/pkg/gofr/http/middleware/cors.go index 477c79384d..9df5958000 100644 --- a/pkg/gofr/http/middleware/cors.go +++ b/pkg/gofr/http/middleware/cors.go @@ -143,6 +143,14 @@ type headerValue struct { // The method list is joined without appending to the caller's slice: that slice // is the router's RegisteredRoutes, and appending in place would write into it // whenever its capacity exceeded its length. +// +// RFC 10008 §3 Accept-Query is intentionally NOT emitted from here. That header +// is path-scoped ("applies to every URI on the server that shares the same +// path"), but this function only knows the deduplicated *methods* list on the +// server and has no path/method map. Advertising a global Accept-Query from +// here would turn one QUERY route anywhere into a false positive on every +// other path. A truthful implementation needs a path-template → methods index +// built at registration and threaded through here — separate change. func buildFixedHeaders(middlewareConfigs map[string]string, routes []string) (fixed []headerValue, methods []string) { allowMethods := joinAllowedMethods(routes) if custom, ok := middlewareConfigs[headerAccessControlAllowMethods]; ok && custom != "" { diff --git a/pkg/gofr/http/middleware/routecache.go b/pkg/gofr/http/middleware/routecache.go index ed7632d568..960e49ede7 100644 --- a/pkg/gofr/http/middleware/routecache.go +++ b/pkg/gofr/http/middleware/routecache.go @@ -4,6 +4,8 @@ import ( "net/http" "sync" "sync/atomic" + + gofrHTTP "gofr.dev/pkg/gofr/http" ) // routeCacheLimit caps the number of entries any per-route cache in this package @@ -39,7 +41,7 @@ func cacheableMethod(method string) bool { switch method { case http.MethodGet, http.MethodHead, http.MethodPost, http.MethodPut, http.MethodPatch, http.MethodDelete, http.MethodConnect, - http.MethodOptions, http.MethodTrace: + http.MethodOptions, http.MethodTrace, gofrHTTP.MethodQuery: return true default: return false diff --git a/pkg/gofr/http/middleware/tracer_test.go b/pkg/gofr/http/middleware/tracer_test.go index 7402ae9ba4..5ef7a24441 100644 --- a/pkg/gofr/http/middleware/tracer_test.go +++ b/pkg/gofr/http/middleware/tracer_test.go @@ -25,6 +25,7 @@ import ( otelTrace "go.opentelemetry.io/otel/trace" "go.opentelemetry.io/otel/trace/noop" + gofrHTTP "gofr.dev/pkg/gofr/http" "gofr.dev/pkg/gofr/version" ) @@ -1535,3 +1536,34 @@ func Test_TracerContract_StatusFlowsThroughLoggingChain(t *testing.T) { require.Len(t, lg.errors, 1, "5xx is logged via Error") assert.Equal(t, http.StatusServiceUnavailable, lg.errors[0].Response) } + +// TestCacheableMethodSet pins the method half of every per-route cache's bound. +// The list is a membership test with no other observable effect -- a method +// dropped from it silently stops being cached and every request on it rebuilds +// its span metadata, with nothing failing -- so the set is asserted directly +// rather than through a caching side effect. +func TestCacheableMethodSet(t *testing.T) { + cacheable := []string{ + http.MethodGet, http.MethodHead, http.MethodPost, http.MethodPut, + http.MethodPatch, http.MethodDelete, http.MethodConnect, + http.MethodOptions, http.MethodTrace, + // QUERY (RFC 10008) has no net/http constant, so it has to be listed by + // hand and is the entry most likely to be forgotten when this set is + // next touched. + gofrHTTP.MethodQuery, + } + + for _, method := range cacheable { + assert.True(t, cacheableMethod(method), + "%s is a defined method and must be cacheable", method) + } + + // The bound only holds because an arbitrary token is refused: net/http + // accepts any RFC 7230 token as a method, so an unauthenticated client + // minting M00001, M00002, ... must not be able to mint a permanent cache + // entry per request. + for _, method := range []string{"M00001", "QUER", "QUERYX", "query", ""} { + assert.False(t, cacheableMethod(method), + "%q is not a defined method and must not be cacheable", method) + } +} diff --git a/pkg/gofr/http/request.go b/pkg/gofr/http/request.go index d0649a2e8e..139985f7b8 100644 --- a/pkg/gofr/http/request.go +++ b/pkg/gofr/http/request.go @@ -10,6 +10,7 @@ import ( "mime" "net/http" "reflect" + "sort" "strings" "github.com/gorilla/mux" @@ -18,12 +19,102 @@ import ( const ( defaultMaxMemory = 32 << 20 // 32 MB - contentTypeJSON = "application/json" + // The request media types Bind can decode; also the set a QUERY request may + // carry (see ValidateQueryContentType). + contentTypeJSON = "application/json" + contentTypeMultipartForm = "multipart/form-data" + contentTypeFormURLEncoded = "application/x-www-form-urlencoded" + // "binary/octet-stream" is GoFr's own spelling, kept for compatibility; + // "application/octet-stream" is the RFC 2046 one and is what clients + // actually send. Both are accepted by Bind and ValidateQueryContentType. contentTypeBinary = "binary/octet-stream" contentTypeOctetStream = "application/octet-stream" + + // MethodQuery is the HTTP QUERY method (RFC 10008). Go's net/http has no such + // constant yet, so GoFr exports it here for use in routing, middleware, RBAC + // method lists, and method comparisons. + MethodQuery = "QUERY" ) +// bindersByMediaType is the single source of truth for which request bodies +// GoFr's Bind can decode, keyed by canonical media type. Bind's dispatch and +// isBindableMediaType both derive from this map, so ValidateQueryContentType +// and Bind cannot disagree on the supported set: a new media type is a new +// map entry and both paths pick it up at once. +// +// The "binary/octet-stream" GoFr spelling and the RFC 2046 "application/ +// octet-stream" spelling both map to bindBinary — keeping the two spellings +// live is a deliberate compatibility choice, not a drift. +// +//nolint:gochecknoglobals // process-wide, read-only dispatch table for Bind. +var bindersByMediaType = map[string]func(*Request, any) error{ + contentTypeJSON: (*Request).bindJSON, + contentTypeMultipartForm: (*Request).bindMultipart, + contentTypeFormURLEncoded: (*Request).bindFormURLEncoded, + contentTypeBinary: (*Request).bindBinary, + contentTypeOctetStream: (*Request).bindBinary, +} + +// isBindableMediaType reports whether ct is a media type Bind can decode. +// Reads from bindersByMediaType, so the answer is exactly the set Bind's +// dispatch can dispatch on. Callers must pass the media type in canonical +// form (lowercase, no parameters); use mediaType() to normalize before calling. +func isBindableMediaType(ct string) bool { + _, ok := bindersByMediaType[ct] + + return ok +} + +// AcceptedQueryMediaTypes returns the comma-separated list of media types the +// QUERY guard accepts, in the exact form RFC 10008 §3.1 wants for the +// Accept-Query response header on a 415. Derived from bindersByMediaType so a +// new binder appears here automatically — the header and the guard's real +// accept set cannot drift. Excludes the "binary/octet-stream" GoFr spelling +// because it is a private alias for "application/octet-stream", which is +// already advertised; publishing both would misrepresent one canonical +// vocabulary as two. +func AcceptedQueryMediaTypes() string { + types := make([]string, 0, len(bindersByMediaType)) + + for ct := range bindersByMediaType { + if ct == contentTypeBinary { + continue + } + + types = append(types, ct) + } + + sort.Strings(types) + + return strings.Join(types, ", ") +} + +// ValidateQueryContentType enforces RFC 10008's requirement that a QUERY request +// carry a Content-Type the server can interpret. A missing Content-Type yields a +// 400 (ErrorMissingParam); a present-but-unsupported one yields a 415 +// (ErrorUnsupportedMediaType). The supported set is isBindableMediaType, which +// reads bindersByMediaType — the same map Bind's dispatch reads, so what the +// guard accepts is exactly what Bind can decode. POST and the other verbs never +// call this. +// +// Normalization goes through mediaType() (mime.ParseMediaType), so casing and +// parameter differences — Application/JSON, application/json; charset=utf-8 — +// resolve to the same canonical form the predicate checks. +func ValidateQueryContentType(r *http.Request) error { + raw := r.Header.Get("Content-Type") + if strings.TrimSpace(raw) == "" { + return ErrorMissingParam{Params: []string{"Content-Type"}} + } + + ct := mediaType(raw) + if !isBindableMediaType(ct) { + return ErrorUnsupportedMediaType{ContentType: raw} + } + + return nil +} + var ( errNoFileFound = errors.New("no files were bounded") errNonPointerBind = errors.New("bind error, cannot bind to a non pointer type") @@ -72,7 +163,10 @@ func (r *Request) PathParam(key string) string { return r.pathParams[key] } -// Bind parses the request body and binds it to the provided interface. +// Bind parses the request body and binds it to the provided interface. The +// media type → binder dispatch is bindersByMediaType, the same map +// isBindableMediaType reads — the two paths share one source, not two +// hand-maintained copies of the supported set. func (r *Request) Bind(i any) error { // Binding into a non-pointer would unmarshal into a throwaway copy and leave // the caller's value untouched, so reject it up front instead of silently @@ -81,40 +175,35 @@ func (r *Request) Bind(i any) error { return errNonPointerBind } - contentType := mediaType(r.req.Header.Get("Content-Type")) + binder, ok := bindersByMediaType[mediaType(r.req.Header.Get("Content-Type"))] + if !ok { + // An unrecognized media type is a no-op: the target is left as it was + // and no error is reported. + // + // This silently discards a body the caller probably meant to bind, and + // an earlier revision of this PR rejected it with 415 for exactly that + // reason. That is a breaking change and it is not a quiet one: + // fetch(url, {method: "POST", body: str}) with no headers sends + // text/plain, so a handler that returns the Bind error would start + // answering 415 to a very common client shape. Those requests bind + // nothing today, but services that do not need the body work, and they + // would stop working. Left as it is deliberately. + return nil + } - switch contentType { - case contentTypeJSON: - body, err := r.body() - if err != nil { - return err - } + return binder(r, i) +} - return json.Unmarshal(body, &i) - case "multipart/form-data": - return r.bindMultipart(i) - case "application/x-www-form-urlencoded": - return r.bindFormURLEncoded(i) - // "binary/octet-stream" is GoFr's own spelling, kept for compatibility; - // "application/octet-stream" is the RFC 2046 one and is what clients - // actually send. Before Bind reported unsupported types, the RFC spelling - // fell through to a silent no-op; rejecting it instead of decoding it would - // have turned a naming gap into a hard error for the commoner spelling. - case contentTypeBinary, contentTypeOctetStream: - return r.bindBinary(i) - } - - // An unrecognized media type is a no-op: the target is left as it was and no - // error is reported. - // - // This silently discards a body the caller probably meant to bind, and an - // earlier revision of this PR rejected it with 415 for exactly that reason. - // That is a breaking change and it is not a quiet one: fetch(url, {method: - // "POST", body: str}) with no headers sends text/plain, so a handler that - // returns the Bind error would start answering 415 to a very common client - // shape. Those requests bind nothing today, but services that do not need - // the body work, and they would stop working. Left as it is deliberately. - return nil +// bindJSON decodes a JSON request body into i. Extracted so JSON dispatch +// matches the other binders in bindersByMediaType — every entry is a method +// on *Request with the same signature. +func (r *Request) bindJSON(i any) error { + body, err := r.body() + if err != nil { + return err + } + + return json.Unmarshal(body, &i) } // mediaType extracts the bare media type from a Content-Type header value. diff --git a/pkg/gofr/http/request_test.go b/pkg/gofr/http/request_test.go index 95ed9012eb..2305e74f17 100644 --- a/pkg/gofr/http/request_test.go +++ b/pkg/gofr/http/request_test.go @@ -1138,3 +1138,91 @@ func TestBind_EmptyBodyWithUnsupportedTypeIsNoOp(t *testing.T) { }) } } + +// TestBindPredicate_SingleSource pins the invariant that isBindableMediaType +// and Bind read from the same source: for every media type in +// bindersByMediaType, the predicate returns true, and there is no accepted +// media type Bind cannot dispatch on. Kills the drift class this PR opened — +// a new binder must be added to the map, and both callers pick it up at once. +func TestBindPredicate_SingleSource(t *testing.T) { + require.NotEmpty(t, bindersByMediaType, "bindersByMediaType must not be empty") + + for ct, binder := range bindersByMediaType { + t.Run(ct, func(t *testing.T) { + require.True(t, isBindableMediaType(ct), + "isBindableMediaType must accept every media type in bindersByMediaType") + require.NotNil(t, binder, + "every entry in bindersByMediaType must have a non-nil binder") + }) + } +} + +// TestValidateQueryContentType pins RFC 10008: a QUERY request MUST carry a +// Content-Type the server can interpret. A missing Content-Type is a 400 and a +// present-but-unsupported one is a 415. The accepted set is the same one Bind +// dispatches on (see TestBindPredicate_SingleSource). +func TestValidateQueryContentType(t *testing.T) { + tests := []struct { + name string + contentType string + wantErr error + }{ + {"json is accepted", "application/json", nil}, + {"json with charset is accepted", "application/json; charset=utf-8", nil}, + {"form-urlencoded is accepted", "application/x-www-form-urlencoded", nil}, + {"multipart is accepted", "multipart/form-data", nil}, + {"binary is accepted", "binary/octet-stream", nil}, + {"application/octet-stream is accepted", "application/octet-stream", nil}, + {"missing content-type is 400", "", ErrorMissingParam{Params: []string{"Content-Type"}}}, + {"xml is 415", "application/xml", ErrorUnsupportedMediaType{ContentType: "application/xml"}}, + {"text/plain is 415", "text/plain", ErrorUnsupportedMediaType{ContentType: "text/plain"}}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + r := httptest.NewRequestWithContext(t.Context(), MethodQuery, "/search", http.NoBody) + if tc.contentType != "" { + r.Header.Set("Content-Type", tc.contentType) + } + + err := ValidateQueryContentType(r) + + if tc.wantErr == nil { + require.NoError(t, err) + return + } + + require.Equal(t, tc.wantErr, err) + }) + } +} + +func TestErrorUnsupportedMediaType(t *testing.T) { + assert.Equal(t, http.StatusUnsupportedMediaType, ErrorUnsupportedMediaType{}.StatusCode()) + assert.Equal(t, "unsupported media type", ErrorUnsupportedMediaType{}.Error()) + assert.Equal(t, "unsupported media type: application/xml", + ErrorUnsupportedMediaType{ContentType: "application/xml"}.Error()) +} + +// TestAcceptedQueryMediaTypes pins the Accept-Query header value shape: +// - every canonical media type Bind can decode is advertised +// - the "binary/octet-stream" GoFr alias is omitted (application/octet-stream +// is the RFC 2046 spelling and already covers the same binder) +// - the list is stable across runs (sorted), so log-based alerting and +// integration tests can string-match without ordering flakes. +func TestAcceptedQueryMediaTypes(t *testing.T) { + got := AcceptedQueryMediaTypes() + + // Stable across calls — sorted, not map-iteration-order. + assert.Equal(t, got, AcceptedQueryMediaTypes(), "AcceptedQueryMediaTypes must be stable across calls") + + types := strings.Split(got, ", ") + + // Every RFC 2046 media type in the binder map must appear; the private + // binary/octet-stream alias must not. + assert.Contains(t, types, contentTypeJSON) + assert.Contains(t, types, contentTypeMultipartForm) + assert.Contains(t, types, contentTypeFormURLEncoded) + assert.Contains(t, types, contentTypeOctetStream) + assert.NotContains(t, types, contentTypeBinary, "binary/octet-stream is an internal alias, do not advertise it") +} diff --git a/pkg/gofr/http/responder.go b/pkg/gofr/http/responder.go index dfe5a74450..92bd1fa764 100644 --- a/pkg/gofr/http/responder.go +++ b/pkg/gofr/http/responder.go @@ -231,10 +231,18 @@ func (r Responder) handleSpecialResponseTypes(data any, err error) bool { return true case resTypes.Redirect: - // Redirect status codes are determined by HTTP method, not error state + // Redirect status codes are determined by HTTP method, not error state. + // QUERY (RFC 10008 §3) gives 303 See Other an explicit meaning: "the original + // query can be accomplished via a normal retrieval request on the URI referenced + // by the Location response field." That is the one status code the RFC calls + // out for QUERY, so QUERY joins the 303 branch. 307 would preserve method+body, + // but GoFr's existing coarse redirect handling already drops the body on the + // GET (302) path too, so 303 keeps QUERY consistent with the framework rather + // than making it a special case — and satisfies the RFC's specific guidance. redirectStatusCode := http.StatusFound - if r.method == http.MethodPost || r.method == http.MethodPut || r.method == http.MethodPatch { + if r.method == http.MethodPost || r.method == http.MethodPut || + r.method == http.MethodPatch || r.method == MethodQuery { redirectStatusCode = http.StatusSeeOther } diff --git a/pkg/gofr/http/responder_test.go b/pkg/gofr/http/responder_test.go index 44f59621b3..c3251327fd 100644 --- a/pkg/gofr/http/responder_test.go +++ b/pkg/gofr/http/responder_test.go @@ -407,6 +407,47 @@ func TestResponder_RedirectResponse_Post(t *testing.T) { assert.Empty(t, recorder.Body.String(), "Redirect response should not have a body") } +func TestResponder_RedirectResponse_Query(t *testing.T) { + recorder := httptest.NewRecorder() + r := NewResponder(recorder, MethodQuery) + + redirectURL := "/results?from=query" + + redirect := resTypes.Redirect{URL: redirectURL} + + r.Respond(redirect, nil) + + // RFC 10008: a QUERY redirect uses 303 See Other so the result can be + // retrieved with a normal GET on the Location URI. + assert.Equal(t, http.StatusSeeOther, recorder.Code, "QUERY redirect must be 303 See Other") + assert.Equal(t, redirectURL, recorder.Header().Get("Location"), + "Redirect should set the Location header") + assert.Empty(t, recorder.Body.String(), "Redirect response should not have a body") +} + +// TestResponder_SuccessStatus_Query pins the successful-QUERY status code at +// 200 OK. Today it reaches 200 via the default arm of handleSuccessStatusCode, +// but nothing else says so — grouping QUERY with POST later would silently +// promote it to 201/202. RFC 10008 §2 puts QUERY in the safe/idempotent class +// (like GET) rather than resource-creating (POST); 200 is the right answer, +// and this test locks it. +func TestResponder_SuccessStatus_Query(t *testing.T) { + tests := []struct { + name string + data any + }{ + {"non-nil data", map[string]string{"matched": "golang"}}, + {"nil data", nil}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got := handleSuccessStatusCode(MethodQuery, tc.data) + assert.Equal(t, http.StatusOK, got, "successful QUERY must be 200 OK") + }) + } +} + func TestResponder_RedirectResponse_Head(t *testing.T) { recorder := httptest.NewRecorder() r := NewResponder(recorder, http.MethodHead) diff --git a/pkg/gofr/mcp.go b/pkg/gofr/mcp.go index d96e0abf74..7519c371ab 100644 --- a/pkg/gofr/mcp.go +++ b/pkg/gofr/mcp.go @@ -29,10 +29,12 @@ func WithExcludedRoutes(paths ...string) MCPOption { } } -// EnableMCP exposes the app's read-only HTTP handlers (GET/HEAD/OPTIONS) as agent-callable tools over -// an MCP server on its own port (MCP_PORT, default 8200; MCP_PORT=0 disables the server). Write -// handlers are never exposed, so an agent cannot mutate state through this surface. The tools are also -// reachable in handlers via ctx.LLM().Tools() regardless of whether the server is enabled. +// EnableMCP exposes the app's safe HTTP handlers — read-only methods (GET/HEAD/OPTIONS) and QUERY +// (RFC 10008, safe and idempotent, whose query payload is passed as a "body" tool argument) — as +// agent-callable tools over an MCP server on its own port (MCP_PORT, default 8200; MCP_PORT=0 disables +// the server). Write handlers (POST/PUT/PATCH/DELETE) are never exposed, so an agent cannot mutate +// state through this surface. The tools are also reachable in handlers via ctx.LLM().Tools() regardless +// of whether the server is enabled. func (a *App) EnableMCP(opts ...MCPOption) { cfg := &mcpConfig{exclude: make(map[string]bool)} for _, o := range opts { diff --git a/pkg/gofr/mcp_test.go b/pkg/gofr/mcp_test.go index 0c774dd405..9f526d6218 100644 --- a/pkg/gofr/mcp_test.go +++ b/pkg/gofr/mcp_test.go @@ -328,3 +328,72 @@ func TestHelpers(t *testing.T) { assert.Equal(t, "42", scalar(json.RawMessage(`"42"`))) assert.Equal(t, "true", scalar(json.RawMessage(`true`))) } + +func TestRouterTools_List_ExposesQuery(t *testing.T) { + app, rt := testRouterTools(t) + app.QUERY("/search", func(*Context) (any, error) { return nil, nil }) + app.POST("/write", func(*Context) (any, error) { return nil, nil }) + + specs := rt.List() + names := toolNames(specs) + + assert.Contains(t, names, "query_search", "QUERY handlers are exposed (safe + idempotent)") + assert.NotContains(t, names, "post_write", "write handlers remain unexposed") + + // The QUERY tool must advertise a required "body" argument for the query payload. + var querySpec ai.ToolSpec + + for _, s := range specs { + if s.Name == "query_search" { + querySpec = s + } + } + + require.NotEmpty(t, querySpec.Name) + assert.Equal(t, ai.ReadOnly, querySpec.Access, "QUERY is safe, so it is ReadOnly") + + schema := map[string]any{} + require.NoError(t, json.Unmarshal(querySpec.InputSchema, &schema)) + + props, _ := schema["properties"].(map[string]any) + assert.Contains(t, props, "body", "QUERY tool schema must include a body property") + assert.Contains(t, schema["required"], "body", "body must be required") +} + +func TestRouterTools_Call_QueryForwardsBody(t *testing.T) { + app, rt := testRouterTools(t) + app.QUERY("/search", func(c *Context) (any, error) { + payload := map[string]any{} + if err := c.Bind(&payload); err != nil { + return nil, err + } + + return payload, nil + }) + + res, err := rt.Call(t.Context(), "query_search", json.RawMessage(`{"body":{"filter":"title"}}`)) + require.NoError(t, err) + + body, err := res.JSON() + require.NoError(t, err) + assert.Contains(t, string(body), `"filter":"title"`, "the QUERY body must reach the handler") +} + +func TestRouterTools_Call_QueryWithPathParamAndBody(t *testing.T) { + app, rt := testRouterTools(t) + app.QUERY("/index/{name}/search", func(c *Context) (any, error) { + payload := map[string]any{} + _ = c.Bind(&payload) + payload["index"] = c.PathParam("name") + + return payload, nil + }) + + res, err := rt.Call(t.Context(), "query_index_name_search", + json.RawMessage(`{"name":"books","body":{"q":"go"}}`)) + require.NoError(t, err) + + body, _ := res.JSON() + assert.Contains(t, string(body), `"index":"books"`) + assert.Contains(t, string(body), `"q":"go"`) +} diff --git a/pkg/gofr/rest.go b/pkg/gofr/rest.go index 330469fe45..e3594f1073 100644 --- a/pkg/gofr/rest.go +++ b/pkg/gofr/rest.go @@ -1,10 +1,22 @@ package gofr import ( + "errors" + "net/http" "strconv" "time" + + "go.opentelemetry.io/otel/trace" + + gofrHTTP "gofr.dev/pkg/gofr/http" + "gofr.dev/pkg/gofr/logging" ) +// MethodQuery is the HTTP QUERY method (RFC 10008). Declared here alongside the +// other route registrations so callers routing a request or writing middleware +// have the canonical constant next to App.QUERY. Aliases gofrHTTP.MethodQuery. +const MethodQuery = gofrHTTP.MethodQuery + // GET adds a Handler for HTTP GET method for a route pattern. func (a *App) GET(pattern string, handler Handler) { a.add("GET", pattern, handler) @@ -30,6 +42,17 @@ func (a *App) PATCH(pattern string, handler Handler) { a.add("PATCH", pattern, handler) } +// QUERY adds a Handler for the HTTP QUERY method (RFC 10008) for a route pattern. +// QUERY is a safe, idempotent method that carries a request body describing the +// query; read it in the handler via ctx.Bind, the same way as a POST body. +// Per RFC 10008 a QUERY request MUST carry a Content-Type the server can interpret; +// GoFr enforces this on the QUERY path, rejecting a missing Content-Type with 400 +// and an unsupported one with 415 before the handler runs. Other verbs, including +// POST, are unaffected. +func (a *App) QUERY(pattern string, handler Handler) { + a.add(MethodQuery, pattern, handler) +} + func (a *App) add(method, pattern string, h Handler) { if !a.httpRegistered && !isPortAvailable(a.httpServer.port) { a.container.Logger.Fatalf("http port %d is blocked or unreachable", a.httpServer.port) @@ -42,10 +65,71 @@ func (a *App) add(method, pattern string, h Handler) { reqTimeout = 0 } - a.httpServer.router.Add(method, pattern, handler{ + var routeHandler http.Handler = handler{ function: h, container: a.container, requestTimeout: time.Duration(reqTimeout) * time.Second, + } + + // RFC 10008: a QUERY request MUST carry a Content-Type the server can + // interpret. Guard only registered QUERY routes — wrapping at ServeHTTP + // would gate the PathPrefix("/") catch-all too, turning a real 404 into + // a spurious 400/415 for QUERY to any unknown path. + if method == MethodQuery { + routeHandler = queryContentTypeGuard(routeHandler, a.container.Logger) + } + + a.httpServer.router.Add(method, pattern, routeHandler) +} + +// queryContentTypeGuard enforces RFC 10008's Content-Type requirement on +// QUERY requests before the user handler runs. Missing → 400, unsupported → +// 415. A denial is logged with the request's trace ID and dispatched to the +// log level the error itself declares — ErrorMissingParam and +// ErrorUnsupportedMediaType both return LogLevel INFO, so a client's bad +// header does NOT surface as an ERROR line and does not page the on-call. +// This mirrors handler.logError so the two paths cannot diverge. +// +// A 415 also carries the Accept-Query response header per RFC 10008 §3.1, so +// the client learns which media types the server would have accepted. The set +// is derived from bindersByMediaType (via gofrHTTP.AcceptedQueryMediaTypes), +// so the advertised list cannot drift from the set Bind actually decodes. +func queryContentTypeGuard(inner http.Handler, log logging.Logger) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if err := gofrHTTP.ValidateQueryContentType(r); err != nil { + traceID := trace.SpanFromContext(r.Context()).SpanContext().TraceID().String() + entry := &ErrorLogEntry{TraceID: traceID, Error: err.Error()} + + logHelper := log.Error + + switch logging.GetLogLevelForError(err) { + case logging.ERROR: + // default is log.Error + case logging.INFO: + logHelper = log.Info + case logging.NOTICE: + logHelper = log.Notice + case logging.DEBUG: + logHelper = log.Debug + case logging.WARN: + logHelper = log.Warn + case logging.FATAL: + logHelper = log.Fatal + } + + logHelper(entry) + + var unsupported gofrHTTP.ErrorUnsupportedMediaType + if errors.As(err, &unsupported) { + w.Header().Set("Accept-Query", gofrHTTP.AcceptedQueryMediaTypes()) + } + + gofrHTTP.NewResponder(w, r.Method).Respond(nil, err) + + return + } + + inner.ServeHTTP(w, r) }) } diff --git a/pkg/gofr/rest_test.go b/pkg/gofr/rest_test.go new file mode 100644 index 0000000000..c838b4e646 --- /dev/null +++ b/pkg/gofr/rest_test.go @@ -0,0 +1,115 @@ +package gofr + +import ( + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/stretchr/testify/assert" + + gofrHTTP "gofr.dev/pkg/gofr/http" + "gofr.dev/pkg/gofr/logging" + "gofr.dev/pkg/gofr/testutil" +) + +// TestQueryContentTypeGuard_LogsAtDeclaredLevel pins the operational contract +// the reviewer flagged: a client's bad Content-Type is a 4xx and MUST NOT show +// up as an ERROR log line. ErrorMissingParam and ErrorUnsupportedMediaType +// both declare LogLevel INFO; the guard must dispatch to log.Info, not +// log.Error, or every missing-header request pages the on-call. +// +// The MockLogger writes ERROR to stderr and everything else to stdout, so a +// leak into stderr is what a regression would look like here. +func TestQueryContentTypeGuard_LogsAtDeclaredLevel(t *testing.T) { + tests := []struct { + name string + contentType string + wantLevel string + // ERROR (and above) is written to stderr; everything else to stdout. + onStderr bool + }{ + {"missing-CT-is-INFO", "", "INFO", false}, + {"unsupported-CT-is-INFO", "text/plain", "INFO", false}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + serve := func() { + inner := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusOK) + }) + guard := queryContentTypeGuard(inner, logging.NewLogger(logging.DEBUG)) + + req := httptest.NewRequestWithContext(t.Context(), MethodQuery, "/x", strings.NewReader(`{}`)) + if tc.contentType != "" { + req.Header.Set("Content-Type", tc.contentType) + } + + guard.ServeHTTP(httptest.NewRecorder(), req) + } + + logs := testutil.StdoutOutputForFunc(serve) + if tc.onStderr { + logs = testutil.StderrOutputForFunc(serve) + } + + assert.Contains(t, logs, tc.wantLevel, + "guard must log a 4xx at the level the error declares, not ERROR — "+ + "a false ERROR pages the on-call on every bad Content-Type") + + // The opposite stream must be empty: a leak into ERROR is the + // regression the reviewer's fix prevents. + if tc.onStderr { + assert.Empty(t, testutil.StdoutOutputForFunc(serve)) + } else { + assert.Empty(t, testutil.StderrOutputForFunc(serve)) + } + }) + } +} + +// TestQueryContentTypeGuard_Accept_QueryOnUnsupportedOnly pins RFC 10008 §3.1: +// a 415 advertises the accepted media types via Accept-Query. A 400 (missing +// header) MUST NOT — nothing about the media type is wrong, so nothing about +// media types belongs in the response. +func TestQueryContentTypeGuard_Accept_QueryOnUnsupportedOnly(t *testing.T) { + inner := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusOK) + }) + guard := queryContentTypeGuard(inner, logging.NewLogger(logging.DEBUG)) + + tests := []struct { + name string + contentType string + wantStatus int + wantAcceptQuery bool + }{ + {"415-advertises-accepted-types", "text/plain", http.StatusUnsupportedMediaType, true}, + {"400-does-not-advertise", "", http.StatusBadRequest, false}, + {"200-does-not-advertise", "application/json", http.StatusOK, false}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + req := httptest.NewRequestWithContext(t.Context(), MethodQuery, "/x", strings.NewReader(`{}`)) + if tc.contentType != "" { + req.Header.Set("Content-Type", tc.contentType) + } + + rec := httptest.NewRecorder() + guard.ServeHTTP(rec, req) + + assert.Equal(t, tc.wantStatus, rec.Code) + + acceptQuery := rec.Header().Get("Accept-Query") + if tc.wantAcceptQuery { + assert.Equal(t, gofrHTTP.AcceptedQueryMediaTypes(), acceptQuery, + "415 must advertise the accepted media types (RFC 10008 §3.1)") + } else { + assert.Empty(t, acceptQuery, + "Accept-Query belongs only on 415; %d is not a media-type refusal", tc.wantStatus) + } + }) + } +} diff --git a/pkg/gofr/service/auth.go b/pkg/gofr/service/auth.go index b4bef6e6e8..e8e55e3079 100644 --- a/pkg/gofr/service/auth.go +++ b/pkg/gofr/service/auth.go @@ -82,3 +82,18 @@ func (a *authProvider) DeleteWithHeaders(ctx context.Context, path string, body return a.HTTP.DeleteWithHeaders(ctx, path, body, headers) } + +func (a *authProvider) Query(ctx context.Context, path string, queryParams map[string]any, + body []byte) (*http.Response, error) { + return a.QueryWithHeaders(ctx, path, queryParams, body, nil) +} + +func (a *authProvider) QueryWithHeaders(ctx context.Context, path string, queryParams map[string]any, + body []byte, headers map[string]string) (*http.Response, error) { + headers, err := a.auth(ctx, headers) + if err != nil { + return nil, err + } + + return a.HTTP.QueryWithHeaders(ctx, path, queryParams, body, headers) +} diff --git a/pkg/gofr/service/auth_test.go b/pkg/gofr/service/auth_test.go index fd18f9f207..85e479d1a1 100644 --- a/pkg/gofr/service/auth_test.go +++ b/pkg/gofr/service/auth_test.go @@ -60,7 +60,7 @@ func TestAuthProvider(t *testing.T) { {authOption: validOAuthConfig, headers: map[string]string{AuthHeader: "auth-string"}, err: authHeaderExistsErr}, } - httpMethods := []string{http.MethodGet, http.MethodPost, http.MethodPut, http.MethodPatch, http.MethodDelete} + httpMethods := []string{http.MethodGet, http.MethodPost, http.MethodPut, http.MethodPatch, http.MethodDelete, methodQuery} for i, tc := range testCases { t.Run(fmt.Sprintf("Test Case #%d", i), func(t *testing.T) { @@ -143,6 +143,8 @@ func callHTTPServiceWithHeaders(ctx context.Context, service HTTP, method string return service.PatchWithHeaders(ctx, path, queryParams, body, headers) case http.MethodDelete: return service.DeleteWithHeaders(ctx, path, body, headers) + case methodQuery: + return service.QueryWithHeaders(ctx, path, queryParams, body, headers) default: return nil, AuthErr{Message: "unknown method"} } @@ -164,6 +166,8 @@ func callHTTPServiceWithoutHeaders(ctx context.Context, service HTTP, method str return service.Patch(ctx, path, queryParams, body) case http.MethodDelete: return service.Delete(ctx, path, body) + case methodQuery: + return service.Query(ctx, path, queryParams, body) default: return nil, AuthErr{Message: "unknown method"} } diff --git a/pkg/gofr/service/circuit_breaker.go b/pkg/gofr/service/circuit_breaker.go index 18228d4eae..715d234459 100644 --- a/pkg/gofr/service/circuit_breaker.go +++ b/pkg/gofr/service/circuit_breaker.go @@ -3,6 +3,7 @@ package service import ( "context" "errors" + "fmt" "net/http" "sync" "time" @@ -18,6 +19,14 @@ var ( // ErrCircuitOpen indicates that the circuit breaker is open. ErrCircuitOpen = errors.New("unable to connect to server at host") ErrUnexpectedCircuitBreakerResultType = errors.New("unexpected result type from circuit breaker") + + // errUnsupportedMethod is returned by doRequest when it is asked to route + // an HTTP method it does not handle. Unexported because doRequest itself is + // unexported and all in-tree callers pass a known method constant, so the + // default branch is unreachable from outside the package — but the branch + // itself is worth keeping: an earlier revision returned (nil, nil) silently + // in that spot. + errUnsupportedMethod = errors.New("unsupported HTTP method for circuit breaker") ) // CircuitBreakerConfig holds the configuration for the circuitBreaker. @@ -266,6 +275,12 @@ func (cb *circuitBreaker) doRequest(ctx context.Context, method, path string, qu result, err = cb.executeWithCircuitBreaker(ctx, func(ctx context.Context) (*http.Response, error) { return cb.HTTP.DeleteWithHeaders(ctx, path, body, headers) }) + case methodQuery: + result, err = cb.executeWithCircuitBreaker(ctx, func(ctx context.Context) (*http.Response, error) { + return cb.HTTP.QueryWithHeaders(ctx, path, queryParams, body, headers) + }) + default: + return nil, fmt.Errorf("%w: %q", errUnsupportedMethod, method) } resp, err := cb.handleCircuitBreakerResult(result, err) @@ -332,3 +347,15 @@ func (cb *circuitBreaker) Delete(ctx context.Context, path string, body []byte) *http.Response, error) { return cb.doRequest(ctx, http.MethodDelete, path, nil, body, nil) } + +// QueryWithHeaders is a wrapper for doRequest with the QUERY method and headers. +func (cb *circuitBreaker) QueryWithHeaders(ctx context.Context, path string, queryParams map[string]any, + body []byte, headers map[string]string) (*http.Response, error) { + return cb.doRequest(ctx, methodQuery, path, queryParams, body, headers) +} + +// Query is a wrapper for doRequest with the QUERY method. +func (cb *circuitBreaker) Query(ctx context.Context, path string, queryParams map[string]any, + body []byte) (*http.Response, error) { + return cb.doRequest(ctx, methodQuery, path, queryParams, body, nil) +} diff --git a/pkg/gofr/service/circuit_breaker_test.go b/pkg/gofr/service/circuit_breaker_test.go index 2807c5fc6c..a20423eb28 100644 --- a/pkg/gofr/service/circuit_breaker_test.go +++ b/pkg/gofr/service/circuit_breaker_test.go @@ -1348,6 +1348,191 @@ func TestCircuitBreaker_SlowHealthCheckDoesNotBlock(t *testing.T) { assert.Equal(t, ClosedState, state, "circuit should be closed after successful recovery") } +func TestHttpService_QuerySuccessRequests(t *testing.T) { + server := testServer() + defer server.Close() + + ctrl := gomock.NewController(t) + mockMetric := NewMockMetrics(ctrl) + + mockMetric.EXPECT().RecordHistogram(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + + service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ + Threshold: 1, + Interval: 1, + }) + + resp, err := service.Query(t.Context(), "test", nil, []byte(`{"q":"x"}`)) + + require.NoError(t, err) + assert.Equal(t, http.StatusOK, resp.StatusCode) + + _ = resp.Body.Close() +} + +func TestHttpService_QueryWithHeaderSuccessRequests(t *testing.T) { + server := testServer() + defer server.Close() + + ctrl := gomock.NewController(t) + mockMetric := NewMockMetrics(ctrl) + + mockMetric.EXPECT().RecordHistogram(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() + mockMetric.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + + service := NewHTTPService(server.URL, logging.NewMockLogger(logging.DEBUG), mockMetric, &CircuitBreakerConfig{ + Threshold: 1, + Interval: 1, + }) + + resp, err := service.QueryWithHeaders(t.Context(), "test", nil, []byte(`{"q":"x"}`), + map[string]string{"content-type": "application/json"}) + + require.NoError(t, err) + assert.Equal(t, http.StatusOK, resp.StatusCode) + + _ = resp.Body.Close() +} + +// TestCircuitBreaker_doRequest_UnsupportedMethod verifies the default case: +// an unknown method must return errUnsupportedMethod instead of a nil response. +func TestCircuitBreaker_doRequest_UnsupportedMethod(t *testing.T) { + cb := &circuitBreaker{state: ClosedState, interval: time.Second} + + //nolint:bodyclose // the unsupported-method path returns a nil response, nothing to close + resp, err := cb.doRequest(t.Context(), "TRACE", "test", nil, nil, nil) + + require.ErrorIs(t, err, errUnsupportedMethod) + assert.Nil(t, resp) +} + +// cbQueryServer is a controllable downstream for QUERY circuit-breaker integration +// tests. When down is true, QUERY /search returns 503 (>500, trips the breaker). When +// aliveMirrorsDown is true, the /.well-known/alive probe also fails while down, so the +// breaker stays open until the service actually heals. +func cbQueryServer(down *atomic.Bool, aliveMirrorsDown bool) *httptest.Server { + mux := http.NewServeMux() + + mux.HandleFunc("/search", func(w http.ResponseWriter, r *http.Request) { + if r.Method != methodQuery { + w.WriteHeader(http.StatusMethodNotAllowed) + return + } + + if down.Load() { + w.WriteHeader(http.StatusServiceUnavailable) + return + } + + body, _ := io.ReadAll(r.Body) + + w.WriteHeader(http.StatusOK) + _, _ = w.Write(body) + }) + + mux.HandleFunc("/.well-known/alive", func(w http.ResponseWriter, _ *http.Request) { + if aliveMirrorsDown && down.Load() { + w.WriteHeader(http.StatusServiceUnavailable) + return + } + + w.WriteHeader(http.StatusOK) + }) + + return httptest.NewServer(mux) +} + +// cbQueryBreaker builds a circuitBreaker directly (not via NewCircuitBreaker) so it does NOT +// start the background health-check goroutine — keeping the test deterministic and leak-free. +// Its embedded HTTP is a plain httpService (no decorators) pointing at url. +func cbQueryBreaker(t *testing.T, url string, threshold int, interval time.Duration) *circuitBreaker { + t.Helper() + + ctrl := gomock.NewController(t) + m := NewMockMetrics(ctrl) + m.EXPECT().RecordHistogram(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + m.EXPECT().NewCounter(gomock.Any(), gomock.Any()).AnyTimes() + m.EXPECT().NewGauge(gomock.Any(), gomock.Any()).AnyTimes() + m.EXPECT().SetGauge(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() + + base := NewHTTPService(url, logging.NewMockLogger(logging.ERROR), m) + + return &circuitBreaker{ + state: ClosedState, + threshold: threshold, + interval: interval, + HTTP: base, + } +} + +// TestCircuitBreaker_Query_Trips verifies an outbound QUERY participates in circuit-breaker +// failure accounting: repeated downstream 503s open the circuit and further QUERY calls are +// short-circuited with ErrCircuitOpen without hitting the downstream. +func TestCircuitBreaker_Query_Trips(t *testing.T) { + var down atomic.Bool + + server := cbQueryServer(&down, false) + defer server.Close() + + cb := cbQueryBreaker(t, server.URL, 2, time.Minute) + + // Healthy: QUERY succeeds and body is echoed. + resp, err := cb.Query(t.Context(), "search", nil, []byte(`{"q":"ok"}`)) + require.NoError(t, err) + assert.Equal(t, http.StatusOK, resp.StatusCode) + _ = resp.Body.Close() + + // Failing downstream: drive QUERY calls until the circuit opens. + down.Store(true) + + var opened bool + + for i := 0; i < 6; i++ { + resp, err = cb.Query(t.Context(), "search", nil, []byte(`{"q":"x"}`)) + if resp != nil { + _ = resp.Body.Close() + } + + if err != nil && err.Error() == ErrCircuitOpen.Error() { + opened = true + break + } + } + + assert.True(t, opened, "QUERY calls should open the circuit after repeated downstream failures") +} + +// TestCircuitBreaker_Query_Recovers verifies that when the circuit is open, an outbound QUERY +// triggers recovery: once the interval has elapsed and the downstream health probe reports UP, +// the breaker closes and the QUERY is served. Deterministic — no background goroutine, no sleeps. +func TestCircuitBreaker_Query_Recovers(t *testing.T) { + var down atomic.Bool + + server := cbQueryServer(&down, false) // /.well-known/alive stays UP => healthy + defer server.Close() + + cb := cbQueryBreaker(t, server.URL, 2, 50*time.Millisecond) + + // Force the breaker open with a stale lastChecked so the next QUERY attempts recovery. + cb.state = OpenState + cb.lastChecked = time.Now().Add(-time.Hour) + + resp, err := cb.Query(t.Context(), "search", nil, []byte(`{"q":"ok"}`)) + require.NoError(t, err) + assert.Equal(t, http.StatusOK, resp.StatusCode) + _ = resp.Body.Close() + + cb.mu.RLock() + state := cb.state + cb.mu.RUnlock() + assert.Equal(t, ClosedState, state, "circuit should be closed after a successful QUERY recovery") +} + // TestCircuitBreaker_ConcurrentRecovery_OnlyOneResetsCircuit verifies that when N // goroutines simultaneously discover the circuit is open and the recovery interval has // elapsed, exactly ONE goroutine fires the health check and resets the circuit. diff --git a/pkg/gofr/service/custom_header.go b/pkg/gofr/service/custom_header.go index 7e7694989f..600ce3669b 100644 --- a/pkg/gofr/service/custom_header.go +++ b/pkg/gofr/service/custom_header.go @@ -80,6 +80,18 @@ func (a *customHeader) DeleteWithHeaders(ctx context.Context, path string, body return a.HTTP.DeleteWithHeaders(ctx, path, body, headers) } +func (a *customHeader) Query(ctx context.Context, path string, queryParams map[string]any, body []byte) ( + *http.Response, error) { + return a.QueryWithHeaders(ctx, path, queryParams, body, nil) +} + +func (a *customHeader) QueryWithHeaders(ctx context.Context, path string, queryParams map[string]any, body []byte, + headers map[string]string) (*http.Response, error) { + headers = setCustomHeader(headers, a.Headers) + + return a.HTTP.QueryWithHeaders(ctx, path, queryParams, body, headers) +} + func setCustomHeader(headers, customHeader map[string]string) map[string]string { if headers == nil { headers = make(map[string]string) diff --git a/pkg/gofr/service/custom_header_test.go b/pkg/gofr/service/custom_header_test.go index 4808ce2e16..7b4dfb091a 100644 --- a/pkg/gofr/service/custom_header_test.go +++ b/pkg/gofr/service/custom_header_test.go @@ -166,3 +166,32 @@ func TestCustomDomainProvider_Delete(t *testing.T) { assert.Equal(t, http.StatusNoContent, resp.StatusCode) require.NoError(t, err) } + +func TestCustomDomainProvider_Query(t *testing.T) { + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + queryParams := map[string]any{"key": "value"} + body := []byte(`{"q":"x"}`) + + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + assert.Equal(t, "QUERY", r.Method) + assert.Equal(t, "test_value", r.Header.Get("Test_key")) + + w.WriteHeader(http.StatusOK) + })) + defer server.Close() + + customHeaderService := NewHTTPService(server.URL, logging.NewMockLogger(logging.INFO), nil, + &DefaultHeaders{ + Headers: map[string]string{ + "TEST_KEY": "test_value", + }}) + + resp, err := customHeaderService.Query(t.Context(), "/path", queryParams, body) + require.NoError(t, err) + + defer resp.Body.Close() + + assert.Equal(t, http.StatusOK, resp.StatusCode) +} diff --git a/pkg/gofr/service/file_token_auth.go b/pkg/gofr/service/file_token_auth.go index aaec377e35..3e4b875306 100644 --- a/pkg/gofr/service/file_token_auth.go +++ b/pkg/gofr/service/file_token_auth.go @@ -301,3 +301,18 @@ func (d *fileTokenDecorator) DeleteWithHeaders(ctx context.Context, path string, return d.HTTP.DeleteWithHeaders(ctx, path, body, headers) } + +func (d *fileTokenDecorator) Query(ctx context.Context, path string, queryParams map[string]any, + body []byte) (*http.Response, error) { + return d.QueryWithHeaders(ctx, path, queryParams, body, nil) +} + +func (d *fileTokenDecorator) QueryWithHeaders(ctx context.Context, path string, queryParams map[string]any, + body []byte, headers map[string]string) (*http.Response, error) { + headers, err := d.inject(headers) + if err != nil { + return nil, err + } + + return d.HTTP.QueryWithHeaders(ctx, path, queryParams, body, headers) +} diff --git a/pkg/gofr/service/file_token_auth_test.go b/pkg/gofr/service/file_token_auth_test.go index bfaa664ad6..bbdaebd719 100644 --- a/pkg/gofr/service/file_token_auth_test.go +++ b/pkg/gofr/service/file_token_auth_test.go @@ -243,6 +243,7 @@ func TestFileTokenAuthConfig_InjectsBearerHeaderAllVerbs(t *testing.T) { {"PUT", func() (*http.Response, error) { return svc.Put(ctx, "", nil, nil) }}, {"PATCH", func() (*http.Response, error) { return svc.Patch(ctx, "", nil, nil) }}, {"DELETE", func() (*http.Response, error) { return svc.Delete(ctx, "", nil) }}, + {"QUERY", func() (*http.Response, error) { return svc.Query(ctx, "", nil, nil) }}, } for _, tc := range tests { diff --git a/pkg/gofr/service/mock_http_service.go b/pkg/gofr/service/mock_http_service.go index 90f2fd83ef..202c6ed342 100644 --- a/pkg/gofr/service/mock_http_service.go +++ b/pkg/gofr/service/mock_http_service.go @@ -174,6 +174,36 @@ func (mr *MockHTTPMockRecorder) PostWithHeaders(ctx, path, queryParams, body, he return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostWithHeaders", reflect.TypeOf((*MockHTTP)(nil).PostWithHeaders), ctx, path, queryParams, body, headers) } +// Query mocks base method. +func (m *MockHTTP) Query(ctx context.Context, path string, queryParams map[string]any, body []byte) (*http.Response, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Query", ctx, path, queryParams, body) + ret0, _ := ret[0].(*http.Response) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Query indicates an expected call of Query. +func (mr *MockHTTPMockRecorder) Query(ctx, path, queryParams, body any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockHTTP)(nil).Query), ctx, path, queryParams, body) +} + +// QueryWithHeaders mocks base method. +func (m *MockHTTP) QueryWithHeaders(ctx context.Context, path string, queryParams map[string]any, body []byte, headers map[string]string) (*http.Response, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryWithHeaders", ctx, path, queryParams, body, headers) + ret0, _ := ret[0].(*http.Response) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryWithHeaders indicates an expected call of QueryWithHeaders. +func (mr *MockHTTPMockRecorder) QueryWithHeaders(ctx, path, queryParams, body, headers any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryWithHeaders", reflect.TypeOf((*MockHTTP)(nil).QueryWithHeaders), ctx, path, queryParams, body, headers) +} + // Put mocks base method. func (m *MockHTTP) Put(ctx context.Context, api string, queryParams map[string]any, body []byte) (*http.Response, error) { m.ctrl.T.Helper() @@ -390,3 +420,33 @@ func (mr *MockhttpClientMockRecorder) PutWithHeaders(ctx, api, queryParams, body mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutWithHeaders", reflect.TypeOf((*MockhttpClient)(nil).PutWithHeaders), ctx, api, queryParams, body, headers) } + +// Query mocks base method. +func (m *MockhttpClient) Query(ctx context.Context, path string, queryParams map[string]any, body []byte) (*http.Response, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Query", ctx, path, queryParams, body) + ret0, _ := ret[0].(*http.Response) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Query indicates an expected call of Query. +func (mr *MockhttpClientMockRecorder) Query(ctx, path, queryParams, body any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockhttpClient)(nil).Query), ctx, path, queryParams, body) +} + +// QueryWithHeaders mocks base method. +func (m *MockhttpClient) QueryWithHeaders(ctx context.Context, path string, queryParams map[string]any, body []byte, headers map[string]string) (*http.Response, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "QueryWithHeaders", ctx, path, queryParams, body, headers) + ret0, _ := ret[0].(*http.Response) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// QueryWithHeaders indicates an expected call of QueryWithHeaders. +func (mr *MockhttpClientMockRecorder) QueryWithHeaders(ctx, path, queryParams, body, headers any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryWithHeaders", reflect.TypeOf((*MockhttpClient)(nil).QueryWithHeaders), ctx, path, queryParams, body, headers) +} diff --git a/pkg/gofr/service/new.go b/pkg/gofr/service/new.go index 9192a77e3d..7ee009c75e 100644 --- a/pkg/gofr/service/new.go +++ b/pkg/gofr/service/new.go @@ -24,6 +24,16 @@ const ( metricLabelService = "service" ) +// methodQuery is the HTTP QUERY method (RFC 10008). It mirrors the exported +// gofrHTTP.MethodQuery / gofr.MethodQuery constant and is deliberately a second +// copy: importing gofr/http here for one string would pull gorilla/mux, +// html/template and archive/zip into the outbound HTTP client's dependency +// graph, which is nine packages the client has no other use for. (The import +// itself compiles -- there is no cycle -- so the reason is the dependency +// weight, not a build constraint.) Go's net/http has no http.MethodQuery yet. +// TestMethodQueryMatchesInboundConstant pins this string to the inbound one. +const methodQuery = "QUERY" + type httpService struct { *http.Client trace.Tracer @@ -76,6 +86,13 @@ type httpClient interface { Delete(ctx context.Context, api string, body []byte) (*http.Response, error) // DeleteWithHeaders performs an HTTP DELETE request with custom headers. DeleteWithHeaders(ctx context.Context, api string, body []byte, headers map[string]string) (*http.Response, error) + + // Query performs an HTTP QUERY request (RFC 10008). QUERY is a safe, idempotent + // method that carries the query in the request body. + Query(ctx context.Context, path string, queryParams map[string]any, body []byte) (*http.Response, error) + // QueryWithHeaders performs an HTTP QUERY request with custom headers. + QueryWithHeaders(ctx context.Context, path string, queryParams map[string]any, body []byte, + headers map[string]string) (*http.Response, error) } // NewHTTPService function creates a new instance of the httpService struct, which implements the HTTP interface. @@ -156,6 +173,16 @@ func (h *httpService) DeleteWithHeaders(ctx context.Context, path string, body [ return h.createAndSendRequest(ctx, http.MethodDelete, path, nil, body, headers) } +func (h *httpService) Query(ctx context.Context, path string, queryParams map[string]any, + body []byte) (*http.Response, error) { + return h.QueryWithHeaders(ctx, path, queryParams, body, nil) +} + +func (h *httpService) QueryWithHeaders(ctx context.Context, path string, queryParams map[string]any, + body []byte, headers map[string]string) (*http.Response, error) { + return h.createAndSendRequest(ctx, methodQuery, path, queryParams, body, headers) +} + func (h *httpService) createAndSendRequest(ctx context.Context, method string, path string, queryParams map[string]any, body []byte, headers map[string]string) (*http.Response, error) { uri := h.url + "/" + path diff --git a/pkg/gofr/service/new_test.go b/pkg/gofr/service/new_test.go index a739482af6..52857610f0 100644 --- a/pkg/gofr/service/new_test.go +++ b/pkg/gofr/service/new_test.go @@ -12,9 +12,20 @@ import ( "go.opentelemetry.io/otel/sdk/trace" "go.uber.org/mock/gomock" + gofrHTTP "gofr.dev/pkg/gofr/http" "gofr.dev/pkg/gofr/logging" ) +// TestMethodQueryMatchesInboundConstant pins the two copies of the QUERY method +// string together. The outbound client keeps its own constant rather than +// importing gofr/http (see the comment on methodQuery), so nothing but this +// assertion stops the two from drifting -- and a drift would be silent: the +// outbound call would simply use a method no GoFr server routes. +func TestMethodQueryMatchesInboundConstant(t *testing.T) { + assert.Equal(t, gofrHTTP.MethodQuery, methodQuery, + "the outbound QUERY method must be the same string the inbound router registers") +} + func TestNewHTTPService(t *testing.T) { tests := []struct { desc string @@ -442,3 +453,65 @@ func newService(t *testing.T, server *httptest.Server) *httpService { Logger: logging.NewMockLogger(logging.INFO), } } + +func TestHTTPService_Query(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + body, err := io.ReadAll(r.Body) + assert.NoError(t, err) + + assert.Equal(t, "QUERY", r.Method) + assert.Equal(t, "/search", r.URL.Path) + assert.Equal(t, "index=books", r.URL.RawQuery) + assert.JSONEq(t, `{"filter":"title"}`, string(body)) + // Content-Type defaults to application/json when the caller sets none. + assert.Equal(t, "application/json", r.Header.Get("Content-Type")) + + w.WriteHeader(http.StatusOK) + })) + defer server.Close() + + service := newService(t, server) + resp, err := service.Query(t.Context(), "search", + map[string]any{"index": "books"}, []byte(`{"filter":"title"}`)) + + validateResponse(t, resp, err, false) +} + +func TestHTTPService_QueryWithHeaders(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + body, err := io.ReadAll(r.Body) + assert.NoError(t, err) + + assert.Equal(t, "QUERY", r.Method) + assert.Equal(t, "/search", r.URL.Path) + assert.Equal(t, "application/sql", r.Header.Get("Content-Type")) + assert.Equal(t, "SELECT 1", string(body)) + + w.WriteHeader(http.StatusOK) + })) + defer server.Close() + + service := newService(t, server) + resp, err := service.QueryWithHeaders(t.Context(), "search", nil, []byte("SELECT 1"), + map[string]string{"content-type": "application/sql"}) + + validateResponse(t, resp, err, false) +} + +func TestHTTPService_Query_EmptyBody(t *testing.T) { + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + body, err := io.ReadAll(r.Body) + assert.NoError(t, err) + + assert.Equal(t, "QUERY", r.Method) + assert.Empty(t, string(body)) + + w.WriteHeader(http.StatusOK) + })) + defer server.Close() + + service := newService(t, server) + resp, err := service.Query(t.Context(), "search", nil, nil) + + validateResponse(t, resp, err, false) +} diff --git a/pkg/gofr/service/rate_limiter.go b/pkg/gofr/service/rate_limiter.go index 79e9844d5e..b2ec6f6b36 100644 --- a/pkg/gofr/service/rate_limiter.go +++ b/pkg/gofr/service/rate_limiter.go @@ -216,3 +216,29 @@ func (rl *rateLimiter) DeleteWithHeaders(ctx context.Context, path string, body return rl.HTTP.DeleteWithHeaders(ctx, path, body, headers) } + +// Query performs rate-limited HTTP QUERY request. +func (rl *rateLimiter) Query(ctx context.Context, path string, queryParams map[string]any, + body []byte) (*http.Response, error) { + fullURL := rl.buildFullURL(path) + req, _ := http.NewRequestWithContext(ctx, methodQuery, fullURL, http.NoBody) + + if err := rl.checkRateLimit(req); err != nil { + return nil, err + } + + return rl.HTTP.Query(ctx, path, queryParams, body) +} + +// QueryWithHeaders performs rate-limited HTTP QUERY request with custom headers. +func (rl *rateLimiter) QueryWithHeaders(ctx context.Context, path string, queryParams map[string]any, body []byte, + headers map[string]string) (*http.Response, error) { + fullURL := rl.buildFullURL(path) + req, _ := http.NewRequestWithContext(ctx, methodQuery, fullURL, http.NoBody) + + if err := rl.checkRateLimit(req); err != nil { + return nil, err + } + + return rl.HTTP.QueryWithHeaders(ctx, path, queryParams, body, headers) +} diff --git a/pkg/gofr/service/rate_limiter_test.go b/pkg/gofr/service/rate_limiter_test.go index 727e7d2753..d951426d81 100644 --- a/pkg/gofr/service/rate_limiter_test.go +++ b/pkg/gofr/service/rate_limiter_test.go @@ -180,3 +180,33 @@ func TestRateLimiter_HTTPMethods(t *testing.T) { _ = resp.Body.Close() } + +func TestRateLimiter_QueryMethods(t *testing.T) { + store := &mockStore{allowed: true} + + rl := &rateLimiter{ + config: RateLimiterConfig{ + KeyFunc: func(*http.Request) string { return "svc" }, + Store: store, + }, + store: store, + HTTP: &mockHTTP{}, + } + + ctx := context.Background() + + resp, err := rl.Query(ctx, "foo", nil, nil) + require.NoError(t, err) + assert.Equal(t, http.StatusOK, resp.StatusCode) + assert.Equal(t, methodQuery, resp.Header.Get("X-Mock-Method"), "rate limiter must delegate to Query, not another verb") + + defer resp.Body.Close() + + resp, err = rl.QueryWithHeaders(ctx, "foo", nil, nil, nil) + require.NoError(t, err) + assert.Equal(t, http.StatusOK, resp.StatusCode) + assert.Equal(t, methodQuery, resp.Header.Get("X-Mock-Method"), + "rate limiter must delegate to QueryWithHeaders, not another verb") + + _ = resp.Body.Close() +} diff --git a/pkg/gofr/service/retry.go b/pkg/gofr/service/retry.go index b3387b28c3..817578a17e 100644 --- a/pkg/gofr/service/retry.go +++ b/pkg/gofr/service/retry.go @@ -100,6 +100,20 @@ func (rp *retryProvider) DeleteWithHeaders(ctx context.Context, path string, bod }) } +func (rp *retryProvider) Query(ctx context.Context, path string, queryParams map[string]any, body []byte) ( + *http.Response, error) { + return rp.doWithRetry(func() (*http.Response, error) { + return rp.HTTP.Query(ctx, path, queryParams, body) + }) +} + +func (rp *retryProvider) QueryWithHeaders(ctx context.Context, path string, queryParams map[string]any, body []byte, + headers map[string]string) (*http.Response, error) { + return rp.doWithRetry(func() (*http.Response, error) { + return rp.HTTP.QueryWithHeaders(ctx, path, queryParams, body, headers) + }) +} + func (rp *retryProvider) doWithRetry(reqFunc func() (*http.Response, error)) (*http.Response, error) { var ( resp *http.Response diff --git a/pkg/gofr/service/retry_test.go b/pkg/gofr/service/retry_test.go index c26a148eff..3e80a65c97 100644 --- a/pkg/gofr/service/retry_test.go +++ b/pkg/gofr/service/retry_test.go @@ -72,6 +72,19 @@ func (*mockHTTP) DeleteWithHeaders(_ context.Context, _ string, _ []byte, _ map[ return &http.Response{StatusCode: http.StatusNoContent, Body: http.NoBody}, nil } +// Query/QueryWithHeaders stamp X-Mock-Method so a test can prove the decorator +// delegated to Query and not to some other verb whose mock also returns 200. +func (*mockHTTP) Query(_ context.Context, _ string, _ map[string]any, _ []byte) (*http.Response, error) { + return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody, + Header: http.Header{"X-Mock-Method": []string{methodQuery}}}, nil +} + +func (*mockHTTP) QueryWithHeaders(_ context.Context, _ string, _ map[string]any, _ []byte, + _ map[string]string) (*http.Response, error) { + return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody, + Header: http.Header{"X-Mock-Method": []string{methodQuery}}}, nil +} + // Helper to create a retry HTTP instance. func newRetryHTTP() HTTP { mockHTTP := &mockHTTP{} @@ -130,6 +143,31 @@ func TestRetryProvider_PostWithHeaders(t *testing.T) { assert.Equal(t, http.StatusCreated, resp.StatusCode) } +func TestRetryProvider_Query(t *testing.T) { + retryHTTP := newRetryHTTP() + + resp, err := retryHTTP.Query(t.Context(), "/test", nil, []byte("body")) + require.NoError(t, err) + + defer resp.Body.Close() + + assert.Equal(t, http.StatusOK, resp.StatusCode) + assert.Equal(t, methodQuery, resp.Header.Get("X-Mock-Method"), "retry must delegate to Query, not another verb") +} + +func TestRetryProvider_QueryWithHeaders(t *testing.T) { + retryHTTP := newRetryHTTP() + + resp, err := retryHTTP.QueryWithHeaders(t.Context(), "/test", nil, []byte("body"), + map[string]string{"Content-Type": "application/json"}) + require.NoError(t, err) + + defer resp.Body.Close() + + assert.Equal(t, http.StatusOK, resp.StatusCode) + assert.Equal(t, methodQuery, resp.Header.Get("X-Mock-Method"), "retry must delegate to QueryWithHeaders, not another verb") +} + func TestRetryProvider_Put(t *testing.T) { retryHTTP := newRetryHTTP() diff --git a/pkg/gofr/tools.go b/pkg/gofr/tools.go index cdfcb1846b..6bc83ee0b2 100644 --- a/pkg/gofr/tools.go +++ b/pkg/gofr/tools.go @@ -1,10 +1,12 @@ package gofr import ( + "bytes" "context" "encoding/json" "errors" "fmt" + "io" "net/http" "net/url" "path" @@ -28,6 +30,9 @@ const ( schemaTypeString = "string" schemaTypeObject = "object" + // bodyKey is the tool argument that carries a QUERY request body (the query payload). + bodyKey = "body" + maxToolResponseBytes = 4 << 20 // cap a captured tool response at 4 MiB ) @@ -114,16 +119,17 @@ func (rt *routerTools) specFor(method, pathTemplate string) (ai.ToolSpec, bool) return ai.ToolSpec{}, false } - // Only read-only handlers (GET/HEAD/OPTIONS) are exposed as tools; write handlers are never + // Only safe handlers are exposed as tools: read-only methods (GET/HEAD/OPTIONS) and QUERY + // (RFC 10008), which is safe and idempotent. Write handlers (POST/PUT/PATCH/DELETE) are never // exposed, so an agent cannot mutate state through the MCP surface. - if !isReadOnlyMethod(method) { + if !isExposableMethod(method) { return ai.ToolSpec{}, false } return ai.ToolSpec{ Name: toolName(method, pathTemplate), Description: method + " " + pathTemplate, - InputSchema: toolSchema(pathTemplate), + InputSchema: toolSchema(method, pathTemplate), Access: ai.ReadOnly, }, true } @@ -199,6 +205,13 @@ func isReadOnlyMethod(method string) bool { } } +// isExposableMethod reports whether a route's method may be exposed as an agent tool. Read-only +// methods (GET/HEAD/OPTIONS) and QUERY (RFC 10008 — safe and idempotent, carrying its input in the +// request body) qualify; write methods never do. +func isExposableMethod(method string) bool { + return isReadOnlyMethod(method) || method == MethodQuery +} + func toolName(method, pathTemplate string) string { var b strings.Builder @@ -216,24 +229,37 @@ func toolName(method, pathTemplate string) string { return b.String() } -// toolSchema builds the JSON Schema for a tool's arguments from the route's path parameters. A route -// with no path parameters gets no schema (nil). Only read-only handlers become tools, so there is no -// request body to describe. -func toolSchema(pathTemplate string) json.RawMessage { +// toolSchema builds the JSON Schema for a tool's arguments from the route's path parameters, plus a +// required "body" object for QUERY tools (RFC 10008 carries the query in the request body). A route +// with no path parameters and no body gets no schema (nil). +func toolSchema(method, pathTemplate string) json.RawMessage { params := pathParams(pathTemplate) - if len(params) == 0 { + needsBody := method == MethodQuery + + if len(params) == 0 && !needsBody { return nil } props := map[string]any{} + required := make([]string, 0, len(params)+1) + for _, p := range params { props[p] = map[string]string{schemaKeyType: schemaTypeString} + required = append(required, p) // path params are always required + } + + if needsBody { + props[bodyKey] = map[string]any{ + schemaKeyType: schemaTypeObject, + "description": "The QUERY request body (RFC 10008): the query payload sent to the endpoint.", + } + required = append(required, bodyKey) } schema := map[string]any{ schemaKeyType: schemaTypeObject, "properties": props, - "required": params, // path params are always required + "required": required, } out, _ := json.Marshal(schema) @@ -279,6 +305,22 @@ func buildToolRequest(ctx context.Context, method, pathTemplate string, args jso } } + // QUERY tools carry the query payload in the request body; extract it before the remaining + // arguments are mapped to path/query so it is not double-counted as a query value. + var ( + body io.Reader = http.NoBody + hasBody bool + ) + + if method == MethodQuery { + if raw, ok := fields[bodyKey]; ok { + delete(fields, bodyKey) + + body = bytes.NewReader(raw) + hasBody = true + } + } + reqPath, query, err := splitArgs(pathTemplate, fields) if err != nil { return nil, err @@ -289,13 +331,25 @@ func buildToolRequest(ctx context.Context, method, pathTemplate string, args jso target += "?" + enc } - // Read-only tools carry no request body. - return http.NewRequestWithContext(ctx, method, target, http.NoBody) + req, err := http.NewRequestWithContext(ctx, method, target, body) + if err != nil { + return nil, err + } + + if hasBody { + // MCP tool invocations always pass JSON bodies (the schema exposes `body` + // as a JSON string), so Content-Type is pinned to application/json. A + // QUERY route registered with a non-JSON binder is not reachable via MCP + // — the guard will 415 it because the Content-Type won't match. + req.Header.Set("Content-Type", "application/json") + } + + return req, nil } // splitArgs maps a tool's arguments to a path and query string. Path parameters are substituted into -// their route segment; every other argument becomes a query value. Only read-only tools are exposed, -// so there is no request body. +// their route segment; every other argument becomes a query value. For QUERY tools the body argument +// is extracted by the caller before this runs, so only path and query values remain here. func splitArgs(pathTemplate string, fields map[string]json.RawMessage, ) (reqPath string, query url.Values, err error) { params := make(map[string]bool) From df192fc086e83044ea6dbd1d2f50417efa525ae4 Mon Sep 17 00:00:00 2001 From: Akshat Singhal <65562230+akshat-kumar-singhal@users.noreply.github.com> Date: Thu, 10 Sep 2026 20:25:35 +0530 Subject: [PATCH 37/48] fix(rbac): make wildcard-method rules reachable and resolve overlapping patterns deterministically (#3808) (#3934) Co-authored-by: Aryan Mehrotra --- docs/advanced-guide/rbac/page.md | 94 +++++- pkg/gofr/rbac/config.go | 111 ++---- pkg/gofr/rbac/config_test.go | 92 +---- pkg/gofr/rbac/endpoint_matcher.go | 73 ++-- pkg/gofr/rbac/endpoint_matcher_test.go | 168 +++++----- pkg/gofr/rbac/resolver.go | 240 +++++++++++++ pkg/gofr/rbac/resolver_test.go | 448 +++++++++++++++++++++++++ 7 files changed, 923 insertions(+), 303 deletions(-) create mode 100644 pkg/gofr/rbac/resolver.go create mode 100644 pkg/gofr/rbac/resolver_test.go diff --git a/docs/advanced-guide/rbac/page.md b/docs/advanced-guide/rbac/page.md index 7a5d96c86a..6f2a6445ec 100644 --- a/docs/advanced-guide/rbac/page.md +++ b/docs/advanced-guide/rbac/page.md @@ -206,6 +206,89 @@ For endpoints that need to match multiple paths, use mux patterns: - **Middle variable**: Use `"/api/{category}/posts"` instead of `"/api/*/posts"` - Matches: `/api/tech/posts`, `/api/news/posts` +### Rule Resolution + +More than one endpoint entry can match the same request — a broad pattern and a narrow one, for +example. GoFr resolves this by **most specific wins**, rather than by the order the entries appear +in the config file. + +Specificity is compared segment by segment, and the first segment where two patterns differ decides: + +1. A literal segment (`users`) is more specific than +2. a constrained variable (`{id:[0-9]+}`), which is more specific than +3. a free variable (`{id}`), which is more specific than +4. a multi-segment catch-all (`{path:.*}`). + +If the paths are equally specific, an entry that names its methods explicitly wins over one +declared with `["*"]`. + +```json +{ + "endpoints": [ + { + "path": "/admin/{path:.*}", + "methods": ["*"], + "requiredPermissions": ["admin:read"] + }, + { + "path": "/admin/orgs/{org_id}", + "methods": ["DELETE"], + "requiredPermissions": ["admin:write"] + } + ] +} +``` + +`DELETE /admin/orgs/123` matches both entries, and the second one governs it — so `admin:write` is +required. `GET /admin/settings` matches only the first, so `admin:read` is required. + +`GET /admin/orgs/123` is the case to watch. The narrow entry is `["DELETE"]`-only, so it does not +cover a GET at all and drops out on method before specificity is ever considered — the catch-all +governs, and the request needs only `admin:read`. Writing a strict rule for one method does not +protect the other methods on that path; each method needs its own entry, or the broad entry has to +be strict enough to stand on its own. + +> **Note**: `"methods": ["*"]` — and omitting `methods` entirely, which means the same thing — +> matches **every** HTTP method, including methods GoFr does not otherwise know about. Since an +> entry states what a caller must have in order to be let through, covering an unrecognized method +> tightens enforcement rather than relaxing it. + +#### Where the ordering is not decided + +**Two patterns that score identically** — `/{a}/{b}` and `/{x}/{y}` are the same shape, so nothing +about the patterns separates them. One thing still does: an entry that **requires permissions wins +over a public one**, because a tie is a config that did not express an intent either way and +enforcing is the recoverable half of that mistake. Past that, the first entry declared wins. Avoid +writing two entries that overlap without one being plainly narrower than the other. + +**A constraint that can span segments** — a constraint containing `/`, such as `{path:[a-z/]+}`, +matches `/files/a/b/c` the way a catch-all does, so it is scored as one: least specific, losing to +any narrower entry it overlaps. That is decided by the `/` appearing in the constraint at all, not +by whether the regex can really produce one — `{id:[0-9]+/}` is scored as a catch-all even though +it is anchored to a single segment. The effect is only ever to move an entry *down* the ordering, +so it can lose to a narrower rule but never shadow one. Write multi-segment matches as `{path:.*}` +or `{path:.+}` and the scoring is exact. + +#### Declaring the same path twice + +Two entries with the same method and path are one entry: **the last one declared wins, in full**. +That includes the `public` flag — a public entry followed by a protected one for the same key is +protected, not public. Duplicates are not rejected, so it is worth checking for them in a config +assembled from more than one source. + +#### A pattern that cannot compile + +If a pattern's constraint is not valid regex — `{id:[}`, for example — the config still loads and +the application still starts, but the pattern can never match a request, so **that endpoint is not +enforced**. GoFr logs the pattern at error level on startup: + +``` +RBAC: endpoint[2]: invalid mux pattern: "/api/{id:[}": ... This endpoint will never match a +request, so it is NOT enforced - any route it was meant to govern is currently unguarded. +``` + +Treat that line as an open route, not a warning about a typo. + ## JWT-Based RBAC For production/public APIs, use JWT-based role extraction: @@ -465,9 +548,18 @@ Or use role inheritance to avoid duplication: **Route not being protected by RBAC** - Verify the route is explicitly configured in `endpoints[]` array - Check that the path pattern matches exactly (case-sensitive) -- Ensure HTTP method matches (or use `["*"]` for all methods) +- Ensure HTTP method matches (or use `["*"]` for all methods) — a rule declared for one method does + not cover the others on that path +- Check the startup logs for `invalid mux pattern` — a pattern whose constraint is not valid regex + loads but never matches, leaving that endpoint unenforced - Remember: Routes not in RBAC config are allowed to proceed (not blocked) +**The wrong permission is being required on a path two entries match** +- The more specific pattern governs — see [Rule Resolution](#rule-resolution) +- Check whether the narrower entry actually covers the request's method; if it does not, it drops + out and the broader entry applies +- If both patterns are equally specific, declaration order decides — rewrite one to be narrower + ## How It Works 1. **Role Extraction**: Extracts user role from header (`X-User-Role`) or JWT claims diff --git a/pkg/gofr/rbac/config.go b/pkg/gofr/rbac/config.go index 8edad15402..9bb8538b24 100644 --- a/pkg/gofr/rbac/config.go +++ b/pkg/gofr/rbac/config.go @@ -125,6 +125,10 @@ type Config struct { publicEndpointsMap map[string]bool `json:"-" yaml:"-"` // Key: "METHOD:/path", Value: true if public endpointMap map[string]*EndpointMapping `json:"-" yaml:"-"` // Key: "METHOD:/path", Value: endpoint object muxRouter *mux.Router `json:"-" yaml:"-"` // Used for mux pattern matching + + // rules holds every (method, path) rule ordered most-specific-first, and is the + // single source of truth for resolving a request that no exact key matches. + rules []endpointRule `json:"-" yaml:"-"` } // LoadPermissions loads RBAC configuration from a JSON or YAML file. @@ -221,6 +225,9 @@ func (c *Config) validateEndpointPath(path string, index int) error { if err := validateMuxPattern(path); err != nil { return fmt.Errorf("endpoint[%d]: invalid mux pattern: %w", index, err) } + + // Non-fatal: a pattern mux cannot compile loads, but never matches, so say so loudly. + c.logUncompilablePattern(path, index) } return nil @@ -289,19 +296,24 @@ func (c *Config) buildRolePermissionsMap() { } } -// buildEndpointPermissionMap builds the endpoint permission map from Endpoints. +// buildEndpointPermissionMap builds the endpoint permission map and the ordered rule list +// from Endpoints. func (c *Config) buildEndpointPermissionMap() error { - for _, endpoint := range c.Endpoints { + for i := range c.Endpoints { + endpoint := &c.Endpoints[i] + methods := endpoint.Methods if len(methods) == 0 { methods = []string{"*"} } - if err := c.processEndpointMethods(&endpoint, methods); err != nil { + if err := c.processEndpointMethods(endpoint, methods); err != nil { return err } } + c.rules = buildEndpointRules(c.Endpoints) + return nil } @@ -326,16 +338,24 @@ func buildEndpointKey(endpoint *EndpointMapping, methodUpper string) string { return fmt.Sprintf("%s:%s", methodUpper, pattern) } -// storeEndpointMapping stores an endpoint mapping. +// storeEndpointMapping stores an endpoint mapping. A duplicate (method, path) declaration +// overwrites the earlier one entirely - including the public flag and the permission list, which +// live in separate maps. Leaving either behind would mix the two declarations together: a public +// entry followed by a protected one for the same key would keep serving the route unauthenticated +// while reporting the protected endpoint. func (c *Config) storeEndpointMapping(endpoint *EndpointMapping, key, methodUpper string) error { // Store endpoint object for fast lookup c.endpointMap[key] = endpoint if endpoint.Public { c.publicEndpointsMap[key] = true + delete(c.endpointPermissionMap, key) + return nil } + delete(c.publicEndpointsMap, key) + if len(endpoint.RequiredPermissions) == 0 { return fmt.Errorf("%w: %s %s", ErrEndpointMissingPermissions, methodUpper, endpoint.Path) } @@ -393,16 +413,15 @@ func (c *Config) GetRolePermissions(role string) []string { // Returns all required permissions (user needs ANY of them - OR logic). // Config is read-only after initialization, so no mutex is needed. func (c *Config) GetEndpointPermission(method, path string) ([]string, bool) { - methodUpper := strings.ToUpper(method) - key := fmt.Sprintf("%s:%s", methodUpper, path) - - // Try exact match first - if perms, isPublic := c.checkExactMatch(key); isPublic || len(perms) > 0 { - return perms, isPublic + endpoint, isPublic := c.resolve(strings.ToUpper(method), path) + if endpoint == nil || isPublic { + return nil, isPublic } - // Try pattern and regex matching - return c.checkPatternMatch(methodUpper, path) + permissions := make([]string, len(endpoint.RequiredPermissions)) + copy(permissions, endpoint.RequiredPermissions) + + return permissions, false } // getExactEndpoint returns the endpoint for an exact key match (O(1) lookup). @@ -415,71 +434,3 @@ func (c *Config) getExactEndpoint(key string) (*EndpointMapping, bool) { return nil, false } - -// checkExactMatch checks for an exact endpoint match. -func (c *Config) checkExactMatch(key string) (permissions []string, isPublic bool) { - if public, ok := c.publicEndpointsMap[key]; ok && public { - return nil, true - } - - if perms, ok := c.endpointPermissionMap[key]; ok { - return perms, false - } - - return nil, false -} - -// findEndpointByPattern finds an endpoint by pattern matching (wildcards/regex). -// Only used when exact match fails, so this is O(n) but only for patterns. -// Config is read-only after initialization, so no mutex is needed. -func (c *Config) findEndpointByPattern(methodUpper, path string) (*EndpointMapping, bool) { - // Try pattern matching for wildcards/regex - // Iterate over endpointMap to find matching patterns - for key, endpoint := range c.endpointMap { - if c.matchesKey(key, methodUpper, path) { - isPublic := c.publicEndpointsMap[key] - return endpoint, isPublic - } - } - - return nil, false -} - -// checkPatternMatch checks for pattern and regex matches. -// Config is read-only after initialization, so no mutex is needed. -func (c *Config) checkPatternMatch(methodUpper, path string) (permissions []string, isPublic bool) { - // Try pattern matching for wildcards - for key, perms := range c.endpointPermissionMap { - if c.matchesKey(key, methodUpper, path) { - return perms, false - } - } - - // Check public endpoints with pattern/regex - for key := range c.publicEndpointsMap { - if c.matchesKey(key, methodUpper, path) { - return nil, true - } - } - - return nil, false -} - -// matchesKey checks if a key matches the given method and path. -// Keys are built by buildEndpointKey which uses Path (may contain mux patterns). -// Uses mux Route.Match() for mux patterns, exact match for non-pattern paths. -func (c *Config) matchesKey(key, methodUpper, path string) bool { - if !strings.HasPrefix(key, methodUpper+":") { - return false - } - - pattern := strings.TrimPrefix(key, methodUpper+":") - - // For exact paths (no variables), use string comparison - if !isMuxPattern(pattern) { - return pattern == path - } - - // For mux patterns, use Route.Match() from endpoint_matcher - return matchMuxPattern(pattern, methodUpper, path, c.muxRouter) -} diff --git a/pkg/gofr/rbac/config_test.go b/pkg/gofr/rbac/config_test.go index 26c79f69e3..437efb553a 100644 --- a/pkg/gofr/rbac/config_test.go +++ b/pkg/gofr/rbac/config_test.go @@ -384,7 +384,7 @@ func createTestConfigFile(filename, content string) (string, error) { return filename, err } -func TestConfig_FindEndpointByPattern(t *testing.T) { +func TestConfig_Resolve(t *testing.T) { t.Run("finds endpoint with mux pattern", func(t *testing.T) { config := &Config{ Endpoints: []EndpointMapping{ @@ -394,7 +394,7 @@ func TestConfig_FindEndpointByPattern(t *testing.T) { err := config.processUnifiedConfig() require.NoError(t, err) - endpoint, isPublic := config.findEndpointByPattern("GET", "/api/users") + endpoint, isPublic := config.resolve("GET", "/api/users") assert.NotNil(t, endpoint) assert.Equal(t, "/api/{resource}", endpoint.Path) assert.False(t, isPublic) @@ -409,7 +409,7 @@ func TestConfig_FindEndpointByPattern(t *testing.T) { err := config.processUnifiedConfig() require.NoError(t, err) - endpoint, isPublic := config.findEndpointByPattern("GET", "/api/users/123") + endpoint, isPublic := config.resolve("GET", "/api/users/123") assert.NotNil(t, endpoint) assert.False(t, isPublic) }) @@ -423,7 +423,7 @@ func TestConfig_FindEndpointByPattern(t *testing.T) { err := config.processUnifiedConfig() require.NoError(t, err) - endpoint, isPublic := config.findEndpointByPattern("GET", "/public/files") + endpoint, isPublic := config.resolve("GET", "/public/files") assert.NotNil(t, endpoint) assert.True(t, isPublic) }) @@ -437,7 +437,7 @@ func TestConfig_FindEndpointByPattern(t *testing.T) { err := config.processUnifiedConfig() require.NoError(t, err) - endpoint, isPublic := config.findEndpointByPattern("GET", "/other/path") + endpoint, isPublic := config.resolve("GET", "/other/path") assert.Nil(t, endpoint) assert.False(t, isPublic) }) @@ -451,92 +451,12 @@ func TestConfig_FindEndpointByPattern(t *testing.T) { err := config.processUnifiedConfig() require.NoError(t, err) - endpoint, isPublic := config.findEndpointByPattern("POST", "/api/users") + endpoint, isPublic := config.resolve("POST", "/api/users") assert.Nil(t, endpoint) assert.False(t, isPublic) }) } -func TestConfig_MatchesKey(t *testing.T) { - t.Run("matches exact path", func(t *testing.T) { - config := &Config{ - Endpoints: []EndpointMapping{ - {Path: "/api/users", Methods: []string{"GET"}, RequiredPermissions: []string{"users:read"}}, - }, - } - err := config.processUnifiedConfig() - require.NoError(t, err) - - result := config.matchesKey("GET:/api/users", "GET", "/api/users") - assert.True(t, result) - }) - - t.Run("matches mux pattern", func(t *testing.T) { - config := &Config{ - Endpoints: []EndpointMapping{ - {Path: "/api/{resource}", Methods: []string{"GET"}, RequiredPermissions: []string{"api:read"}}, - }, - } - err := config.processUnifiedConfig() - require.NoError(t, err) - - result := config.matchesKey("GET:/api/{resource}", "GET", "/api/users") - assert.True(t, result) - }) - - t.Run("matches mux pattern with constraint", func(t *testing.T) { - config := &Config{ - Endpoints: []EndpointMapping{ - {Path: "/api/users/{id:[0-9]+}", Methods: []string{"GET"}, RequiredPermissions: []string{"users:read"}}, - }, - } - err := config.processUnifiedConfig() - require.NoError(t, err) - - result := config.matchesKey("GET:/api/users/{id:[0-9]+}", "GET", "/api/users/123") - assert.True(t, result) - }) - - t.Run("matches mux pattern with constraint", func(t *testing.T) { - config := &Config{ - Endpoints: []EndpointMapping{ - {Path: "/test/{id:[0-9]+}", Methods: []string{"GET"}, RequiredPermissions: []string{"test:read"}}, - }, - } - err := config.processUnifiedConfig() - require.NoError(t, err) - - result := config.matchesKey("GET:/test/{id:[0-9]+}", "GET", "/test/456") - assert.True(t, result) - }) - - t.Run("returns false when method doesn't match", func(t *testing.T) { - config := &Config{ - Endpoints: []EndpointMapping{ - {Path: "/api/users", Methods: []string{"GET"}, RequiredPermissions: []string{"users:read"}}, - }, - } - err := config.processUnifiedConfig() - require.NoError(t, err) - - result := config.matchesKey("GET:/api/users", "POST", "/api/users") - assert.False(t, result) - }) - - t.Run("returns false for invalid mux pattern", func(t *testing.T) { - config := &Config{ - Endpoints: []EndpointMapping{ - {Path: "/api/invalid{", Methods: []string{"GET"}, RequiredPermissions: []string{"test:read"}}, - }, - } - err := config.processUnifiedConfig() - require.NoError(t, err) - - result := config.matchesKey("GET:/api/invalid{", "GET", "/test") - assert.False(t, result) - }) -} - func TestConfig_getEffectivePermissions(t *testing.T) { testCases := []struct { desc string diff --git a/pkg/gofr/rbac/endpoint_matcher.go b/pkg/gofr/rbac/endpoint_matcher.go index 2bd3833d52..d788660801 100644 --- a/pkg/gofr/rbac/endpoint_matcher.go +++ b/pkg/gofr/rbac/endpoint_matcher.go @@ -25,37 +25,10 @@ const ( var ( // errUnbalancedBraces is returned when a mux pattern has unbalanced braces. errUnbalancedBraces = errors.New("unbalanced braces in pattern") -) - -// matchEndpoint checks if the request matches an endpoint configuration. -// This is the primary authorization check using the unified Endpoints configuration. -// Returns the matched endpoint and whether it's public. -func matchEndpoint(method, route string, endpoints []EndpointMapping, config *Config) (*EndpointMapping, bool) { - for i := range endpoints { - endpoint := &endpoints[i] - - // Check if endpoint is public - if endpoint.Public { - if matchesEndpointPattern(endpoint, route, config) { - return endpoint, true - } - - continue - } - // Check method match - if !matchesHTTPMethod(method, endpoint.Methods) { - continue - } - - // Check route match - if matchesEndpointPattern(endpoint, route, config) { - return endpoint, false - } - } - - return nil, false -} + // errInvalidPattern is returned when mux cannot compile a pattern. + errInvalidPattern = errors.New("invalid mux pattern") +) // matchesHTTPMethod checks if the HTTP method matches the endpoint's allowed methods. func matchesHTTPMethod(method string, allowedMethods []string) bool { @@ -111,6 +84,9 @@ func matchMuxPattern(pattern, method, path string, router *mux.Router) bool { // validateMuxPattern validates mux pattern syntax. // Ensures balanced braces and validates regex constraints format. +// +// Whether mux can actually compile the pattern is checked separately and non-fatally by +// logUncompilablePattern - see the note there. func validateMuxPattern(pattern string) error { // Check for balanced braces openCount := strings.Count(pattern, "{") @@ -127,13 +103,32 @@ func validateMuxPattern(pattern string) error { return fmt.Errorf("%w: %s", errUnbalancedBraces, pattern) } - // Basic validation: check that braces are properly formatted - // More detailed validation would require parsing, which mux will do anyway return nil } +// logUncompilablePattern reports, at error level, an endpoint pattern that mux cannot compile - +// an unterminated character class such as "{id:[}", for example. +// +// It does not fail the load. A pattern like that passes the brace-balance check, loads cleanly, +// and then never matches any request, so the endpoint it was written to govern is left unguarded: +// the same failure shape as an unreachable wildcard-method rule, reached a different way. Refusing +// to start would close that hole, but GoFr's position is to log and stay up rather than abort on a +// config defect (gofr-dev/gofr#2378), and reversing that is not something a bugfix should do. +// Closing it properly needs the fail-closed default for unmatched routes tracked in #3935; until +// then the operator gets a loud line naming the pattern instead of silence. +func (c *Config) logUncompilablePattern(pattern string, index int) { + err := mux.NewRouter().NewRoute().Path(pattern).GetError() + if err == nil || c.Logger == nil { + return + } + + c.Logger.Errorf("RBAC: endpoint[%d]: %v: %q: %v. This endpoint will never match a request, "+ + "so it is NOT enforced - any route it was meant to govern is currently unguarded.", + index, errInvalidPattern, pattern, err) +} + // matchesEndpointPattern checks if the route matches the endpoint pattern. -// Method matching is handled separately in matchEndpoint before this function is called. +// Method matching is handled separately by endpointRule.matchesMethod before this is called. // Uses mux Route.Match() for mux patterns, exact match for non-pattern paths. func matchesEndpointPattern(endpoint *EndpointMapping, route string, config *Config) bool { if endpoint.Path == "" { @@ -197,17 +192,7 @@ func getEndpointForRequest(r *http.Request, config *Config) (*EndpointMapping, b return nil, false } - method := strings.ToUpper(r.Method) - path := r.URL.Path - key := fmt.Sprintf("%s:%s", method, path) - - // Try exact match first (O(1) lookup) - if endpoint, isPublic := config.getExactEndpoint(key); endpoint != nil { - return endpoint, isPublic - } - - // Try pattern matching (O(n) but only for patterns, not exact matches) - return config.findEndpointByPattern(method, path) + return config.resolve(strings.ToUpper(r.Method), r.URL.Path) } // ResolveRBACConfigPath resolves the RBAC config file path. diff --git a/pkg/gofr/rbac/endpoint_matcher_test.go b/pkg/gofr/rbac/endpoint_matcher_test.go index 773b660de7..c338a459c6 100644 --- a/pkg/gofr/rbac/endpoint_matcher_test.go +++ b/pkg/gofr/rbac/endpoint_matcher_test.go @@ -12,108 +12,92 @@ import ( "github.com/stretchr/testify/require" ) -func TestMatchEndpoint_ExactMatch(t *testing.T) { - config := &Config{ - Endpoints: []EndpointMapping{ - {Path: "/api/users", Methods: []string{"GET"}, RequiredPermissions: []string{"users:read"}}, +// TestConfig_resolve_Cases covers the resolution cases that used to be exercised through the +// now-deleted matchEndpoint helper. They run against config.resolve, which is the single entry +// point the middleware and GetEndpointPermission both use. +func TestConfig_resolve_Cases(t *testing.T) { + testCases := []struct { + desc string + endpoints []EndpointMapping + method string + path string + expectedPath string + expectedPublic bool + }{ + { + desc: "exact match", + endpoints: []EndpointMapping{{Path: "/api/users", Methods: []string{"GET"}, RequiredPermissions: []string{"users:read"}}}, + method: http.MethodGet, + path: "/api/users", + expectedPath: "/api/users", }, - } - _ = config.processUnifiedConfig() - endpoints := config.Endpoints - endpoint, isPublic := matchEndpoint("GET", "/api/users", endpoints, config) - require.NotNil(t, endpoint) - assert.False(t, isPublic) -} - -func TestMatchEndpoint_PublicEndpoint(t *testing.T) { - config := &Config{ - Endpoints: []EndpointMapping{ - {Path: "/health", Methods: []string{"GET"}, Public: true}, + { + desc: "public endpoint", + endpoints: []EndpointMapping{{Path: "/health", Methods: []string{"GET"}, Public: true}}, + method: http.MethodGet, + path: "/health", + expectedPath: "/health", + expectedPublic: true, }, - } - _ = config.processUnifiedConfig() - endpoints := config.Endpoints - endpoint, isPublic := matchEndpoint("GET", "/health", endpoints, config) - require.NotNil(t, endpoint) - assert.True(t, isPublic) -} - -func TestMatchEndpoint_DifferentMethod(t *testing.T) { - config := &Config{ - Endpoints: []EndpointMapping{ - {Path: "/api/users", Methods: []string{"GET"}, RequiredPermissions: []string{"users:read"}}, + { + desc: "declared method does not cover the request method", + endpoints: []EndpointMapping{{Path: "/api/users", Methods: []string{"GET"}, RequiredPermissions: []string{"users:read"}}}, + method: http.MethodPost, + path: "/api/users", }, - } - _ = config.processUnifiedConfig() - endpoints := config.Endpoints - endpoint, isPublic := matchEndpoint("POST", "/api/users", endpoints, config) - require.Nil(t, endpoint) - assert.False(t, isPublic) -} - -func TestMatchEndpoint_WildcardMethod(t *testing.T) { - config := &Config{ - Endpoints: []EndpointMapping{ - {Path: "/api", Methods: []string{"*"}, RequiredPermissions: []string{"api:*"}}, + { + desc: "wildcard method", + endpoints: []EndpointMapping{{Path: "/api", Methods: []string{"*"}, RequiredPermissions: []string{"api:read"}}}, + method: http.MethodPost, + path: "/api", + expectedPath: "/api", }, - } - _ = config.processUnifiedConfig() - endpoints := config.Endpoints - endpoint, isPublic := matchEndpoint("POST", "/api", endpoints, config) - require.NotNil(t, endpoint) - assert.False(t, isPublic) -} - -func TestMatchEndpoint_MuxPatternPath(t *testing.T) { - config := &Config{ - Endpoints: []EndpointMapping{ - {Path: "/api/{resource}", Methods: []string{"GET"}, RequiredPermissions: []string{"api:read"}}, + { + desc: "omitted methods behaves as wildcard", + endpoints: []EndpointMapping{{Path: "/api", Methods: []string{}, RequiredPermissions: []string{"api:read"}}}, + method: http.MethodPost, + path: "/api", + expectedPath: "/api", }, - } - _ = config.processUnifiedConfig() - endpoints := config.Endpoints - endpoint, isPublic := matchEndpoint("GET", "/api/users", endpoints, config) - require.NotNil(t, endpoint) - assert.False(t, isPublic) -} - -func TestMatchEndpoint_MuxPatternWithConstraint(t *testing.T) { - config := &Config{ - Endpoints: []EndpointMapping{ - {Path: "/api/users/{id:[0-9]+}", Methods: []string{"GET"}, RequiredPermissions: []string{"users:read"}}, + { + desc: "mux pattern path", + endpoints: []EndpointMapping{{Path: "/api/{resource}", Methods: []string{"GET"}, RequiredPermissions: []string{"api:read"}}}, + method: http.MethodGet, + path: "/api/users", + expectedPath: "/api/{resource}", }, - } - _ = config.processUnifiedConfig() - endpoints := config.Endpoints - endpoint, isPublic := matchEndpoint("GET", "/api/users/123", endpoints, config) - require.NotNil(t, endpoint) - assert.False(t, isPublic) -} - -func TestMatchEndpoint_NotFound(t *testing.T) { - config := &Config{ - Endpoints: []EndpointMapping{ - {Path: "/api/users", Methods: []string{"GET"}, RequiredPermissions: []string{"users:read"}}, + { + desc: "mux pattern with constraint", + endpoints: []EndpointMapping{{Path: "/api/users/{id:[0-9]+}", Methods: []string{"GET"}, RequiredPermissions: []string{"users:read"}}}, + method: http.MethodGet, + path: "/api/users/123", + expectedPath: "/api/users/{id:[0-9]+}", + }, + { + desc: "no configured endpoint matches", + endpoints: []EndpointMapping{{Path: "/api/users", Methods: []string{"GET"}, RequiredPermissions: []string{"users:read"}}}, + method: http.MethodGet, + path: "/api/posts", }, } - _ = config.processUnifiedConfig() - endpoints := config.Endpoints - endpoint, isPublic := matchEndpoint("GET", "/api/posts", endpoints, config) - require.Nil(t, endpoint) - assert.False(t, isPublic) -} -func TestMatchEndpoint_EmptyMethods(t *testing.T) { - config := &Config{ - Endpoints: []EndpointMapping{ - {Path: "/api", Methods: []string{}, RequiredPermissions: []string{"api:*"}}, - }, + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + config := newTestConfig(t, tc.endpoints, nil) + + endpoint, isPublic := config.resolve(tc.method, tc.path) + + assert.Equal(t, tc.expectedPublic, isPublic) + + if tc.expectedPath == "" { + assert.Nil(t, endpoint) + return + } + + require.NotNil(t, endpoint) + assert.Equal(t, tc.expectedPath, endpoint.Path) + }) } - _ = config.processUnifiedConfig() - endpoints := config.Endpoints - endpoint, isPublic := matchEndpoint("POST", "/api", endpoints, config) - require.NotNil(t, endpoint) - assert.False(t, isPublic) } func TestMatchesHTTPMethod(t *testing.T) { diff --git a/pkg/gofr/rbac/resolver.go b/pkg/gofr/rbac/resolver.go new file mode 100644 index 0000000000..d7a07e4daf --- /dev/null +++ b/pkg/gofr/rbac/resolver.go @@ -0,0 +1,240 @@ +package rbac + +import ( + "sort" + "strings" +) + +// Segment specificity scores, compared segment by segment to order overlapping rules. +// Each level constrains the set of paths a segment can match more tightly than the one below it: +// a literal matches one string, a constrained variable matches one segment drawn from a regex, +// a free variable matches any one segment, and a catch-all matches any number of them. +const ( + segCatchAll = iota + 1 // {path:.*} - matches any number of segments + segVariable // {id} - matches exactly one segment, unconstrained + segConstrained // {id:[0-9]+} - matches exactly one segment, and only some of them + segLiteral // users - matches itself +) + +// endpointRule is one (path, method) pair from the config, pre-scored so that overlapping +// rules resolve deterministically. Rules are sorted once at load time. +type endpointRule struct { + endpoint *EndpointMapping + + // pattern is the endpoint path, which may contain mux variables. + pattern string + + // method is the upper-cased declared method, or "*" for all methods. + method string + + // isPublic mirrors endpoint.Public. + isPublic bool + + // pathScore is the per-segment specificity of pattern. + pathScore []int + + // methodScore is 1 for an explicitly declared method and 0 for "*", so that an explicit + // method wins over a wildcard on an otherwise equally specific path. + methodScore int +} + +// matchesMethod reports whether the rule covers the given upper-cased request method. +// A rule declared with "*" covers every method, including methods GoFr does not know about +// (WebDAV verbs, for example). That is the safe direction here: because a rule imposes a +// permission requirement rather than granting access, covering an unknown verb tightens +// enforcement rather than loosening it. +func (r *endpointRule) matchesMethod(methodUpper string) bool { + return matchesHTTPMethod(methodUpper, []string{r.method}) +} + +// matches reports whether the rule covers the given request. +func (r *endpointRule) matches(methodUpper, path string, config *Config) bool { + return r.matchesMethod(methodUpper) && matchesEndpointPattern(r.endpoint, path, config) +} + +// buildEndpointRules expands endpoints into one rule per declared method and orders them +// most-specific-first, so that a narrower rule governs a request even when a broader one is +// declared ahead of it. Rules that score identically on the path - two patterns of the +// same shape, such as "/{a}/{b}" and "/{x}/{y}" - are separated first by method, an explicitly +// declared one outranking "*", and then by enforcement, a rule that requires permissions +// outranking a public one. Declaration order decides only between rules alike on all three. +// +// Duplicate (method, path) declarations collapse to the last one, matching how the lookup +// maps are built, so both resolution paths always agree. +func buildEndpointRules(endpoints []EndpointMapping) []endpointRule { + byKey := make(map[string]endpointRule, len(endpoints)) + order := make([]string, 0, len(endpoints)) + + for i := range endpoints { + endpoint := &endpoints[i] + + methods := endpoint.Methods + if len(methods) == 0 { + methods = []string{"*"} + } + + for _, method := range methods { + methodUpper := strings.ToUpper(method) + key := buildEndpointKey(endpoint, methodUpper) + + methodScore := 1 + if methodUpper == "*" { + methodScore = 0 + } + + if _, seen := byKey[key]; !seen { + order = append(order, key) + } + + byKey[key] = endpointRule{ + endpoint: endpoint, + pattern: endpoint.Path, + method: methodUpper, + isPublic: endpoint.Public, + pathScore: pathSpecificity(endpoint.Path), + methodScore: methodScore, + } + } + } + + rules := make([]endpointRule, 0, len(order)) + for _, key := range order { + rules = append(rules, byKey[key]) + } + + sort.SliceStable(rules, func(i, j int) bool { + if cmp := compareSpecificity(rules[i].pathScore, rules[j].pathScore); cmp != 0 { + return cmp > 0 + } + + if rules[i].methodScore != rules[j].methodScore { + return rules[i].methodScore > rules[j].methodScore + } + + // Nothing about the patterns separates them, so fall back on the safer outcome: a rule + // that requires permissions outranks a public one. A tie is a config the operator did not + // intend either way, and enforcing is the recoverable half of that mistake. + return !rules[i].isPublic && rules[j].isPublic + }) + + return rules +} + +// pathSpecificity scores each segment of a path pattern. +func pathSpecificity(pattern string) []int { + if pattern == "" { + return nil + } + + segments := splitPatternSegments(strings.Trim(pattern, "/")) + scores := make([]int, 0, len(segments)) + + for _, segment := range segments { + switch { + case !strings.HasPrefix(segment, "{") || !strings.HasSuffix(segment, "}"): + scores = append(scores, segLiteral) + case isCatchAllVariable(segment): + scores = append(scores, segCatchAll) + case strings.Contains(segment, ":"): + scores = append(scores, segConstrained) + default: + scores = append(scores, segVariable) + } + } + + return scores +} + +// splitPatternSegments splits a path pattern on "/", ignoring separators that sit inside a +// "{name:regex}" constraint - "{path:[a-z/]+}" is one segment, not three. Splitting naively +// would shatter such a constraint into fragments that each look like a literal, scoring the +// loosest pattern in the config as the most specific one. +func splitPatternSegments(pattern string) []string { + var ( + segments []string + depth int + start int + ) + + for i, r := range pattern { + switch r { + case '{': + depth++ + case '}': + if depth > 0 { + depth-- + } + case '/': + if depth == 0 { + segments = append(segments, pattern[start:i]) + start = i + 1 + } + } + } + + return append(segments, pattern[start:]) +} + +// isCatchAllVariable reports whether a "{name:regex}" segment can span multiple path +// segments. Two kinds qualify: the documented ".*" and ".+" forms, and any constraint that +// admits "/" itself, such as "{path:[a-z/]+}" - it matches "/files/a/b/c" just as a +// catch-all would, so scoring it as a single-segment variable would let the loosest pattern in +// the config outrank a narrower one it fully contains. +// +// Whether the constraint can *actually* produce a "/" is not decided here; a "/" appearing +// anywhere in it is enough. Deciding it properly means parsing the regex, and the conservative +// answer only ever moves a pattern down the ordering, which is the safe direction: it can lose +// to a narrower rule, never shadow one. +func isCatchAllVariable(segment string) bool { + inner := segment[1 : len(segment)-1] + + idx := strings.Index(inner, ":") + if idx < 0 { + return false + } + + constraint := strings.TrimSpace(inner[idx+1:]) + + return constraint == ".*" || constraint == ".+" || strings.Contains(constraint, "/") +} + +// compareSpecificity orders two segment score vectors, most specific first. +// The first differing segment decides; if one vector is a prefix of the other, the longer +// (more constrained) pattern wins. Returns >0 when a is more specific than b. +func compareSpecificity(a, b []int) int { + for i := 0; i < len(a) && i < len(b); i++ { + if a[i] != b[i] { + return a[i] - b[i] + } + } + + return len(a) - len(b) +} + +// resolveEndpoint returns the most specific rule covering the request, and whether it is public. +func resolveEndpoint(methodUpper, path string, rules []endpointRule, config *Config) (*EndpointMapping, bool) { + for i := range rules { + if rules[i].matches(methodUpper, path, config) { + return rules[i].endpoint, rules[i].isPublic + } + } + + return nil, false +} + +// resolve finds the endpoint governing a request, preferring the O(1) exact-path lookups. +// +// The exact lookups stay consistent with the ordered scan because a literal path is always +// more specific than any pattern, and an explicitly declared method is always preferred over +// a wildcard one - which is why the request's own method is probed before "*". +func (c *Config) resolve(methodUpper, path string) (*EndpointMapping, bool) { + if endpoint, isPublic := c.getExactEndpoint(methodUpper + ":" + path); endpoint != nil { + return endpoint, isPublic + } + + if endpoint, isPublic := c.getExactEndpoint("*:" + path); endpoint != nil { + return endpoint, isPublic + } + + return resolveEndpoint(methodUpper, path, c.rules, c) +} diff --git a/pkg/gofr/rbac/resolver_test.go b/pkg/gofr/rbac/resolver_test.go new file mode 100644 index 0000000000..41e3e41236 --- /dev/null +++ b/pkg/gofr/rbac/resolver_test.go @@ -0,0 +1,448 @@ +package rbac + +import ( + "net/http" + "net/http/httptest" + "os" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// newTestConfig builds a Config from endpoints and processes it, failing the test on error. +func newTestConfig(tb testing.TB, endpoints []EndpointMapping, roles []RoleDefinition) *Config { + tb.Helper() + + config := &Config{Endpoints: endpoints, Roles: roles, RoleHeader: "X-User-Role"} + require.NoError(tb, config.processUnifiedConfig()) + + return config +} + +func TestGetEndpointForRequest_WildcardMethod(t *testing.T) { + testCases := []struct { + desc string + methods []string + requestMethod string + expectMatch bool + }{ + {"wildcard matches GET", []string{"*"}, http.MethodGet, true}, + {"wildcard matches DELETE", []string{"*"}, http.MethodDelete, true}, + {"wildcard matches custom method", []string{"*"}, "PROPFIND", true}, + {"omitted methods matches DELETE", nil, http.MethodDelete, true}, + {"empty methods matches DELETE", []string{}, http.MethodDelete, true}, + {"explicit method matches itself", []string{"GET"}, http.MethodGet, true}, + {"explicit method does not match other", []string{"GET"}, http.MethodDelete, false}, + {"lowercase declaration matches", []string{"get"}, http.MethodGet, true}, + } + + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + config := newTestConfig(t, []EndpointMapping{ + {Path: "/admin/{path:.*}", Methods: tc.methods, RequiredPermissions: []string{"admin:read"}}, + }, nil) + + req := httptest.NewRequestWithContext(t.Context(), tc.requestMethod, "/admin/orgs/123", http.NoBody) + endpoint, isPublic := getEndpointForRequest(req, config) + + assert.False(t, isPublic) + + if tc.expectMatch { + require.NotNil(t, endpoint, "expected the rule to match") + assert.Equal(t, "/admin/{path:.*}", endpoint.Path) + } else { + assert.Nil(t, endpoint) + } + }) + } +} + +func TestGetEndpointForRequest_MostSpecificWins(t *testing.T) { + broad := EndpointMapping{Path: "/admin/{path:.*}", Methods: []string{"*"}, RequiredPermissions: []string{"admin:read"}} + narrow := EndpointMapping{Path: "/admin/orgs/{org_id}", Methods: []string{"DELETE"}, RequiredPermissions: []string{"admin:write"}} + literal := EndpointMapping{Path: "/admin/orgs/global", Methods: []string{"DELETE"}, RequiredPermissions: []string{"admin:super"}} + + // A constrained variable admits fewer paths than a free one, so it has to outrank it - + // otherwise these two score equally and the sort falls through to declaration order. + free := EndpointMapping{Path: "/users/{id}", Methods: []string{"*"}, RequiredPermissions: []string{"users:read"}} + constrained := EndpointMapping{Path: "/users/{id:[0-9]+}", Methods: []string{"*"}, RequiredPermissions: []string{"users:write"}} + + // Same depth, differing only in one segment, and the more specific one is declared last: these + // go red if segments stop being compared position by position, where a case whose patterns + // differ in length or that a literal path resolves by exact lookup would still pass. + varPrefix := EndpointMapping{Path: "/{scope}/orgs/{org_id}", Methods: []string{"*"}, RequiredPermissions: []string{"scope:read"}} + varTail := EndpointMapping{Path: "/admin/{section}/{org_id}", Methods: []string{"*"}, RequiredPermissions: []string{"admin:list"}} + litTail := EndpointMapping{Path: "/admin/orgs/{org_id}", Methods: []string{"*"}, RequiredPermissions: []string{"orgs:read"}} + + testCases := []struct { + desc string + endpoints []EndpointMapping + path string + expected string + }{ + {"narrow wins over broad", []EndpointMapping{broad, narrow}, "/admin/orgs/123", "/admin/orgs/{org_id}"}, + {"declaration order is irrelevant", []EndpointMapping{narrow, broad}, "/admin/orgs/123", "/admin/orgs/{org_id}"}, + {"literal wins over param", []EndpointMapping{broad, narrow, literal}, "/admin/orgs/global", "/admin/orgs/global"}, + {"literal segment wins over a variable in the same position", []EndpointMapping{varPrefix, litTail}, + "/admin/orgs/123", "/admin/orgs/{org_id}"}, + {"the first differing segment decides", []EndpointMapping{varPrefix, varTail}, "/admin/orgs/123", "/admin/{section}/{org_id}"}, + {"broad wins when it is the only match", []EndpointMapping{broad, narrow}, "/admin/settings", "/admin/{path:.*}"}, + {"constrained variable wins over free one", []EndpointMapping{free, constrained}, "/users/42", "/users/{id:[0-9]+}"}, + {"constrained variable wins in either declaration order", []EndpointMapping{constrained, free}, "/users/42", "/users/{id:[0-9]+}"}, + {"free variable still matches what the constraint rejects", []EndpointMapping{constrained, free}, "/users/me", "/users/{id}"}, + } + + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + config := newTestConfig(t, tc.endpoints, nil) + + // Repeat to catch map-iteration nondeterminism: Go randomizes range order per range. + for range 100 { + req := httptest.NewRequestWithContext(t.Context(), http.MethodDelete, tc.path, http.NoBody) + endpoint, _ := getEndpointForRequest(req, config) + + require.NotNil(t, endpoint) + require.Equal(t, tc.expected, endpoint.Path) + } + }) + } +} + +func TestGetEndpointForRequest_ExplicitMethodBeatsWildcard(t *testing.T) { + // A literal path is answered by the exact-key fast path, which probes the request's own + // method before "*". A pattern path has no exact key, so it reaches the ordered scan and is + // the only case that exercises the methodScore tie-break in buildEndpointRules - with the + // wildcard declared first, so a stable sort alone cannot produce the right answer. + wildcardLiteral := EndpointMapping{Path: "/admin/reports", Methods: []string{"*"}, RequiredPermissions: []string{"admin:read"}} + deleteLiteral := EndpointMapping{Path: "/admin/reports", Methods: []string{"DELETE"}, RequiredPermissions: []string{"admin:write"}} + + wildcardPattern := EndpointMapping{Path: "/admin/{id}", Methods: []string{"*"}, RequiredPermissions: []string{"admin:read"}} + deletePattern := EndpointMapping{Path: "/admin/{id}", Methods: []string{"DELETE"}, RequiredPermissions: []string{"admin:write"}} + + testCases := []struct { + desc string + endpoints []EndpointMapping + path string + expected []string + }{ + {"exact path, wildcard declared first", []EndpointMapping{wildcardLiteral, deleteLiteral}, "/admin/reports", []string{"admin:write"}}, + {"exact path, explicit declared first", []EndpointMapping{deleteLiteral, wildcardLiteral}, "/admin/reports", []string{"admin:write"}}, + {"pattern path, wildcard declared first", []EndpointMapping{wildcardPattern, deletePattern}, "/admin/42", []string{"admin:write"}}, + {"pattern path, explicit declared first", []EndpointMapping{deletePattern, wildcardPattern}, "/admin/42", []string{"admin:write"}}, + } + + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + config := newTestConfig(t, tc.endpoints, nil) + + for range 100 { + req := httptest.NewRequestWithContext(t.Context(), http.MethodDelete, tc.path, http.NoBody) + endpoint, _ := getEndpointForRequest(req, config) + + require.NotNil(t, endpoint) + require.Equal(t, tc.expected, endpoint.RequiredPermissions) + } + }) + } + + t.Run("the wildcard rule still governs a method the explicit one does not cover", func(t *testing.T) { + config := newTestConfig(t, []EndpointMapping{wildcardPattern, deletePattern}, nil) + + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/admin/42", http.NoBody) + endpoint, _ := getEndpointForRequest(req, config) + + require.NotNil(t, endpoint) + require.Equal(t, []string{"admin:read"}, endpoint.RequiredPermissions) + }) +} + +func TestConfig_GetEndpointPermission_WildcardMethod(t *testing.T) { + testCases := []struct { + desc string + method string + path string + expectedPerms []string + expectedPublic bool + }{ + {"wildcard rule is reachable", http.MethodDelete, "/admin/orgs/123", []string{"admin:read"}, false}, + {"most specific rule wins", http.MethodGet, "/team/reports", []string{"team:read"}, false}, + {"public rule reported as public", http.MethodGet, "/health", nil, true}, + {"unconfigured path returns nothing", http.MethodGet, "/nope", nil, false}, + } + + config := newTestConfig(t, []EndpointMapping{ + {Path: "/admin/{path:.*}", Methods: []string{"*"}, RequiredPermissions: []string{"admin:read"}}, + {Path: "/team/reports", Methods: []string{"GET"}, RequiredPermissions: []string{"team:read"}}, + {Path: "/health", Methods: []string{"GET"}, Public: true}, + }, nil) + + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + perms, isPublic := config.GetEndpointPermission(tc.method, tc.path) + + assert.Equal(t, tc.expectedPublic, isPublic) + assert.Equal(t, tc.expectedPerms, perms) + }) + } +} + +func TestMiddleware_WildcardMethodEnforcement(t *testing.T) { + testCases := []struct { + desc string + role string + expectedCode int + }{ + {"no role is rejected", "", http.StatusUnauthorized}, + {"insufficient role is rejected", "viewer", http.StatusForbidden}, + {"authorized role is allowed", "admin", http.StatusOK}, + } + + config := newTestConfig(t, + []EndpointMapping{ + {Path: "/admin/{path:.*}", Methods: []string{"*"}, RequiredPermissions: []string{"admin:write"}}, + }, + []RoleDefinition{ + {Name: "admin", Permissions: []string{"admin:write"}}, + {Name: "viewer", Permissions: []string{"admin:read"}}, + }, + ) + + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + reached := false + handler := Middleware(config)(http.HandlerFunc(func(http.ResponseWriter, *http.Request) { + reached = true + })) + + req := httptest.NewRequestWithContext(t.Context(), http.MethodDelete, "/admin/orgs/123", http.NoBody) + if tc.role != "" { + req.Header.Set("X-User-Role", tc.role) + } + + rec := httptest.NewRecorder() + handler.ServeHTTP(rec, req) + + assert.Equal(t, tc.expectedCode, rec.Code) + assert.Equal(t, tc.expectedCode == http.StatusOK, reached) + }) + } +} + +func TestLoadPermissions_UncompilablePatternIsNonFatal(t *testing.T) { + testCases := []struct { + desc string + path string + expectLog bool + }{ + {"unparsable regex constraint", "/api/{id:[}", true}, + {"unbalanced parenthesis in constraint", "/api/{id:(}", true}, + {"valid numeric constraint", "/api/{id:[0-9]+}", false}, + {"valid catch-all", "/api/{path:.*}", false}, + {"plain path", "/api/users", false}, + } + + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + fileContent := `{ + "roles": [{"name": "admin", "permissions": ["admin:read"]}], + "endpoints": [{"path": "` + tc.path + `", "methods": ["GET"], "requiredPermissions": ["admin:read"]}] + }` + + path, err := createTestConfigFile("test_pattern_config.json", fileContent) + require.NoError(t, err) + + defer os.Remove(path) + + logger := &mockLogger{} + + config, err := LoadPermissions("test_pattern_config.json", logger, nil, nil) + + // A pattern mux cannot compile does not stop the app from booting - it is logged loudly + // instead, because the endpoint it governs will silently never match. + require.NoError(t, err) + require.NotNil(t, config) + + if tc.expectLog { + require.Len(t, logger.errorLogs, 1) + assert.Contains(t, logger.errorLogs[0], tc.path) + assert.Contains(t, logger.errorLogs[0], "NOT enforced") + } else { + assert.Empty(t, logger.errorLogs) + } + }) + } +} + +func TestLoadPermissions_UncompilablePatternWithoutLogger(t *testing.T) { + fileContent := `{ + "roles": [{"name": "admin", "permissions": ["admin:read"]}], + "endpoints": [{"path": "/api/{id:[}", "methods": ["GET"], "requiredPermissions": ["admin:read"]}] + }` + + path, err := createTestConfigFile("test_pattern_nolog_config.json", fileContent) + require.NoError(t, err) + + defer os.Remove(path) + + config, err := LoadPermissions("test_pattern_nolog_config.json", nil, nil, nil) + + require.NoError(t, err) + assert.NotNil(t, config) +} + +func TestLoadPermissions_UnbalancedBracesStillFails(t *testing.T) { + fileContent := `{ + "roles": [{"name": "admin", "permissions": ["admin:read"]}], + "endpoints": [{"path": "/api/{id}}", "methods": ["GET"], "requiredPermissions": ["admin:read"]}] + }` + + path, err := createTestConfigFile("test_pattern_braces_config.json", fileContent) + require.NoError(t, err) + + defer os.Remove(path) + + config, err := LoadPermissions("test_pattern_braces_config.json", nil, nil, nil) + + require.ErrorIs(t, err, errUnbalancedBraces) + assert.Nil(t, config) +} + +func TestPathSpecificity(t *testing.T) { + testCases := []struct { + desc string + pattern string + expected []int + }{ + {"empty pattern has no segments", "", nil}, + {"literal segments", "/admin/orgs/global", []int{segLiteral, segLiteral, segLiteral}}, + {"free variable", "/users/{id}", []int{segLiteral, segVariable}}, + {"constrained variable", "/users/{id:[0-9]+}", []int{segLiteral, segConstrained}}, + {"constrained variable with a quantifier", "/users/{id:[0-9]{2,3}}", []int{segLiteral, segConstrained}}, + {"documented catch-all", "/admin/{path:.*}", []int{segLiteral, segCatchAll}}, + {"one-or-more catch-all", "/admin/{path:.+}", []int{segLiteral, segCatchAll}}, + + // A "/" inside the constraint must not be treated as a segment separator: splitting on it + // would leave three fragments that each look literal, scoring the loosest pattern in the + // config as the most specific one. + {"constraint admitting a slash spans segments", "/files/{path:[a-z/]+}", []int{segLiteral, segCatchAll}}, + } + + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + assert.Equal(t, tc.expected, pathSpecificity(tc.pattern)) + }) + } +} + +func TestCompareSpecificity(t *testing.T) { + testCases := []struct { + desc string + a, b []int + expectAFirst bool + expectTie bool + }{ + {"literal beats constrained in the same position", []int{segLiteral, segLiteral}, []int{segLiteral, segConstrained}, true, false}, + {"constrained beats free", []int{segLiteral, segConstrained}, []int{segLiteral, segVariable}, true, false}, + {"free beats catch-all", []int{segLiteral, segVariable}, []int{segLiteral, segCatchAll}, true, false}, + {"the first differing segment decides, not later ones", []int{segCatchAll, segLiteral}, []int{segLiteral, segCatchAll}, false, false}, + {"a longer path wins when one is a prefix of the other", []int{segLiteral, segLiteral}, []int{segLiteral}, true, false}, + {"identical vectors tie", []int{segLiteral, segVariable}, []int{segLiteral, segVariable}, false, true}, + } + + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + got := compareSpecificity(tc.a, tc.b) + + if tc.expectTie { + assert.Equal(t, 0, got) + return + } + + assert.Equal(t, tc.expectAFirst, got > 0) + // The comparison has to be antisymmetric, or sort.SliceStable's ordering is undefined. + assert.Equal(t, tc.expectAFirst, compareSpecificity(tc.b, tc.a) < 0) + }) + } +} + +func TestGetEndpointForRequest_DuplicateDeclarationLastWins(t *testing.T) { + public := EndpointMapping{Path: "/admin/reports", Methods: []string{"GET"}, Public: true} + protected := EndpointMapping{Path: "/admin/reports", Methods: []string{"GET"}, RequiredPermissions: []string{"admin:read"}} + + testCases := []struct { + desc string + endpoints []EndpointMapping + expectedPublic bool + expectedPerms []string + }{ + // The public flag and the permission list live in maps of their own, so overwriting the + // endpoint alone would leave the earlier declaration's flag behind - and a stale public + // flag serves the route unauthenticated. + {"protected declared last is enforced", []EndpointMapping{public, protected}, false, []string{"admin:read"}}, + {"public declared last is public", []EndpointMapping{protected, public}, true, nil}, + } + + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + config := newTestConfig(t, tc.endpoints, nil) + + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/admin/reports", http.NoBody) + endpoint, isPublic := getEndpointForRequest(req, config) + + require.NotNil(t, endpoint) + assert.Equal(t, tc.expectedPublic, isPublic) + assert.Equal(t, tc.expectedPerms, endpoint.RequiredPermissions) + + perms, isPublic := config.GetEndpointPermission(http.MethodGet, "/admin/reports") + assert.Equal(t, tc.expectedPublic, isPublic) + assert.Equal(t, tc.expectedPerms, perms) + }) + } +} + +func TestGetEndpointForRequest_ProtectedBeatsPublicOnTie(t *testing.T) { + public := EndpointMapping{Path: "/{a}/{b}", Methods: []string{"GET"}, Public: true} + protected := EndpointMapping{Path: "/{x}/{y}", Methods: []string{"GET"}, RequiredPermissions: []string{"admin:read"}} + + testCases := []struct { + desc string + endpoints []EndpointMapping + }{ + {"public declared first", []EndpointMapping{public, protected}}, + {"protected declared first", []EndpointMapping{protected, public}}, + } + + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + config := newTestConfig(t, tc.endpoints, nil) + + for range 100 { + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/foo/bar", http.NoBody) + endpoint, isPublic := getEndpointForRequest(req, config) + + require.NotNil(t, endpoint) + assert.False(t, isPublic, "a tie must not resolve to the public rule") + assert.Equal(t, "/{x}/{y}", endpoint.Path) + } + }) + } +} + +func TestGetEndpointForRequest_SlashConstraintDoesNotOutrankNarrowRule(t *testing.T) { + // "{path:[a-z/]+}" spans segments exactly as "{path:.*}" does. Scored naively it reads as + // three literal segments and outranks the narrow rule below, which is the fail-open direction + // when the broad rule is the more permissive one. + broad := EndpointMapping{Path: "/files/{path:[a-z/]+}", Methods: []string{"*"}, RequiredPermissions: []string{"files:read"}} + narrow := EndpointMapping{Path: "/files/private/{name}", Methods: []string{"*"}, RequiredPermissions: []string{"files:admin"}} + + for _, endpoints := range [][]EndpointMapping{{broad, narrow}, {narrow, broad}} { + config := newTestConfig(t, endpoints, nil) + + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/files/private/secret", http.NoBody) + endpoint, _ := getEndpointForRequest(req, config) + + require.NotNil(t, endpoint) + assert.Equal(t, "/files/private/{name}", endpoint.Path) + } +} From 1a76a6aaae02d1cce8e0d366fd69eab28fe115dd Mon Sep 17 00:00:00 2001 From: Akshat Singhal <65562230+akshat-kumar-singhal@users.noreply.github.com> Date: Fri, 11 Sep 2026 14:13:16 +0530 Subject: [PATCH 38/48] fix(rbac): compile endpoint patterns once at load, not per rule per request (#3979) (#4047) --- pkg/gofr/rbac/config.go | 8 - pkg/gofr/rbac/endpoint_matcher.go | 99 +++++------- pkg/gofr/rbac/endpoint_matcher_test.go | 168 ++++++-------------- pkg/gofr/rbac/resolver.go | 35 ++++- pkg/gofr/rbac/resolver_concurrency_test.go | 175 +++++++++++++++++++++ 5 files changed, 289 insertions(+), 196 deletions(-) create mode 100644 pkg/gofr/rbac/resolver_concurrency_test.go diff --git a/pkg/gofr/rbac/config.go b/pkg/gofr/rbac/config.go index 9bb8538b24..7bc1a18a7f 100644 --- a/pkg/gofr/rbac/config.go +++ b/pkg/gofr/rbac/config.go @@ -9,7 +9,6 @@ import ( "path/filepath" "strings" - "github.com/gorilla/mux" "go.opentelemetry.io/otel/trace" "gopkg.in/yaml.v3" @@ -124,7 +123,6 @@ type Config struct { endpointPermissionMap map[string][]string `json:"-" yaml:"-"` // Key: "METHOD:/path", Value: []permissions publicEndpointsMap map[string]bool `json:"-" yaml:"-"` // Key: "METHOD:/path", Value: true if public endpointMap map[string]*EndpointMapping `json:"-" yaml:"-"` // Key: "METHOD:/path", Value: endpoint object - muxRouter *mux.Router `json:"-" yaml:"-"` // Used for mux pattern matching // rules holds every (method, path) rule ordered most-specific-first, and is the // single source of truth for resolving a request that no exact key matches. @@ -163,10 +161,6 @@ func LoadPermissions(path string, logger datasource.Logger, metrics container.Me config.Metrics = metrics config.Tracer = tracer - // Initialize mux router for pattern matching - // Use StrictSlash(false) to match the application router's behavior - config.muxRouter = mux.NewRouter().StrictSlash(false) - // Validate config before processing if err := config.validate(); err != nil { return nil, fmt.Errorf("invalid RBAC config: %w", err) @@ -282,8 +276,6 @@ func (c *Config) initializeMaps() { c.endpointPermissionMap = make(map[string][]string) c.publicEndpointsMap = make(map[string]bool) c.endpointMap = make(map[string]*EndpointMapping) - // Use StrictSlash(false) to match the application router's behavior - c.muxRouter = mux.NewRouter().StrictSlash(false) } // buildRolePermissionsMap builds the role permissions map from Roles. diff --git a/pkg/gofr/rbac/endpoint_matcher.go b/pkg/gofr/rbac/endpoint_matcher.go index d788660801..1e5a63d1dc 100644 --- a/pkg/gofr/rbac/endpoint_matcher.go +++ b/pkg/gofr/rbac/endpoint_matcher.go @@ -30,56 +30,59 @@ var ( errInvalidPattern = errors.New("invalid mux pattern") ) -// matchesHTTPMethod checks if the HTTP method matches the endpoint's allowed methods. -func matchesHTTPMethod(method string, allowedMethods []string) bool { - // Empty methods or "*" means all methods - if len(allowedMethods) == 0 { - return true - } - - for _, m := range allowedMethods { - if m == "*" || strings.EqualFold(m, method) { - return true - } - } - - return false -} - // isMuxPattern detects if a pattern contains mux-style variables. // Returns true if pattern contains { and }. func isMuxPattern(pattern string) bool { return strings.Contains(pattern, "{") && strings.Contains(pattern, "}") } -// matchMuxPattern uses mux Route.Match() to test if a path matches a mux pattern. -// Creates a temporary mux Route and uses Route.Match() to test the pattern. -// Handles all mux pattern types: {id}, {id:[0-9]+}, {path:.*}, etc. -func matchMuxPattern(pattern, method, path string, router *mux.Router) bool { - if router == nil { - return false - } - - // Create a temporary route with the pattern - route := router.NewRoute().Path(pattern) +// compilePattern compiles an endpoint path into a mux route, once, at load time. +// Returns nil for a literal path, which is cheaper to compare as a string. +// +// Each pattern is compiled onto a router of its own. mux.Router.NewRoute appends to the router it +// is called on, so compiling against a router shared by every request - as this package used to - +// both mutated that router without synchronization and grew it by one entry per rule per request, +// for the life of the process. A router built here is never written to again, and Route.Match only +// reads the route, so the compiled result is safe to share across goroutines. +func compilePattern(pattern string) *mux.Route { + if pattern == "" || !isMuxPattern(pattern) { + return nil + } + + // StrictSlash(false) matches the application router's behavior. + return mux.NewRouter().StrictSlash(false).NewRoute().Path(pattern) +} - // If method is specified, add it to the route - if method != "" { - route = route.Methods(method) - } +// matchContext carries the values one resolution scan matches its compiled routes against. +// +// mux writes its result into the RouteMatch, so a single one is reused across the scan and reset +// before each use; nothing here reads it. Hoisting it out of the per-rule call keeps the scan's +// allocation count flat instead of growing with the number of rules in the config. +type matchContext struct { + req *http.Request + match mux.RouteMatch +} - // Create a mock request for matching - req := &http.Request{ - Method: method, - URL: &url.URL{ - Path: path, +// newMatchContext builds the context for resolving one request. mux matchers only read the +// request, so one value serves the whole scan. +func newMatchContext(methodUpper, path string) *matchContext { + return &matchContext{ + req: &http.Request{ + Method: methodUpper, + URL: &url.URL{ + Path: path, + }, }, } +} - // Use Route.Match() to test if the request matches the pattern - var match mux.RouteMatch +// matches reports whether the context's request matches a route returned by compilePattern. +// A pattern mux could not compile carries the error on the route and matches nothing, which is the +// unguarded-endpoint case logUncompilablePattern reports at load. +func (m *matchContext) matches(route *mux.Route) bool { + m.match = mux.RouteMatch{} - return route.Match(req, &match) + return route.Match(m.req, &m.match) } // validateMuxPattern validates mux pattern syntax. @@ -127,26 +130,6 @@ func (c *Config) logUncompilablePattern(pattern string, index int) { index, errInvalidPattern, pattern, err) } -// matchesEndpointPattern checks if the route matches the endpoint pattern. -// Method matching is handled separately by endpointRule.matchesMethod before this is called. -// Uses mux Route.Match() for mux patterns, exact match for non-pattern paths. -func matchesEndpointPattern(endpoint *EndpointMapping, route string, config *Config) bool { - if endpoint.Path == "" { - return false - } - - pattern := endpoint.Path - - // Exact match for non-pattern paths - if !isMuxPattern(pattern) { - return pattern == route - } - - // Use mux Route.Match() for patterns - // Method is handled separately, so pass empty string here - return matchMuxPattern(pattern, "", route, config.muxRouter) -} - // checkEndpointAuthorization checks if the user's role is authorized for the endpoint. // Pure permission-based: checks if role has ANY of the required permissions (OR logic). // Uses the endpoint parameter directly instead of re-looking it up. diff --git a/pkg/gofr/rbac/endpoint_matcher_test.go b/pkg/gofr/rbac/endpoint_matcher_test.go index c338a459c6..f4ad87f4ac 100644 --- a/pkg/gofr/rbac/endpoint_matcher_test.go +++ b/pkg/gofr/rbac/endpoint_matcher_test.go @@ -7,7 +7,6 @@ import ( "path/filepath" "testing" - "github.com/gorilla/mux" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -100,60 +99,6 @@ func TestConfig_resolve_Cases(t *testing.T) { } } -func TestMatchesHTTPMethod(t *testing.T) { - testCases := []struct { - desc string - method string - allowedMethods []string - expected bool - }{ - { - desc: "matches exact method", - method: "GET", - allowedMethods: []string{"GET"}, - expected: true, - }, - { - desc: "matches case-insensitive method", - method: "get", - allowedMethods: []string{"GET"}, - expected: true, - }, - { - desc: "matches wildcard method", - method: "POST", - allowedMethods: []string{"*"}, - expected: true, - }, - { - desc: "matches empty methods as all", - method: "DELETE", - allowedMethods: []string{}, - expected: true, - }, - { - desc: "does not match different method", - method: "POST", - allowedMethods: []string{"GET"}, - expected: false, - }, - { - desc: "matches one of multiple methods", - method: "PUT", - allowedMethods: []string{"GET", "PUT", "POST"}, - expected: true, - }, - } - - for i, tc := range testCases { - t.Run(tc.desc, func(t *testing.T) { - result := matchesHTTPMethod(tc.method, tc.allowedMethods) - - assert.Equal(t, tc.expected, result, "TEST[%d], Failed.\n%s", i, tc.desc) - }) - } -} - func TestMatchesEndpointPattern(t *testing.T) { testCases := []struct { desc string @@ -227,12 +172,14 @@ func TestMatchesEndpointPattern(t *testing.T) { }, } - config := &Config{} - _ = config.processUnifiedConfig() - for i, tc := range testCases { t.Run(tc.desc, func(t *testing.T) { - result := matchesEndpointPattern(tc.endpoint, tc.route, config) + rule := endpointRule{ + pattern: tc.endpoint.Path, + route: compilePattern(tc.endpoint.Path), + } + + result := rule.matchesPath(tc.route, newMatchContext(http.MethodGet, tc.route)) assert.Equal(t, tc.expected, result, "TEST[%d], Failed.\n%s", i, tc.desc) }) @@ -523,88 +470,61 @@ func TestIsMuxPattern(t *testing.T) { } } -func TestMatchMuxPattern(t *testing.T) { - router := mux.NewRouter() - +func TestCompilePattern(t *testing.T) { testCases := []struct { desc string pattern string - method string path string + compiled bool expected bool }{ - { - desc: "matches single variable", - pattern: "/api/users/{id}", - method: "GET", - path: "/api/users/123", - expected: true, - }, - { - desc: "matches variable with constraint", - pattern: "/api/users/{id:[0-9]+}", - method: "GET", - path: "/api/users/123", - expected: true, - }, - { - desc: "does not match constraint violation", - pattern: "/api/users/{id:[0-9]+}", - method: "GET", - path: "/api/users/abc", - expected: false, - }, - { - desc: "matches multi-level pattern", - pattern: "/api/{path:.*}", - method: "GET", - path: "/api/users/123", - expected: true, - }, - { - desc: "matches middle variable", - pattern: "/api/{category}/posts", - method: "GET", - path: "/api/tech/posts", - expected: true, - }, - { - desc: "matches multiple variables", - pattern: "/api/{category}/posts/{id:[0-9]+}", - method: "GET", - path: "/api/tech/posts/123", - expected: true, - }, - { - desc: "does not match different path", - pattern: "/api/users/{id}", - method: "GET", - path: "/api/posts/123", - expected: false, - }, - { - desc: "returns false for nil router", - pattern: "/api/users/{id}", - method: "GET", - path: "/api/users/123", - expected: false, - }, + {"matches single variable", "/api/users/{id}", "/api/users/123", true, true}, + {"matches variable with constraint", "/api/users/{id:[0-9]+}", "/api/users/123", true, true}, + {"does not match constraint violation", "/api/users/{id:[0-9]+}", "/api/users/abc", true, false}, + {"matches multi-level pattern", "/api/{path:.*}", "/api/users/123", true, true}, + {"matches middle variable", "/api/{category}/posts", "/api/tech/posts", true, true}, + {"matches multiple variables", "/api/{category}/posts/{id:[0-9]+}", "/api/tech/posts/123", true, true}, + {"does not match different path", "/api/users/{id}", "/api/posts/123", true, false}, + {"literal path is not compiled", "/api/users", "/api/users", false, false}, + {"empty path is not compiled", "", "/api/users", false, false}, + {"uncompilable pattern matches nothing", "/api/{id:[}", "/api/users", true, false}, } for _, tc := range testCases { t.Run(tc.desc, func(t *testing.T) { - var testRouter *mux.Router + route := compilePattern(tc.pattern) - if tc.desc != "returns false for nil router" { - testRouter = router + if !tc.compiled { + assert.Nil(t, route, "a literal path carries no compiled route") + + return } - result := matchMuxPattern(tc.pattern, tc.method, tc.path, testRouter) - assert.Equal(t, tc.expected, result) + require.NotNil(t, route) + assert.Equal(t, tc.expected, newMatchContext(http.MethodGet, tc.path).matches(route)) }) } } +// TestCompilePattern_routeIsNotShared pins the fix for the unbounded router growth: compiling a +// pattern must not append to any router that outlives the call. +func TestCompilePattern_routeIsNotShared(t *testing.T) { + const pattern = "/api/users/{id}" + + first, second := compilePattern(pattern), compilePattern(pattern) + + require.NotNil(t, first) + require.NotNil(t, second) + assert.NotSame(t, first, second, "each pattern must compile onto a router of its own") + + mc := newMatchContext(http.MethodGet, "/api/users/123") + + // Matching repeatedly must be a pure read - the same answer, every time. + for range 3 { + assert.True(t, mc.matches(first)) + } +} + func TestValidateMuxPattern(t *testing.T) { testCases := []struct { desc string diff --git a/pkg/gofr/rbac/resolver.go b/pkg/gofr/rbac/resolver.go index d7a07e4daf..75b45ef65a 100644 --- a/pkg/gofr/rbac/resolver.go +++ b/pkg/gofr/rbac/resolver.go @@ -3,6 +3,8 @@ package rbac import ( "sort" "strings" + + "github.com/gorilla/mux" ) // Segment specificity scores, compared segment by segment to order overlapping rules. @@ -24,6 +26,9 @@ type endpointRule struct { // pattern is the endpoint path, which may contain mux variables. pattern string + // route is pattern compiled once at load time, or nil when pattern is a literal path. + route *mux.Route + // method is the upper-cased declared method, or "*" for all methods. method string @@ -44,12 +49,27 @@ type endpointRule struct { // permission requirement rather than granting access, covering an unknown verb tightens // enforcement rather than loosening it. func (r *endpointRule) matchesMethod(methodUpper string) bool { - return matchesHTTPMethod(methodUpper, []string{r.method}) + return r.method == "*" || strings.EqualFold(r.method, methodUpper) +} + +// matchesPath reports whether the rule's path covers the request carried by mc, which is shared +// across the whole scan. +func (r *endpointRule) matchesPath(path string, mc *matchContext) bool { + if r.pattern == "" { + return false + } + + // A literal path is compared directly; only mux patterns carry a compiled route. + if r.route == nil { + return r.pattern == path + } + + return mc.matches(r.route) } // matches reports whether the rule covers the given request. -func (r *endpointRule) matches(methodUpper, path string, config *Config) bool { - return r.matchesMethod(methodUpper) && matchesEndpointPattern(r.endpoint, path, config) +func (r *endpointRule) matches(methodUpper, path string, mc *matchContext) bool { + return r.matchesMethod(methodUpper) && r.matchesPath(path, mc) } // buildEndpointRules expands endpoints into one rule per declared method and orders them @@ -89,6 +109,7 @@ func buildEndpointRules(endpoints []EndpointMapping) []endpointRule { byKey[key] = endpointRule{ endpoint: endpoint, pattern: endpoint.Path, + route: compilePattern(endpoint.Path), method: methodUpper, isPublic: endpoint.Public, pathScore: pathSpecificity(endpoint.Path), @@ -212,9 +233,11 @@ func compareSpecificity(a, b []int) int { } // resolveEndpoint returns the most specific rule covering the request, and whether it is public. -func resolveEndpoint(methodUpper, path string, rules []endpointRule, config *Config) (*EndpointMapping, bool) { +func resolveEndpoint(methodUpper, path string, rules []endpointRule) (*EndpointMapping, bool) { + mc := newMatchContext(methodUpper, path) + for i := range rules { - if rules[i].matches(methodUpper, path, config) { + if rules[i].matches(methodUpper, path, mc) { return rules[i].endpoint, rules[i].isPublic } } @@ -236,5 +259,5 @@ func (c *Config) resolve(methodUpper, path string) (*EndpointMapping, bool) { return endpoint, isPublic } - return resolveEndpoint(methodUpper, path, c.rules, c) + return resolveEndpoint(methodUpper, path, c.rules) } diff --git a/pkg/gofr/rbac/resolver_concurrency_test.go b/pkg/gofr/rbac/resolver_concurrency_test.go new file mode 100644 index 0000000000..0ef3839720 --- /dev/null +++ b/pkg/gofr/rbac/resolver_concurrency_test.go @@ -0,0 +1,175 @@ +package rbac + +import ( + "fmt" + "net/http" + "net/http/httptest" + "sync" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// patternEndpoints builds a config body of `count` mux-pattern rules, none of which match the +// path used by the tests below, followed by one that does. Pattern rules are what force the +// ordered scan; a config of literal paths never reaches it. +func patternEndpoints(count int) []EndpointMapping { + endpoints := make([]EndpointMapping, 0, count+1) + + for i := range count { + endpoints = append(endpoints, EndpointMapping{ + Path: fmt.Sprintf("/other%d/{id}/sub/{sub}", i), + Methods: []string{"*"}, + RequiredPermissions: []string{"other:read"}, + }) + } + + return append(endpoints, EndpointMapping{ + Path: "/admin/{path:.*}", + Methods: []string{"*"}, + RequiredPermissions: []string{"admin:read"}, + }) +} + +// TestConfig_resolve_concurrent drives the resolver from many goroutines at once, which is the +// only way a server ever runs it. Under -race this fails before the fix: resolving a pattern +// appended a route to the config's shared mux.Router on every call. +func TestConfig_resolve_concurrent(t *testing.T) { + const ( + goroutines = 50 + iterations = 20 + ) + + config := newTestConfig(t, patternEndpoints(5), nil) + + var wg sync.WaitGroup + + wg.Add(goroutines) + + for range goroutines { + go func() { + defer wg.Done() + + for range iterations { + endpoint, isPublic := config.resolve(http.MethodDelete, "/admin/orgs/123") + + assert.False(t, isPublic) + assert.NotNil(t, endpoint) + } + }() + } + + wg.Wait() +} + +// TestMiddleware_concurrent is the same check one layer up, through the exported entry point +// an application actually mounts. +func TestMiddleware_concurrent(t *testing.T) { + const ( + goroutines = 50 + iterations = 20 + ) + + config := newTestConfig(t, patternEndpoints(5), + []RoleDefinition{{Name: "admin", Permissions: []string{"admin:read"}}}) + + handler := Middleware(config)(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusOK) + })) + + var wg sync.WaitGroup + + wg.Add(goroutines) + + for range goroutines { + go func() { + defer wg.Done() + + for range iterations { + req := httptest.NewRequestWithContext(t.Context(), http.MethodDelete, "/admin/orgs/123", http.NoBody) + req.Header.Set("X-User-Role", "admin") + + rec := httptest.NewRecorder() + handler.ServeHTTP(rec, req) + + assert.Equal(t, http.StatusOK, rec.Code) + } + }() + } + + wg.Wait() +} + +// TestConfig_resolve_allocations pins the per-request cost of the ordered scan to the size of the +// request rather than the size of the config. RBAC runs on every request of every route, so an +// allocation here lands on the whole application's hot path. +// +// The assertion is comparative rather than an absolute count: the scan allocates a small fixed set +// of per-request values, and exactly what that comes to varies with the Go version and with +// whether the race detector is on. What must not vary is that it stays flat as rules are added. +// Before the fix each rule's pattern was recompiled per request, so this ran to 1064, 3924 and +// 9684 allocations for the three sizes below. +func TestConfig_resolve_allocations(t *testing.T) { + measure := func(rules int) float64 { + config := newTestConfig(t, patternEndpoints(rules), nil) + + // Warm up, so any first-call lazy work is not counted. + config.resolve(http.MethodDelete, "/admin/orgs/123") + + return testing.AllocsPerRun(100, func() { + config.resolve(http.MethodDelete, "/admin/orgs/123") + }) + } + + baseline := measure(5) + + // Generous: a scan that recompiles patterns costs hundreds of allocations per added rule, so + // any real regression clears this by orders of magnitude. + const tolerance = 4 + + for _, rules := range []int{20, 50} { + t.Run(fmt.Sprintf("%d_rules", rules+1), func(t *testing.T) { + assert.LessOrEqual(t, measure(rules), baseline+tolerance, + "resolve allocates per rule scanned; cost must not scale with config size") + }) + } +} + +func TestEndpointRule_matchesMethod(t *testing.T) { + testCases := []struct { + desc string + ruleMethod string + requestUpper string + expected bool + }{ + {"explicit method matches itself", http.MethodGet, http.MethodGet, true}, + {"explicit method rejects another", http.MethodGet, http.MethodDelete, false}, + {"explicit method matches case-insensitively", http.MethodGet, "get", true}, + {"wildcard matches any known method", "*", http.MethodDelete, true}, + {"wildcard matches unknown method", "*", "PROPFIND", true}, + } + + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + rule := endpointRule{method: tc.ruleMethod} + assert.Equal(t, tc.expected, rule.matchesMethod(tc.requestUpper)) + }) + } +} + +func BenchmarkConfig_resolve(b *testing.B) { + for _, rules := range []int{5, 20, 50} { + b.Run(fmt.Sprintf("%d_rules", rules+1), func(b *testing.B) { + config := newTestConfig(b, patternEndpoints(rules), nil) + + b.ReportAllocs() + b.ResetTimer() + + for range b.N { + endpoint, _ := config.resolve(http.MethodDelete, "/admin/orgs/123") + require.NotNil(b, endpoint) + } + }) + } +} From 9bbdbbe2302ac29a70864dfc3d3921ffb9c4b6b3 Mon Sep 17 00:00:00 2001 From: Akshat Singhal <65562230+akshat-kumar-singhal@users.noreply.github.com> Date: Mon, 14 Sep 2026 18:36:23 +0530 Subject: [PATCH 39/48] =?UTF-8?q?fix(ci):=20pull=20MinIO=20from=20quay.io?= =?UTF-8?q?=20=E2=80=94=20docker.io/minio/minio=20is=20no=20longer=20publi?= =?UTF-8?q?c=20(#4208)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit quay.io/minio/minio:RELEASE.2025-09-07T16-13-09Z carries the identical manifest list — sha256:14cea493… , byte-for-byte the digest already pinned — so this changes the registry and nothing else. The image CI runs is provably the one it ran on 2026-09-11, and the digest pin protecting the integration guard for #3804 stays intact. Bumping to a newer release instead would have changed two things at once. --- .github/workflows/go.yml | 9 +++++++-- examples/using-s3-filestore/README.md | 2 +- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index e7bf547883..d980f67ee2 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -170,11 +170,16 @@ jobs: # Run it explicitly (same pattern as Zipkin above) and wait for readiness. - name: Start MinIO run: | - # Pinned by digest now that this step is required: an unexpected image + # Pulled from quay.io, not Docker Hub: docker.io/minio/minio is no + # longer publicly pullable ("pull access denied ... repository does not + # exist or may require 'docker login'"), for every tag and for the + # digest below. quay.io/minio/minio carries the identical manifest list + # — same digest — so this is a registry change and not an image change. + # Pinned by digest because this step is required: an unexpected image # change can't silently alter the integration guard for #3804. docker run -d --name minio -p 9000:9000 \ -e MINIO_ROOT_USER=minioadmin -e MINIO_ROOT_PASSWORD=minioadmin \ - minio/minio:RELEASE.2025-09-07T16-13-09Z@sha256:14cea493d9a34af32f524e538b8346cf79f3321eff8e708c1e2960462bd8936e \ + quay.io/minio/minio:RELEASE.2025-09-07T16-13-09Z@sha256:14cea493d9a34af32f524e538b8346cf79f3321eff8e708c1e2960462bd8936e \ server /data for i in $(seq 1 30); do if curl -fs http://localhost:9000/minio/health/live >/dev/null; then diff --git a/examples/using-s3-filestore/README.md b/examples/using-s3-filestore/README.md index c3937458da..6a0397e303 100644 --- a/examples/using-s3-filestore/README.md +++ b/examples/using-s3-filestore/README.md @@ -17,7 +17,7 @@ Start a MinIO server (any S3-compatible backend works): ```bash docker run -d --name minio \ -e MINIO_ROOT_USER=minioadmin -e MINIO_ROOT_PASSWORD=minioadmin \ - minio/minio server /data + quay.io/minio/minio server /data ``` Point `configs/.env` (`S3_ENDPOINT`, `S3_BUCKET_NAME`, credentials) at it, make From edf7b2c31c5ca83d0eeb4a58ff37d803834b2c31 Mon Sep 17 00:00:00 2001 From: Akshat Singhal <65562230+akshat-kumar-singhal@users.noreply.github.com> Date: Tue, 15 Sep 2026 12:29:03 +0530 Subject: [PATCH 40/48] fix(http,metrics,mcp): don't lose a shutdown that arrives before the server starts (#3801) (#4139) --- pkg/gofr/http_server.go | 35 ++++++-- pkg/gofr/mcp.go | 14 +++- pkg/gofr/metrics_server.go | 18 +++- pkg/gofr/shutdown_test.go | 168 +++++++++++++++++++++++++++++++++++++ 4 files changed, 226 insertions(+), 9 deletions(-) diff --git a/pkg/gofr/http_server.go b/pkg/gofr/http_server.go index 7b201178b8..452283cbda 100644 --- a/pkg/gofr/http_server.go +++ b/pkg/gofr/http_server.go @@ -18,11 +18,26 @@ import ( ) type httpServer struct { - router *gofrHTTP.Router - port int - ws *websocket.Manager - srvMu sync.Mutex // guards srv, which run() writes on the serve goroutine and Shutdown() reads on the caller goroutine - srv *http.Server + router *gofrHTTP.Router + port int + ws *websocket.Manager + // srvMu guards srv and stopped. run() writes them on the serve goroutine and + // Shutdown() on the caller goroutine, and the two decide between them — under + // this lock — whether the server ever comes up. See the note on stopped. + srvMu sync.Mutex + srv *http.Server + // stopped records that Shutdown has been called. It is sticky: once set, run() + // will not bring a listener up. srv == nil means "not started", which is not + // the same as "will not start" — without this flag a Shutdown that lands before + // run() publishes srv reports success and stops nothing, and the listener that + // follows serves with no way left to stop it. + // + // The flag is one-way and terminal for the lifetime of this object: nothing + // clears it, so the stop is one-shot and a server that has been Shutdown can + // never be run again. Since App.Shutdown is exported, an application that calls + // Shutdown and then Run gets a process that serves nothing and logs why. That + // is deliberate — the alternative is the unstoppable listener above. + stopped bool certFile string keyFile string staticFiles map[string]string @@ -90,6 +105,13 @@ func (s *httpServer) run(c *container.Container) { s.srvMu.Lock() + if s.stopped { + s.srvMu.Unlock() + c.Logf("Server was shut down before it started on port: %d", s.port) + + return + } + if s.srv != nil { s.srvMu.Unlock() c.Logf("Server already running on port: %d", s.port) @@ -133,9 +155,12 @@ func (s *httpServer) run(c *container.Container) { func (s *httpServer) Shutdown(ctx context.Context) error { s.srvMu.Lock() + s.stopped = true srv := s.srv s.srvMu.Unlock() + // Nothing has been published yet, so there is nothing to stop — and because + // stopped was set under the same lock, run() will not start one either. if srv == nil { return nil } diff --git a/pkg/gofr/mcp.go b/pkg/gofr/mcp.go index 7519c371ab..28393df80d 100644 --- a/pkg/gofr/mcp.go +++ b/pkg/gofr/mcp.go @@ -77,8 +77,11 @@ func (a *App) mcpPort() (int, bool) { type mcpServer struct { port int handler http.Handler - srvMu sync.Mutex // guards srv, written by Run on the serve goroutine and read by Shutdown on the caller goroutine + // srvMu guards srv and stopped; see the note on httpServer.stopped for why a + // nil srv alone cannot tell Shutdown whether a start is still coming. + srvMu sync.Mutex srv *http.Server + stopped bool } func newMCPServer(port int, handler http.Handler) *mcpServer { @@ -99,6 +102,14 @@ func (m *mcpServer) Run(c *container.Container) { } m.srvMu.Lock() + + if m.stopped { + m.srvMu.Unlock() + c.Logf("MCP server was shut down before it started on port: %d", m.port) + + return + } + m.srv = srv m.srvMu.Unlock() @@ -109,6 +120,7 @@ func (m *mcpServer) Run(c *container.Container) { func (m *mcpServer) Shutdown(ctx context.Context) error { m.srvMu.Lock() + m.stopped = true srv := m.srv m.srvMu.Unlock() diff --git a/pkg/gofr/metrics_server.go b/pkg/gofr/metrics_server.go index 22f62cd0e7..56a7f0b79c 100644 --- a/pkg/gofr/metrics_server.go +++ b/pkg/gofr/metrics_server.go @@ -13,9 +13,12 @@ import ( ) type metricServer struct { - port int - srvMu sync.Mutex // guards srv, written by Run on the serve goroutine and read by Shutdown on the caller goroutine - srv *http.Server + port int + // srvMu guards srv and stopped; see the note on httpServer.stopped for why a + // nil srv alone cannot tell Shutdown whether a start is still coming. + srvMu sync.Mutex + srv *http.Server + stopped bool } func newMetricServer(port int) *metricServer { @@ -35,6 +38,14 @@ func (m *metricServer) Run(c *container.Container) { } m.srvMu.Lock() + + if m.stopped { + m.srvMu.Unlock() + c.Logf("Metrics server was shut down before it started on port: %d", m.port) + + return + } + m.srv = srv m.srvMu.Unlock() @@ -48,6 +59,7 @@ func (m *metricServer) Run(c *container.Container) { func (m *metricServer) Shutdown(ctx context.Context) error { m.srvMu.Lock() + m.stopped = true srv := m.srv m.srvMu.Unlock() diff --git a/pkg/gofr/shutdown_test.go b/pkg/gofr/shutdown_test.go index cc64fd504c..36c9b98bc6 100644 --- a/pkg/gofr/shutdown_test.go +++ b/pkg/gofr/shutdown_test.go @@ -2,6 +2,10 @@ package gofr import ( "context" + "fmt" + "net" + "net/http" + "sync" "testing" "time" @@ -9,6 +13,9 @@ import ( "github.com/stretchr/testify/require" "gofr.dev/pkg/gofr/config" + "gofr.dev/pkg/gofr/container" + gofrHTTP "gofr.dev/pkg/gofr/http" + "gofr.dev/pkg/gofr/logging" ) func TestShutdownWithContext_ContextTimeout(t *testing.T) { @@ -74,3 +81,164 @@ func Test_getShutdownTimeoutFromConfig_Error(t *testing.T) { _, err := getShutdownTimeoutFromConfig(mockConfig) require.Error(t, err) } + +// freeTCPPort returns a port that was free at the moment it was probed. The +// servers under test take a port number rather than a listener, so there is no +// way to ask them to bind :0 and report back. +func freeTCPPort(t *testing.T) int { + t.Helper() + + l, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", "127.0.0.1:0") + require.NoError(t, err) + + port := l.Addr().(*net.TCPAddr).Port + + require.NoError(t, l.Close()) + + return port +} + +// isListening reports whether anything accepts a connection on the port. +func isListening(ctx context.Context, port int) bool { + dialer := net.Dialer{Timeout: 200 * time.Millisecond} + + conn, err := dialer.DialContext(ctx, "tcp", fmt.Sprintf("127.0.0.1:%d", port)) + if err != nil { + return false + } + + conn.Close() + + return true +} + +// A termination signal can arrive before the serve goroutine has published its +// *http.Server — Run starts the shutdown handler before the servers. Shutdown +// must record that stop was requested, so the start that follows is abandoned +// instead of serving a listener nobody will ever stop. +func TestShutdown_BeforeStart_AbandonsTheStart(t *testing.T) { + tests := []struct { + name string + server func(port int) (run func(*container.Container), shutdown func(context.Context) error) + }{ + {"http server", func(port int) (func(*container.Container), func(context.Context) error) { + s := &httpServer{router: gofrHTTP.NewRouter(), port: port} + return s.run, s.Shutdown + }}, + {"metrics server", func(port int) (func(*container.Container), func(context.Context) error) { + m := newMetricServer(port) + return m.Run, m.Shutdown + }}, + {"mcp server", func(port int) (func(*container.Container), func(context.Context) error) { + m := newMCPServer(port, http.NotFoundHandler()) + return m.Run, m.Shutdown + }}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + port := freeTCPPort(t) + run, shutdown := tt.server(port) + c := &container.Container{Logger: logging.NewLogger(logging.ERROR)} + + ctx, cancel := context.WithTimeout(t.Context(), time.Second) + defer cancel() + + require.NoError(t, shutdown(ctx), "shutting down a server that has not started is not an error") + + returned := make(chan struct{}) + + go func() { + defer close(returned) + + run(c) + }() + + select { + case <-returned: + case <-time.After(2 * time.Second): + t.Fatal("run() did not return after Shutdown: the server started anyway and nothing will stop it") + } + + assert.False(t, isListening(t.Context(), port), "port %d is being served after Shutdown", port) + }) + } +} + +// The signal window is a race, not a fixed ordering: Shutdown can land before +// run() publishes its server, after it, or while it is publishing. Whichever way +// the two goroutines interleave, the process must not be left serving. +// +// Which interleaving happens is the scheduler's to decide, so this test is +// opportunistic for every one of its cases, mcp included: it exercises the losing +// ordering only when the ordering falls that way, and none of the three subtests +// is a guarantee on its own. On development the pre-publish ordering does show up +// often enough to fail (measured over five runs: metrics 5/5, http 4/5, mcp 3/5), +// but the proportions are a property of the machine, not of the code — a subtest +// here that passes on development is not evidence that it covers nothing. +// +// The deterministic guard is TestShutdown_BeforeStart_AbandonsTheStart above, +// which fixes the ordering and covers all three servers; this test adds the +// interleavings a fixed ordering cannot reach. Neither replaces the other, and a +// case that looks flaky here should be diagnosed rather than deleted. +func TestShutdown_ConcurrentWithStart_LeavesNothingServing(t *testing.T) { + tests := []struct { + name string + server func(port int) (run func(*container.Container), shutdown func(context.Context) error) + }{ + {"http server", func(port int) (func(*container.Container), func(context.Context) error) { + s := &httpServer{router: gofrHTTP.NewRouter(), port: port} + return s.run, s.Shutdown + }}, + {"metrics server", func(port int) (func(*container.Container), func(context.Context) error) { + m := newMetricServer(port) + return m.Run, m.Shutdown + }}, + {"mcp server", func(port int) (func(*container.Container), func(context.Context) error) { + m := newMCPServer(port, http.NotFoundHandler()) + return m.Run, m.Shutdown + }}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + port := freeTCPPort(t) + run, shutdown := tt.server(port) + c := &container.Container{Logger: logging.NewLogger(logging.ERROR)} + + ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second) + defer cancel() + + var wg sync.WaitGroup + + wg.Add(2) + + go func() { + defer wg.Done() + + run(c) + }() + + go func() { + defer wg.Done() + + assert.NoError(t, shutdown(ctx)) + }() + + done := make(chan struct{}) + + go func() { + wg.Wait() + close(done) + }() + + select { + case <-done: + case <-time.After(10 * time.Second): + t.Fatal("run() outlived Shutdown: the server is serving with nothing left to stop it") + } + + assert.False(t, isListening(t.Context(), port), "port %d is being served after Shutdown", port) + }) + } +} From 6b23d89f8e551b5a3cc9f1efe03786358484f293 Mon Sep 17 00:00:00 2001 From: Akshat Singhal <65562230+akshat-kumar-singhal@users.noreply.github.com> Date: Tue, 15 Sep 2026 13:02:25 +0530 Subject: [PATCH 41/48] fix(tracing): derive OTLP transport security from the TRACER_URL scheme (#4205) --- docs/guides/production-tracing/page.md | 24 ++- docs/guides/twelve-factor-config/page.md | 7 +- docs/quick-start/observability/page.md | 2 +- docs/references/configs/page.md | 8 +- pkg/gofr/otel.go | 118 +++++++++- pkg/gofr/otel_test.go | 262 +++++++++++++++++++++++ 6 files changed, 411 insertions(+), 10 deletions(-) diff --git a/docs/guides/production-tracing/page.md b/docs/guides/production-tracing/page.md index 872bbcbb31..f3b9c16cbb 100644 --- a/docs/guides/production-tracing/page.md +++ b/docs/guides/production-tracing/page.md @@ -12,7 +12,7 @@ nextjs: GoFr ships built-in OpenTelemetry tracing — every HTTP request, gRPC call, and datasource operation is traced automatically. Configure the exporter via `TRACE_EXPORTER` (`otlp`, `jaeger`, `zipkin`, or `gofr`) and `TRACER_URL`, set `TRACER_RATIO` for head-based sampling, and W3C Trace Context propagation flows through GoFr's HTTP service client without extra code. {% /answer %} -{% howto name="Wire production tracing for a GoFr service" description="Configure OTLP gRPC tracing in GoFr, point it at Jaeger / Tempo / Honeycomb, and tune sampling for production." steps=[{"name": "Set TRACE_EXPORTER", "text": "Set TRACE_EXPORTER=otlp in configs/.env (or an env-based ConfigMap in K8s) — GoFr ships an OTLP gRPC exporter."}, {"name": "Set TRACER_URL", "text": "Set TRACER_URL to a bare host:port (no http:// scheme) on port 4317 for OTLP gRPC; route to Jaeger collector, Tempo, or any OTLP backend."}, {"name": "Tune TRACER_RATIO", "text": "Set TRACER_RATIO to 1.0 in dev for full sampling; in prod step down to 0.1 or lower based on volume."}, {"name": "Add custom spans", "text": "Use ctx.Trace(name) inside handlers to mark sub-operations; existing HTTP, gRPC, and datasource spans are emitted automatically."}, {"name": "Verify in the backend", "text": "Hit a route, then open the Jaeger UI / Grafana Tempo and search for the service by APP_NAME — confirm spans show up with trace_id."}, {"name": "Propagate across services", "text": "GoFr injects W3C TraceContext on outbound calls via ctx.GetHTTPService — so two GoFr services share a single trace ID end to end."}] /%} +{% howto name="Wire production tracing for a GoFr service" description="Configure OTLP gRPC tracing in GoFr, point it at Jaeger / Tempo / Honeycomb, and tune sampling for production." steps=[{"name": "Set TRACE_EXPORTER", "text": "Set TRACE_EXPORTER=otlp in configs/.env (or an env-based ConfigMap in K8s) — GoFr ships an OTLP gRPC exporter."}, {"name": "Set TRACER_URL", "text": "Set TRACER_URL to the collector endpoint on port 4317 for OTLP gRPC \u2014 https:// for a TLS-terminating backend, http:// or a bare host:port for plaintext; route to Jaeger collector, Tempo, or any OTLP backend."}, {"name": "Tune TRACER_RATIO", "text": "Set TRACER_RATIO to 1.0 in dev for full sampling; in prod step down to 0.1 or lower based on volume."}, {"name": "Add custom spans", "text": "Use ctx.Trace(name) inside handlers to mark sub-operations; existing HTTP, gRPC, and datasource spans are emitted automatically."}, {"name": "Verify in the backend", "text": "Hit a route, then open the Jaeger UI / Grafana Tempo and search for the service by APP_NAME — confirm spans show up with trace_id."}, {"name": "Propagate across services", "text": "GoFr injects W3C TraceContext on outbound calls via ctx.GetHTTPService — so two GoFr services share a single trace ID end to end."}] /%} ## When to use this guide @@ -40,6 +40,7 @@ GoFr reads tracing config from environment variables. The relevant keys (verifie |---|---|---| | `TRACE_EXPORTER` | One of `otlp`, `jaeger`, `zipkin`, `gofr` | unset (tracing disabled) | | `TRACER_URL` | Endpoint for the chosen exporter | unset | +| `TRACER_INSECURE` | Plaintext transport for a schemeless `TRACER_URL` (`host:port`); `false` uses TLS. Ignored when `TRACER_URL` has a scheme | `true` | | `TRACER_HOST` | **Deprecated** — use `TRACER_URL` | unset | | `TRACER_PORT` | **Deprecated** — use `TRACER_URL` | `9411` | | `TRACER_RATIO` | Head-based sampling ratio (0.0–1.0) | `1` | @@ -65,6 +66,25 @@ TRACER_RATIO: "0.1" `jaeger` and `otlp` use the same OTLP gRPC exporter under the hood — they differ only in log labeling. +### TLS + +Transport security comes from the `TRACER_URL` scheme when it has one: + +```yaml +TRACER_URL: "https://collector.example.com:4317" # TLS, system root CAs +TRACER_URL: "http://collector.example.com:4317" # plaintext +``` + +A schemeless `host:port` stays plaintext for backward compatibility — that is what every existing +GoFr deployment points at. Set `TRACER_INSECURE: "false"` to upgrade it to TLS without changing the +endpoint. `TRACER_INSECURE` is ignored (with a warning) when the URL already carries a scheme, and +GoFr warns when credentials from `TRACER_HEADERS`/`TRACER_AUTH_KEY` would travel over a plaintext +connection. + +Precedence is `TRACER_URL`'s scheme, then `TRACER_INSECURE`, then the OTel standard +`OTEL_EXPORTER_OTLP_INSECURE` / `OTEL_EXPORTER_OTLP_TRACES_INSECURE`. The SDK applies its +environment variables before any option GoFr passes, so a GoFr config always wins over them. + ### Grafana Tempo / OpenTelemetry Collector Point at any OTLP gRPC endpoint: @@ -94,7 +114,7 @@ Or with a single auth header: TRACER_AUTH_KEY: "Bearer YOUR_TOKEN" ``` -GoFr's OTLP exporter currently uses an insecure (cleartext) gRPC connection inside the cluster — for SaaS endpoints over the public internet, route through an OTel Collector that terminates TLS, or rely on a service mesh. +For a SaaS endpoint over the public internet, give `TRACER_URL` an `https://` scheme (or set `TRACER_INSECURE: "false"` on a schemeless one) so the connection is encrypted — see the TLS section above. A schemeless URL with no `TRACER_INSECURE` stays cleartext, and GoFr warns when credentials would travel over it. ## Sampling: head-based vs tail-based diff --git a/docs/guides/twelve-factor-config/page.md b/docs/guides/twelve-factor-config/page.md index cae0ae4570..2db0608ceb 100644 --- a/docs/guides/twelve-factor-config/page.md +++ b/docs/guides/twelve-factor-config/page.md @@ -86,9 +86,10 @@ data: DB_MAX_OPEN_CONNECTION: "20" DB_MAX_IDLE_CONNECTION: "5" TRACE_EXPORTER: otlp - # GoFr's OTLP exporter speaks gRPC (otlptracegrpc). TRACER_URL must be a bare - # host:port — no http:// scheme — and the OTLP gRPC port is 4317 (4318 is OTLP - # HTTP, which GoFr does NOT use). + # GoFr's OTLP exporter speaks gRPC (otlptracegrpc), on port 4317 (4318 is OTLP + # HTTP, which GoFr does NOT use). The TRACER_URL scheme selects the transport: + # https:// for TLS, http:// or a bare host:port for plaintext. + # A bare host:port can be upgraded with TRACER_INSECURE: "false". TRACER_URL: otel-collector.observability.svc.cluster.local:4317 --- apiVersion: v1 diff --git a/docs/quick-start/observability/page.md b/docs/quick-start/observability/page.md index b92dfe13e0..a1e48b698d 100644 --- a/docs/quick-start/observability/page.md +++ b/docs/quick-start/observability/page.md @@ -480,7 +480,7 @@ APP_NAME=my-service # Grafana Cloud OTLP endpoint with authentication TRACE_EXPORTER=otlp -TRACER_URL=otlp-gateway-prod-us-east-0.grafana.net:443 +TRACER_URL=https://otlp-gateway-prod-us-east-0.grafana.net:443 TRACER_HEADERS="Authorization=Basic dXNlcm5hbWU6cGFzc3dvcmQ=,X-Scope-OrgID=123456" TRACER_RATIO=1.0 ``` diff --git a/docs/references/configs/page.md b/docs/references/configs/page.md index d2e7328ae2..8fd5fe0868 100644 --- a/docs/references/configs/page.md +++ b/docs/references/configs/page.md @@ -146,7 +146,13 @@ This document lists all the configuration options supported by the GoFr framewor --- - TRACER_URL -- URL of the trace collector. Required if TRACE_EXPORTER is set to zipkin or jaeger. +- URL of the trace collector. Required if TRACE_EXPORTER is set to zipkin or jaeger. An `http://` or `https://` scheme selects the transport; a schemeless `host:port` is governed by TRACER_INSECURE. + +--- + +- TRACER_INSECURE +- Whether a schemeless TRACER_URL (`host:port`) is exported over plaintext. Set to `false` to use TLS with the system root CAs. Ignored when TRACER_URL carries an `http://` or `https://` scheme, which selects the transport itself. Takes precedence over the OTel standard OTEL_EXPORTER_OTLP_INSECURE / OTEL_EXPORTER_OTLP_TRACES_INSECURE. Supported for otlp, jaeger. +- true --- diff --git a/pkg/gofr/otel.go b/pkg/gofr/otel.go index 17750206b6..542295e8c1 100644 --- a/pkg/gofr/otel.go +++ b/pkg/gofr/otel.go @@ -155,6 +155,30 @@ func (a *App) getTracerHeaders() map[string]string { return headers } +// tracerInsecure resolves TRACER_INSECURE, which controls transport security for +// a schemeless TRACER_URL (host:port). It reports the flag and whether it was +// explicitly configured — a scheme-bearing TRACER_URL derives its security from +// the scheme and warns when the flag was set and therefore ignored. +// +// It defaults to true (plaintext), unlike METRICS_INSECURE, which defaults to +// false. See resolveOtlpTransport for why the two diverge. +func (a *App) tracerInsecure() (insecure, set bool) { + v := strings.TrimSpace(a.Config.Get("TRACER_INSECURE")) + if v == "" { + return true, false + } + + b, err := strconv.ParseBool(v) + if err != nil { + a.Logger().Warnf("invalid TRACER_INSECURE %q: expected a boolean; defaulting to plaintext for a "+ + "schemeless TRACER_URL", v) + + return true, false + } + + return b, true +} + func (a *App) getExporter(name, host, port, url string) (sdktrace.SpanExporter, error) { var ( exporter sdktrace.SpanExporter @@ -165,7 +189,12 @@ func (a *App) getExporter(name, host, port, url string) (sdktrace.SpanExporter, switch strings.ToLower(name) { case "otlp", "jaeger": - exporter, err = buildOtlpExporter(a.Logger(), name, url, host, port, headers) + // Resolved inside the case, not above the switch: TRACER_INSECURE means + // nothing to zipkin or gofr, and evaluating it for them would warn about a + // malformed value under an exporter that never reads it. + insecure, insecureSet := a.tracerInsecure() + + exporter, err = buildOtlpExporter(a.Logger(), name, url, host, port, headers, insecure, insecureSet) case "zipkin": a.Logger().Warn("TRACE_EXPORTER=zipkin is deprecated and will be removed in a future release. " + "Zipkin supports OTLP natively (v2.24+) — to migrate, switch to TRACE_EXPORTER=otlp " + @@ -181,16 +210,99 @@ func (a *App) getExporter(name, host, port, url string) (sdktrace.SpanExporter, return exporter, err } +// otlpTransport is the resolved transport-security decision for the OTLP trace +// exporter: which endpoint option to use, whether to apply WithInsecure, and +// whether the resulting connection carries traffic in the clear. +type otlpTransport struct { + // useEndpointURL selects WithEndpointURL (the endpoint carries a scheme) + // over WithEndpoint. The two are never combined. + useEndpointURL bool + + // insecure applies WithInsecure(). Only ever true for a schemeless endpoint — + // WithEndpointURL derives transport security from the scheme itself. + insecure bool + + // plaintext reports whether spans will leave the process unencrypted, + // regardless of which option expressed it. + plaintext bool +} + +// resolveOtlpTransport derives transport security from the TRACER_URL scheme +// when it has one, and from TRACER_INSECURE only when it does not. +// +// Before this change the exporter passed the raw TRACER_URL to WithEndpoint, +// which stores it verbatim as the gRPC target. A scheme-bearing value is not a +// valid target ("too many colons in address"), so the dialer never opened a +// socket and no span was ever exported — the endpoint was unusable rather than +// downgraded. +// +// WithEndpointURL is what reads the scheme, and it must never be paired with +// WithInsecure(): the SDK applies options in slice order, so a WithInsecure() +// appended afterwards would override the scheme and downgrade the connection to +// plaintext. Hence the two are mutually exclusive below. +// +// Precedence: the SDK applies OTEL_EXPORTER_OTLP_INSECURE (and +// OTEL_EXPORTER_OTLP_TRACES_INSECURE) before any explicit option, so whatever +// GoFr passes here wins over them. TRACER_URL's scheme, then TRACER_INSECURE, +// then the OTel standard variables. +// +// Deliberate divergence from the metrics exporter (metrics/exporters/otlp.go), +// which defaults a schemeless METRICS_URL to TLS: every TRACER_URL=host:4317 +// deployment in the wild points at a plaintext collector today, because this +// exporter hardcoded WithInsecure(). Defaulting a schemeless endpoint to TLS +// would break all of them silently in a minor release, so traces default a +// schemeless endpoint to plaintext and TRACER_INSECURE=false is the opt-in. +func resolveOtlpTransport(logger logging.Logger, url string, insecure, insecureSet bool) otlpTransport { + const ( + schemeHTTP = "http://" + schemeHTTPS = "https://" + ) + + // Scheme comparison is case-insensitive per RFC 3986 §3.1, and url.Parse + // inside WithEndpointURL treats it that way — so HTTPS://host:4317 must not + // fall through to WithEndpoint, where it would be an invalid gRPC target. + scheme := strings.ToLower(url) + + if strings.HasPrefix(scheme, schemeHTTP) || strings.HasPrefix(scheme, schemeHTTPS) { + if insecureSet { + logger.Warnf("TRACER_INSECURE is ignored for TRACER_URL=%q: transport security is derived "+ + "from the URL scheme", url) + } + + return otlpTransport{useEndpointURL: true, plaintext: strings.HasPrefix(scheme, schemeHTTP)} + } + + return otlpTransport{insecure: insecure, plaintext: insecure} +} + // buildOpenTelemetryProtocol using OpenTelemetryProtocol as the trace exporter // jaeger accept OpenTelemetry Protocol (OTLP) over gRPC to upload trace data. -func buildOtlpExporter(logger logging.Logger, name, url, host, port string, headers map[string]string) (sdktrace.SpanExporter, error) { +func buildOtlpExporter(logger logging.Logger, name, url, host, port string, headers map[string]string, + insecure, insecureSet bool) (sdktrace.SpanExporter, error) { if url == "" { url = fmt.Sprintf("%s:%s", host, port) } + transport := resolveOtlpTransport(logger, url, insecure, insecureSet) + + if transport.plaintext && len(headers) > 0 { + logger.Warnf("traces are exported to %s over plaintext with headers configured: "+ + "headers (including auth credentials) will be sent in the clear", url) + } + logger.Infof("Exporting traces to %s at %s", strings.ToLower(name), url) - opts := []otlptracegrpc.Option{otlptracegrpc.WithInsecure(), otlptracegrpc.WithEndpoint(url)} + var opts []otlptracegrpc.Option + + if transport.useEndpointURL { + opts = append(opts, otlptracegrpc.WithEndpointURL(url)) + } else { + opts = append(opts, otlptracegrpc.WithEndpoint(url)) + + if transport.insecure { + opts = append(opts, otlptracegrpc.WithInsecure()) + } + } if len(headers) > 0 { opts = append(opts, otlptracegrpc.WithHeaders(headers)) diff --git a/pkg/gofr/otel_test.go b/pkg/gofr/otel_test.go index 2606e3fcbe..4016a33e64 100644 --- a/pkg/gofr/otel_test.go +++ b/pkg/gofr/otel_test.go @@ -3,18 +3,280 @@ package gofr import ( "context" "errors" + "net" "testing" + "time" "github.com/stretchr/testify/require" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/sdk/resource" sdktrace "go.opentelemetry.io/otel/sdk/trace" + "go.opentelemetry.io/otel/sdk/trace/tracetest" "go.opentelemetry.io/otel/trace/noop" "gofr.dev/pkg/gofr/config" + "gofr.dev/pkg/gofr/container" "gofr.dev/pkg/gofr/logging" + "gofr.dev/pkg/gofr/testutil" ) +func Test_resolveOtlpTransport(t *testing.T) { + tests := []struct { + name string + url string + insecure bool + insecureSet bool + expected otlpTransport + }{ + { + name: "schemeless endpoint defaults to plaintext", + url: "collector:4317", + insecure: true, + expected: otlpTransport{useEndpointURL: false, insecure: true, plaintext: true}, + }, + { + name: "schemeless endpoint with TRACER_INSECURE=false uses TLS", + url: "collector:4317", + insecure: false, + insecureSet: true, + expected: otlpTransport{useEndpointURL: false, insecure: false, plaintext: false}, + }, + { + name: "http scheme is plaintext", + url: "http://collector:4317", + insecure: true, + expected: otlpTransport{useEndpointURL: true, insecure: false, plaintext: true}, + }, + { + name: "https scheme uses TLS", + url: "https://collector:4317", + insecure: true, + expected: otlpTransport{useEndpointURL: true, insecure: false, plaintext: false}, + }, + { + name: "https scheme wins over TRACER_INSECURE=true", + url: "https://collector:4317", + insecure: true, + insecureSet: true, + expected: otlpTransport{useEndpointURL: true, insecure: false, plaintext: false}, + }, + { + name: "http scheme wins over TRACER_INSECURE=false", + url: "http://collector:4317", + insecure: false, + insecureSet: true, + expected: otlpTransport{useEndpointURL: true, insecure: false, plaintext: true}, + }, + { + name: "deprecated host:port path is plaintext by default", + url: "localhost:9411", + insecure: true, + expected: otlpTransport{useEndpointURL: false, insecure: true, plaintext: true}, + }, + { + name: "scheme match is case-insensitive", + url: "HTTPS://collector:4317", + insecure: true, + expected: otlpTransport{useEndpointURL: true, insecure: false, plaintext: false}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := resolveOtlpTransport(logging.NewMockLogger(logging.ERROR), tt.url, tt.insecure, tt.insecureSet) + + require.Equal(t, tt.expected, got) + }) + } +} + +// Test_resolveOtlpTransport_httpsIsNotDowngraded guards the invariant that makes +// the fix correct: an https:// endpoint resolves to WithEndpointURL alone. Pairing +// it with WithInsecure() would override the scheme, because the SDK applies +// options in slice order. +func Test_resolveOtlpTransport_httpsIsNotDowngraded(t *testing.T) { + got := resolveOtlpTransport(logging.NewMockLogger(logging.ERROR), "https://otelcol.local:4317", true, false) + + require.True(t, got.useEndpointURL, "an https:// endpoint must be passed to WithEndpointURL") + require.False(t, got.insecure, "WithInsecure must never be applied to an https:// endpoint") + require.False(t, got.plaintext, "an https:// endpoint must not resolve to plaintext") +} + +func Test_resolveOtlpTransport_warnsWhenInsecureIgnored(t *testing.T) { + out := testutil.StdoutOutputForFunc(func() { + resolveOtlpTransport(logging.NewMockLogger(logging.WARN), "https://collector:4317", true, true) + }) + + require.Contains(t, out, "TRACER_INSECURE") +} + +func Test_App_tracerInsecure(t *testing.T) { + tests := []struct { + name string + value string + expectedFlag bool + expectedFlagSet bool + }{ + {name: "unset defaults to plaintext", value: "", expectedFlag: true, expectedFlagSet: false}, + {name: "explicit true", value: "true", expectedFlag: true, expectedFlagSet: true}, + {name: "explicit false", value: "false", expectedFlag: false, expectedFlagSet: true}, + {name: "numeric false", value: "0", expectedFlag: false, expectedFlagSet: true}, + {name: "whitespace is trimmed", value: " false ", expectedFlag: false, expectedFlagSet: true}, + {name: "invalid value falls back to the default", value: "yes-please", expectedFlag: true, expectedFlagSet: false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + app := &App{ + Config: config.NewMockConfig(map[string]string{"TRACER_INSECURE": tt.value}), + container: &container.Container{Logger: logging.NewMockLogger(logging.ERROR)}, + } + + insecure, set := app.tracerInsecure() + + require.Equal(t, tt.expectedFlag, insecure) + require.Equal(t, tt.expectedFlagSet, set) + }) + } +} + +func Test_buildOtlpExporter_warnsOnPlaintextCredentials(t *testing.T) { + out := testutil.StdoutOutputForFunc(func() { + exp, err := buildOtlpExporter(logging.NewMockLogger(logging.WARN), "otlp", "collector:4317", "", "", + map[string]string{"Authorization": "Bearer token"}, true, false) + require.NoError(t, err) + require.NotNil(t, exp) + + _ = exp.Shutdown(t.Context()) + }) + + require.Contains(t, out, "plaintext") +} + +func Test_buildOtlpExporter(t *testing.T) { + tests := []struct { + name string + url string + host string + port string + insecure bool + insecureSet bool + }{ + {name: "schemeless default", url: "collector:4317", insecure: true}, + {name: "schemeless with TLS", url: "collector:4317", insecure: false, insecureSet: true}, + {name: "http scheme", url: "http://collector:4317", insecure: true}, + {name: "https scheme", url: "https://collector:4317", insecure: true}, + {name: "deprecated host and port", host: "localhost", port: "9411", insecure: true}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + exp, err := buildOtlpExporter(logging.NewMockLogger(logging.ERROR), "otlp", tt.url, tt.host, tt.port, + nil, tt.insecure, tt.insecureSet) + + require.NoError(t, err) + require.NotNil(t, exp) + + _ = exp.Shutdown(t.Context()) + }) + } +} + +// Test_buildOtlpExporter_wireTransport asserts the bytes the exporter actually +// puts on the socket, which is the only assertion that fails if the option block +// regresses: Test_buildOtlpExporter's err == nil && exp != nil holds for any +// option set, and resolveOtlpTransport is a pure function the wiring could stop +// consulting. Restoring the pre-fix line (WithInsecure + WithEndpoint(url)) makes +// both scheme-bearing subtests fail here — the raw URL is an invalid gRPC target, +// so no connection is ever opened. +func Test_buildOtlpExporter_wireTransport(t *testing.T) { + const ( + h2cPreface = "PRI * HTTP/2.0" + tlsHandshake = 0x16 + ) + + tests := []struct { + name string + scheme string + insecure bool + insecureSet bool + expectTLS bool + }{ + {name: "schemeless endpoint speaks h2c", scheme: "", insecure: true}, + {name: "http scheme speaks h2c", scheme: "http://", insecure: true}, + {name: "https scheme speaks TLS", scheme: "https://", insecure: true, expectTLS: true}, + { + name: "schemeless with TRACER_INSECURE=false speaks TLS", scheme: "", insecure: false, + insecureSet: true, expectTLS: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + first := make(chan []byte, 1) + url := tt.scheme + listenForFirstBytes(t, first) + + exp, err := buildOtlpExporter(logging.NewMockLogger(logging.ERROR), "otlp", url, "", "", + nil, tt.insecure, tt.insecureSet) + require.NoError(t, err) + + t.Cleanup(func() { _ = exp.Shutdown(context.Background()) }) + + // The export itself always errors — nothing on the far end speaks OTLP. + // What is under test is whether a connection happened at all, and in + // which protocol. A short deadline keeps the TLS case off the SDK default. + ctx, cancel := context.WithTimeout(t.Context(), time.Second) + defer cancel() + + _ = exp.ExportSpans(ctx, tracetest.SpanStubs{{Name: "wire-probe"}}.Snapshots()) + + select { + case got := <-first: + require.NotEmpty(t, got, "connection opened but no bytes were sent") + + if tt.expectTLS { + require.EqualValues(t, tlsHandshake, got[0], "expected a TLS ClientHello, got %q", got) + } else { + require.Contains(t, string(got), h2cPreface, "expected the h2c preface") + } + case <-time.After(2 * time.Second): + t.Fatalf("no connection was made to %s: the endpoint is not a usable gRPC target", url) + } + }) + } +} + +// listenForFirstBytes starts a throwaway listener and hands the first bytes of +// the first connection to first. It returns the host:port to dial. +func listenForFirstBytes(t *testing.T, first chan<- []byte) string { + t.Helper() + + var lc net.ListenConfig + + ln, err := lc.Listen(t.Context(), "tcp", "127.0.0.1:0") + require.NoError(t, err) + + t.Cleanup(func() { _ = ln.Close() }) + + go func() { + conn, err := ln.Accept() + if err != nil { + return + } + + defer conn.Close() + + _ = conn.SetReadDeadline(time.Now().Add(2 * time.Second)) + + buf := make([]byte, 24) + n, _ := conn.Read(buf) + + first <- buf[:n] + }() + + return ln.Addr().String() +} + func TestParseHeaders(t *testing.T) { tests := []struct { name string From 9c6a9dfa49d1159bcda8cb83388b685759861e6a Mon Sep 17 00:00:00 2001 From: Akshat Singhal <65562230+akshat-kumar-singhal@users.noreply.github.com> Date: Tue, 15 Sep 2026 15:32:15 +0530 Subject: [PATCH 42/48] ci: stop passing -short to submodule tests, which skipped 10 mongo tests entirely (#4201) Co-authored-by: Aryan Mehrotra --- .github/workflows/go.yml | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index d980f67ee2..75fc90a5bb 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -455,8 +455,25 @@ jobs: # is checked without mutation in the code_quality job instead. go mod download - # Run tests with a focus on failed tests first - go test ./... -v -short -coverprofile="${module_name}.cov" -coverpkg=./... + # NOTE: this whole block is the single-quoted payload of the + # `bash -c` above, so nothing in here may contain an apostrophe — + # not even inside a comment. One in a comment closes the quote and + # the runner fails with a syntax error before any test runs. + # + # Deliberately NOT `-short`. It does not merely shorten these + # suites, it deletes whole test functions from the coverage figure: + # the mtest harness shipped by the mongo driver calls t.Skip with + # "skipping mtest integration test in short mode" even under + # ClientType of mtest.Mock, which needs no server and no network. + # Ten test functions covering every mongo CRUD path were being + # skipped, so pkg/gofr/datasource/mongo reported 27.2% instead of + # 87.7% for tests that already exist and run in 1.4s. + # + # Measured across all 27 submodules: mongo is the only one whose + # figure changes at all and the only one with any testing.Short + # gating, and all 27 pass either way. Dropping the flag changes + # only what mtest was hiding. + go test ./... -v -coverprofile="${module_name}.cov" -coverpkg=./... # Copy coverage file to the coverage_reports directory cp "${module_name}.cov" "$COVERAGE_DIR/" From 851b78a7723ffb24fd03bf8209e45a2fb3366efd Mon Sep 17 00:00:00 2001 From: Akshat Singhal <65562230+akshat-kumar-singhal@users.noreply.github.com> Date: Tue, 15 Sep 2026 16:14:44 +0530 Subject: [PATCH 43/48] ci: measure every in-repo pkg/gofr package, not just the 29 top-level files (#4202) (#4203) --- .github/workflows/go.yml | 43 ++++++++++++++++++++++++++++++++++------ 1 file changed, 37 insertions(+), 6 deletions(-) diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index 75fc90a5bb..795c895199 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -291,10 +291,19 @@ jobs: set -eo pipefail export APP_ENV=test - # Run tests for root gofr package + # Run tests for root gofr package. + # + # `-coverpkg=./pkg/gofr/...`, not `./pkg/gofr`: the narrow form + # instruments only the 29 top-level pkg/gofr/*.go files, so every + # in-repo sub-package — http, http/middleware, container, service, + # logging, cmd, migration, rbac, datasource/sql, datasource/redis + # and the rest — was absent from the published figure even though + # its tests run here on every push. The narrow glob measured 1,848 + # statements; the tree measures 10,482, and the figure went from + # 86.5% to 90.0% without a new test being written (#4202). exit_code=0 go test -v -short -covermode=atomic \ - -coverpkg=./pkg/gofr -coverprofile=gofr_only.cov ./pkg/gofr || exit_code=$? + -coverpkg=./pkg/gofr/... -coverprofile=root_pkg.cov ./pkg/gofr || exit_code=$? if [ $exit_code -eq 2 ]; then echo "::error::Panic detected in root gofr package tests" exit 2 @@ -303,10 +312,13 @@ jobs: exit $exit_code fi - # Run tests for sub-packages + # Run tests for sub-packages. Same widening as above; the profile + # name says sub-packages because these are packages of this module, + # not the pkg/gofr/datasource/* submodules (those are separate Go + # modules, covered by Submodule-Unit-Testing). exit_code=0 go test -v -covermode=atomic \ - -coverpkg=./pkg/gofr -coverprofile=submodules.cov ./pkg/gofr/... || exit_code=$? + -coverpkg=./pkg/gofr/... -coverprofile=sub_pkgs.cov ./pkg/gofr/... || exit_code=$? if [ $exit_code -eq 2 ]; then echo "::error::Panic detected in gofr sub-packages tests" exit 2 @@ -315,9 +327,28 @@ jobs: exit $exit_code fi - # Combine coverage profiles + # Combine coverage profiles. + # + # `/mock_` strips generated gomock files. `/testutil/` strips the + # test helper package, which the widened -coverpkg would otherwise + # admit: it is scaffolding for tests, not shipped behaviour, and at + # 98% it flatters the numerator the same way the mocks would. + # + # The awk merges duplicate blocks. Under a multi-package -coverpkg + # every block is emitted once per test binary, so a plain + # concatenation here is 31 copies of the same 12k blocks: 21 MB of + # profile to upload, download and hand to qlty. Keyed by block + # position, statement count carried through, execution counts + # summed — which is what merging two profiles of the same code + # means. `go tool cover` reaches the same percentage either way + # (it resolves duplicates itself); this is about the artifact, and + # about a profile a human can read. echo "mode: atomic" > profile.cov - grep -h -v "mode:" gofr_only.cov submodules.cov | grep -v '/mock_' >> profile.cov + grep -h -v "mode:" root_pkg.cov sub_pkgs.cov \ + | grep -v '/mock_' \ + | grep -v '/testutil/' \ + | awk '{stmts[$1] = $2; count[$1] += $3} END {for (blk in stmts) print blk, stmts[blk], count[blk]}' \ + | sort >> profile.cov # Show coverage summary go tool cover -func profile.cov From 23852af71d476e1f065671c431e184dea64ff2ec Mon Sep 17 00:00:00 2001 From: Umang Mundhra Date: Wed, 16 Sep 2026 14:27:47 +0530 Subject: [PATCH 44/48] chore(deps): consolidate minor dependency updates (2026-09-16) (#4244) --- examples/using-cloudsql/go.mod | 2 +- examples/using-cloudsql/go.sum | 4 +- examples/using-gcp-metrics/go.mod | 48 +++---- examples/using-gcp-metrics/go.sum | 124 +++++++++---------- go.mod | 20 +-- go.sum | 48 +++---- go.work.sum | 8 ++ pkg/gofr/datasource/arangodb/go.mod | 6 +- pkg/gofr/datasource/arangodb/go.sum | 12 +- pkg/gofr/datasource/cassandra/go.mod | 6 +- pkg/gofr/datasource/cassandra/go.sum | 15 ++- pkg/gofr/datasource/clickhouse/go.mod | 4 +- pkg/gofr/datasource/clickhouse/go.sum | 8 +- pkg/gofr/datasource/cloudsql/go.mod | 2 +- pkg/gofr/datasource/cloudsql/go.sum | 4 +- pkg/gofr/datasource/couchbase/go.mod | 6 +- pkg/gofr/datasource/couchbase/go.sum | 12 +- pkg/gofr/datasource/dbresolver/go.mod | 6 +- pkg/gofr/datasource/dbresolver/go.sum | 12 +- pkg/gofr/datasource/dgraph/go.mod | 6 +- pkg/gofr/datasource/dgraph/go.sum | 12 +- pkg/gofr/datasource/elasticsearch/go.mod | 6 +- pkg/gofr/datasource/elasticsearch/go.sum | 12 +- pkg/gofr/datasource/file/gcs/go.mod | 10 +- pkg/gofr/datasource/file/gcs/go.sum | 20 +-- pkg/gofr/datasource/kv-store/badger/go.mod | 6 +- pkg/gofr/datasource/kv-store/badger/go.sum | 12 +- pkg/gofr/datasource/kv-store/dynamodb/go.mod | 4 +- pkg/gofr/datasource/kv-store/dynamodb/go.sum | 8 +- pkg/gofr/datasource/kv-store/nats/go.mod | 4 +- pkg/gofr/datasource/kv-store/nats/go.sum | 8 +- pkg/gofr/datasource/mongo/go.mod | 6 +- pkg/gofr/datasource/mongo/go.sum | 12 +- pkg/gofr/datasource/opentsdb/go.mod | 6 +- pkg/gofr/datasource/opentsdb/go.sum | 12 +- pkg/gofr/datasource/oracle/go.mod | 6 +- pkg/gofr/datasource/oracle/go.sum | 12 +- pkg/gofr/datasource/pubsub/eventhub/go.mod | 6 +- pkg/gofr/datasource/pubsub/eventhub/go.sum | 12 +- pkg/gofr/datasource/pubsub/sqs/go.mod | 8 +- pkg/gofr/datasource/pubsub/sqs/go.sum | 16 +-- pkg/gofr/datasource/scylladb/go.mod | 4 +- pkg/gofr/datasource/scylladb/go.sum | 8 +- pkg/gofr/datasource/solr/go.mod | 6 +- pkg/gofr/datasource/solr/go.sum | 12 +- pkg/gofr/datasource/surrealdb/go.mod | 8 +- pkg/gofr/datasource/surrealdb/go.sum | 16 +-- pkg/gofr/metrics/exporters/gcp/go.mod | 2 +- pkg/gofr/metrics/exporters/gcp/go.sum | 4 +- 49 files changed, 309 insertions(+), 302 deletions(-) diff --git a/examples/using-cloudsql/go.mod b/examples/using-cloudsql/go.mod index 440d24e957..fd08586ffc 100644 --- a/examples/using-cloudsql/go.mod +++ b/examples/using-cloudsql/go.mod @@ -45,7 +45,7 @@ require ( github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 // indirect github.com/jackc/pgpassfile v1.0.0 // indirect github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect - github.com/jackc/pgx/v5 v5.10.0 // indirect + github.com/jackc/pgx/v5 v5.11.0 // indirect github.com/jackc/puddle/v2 v2.2.2 // indirect github.com/joho/godotenv v1.5.1 // indirect github.com/klauspost/compress v1.18.6 // indirect diff --git a/examples/using-cloudsql/go.sum b/examples/using-cloudsql/go.sum index c80933626b..20b2bf84fa 100644 --- a/examples/using-cloudsql/go.sum +++ b/examples/using-cloudsql/go.sum @@ -138,8 +138,8 @@ github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsI github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= -github.com/jackc/pgx/v5 v5.10.0 h1:VhSvgU2jSli8o3AqIEOTJr7rZwAEUVo4E4XhR94Zfr0= -github.com/jackc/pgx/v5 v5.10.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= +github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg= +github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= diff --git a/examples/using-gcp-metrics/go.mod b/examples/using-gcp-metrics/go.mod index 1ceb46b737..6232a35aad 100644 --- a/examples/using-gcp-metrics/go.mod +++ b/examples/using-gcp-metrics/go.mod @@ -9,7 +9,7 @@ require ( require ( cloud.google.com/go v0.123.0 // indirect - cloud.google.com/go/auth v0.22.0 // indirect + cloud.google.com/go/auth v0.23.2 // indirect cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect cloud.google.com/go/compute/metadata v0.9.0 // indirect cloud.google.com/go/iam v1.12.0 // indirect @@ -17,7 +17,7 @@ require ( cloud.google.com/go/pubsub/v2 v2.6.0 // indirect filippo.io/edwards25519 v1.2.0 // indirect github.com/DATA-DOG/go-sqlmock v1.5.2 // indirect - github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.33.0 // indirect + github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.36.0 // indirect github.com/XSAM/otelsql v0.43.0 // indirect github.com/agnivade/levenshtein v1.2.1 // indirect github.com/beorn7/perks v1.0.1 // indirect @@ -34,8 +34,8 @@ require ( github.com/golang-jwt/jwt/v5 v5.3.1 // indirect github.com/google/s2a-go v0.1.9 // indirect github.com/google/uuid v1.6.0 // indirect - github.com/googleapis/enterprise-certificate-proxy v0.3.19 // indirect - github.com/googleapis/gax-go/v2 v2.23.0 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.20 // indirect + github.com/googleapis/gax-go/v2 v2.24.0 // indirect github.com/gorilla/mux v1.8.1 // indirect github.com/gorilla/websocket v1.5.3 // indirect github.com/graphql-go/graphql v0.8.1 // indirect @@ -61,50 +61,50 @@ require ( github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect github.com/segmentio/kafka-go v0.4.51 // indirect github.com/stretchr/testify v1.12.1 // indirect - github.com/vektah/gqlparser/v2 v2.5.36 // indirect + github.com/vektah/gqlparser/v2 v2.5.37 // indirect github.com/xdg-go/pbkdf2 v1.0.0 // indirect github.com/xdg-go/scram v1.1.2 // indirect github.com/xdg-go/stringprep v1.0.4 // indirect go.opencensus.io v0.24.0 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/contrib/detectors/gcp v1.44.0 // indirect + go.opentelemetry.io/contrib/detectors/gcp v1.46.0 // indirect go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 // indirect go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 // indirect go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 // indirect - go.opentelemetry.io/otel v1.45.0 // indirect + go.opentelemetry.io/otel v1.46.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.44.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 // indirect go.opentelemetry.io/otel/exporters/prometheus v0.67.0 // indirect - go.opentelemetry.io/otel/exporters/zipkin v1.44.0 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect - go.opentelemetry.io/otel/sdk v1.45.0 // indirect - go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect - go.opentelemetry.io/otel/trace v1.45.0 // indirect + go.opentelemetry.io/otel/exporters/zipkin v1.46.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect + go.opentelemetry.io/otel/sdk v1.46.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.46.0 // indirect + go.opentelemetry.io/otel/trace v1.46.0 // indirect go.opentelemetry.io/proto/otlp v1.10.0 // indirect go.uber.org/atomic v1.11.0 // indirect go.uber.org/mock v0.6.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/crypto v0.55.0 // indirect - golang.org/x/net v0.57.0 // indirect - golang.org/x/oauth2 v0.36.0 // indirect - golang.org/x/sync v0.22.0 // indirect - golang.org/x/sys v0.47.0 // indirect - golang.org/x/term v0.45.0 // indirect - golang.org/x/text v0.41.0 // indirect - golang.org/x/time v0.15.0 // indirect - google.golang.org/api v0.291.0 // indirect + golang.org/x/net v0.58.0 // indirect + golang.org/x/oauth2 v0.37.0 // indirect + golang.org/x/sync v0.23.0 // indirect + golang.org/x/sys v0.48.0 // indirect + golang.org/x/term v0.46.0 // indirect + golang.org/x/text v0.42.0 // indirect + golang.org/x/time v0.16.0 // indirect + google.golang.org/api v0.297.0 // indirect google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 // indirect - google.golang.org/grpc v1.83.1 // indirect + google.golang.org/grpc v1.83.2 // indirect google.golang.org/protobuf v1.36.12 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect - modernc.org/libc v1.74.4 // indirect + modernc.org/libc v1.75.6 // indirect modernc.org/mathutil v1.7.1 // indirect - modernc.org/memory v1.11.0 // indirect - modernc.org/sqlite v1.56.0 // indirect + modernc.org/memory v1.12.1 // indirect + modernc.org/sqlite v1.58.0 // indirect ) replace gofr.dev => ../../ diff --git a/examples/using-gcp-metrics/go.sum b/examples/using-gcp-metrics/go.sum index 3336e317d9..5decad80e6 100644 --- a/examples/using-gcp-metrics/go.sum +++ b/examples/using-gcp-metrics/go.sum @@ -1,8 +1,8 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE= cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU= -cloud.google.com/go/auth v0.22.0 h1:Xp9wAKkLoeaYb5pYZZoQGz4E9sdPxIbzS3gywZE3ciQ= -cloud.google.com/go/auth v0.22.0/go.mod h1:M9o2Oz+YI2jAfxewJgb1vyI3vceHF+eohmxyzmrl+9s= +cloud.google.com/go/auth v0.23.2 h1:pxSCpfiji41hpzpPdMCftEUCezpgpqmmDdYiAjCKXxo= +cloud.google.com/go/auth v0.23.2/go.mod h1:4DhBRcqvtljQN3dJ57qtqbib5ZGCYE5f2crfiiC2EM0= cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc= cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= @@ -22,14 +22,14 @@ filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU= github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= -github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.33.0 h1:l7+6kwRMJNwdCvYdDl7Eax+wzEYHSnNY7zrrfbhDdTA= -github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.33.0/go.mod h1:pJTkW8hEUIIi3Pf65lPZOnn4Y81yCllX6IWk2jNXdkM= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.36.0 h1:3SdxXLkgAfiHRWcGTq6fneq9jgoJzneiY0yPQnjoT2E= +github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.36.0/go.mod h1:1iIdl0k+ppn9wT0wzR9H7HkSvIui/4qgtnKW10cQtds= github.com/XSAM/otelsql v0.43.0 h1:ZIhXqRoMhILXQwBQoq/Dl6Taap/KEFQXZrWjYV1L8X8= github.com/XSAM/otelsql v0.43.0/go.mod h1:DJBGBvbtwf1OCBYRTjpRFxOqi6ONpdfb+htr4ncRWuw= github.com/agnivade/levenshtein v1.2.1 h1:EHBY3UOn1gwdy/VbFwgo4cxecRznFk7fKWN1KOX7eoM= github.com/agnivade/levenshtein v1.2.1/go.mod h1:QVVI16kDrtSuwcpd0p1+xMC6Z/VfhtCyDIjcwga4/DU= -github.com/alicebob/miniredis/v2 v2.38.0 h1:nZAzCR+Lj+Vxk4ZXzm2NuKq2O33RXj1XxJ2e2uP9jiw= -github.com/alicebob/miniredis/v2 v2.38.0/go.mod h1:TcL7YfarKPGDAthEtl5NBeHZfeUQj6OXMm/+iu5cLMM= +github.com/alicebob/miniredis/v2 v2.39.0 h1:M7WbmV5BmV56L8KTG0rw6vEQ+woTOghpDgin2xv4A0g= +github.com/alicebob/miniredis/v2 v2.39.0/go.mod h1:TcL7YfarKPGDAthEtl5NBeHZfeUQj6OXMm/+iu5cLMM= github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0 h1:jfIu9sQUG6Ig+0+Ap1h4unLjW6YQJpKZVmUzxsD4E/Q= github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0/go.mod h1:t2tdKJDJF9BV14lnkjHmOQgcvEKgtqs5a1N3LNdJhGE= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= @@ -112,10 +112,10 @@ github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/enterprise-certificate-proxy v0.3.19 h1:mMOE7DN2+p76/EdIrmAy9B9bH+yC4563vmnJ34QR8i4= -github.com/googleapis/enterprise-certificate-proxy v0.3.19/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= -github.com/googleapis/gax-go/v2 v2.23.0 h1:Tchl7qkvE7Ip3y+ztvNufYFvkfqTe7NfLTYGIdJRLuE= -github.com/googleapis/gax-go/v2 v2.23.0/go.mod h1:rBQKOVJCdb8IFEzg+FCwlt1LP/xMDGuqUXhUG+XMXEg= +github.com/googleapis/enterprise-certificate-proxy v0.3.20 h1:t/xL64VUoN69MuMRQuJETqYGOw4Z9mSRJK9epIEtwFk= +github.com/googleapis/enterprise-certificate-proxy v0.3.20/go.mod h1:L3D/IQExI6LqEjBdXcZQ1WluSgigQmSwBboFstVPM4w= +github.com/googleapis/gax-go/v2 v2.24.0 h1:myMaPYyF9MecEmvQqMqomIwn9t/4KCZN9qnwsS76wlg= +github.com/googleapis/gax-go/v2 v2.24.0/go.mod h1:IaTHBDd7NHxSCiu0vEs8pQZu4dGZrWwuSoxCnk16OFM= github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= @@ -193,8 +193,8 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= -github.com/vektah/gqlparser/v2 v2.5.36 h1:CN9mKVHgMkc+XftdOWIhb4HEL8wKSYkFAqhf8booa7s= -github.com/vektah/gqlparser/v2 v2.5.36/go.mod h1:cAJ9qwVgPaUkWv6Gn8vn0mqOE0Ui5Pn56wNy5396XWo= +github.com/vektah/gqlparser/v2 v2.5.37 h1:jbb1Ilv+xBklV6653tKb4oVUupPNTLb5LmrnBKVI12Y= +github.com/vektah/gqlparser/v2 v2.5.37/go.mod h1:9O4Ox6Ngd3Y12bMD3w6i3CRQXh8W1oC1q0m6olCymDM= github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c= github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI= github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY= @@ -214,16 +214,16 @@ go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0= go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/contrib/detectors/gcp v1.44.0 h1:NmLfL734pJhM0JKaYd2Y28+nY9dPRWYAAbxhRCrKXPw= -go.opentelemetry.io/contrib/detectors/gcp v1.44.0/go.mod h1:tNAsgd8avTGke1+MndXlU5Cru4PQ9Ai/cCNWQv/ZJ/s= +go.opentelemetry.io/contrib/detectors/gcp v1.46.0 h1:PI8dGkqDaQkwJ8kOopqMhDTbrnK3UIeG/RCHH4HErbo= +go.opentelemetry.io/contrib/detectors/gcp v1.46.0/go.mod h1:nsrN5c/sOLoY2vsPxN/rQ0V0nvGrWJCqcW4UXLtqNG8= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 h1:0Qx7VGBacMm9ZENQ7TnNObTYI4ShC+lHI16seduaxZo= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0/go.mod h1:Sje3i3MjSPKTSPvVWCaL8ugBzJwik3u4smCjUeuupqg= go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 h1:aVgLpGksz0vjoe6OynycqX8daNOAxJx5ZEhJXIXOVIU= go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0/go.mod h1:kmJlX6WuTrAH1fOCSbPJFrSnUagB8c3SY3E87It3JD8= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 h1:LMuyCAyfalSjDyjdC65nK6N0zoTT63+E/u95X0JovZI= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0/go.mod h1:085m8qbm4hgc8rZWGDEa4vmyyo2c3nPxUslYUKUIU04= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0 h1:SUplec5dp06reu1zaXmOXdvqH398taqrDXqUl99jxSc= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0/go.mod h1:ho2g4N+ane+swq5I/VBkKWnRDY4kUINH3FuqyZqX/Ug= go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.44.0 h1:RuynHbfU8JUEw7DyONgkVYg2SVtsoF28y0LGIr69jgA= @@ -234,18 +234,18 @@ go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 h1:qazEJ go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0/go.mod h1:fOD2Yefuxixkx3ahVNf0O/PERb6r4OlbxfATVnYvzCo= go.opentelemetry.io/otel/exporters/prometheus v0.67.0 h1:7IefDa35e6V3NoiqIeLDMDxMFyZDk5qcoC0Ax4cC16E= go.opentelemetry.io/otel/exporters/prometheus v0.67.0/go.mod h1:nsPI1awTg5Vmg1YrommL2mVarVGlqc4yXOoKAkPRD0c= -go.opentelemetry.io/otel/exporters/zipkin v1.44.0 h1:zv7PRYGLrQHkdeZj0c5SNAZOJcw55XgaTezUkNpwA+w= -go.opentelemetry.io/otel/exporters/zipkin v1.44.0/go.mod h1:3+VZyCi6hFW+UuxFF+wSOvwsOwncfBpQfP7Qdb3JXKg= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= -go.opentelemetry.io/otel/metric/x v0.67.0 h1:PcicCNZFkZ4bXfSooXdo3WN7RBOVOtjVdo1wD358Uns= -go.opentelemetry.io/otel/metric/x v0.67.0/go.mod h1:FBjCWZe6wgcqxcMtjdGiClDKXb2YxxXii0CXftE4QtI= -go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= -go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= -go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= -go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel/exporters/zipkin v1.46.0 h1:7y0nqfbwuPdaYKwm35PRMRMOa8iYu1SXxnAJNNR2o1M= +go.opentelemetry.io/otel/exporters/zipkin v1.46.0/go.mod h1:MGmDLXGsdDzWBOt0y5VcW2u5hRsFV4MzylPvvNkQ9qw= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/metric/x v0.68.0 h1:TA/cBT23D3MnxYPwHL7YFOdYGdx0A0v+s7Mzotpd1dU= +go.opentelemetry.io/otel/metric/x v0.68.0/go.mod h1:agudOmvWhwUTjgibWDzxD2PoWYnpw5Ht5jISYOD2Hd4= +go.opentelemetry.io/otel/sdk v1.46.0 h1:h5CNQQjEbuQXY/JfZtgt3i7HVFV3aHPO2OAwO2eTYPI= +go.opentelemetry.io/otel/sdk v1.46.0/go.mod h1:GAERFXFt5SYCEB+YiKUbMBeza6UaDH7GmGOZEfh2gSM= +go.opentelemetry.io/otel/sdk/metric v1.46.0 h1:0piZ26EG4RBfebb2jhDH6ERCYHoVWduc3kLgPCwSnSE= +go.opentelemetry.io/otel/sdk/metric v1.46.0/go.mod h1:I1PbKrdVc8Qu8HYVDNtqVIwLwjNrhsV/uFuxfwg8mO4= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.opentelemetry.io/proto/otlp v1.10.0 h1:IQRWgT5srOCYfiWnpqUYz9CVmbO8bFmKcwYxpuCSL2g= go.opentelemetry.io/proto/otlp v1.10.0/go.mod h1:/CV4QoCR/S9yaPj8utp3lvQPoqMtxXdzn7ozvvozVqk= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= @@ -271,8 +271,8 @@ golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHl golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk= -golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40= +golang.org/x/mod v0.41.0 h1:qJmnOUb4YB+FsEuM3HcWucdZASCPGhsX6uljO6pog0c= +golang.org/x/mod v0.41.0/go.mod h1:Ek9pY8RKWXwsWvd3rQiHYtMqkjSUV+s1Rj7j4H5Ur6o= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -284,19 +284,19 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= -golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= -golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= -golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= +golang.org/x/oauth2 v0.37.0 h1:JUlcxA8oAtauLfiH8FX2/FkAWHAdi0QtGCGc+hofE98= +golang.org/x/oauth2 v0.37.0/go.mod h1:IxwZNxUULJmpBFf9K/9NTMSIfZZuvuTy1gGxhigP/58= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek= -golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= +golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk= +golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -305,20 +305,20 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= -golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo= +golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= -golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= +golang.org/x/term v0.46.0 h1:3+OXuTbaKDgwk8jTi3aSLHRlmWqHEUDUtxnbFigO4YE= +golang.org/x/term v0.46.0/go.mod h1:+K02xbkittuwc0Am4abfA3Fc+XRGXkvBXNO88NCXPoc= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= -golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= -golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= -golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= -golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= +golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI= +golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E= +golang.org/x/time v0.16.0 h1:vMb6ptszcQMkcwiRTAuNNU50gom6++Q/6gY2hDM6VDE= +golang.org/x/time v0.16.0/go.mod h1:rVKOqvZeKvrDKTQiAHJ7wmwP0RzleSphoEA9RcdLA0s= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= @@ -328,16 +328,16 @@ golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE= -golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk= +golang.org/x/tools v0.49.0 h1:3NI7VXzL9+1WZD52Dx2ttoPwD5DWrFGpl9mFZDlmisI= +golang.org/x/tools v0.49.0/go.mod h1:SJNXV9DBKT0UbdttsQjbfJlAE/q+y36++zo3uL3N0Oo= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= -google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= +google.golang.org/api v0.297.0 h1:WktxTsnnx0yZNnsR6j0q6hR21RnnK81FHTOPy/ux4OE= +google.golang.org/api v0.297.0/go.mod h1:S4m8x0M6OkQpkOzGk1y9JG2sm4fFQrMh6dxzjCTszhE= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= @@ -354,8 +354,8 @@ google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyac google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y= -google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ= +google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= +google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -375,30 +375,30 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -modernc.org/cc/v4 v4.29.1 h1:MKgdCV3WykTSPqpVrnxdEDS0HEd2FHpKZDzxzU5LyeI= -modernc.org/cc/v4 v4.29.1/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= -modernc.org/ccgo/v4 v4.34.6 h1:sBgfIwyN0TQ9C5hwIeuqyeAKyMWnbvj2fvpF4L11uzU= -modernc.org/ccgo/v4 v4.34.6/go.mod h1:SZ8YcN9NG7XVsQYdm6jYBvi8PQP1qi+kqB6OhjqI3Fk= +modernc.org/cc/v4 v4.29.2 h1:h6+9ciCnPKutf4I03CvheAvDLX7+IHlqR6Iy6J+cgd8= +modernc.org/cc/v4 v4.29.2/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= +modernc.org/ccgo/v4 v4.35.0 h1:F+TUsmw09QxLzmi3aeYYGxjAXarmZaKgj3mKQHNaA8w= +modernc.org/ccgo/v4 v4.35.0/go.mod h1:qrVGs9S3Sr2Ztcg9ve+kTAYMp5a3YvWjo+SoN06kJ5I= modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM= modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU= modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI= modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito= -modernc.org/gc/v3 v3.1.4 h1:2g65LGVSmFQrXeITAw97x7hCRvZFcyE1uDP+7Vng7JI= -modernc.org/gc/v3 v3.1.4/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= +modernc.org/gc/v3 v3.1.5 h1:21ldfPfRYE31Tb7B3mwAK8gy1AxP4+dKjrOQPfqakoc= +modernc.org/gc/v3 v3.1.5/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks= modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI= -modernc.org/libc v1.74.4 h1:fX1Omw4o2/1C2iRkkIsrQTasJQldLhRmuPreXLoWs9k= -modernc.org/libc v1.74.4/go.mod h1:eeQAS9W3sZeKYMFubydxJpII9ybHWshk+7or7bLG9co= +modernc.org/libc v1.75.6 h1:yKk8qo+Di4gkmvRboK8ocCqH22FiUCR6jRy2OwtCRus= +modernc.org/libc v1.75.6/go.mod h1:bO5o2ztHxBb2rjz0PgdHN0sSMw57CgxGFLZ3Qd/QpVQ= modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= -modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI= -modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw= +modernc.org/memory v1.12.1 h1:nFMiWrpStgZczNl6XI9GnIk/rWhYIyHGUaR04pGbp9g= +modernc.org/memory v1.12.1/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw= modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg= modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE= -modernc.org/sqlite v1.56.0 h1:/D8e2RfFqoy/Zc6PuC76U28zFwmI/sYx1Kjm4yEn9e0= -modernc.org/sqlite v1.56.0/go.mod h1:yCJ2cmAaIkHQ25oXWrF8H4O1lIfPYPR26yCEDj2P3pQ= +modernc.org/sqlite v1.58.0 h1:38u40/bwkfM7f0Myhosl+SEMltSDxnGdQf8o6Kjmys0= +modernc.org/sqlite v1.58.0/go.mod h1:rsD2CckafgObKC4DhBlGBf+RiHxkc3hINGt1Xw32tVY= modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= diff --git a/go.mod b/go.mod index ecf08b6bd9..1cff9f198a 100644 --- a/go.mod +++ b/go.mod @@ -27,7 +27,7 @@ require ( github.com/redis/go-redis/v9 v9.22.0 github.com/segmentio/kafka-go v0.4.51 github.com/stretchr/testify v1.12.1 - github.com/vektah/gqlparser/v2 v2.5.36 + github.com/vektah/gqlparser/v2 v2.5.37 go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 go.opentelemetry.io/otel v1.46.0 go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.44.0 @@ -41,12 +41,12 @@ require ( go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/goleak v1.3.0 go.uber.org/mock v0.6.0 - golang.org/x/oauth2 v0.36.0 + golang.org/x/oauth2 v0.37.0 golang.org/x/sync v0.23.0 - golang.org/x/term v0.45.0 - golang.org/x/text v0.41.0 - golang.org/x/time v0.15.0 - google.golang.org/api v0.291.0 + golang.org/x/term v0.46.0 + golang.org/x/text v0.42.0 + golang.org/x/time v0.16.0 + google.golang.org/api v0.297.0 google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 google.golang.org/grpc v1.83.2 google.golang.org/protobuf v1.36.12 @@ -56,7 +56,7 @@ require ( require ( cloud.google.com/go v0.123.0 // indirect - cloud.google.com/go/auth v0.22.0 // indirect + cloud.google.com/go/auth v0.23.2 // indirect cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect cloud.google.com/go/compute/metadata v0.9.0 // indirect cloud.google.com/go/iam v1.12.0 // indirect @@ -74,8 +74,8 @@ require ( github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect github.com/google/go-cmp v0.7.0 // indirect github.com/google/s2a-go v0.1.9 // indirect - github.com/googleapis/enterprise-certificate-proxy v0.3.19 // indirect - github.com/googleapis/gax-go/v2 v2.23.0 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.20 // indirect + github.com/googleapis/gax-go/v2 v2.24.0 // indirect github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 // indirect github.com/klauspost/compress v1.19.2 // indirect github.com/mattn/go-isatty v0.0.24 // indirect @@ -104,7 +104,7 @@ require ( go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/crypto v0.55.0 // indirect golang.org/x/net v0.58.0 // indirect - golang.org/x/sys v0.47.0 // indirect + golang.org/x/sys v0.48.0 // indirect google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd // indirect modernc.org/libc v1.75.6 // indirect diff --git a/go.sum b/go.sum index f433e34749..a1ce2fb6b8 100644 --- a/go.sum +++ b/go.sum @@ -1,8 +1,8 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE= cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU= -cloud.google.com/go/auth v0.22.0 h1:Xp9wAKkLoeaYb5pYZZoQGz4E9sdPxIbzS3gywZE3ciQ= -cloud.google.com/go/auth v0.22.0/go.mod h1:M9o2Oz+YI2jAfxewJgb1vyI3vceHF+eohmxyzmrl+9s= +cloud.google.com/go/auth v0.23.2 h1:pxSCpfiji41hpzpPdMCftEUCezpgpqmmDdYiAjCKXxo= +cloud.google.com/go/auth v0.23.2/go.mod h1:4DhBRcqvtljQN3dJ57qtqbib5ZGCYE5f2crfiiC2EM0= cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc= cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= @@ -112,10 +112,10 @@ github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/enterprise-certificate-proxy v0.3.19 h1:mMOE7DN2+p76/EdIrmAy9B9bH+yC4563vmnJ34QR8i4= -github.com/googleapis/enterprise-certificate-proxy v0.3.19/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= -github.com/googleapis/gax-go/v2 v2.23.0 h1:Tchl7qkvE7Ip3y+ztvNufYFvkfqTe7NfLTYGIdJRLuE= -github.com/googleapis/gax-go/v2 v2.23.0/go.mod h1:rBQKOVJCdb8IFEzg+FCwlt1LP/xMDGuqUXhUG+XMXEg= +github.com/googleapis/enterprise-certificate-proxy v0.3.20 h1:t/xL64VUoN69MuMRQuJETqYGOw4Z9mSRJK9epIEtwFk= +github.com/googleapis/enterprise-certificate-proxy v0.3.20/go.mod h1:L3D/IQExI6LqEjBdXcZQ1WluSgigQmSwBboFstVPM4w= +github.com/googleapis/gax-go/v2 v2.24.0 h1:myMaPYyF9MecEmvQqMqomIwn9t/4KCZN9qnwsS76wlg= +github.com/googleapis/gax-go/v2 v2.24.0/go.mod h1:IaTHBDd7NHxSCiu0vEs8pQZu4dGZrWwuSoxCnk16OFM= github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= @@ -199,8 +199,8 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= -github.com/vektah/gqlparser/v2 v2.5.36 h1:CN9mKVHgMkc+XftdOWIhb4HEL8wKSYkFAqhf8booa7s= -github.com/vektah/gqlparser/v2 v2.5.36/go.mod h1:cAJ9qwVgPaUkWv6Gn8vn0mqOE0Ui5Pn56wNy5396XWo= +github.com/vektah/gqlparser/v2 v2.5.37 h1:jbb1Ilv+xBklV6653tKb4oVUupPNTLb5LmrnBKVI12Y= +github.com/vektah/gqlparser/v2 v2.5.37/go.mod h1:9O4Ox6Ngd3Y12bMD3w6i3CRQXh8W1oC1q0m6olCymDM= github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c= github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI= github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY= @@ -275,8 +275,8 @@ golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHl golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk= -golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40= +golang.org/x/mod v0.41.0 h1:qJmnOUb4YB+FsEuM3HcWucdZASCPGhsX6uljO6pog0c= +golang.org/x/mod v0.41.0/go.mod h1:Ek9pY8RKWXwsWvd3rQiHYtMqkjSUV+s1Rj7j4H5Ur6o= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -291,8 +291,8 @@ golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= -golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= -golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= +golang.org/x/oauth2 v0.37.0 h1:JUlcxA8oAtauLfiH8FX2/FkAWHAdi0QtGCGc+hofE98= +golang.org/x/oauth2 v0.37.0/go.mod h1:IxwZNxUULJmpBFf9K/9NTMSIfZZuvuTy1gGxhigP/58= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -310,20 +310,20 @@ golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= -golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo= +golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= -golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= +golang.org/x/term v0.46.0 h1:3+OXuTbaKDgwk8jTi3aSLHRlmWqHEUDUtxnbFigO4YE= +golang.org/x/term v0.46.0/go.mod h1:+K02xbkittuwc0Am4abfA3Fc+XRGXkvBXNO88NCXPoc= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= -golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= -golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= -golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= -golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= +golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI= +golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E= +golang.org/x/time v0.16.0 h1:vMb6ptszcQMkcwiRTAuNNU50gom6++Q/6gY2hDM6VDE= +golang.org/x/time v0.16.0/go.mod h1:rVKOqvZeKvrDKTQiAHJ7wmwP0RzleSphoEA9RcdLA0s= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= @@ -333,16 +333,16 @@ golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE= -golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk= +golang.org/x/tools v0.49.0 h1:3NI7VXzL9+1WZD52Dx2ttoPwD5DWrFGpl9mFZDlmisI= +golang.org/x/tools v0.49.0/go.mod h1:SJNXV9DBKT0UbdttsQjbfJlAE/q+y36++zo3uL3N0Oo= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= -google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= +google.golang.org/api v0.297.0 h1:WktxTsnnx0yZNnsR6j0q6hR21RnnK81FHTOPy/ux4OE= +google.golang.org/api v0.297.0/go.mod h1:S4m8x0M6OkQpkOzGk1y9JG2sm4fFQrMh6dxzjCTszhE= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= diff --git a/go.work.sum b/go.work.sum index 342cd78fa8..44ba2d6fe6 100644 --- a/go.work.sum +++ b/go.work.sum @@ -1749,6 +1749,7 @@ golang.org/x/mod v0.21.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY= golang.org/x/mod v0.29.0/go.mod h1:NyhrlYXJ2H4eJiRy/WDBO6HMqZQ6q9nk4JzS3NuCK+w= golang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU= golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w= +golang.org/x/mod v0.39.0/go.mod h1:bvIbwjQ0HUFFf5AKukeeYQG4ZBUG9yxQbR9aEweIwYY= golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= @@ -1890,6 +1891,7 @@ golang.org/x/telemetry v0.0.0-20260625142307-59b4966ccb57 h1:nwGZBCt+FnXUrGsj5vj golang.org/x/telemetry v0.0.0-20260625142307-59b4966ccb57/go.mod h1:3AWMyWHS+caVoiEXpiq6+tzKA40J4vQT3MYr80ZtQpc= golang.org/x/telemetry v0.0.0-20260708182218-49f421fb7959 h1:RJhm5l6Fo4rmEIcndxDllNhhf/fAx8qIm4t6A7vpm2A= golang.org/x/telemetry v0.0.0-20260708182218-49f421fb7959/go.mod h1:LV7u5Oco+Z/g6XI7PqN+EUUUGGkEcmB1uj2ceI0fOVg= +golang.org/x/telemetry v0.0.0-20260811182544-a038080d80e5/go.mod h1:LVehoXe41cL5SCVQilsV7Gg6BNG+Js6P9PhSbYTIUkQ= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= @@ -2019,6 +2021,7 @@ google.golang.org/api v0.272.0/go.mod h1:wKjowi5LNJc5qarNvDCvNQBn3rVK8nSy6jg2SwR google.golang.org/api v0.273.1/go.mod h1:JbAt7mF+XVmWu6xNP8/+CTiGH30ofmCmk9nM8d8fHew= google.golang.org/api v0.274.0/go.mod h1:JbAt7mF+XVmWu6xNP8/+CTiGH30ofmCmk9nM8d8fHew= google.golang.org/api v0.287.1/go.mod h1:lM2kYRzYUCBY91P9h6VF1PYmvhxii3O5hji37qRvIcY= +google.golang.org/api v0.288.0/go.mod h1:lM2kYRzYUCBY91P9h6VF1PYmvhxii3O5hji37qRvIcY= google.golang.org/api v0.290.0/go.mod h1:weJZ3lldHFYI0DBFNKpJelUDNnusTt5YaOEgxvt8ci8= google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= @@ -2067,6 +2070,7 @@ google.golang.org/genproto v0.0.0-20250922171735-9219d122eba9/go.mod h1:QFOrLhdA google.golang.org/genproto v0.0.0-20251202230838-ff82c1b0f217/go.mod h1:yJ2HH4EHEDTd3JiLmhds6NkJ17ITVYOdV3m3VKOnws0= google.golang.org/genproto v0.0.0-20260217215200-42d3e9bedb6d/go.mod h1:0oz9d7g9QLSdv9/lgbIjowW1JoxMbxmBVNe8i6tORJI= google.golang.org/genproto v0.0.0-20260319201613-d00831a3d3e7/go.mod h1:L43LFes82YgSonw6iTXTxXUX1OlULt4AQtkik4ULL/I= +google.golang.org/genproto v0.0.0-20260715232425-e75dac1f907d/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= google.golang.org/genproto/googleapis/api v0.0.0-20230822172742-b8732ec3820d/go.mod h1:KjSP20unUpOx5kyQUFa7k4OJg0qeJ7DEZflGDu2p6Bk= google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142/go.mod h1:d6be+8HhtEtucleCbxpPW9PA9XwISACu8nvpPqF0BVo= google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:qpvKtACPCQhAdu3PyQgV4l3LMXZEtft7y8QcarRsp9I= @@ -2102,6 +2106,7 @@ google.golang.org/genproto/googleapis/api v0.0.0-20260414002931-afd174a4e478/go. google.golang.org/genproto/googleapis/api v0.0.0-20260511170946-3700d4141b60/go.mod h1:7yoXV7RIh5gblj/xVYoogxAWvA9wUeVbpsK/M694l00= google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa/go.mod h1:q4lMZS6kskjT5HvCPrnnypcDPVJqT/f4nfxmkE7gryY= google.golang.org/genproto/googleapis/api v0.0.0-20260630182238-925bb5da69e7/go.mod h1:KqHwBx2upmfa1XSi1WuRvC+2VGCLtooKkfmyvRbUmqA= +google.golang.org/genproto/googleapis/api v0.0.0-20260715232425-e75dac1f907d/go.mod h1:WRrQ7/7N19PypuT0fxLOL5Lq0waoiRri4FbtHDEKrGE= google.golang.org/genproto/googleapis/bytestream v0.0.0-20250929231259-57b25ae835d4/go.mod h1:YUQUKndxDbAanQC0ln4pZ3Sis3N5sqgDte2XQqufkJc= google.golang.org/genproto/googleapis/bytestream v0.0.0-20251103181224-f26f9409b101 h1:yPJt1QyhbMgVYk1uHU1fzFDusVK69zmYfO7uupO0/QE= google.golang.org/genproto/googleapis/bytestream v0.0.0-20251103181224-f26f9409b101/go.mod h1:ejCb7yLmK6GCVHp5qpeKbm4KZew/ldg+9b8kq5MONgk= @@ -2135,6 +2140,7 @@ google.golang.org/genproto/googleapis/bytestream v0.0.0-20260630182238-925bb5da6 google.golang.org/genproto/googleapis/bytestream v0.0.0-20260630182238-925bb5da69e7/go.mod h1:6TABGosqSqU2l1+fJ3jdvOYPPVryeKybxYF0cCZkTBE= google.golang.org/genproto/googleapis/bytestream v0.0.0-20260724162435-b2f20204f0df h1:TAN5A5QLM1MUvN1I9X+yRFsuoHNPUoDem77KCZas9HM= google.golang.org/genproto/googleapis/bytestream v0.0.0-20260724162435-b2f20204f0df/go.mod h1:zpqRtTwVou7odpidkkHm+GTCum9L4nuS3SvU5rrEeik= +google.golang.org/genproto/googleapis/bytestream v0.0.0-20260819154853-08b0e4226688/go.mod h1:832FQwEl9OKXy5rHqEY2U7uF7Bg+Hs7Zo72IIq+dYZ4= google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237/go.mod h1:WtryC6hu0hhx87FDGxWCDptyssuo68sk10vYjF+T9fY= google.golang.org/genproto/googleapis/rpc v0.0.0-20240826202546-f6391c0de4c7/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= @@ -2177,8 +2183,10 @@ google.golang.org/genproto/googleapis/rpc v0.0.0-20260523011958-0a33c5d7ca68/go. google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/genproto/googleapis/rpc v0.0.0-20260610212136-7ab31c22f7ad/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/genproto/googleapis/rpc v0.0.0-20260630182238-925bb5da69e7/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260715232425-e75dac1f907d/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/genproto/googleapis/rpc v0.0.0-20260720155508-bb71a54f79dc/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/genproto/googleapis/rpc v0.0.0-20260723164925-7274b71286bd/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260819154853-08b0e4226688/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= diff --git a/pkg/gofr/datasource/arangodb/go.mod b/pkg/gofr/datasource/arangodb/go.mod index 8b75889cea..380f4eb2bd 100644 --- a/pkg/gofr/datasource/arangodb/go.mod +++ b/pkg/gofr/datasource/arangodb/go.mod @@ -5,8 +5,8 @@ go 1.26.0 require ( github.com/arangodb/go-driver/v2 v2.3.1 github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 ) @@ -23,7 +23,7 @@ require ( github.com/pkg/errors v0.9.1 // indirect github.com/rs/zerolog v1.34.0 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/net v0.58.0 // indirect golang.org/x/sys v0.47.0 // indirect diff --git a/pkg/gofr/datasource/arangodb/go.sum b/pkg/gofr/datasource/arangodb/go.sum index 22b28c7331..ff78598961 100644 --- a/pkg/gofr/datasource/arangodb/go.sum +++ b/pkg/gofr/datasource/arangodb/go.sum @@ -39,12 +39,12 @@ github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWD github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= diff --git a/pkg/gofr/datasource/cassandra/go.mod b/pkg/gofr/datasource/cassandra/go.mod index 15257f8d1a..842d9e8f5b 100644 --- a/pkg/gofr/datasource/cassandra/go.mod +++ b/pkg/gofr/datasource/cassandra/go.mod @@ -5,8 +5,8 @@ go 1.26.0 require ( github.com/gocql/gocql v1.7.0 github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 ) @@ -17,7 +17,7 @@ require ( github.com/golang/snappy v1.0.0 // indirect github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect gopkg.in/inf.v0 v0.9.1 // indirect ) diff --git a/pkg/gofr/datasource/cassandra/go.sum b/pkg/gofr/datasource/cassandra/go.sum index fbaf766d1b..ab3632a72b 100644 --- a/pkg/gofr/datasource/cassandra/go.sum +++ b/pkg/gofr/datasource/cassandra/go.sum @@ -23,9 +23,8 @@ github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORN github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= @@ -35,12 +34,12 @@ github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWD github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= diff --git a/pkg/gofr/datasource/clickhouse/go.mod b/pkg/gofr/datasource/clickhouse/go.mod index a07ba1d3dc..e838797649 100644 --- a/pkg/gofr/datasource/clickhouse/go.mod +++ b/pkg/gofr/datasource/clickhouse/go.mod @@ -5,8 +5,8 @@ go 1.26.0 require ( github.com/ClickHouse/clickhouse-go/v2 v2.48.0 github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 ) diff --git a/pkg/gofr/datasource/clickhouse/go.sum b/pkg/gofr/datasource/clickhouse/go.sum index 2d1e00cee5..75a2460872 100644 --- a/pkg/gofr/datasource/clickhouse/go.sum +++ b/pkg/gofr/datasource/clickhouse/go.sum @@ -28,10 +28,10 @@ github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWD github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU= github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= diff --git a/pkg/gofr/datasource/cloudsql/go.mod b/pkg/gofr/datasource/cloudsql/go.mod index 8b223e0a6a..404bd73520 100644 --- a/pkg/gofr/datasource/cloudsql/go.mod +++ b/pkg/gofr/datasource/cloudsql/go.mod @@ -5,7 +5,7 @@ go 1.26.0 require ( cloud.google.com/go/cloudsqlconn v1.25.1 github.com/go-sql-driver/mysql v1.10.0 - github.com/jackc/pgx/v5 v5.10.0 + github.com/jackc/pgx/v5 v5.11.0 github.com/stretchr/testify v1.12.1 ) diff --git a/pkg/gofr/datasource/cloudsql/go.sum b/pkg/gofr/datasource/cloudsql/go.sum index 990fbc6934..c556d7bf1d 100644 --- a/pkg/gofr/datasource/cloudsql/go.sum +++ b/pkg/gofr/datasource/cloudsql/go.sum @@ -80,8 +80,8 @@ github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsI github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= -github.com/jackc/pgx/v5 v5.10.0 h1:VhSvgU2jSli8o3AqIEOTJr7rZwAEUVo4E4XhR94Zfr0= -github.com/jackc/pgx/v5 v5.10.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= +github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg= +github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= github.com/microsoft/go-mssqldb v1.10.0 h1:pHEt+Qz6YFPWqREq10mqSE524QQo+/QremwTCQht7TY= diff --git a/pkg/gofr/datasource/couchbase/go.mod b/pkg/gofr/datasource/couchbase/go.mod index ba486e63b7..85ea4f2d01 100644 --- a/pkg/gofr/datasource/couchbase/go.mod +++ b/pkg/gofr/datasource/couchbase/go.mod @@ -5,8 +5,8 @@ go 1.26.0 require ( github.com/couchbase/gocb/v2 v2.12.4 github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 ) @@ -23,7 +23,7 @@ require ( github.com/gorilla/websocket v1.5.3 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.opentelemetry.io/otel/sdk v1.45.0 // indirect go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect go.uber.org/multierr v1.11.0 // indirect diff --git a/pkg/gofr/datasource/couchbase/go.sum b/pkg/gofr/datasource/couchbase/go.sum index 342a7b22a8..ffaba2ac99 100644 --- a/pkg/gofr/datasource/couchbase/go.sum +++ b/pkg/gofr/datasource/couchbase/go.sum @@ -35,16 +35,16 @@ go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0 h1:0Qx7VGBacMm9ZENQ7TnNObTYI4ShC+lHI16seduaxZo= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.68.0/go.mod h1:Sje3i3MjSPKTSPvVWCaL8ugBzJwik3u4smCjUeuupqg= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= diff --git a/pkg/gofr/datasource/dbresolver/go.mod b/pkg/gofr/datasource/dbresolver/go.mod index e658cccbc6..257639fd5d 100644 --- a/pkg/gofr/datasource/dbresolver/go.mod +++ b/pkg/gofr/datasource/dbresolver/go.mod @@ -4,8 +4,8 @@ go 1.26.0 require ( github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 ) @@ -75,7 +75,7 @@ require ( go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 // indirect go.opentelemetry.io/otel/exporters/prometheus v0.67.0 // indirect go.opentelemetry.io/otel/exporters/zipkin v1.44.0 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.opentelemetry.io/otel/sdk v1.45.0 // indirect go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect go.opentelemetry.io/proto/otlp v1.10.0 // indirect diff --git a/pkg/gofr/datasource/dbresolver/go.sum b/pkg/gofr/datasource/dbresolver/go.sum index 5ab0cad076..7d3fa422c2 100644 --- a/pkg/gofr/datasource/dbresolver/go.sum +++ b/pkg/gofr/datasource/dbresolver/go.sum @@ -218,8 +218,8 @@ go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0. go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0/go.mod h1:kmJlX6WuTrAH1fOCSbPJFrSnUagB8c3SY3E87It3JD8= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 h1:LMuyCAyfalSjDyjdC65nK6N0zoTT63+E/u95X0JovZI= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0/go.mod h1:085m8qbm4hgc8rZWGDEa4vmyyo2c3nPxUslYUKUIU04= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0 h1:4YsVu3B8+3qtWYYrsUYgn0OG78pN0rnNPRGX4SbokQI= go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0/go.mod h1:+wnlSn0mD1ADVMe3v9Z/WIaiz6q6gL2J/ejaAmdmv80= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0 h1:qazEJlUOQzhCpzQpFETGby7EdqjI1wsd0W+6Gg1SCTU= @@ -228,16 +228,16 @@ go.opentelemetry.io/otel/exporters/prometheus v0.67.0 h1:7IefDa35e6V3NoiqIeLDMDx go.opentelemetry.io/otel/exporters/prometheus v0.67.0/go.mod h1:nsPI1awTg5Vmg1YrommL2mVarVGlqc4yXOoKAkPRD0c= go.opentelemetry.io/otel/exporters/zipkin v1.44.0 h1:zv7PRYGLrQHkdeZj0c5SNAZOJcw55XgaTezUkNpwA+w= go.opentelemetry.io/otel/exporters/zipkin v1.44.0/go.mod h1:3+VZyCi6hFW+UuxFF+wSOvwsOwncfBpQfP7Qdb3JXKg= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= go.opentelemetry.io/otel/metric/x v0.67.0 h1:PcicCNZFkZ4bXfSooXdo3WN7RBOVOtjVdo1wD358Uns= go.opentelemetry.io/otel/metric/x v0.67.0/go.mod h1:FBjCWZe6wgcqxcMtjdGiClDKXb2YxxXii0CXftE4QtI= go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.opentelemetry.io/proto/otlp v1.10.0 h1:IQRWgT5srOCYfiWnpqUYz9CVmbO8bFmKcwYxpuCSL2g= go.opentelemetry.io/proto/otlp v1.10.0/go.mod h1:/CV4QoCR/S9yaPj8utp3lvQPoqMtxXdzn7ozvvozVqk= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= diff --git a/pkg/gofr/datasource/dgraph/go.mod b/pkg/gofr/datasource/dgraph/go.mod index a083388be3..f5d2381291 100644 --- a/pkg/gofr/datasource/dgraph/go.mod +++ b/pkg/gofr/datasource/dgraph/go.mod @@ -6,8 +6,8 @@ require ( github.com/dgraph-io/dgo/v210 v210.0.0-20230328113526-b66f8ae53a2d github.com/prometheus/client_golang v1.24.1 github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 google.golang.org/grpc v1.83.2 ) @@ -24,7 +24,7 @@ require ( github.com/prometheus/common v0.70.1 // indirect github.com/prometheus/procfs v0.21.1 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/net v0.58.0 // indirect diff --git a/pkg/gofr/datasource/dgraph/go.sum b/pkg/gofr/datasource/dgraph/go.sum index d698155294..4c947952e2 100644 --- a/pkg/gofr/datasource/dgraph/go.sum +++ b/pkg/gofr/datasource/dgraph/go.sum @@ -37,16 +37,16 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= diff --git a/pkg/gofr/datasource/elasticsearch/go.mod b/pkg/gofr/datasource/elasticsearch/go.mod index 8a721f25ba..3e0801607e 100644 --- a/pkg/gofr/datasource/elasticsearch/go.mod +++ b/pkg/gofr/datasource/elasticsearch/go.mod @@ -5,8 +5,8 @@ go 1.26.0 require ( github.com/elastic/go-elasticsearch/v8 v8.19.7 github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 ) @@ -16,7 +16,7 @@ require ( github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.opentelemetry.io/otel/sdk v1.45.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect ) diff --git a/pkg/gofr/datasource/elasticsearch/go.sum b/pkg/gofr/datasource/elasticsearch/go.sum index 17fdd3c076..89c69b7e73 100644 --- a/pkg/gofr/datasource/elasticsearch/go.sum +++ b/pkg/gofr/datasource/elasticsearch/go.sum @@ -17,14 +17,14 @@ github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWD github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= diff --git a/pkg/gofr/datasource/file/gcs/go.mod b/pkg/gofr/datasource/file/gcs/go.mod index 572634c64a..01185d7bb1 100644 --- a/pkg/gofr/datasource/file/gcs/go.mod +++ b/pkg/gofr/datasource/file/gcs/go.mod @@ -7,14 +7,14 @@ require ( github.com/stretchr/testify v1.12.1 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 - golang.org/x/oauth2 v0.36.0 - google.golang.org/api v0.291.0 + golang.org/x/oauth2 v0.37.0 + google.golang.org/api v0.297.0 ) require ( cel.dev/expr v0.25.2 // indirect cloud.google.com/go v0.123.0 // indirect - cloud.google.com/go/auth v0.22.0 // indirect + cloud.google.com/go/auth v0.23.2 // indirect cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect cloud.google.com/go/compute/metadata v0.9.0 // indirect cloud.google.com/go/iam v1.12.0 // indirect @@ -32,8 +32,8 @@ require ( github.com/go-logr/stdr v1.2.2 // indirect github.com/google/s2a-go v0.1.9 // indirect github.com/google/uuid v1.6.0 // indirect - github.com/googleapis/enterprise-certificate-proxy v0.3.19 // indirect - github.com/googleapis/gax-go/v2 v2.23.0 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.20 // indirect + github.com/googleapis/gax-go/v2 v2.24.0 // indirect github.com/joho/godotenv v1.5.1 // indirect github.com/pkg/errors v0.9.1 // indirect github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect diff --git a/pkg/gofr/datasource/file/gcs/go.sum b/pkg/gofr/datasource/file/gcs/go.sum index b8fcbce290..30876bb780 100644 --- a/pkg/gofr/datasource/file/gcs/go.sum +++ b/pkg/gofr/datasource/file/gcs/go.sum @@ -2,8 +2,8 @@ cel.dev/expr v0.25.2 h1:K6j46C81hXtZQfuX60cVWQFBJahKSE2gfRbNuvr5bFs= cel.dev/expr v0.25.2/go.mod h1:hrXvqGP6G6gyx8UAHSHJ5RGk//1Oj5nXQ2NI02Nrsg4= cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE= cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU= -cloud.google.com/go/auth v0.22.0 h1:Xp9wAKkLoeaYb5pYZZoQGz4E9sdPxIbzS3gywZE3ciQ= -cloud.google.com/go/auth v0.22.0/go.mod h1:M9o2Oz+YI2jAfxewJgb1vyI3vceHF+eohmxyzmrl+9s= +cloud.google.com/go/auth v0.23.2 h1:pxSCpfiji41hpzpPdMCftEUCezpgpqmmDdYiAjCKXxo= +cloud.google.com/go/auth v0.23.2/go.mod h1:4DhBRcqvtljQN3dJ57qtqbib5ZGCYE5f2crfiiC2EM0= cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc= cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= @@ -59,10 +59,10 @@ github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0= github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/enterprise-certificate-proxy v0.3.19 h1:mMOE7DN2+p76/EdIrmAy9B9bH+yC4563vmnJ34QR8i4= -github.com/googleapis/enterprise-certificate-proxy v0.3.19/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= -github.com/googleapis/gax-go/v2 v2.23.0 h1:Tchl7qkvE7Ip3y+ztvNufYFvkfqTe7NfLTYGIdJRLuE= -github.com/googleapis/gax-go/v2 v2.23.0/go.mod h1:rBQKOVJCdb8IFEzg+FCwlt1LP/xMDGuqUXhUG+XMXEg= +github.com/googleapis/enterprise-certificate-proxy v0.3.20 h1:t/xL64VUoN69MuMRQuJETqYGOw4Z9mSRJK9epIEtwFk= +github.com/googleapis/enterprise-certificate-proxy v0.3.20/go.mod h1:L3D/IQExI6LqEjBdXcZQ1WluSgigQmSwBboFstVPM4w= +github.com/googleapis/gax-go/v2 v2.24.0 h1:myMaPYyF9MecEmvQqMqomIwn9t/4KCZN9qnwsS76wlg= +github.com/googleapis/gax-go/v2 v2.24.0/go.mod h1:IaTHBDd7NHxSCiu0vEs8pQZu4dGZrWwuSoxCnk16OFM= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= @@ -105,8 +105,8 @@ golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= -golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= -golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= +golang.org/x/oauth2 v0.37.0 h1:JUlcxA8oAtauLfiH8FX2/FkAWHAdi0QtGCGc+hofE98= +golang.org/x/oauth2 v0.37.0/go.mod h1:IxwZNxUULJmpBFf9K/9NTMSIfZZuvuTy1gGxhigP/58= golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek= golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= @@ -119,8 +119,8 @@ golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/api v0.291.0 h1:wfPbbY+mr9c7wZLqqzrHJLft/q8iFKREd6IgTBUene0= -google.golang.org/api v0.291.0/go.mod h1:at7kwWbuonglBFEBoeMDAV1bguHqL3qf0BHFsv3coa0= +google.golang.org/api v0.297.0 h1:WktxTsnnx0yZNnsR6j0q6hR21RnnK81FHTOPy/ux4OE= +google.golang.org/api v0.297.0/go.mod h1:S4m8x0M6OkQpkOzGk1y9JG2sm4fFQrMh6dxzjCTszhE= google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd h1:0GnSESHqea5EoaQgJyYxC3o5m0L191gCQdDgo2cxO5I= google.golang.org/genproto v0.0.0-20260723164925-7274b71286bd/go.mod h1:Wz2wFJntZFmLGo7pLDXZ3wYk5hyc0Mb+SkHhDDXT+lU= google.golang.org/genproto/googleapis/api v0.0.0-20260723164925-7274b71286bd h1:k+Z6yS8OmX4IJpSXEjeT0nqv6efIFFaa5DfDVeqy16A= diff --git a/pkg/gofr/datasource/kv-store/badger/go.mod b/pkg/gofr/datasource/kv-store/badger/go.mod index b2e01cf242..b7498d93e0 100644 --- a/pkg/gofr/datasource/kv-store/badger/go.mod +++ b/pkg/gofr/datasource/kv-store/badger/go.mod @@ -5,8 +5,8 @@ go 1.26.0 require ( github.com/dgraph-io/badger/v4 v4.9.4 github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 ) @@ -19,7 +19,7 @@ require ( github.com/google/flatbuffers v25.2.10+incompatible // indirect github.com/klauspost/compress v1.19.2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/sys v0.47.0 // indirect google.golang.org/protobuf v1.36.12 // indirect diff --git a/pkg/gofr/datasource/kv-store/badger/go.sum b/pkg/gofr/datasource/kv-store/badger/go.sum index f495cab75e..8c651b049c 100644 --- a/pkg/gofr/datasource/kv-store/badger/go.sum +++ b/pkg/gofr/datasource/kv-store/badger/go.sum @@ -23,12 +23,12 @@ github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWD github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= diff --git a/pkg/gofr/datasource/kv-store/dynamodb/go.mod b/pkg/gofr/datasource/kv-store/dynamodb/go.mod index 4ffb32a859..6e91af6068 100644 --- a/pkg/gofr/datasource/kv-store/dynamodb/go.mod +++ b/pkg/gofr/datasource/kv-store/dynamodb/go.mod @@ -7,8 +7,8 @@ require ( github.com/aws/aws-sdk-go-v2/config v1.33.3 github.com/aws/aws-sdk-go-v2/service/dynamodb v1.67.0 github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 ) diff --git a/pkg/gofr/datasource/kv-store/dynamodb/go.sum b/pkg/gofr/datasource/kv-store/dynamodb/go.sum index 8cd0eda93d..b497193e9d 100644 --- a/pkg/gofr/datasource/kv-store/dynamodb/go.sum +++ b/pkg/gofr/datasource/kv-store/dynamodb/go.sum @@ -36,10 +36,10 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= diff --git a/pkg/gofr/datasource/kv-store/nats/go.mod b/pkg/gofr/datasource/kv-store/nats/go.mod index 9cdfbc21b1..72d66925b5 100644 --- a/pkg/gofr/datasource/kv-store/nats/go.mod +++ b/pkg/gofr/datasource/kv-store/nats/go.mod @@ -5,8 +5,8 @@ go 1.26.0 require ( github.com/nats-io/nats.go v1.53.1 github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 ) diff --git a/pkg/gofr/datasource/kv-store/nats/go.sum b/pkg/gofr/datasource/kv-store/nats/go.sum index 9641c9e01b..ecd90e7bbe 100644 --- a/pkg/gofr/datasource/kv-store/nats/go.sum +++ b/pkg/gofr/datasource/kv-store/nats/go.sum @@ -12,10 +12,10 @@ github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw= github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= diff --git a/pkg/gofr/datasource/mongo/go.mod b/pkg/gofr/datasource/mongo/go.mod index 1865219900..c0b1717c31 100644 --- a/pkg/gofr/datasource/mongo/go.mod +++ b/pkg/gofr/datasource/mongo/go.mod @@ -5,8 +5,8 @@ go 1.26.0 require ( github.com/stretchr/testify v1.12.1 go.mongodb.org/mongo-driver v1.17.9 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 ) @@ -23,7 +23,7 @@ require ( github.com/xdg-go/stringprep v1.0.4 // indirect github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/crypto v0.55.0 // indirect golang.org/x/sync v0.22.0 // indirect diff --git a/pkg/gofr/datasource/mongo/go.sum b/pkg/gofr/datasource/mongo/go.sum index 352311ba97..09d2f49c92 100644 --- a/pkg/gofr/datasource/mongo/go.sum +++ b/pkg/gofr/datasource/mongo/go.sum @@ -30,12 +30,12 @@ go.mongodb.org/mongo-driver v1.17.9 h1:IexDdCuuNJ3BHrELgBlyaH9p60JXAvdzWR128q+U5 go.mongodb.org/mongo-driver v1.17.9/go.mod h1:LlOhpH5NUEfhxcAwG0UEkMqwYcc4JU18gtCdGudk/tQ= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= diff --git a/pkg/gofr/datasource/opentsdb/go.mod b/pkg/gofr/datasource/opentsdb/go.mod index da862713d8..1dba9d9302 100644 --- a/pkg/gofr/datasource/opentsdb/go.mod +++ b/pkg/gofr/datasource/opentsdb/go.mod @@ -4,8 +4,8 @@ go 1.26.0 require ( github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 ) @@ -14,6 +14,6 @@ require ( github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect ) diff --git a/pkg/gofr/datasource/opentsdb/go.sum b/pkg/gofr/datasource/opentsdb/go.sum index 3622e32887..3e7149f217 100644 --- a/pkg/gofr/datasource/opentsdb/go.sum +++ b/pkg/gofr/datasource/opentsdb/go.sum @@ -11,12 +11,12 @@ github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWD github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= diff --git a/pkg/gofr/datasource/oracle/go.mod b/pkg/gofr/datasource/oracle/go.mod index f8317a9bdd..8f62b3dd0b 100644 --- a/pkg/gofr/datasource/oracle/go.mod +++ b/pkg/gofr/datasource/oracle/go.mod @@ -6,8 +6,8 @@ require ( github.com/DATA-DOG/go-sqlmock v1.5.2 github.com/godror/godror v0.51.4 github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 ) @@ -67,7 +67,7 @@ require ( go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 // indirect go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 // indirect go.opentelemetry.io/otel/exporters/prometheus v0.67.0 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.opentelemetry.io/otel/sdk v1.45.0 // indirect go.opentelemetry.io/otel/sdk/metric v1.45.0 // indirect go.uber.org/atomic v1.11.0 // indirect diff --git a/pkg/gofr/datasource/oracle/go.sum b/pkg/gofr/datasource/oracle/go.sum index 6cd0401e89..fa95b4ae51 100644 --- a/pkg/gofr/datasource/oracle/go.sum +++ b/pkg/gofr/datasource/oracle/go.sum @@ -198,20 +198,20 @@ go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0. go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0/go.mod h1:kmJlX6WuTrAH1fOCSbPJFrSnUagB8c3SY3E87It3JD8= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 h1:LMuyCAyfalSjDyjdC65nK6N0zoTT63+E/u95X0JovZI= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0/go.mod h1:085m8qbm4hgc8rZWGDEa4vmyyo2c3nPxUslYUKUIU04= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= go.opentelemetry.io/otel/exporters/prometheus v0.67.0 h1:7IefDa35e6V3NoiqIeLDMDxMFyZDk5qcoC0Ax4cC16E= go.opentelemetry.io/otel/exporters/prometheus v0.67.0/go.mod h1:nsPI1awTg5Vmg1YrommL2mVarVGlqc4yXOoKAkPRD0c= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= go.opentelemetry.io/otel/metric/x v0.67.0 h1:PcicCNZFkZ4bXfSooXdo3WN7RBOVOtjVdo1wD358Uns= go.opentelemetry.io/otel/metric/x v0.67.0/go.mod h1:FBjCWZe6wgcqxcMtjdGiClDKXb2YxxXii0CXftE4QtI= go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= diff --git a/pkg/gofr/datasource/pubsub/eventhub/go.mod b/pkg/gofr/datasource/pubsub/eventhub/go.mod index 06777e9fd2..66d63711d5 100644 --- a/pkg/gofr/datasource/pubsub/eventhub/go.mod +++ b/pkg/gofr/datasource/pubsub/eventhub/go.mod @@ -8,8 +8,8 @@ require ( github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.8.0 github.com/coder/websocket v1.8.15 github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 gofr.dev v1.57.0 ) @@ -24,7 +24,7 @@ require ( github.com/joho/godotenv v1.5.1 // indirect github.com/pkg/errors v0.9.1 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/net v0.58.0 // indirect golang.org/x/text v0.41.0 // indirect diff --git a/pkg/gofr/datasource/pubsub/eventhub/go.sum b/pkg/gofr/datasource/pubsub/eventhub/go.sum index bb43dd52d6..bbc67a3555 100644 --- a/pkg/gofr/datasource/pubsub/eventhub/go.sum +++ b/pkg/gofr/datasource/pubsub/eventhub/go.sum @@ -48,12 +48,12 @@ github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUm github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= diff --git a/pkg/gofr/datasource/pubsub/sqs/go.mod b/pkg/gofr/datasource/pubsub/sqs/go.mod index 8e2e71b070..bb27b61510 100644 --- a/pkg/gofr/datasource/pubsub/sqs/go.mod +++ b/pkg/gofr/datasource/pubsub/sqs/go.mod @@ -3,10 +3,10 @@ module gofr.dev/pkg/gofr/datasource/pubsub/sqs go 1.26.0 require ( - github.com/aws/aws-sdk-go-v2 v1.46.0 + github.com/aws/aws-sdk-go-v2 v1.47.0 github.com/aws/aws-sdk-go-v2/config v1.33.3 github.com/aws/aws-sdk-go-v2/credentials v1.20.3 - github.com/aws/aws-sdk-go-v2/service/sqs v1.51.0 + github.com/aws/aws-sdk-go-v2/service/sqs v1.52.0 github.com/stretchr/testify v1.12.1 go.opentelemetry.io/otel v1.46.0 go.opentelemetry.io/otel/sdk v1.46.0 @@ -16,8 +16,8 @@ require ( require ( github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2 // indirect - github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2 // indirect - github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.3 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.3 // indirect github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2 // indirect github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 // indirect github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2 // indirect diff --git a/pkg/gofr/datasource/pubsub/sqs/go.sum b/pkg/gofr/datasource/pubsub/sqs/go.sum index 8ab0bea686..cb2a7fe8d7 100644 --- a/pkg/gofr/datasource/pubsub/sqs/go.sum +++ b/pkg/gofr/datasource/pubsub/sqs/go.sum @@ -1,15 +1,15 @@ -github.com/aws/aws-sdk-go-v2 v1.46.0 h1:1kt7m/EKcEHt5mlyyxx9cSlMddRPIKbjb6DIQsu4HPk= -github.com/aws/aws-sdk-go-v2 v1.46.0/go.mod h1:bttEH6JqnUL8LepvDVfdrds/fZ5bCIxzpe3abyUrhDU= +github.com/aws/aws-sdk-go-v2 v1.47.0 h1:0jsHallhJCeaU0Ko48c/3FK1ctOQ7NpzggxriJOQ8MQ= +github.com/aws/aws-sdk-go-v2 v1.47.0/go.mod h1:bttEH6JqnUL8LepvDVfdrds/fZ5bCIxzpe3abyUrhDU= github.com/aws/aws-sdk-go-v2/config v1.33.3 h1:h090b3O5S17bF87/0ysHZuIT/7DCb4EBRFQX2PMVPCw= github.com/aws/aws-sdk-go-v2/config v1.33.3/go.mod h1:YYDB1kTejxbfAbEVUqgCtkVp26xvNCHev9cLKABMGAk= github.com/aws/aws-sdk-go-v2/credentials v1.20.3 h1:tToOYM/LXev4NpfWlIYGDvBvjHmJ3HXpRU9ppl+pM6k= github.com/aws/aws-sdk-go-v2/credentials v1.20.3/go.mod h1:wfGneWyncO7p67wqXV2IQhPk14JqIc25woKlaArT3WI= github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2 h1:Ldv7RPHs7qwwTscRjAl3YBud32f3BvdAGRmSvAx5L38= github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.2/go.mod h1:XyK6UV8xbo66ysVqLd2783C09pBYHOm8aKTRV5DVJ30= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2 h1:q/PSLGuRWCChWg+dLnb9dWOnrCxJtnboXbBtFoqqRrI= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.2/go.mod h1:TD1jvU2LvXkJexct5vBqcd8QlNXh5EmRUeL/Z32p0n4= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2 h1:6fl86IPqKEXoySqiOWdfgbEp9OVbn44zTfEICNEBDhY= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.2/go.mod h1:63HDfhFkdzBpI8WGXTSKUHPKS6mqldj4u3LJW7RZtSU= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.3 h1:Hp/VgjP0BysR3OgLlR057Vz2LcbbVnoWeJ+3qWiS/fY= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.3/go.mod h1:nwGV5qw7F1IZPgxCvA/ph8N2TAuz+BkRG/bXn808qMA= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.3 h1:MUaM4f+kj1ZIBPZfUS8cxP1GKXXZtHJjAthy93AN7SM= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.3/go.mod h1:6YmVmEVRI5ZZzRjCSsb9SryKH0hAlMRdgA7kG9aDvBU= github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2 h1:XMgIRS+uW9F3yFKnXGRrI9pkHi99CXTmoz2kz2/TGBA= github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.2/go.mod h1:vorxDzK+n3jiv9a5ST/LG0Eu9cSv1CRdKTpG6pDMs+M= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 h1:bAdDl/HkGCcGPoe25ToSHEw23VIxt6CT5fLcg111BKg= @@ -18,8 +18,8 @@ github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2 h1:ZtHYnumr6 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.2/go.mod h1:a1NXrYpBd311gBzn1UI5UzJyyvXktM4xNh/ydPiPpqY= github.com/aws/aws-sdk-go-v2/service/signin v1.9.0 h1:c3k+k/CS4L+sAIH6fxikL+g5g2LpeNczaoyjjw1iMKI= github.com/aws/aws-sdk-go-v2/service/signin v1.9.0/go.mod h1:AGIoQg99fBrOIQnF78TLx4lj18mc4gZ0hJx1UaLIFM4= -github.com/aws/aws-sdk-go-v2/service/sqs v1.51.0 h1:FghdY9ebeZf9iIan9J0xfBEID8arYibNBeZ1XHvs4oA= -github.com/aws/aws-sdk-go-v2/service/sqs v1.51.0/go.mod h1:wu7uOJ/2nAdenjvhHikeF6j0al99kfPVG6ZDU4e76OY= +github.com/aws/aws-sdk-go-v2/service/sqs v1.52.0 h1:39EpbrAPFSOPYc9FVr2ki84cLB/9C5nC03aL7ope2rU= +github.com/aws/aws-sdk-go-v2/service/sqs v1.52.0/go.mod h1:yErwLsJkArgQLSGWtLjjwlpvlLK4+c9h0jDZZVN02hw= github.com/aws/aws-sdk-go-v2/service/sso v1.37.0 h1:+rqBaOq7jzInjY8M12hr+zEe85JpRll9BjMx38r33Ok= github.com/aws/aws-sdk-go-v2/service/sso v1.37.0/go.mod h1:XFlVwUsw3sYh8Hw37umYVJnrcWrwXWRxbNw/JY0bblw= github.com/aws/aws-sdk-go-v2/service/ssooidc v1.42.0 h1:hzM3GslEAOBcLn3DHH6ENToFi+vXP+n02W+x6zejAIM= diff --git a/pkg/gofr/datasource/scylladb/go.mod b/pkg/gofr/datasource/scylladb/go.mod index 01cd783842..a4072bf4fa 100644 --- a/pkg/gofr/datasource/scylladb/go.mod +++ b/pkg/gofr/datasource/scylladb/go.mod @@ -6,8 +6,8 @@ require ( github.com/gocql/gocql v1.7.0 github.com/stoewer/go-strcase v1.3.1 github.com/stretchr/testify v1.12.1 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 ) diff --git a/pkg/gofr/datasource/scylladb/go.sum b/pkg/gofr/datasource/scylladb/go.sum index 8f2b9c4e8f..022e2f1382 100644 --- a/pkg/gofr/datasource/scylladb/go.sum +++ b/pkg/gofr/datasource/scylladb/go.sum @@ -39,10 +39,10 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= diff --git a/pkg/gofr/datasource/solr/go.mod b/pkg/gofr/datasource/solr/go.mod index 8b4a084d0d..d3a97a7f48 100644 --- a/pkg/gofr/datasource/solr/go.mod +++ b/pkg/gofr/datasource/solr/go.mod @@ -5,8 +5,8 @@ go 1.26.0 require ( github.com/stretchr/testify v1.12.1 go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 ) @@ -15,6 +15,6 @@ require ( github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect ) diff --git a/pkg/gofr/datasource/solr/go.sum b/pkg/gofr/datasource/solr/go.sum index 306244c0a1..95713bfdbb 100644 --- a/pkg/gofr/datasource/solr/go.sum +++ b/pkg/gofr/datasource/solr/go.sum @@ -19,16 +19,16 @@ go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0. go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.70.0/go.mod h1:kmJlX6WuTrAH1fOCSbPJFrSnUagB8c3SY3E87It3JD8= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 h1:LMuyCAyfalSjDyjdC65nK6N0zoTT63+E/u95X0JovZI= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0/go.mod h1:085m8qbm4hgc8rZWGDEa4vmyyo2c3nPxUslYUKUIU04= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= go.opentelemetry.io/otel/sdk v1.45.0 h1:4VVSMgQ83dUgW2aoX5f6JgLvHwIvzcuLnF9lUdCSpCw= go.opentelemetry.io/otel/sdk v1.45.0/go.mod h1:Sr40LgXV7DsKMMJMKOhUWOgMWTfAaqvm2kF0g7ilwuA= go.opentelemetry.io/otel/sdk/metric v1.45.0 h1:oVFszMfyj1Am6s24Vtc7wBb8BKLcwepJjNEYILuiE3o= go.opentelemetry.io/otel/sdk/metric v1.45.0/go.mod h1:vUWUxDZvu1WVRj8JA8S0AdhsPrZoDpA2DdZauIh4mDA= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= diff --git a/pkg/gofr/datasource/surrealdb/go.mod b/pkg/gofr/datasource/surrealdb/go.mod index 41d4209576..5810cbf675 100644 --- a/pkg/gofr/datasource/surrealdb/go.mod +++ b/pkg/gofr/datasource/surrealdb/go.mod @@ -4,9 +4,9 @@ go 1.26.0 require ( github.com/stretchr/testify v1.12.1 - github.com/surrealdb/surrealdb.go v1.6.0 - go.opentelemetry.io/otel v1.45.0 - go.opentelemetry.io/otel/trace v1.45.0 + github.com/surrealdb/surrealdb.go v1.7.0 + go.opentelemetry.io/otel v1.46.0 + go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/mock v0.6.0 ) @@ -21,6 +21,6 @@ require ( github.com/klauspost/compress v1.19.2 // indirect github.com/x448/float16 v0.8.4 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect - go.opentelemetry.io/otel/metric v1.45.0 // indirect + go.opentelemetry.io/otel/metric v1.46.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect ) diff --git a/pkg/gofr/datasource/surrealdb/go.sum b/pkg/gofr/datasource/surrealdb/go.sum index 1c10dc0a68..0f1915bbbd 100644 --- a/pkg/gofr/datasource/surrealdb/go.sum +++ b/pkg/gofr/datasource/surrealdb/go.sum @@ -23,18 +23,18 @@ github.com/lxzan/gws v1.8.9 h1:VU3SGUeWlQrEwfUSfokcZep8mdg/BrUF+y73YYshdBM= github.com/lxzan/gws v1.8.9/go.mod h1:d9yHaR1eDTBHagQC6KY7ycUOaz5KWeqQtP3xu7aMK8Y= github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= -github.com/surrealdb/surrealdb.go v1.6.0 h1:x88b/W0gDQN7FAtHRsBTEcHLr8UBKNV0uo2MjNKR52s= -github.com/surrealdb/surrealdb.go v1.6.0/go.mod h1:mKSZxow8ZN2tkR2p/fWzjIbinRFXWOGCOpfIdiYYZzc= +github.com/surrealdb/surrealdb.go v1.7.0 h1:PsWVKpIxSv4i/H49lx4aE4h8+8zxMqhnS8R//ks3AMY= +github.com/surrealdb/surrealdb.go v1.7.0/go.mod h1:mKSZxow8ZN2tkR2p/fWzjIbinRFXWOGCOpfIdiYYZzc= github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM= github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.45.0 h1:pdrWmLHofpubmArBv1LgFSv1Z0Ie/ppdZzu+kUN5EeU= -go.opentelemetry.io/otel v1.45.0/go.mod h1:XZxIqPapzEYnhNSScF5DIqXhm/rYi0FzCe2XddAwZfQ= -go.opentelemetry.io/otel/metric v1.45.0 h1:7Eg1uH7CJ5cXv9is6tnBe1FI6rj1nwUdbFypRm3br/M= -go.opentelemetry.io/otel/metric v1.45.0/go.mod h1:HAPbm1nd3p1PmFH7v2dR+6BjXxw+Lq4a2+pndMAm08s= -go.opentelemetry.io/otel/trace v1.45.0 h1:l/mP6Uv7oNO7/TblbhpbgMidxhq1uO/rPsikOyVhxag= -go.opentelemetry.io/otel/trace v1.45.0/go.mod h1:qoJJA2xNMnxRrdISU/kLtfUH2wNeQbiv+jhs/CxI8bc= +go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc= +go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE= +go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8= +go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o= +go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c= +go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= diff --git a/pkg/gofr/metrics/exporters/gcp/go.mod b/pkg/gofr/metrics/exporters/gcp/go.mod index 3c3a8c0e74..50027f8b0c 100644 --- a/pkg/gofr/metrics/exporters/gcp/go.mod +++ b/pkg/gofr/metrics/exporters/gcp/go.mod @@ -9,7 +9,7 @@ require ( go.opentelemetry.io/otel/sdk v1.46.0 go.opentelemetry.io/otel/sdk/metric v1.46.0 gofr.dev v1.60.1 - golang.org/x/oauth2 v0.36.0 + golang.org/x/oauth2 v0.37.0 google.golang.org/grpc v1.83.2 ) diff --git a/pkg/gofr/metrics/exporters/gcp/go.sum b/pkg/gofr/metrics/exporters/gcp/go.sum index 1a9212a93b..1361c64a04 100644 --- a/pkg/gofr/metrics/exporters/gcp/go.sum +++ b/pkg/gofr/metrics/exporters/gcp/go.sum @@ -71,8 +71,8 @@ gofr.dev v1.60.1 h1:tgUCh33369oDSQNmcSxVNM+xgFxtCXxA9LZLgUK2m6k= gofr.dev v1.60.1/go.mod h1:5b56VoXF2ImEkDnYV69ExzRS586o2juu96zJKaRuZL4= golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= -golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= -golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= +golang.org/x/oauth2 v0.37.0 h1:JUlcxA8oAtauLfiH8FX2/FkAWHAdi0QtGCGc+hofE98= +golang.org/x/oauth2 v0.37.0/go.mod h1:IxwZNxUULJmpBFf9K/9NTMSIfZZuvuTy1gGxhigP/58= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= From 38ed931a305f11df7d743d7ed9944b1545d84bfe Mon Sep 17 00:00:00 2001 From: aryanmehrotra Date: Wed, 16 Sep 2026 20:19:24 +0530 Subject: [PATCH 45/48] update release version to v1.61.0 --- go.work.sum | 1 + pkg/gofr/version/version.go | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/go.work.sum b/go.work.sum index 44ba2d6fe6..75ce3205c3 100644 --- a/go.work.sum +++ b/go.work.sum @@ -1793,6 +1793,7 @@ golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs= golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ= golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww= golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec= +golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= diff --git a/pkg/gofr/version/version.go b/pkg/gofr/version/version.go index 4060342d1d..10e8bf22a3 100644 --- a/pkg/gofr/version/version.go +++ b/pkg/gofr/version/version.go @@ -1,3 +1,3 @@ package version -const Framework = "dev" +const Framework = "v1.61.0" From 5613321df6d50be447d58c59332702d6690e7ecc Mon Sep 17 00:00:00 2001 From: Aryan Mehrotra Date: Thu, 17 Sep 2026 14:25:56 +0530 Subject: [PATCH 46/48] fix(metrics): keep caller-controlled labels from crowding out real routes (#4163) --- docs/references/configs/page.md | 2 +- pkg/gofr/container/metrics_exporter.go | 27 ++ pkg/gofr/http/middleware/config.go | 9 + pkg/gofr/http/middleware/config_test.go | 24 ++ pkg/gofr/http/middleware/metrics.go | 170 +++++++++++- .../middleware/metrics_cardinality_test.go | 249 ++++++++++++++++++ pkg/gofr/http_server.go | 2 +- pkg/gofr/metrics/exporters/provider_test.go | 40 +++ 8 files changed, 519 insertions(+), 4 deletions(-) create mode 100644 pkg/gofr/http/middleware/metrics_cardinality_test.go diff --git a/docs/references/configs/page.md b/docs/references/configs/page.md index 8fd5fe0868..35bd882e8b 100644 --- a/docs/references/configs/page.md +++ b/docs/references/configs/page.md @@ -105,7 +105,7 @@ This document lists all the configuration options supported by the GoFr framewor --- - METRICS_CARDINALITY_LIMIT -- Per-instrument attribute-set limit, inclusive of the overflow slot: an instrument keeps up to one fewer than this many distinct label sets per collection cycle, and the remaining series collapse into a single otel.metric.overflow series (so a value of n keeps n-1 real label sets). Set 0 or negative for unlimited. When unset, the OpenTelemetry SDK default applies (2000, or OTEL_GO_X_CARDINALITY_LIMIT if set); a set value takes precedence over OTEL_GO_X_CARDINALITY_LIMIT. +- Per-instrument attribute-set limit, inclusive of the overflow slot: an instrument keeps up to one fewer than this many distinct label sets per collection cycle, and the remaining series collapse into a single otel.metric.overflow series (so a value of n keeps n-1 real label sets). Set 0 or negative for unlimited. When unset, the OpenTelemetry SDK default applies (2000, or OTEL_GO_X_CARDINALITY_LIMIT if set); a set value takes precedence over OTEL_GO_X_CARDINALITY_LIMIT. HTTP metrics give requests that match no route (and unknown methods) at most a quarter of this limit, capped at 500 distinct (path, method, status) label sets; past that they are recorded as `__unmatched__` / `__other__`, so scanner traffic cannot push real routes into the overflow series. - 2000 --- diff --git a/pkg/gofr/container/metrics_exporter.go b/pkg/gofr/container/metrics_exporter.go index 9b675f8e27..58fbc0412c 100644 --- a/pkg/gofr/container/metrics_exporter.go +++ b/pkg/gofr/container/metrics_exporter.go @@ -85,6 +85,33 @@ func metricsCardinalityLimit(conf config.Config, logger exporters.Logger) *int { return &n } +// defaultMetricsCardinalityLimit is the OTel SDK's per-instrument default. +const defaultMetricsCardinalityLimit = 2000 + +// MetricsCardinalityLimit returns the per-instrument datapoint ceiling the meter +// provider will actually apply: METRICS_CARDINALITY_LIMIT when it parses (the +// override metricsExporterConfig passes to the provider), otherwise +// OTEL_GO_X_CARDINALITY_LIMIT, which the SDK reads itself, otherwise the SDK +// default. Zero or negative means unlimited. +// +// Reading the OTel key through conf agrees with the SDK reading it through +// os.Getenv: GoFr's env loader loads configs/.env into the process environment +// before either runs, so a value set only in .env is visible to both. +// +// It is a function rather than a Container method so that it is not promoted +// onto every handler's Context. +func MetricsCardinalityLimit(conf config.Config) int { + if n := metricsCardinalityLimit(conf, nil); n != nil { + return *n + } + + if n, err := strconv.Atoi(strings.TrimSpace(conf.Get("OTEL_GO_X_CARDINALITY_LIMIT"))); err == nil { + return n + } + + return defaultMetricsCardinalityLimit +} + // metricsExportInterval resolves the push interval, preferring the GoFr-native // METRICS_EXPORT_INTERVAL (seconds), then the OpenTelemetry standard // OTEL_METRIC_EXPORT_INTERVAL (milliseconds, per spec), then the default. diff --git a/pkg/gofr/http/middleware/config.go b/pkg/gofr/http/middleware/config.go index 3648ba1250..73a233fbb9 100644 --- a/pkg/gofr/http/middleware/config.go +++ b/pkg/gofr/http/middleware/config.go @@ -8,12 +8,19 @@ import ( "golang.org/x/text/language" "gofr.dev/pkg/gofr/config" + "gofr.dev/pkg/gofr/container" "gofr.dev/pkg/gofr/service" ) type Config struct { CorsHeaders map[string]string LogProbes LogProbes + + // MetricsCardinalityLimit is the meter provider's effective per-instrument + // datapoint ceiling, from container.MetricsCardinalityLimit so the two cannot + // disagree. Zero or negative means unlimited. The Metrics middleware sizes its + // caller-controlled label budget from it; see WithCardinalityLimit. + MetricsCardinalityLimit int } type LogProbes struct { @@ -51,6 +58,8 @@ func GetConfigs(c config.Config) Config { middlewareConfigs.LogProbes.Disabled = value } + middlewareConfigs.MetricsCardinalityLimit = container.MetricsCardinalityLimit(c) + return middlewareConfigs } diff --git a/pkg/gofr/http/middleware/config_test.go b/pkg/gofr/http/middleware/config_test.go index 197f31a7f1..911c24c7e6 100644 --- a/pkg/gofr/http/middleware/config_test.go +++ b/pkg/gofr/http/middleware/config_test.go @@ -37,3 +37,27 @@ func TestLogDisableProbesConfig(t *testing.T) { assert.True(t, middlewareConfigs.LogProbes.Disabled, "TestLogDisableProbesConfig Failed!") } + +func TestGetConfigs_MetricsCardinalityLimit(t *testing.T) { + tests := []struct { + name string + env map[string]string + expected int + }{ + {name: "neither set uses the SDK default", env: map[string]string{}, expected: 2000}, + {name: "METRICS_CARDINALITY_LIMIT", env: map[string]string{"METRICS_CARDINALITY_LIMIT": "100"}, expected: 100}, + {name: "OTEL_GO_X_CARDINALITY_LIMIT", env: map[string]string{"OTEL_GO_X_CARDINALITY_LIMIT": "300"}, expected: 300}, + {name: "GoFr key wins over the OTel key", + env: map[string]string{"METRICS_CARDINALITY_LIMIT": "100", "OTEL_GO_X_CARDINALITY_LIMIT": "300"}, expected: 100}, + {name: "invalid GoFr key falls through to the OTel key", + env: map[string]string{"METRICS_CARDINALITY_LIMIT": "lots", "OTEL_GO_X_CARDINALITY_LIMIT": "300"}, expected: 300}, + {name: "zero means unlimited and is kept", env: map[string]string{"METRICS_CARDINALITY_LIMIT": "0"}, expected: 0}, + {name: "whitespace is trimmed", env: map[string]string{"METRICS_CARDINALITY_LIMIT": " 64 "}, expected: 64}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + assert.Equal(t, tt.expected, GetConfigs(config.NewMockConfig(tt.env)).MetricsCardinalityLimit) + }) + } +} diff --git a/pkg/gofr/http/middleware/metrics.go b/pkg/gofr/http/middleware/metrics.go index cf8e24999f..3aef2830d2 100644 --- a/pkg/gofr/http/middleware/metrics.go +++ b/pkg/gofr/http/middleware/metrics.go @@ -44,13 +44,60 @@ type routeMethodKey struct { // metrics, so recording app_http_response for it would double-count. const graphqlPath = "/graphql" +// MetricsOption configures the Metrics middleware. +type MetricsOption func(*metricsOptions) + +type metricsOptions struct { + untemplatedLimit int64 +} + +// WithCardinalityLimit sizes the budget for caller-controlled label sets from +// the meter provider's per-instrument datapoint ceiling, so that unmatched +// traffic can take at most a quarter of it and the route table keeps the rest. +// A ceiling of zero or less means unlimited, and the budget stays at +// untemplatedLabelLimit because memory still needs a bound. A ceiling below +// untemplatedCeilingShare gives a budget of zero: every caller-controlled +// request collapses from the first one. +// +// The budget belongs to this Metrics instance, while the admitted set is shared +// process-wide (see untemplatedLabels). Two instances built with different +// ceilings each stop admitting at their own budget, so both stay bounded. +func WithCardinalityLimit(limit int) MetricsOption { + return func(o *metricsOptions) { + o.untemplatedLimit = untemplatedBudget(limit) + } +} + +// untemplatedCeilingShare is the inverse of the fraction of the provider ceiling +// that caller-controlled label sets may occupy. The budget counts the same unit +// the ceiling counts -- distinct (path, method, status) attribute sets -- so it +// really is a quarter of the datapoints, not a quarter of the (path, method) +// pairs. On top of it sit only the collapsed __unmatched__ / __other__ series, +// one per status the handlers return. +const untemplatedCeilingShare = 4 + +func untemplatedBudget(ceiling int) int64 { + if ceiling <= 0 { + return untemplatedLabelLimit + } + + return min(int64(untemplatedLabelLimit), int64(ceiling/untemplatedCeilingShare)) +} + // Metrics is a middleware that records request response time metrics using the provided metrics interface. -func Metrics(metrics metrics) func(inner http.Handler) http.Handler { +func Metrics(metrics metrics, opts ...MetricsOption) func(inner http.Handler) http.Handler { // The recording strategy is selected once, here, from what the metrics // backend supports. The per-request path then makes a single call and // carries none of that branching itself. recorder := newHistogramRecorder(metrics) + options := metricsOptions{untemplatedLimit: untemplatedLabelLimit} + for _, opt := range opts { + opt(&options) + } + + untemplatedLimit := options.untemplatedLimit + return func(inner http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { // If an outer middleware (Logging) has already wrapped w in a @@ -79,7 +126,10 @@ func Metrics(metrics metrics) func(inner http.Handler) http.Handler { // nothing, net/http implicit-200) to http.StatusOK so neither the // histogram nor any status cache is poisoned with status=0. defer func(res *StatusResponseWriter, req *http.Request) { - recorder.record(path, req.Method, res.Status(), time.Since(start).Seconds(), templated) + status := res.Status() + pathLabel, methodLabel := metricLabels(path, req.Method, status, templated, untemplatedLimit) + recorder.record(pathLabel, methodLabel, status, + time.Since(start).Seconds(), templated) }(srw, r) inner.ServeHTTP(srw, r) @@ -87,6 +137,122 @@ func Metrics(metrics metrics) func(inner http.Handler) http.Handler { } } +// The labels recorded for a request whose path or method is caller-controlled +// rather than drawn from the route table. +// +// A histogram retains one datapoint per distinct attribute set for the life of +// the process, and the set is keyed on the (path, method, status) triple. Both +// halves of that key come off the request for anything that does not resolve to +// a route template: net/http accepts any RFC 7230 token as a method, and GoFr's +// PathPrefix("/") catch-all -- registered with no .Methods() restriction -- means +// an unmatched request still runs this middleware rather than being turned away. +// +// The meter provider caps datapoints per instrument: the SDK default of 2000, +// OTEL_GO_X_CARDINALITY_LIMIT, or METRICS_CARDINALITY_LIMIT, which takes +// precedence. Datapoints past that ceiling are folded into a single overflow +// series, so junk arriving first evicts nothing but occupies the slots, and the +// REAL routes registered afterwards are the ones that vanish from the dashboard. +// Collapsing caller-controlled labels keeps the junk to one series and leaves the +// ceiling for routes that matter. +// +// It is also the only bound on memory when that ceiling is configured away +// (METRICS_CARDINALITY_LIMIT=0 means unlimited): every series pins a datapoint, +// and exporters re-send every held series on every interval. +const ( + unmatchedPathLabel = "__unmatched__" + otherMethodLabel = "__other__" + + // untemplatedLabelLimit is the most distinct caller-controlled + // (path, method, status) label sets recorded verbatim before path and method + // collapse. WithCardinalityLimit lowers it to a quarter of a smaller provider + // ceiling; it never raises it. + // + // It bounds the whole attribute set rather than each label separately, + // because independent ceilings multiply: 4096 paths and 64 methods is a + // quarter of a million possible series, and every status a pair is seen with + // multiplies that again. The attribute set is the quantity the provider + // ceiling counts, so it is the one bounded here. + // + // The value is a quarter of the SDK default provider ceiling (2000), + // so caller-controlled series cannot crowd out the route table. It also sits + // below routeCacheLimit on purpose: this check fires first, so routeCache's + // own refusal to store past its limit never triggers for this set. + untemplatedLabelLimit = 500 +) + +// untemplatedLabels is the set of caller-controlled (path, method, status) +// label sets admitted verbatim. +// +// It is process-wide, unlike the per-Metrics() recorder caches, because the +// resource it protects -- the meter provider's datapoint table -- is also +// process-wide. The budget checked against it is per Metrics() instance; see +// WithCardinalityLimit. +// +// Admission is check-then-act, so concurrent first sightings can overshoot by +// roughly the number of requests in flight. The overshoot is bounded by +// concurrency rather than by the caller, and the population stays finite. +// +// Admission is first-come and nothing is ever evicted. That mirrors the +// resource: exporters.Build always installs the Prometheus reader, and +// Prometheus is cumulative, so at least one pipeline keeps every recorded +// series for the life of the process whatever temporality a push exporter +// uses. Evicting a label set here would free nothing there, and admitting a +// new one in its place would mint another datapoint -- this set would stop +// bounding anything. (Only if the Prometheus reader failed to initialize and a +// delta push reader were the sole pipeline would the SDK free datapoints that +// this set still holds; that is narrow enough to accept.) The accepted cost is that +// a burst of junk early in the process fills the set, after which other +// untemplated traffic, static assets included, is recorded as __unmatched__. It +// is still counted and timed, only not per path. Templated routes never reach +// the set and are unaffected. +// +// Tests that assert on this set reset it and must not call t.Parallel(). +// +//nolint:gochecknoglobals // process-wide by necessity: see above. +var untemplatedLabels routeCache[struct{}] + +// untemplatedKey identifies one caller-controlled attribute set. +type untemplatedKey struct { + path, method string + status int +} + +// metricLabels returns the path and method labels to record. +// +// A templated path and a standard method are bounded by construction and are +// always recorded as themselves. Anything else is recorded verbatim until the +// ceiling and collapses afterwards, which keeps existing behavior -- recording +// the raw path for unrouted and static requests, and the verbatim method +// including custom verbs, are both deliberately tested -- while stopping a +// caller from filling the datapoint table. +func metricLabels(path, method string, status int, templated bool, limit int64) (pathLabel, methodLabel string) { + standardMethod := cacheableMethod(method) + if templated && standardMethod { + return path, method + } + + key := untemplatedKey{path: path, method: method, status: status} + if _, admitted := untemplatedLabels.load(key); admitted { + return path, method + } + + if untemplatedLabels.len() >= limit { + if !templated { + path = unmatchedPathLabel + } + + if !standardMethod { + method = otherMethodLabel + } + + return path, method + } + + untemplatedLabels.store(key, struct{}{}) + + return path, method +} + // metricsPath resolves the path label and reports whether it is a bounded route // template. // diff --git a/pkg/gofr/http/middleware/metrics_cardinality_test.go b/pkg/gofr/http/middleware/metrics_cardinality_test.go new file mode 100644 index 0000000000..70a6891ebc --- /dev/null +++ b/pkg/gofr/http/middleware/metrics_cardinality_test.go @@ -0,0 +1,249 @@ +package middleware + +import ( + "context" + "fmt" + "net/http" + "net/http/httptest" + "testing" + + "github.com/gorilla/mux" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// cardRecorder captures the label sets the middleware actually records, so these +// tests observe the wiring rather than the helper it calls. +type cardRecorder struct{ labels [][]string } + +func (c *cardRecorder) RecordHistogram(_ context.Context, _ string, _ float64, labels ...string) { + c.labels = append(c.labels, labels) +} + +func (*cardRecorder) IncrementCounter(context.Context, string, ...string) {} +func (*cardRecorder) DeltaUpDownCounter(context.Context, string, float64, ...string) {} +func (*cardRecorder) SetGauge(string, float64, ...string) {} + +// series returns the distinct (path, method, status) sets recorded -- the unit the +// provider ceiling counts, one retained datapoint each. +func (c *cardRecorder) series() map[[3]string]int { + out := map[[3]string]int{} + + for _, l := range c.labels { + var set [3]string + + for i := 0; i+1 < len(l); i += 2 { + switch l[i] { + case "path": + set[0] = l[i+1] + case "method": + set[1] = l[i+1] + case "status": + set[2] = l[i+1] + } + } + + out[set]++ + } + + return out +} + +// cardServe drives the real Metrics middleware, with no router, so every request +// is untemplated -- the state an unmatched request reaches this middleware in. +func cardServe(t *testing.T, rec *cardRecorder, method, path string) { + t.Helper() + + cardServeStatus(t, rec, method, path, http.StatusNotFound) +} + +func cardServeStatus(t *testing.T, rec *cardRecorder, method, path string, status int) { + t.Helper() + + h := Metrics(rec)(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(status) + })) + + req := httptest.NewRequestWithContext(context.Background(), method, path, http.NoBody) + h.ServeHTTP(httptest.NewRecorder(), req) +} + +// TestMultiStatusPairsStayWithinBudget is the review finding that the budget +// once counted (path, method) pairs while the provider ceiling counts +// (path, method, status) sets: 3000 unmatched paths each seen with 4 statuses +// kept 501 pairs but minted 2004 sets, the whole default ceiling. Static assets +// served as 200, 304, 403 and 404 produce exactly that mix. +func TestMultiStatusPairsStayWithinBudget(t *testing.T) { + untemplatedLabels.reset() + defer untemplatedLabels.reset() + + statuses := []int{http.StatusOK, http.StatusNotModified, http.StatusForbidden, http.StatusNotFound} + rec := &cardRecorder{} + + for i := range 3000 { + for _, status := range statuses { + cardServeStatus(t, rec, http.MethodGet, fmt.Sprintf("/static/asset-%d.js", i), status) + } + } + + // The budget, plus at most one collapsed series per status. + assert.LessOrEqual(t, len(rec.series()), untemplatedLabelLimit+len(statuses), + "%d attribute sets recorded against a budget of %d", len(rec.series()), untemplatedLabelLimit) +} + +// TestUntemplatedSeriesAreBounded is what this change exists for. +// +// A histogram retains a datapoint per distinct attribute set for the life of the +// process, and the meter provider caps how many it will hold. Series past that +// cap fold into one overflow bucket, so caller-controlled labels arriving first +// occupy the slots and the real routes registered later are the ones that +// disappear from the dashboard. This asserts the caller-controlled population is +// finite, measured through the middleware rather than through the helper. +func TestUntemplatedSeriesAreBounded(t *testing.T) { + untemplatedLabels.reset() + defer untemplatedLabels.reset() + + rec := &cardRecorder{} + + for i := range untemplatedLabelLimit * 3 { + cardServe(t, rec, http.MethodGet, fmt.Sprintf("/no/such/path/%d", i)) + } + + assert.LessOrEqual(t, len(rec.series()), untemplatedLabelLimit+1, + "%d invented paths produced %d metric series", untemplatedLabelLimit*3, len(rec.series())) +} + +// TestInventedMethodsAreBounded closes the other half of the key. Holding the +// path fixed and varying the method reaches the same datapoint table, and would +// never consult a path-only ceiling. +func TestInventedMethodsAreBounded(t *testing.T) { + untemplatedLabels.reset() + defer untemplatedLabels.reset() + + rec := &cardRecorder{} + + for i := range untemplatedLabelLimit * 3 { + cardServe(t, rec, fmt.Sprintf("M%05d", i), "/fixed") + } + + assert.LessOrEqual(t, len(rec.series()), untemplatedLabelLimit+1, + "%d invented methods produced %d metric series", untemplatedLabelLimit*3, len(rec.series())) +} + +// TestTemplatedRoutesSurviveJunkTraffic pins the point of bounding at all: a real +// route must still get its own series while junk is holding the ceiling down. +func TestTemplatedRoutesSurviveJunkTraffic(t *testing.T) { + untemplatedLabels.reset() + defer untemplatedLabels.reset() + + junk := &cardRecorder{} + for i := range untemplatedLabelLimit + 50 { + cardServe(t, junk, http.MethodGet, fmt.Sprintf("/junk/%d", i)) + } + + rec := &cardRecorder{} + router := mux.NewRouter() + router.Use(Metrics(rec)) + router.NewRoute().Methods(http.MethodGet).Path("/users/{id}"). + Handler(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusOK) })) + router.ServeHTTP(httptest.NewRecorder(), + httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/users/42", http.NoBody)) + + require.Len(t, rec.labels, 1) + assert.Contains(t, rec.series(), [3]string{"/users/{id}", http.MethodGet, "200"}, + "a templated route keeps its own series regardless of junk traffic") +} + +func TestUntemplatedBudget(t *testing.T) { + tests := []struct { + ceiling int + expected int64 + }{ + {ceiling: 2000, expected: untemplatedLabelLimit}, + {ceiling: 100000, expected: untemplatedLabelLimit}, + {ceiling: 100, expected: 25}, + {ceiling: 3, expected: 0}, + {ceiling: 1, expected: 0}, + {ceiling: 4, expected: 1}, + {ceiling: 0, expected: untemplatedLabelLimit}, + {ceiling: -1, expected: untemplatedLabelLimit}, + } + + for _, tt := range tests { + assert.Equal(t, tt.expected, untemplatedBudget(tt.ceiling), "ceiling %d", tt.ceiling) + } +} + +// TestLowCeilingKeepsRoutesReachable is the case a fixed budget got wrong: with +// the provider ceiling at 100, 512 caller-controlled pairs alone would fill it. +// Through WithCardinalityLimit the junk takes at most a quarter and a real route +// still records under its own template. +func TestLowCeilingKeepsRoutesReachable(t *testing.T) { + untemplatedLabels.reset() + defer untemplatedLabels.reset() + + const ceiling = 100 + + junk := &cardRecorder{} + h := Metrics(junk, WithCardinalityLimit(ceiling))(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusNotFound) + })) + + for i := range ceiling * 3 { + h.ServeHTTP(httptest.NewRecorder(), httptest.NewRequestWithContext(context.Background(), + http.MethodGet, fmt.Sprintf("/.env.scan-%d", i), http.NoBody)) + } + + assert.LessOrEqual(t, len(junk.series()), ceiling/untemplatedCeilingShare+1, + "junk may take at most a quarter of the ceiling, plus the collapsed series") + + rec := &cardRecorder{} + router := mux.NewRouter() + router.Use(Metrics(rec, WithCardinalityLimit(ceiling))) + router.NewRoute().Methods(http.MethodGet).Path("/users/{id}"). + Handler(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusOK) })) + router.ServeHTTP(httptest.NewRecorder(), + httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/users/7", http.NoBody)) + + assert.Contains(t, rec.series(), [3]string{"/users/{id}", http.MethodGet, "200"}) +} + +// BenchmarkMetricLabels isolates the per-request cost this change adds in front +// of the recorder, for the three paths a request can take through it. +func BenchmarkMetricLabels(b *testing.B) { + b.Run("templated", func(b *testing.B) { + b.ReportAllocs() + + for range b.N { + metricLabels("/users/{id}", http.MethodGet, http.StatusOK, true, untemplatedLabelLimit) + } + }) + + b.Run("untemplated_admitted", func(b *testing.B) { + untemplatedLabels.reset() + b.Cleanup(untemplatedLabels.reset) + metricLabels("/.env", http.MethodGet, http.StatusNotFound, false, untemplatedLabelLimit) + b.ReportAllocs() + b.ResetTimer() + + for range b.N { + metricLabels("/.env", http.MethodGet, http.StatusNotFound, false, untemplatedLabelLimit) + } + }) + + b.Run("untemplated_collapsed", func(b *testing.B) { + untemplatedLabels.reset() + b.Cleanup(untemplatedLabels.reset) + + for i := range untemplatedLabelLimit { + metricLabels(fmt.Sprintf("/fill/%d", i), http.MethodGet, http.StatusNotFound, false, untemplatedLabelLimit) + } + + b.ReportAllocs() + b.ResetTimer() + + for range b.N { + metricLabels("/.env.new", http.MethodGet, http.StatusNotFound, false, untemplatedLabelLimit) + } + }) +} diff --git a/pkg/gofr/http_server.go b/pkg/gofr/http_server.go index 452283cbda..2e083ad922 100644 --- a/pkg/gofr/http_server.go +++ b/pkg/gofr/http_server.go @@ -82,7 +82,7 @@ func newHTTPServer(c *container.Container, port int, middlewareConfigs middlewar middleware.Tracer, middleware.Logging(middlewareConfigs.LogProbes, c.Logger), middleware.CORS(middlewareConfigs.CorsHeaders, r.RegisteredRoutes), - middleware.Metrics(c.Metrics()), + middleware.Metrics(c.Metrics(), middleware.WithCardinalityLimit(middlewareConfigs.MetricsCardinalityLimit)), ) return &httpServer{ diff --git a/pkg/gofr/metrics/exporters/provider_test.go b/pkg/gofr/metrics/exporters/provider_test.go index c64a57ba16..38d6224924 100644 --- a/pkg/gofr/metrics/exporters/provider_test.go +++ b/pkg/gofr/metrics/exporters/provider_test.go @@ -63,6 +63,46 @@ func TestBuild_appliesCardinalityLimit(t *testing.T) { } } +// TestBuild_unsetCardinalityLimitHonorsSDKEnv pins the other half of the +// contract: with METRICS_CARDINALITY_LIMIT unset, Build must pass no limit at +// all. The SDK applies explicit options after OTEL_GO_X_CARDINALITY_LIMIT +// (sdk/metric config.go newConfig), so any hard-coded WithCardinalityLimit in +// Build would silently make that variable inert. +func TestBuild_unsetCardinalityLimitHonorsSDKEnv(t *testing.T) { + t.Setenv("OTEL_GO_X_CARDINALITY_LIMIT", "3") + + reader := metricSdk.NewManualReader() + + Register("card-env-test", func(_ context.Context, _ *Config, _ Logger) (metricSdk.Reader, error) { + return reader, nil + }) + + cfg := Config{AppName: "app", AppVersion: "v1", Exporter: "card-env-test"} + + shutdown, meter := Build(context.Background(), &cfg, logging.NewMockLogger(logging.ERROR)) + + defer func() { _ = shutdown(context.Background()) }() + + counter, err := meter.Int64Counter("card_env_counter") + if err != nil { + t.Fatalf("failed to create counter: %v", err) + } + + const distinct = 10 + for i := 0; i < distinct; i++ { + counter.Add(context.Background(), 1, metric.WithAttributes(attribute.Int("i", i))) + } + + var rm metricdata.ResourceMetrics + if err := reader.Collect(context.Background(), &rm); err != nil { + t.Fatalf("collect failed: %v", err) + } + + if points := countDataPoints(t, &rm, "card_env_counter"); points == 0 || points > 3 { + t.Errorf("OTEL_GO_X_CARDINALITY_LIMIT=3 not honored with METRICS_CARDINALITY_LIMIT unset: got %d data points", points) + } +} + func countDataPoints(t *testing.T, rm *metricdata.ResourceMetrics, name string) int { t.Helper() From 5d1811fe6a723920219627f9dbcfb13ac364ad78 Mon Sep 17 00:00:00 2001 From: Aryan Mehrotra Date: Thu, 17 Sep 2026 15:32:14 +0530 Subject: [PATCH 47/48] fix(tracing): redact tracer config in logs (#4247) Co-authored-by: Umang Mundhra --- pkg/gofr/constants.go | 2 + pkg/gofr/gofr_test.go | 2 +- pkg/gofr/otel.go | 151 +++++++++++++++++++++++++++++++++++++----- pkg/gofr/otel_test.go | 117 ++++++++++++++++++++++++++++++++ 4 files changed, 256 insertions(+), 16 deletions(-) diff --git a/pkg/gofr/constants.go b/pkg/gofr/constants.go index 10a6974bc9..65ac705072 100644 --- a/pkg/gofr/constants.go +++ b/pkg/gofr/constants.go @@ -6,6 +6,8 @@ const ( defaultPublicStaticDir = "static" shutDownTimeout = 30 * time.Second gofrTraceExporter = "gofr" + otlpTraceExporter = "otlp" + jaegerTraceExporter = "jaeger" gofrTracerURL = "https://tracer.gofr.dev" checkPortTimeout = 2 * time.Second gofrHost = "https://gofr.dev" diff --git a/pkg/gofr/gofr_test.go b/pkg/gofr/gofr_test.go index 17f3b2f174..ca87b339b9 100644 --- a/pkg/gofr/gofr_test.go +++ b/pkg/gofr/gofr_test.go @@ -836,7 +836,7 @@ func Test_initTracer_invalidConfig(t *testing.T) { config config.Config expectedLogMessage string }{ - {"unsupported trace_exporter", mockConfig1, "unsupported TRACE_EXPORTER: abc"}, + {"unsupported trace_exporter", mockConfig1, "unsupported TRACE_EXPORTER=abc: expected one of otlp, jaeger, zipkin or gofr"}, {"missing trace_exporter", mockConfig2, "missing TRACE_EXPORTER config, should be provided with TRACER_URL to enable tracing"}, {"miss tracer_url ", mockConfig3, "missing TRACER_URL config, should be provided with TRACE_EXPORTER to enable tracing"}, diff --git a/pkg/gofr/otel.go b/pkg/gofr/otel.go index 542295e8c1..accc638f8a 100644 --- a/pkg/gofr/otel.go +++ b/pkg/gofr/otel.go @@ -3,8 +3,10 @@ package gofr import ( "context" "fmt" + "net/url" "strconv" "strings" + "unicode" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc" @@ -170,8 +172,10 @@ func (a *App) tracerInsecure() (insecure, set bool) { b, err := strconv.ParseBool(v) if err != nil { - a.Logger().Warnf("invalid TRACER_INSECURE %q: expected a boolean; defaulting to plaintext for a "+ - "schemeless TRACER_URL", v) + // The raw value is not echoed. Tracer config reaches a log only through + // redactURL, redactExporterName or as a matched constant. + a.Logger().Warn("invalid TRACER_INSECURE: expected true or false; defaulting to plaintext for a " + + "schemeless TRACER_URL") return true, false } @@ -188,13 +192,10 @@ func (a *App) getExporter(name, host, port, url string) (sdktrace.SpanExporter, headers := a.getTracerHeaders() switch strings.ToLower(name) { - case "otlp", "jaeger": - // Resolved inside the case, not above the switch: TRACER_INSECURE means - // nothing to zipkin or gofr, and evaluating it for them would warn about a - // malformed value under an exporter that never reads it. - insecure, insecureSet := a.tracerInsecure() - - exporter, err = buildOtlpExporter(a.Logger(), name, url, host, port, headers, insecure, insecureSet) + case otlpTraceExporter: + exporter, err = a.buildOtlpFamilyExporter(otlpTraceExporter, url, host, port, headers) + case jaegerTraceExporter: + exporter, err = a.buildOtlpFamilyExporter(jaegerTraceExporter, url, host, port, headers) case "zipkin": a.Logger().Warn("TRACE_EXPORTER=zipkin is deprecated and will be removed in a future release. " + "Zipkin supports OTLP natively (v2.24+) — to migrate, switch to TRACE_EXPORTER=otlp " + @@ -204,12 +205,25 @@ func (a *App) getExporter(name, host, port, url string) (sdktrace.SpanExporter, case gofrTraceExporter: exporter = buildGoFrExporter(a.Logger(), url) default: - a.container.Errorf("unsupported TRACE_EXPORTER: %s", name) + a.container.Errorf("unsupported TRACE_EXPORTER=%s: expected one of otlp, jaeger, zipkin or gofr", + redactExporterName(name)) } return exporter, err } +// buildOtlpFamilyExporter builds the OTLP exporter for otlp and jaeger. The +// exporter name is passed as the matched constant rather than the configured +// string, so only a known name is ever logged. +func (a *App) buildOtlpFamilyExporter(name, endpoint, host, port string, headers map[string]string) (sdktrace.SpanExporter, error) { + // Resolved here, not in getExporter above the switch: TRACER_INSECURE means + // nothing to zipkin or gofr, and evaluating it for them would warn about a + // malformed value under an exporter that never reads it. + insecure, insecureSet := a.tracerInsecure() + + return buildOtlpExporter(a.Logger(), name, endpoint, host, port, headers, insecure, insecureSet) +} + // otlpTransport is the resolved transport-security decision for the OTLP trace // exporter: which endpoint option to use, whether to apply WithInsecure, and // whether the resulting connection carries traffic in the clear. @@ -266,7 +280,7 @@ func resolveOtlpTransport(logger logging.Logger, url string, insecure, insecureS if strings.HasPrefix(scheme, schemeHTTP) || strings.HasPrefix(scheme, schemeHTTPS) { if insecureSet { logger.Warnf("TRACER_INSECURE is ignored for TRACER_URL=%q: transport security is derived "+ - "from the URL scheme", url) + "from the URL scheme", redactURL(url)) } return otlpTransport{useEndpointURL: true, plaintext: strings.HasPrefix(scheme, schemeHTTP)} @@ -287,10 +301,10 @@ func buildOtlpExporter(logger logging.Logger, name, url, host, port string, head if transport.plaintext && len(headers) > 0 { logger.Warnf("traces are exported to %s over plaintext with headers configured: "+ - "headers (including auth credentials) will be sent in the clear", url) + "headers (including auth credentials) will be sent in the clear", redactURL(url)) } - logger.Infof("Exporting traces to %s at %s", strings.ToLower(name), url) + logger.Infof("Exporting traces to %s at %s", name, redactURL(url)) var opts []otlptracegrpc.Option @@ -316,7 +330,7 @@ func buildZipkinExporter(logger logging.Logger, url, host, port string, headers url = fmt.Sprintf("http://%s:%s/api/v2/spans", host, port) } - logger.Infof("Exporting traces to zipkin at %s", url) + logger.Infof("Exporting traces to zipkin at %s", redactURL(url)) var opts []zipkin.Option if len(headers) > 0 { @@ -331,11 +345,118 @@ func buildGoFrExporter(logger logging.Logger, url string) sdktrace.SpanExporter url = "https://tracer-api.gofr.dev/api/spans" } - logger.Infof("Exporting traces to GoFr at %s", url) + logger.Infof("Exporting traces to GoFr at %s", redactURL(url)) return NewExporter(url, logging.NewLogger(logging.INFO)) } +// redactedPlaceholder stands in for credentials when a tracer endpoint is logged. +const redactedPlaceholder = "REDACTED" + +// redactURL returns a tracer endpoint that is safe to write to a log. +// +// A scheme-bearing TRACER_URL is a real URL, so it can carry credentials in its +// userinfo (https://user:token@collector:4317) or its query +// (https://collector/api/v2/spans?api-key=...). Both are replaced rather than +// dropped, so the log still shows that something was configured there. +// +// Secrets placed in path segments (https://host/v1/TOKEN/spans) are not +// redacted: no tracer backend GoFr supports takes credentials there, and +// hiding the path would hide the part of the endpoint an operator debugs. +// +// Control characters are escaped on the unparsed path only: url.Parse rejects +// them, so such a value always lands there, and a raw newline would otherwise +// forge a second log line in the terminal's pretty output. +func redactURL(raw string) string { + u, err := url.Parse(raw) + if err != nil || u.Host == "" { + return escapeControlChars(redactUnparsedURL(raw)) + } + + if u.User != nil { + u.User = url.User(redactedPlaceholder) + } + + if u.RawQuery != "" { + u.RawQuery = redactedPlaceholder + } + + u.Fragment = "" + + return u.String() +} + +// escapeControlChars replaces every control character with its \x or \u +// escape, so a logged value always stays on one line. +func escapeControlChars(s string) string { + if strings.IndexFunc(s, unicode.IsControl) < 0 { + return s + } + + var b strings.Builder + + for _, r := range s { + switch { + case !unicode.IsControl(r): + b.WriteRune(r) + case r <= unicode.MaxLatin1: + fmt.Fprintf(&b, `\x%02x`, r) + default: + fmt.Fprintf(&b, `\u%04x`, r) + } + } + + return b.String() +} + +// maxEchoedExporterNameLen bounds how much of an unsupported TRACE_EXPORTER is +// echoed back; every supported name is at most 6 characters. +const maxEchoedExporterNameLen = 16 + +// redactExporterName returns an unsupported TRACE_EXPORTER value in a form safe +// to log. A typo of a real exporter name -- short, letters and '-' or '_' only +// -- is echoed so it can be spotted; anything else, which is more likely a +// value pasted into the wrong variable, is replaced. +func redactExporterName(name string) string { + if name == "" || len(name) > maxEchoedExporterNameLen { + return redactedPlaceholder + } + + for _, r := range name { + if (r < 'a' || r > 'z') && (r < 'A' || r > 'Z') && r != '-' && r != '_' { + return redactedPlaceholder + } + } + + return name +} + +// redactUnparsedURL redacts an endpoint that url.Parse cannot split into a host +// and the rest: a schemeless host:port, host/path or user:pass@host, or input +// that does not parse at all. It works on the raw string and over-redacts +// rather than risk a leak. +// +// Userinfo is handled first, up to the last '@'. A '?' in a password, or an +// '@' in a query value, then falls inside the replaced prefix instead of +// splitting the credential. The query and fragment are handled after that. +func redactUnparsedURL(raw string) string { + redacted := raw + + if i := strings.LastIndex(redacted, "@"); i >= 0 { + redacted = redactedPlaceholder + redacted[i:] + } + + if i := strings.IndexByte(redacted, '#'); i >= 0 { + redacted = redacted[:i] + } + + if i := strings.IndexByte(redacted, '?'); i >= 0 { + redacted = redacted[:i+1] + redactedPlaceholder + } + + return redacted +} + type otelErrorHandler struct { logger logging.Logger } diff --git a/pkg/gofr/otel_test.go b/pkg/gofr/otel_test.go index 4016a33e64..1c84fc1faa 100644 --- a/pkg/gofr/otel_test.go +++ b/pkg/gofr/otel_test.go @@ -614,3 +614,120 @@ func BenchmarkSpanStart_NeverSampleSDK(b *testing.B) { span.End() } } + +func Test_redactExporterName(t *testing.T) { + tests := []struct { + name string + value string + expected string + }{ + {name: "typo of a real exporter is echoed", value: "otpl", expected: "otpl"}, + {name: "mixed case and separators are echoed", value: "Open_Telemetry-x", expected: "Open_Telemetry-x"}, + {name: "empty is replaced", value: "", expected: "REDACTED"}, + {name: "longer than 16 is replaced", value: "abcdefghijklmnopq", expected: "REDACTED"}, + {name: "digits look like a pasted secret", value: "ab12cd34", expected: "REDACTED"}, + {name: "URL pasted into the wrong variable", value: "https://x", expected: "REDACTED"}, + {name: "control character is replaced", value: "otlp\n", expected: "REDACTED"}, + {name: "non-ASCII letter is replaced", value: "ötlp", expected: "REDACTED"}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + require.Equal(t, tt.expected, redactExporterName(tt.value)) + }) + } +} + +func Test_redactURL(t *testing.T) { + tests := []struct { + name string + raw string + expected string + }{ + {name: "schemeless host:port is unchanged", raw: "collector:4317", expected: "collector:4317"}, + {name: "plain https URL is unchanged", raw: "https://collector:4317", expected: "https://collector:4317"}, + {name: "path is kept", raw: "http://localhost:2005/api/v2/spans", expected: "http://localhost:2005/api/v2/spans"}, + {name: "empty is unchanged", raw: "", expected: ""}, + {name: "userinfo with password", raw: "https://user:s3cret@collector:4317", expected: "https://REDACTED@collector:4317"}, + {name: "userinfo token only", raw: "https://t0ken@collector:4317", expected: "https://REDACTED@collector:4317"}, + {name: "query credentials", raw: "https://zipkin/api/v2/spans?api-key=s3cret", expected: "https://zipkin/api/v2/spans?REDACTED"}, + {name: "fragment is dropped", raw: "https://collector:4317#s3cret", expected: "https://collector:4317"}, + {name: "schemeless userinfo", raw: "user:s3cret@collector:4317", expected: "REDACTED@collector:4317"}, + {name: "unparsable with userinfo", raw: "https://user:s3cret@collector:43%17", expected: "REDACTED@collector:43%17"}, + {name: "schemeless query credentials", raw: "localhost:9411/api/v2/spans?api-key=s3cret", + expected: "localhost:9411/api/v2/spans?REDACTED"}, + {name: "schemeless userinfo and query", raw: "user:s3cret@collector:4317/p?k=s3cret", expected: "REDACTED@collector:4317/p?REDACTED"}, + {name: "schemeless password containing '?'", raw: "user:s3?cret@collector:4317", expected: "REDACTED@collector:4317"}, + {name: "schemeless '@' inside query value", raw: "collector:4317/p?k=s3cret@x", expected: "REDACTED@x"}, + {name: "schemeless fragment is dropped", raw: "collector:4317#s3cret", expected: "collector:4317"}, + {name: "newline cannot forge a log line", raw: "collector:4317\n{\"level\":\"INFO\"}", + expected: `collector:4317\x0a{"level":"INFO"}`}, + {name: "carriage return and tab are escaped", raw: "host\r:4317\t", expected: `host\x0d:4317\x09`}, + {name: "C1 control is escaped", raw: "host" + string(rune(0x85)) + ":4317", expected: `host\x85:4317`}, + {name: "control char with userinfo is escaped after redaction", raw: "https://user:s3cret@collector\n:4317", + expected: `REDACTED@collector\x0a:4317`}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + require.Equal(t, tt.expected, redactURL(tt.raw)) + }) + } +} + +// Test_initTracer_doesNotLogCredentials drives the real startup path for every +// exporter that logs its endpoint, and asserts the credentials in TRACER_URL and +// the raw TRACER_INSECURE value never reach the log. +func Test_initTracer_doesNotLogCredentials(t *testing.T) { + const secret = "s3cret-value" + + tests := []struct { + name string + exporter string + url string + insecure string + expected string + }{ + {name: "otlp userinfo", exporter: "otlp", url: "https://user:" + secret + "@localhost:4317", + expected: "Exporting traces to otlp at https://REDACTED@localhost:4317"}, + {name: "jaeger ignored TRACER_INSECURE", exporter: "JAEGER", url: "http://user:" + secret + "@localhost:4317", + insecure: "true", expected: "Exporting traces to jaeger at http://REDACTED@localhost:4317"}, + {name: "otlp invalid TRACER_INSECURE", exporter: "otlp", url: "localhost:4317", insecure: secret, + expected: "invalid TRACER_INSECURE"}, + {name: "zipkin query key", exporter: "zipkin", url: "http://localhost:2005/api/v2/spans?api-key=" + secret, + expected: "Exporting traces to zipkin at http://localhost:2005/api/v2/spans?REDACTED"}, + {name: "zipkin schemeless query key", exporter: "zipkin", url: "localhost:9411/api/v2/spans?api-key=" + secret, + expected: "Exporting traces to zipkin at localhost:9411/api/v2/spans?REDACTED"}, + {name: "gofr userinfo", exporter: "gofr", url: "https://user:" + secret + "@tracer.example.com/api/spans", + expected: "Exporting traces to GoFr at https://REDACTED@tracer.example.com/api/spans"}, + {name: "secret pasted into TRACE_EXPORTER", exporter: secret, url: "localhost:4317", + expected: "unsupported TRACE_EXPORTER=REDACTED"}, + {name: "typo in TRACE_EXPORTER is echoed", exporter: "otpl", url: "localhost:4317", + expected: "unsupported TRACE_EXPORTER=otpl"}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfg := map[string]string{"TRACE_EXPORTER": tt.exporter, "TRACER_URL": tt.url, "TRACER_AUTH_KEY": "Bearer x"} + if tt.insecure != "" { + cfg["TRACER_INSECURE"] = tt.insecure + } + + var stderr string + + stdout := testutil.StdoutOutputForFunc(func() { + stderr = testutil.StderrOutputForFunc(func() { + mockContainer, _ := container.NewMockContainer(t) + + a := App{Config: config.NewMockConfig(cfg), container: mockContainer} + a.initTracer() + }) + }) + + out := stdout + stderr + + require.Contains(t, out, tt.expected) + require.NotContains(t, out, secret) + }) + } +} From 4f3e02dfccda411eb3b348ba004323751e1fb8f1 Mon Sep 17 00:00:00 2001 From: Aryan Mehrotra Date: Thu, 17 Sep 2026 17:15:22 +0530 Subject: [PATCH 48/48] fix(tracing): stop tracer parameters shadowing the net/url import (#4249) --- pkg/gofr/constants.go | 1 + pkg/gofr/otel.go | 62 +++++++++++++++++++++---------------------- 2 files changed, 32 insertions(+), 31 deletions(-) diff --git a/pkg/gofr/constants.go b/pkg/gofr/constants.go index 65ac705072..8f862cc193 100644 --- a/pkg/gofr/constants.go +++ b/pkg/gofr/constants.go @@ -8,6 +8,7 @@ const ( gofrTraceExporter = "gofr" otlpTraceExporter = "otlp" jaegerTraceExporter = "jaeger" + zipkinTraceExporter = "zipkin" gofrTracerURL = "https://tracer.gofr.dev" checkPortTimeout = 2 * time.Second gofrHost = "https://gofr.dev" diff --git a/pkg/gofr/otel.go b/pkg/gofr/otel.go index accc638f8a..c574efd9d7 100644 --- a/pkg/gofr/otel.go +++ b/pkg/gofr/otel.go @@ -85,19 +85,19 @@ func (a *App) initTracer() { tp.RegisterSpanProcessor(batcher) } -func isValidConfig(logger logging.Logger, name, url, host, port string) bool { - if url == "" && name == "" { +func isValidConfig(logger logging.Logger, name, endpoint, host, port string) bool { + if endpoint == "" && name == "" { logger.Debug("tracing is disabled, as configs are not provided") return false } - if url != "" && name == "" { + if endpoint != "" && name == "" { logger.Error("missing TRACE_EXPORTER config, should be provided with TRACER_URL to enable tracing") return false } //nolint:revive // early-return is not possible here, as below is the intentional logging flow - if url == "" && name != "" && !strings.EqualFold(name, "gofr") { + if endpoint == "" && name != "" && !strings.EqualFold(name, "gofr") { if host != "" && port != "" { logger.Warn("TRACER_HOST and TRACER_PORT are deprecated, use TRACER_URL instead") } else { @@ -183,7 +183,7 @@ func (a *App) tracerInsecure() (insecure, set bool) { return b, true } -func (a *App) getExporter(name, host, port, url string) (sdktrace.SpanExporter, error) { +func (a *App) getExporter(name, host, port, endpoint string) (sdktrace.SpanExporter, error) { var ( exporter sdktrace.SpanExporter err error @@ -193,17 +193,17 @@ func (a *App) getExporter(name, host, port, url string) (sdktrace.SpanExporter, switch strings.ToLower(name) { case otlpTraceExporter: - exporter, err = a.buildOtlpFamilyExporter(otlpTraceExporter, url, host, port, headers) + exporter, err = a.buildOtlpFamilyExporter(otlpTraceExporter, endpoint, host, port, headers) case jaegerTraceExporter: - exporter, err = a.buildOtlpFamilyExporter(jaegerTraceExporter, url, host, port, headers) - case "zipkin": + exporter, err = a.buildOtlpFamilyExporter(jaegerTraceExporter, endpoint, host, port, headers) + case zipkinTraceExporter: a.Logger().Warn("TRACE_EXPORTER=zipkin is deprecated and will be removed in a future release. " + "Zipkin supports OTLP natively (v2.24+) — to migrate, switch to TRACE_EXPORTER=otlp " + "and point TRACER_URL to your Zipkin OTLP gRPC endpoint (default: :4317)") - exporter, err = buildZipkinExporter(a.Logger(), url, host, port, headers) + exporter, err = buildZipkinExporter(a.Logger(), endpoint, host, port, headers) case gofrTraceExporter: - exporter = buildGoFrExporter(a.Logger(), url) + exporter = buildGoFrExporter(a.Logger(), endpoint) default: a.container.Errorf("unsupported TRACE_EXPORTER=%s: expected one of otlp, jaeger, zipkin or gofr", redactExporterName(name)) @@ -266,7 +266,7 @@ type otlpTransport struct { // exporter hardcoded WithInsecure(). Defaulting a schemeless endpoint to TLS // would break all of them silently in a minor release, so traces default a // schemeless endpoint to plaintext and TRACER_INSECURE=false is the opt-in. -func resolveOtlpTransport(logger logging.Logger, url string, insecure, insecureSet bool) otlpTransport { +func resolveOtlpTransport(logger logging.Logger, endpoint string, insecure, insecureSet bool) otlpTransport { const ( schemeHTTP = "http://" schemeHTTPS = "https://" @@ -275,12 +275,12 @@ func resolveOtlpTransport(logger logging.Logger, url string, insecure, insecureS // Scheme comparison is case-insensitive per RFC 3986 §3.1, and url.Parse // inside WithEndpointURL treats it that way — so HTTPS://host:4317 must not // fall through to WithEndpoint, where it would be an invalid gRPC target. - scheme := strings.ToLower(url) + scheme := strings.ToLower(endpoint) if strings.HasPrefix(scheme, schemeHTTP) || strings.HasPrefix(scheme, schemeHTTPS) { if insecureSet { logger.Warnf("TRACER_INSECURE is ignored for TRACER_URL=%q: transport security is derived "+ - "from the URL scheme", redactURL(url)) + "from the URL scheme", redactURL(endpoint)) } return otlpTransport{useEndpointURL: true, plaintext: strings.HasPrefix(scheme, schemeHTTP)} @@ -291,27 +291,27 @@ func resolveOtlpTransport(logger logging.Logger, url string, insecure, insecureS // buildOpenTelemetryProtocol using OpenTelemetryProtocol as the trace exporter // jaeger accept OpenTelemetry Protocol (OTLP) over gRPC to upload trace data. -func buildOtlpExporter(logger logging.Logger, name, url, host, port string, headers map[string]string, +func buildOtlpExporter(logger logging.Logger, name, endpoint, host, port string, headers map[string]string, insecure, insecureSet bool) (sdktrace.SpanExporter, error) { - if url == "" { - url = fmt.Sprintf("%s:%s", host, port) + if endpoint == "" { + endpoint = fmt.Sprintf("%s:%s", host, port) } - transport := resolveOtlpTransport(logger, url, insecure, insecureSet) + transport := resolveOtlpTransport(logger, endpoint, insecure, insecureSet) if transport.plaintext && len(headers) > 0 { logger.Warnf("traces are exported to %s over plaintext with headers configured: "+ - "headers (including auth credentials) will be sent in the clear", redactURL(url)) + "headers (including auth credentials) will be sent in the clear", redactURL(endpoint)) } - logger.Infof("Exporting traces to %s at %s", name, redactURL(url)) + logger.Infof("Exporting traces to %s at %s", name, redactURL(endpoint)) var opts []otlptracegrpc.Option if transport.useEndpointURL { - opts = append(opts, otlptracegrpc.WithEndpointURL(url)) + opts = append(opts, otlptracegrpc.WithEndpointURL(endpoint)) } else { - opts = append(opts, otlptracegrpc.WithEndpoint(url)) + opts = append(opts, otlptracegrpc.WithEndpoint(endpoint)) if transport.insecure { opts = append(opts, otlptracegrpc.WithInsecure()) @@ -325,29 +325,29 @@ func buildOtlpExporter(logger logging.Logger, name, url, host, port string, head return otlptracegrpc.New(context.Background(), opts...) } -func buildZipkinExporter(logger logging.Logger, url, host, port string, headers map[string]string) (sdktrace.SpanExporter, error) { - if url == "" { - url = fmt.Sprintf("http://%s:%s/api/v2/spans", host, port) +func buildZipkinExporter(logger logging.Logger, endpoint, host, port string, headers map[string]string) (sdktrace.SpanExporter, error) { + if endpoint == "" { + endpoint = fmt.Sprintf("http://%s:%s/api/v2/spans", host, port) } - logger.Infof("Exporting traces to zipkin at %s", redactURL(url)) + logger.Infof("Exporting traces to zipkin at %s", redactURL(endpoint)) var opts []zipkin.Option if len(headers) > 0 { opts = append(opts, zipkin.WithHeaders(headers)) } - return zipkin.New(url, opts...) + return zipkin.New(endpoint, opts...) } -func buildGoFrExporter(logger logging.Logger, url string) sdktrace.SpanExporter { - if url == "" { - url = "https://tracer-api.gofr.dev/api/spans" +func buildGoFrExporter(logger logging.Logger, endpoint string) sdktrace.SpanExporter { + if endpoint == "" { + endpoint = "https://tracer-api.gofr.dev/api/spans" } - logger.Infof("Exporting traces to GoFr at %s", redactURL(url)) + logger.Infof("Exporting traces to GoFr at %s", redactURL(endpoint)) - return NewExporter(url, logging.NewLogger(logging.INFO)) + return NewExporter(endpoint, logging.NewLogger(logging.INFO)) } // redactedPlaceholder stands in for credentials when a tracer endpoint is logged.