From ea5c8544f4a407ad00ef8010a7916931e07b332d Mon Sep 17 00:00:00 2001 From: akvlad Date: Tue, 8 Oct 2024 21:38:44 +0300 Subject: [PATCH] longtest; docker compose test env --- .gitignore | 2 + promql/index.js | 4 +- test/qryn_test_env/docker-compose.yaml | 118 ++ .../dashboards/11159_rev1_custom.json | 1047 +++++++++++++++++ .../provisioning/dashboards/default.yaml | 8 + .../provisioning/datasources/datasource.yml | 80 ++ test/qryn_test_env/longtest/README.md | 26 + test/qryn_test_env/longtest/common.go | 7 + test/qryn_test_env/longtest/datadogSender.go | 132 +++ test/qryn_test_env/longtest/generate.go | 87 ++ test/qryn_test_env/longtest/genericSender.go | 191 +++ test/qryn_test_env/longtest/go.mod | 50 + test/qryn_test_env/longtest/go.sum | 512 ++++++++ test/qryn_test_env/longtest/influxSender.go | 51 + .../longtest/jsonConsistencyChecker.go | 45 + test/qryn_test_env/longtest/logReader.go | 103 ++ test/qryn_test_env/longtest/logSender.go | 54 + test/qryn_test_env/longtest/longtest.go | 188 +++ test/qryn_test_env/longtest/metricReader.go | 1 + test/qryn_test_env/longtest/metricSender.go | 94 ++ test/qryn_test_env/longtest/otlpSender.go | 132 +++ test/qryn_test_env/longtest/pqtSender.go | 59 + test/qryn_test_env/longtest/sendStats.go | 99 ++ .../longtest/serviceGraphSender.go | 95 ++ test/qryn_test_env/longtest/stats.go | 24 + test/qryn_test_env/longtest/timerSender.go | 48 + test/qryn_test_env/longtest/zipkinSender.go | 72 ++ .../otel/otel-collector-config.yaml | 116 ++ 28 files changed, 3444 insertions(+), 1 deletion(-) create mode 100644 test/qryn_test_env/docker-compose.yaml create mode 100644 test/qryn_test_env/grafana/provisioning/dashboards/11159_rev1_custom.json create mode 100644 test/qryn_test_env/grafana/provisioning/dashboards/default.yaml create mode 100644 test/qryn_test_env/grafana/provisioning/datasources/datasource.yml create mode 100644 test/qryn_test_env/longtest/README.md create mode 100644 test/qryn_test_env/longtest/common.go create mode 100644 test/qryn_test_env/longtest/datadogSender.go create mode 100644 test/qryn_test_env/longtest/generate.go create mode 100644 test/qryn_test_env/longtest/genericSender.go create mode 100644 test/qryn_test_env/longtest/go.mod create mode 100644 test/qryn_test_env/longtest/go.sum create mode 100644 test/qryn_test_env/longtest/influxSender.go create mode 100644 test/qryn_test_env/longtest/jsonConsistencyChecker.go create mode 100644 test/qryn_test_env/longtest/logReader.go create mode 100644 test/qryn_test_env/longtest/logSender.go create mode 100644 test/qryn_test_env/longtest/longtest.go create mode 100644 test/qryn_test_env/longtest/metricReader.go create mode 100644 test/qryn_test_env/longtest/metricSender.go create mode 100644 test/qryn_test_env/longtest/otlpSender.go create mode 100644 test/qryn_test_env/longtest/pqtSender.go create mode 100644 test/qryn_test_env/longtest/sendStats.go create mode 100644 test/qryn_test_env/longtest/serviceGraphSender.go create mode 100644 test/qryn_test_env/longtest/stats.go create mode 100644 test/qryn_test_env/longtest/timerSender.go create mode 100644 test/qryn_test_env/longtest/zipkinSender.go create mode 100644 test/qryn_test_env/otel/otel-collector-config.yaml diff --git a/.gitignore b/.gitignore index c2bb70cb..e23f35f9 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,5 @@ node_modules /wasm_parts/vendor/ /wasm_parts/main.wasm /wasm_parts/wasm_parts.iml +/test/qryn_test_env/clickhouse/_data/ +/test/qryn_test_env/grafana/_data/ diff --git a/promql/index.js b/promql/index.js index 8bda90ab..4692c4ce 100644 --- a/promql/index.js +++ b/promql/index.js @@ -61,7 +61,9 @@ module.exports.series = async (query, fromMs, toMs) => { const data = await rawRequest(req.toString() + ' FORMAT JSON', null, DATABASE_NAME()) - return data.data.data.map(l => JSON.parse(l.labels)) + return data.data.data.map(l => + Object.fromEntries(Object.entries(JSON.parse(l.labels)).filter(e => e[1])) + ) } catch (e) { if (e instanceof prometheus.WasmError) { throw new PSQLError(e.message) diff --git a/test/qryn_test_env/docker-compose.yaml b/test/qryn_test_env/docker-compose.yaml new file mode 100644 index 00000000..f843eae3 --- /dev/null +++ b/test/qryn_test_env/docker-compose.yaml @@ -0,0 +1,118 @@ +version: '2.1' + +networks: + qryn-test: + driver: bridge + +services: + grafana: + image: grafana/grafana:11.1.0 + container_name: grafana + user: root + networks: + - qryn-test + volumes: + - ./grafana/_data:/var/lib/grafana:rw + - ./grafana/provisioning/:/etc/grafana/provisioning/ + environment: + - GF_SECURITY_ADMIN_USER=${ADMIN_USER:-admin} + - GF_SECURITY_ADMIN_PASSWORD=${ADMIN_PASSWORD:-admin} + - GF_USERS_ALLOW_SIGN_UP=false + - GF_USERS_DEFAULT_THEME=light + - GF_EXPLORE_ENABLED=true + - GF_ALERTING_ENABLED=false + - GF_UNIFIED_ALERTING_ENABLED=true + - GF_FEATURE_TOGGLES_ENABLE=traceToMetrics,publicDashboards,tempoApmTable + - GF_INSTALL_PLUGINS=grafana-pyroscope-app,https://storage.googleapis.com/integration-artifacts/grafana-lokiexplore-app/grafana-lokiexplore-app-latest.zip;grafana-lokiexplore-app + restart: unless-stopped + ports: + - 3000:3000 + depends_on: + - qryn + + clickhouse-server: + image: clickhouse/clickhouse-server:24.1 + container_name: clickhouse-server + hostname: clickhouse + restart: unless-stopped + volumes: + - ./clickhouse/_data:/var/lib/clickhouse + networks: + - qryn-test + environment: + - CLICKHOUSE_USER=qryn + - CLICKHOUSE_PASSWORD=demo + ports: + - 8123:8123 + - 9000:9000 + healthcheck: + test: ['CMD', 'wget', '--spider', '-q', '127.0.0.1:8123/ping'] + interval: 1s + timeout: 1s + retries: 30 + + qryn: + image: node:22 + container_name: qryn + hostname: qryn + restart: unless-stopped + volumes: + - ../../:/app + networks: + - qryn-test + expose: + - 3100 + ports: + - "3100:3100" + environment: + - CLICKHOUSE_SERVER=clickhouse-server + - CLICKHOUSE_PORT=8123 + - CLICKHOUSE_AUTH=qryn:demo + - CLICKHOUSE_DB=qryn + - NODE_OPTIONS="--max-old-space-size=4096" + - FASTIFY_METRICS=true + working_dir: /app + command: ["qryn.mjs"] + depends_on: + clickhouse-server: + condition: service_healthy + + longtest: + image: golang:1.22-alpine + volumes: + - ./longtest:/longtest + working_dir: /longtest + environment: + MODE: LMZ + URL: http://qryn:3100 + command: ["go", "run", "."] + networks: + - qryn-test + depends_on: + - qryn + + otel-collector: + container_name: otel-collector + hostname: otel-collector + image: ghcr.io/metrico/qryn-otel-collector:0.0.5 + networks: + - qryn-test + volumes: + - ./otel/otel-collector-config.yaml:/etc/otel/config.yaml + ports: + - "3200:3100" # Loki/Logql HTTP receiver + - "3201:3200" # Loki/Logql gRPC receiver + - "8088:8088" # Splunk HEC receiver + - "5514:5514" # Syslog TCP Rereceiverceiver + - "24224:24224" # Fluent Forward receiver + - "4317:4317" # OTLP gRPC receiver + - "4318:4318" # OTLP HTTP receiver + - "14250:14250" # Jaeger gRPC receiver + - "14268:14268" # Jaeger thrift HTTP receiver + - "9411:9411" # Zipkin Trace receiver + - "11800:11800" # Skywalking gRPC receiver + - "12800:12800" # Skywalking HTTP receiver + - "8086:8086" # InfluxDB Line proto HTTP + - "8062:8062" # Pyroscope jprof + restart: on-failure + diff --git a/test/qryn_test_env/grafana/provisioning/dashboards/11159_rev1_custom.json b/test/qryn_test_env/grafana/provisioning/dashboards/11159_rev1_custom.json new file mode 100644 index 00000000..27cbd5bd --- /dev/null +++ b/test/qryn_test_env/grafana/provisioning/dashboards/11159_rev1_custom.json @@ -0,0 +1,1047 @@ +{ + "annotations": { + "list": [ + { + "builtIn": 1, + "datasource": { + "type": "datasource", + "uid": "grafana" + }, + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "description": "node.js prometheus client basic metrics", + "editable": true, + "fiscalYearStartMonth": 0, + "gnetId": 11159, + "graphTooltip": 0, + "id": 6, + "links": [], + "liveNow": false, + "panels": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "percent" + }, + "overrides": [] + }, + "gridPos": { + "h": 7, + "w": 10, + "x": 0, + "y": 0 + }, + "id": 6, + "links": [], + "options": { + "legend": { + "calcs": [ + "mean", + "lastNotNull", + "max", + "min" + ], + "displayMode": "table", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "multi", + "sort": "none" + } + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "expr": "irate(process_cpu_user_seconds_total{instance=~\"$instance\"}[2m]) * 100", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "User CPU - {{instance}}", + "refId": "A" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "expr": "irate(process_cpu_system_seconds_total{instance=~\"$instance\"}[2m]) * 100", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "Sys CPU - {{instance}}", + "refId": "B" + } + ], + "title": "Process CPU Usage", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "s" + }, + "overrides": [] + }, + "gridPos": { + "h": 7, + "w": 9, + "x": 10, + "y": 0 + }, + "id": 8, + "links": [], + "options": { + "legend": { + "calcs": [ + "mean", + "lastNotNull", + "max", + "min" + ], + "displayMode": "table", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "multi", + "sort": "none" + } + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "expr": "nodejs_eventloop_lag_seconds{instance=~\"$instance\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "{{instance}}", + "refId": "A" + } + ], + "title": "Event Loop Lag", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "mappings": [ + { + "options": { + "match": "null", + "result": { + "text": "N/A" + } + }, + "type": "special" + } + ], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "none" + }, + "overrides": [] + }, + "gridPos": { + "h": 3, + "w": 5, + "x": 19, + "y": 0 + }, + "id": 2, + "interval": "", + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "none", + "graphMode": "none", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "mean" + ], + "fields": "/^__name__$/", + "values": false + }, + "textMode": "name", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "expr": "sum(nodejs_version_info{instance=~\"$instance\"}) by (version)", + "format": "time_series", + "instant": false, + "interval": "", + "intervalFactor": 1, + "legendFormat": "{{version}}", + "refId": "A" + } + ], + "title": "Node.js Version", + "type": "stat" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "fixedColor": "#F2495C", + "mode": "fixed" + }, + "mappings": [ + { + "options": { + "match": "null", + "result": { + "text": "N/A" + } + }, + "type": "special" + } + ], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "none" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 5, + "x": 19, + "y": 3 + }, + "id": 4, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "none", + "graphMode": "area", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "expr": "sum(changes(process_start_time_seconds{instance=~\"$instance\"}[1m]))", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "{{instance}}", + "refId": "A" + } + ], + "title": "Process Restart Times", + "type": "stat" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "bytes" + }, + "overrides": [] + }, + "gridPos": { + "h": 7, + "w": 16, + "x": 0, + "y": 7 + }, + "id": 7, + "links": [], + "options": { + "legend": { + "calcs": [ + "mean", + "lastNotNull", + "max", + "min" + ], + "displayMode": "table", + "placement": "right", + "showLegend": true + }, + "tooltip": { + "mode": "multi", + "sort": "none" + } + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "expr": "process_resident_memory_bytes{instance=~\"$instance\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "Process Memory - {{instance}}", + "refId": "A" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "expr": "nodejs_heap_size_total_bytes{instance=~\"$instance\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "Heap Total - {{instance}}", + "refId": "B" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "expr": "nodejs_heap_size_used_bytes{instance=~\"$instance\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "Heap Used - {{instance}}", + "refId": "C" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "expr": "nodejs_external_memory_bytes{instance=~\"$instance\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "External Memory - {{instance}}", + "refId": "D" + } + ], + "title": "Process Memory Usage", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "short" + }, + "overrides": [] + }, + "gridPos": { + "h": 7, + "w": 8, + "x": 16, + "y": 7 + }, + "id": 9, + "links": [], + "options": { + "legend": { + "calcs": [ + "mean", + "lastNotNull", + "max", + "min" + ], + "displayMode": "table", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "multi", + "sort": "none" + } + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "expr": "nodejs_active_handles_total{instance=~\"$instance\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "Active Handler - {{instance}}", + "refId": "A" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "expr": "nodejs_active_requests_total{instance=~\"$instance\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "Active Request - {{instance}}", + "refId": "B" + } + ], + "title": "Active Handlers/Requests Total", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "bytes" + }, + "overrides": [] + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 0, + "y": 14 + }, + "id": 10, + "links": [], + "options": { + "legend": { + "calcs": [ + "mean", + "lastNotNull", + "max", + "min" + ], + "displayMode": "table", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "multi", + "sort": "none" + } + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "expr": "nodejs_heap_space_size_total_bytes{instance=~\"$instance\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "Heap Total - {{instance}} - {{space}}", + "refId": "A" + } + ], + "title": "Heap Total Detail", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "bytes" + }, + "overrides": [] + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 8, + "y": 14 + }, + "id": 11, + "links": [], + "options": { + "legend": { + "calcs": [ + "mean", + "lastNotNull", + "max", + "min" + ], + "displayMode": "table", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "multi", + "sort": "none" + } + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "expr": "nodejs_heap_space_size_used_bytes{instance=~\"$instance\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "Heap Used - {{instance}} - {{space}}", + "refId": "A" + } + ], + "title": "Heap Used Detail", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "bytes" + }, + "overrides": [] + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 16, + "y": 14 + }, + "id": 12, + "links": [], + "options": { + "legend": { + "calcs": [ + "mean", + "lastNotNull", + "max", + "min" + ], + "displayMode": "table", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "multi", + "sort": "none" + } + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "expr": "nodejs_heap_space_size_available_bytes{instance=~\"$instance\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "Heap Used - {{instance}} - {{space}}", + "refId": "A" + } + ], + "title": "Heap Available Detail", + "type": "timeseries" + } + ], + "refresh": "", + "schemaVersion": 38, + "tags": [ + "nodejs" + ], + "templating": { + "list": [ + { + "current": { + "selected": false, + "text": "Prometheus", + "value": "prometheus" + }, + "hide": 0, + "includeAll": false, + "label": "Datasource", + "multi": false, + "name": "DS_PROMETHEUS", + "options": [], + "query": "prometheus", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "type": "datasource" + }, + { + "current": { + "selected": false, + "text": "All", + "value": "$__all" + }, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "definition": "label_values(nodejs_version_info, instance)", + "hide": 0, + "includeAll": true, + "label": "instance", + "multi": true, + "name": "instance", + "options": [], + "query": "label_values(nodejs_version_info, instance)", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 1, + "tagValuesQuery": "", + "tagsQuery": "", + "type": "query", + "useTags": false + } + ] + }, + "time": { + "from": "now-1h", + "to": "now" + }, + "timepicker": { + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ], + "time_options": [ + "5m", + "15m", + "1h", + "6h", + "12h", + "24h", + "2d", + "7d", + "30d" + ] + }, + "timezone": "", + "title": "NodeJS Application Dashboard", + "uid": "PTSqcpJWk1", + "version": 3, + "weekStart": "" +} \ No newline at end of file diff --git a/test/qryn_test_env/grafana/provisioning/dashboards/default.yaml b/test/qryn_test_env/grafana/provisioning/dashboards/default.yaml new file mode 100644 index 00000000..7c4d0dd5 --- /dev/null +++ b/test/qryn_test_env/grafana/provisioning/dashboards/default.yaml @@ -0,0 +1,8 @@ +apiVersion: 1 + +providers: + - name: Qryn NodeJS Application Dashboard + folder: Services + type: file + options: + path: /etc/grafana/provisioning/dashboards/11159_rev1_custom.json \ No newline at end of file diff --git a/test/qryn_test_env/grafana/provisioning/datasources/datasource.yml b/test/qryn_test_env/grafana/provisioning/datasources/datasource.yml new file mode 100644 index 00000000..8902c532 --- /dev/null +++ b/test/qryn_test_env/grafana/provisioning/datasources/datasource.yml @@ -0,0 +1,80 @@ +# config file version +apiVersion: 1 + +deleteDatasources: + - name: Loki + orgId: 1 + - name: Tempo + orgId: 1 + - name: Prometheus + orgId: 1 + - name: Pyroscope + orgId: 1 + +datasources: + - name: Loki + type: loki + access: proxy + uid: loki + url: http://qryn:3100 + editable: true + jsonData: + derivedFields: + - datasourceUid: tempo + matcherRegex: "^.*?traceI[d|D]=(\\w+).*$" + name: traceId + url: '$${__value.raw}' + - datasourceUid: tempo + matcherRegex: "^.*?\"traceID\":\"(\\w+)\".*$" + name: traceID + url: '$${__value.raw}' + - name: Tempo + type: tempo + access: proxy + uid: tempo + url: http://qryn:3100 + editable: true + jsonData: + nodeGraph: + enabled: true + tracesToLogs: + datasourceUid: loki + filterByTraceID: false + spanEndTimeShift: "2000ms" + spanStartTimeShift: "-2000ms" + tags: ['job'] + tracesToMetrics: + datasourceUid: prometheus + tags: ['job'] + serviceMap: + datasourceUid: prometheus + lokiSearch: + datasourceUid: loki + - name: Prometheus + type: prometheus + access: proxy + uid: prometheus + url: http://qryn:3100 + editable: true + basicAuth: false + jsonData: + httpMethod: GET + graphiteVersion: "1.1" + tlsAuth: false + tlsAuthWithCACert: false + cacheLevel: 'High' + incrementalQuerying: 'Enable' + incrementalQueryOverlapWindow: 2m + - name: Pyroscope + uid: pyroscope + type: grafana-pyroscope-datasource + version: 2 + access: proxy + url: http://qryn:3100 + basicAuth: false + basicAuthUser: "" + withCredentials: false + isDefault: false + readOnly: false + # secureJsonData: + # apiKey: {YOUR_API_KEY} diff --git a/test/qryn_test_env/longtest/README.md b/test/qryn_test_env/longtest/README.md new file mode 100644 index 00000000..2e68e484 --- /dev/null +++ b/test/qryn_test_env/longtest/README.md @@ -0,0 +1,26 @@ +# gigaswap - long test + +long-term test of qryn endpoint +It sends +- 3000 logs/sec +- 3000 influx logs / sec +- 300 zipkin traces/sec +- 300 datadog traces/sec with variable amount of spans +- 5K of metrics / 15 sec + +depending on the MODE until you stop it. + +# Usage + +- go build -o longtest +- URL='' MODE= ZPATH=/path/for/zipkin DPATH=/path/for/datadog ./longtest + +## MODE LIST + +- L - for loki logs +- M - for metrics remote-write +- Z - for zipkin traces +- D - for datadog traces +- I - for influx logs +- C - for a lot of small simultaneous loki log request to check batching +- S - for servicegraph testing diff --git a/test/qryn_test_env/longtest/common.go b/test/qryn_test_env/longtest/common.go new file mode 100644 index 00000000..3a9ec37d --- /dev/null +++ b/test/qryn_test_env/longtest/common.go @@ -0,0 +1,7 @@ +package main + +import "math/rand" + +func pickRandom[T any](arr []T, rnd *rand.Rand) T { + return arr[rnd.Intn(len(arr))] +} diff --git a/test/qryn_test_env/longtest/datadogSender.go b/test/qryn_test_env/longtest/datadogSender.go new file mode 100644 index 00000000..5a048cb5 --- /dev/null +++ b/test/qryn_test_env/longtest/datadogSender.go @@ -0,0 +1,132 @@ +package main + +import ( + "encoding/json" + "fmt" + "math/rand" + "os" + "time" +) + +// https://docs.datadoghq.com/tracing/guide/send_traces_to_agent_by_api/#model +type DataDogModel struct { + Duration int64 `json:"duration"` + Error int32 `json:"error"` + Meta map[string]string `json:"meta"` + Metrics map[string]float64 `json:"metrics"` + Name string `json:"name"` + ParentID int64 `json:"parent_id"` + Resource string `json:"resource"` + Service string `json:"service"` + SpanID int64 `json:"span_id"` + Start int64 `json:"start"` + TraceID int64 `json:"trace_id"` + Type DataDogModelEnum `json:"type"` +} + +type DataDogModelEnum string + +func (d DataDogModelEnum) String() string { + return string(d) +} + +const ( + DataDogModelEnumWeb DataDogModelEnum = "web" + DataDogModelEnumDb DataDogModelEnum = "db" + DataDogModelEnumCache DataDogModelEnum = "cache" + DataDogModelEnumCustom DataDogModelEnum = "custom" +) + +type DatadogReq [][]DataDogModel + +func (d DatadogReq) Serialize() ([]byte, error) { + return json.Marshal(d) +} + +func NewDatadogSender(opts LogSenderOpts) ISender { + rnd := rand.New(rand.NewSource(time.Now().UnixNano())) + path := "/v0.3/traces" + if os.Getenv("DPATH") != "" { + path = os.Getenv("DPATH") + } + l := &GenericSender{ + LogSenderOpts: opts, + rnd: rnd, + timeout: time.Second, + path: path, + } + pickCont := func() string { + return l.pickRandom(opts.Containers) + } + l.generate = func() IRequest { + + var ( + spansPerTrace int = 3 + traces int = 0 + remainder int = 0 + ) + + // if the total is less than the spans per trace, we only do those. + if opts.LinesPS < spansPerTrace { + remainder = opts.LinesPS + } else { + traces = opts.LinesPS / spansPerTrace + remainder = opts.LinesPS % spansPerTrace + } + + // make sure we always have an array with the correct amount of slots. + arrayLength := traces + if remainder != 0 { + arrayLength++ + } + + // initiate the main container + req := make(DatadogReq, arrayLength) + // add the traces that fit + for i := 0; i < traces; i++ { + req[i] = trace(i, spansPerTrace, rnd, pickCont) + } + + // add a last trace with the remaining spans. + if remainder != 0 { + req[traces] = trace(traces, remainder, rnd, pickCont) + } + + return req + } + return l +} + +func trace(i int, spans int, rnd *rand.Rand, pickCont func() string) []DataDogModel { + var ( + traceID = rnd.Int63n(10000000) + tr = make([]DataDogModel, spans) + ) + + for j := 0; j < spans; j++ { + cont := pickCont() + now := time.Now() + + tr[j] = DataDogModel{ + Duration: time.Duration(1 * (i + 1)).Nanoseconds(), + Error: 0, + Meta: map[string]string{ + "sender": "longtest", + "randomContainer": cont, + }, + Metrics: map[string]float64{ + REQ_BYTES: rnd.Float64(), + }, + Name: fmt.Sprintf("longtest-%d-%d", i+1, j+1), + ParentID: 0, + Resource: "/", + Service: "longtest", + SpanID: int64((i + 1) * (j + 1)), + Start: now.UnixNano(), + TraceID: traceID, + Type: DataDogModelEnumWeb, + } + } + + return tr +} diff --git a/test/qryn_test_env/longtest/generate.go b/test/qryn_test_env/longtest/generate.go new file mode 100644 index 00000000..c4698e51 --- /dev/null +++ b/test/qryn_test_env/longtest/generate.go @@ -0,0 +1,87 @@ +package main + +import ( + "bytes" + "fmt" + "github.com/akvlad/flog/generator" + "github.com/scaleway/scaleway-sdk-go/namegenerator" + "strconv" + "sync" + "time" +) + +type bufCloser struct { + *bytes.Buffer +} + +func (*bufCloser) Close() error { + return nil +} + +func generateLogs() []string { + var res []string + writers := make([]bytes.Buffer, 8) + wg := sync.WaitGroup{} + for i, format := range []string{"apache_common", "apache_combined", "apache_error", "rfc3164", "rfc5424", + "common_log", "json"} { + wg.Add(1) + go func(format string, i int) { + defer wg.Done() + generator.Generate(&generator.Option{ + Format: format, + Output: "", + Type: "stdout", + Number: 0, + Bytes: 10 * 1024 * 1024, + Sleep: 0, + Delay: 0, + SplitBy: 0, + Overwrite: false, + Forever: false, + Writer: &bufCloser{&writers[i]}, + }) + }(format, i) + } + generateFaro(&writers[7]) + wg.Wait() + for _, w := range writers { + lines := bytes.Split(w.Bytes(), []byte("\n")) + for _, l := range lines { + res = append(res, string(l)) + } + } + return res +} + +func generateFaro(buf *bytes.Buffer) { + _buf := bytes.Buffer{} + + generator.Generate(&generator.Option{ + Format: "common_log", + Output: "", + Type: "stdout", + Number: 0, + Bytes: 10 * 1024 * 1024, + Sleep: 0, + Delay: 0, + SplitBy: 0, + Overwrite: false, + Forever: false, + Writer: &bufCloser{&_buf}, + }) + + lines := bytes.Split(_buf.Bytes(), []byte("\n")) + for _, l := range lines { + buf.WriteString(fmt.Sprintf( + "timestamp=\"%s\" kind=log message=%s level=log sdk_name=@grafana/faro-core sdk_version=1.0.0 sdk_integrations=@grafana/faro-web-sdk:instrumentation-errors:1.0.0,@grafana/faro-web-sdk:instrumentation-web-vitals:1.0.0,@grafana/faro-web-sdk:instrumentation-session:1.0.32,@grafana/faro-web-sdk:instrumentation-view:1.0.32,@grafana/faro-web-sdk:instrumentation-console:1.0.0,@grafana/faro-web-tracing:1.0.0,@grafana/faro-react:1.0.0 app_name=@grafana/faro-demo-client app_version=1.0.0 app_environment=production session_id=fDKz3Gccz6 page_url=http://localhost:5173/ browser_name=Firefox browser_version=122.0 browser_os=\"Ubuntu unknown\" browser_mobile=false view_name=default\n", + time.Now().UTC().Format(time.RFC3339Nano), strconv.Quote(string(l)))) + } +} + +func generateNames(n int) []string { + names := make([]string, n) + for i := range names { + names[i] = namegenerator.GetRandomName() + } + return names +} diff --git a/test/qryn_test_env/longtest/genericSender.go b/test/qryn_test_env/longtest/genericSender.go new file mode 100644 index 00000000..3f9d98f8 --- /dev/null +++ b/test/qryn_test_env/longtest/genericSender.go @@ -0,0 +1,191 @@ +package main + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "math/rand" + "net/http" + "sync" + "time" +) + +const ( + REQ_OK = "req_ok" + REQ_ERR = "req_err" + REQ_FAIL = "req_fail" + REQ_BYTES = "req_bytes" + REQ_TIME_MS = "req_time_ms" +) + +type IRequest interface { + Serialize() ([]byte, error) +} + +type LogStream struct { + Stream map[string]string `json:"stream"` + Values [][]interface{} `json:"values"` +} + +type LogRequest struct { + Streams []*LogStream `json:"streams"` +} + +func (l *LogRequest) Serialize() ([]byte, error) { + return json.Marshal(l) +} + +type ISender interface { + Run() + Stop() +} + +type LogSenderOpts struct { + Containers []string + Lines []string + LinesPS int + URL string + Headers map[string]string + ID string +} + +type GenericSender struct { + LogSenderOpts + mtx sync.Mutex + rnd *rand.Rand + ticker *time.Ticker + timeout time.Duration + path string + generate func() IRequest + numOfSends int +} + +func (l *GenericSender) Run() { + if l.ticker != nil { + return + } + l.ticker = time.NewTicker(l.timeout) + go func() { + for range l.ticker.C { + if l.generate == nil { + fmt.Println("ERROR! No generate function") + } + numOfSends := l.numOfSends + if numOfSends == 0 { + numOfSends = 1 + } + for i := 0; i < numOfSends; i++ { + err := l.send(l.generate()) + if err != nil { + fmt.Printf("%v\n", err) + continue + } + } + } + }() +} + +func (l *GenericSender) Stop() { + if l.ticker != nil { + l.ticker.Stop() + l.ticker = nil + } +} + +func (l *GenericSender) random(n int) int { + l.mtx.Lock() + defer l.mtx.Unlock() + return l.rnd.Intn(n) +} + +func (l *GenericSender) pickRandom(array []string) string { + if len(array) == 0 { + return "" + } + l.mtx.Lock() + defer l.mtx.Unlock() + return pickRandom[string](array, l.rnd) +} + +func (l *GenericSender) send(request IRequest) error { + retries := 0 + body, err := request.Serialize() + if err != nil { + return err + } + send := func(url string, count bool) { + if url == "" { + url = l.URL + l.path + } + var statsInc = func(name string) { + if count { + stats.Inc(name) + } + } + var statsObserve = func(name string, value int64) { + if count { + stats.Observe(name, value) + } + } + for { + start := time.Now() + req, err := http.NewRequest("POST", url, bytes.NewReader(body)) + if err != nil { + fmt.Printf("Request error: %v\n", err) + <-time.After(time.Second) + if retries < 10 { + statsInc(REQ_ERR) + retries++ + continue + } else { + statsInc(REQ_FAIL) + return + } + } + req.Header.Set("Content-Type", "application/json") + for k, v := range l.Headers { + req.Header.Set(k, v) + } + client := http.Client{ + Timeout: 30 * time.Second, + } + resp, err := client.Do(req) + if err != nil { + fmt.Printf("Request error: %v\n", err) + <-time.After(time.Second) + if retries < 10 { + statsInc(REQ_ERR) + retries++ + continue + } else { + statsInc(REQ_FAIL) + return + } + } + if resp.StatusCode/100 != 2 { + b := bytes.Buffer{} + io.Copy(&b, resp.Body) + fmt.Printf("Request error: [%d]: %s\n", resp.StatusCode, string(b.Bytes())) + <-time.After(time.Second) + if retries < 10 { + statsInc(REQ_ERR) + retries++ + continue + } else { + stats.Inc(REQ_FAIL) + return + } + } + statsInc(REQ_OK) + statsObserve(REQ_BYTES, int64(len(body))) + statsObserve(REQ_TIME_MS, time.Now().Sub(start).Milliseconds()) + return + } + } + go func() { + send("", true) + }() + + return nil +} diff --git a/test/qryn_test_env/longtest/go.mod b/test/qryn_test_env/longtest/go.mod new file mode 100644 index 00000000..d2412dfc --- /dev/null +++ b/test/qryn_test_env/longtest/go.mod @@ -0,0 +1,50 @@ +module longtest + +go 1.18 + +replace k8s.io/client-go v12.0.0+incompatible => k8s.io/client-go v0.22.1 + +require ( + github.com/akvlad/flog v0.4.4-0.20220607095327-09ef70e4099e + github.com/apache/arrow/go/v13 v13.0.0-20230607163259-9be7074f85d6 + github.com/golang/protobuf v1.5.2 + github.com/golang/snappy v0.0.4 + github.com/influxdata/influxdb-client-go/v2 v2.12.2 + github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf + github.com/openzipkin/zipkin-go v0.4.1 + github.com/prometheus/prometheus v0.42.0 + github.com/scaleway/scaleway-sdk-go v1.0.0-beta.13 + go.opentelemetry.io/proto/otlp v0.19.0 + google.golang.org/protobuf v1.33.0 +) + +require ( + github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c // indirect + github.com/andybalholm/brotli v1.0.4 // indirect + github.com/apache/thrift v0.16.0 // indirect + github.com/apapsch/go-jsonmerge/v2 v2.0.0 // indirect + github.com/brianvoe/gofakeit v3.18.0+incompatible // indirect + github.com/deepmap/oapi-codegen v1.12.4 // indirect + github.com/goccy/go-json v0.10.0 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/google/flatbuffers v23.1.21+incompatible // indirect + github.com/google/uuid v1.3.0 // indirect + github.com/klauspost/asmfmt v1.3.2 // indirect + github.com/klauspost/compress v1.15.15 // indirect + github.com/klauspost/cpuid/v2 v2.2.3 // indirect + github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8 // indirect + github.com/minio/c2goasm v0.0.0-20190812172519-36a3d3bbc4f3 // indirect + github.com/pierrec/lz4/v4 v4.1.17 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/zeebo/xxh3 v1.0.2 // indirect + golang.org/x/exp v0.0.0-20230206171751-46f607a40771 // indirect + golang.org/x/mod v0.8.0 // indirect + golang.org/x/net v0.7.0 // indirect + golang.org/x/sync v0.1.0 // indirect + golang.org/x/sys v0.5.0 // indirect + golang.org/x/text v0.7.0 // indirect + golang.org/x/tools v0.6.0 // indirect + golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect + google.golang.org/genproto v0.0.0-20230209215440-0dfe4f8abfcc // indirect + google.golang.org/grpc v1.53.0 // indirect +) diff --git a/test/qryn_test_env/longtest/go.sum b/test/qryn_test_env/longtest/go.sum new file mode 100644 index 00000000..c80b8df6 --- /dev/null +++ b/test/qryn_test_env/longtest/go.sum @@ -0,0 +1,512 @@ +bou.ke/monkey v1.0.1 h1:zEMLInw9xvNakzUUPjfS4Ds6jYPqCFx3m7bRmG5NH2U= +bou.ke/monkey v1.0.1/go.mod h1:FgHuK96Rv2Nlf+0u1OOVDpCMdsWyOFmeeketDHE7LIg= +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= +cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= +cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= +cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= +cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= +cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= +cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= +cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= +cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= +cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= +cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= +cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= +cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= +cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= +cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= +cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= +cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= +cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= +cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= +cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= +cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= +cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= +cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= +cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= +cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= +cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= +cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= +cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= +cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= +dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= +github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c h1:RGWPOewvKIROun94nF7v2cua9qP+thov/7M50KEoeSU= +github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c/go.mod h1:X0CRv0ky0k6m906ixxpzmDRLvX58TFUKS2eePweuyxk= +github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= +github.com/RaveNoX/go-jsoncommentstrip v1.0.0/go.mod h1:78ihd09MekBnJnxpICcwzCMzGrKSKYe4AqU6PDYYpjk= +github.com/akvlad/flog v0.4.4-0.20220607095327-09ef70e4099e h1:3AbWEyBxLZuELxe9FVBLrj97iqiST4FqXCNx0Afw8qA= +github.com/akvlad/flog v0.4.4-0.20220607095327-09ef70e4099e/go.mod h1:0mcqdrwr9BJQeJ4pPjTh4ENgp0+lJfybTYMjJGV2wM4= +github.com/andybalholm/brotli v1.0.4 h1:V7DdXeJtZscaqfNuAdSRuRFzuiKlHSC/Zh3zl9qY3JY= +github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig= +github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= +github.com/apache/arrow/go/v13 v13.0.0-20230607163259-9be7074f85d6 h1:vaX/XjM1MG7TMtkkESfs1B1/vIfvxSdFVwg/yM9rCho= +github.com/apache/arrow/go/v13 v13.0.0-20230607163259-9be7074f85d6/go.mod h1:W69eByFNO0ZR30q1/7Sr9d83zcVZmF2MiP3fFYAWJOc= +github.com/apache/thrift v0.16.0 h1:qEy6UW60iVOlUy+b9ZR0d5WzUWYGOo4HfopoyBaNmoY= +github.com/apache/thrift v0.16.0/go.mod h1:PHK3hniurgQaNMZYaCLEqXKsYK8upmhPbmdP2FXSqgU= +github.com/apapsch/go-jsonmerge/v2 v2.0.0 h1:axGnT1gRIfimI7gJifB699GoE/oq+F2MU7Dml6nw9rQ= +github.com/apapsch/go-jsonmerge/v2 v2.0.0/go.mod h1:lvDnEdqiQrp0O42VQGgmlKpxL1AP2+08jFMw88y4klk= +github.com/bmatcuk/doublestar v1.1.1/go.mod h1:UD6OnuiIn0yFxxA2le/rnRU1G4RaI4UvFv1sNto9p6w= +github.com/brianvoe/gofakeit v3.11.5+incompatible/go.mod h1:kfwdRA90vvNhPutZWfH7WPaDzUjz+CZFqG+rPkOjGOc= +github.com/brianvoe/gofakeit v3.18.0+incompatible h1:wDOmHc9DLG4nRjUVVaxA+CEglKOW72Y5+4WNxUIkjM8= +github.com/brianvoe/gofakeit v3.18.0+incompatible/go.mod h1:kfwdRA90vvNhPutZWfH7WPaDzUjz+CZFqG+rPkOjGOc= +github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= +github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= +github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= +github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= +github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= +github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/deepmap/oapi-codegen v1.12.4 h1:pPmn6qI9MuOtCz82WY2Xaw46EQjgvxednXXrP7g5Q2s= +github.com/deepmap/oapi-codegen v1.12.4/go.mod h1:3lgHGMu6myQ2vqbbTXH2H1o4eXFTGnFiDaOaKKl5yas= +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/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= +github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= +github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= +github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/goccy/go-json v0.10.0 h1:mXKd9Qw4NuzShiRlOXKews24ufknHO7gx30lsDyokKA= +github.com/goccy/go-json v0.10.0/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= +github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= +github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= +github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw= +github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM= +github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/flatbuffers v23.1.21+incompatible h1:bUqzx/MXCDxuS0hRJL2EfjyZL3uQrPbMocUa8zGqsTA= +github.com/google/flatbuffers v23.1.21+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= +github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= +github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= +github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= +github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +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/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0/go.mod h1:hgWBS7lorOAVIJEQMi4ZsPv9hVvWI6+ch50m39Pf2Ks= +github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/influxdata/influxdb-client-go/v2 v2.12.2 h1:uYABKdrEKlYm+++qfKdbgaHKBPmoWR5wpbmj6MBB/2g= +github.com/influxdata/influxdb-client-go/v2 v2.12.2/go.mod h1:YteV91FiQxRdccyJ2cHvj2f/5sq4y4Njqu1fQzsQCOU= +github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf h1:7JTmneyiNEwVBOHSjoMxiWAqB992atOeepeFYegn5RU= +github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo= +github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= +github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= +github.com/juju/gnuflag v0.0.0-20171113085948-2ce1bb71843d/go.mod h1:2PavIy+JPciBPrBUjwbNvtwB6RQlve+hkpll6QSNmOE= +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/klauspost/asmfmt v1.3.2 h1:4Ri7ox3EwapiOjCki+hw14RyKk201CN4rzyCJRFLpK4= +github.com/klauspost/asmfmt v1.3.2/go.mod h1:AG8TuvYojzulgDAMCnYn50l/5QV3Bs/tp6j0HLHbNSE= +github.com/klauspost/compress v1.15.15 h1:EF27CXIuDsYJ6mmvtBRlEuB2UVOqHG1tAXgZ7yIO+lw= +github.com/klauspost/compress v1.15.15/go.mod h1:ZcK2JAFqKOpnBlxcLsJzYfrS9X1akm9fHZNnD9+Vo/4= +github.com/klauspost/cpuid/v2 v2.2.3 h1:sxCkb+qR91z4vsqw4vGGZlDgPz3G7gjaLyK3V8y70BU= +github.com/klauspost/cpuid/v2 v2.2.3/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +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/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= +github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= +github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= +github.com/mingrammer/cfmt v1.0.0/go.mod h1:D2ZhJie9PURSfLSb+DB3l+aE32t+K7B596FI6rdm/pI= +github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8 h1:AMFGa4R4MiIpspGNG7Z948v4n35fFGB3RR3G/ry4FWs= +github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8/go.mod h1:mC1jAcsrzbxHt8iiaC+zU4b1ylILSosueou12R++wfY= +github.com/minio/c2goasm v0.0.0-20190812172519-36a3d3bbc4f3 h1:+n/aFZefKZp7spd8DFdX7uMikMLXX4oubIzJF4kv/wI= +github.com/minio/c2goasm v0.0.0-20190812172519-36a3d3bbc4f3/go.mod h1:RagcQ7I8IeTMnF8JTXieKnO4Z6JCsikNEzj0DwauVzE= +github.com/openzipkin/zipkin-go v0.4.1 h1:kNd/ST2yLLWhaWrkgchya40TJabe8Hioj9udfPcEO5A= +github.com/openzipkin/zipkin-go v0.4.1/go.mod h1:qY0VqDSN1pOBN94dBc6w2GJlWLiovAyg7Qt6/I9HecM= +github.com/pierrec/lz4/v4 v4.1.17 h1:kV4Ip+/hUBC+8T6+2EgburRtkE9ef4nbY3f4dFhGjMc= +github.com/pierrec/lz4/v4 v4.1.17/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= +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 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/prometheus v0.42.0 h1:G769v8covTkOiNckXFIwLx01XE04OE6Fr0JPA0oR2nI= +github.com/prometheus/prometheus v0.42.0/go.mod h1:Pfqb/MLnnR2KK+0vchiaH39jXxvLMBk+3lnIGP4N7Vk= +github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= +github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/scaleway/scaleway-sdk-go v1.0.0-beta.13 h1:n5J2K6g/kl/iT6mODjCoSoRBGQVmIG3aMtYbofi9kxc= +github.com/scaleway/scaleway-sdk-go v1.0.0-beta.13/go.mod h1:fCa7OJZ/9DRTnOKmxvT6pn+LPWUptQAmHF/SBJUGEcg= +github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/spf13/pflag v1.0.0/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= +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.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c= +github.com/stretchr/testify v1.2.1/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ= +github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0= +github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA= +go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= +go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= +go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= +go.opentelemetry.io/proto/otlp v0.19.0 h1:IVN6GR+mhC4s5yfcTbmzHYODqvWAp3ZedA2SJPI1Nnw= +go.opentelemetry.io/proto/otlp v0.19.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +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/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +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= +golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= +golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= +golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= +golang.org/x/exp v0.0.0-20230206171751-46f607a40771 h1:xP7rWLUr1e1n2xkK5YB4LI0hPEy3LJC6Wk+D4pGlOJg= +golang.org/x/exp v0.0.0-20230206171751-46f607a40771/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= +golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= +golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +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= +golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= +golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= +golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= +golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= +golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +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.8.0 h1:LUYupSeNrTNCGzR/hVBk2NHZO4hXcVaW1k4Qx7rjPx8= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +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-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +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-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/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-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g= +golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +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= +golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +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-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/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-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/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.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +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-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/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= +golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.0/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= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +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= +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= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= +golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.6.0 h1:BOw41kyTf3PuCW1pVQf8+Cyg8pMlkYB1oo9iJ6D/lKM= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +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= +golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 h1:H2TDz8ibqkAF6YGhCdN3jS9O0/s90v0rJh3X/OLHEUk= +golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +gonum.org/v1/gonum v0.12.0 h1:xKuo6hzt+gMav00meVPUlXwSdoEJP46BR+wdxQEFK2o= +google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= +google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= +google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= +google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= +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/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= +google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= +google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= +google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= +google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= +google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= +google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20230209215440-0dfe4f8abfcc h1:ijGwO+0vL2hJt5gaygqP2j6PfflOBrRot0IczKbmtio= +google.golang.org/genproto v0.0.0-20230209215440-0dfe4f8abfcc/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +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.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= +google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= +google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= +google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= +google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= +google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.53.0 h1:LAv2ds7cmFV/XTS3XG1NneeENYrXGmorPxsBbptIjNc= +google.golang.org/grpc v1.53.0/go.mod h1:OnIrk0ipVdj4N5d9IUoFUx72/VlD7+jUsHwZgwSMQpw= +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= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +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.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= +google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= +google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +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= +honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= +honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= +rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= +rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= diff --git a/test/qryn_test_env/longtest/influxSender.go b/test/qryn_test_env/longtest/influxSender.go new file mode 100644 index 00000000..3693e9fd --- /dev/null +++ b/test/qryn_test_env/longtest/influxSender.go @@ -0,0 +1,51 @@ +package main + +import ( + "bytes" + influx "github.com/influxdata/influxdb-client-go/v2" + "github.com/influxdata/influxdb-client-go/v2/api/write" + lp "github.com/influxdata/line-protocol" + "math/rand" + "time" +) + +type InfluxReq []*write.Point + +func (i InfluxReq) Serialize() ([]byte, error) { + var buffer bytes.Buffer + e := lp.NewEncoder(&buffer) + e.SetFieldTypeSupport(lp.UintSupport) + e.FailOnFieldErr(true) + e.SetPrecision(time.Nanosecond) + for _, item := range i { + _, err := e.Encode(item) + if err != nil { + return nil, err + } + } + return buffer.Bytes(), nil +} + +func NewInfluxSender(opts LogSenderOpts) ISender { + l := &GenericSender{ + LogSenderOpts: opts, + rnd: rand.New(rand.NewSource(time.Now().UnixNano())), + timeout: time.Second, + path: "/influx/api/v2/write", + } + l.generate = func() IRequest { + points := make(InfluxReq, opts.LinesPS) + for i := range points { + points[i] = influx.NewPoint("syslog", map[string]string{ + "container": l.pickRandom(l.Containers), + "level": l.pickRandom([]string{"info", "debug", "error"}), + "sender": "logtest", + "endpoint": "influx", + }, map[string]interface{}{ + "message": l.pickRandom(opts.Lines), + }, time.Now()) + } + return points + } + return l +} diff --git a/test/qryn_test_env/longtest/jsonConsistencyChecker.go b/test/qryn_test_env/longtest/jsonConsistencyChecker.go new file mode 100644 index 00000000..437f17a3 --- /dev/null +++ b/test/qryn_test_env/longtest/jsonConsistencyChecker.go @@ -0,0 +1,45 @@ +package main + +import ( + "encoding/json" + "fmt" + "math/rand" + "sync" + "time" +) + +func NewJSONConsistencyChecker(opts LogSenderOpts) ISender { + res := &GenericSender{ + LogSenderOpts: opts, + mtx: sync.Mutex{}, + rnd: rand.New(rand.NewSource(time.Now().UnixNano())), + timeout: time.Second, + path: "/loki/api/v1/push", + numOfSends: 10, + } + res.generate = func() IRequest { + logLen := 0 + req := &LogRequest{} + for logLen < 10 { + streamLen := 2 + stream := &LogStream{ + Stream: map[string]string{ + "container": res.pickRandom(res.Containers), + "level": res.pickRandom([]string{"info", "debug", "error"}), + "sender": "consistency-checker", + }, + Values: make([][]interface{}, streamLen), + } + for i := 0; i < streamLen; i++ { + t := fmt.Sprintf("%d", time.Now().UnixNano()) + line, _ := json.Marshal(stream.Stream) + line = append(line, []byte(", t="+t)...) + stream.Values[i] = []interface{}{t, string(line)} + logLen++ + } + req.Streams = append(req.Streams, stream) + } + return req + } + return res +} diff --git a/test/qryn_test_env/longtest/logReader.go b/test/qryn_test_env/longtest/logReader.go new file mode 100644 index 00000000..81dda4c6 --- /dev/null +++ b/test/qryn_test_env/longtest/logReader.go @@ -0,0 +1,103 @@ +package main + +import ( + "fmt" + "math/rand" + "sync" + "time" +) + +const ( + LOG_READ_MODE_RAW = 1 + LOG_READ_MODE_LRA = 2 + LOG_READ_MODE_AGG_OP = 3 + LOG_READ_MODE_UNWRAP = 4 + LOG_READ_MODE_UNWRAP_AGG_OP = 5 +) + +type LogReader struct { + Url string + mtx sync.Mutex + rand *rand.Rand +} + +func NewLogReader(url string) *LogReader { + return &LogReader{ + Url: url, + rand: rand.New(rand.NewSource(time.Now().UnixNano())), + } +} + +func (l *LogReader) ReadLogs(mode int) { + containers := l.getValues("container") + switch mode { + case LOG_READ_MODE_RAW: + l.rawRequest(containers) + break + case LOG_READ_MODE_LRA: + l.logRangeAggregationRequest(containers) + break + case LOG_READ_MODE_AGG_OP: + l.aggregationOperatorRequest(containers) + break + case LOG_READ_MODE_UNWRAP: + l.unwrapRequest(containers) + break + case LOG_READ_MODE_UNWRAP_AGG_OP: + l.unwrapAggregationOperatorRequest(containers) + break + } +} + +func (l *LogReader) rawRequest(containers []string) { + l.mtx.Lock() + cnt := pickRandom(containers, l.rand) + to := time.Now().UnixNano() - l.rand.Int63n(600000000000) + from := to - l.rand.Int63n(3600000000000) + l.mtx.Unlock() + l.request(fmt.Sprintf("{sender=\"logtest\", container=\"%s\"}", cnt), from, to) +} + +func (l *LogReader) logRangeAggregationRequest(containers []string) { + l.mtx.Lock() + cnt := pickRandom(containers, l.rand) + to := time.Now().UnixNano() - l.rand.Int63n(600000000000) + from := to - l.rand.Int63n(3600000000000) + l.mtx.Unlock() + l.request(fmt.Sprintf("rate({sender=\"logtest\", container=\"%s\"}[1m])", cnt), from, to) +} + +func (l *LogReader) aggregationOperatorRequest(containers []string) { + l.mtx.Lock() + cnt := pickRandom(containers, l.rand) + to := time.Now().UnixNano() - l.rand.Int63n(600000000000) + from := to - l.rand.Int63n(3600000000000) + l.mtx.Unlock() + l.request(fmt.Sprintf("sum by (level) (rate({sender=\"logtest\", container=\"%s\"}[1m]))", cnt), from, to) +} + +func (l *LogReader) unwrapRequest(containers []string) { + l.mtx.Lock() + cnt := pickRandom(containers, l.rand) + to := time.Now().UnixNano() - l.rand.Int63n(600000000000) + from := to - l.rand.Int63n(3600000000000) + l.mtx.Unlock() + l.request(fmt.Sprintf("rate({sender=\"logtest\", container=\"%s\"} | unwrap_value [1m])", cnt), from, to) +} + +func (l *LogReader) unwrapAggregationOperatorRequest(containers []string) { + l.mtx.Lock() + cnt := pickRandom(containers, l.rand) + to := time.Now().UnixNano() - l.rand.Int63n(600000000000) + from := to - l.rand.Int63n(3600000000000) + l.mtx.Unlock() + l.request(fmt.Sprintf("sum by (sender) (rate({sender=\"logtest\", container=\"%s\"} | unwrap_value [1m]))", cnt), from, to) +} + +func (l *LogReader) request(req string, from int64, to int64) { + +} + +func (l *LogReader) getValues(name string) []string { + return nil +} diff --git a/test/qryn_test_env/longtest/logSender.go b/test/qryn_test_env/longtest/logSender.go new file mode 100644 index 00000000..97635fbe --- /dev/null +++ b/test/qryn_test_env/longtest/logSender.go @@ -0,0 +1,54 @@ +package main + +import ( + "fmt" + "math/rand" + "sync" + "time" +) + +type LogSender struct { + LogSenderOpts + mtx sync.Mutex + rnd *rand.Rand + ticker *time.Ticker + path string +} + +func NewLogSender(opts LogSenderOpts) ISender { + var l *GenericSender + l = &GenericSender{ + LogSenderOpts: opts, + mtx: sync.Mutex{}, + rnd: rand.New(rand.NewSource(time.Now().UnixNano())), + timeout: time.Second, + path: "/loki/api/v1/push", + generate: func() IRequest { + logLen := 0 + req := &LogRequest{} + for logLen < l.LinesPS { + streamLen := 20 + stream := &LogStream{ + Stream: map[string]string{ + "orgid": opts.Headers["X-Scope-OrgID"], + "container": l.pickRandom(l.Containers), + "level": l.pickRandom([]string{"info", "debug", "error"}), + "sender": "logtest", + "__name__": "logs", + "__ttl_days__": "25", + }, + Values: make([][]interface{}, streamLen), + } + for i := 0; i < streamLen; i++ { + //line := fmt.Sprintf("opaqueid=%d mos=%f", l.random(1000), float64(l.random(1000)/250)) + line := l.pickRandom(l.Lines) + stream.Values[i] = []interface{}{fmt.Sprintf("%d", time.Now().UnixNano()), line} + logLen++ + } + req.Streams = append(req.Streams, stream) + } + return req + }, + } + return l +} diff --git a/test/qryn_test_env/longtest/longtest.go b/test/qryn_test_env/longtest/longtest.go new file mode 100644 index 00000000..1868c5f4 --- /dev/null +++ b/test/qryn_test_env/longtest/longtest.go @@ -0,0 +1,188 @@ +package main + +import ( + "fmt" + "os" + "strconv" + "strings" + "time" +) + +func main() { + kind := os.Getenv("KIND") + if kind == "" { + kind = "WRITE" + } + switch kind { + case "WRITE": + writeTest() + break + case "READ": + readTest() + break + } +} + +func writeTest() { + fmt.Println("GENERATING") + logs := generateLogs() + //names := generateNames(1500) + fmt.Println("SENDING") + names := generateNames(3300) + power := 1 + if os.Getenv("POWER") != "" { + var err error + power, err = strconv.Atoi(os.Getenv("POWER")) + if err != nil { + panic(err) + } + } + headers := map[string]string{} + if strings.Contains(os.Getenv("MODE"), "L") { + fmt.Println("Run logs") + sender := NewLogSender(LogSenderOpts{ + ID: "logs", + Containers: names, + Lines: logs, + LinesPS: 120 * power, + URL: os.Getenv("URL"), + Headers: headers, + }) + sender.Run() + } + /*if strings.Contains(os.Getenv("MODE"), "P") { + fmt.Println("Run logs PB") + _headers := make(map[string]string, 20) + for k, v := range headers { + _headers[k] = v + } + _headers["Content-Type"] = "application/x-protobuf" + sender := NewPBSender(LogSenderOpts{ + ID: "logs", + Containers: names, + Lines: logs, + LinesPS: 50000, + URL: os.Getenv("URL"), + Headers: _headers, + }) + sender.Run() + }*/ + if strings.Contains(os.Getenv("MODE"), "M") { + fmt.Println("Run metrics") + metrics := NewMetricSender(LogSenderOpts{ + ID: "metrics", + Containers: names, + Lines: logs, + LinesPS: 30 * power, + URL: os.Getenv("URL"), + Headers: headers, + }) + metrics.Run() + } + if strings.Contains(os.Getenv("MODE"), "Z") { + fmt.Println("Run zipkin") + zipkins := NewZipkinSender(LogSenderOpts{ + ID: "traces", + Containers: names, + Lines: logs, + LinesPS: 40 * power, + URL: os.Getenv("URL"), + Headers: headers, + }) + zipkins.Run() + } + if strings.Contains(os.Getenv("MODE"), "O") { + fmt.Println("Run OTLP") + zipkins := NewOTLPSender(LogSenderOpts{ + ID: "traces", + Containers: names, + Lines: logs, + LinesPS: 40 * power, + URL: os.Getenv("URL"), + Headers: headers, + }) + zipkins.Run() + } + if strings.Contains(os.Getenv("MODE"), "G") { + fmt.Println("Run zipkin") + zipkins := NewSGSender(LogSenderOpts{ + ID: "traces", + Containers: names, + Lines: logs, + LinesPS: 10 * power, + URL: os.Getenv("URL"), + Headers: headers, + }) + zipkins.Run() + } + if strings.Contains(os.Getenv("MODE"), "D") { + fmt.Println("Run datadog") + datadogs := NewDatadogSender(LogSenderOpts{ + ID: "traces", + Containers: names, + Lines: logs, + LinesPS: 120 * power, + URL: os.Getenv("URL"), + Headers: headers, + }) + datadogs.Run() + } + if strings.Contains(os.Getenv("MODE"), "I") { + fmt.Println("Run influx") + influx := NewInfluxSender(LogSenderOpts{ + ID: "influx", + Containers: names, + Lines: logs, + LinesPS: 100 * power, + URL: os.Getenv("URL"), + Headers: headers, + }) + influx.Run() + } + if strings.Contains(os.Getenv("MODE"), "C") { + fmt.Println("Run consistency checker") + cons := NewJSONConsistencyChecker(LogSenderOpts{ + ID: "consistency-1", + Containers: names, + Lines: logs, + LinesPS: 300 * power, + URL: os.Getenv("URL"), + Headers: headers, + }) + cons.Run() + } + if strings.Contains(os.Getenv("MODE"), "T") { + fmt.Println("Run time sender") + pqt := NewTimeSender(LogSenderOpts{ + ID: "longtest-TIME", + Containers: names, + Lines: logs, + LinesPS: 10, + URL: os.Getenv("URL"), + Headers: headers, + }) + pqt.Run() + } + t := time.NewTicker(time.Second) + go func() { + for range t.C { + s := stats.Collect() + fmt.Printf("Ok requests: %d, Errors: %d, Failed: %d\n", s[REQ_OK], s[REQ_ERR], s[REQ_FAIL]) + fmt.Printf("Ok Requests time: min: %d, max: %d, avg: %f\n", + s[REQ_TIME_MS+"_min"], + s[REQ_TIME_MS+"_max"], + float64(s[REQ_TIME_MS+"_sum"])/float64(s[REQ_TIME_MS+"_count"])) + fmt.Printf("Ok Requests MB sent: %f, (%fMB/s)\n", + float64(s[REQ_BYTES+"_sum"])/1024/1024, + float64(s[REQ_BYTES+"_sum"])/1024/1024/5, + ) + } + }() + for { + time.Sleep(time.Second) + } +} + +func readTest() { + +} diff --git a/test/qryn_test_env/longtest/metricReader.go b/test/qryn_test_env/longtest/metricReader.go new file mode 100644 index 00000000..06ab7d0f --- /dev/null +++ b/test/qryn_test_env/longtest/metricReader.go @@ -0,0 +1 @@ +package main diff --git a/test/qryn_test_env/longtest/metricSender.go b/test/qryn_test_env/longtest/metricSender.go new file mode 100644 index 00000000..b52a3708 --- /dev/null +++ b/test/qryn_test_env/longtest/metricSender.go @@ -0,0 +1,94 @@ +package main + +import ( + "github.com/golang/protobuf/proto" + "github.com/golang/snappy" + "github.com/prometheus/prometheus/prompb" + "hash/crc32" + "math" + "math/rand" + "sync" + "time" +) + +type PromReq []prompb.TimeSeries + +func (p PromReq) Serialize() ([]byte, error) { + bytes, err := proto.Marshal(&prompb.WriteRequest{Timeseries: p}) + if err != nil { + return nil, err + } + enc := snappy.Encode(nil, bytes) + return enc, nil +} + +func NewMetricSender(opts LogSenderOpts) ISender { + var l *GenericSender + hdrs := opts.Headers + opts.Headers = map[string]string{} + for k, v := range hdrs { + opts.Headers[k] = v + } + opts.Headers["Content-Type"] = "application/x-protobuf" + opts.Headers["Content-Encoding"] = "snappy" + l = &GenericSender{ + LogSenderOpts: opts, + mtx: sync.Mutex{}, + rnd: rand.New(rand.NewSource(time.Now().UnixNano())), + timeout: time.Second * 15, + path: "/api/v1/prom/remote/write", + generate: func() IRequest { + if opts.LinesPS/3 < len(l.Containers) { + l.Containers = l.Containers[:opts.LinesPS/3] + } + req := make(PromReq, len(l.Containers)*3) + for i, container := range l.Containers { + base := int(crc32.ChecksumIEEE([]byte(container))) + req[i*3] = prompb.TimeSeries{ + Labels: []prompb.Label{ + {Name: "__name__", Value: "cpu_usage"}, + {Name: "container", Value: container}, + {Name: "orgid", Value: opts.Headers["X-Scope-OrgID"]}, + {Name: "sender", Value: "logmetrics"}, + }, + Samples: []prompb.Sample{ + { + Timestamp: time.Now().UnixMilli(), + Value: math.Max(float64(base%100+(l.random(20)-10)), 0), + }, + }, + } + req[i*3+1] = prompb.TimeSeries{ + Labels: []prompb.Label{ + {Name: "__name__", Value: "ram_usage"}, + {Name: "container", Value: container}, + {Name: "orgid", Value: opts.Headers["X-Scope-OrgID"]}, + {Name: "sender", Value: "logmetrics"}, + }, + Samples: []prompb.Sample{ + { + Timestamp: time.Now().UnixMilli(), + Value: math.Max(float64(base%1000+(l.random(200)-100)), 0), + }, + }, + } + req[i*3+2] = prompb.TimeSeries{ + Labels: []prompb.Label{ + {Name: "__name__", Value: "network_usage"}, + {Name: "container", Value: container}, + {Name: "orgid", Value: opts.Headers["X-Scope-OrgID"]}, + {Name: "sender", Value: "logmetrics"}, + }, + Samples: []prompb.Sample{ + { + Timestamp: time.Now().UnixMilli(), + Value: math.Max(float64(base%1000000+(l.random(2000)-1000)), 0), + }, + }, + } + } + return req + }, + } + return l +} diff --git a/test/qryn_test_env/longtest/otlpSender.go b/test/qryn_test_env/longtest/otlpSender.go new file mode 100644 index 00000000..aeb22383 --- /dev/null +++ b/test/qryn_test_env/longtest/otlpSender.go @@ -0,0 +1,132 @@ +package main + +import ( + "fmt" + cv1 "go.opentelemetry.io/proto/otlp/common/v1" + rv1 "go.opentelemetry.io/proto/otlp/resource/v1" + v1 "go.opentelemetry.io/proto/otlp/trace/v1" + "google.golang.org/protobuf/proto" + "math/rand" + "os" + "time" + "unsafe" +) + +type OTLPReq v1.TracesData + +func (z *OTLPReq) Serialize() ([]byte, error) { + return proto.Marshal((*v1.TracesData)(z)) +} + +func NewOTLPSender(opts LogSenderOpts) ISender { + rnd := rand.New(rand.NewSource(time.Now().UnixNano())) + path := "/v1/traces" + if os.Getenv("ZPATH") != "" { + path = os.Getenv("ZPATH") + } + l := &GenericSender{ + LogSenderOpts: opts, + rnd: rnd, + timeout: time.Second, + path: path, + } + pickCont := func() string { + return l.pickRandom(opts.Containers) + } + /*pickLine := func() string { + return l.pickRandom(opts.Lines) + }*/ + l.generate = func() IRequest { + req := &OTLPReq{ + ResourceSpans: make([]*v1.ResourceSpans, opts.LinesPS/10), + } + for i := range req.ResourceSpans { + uintTraceId := []uint64{uint64(l.random(0xFFFFFFFF)), uint64(i)} + bTraceId := make([]byte, 16) + copy(bTraceId, unsafe.Slice((*byte)(unsafe.Pointer(&uintTraceId[0])), 16)) + uintSpanId := uint64(l.random(0xFFFFFFFF)) + bSpanId := make([]byte, 8) + copy(bSpanId, unsafe.Slice((*byte)(unsafe.Pointer(&uintSpanId)), 8)) + req.ResourceSpans[i] = &v1.ResourceSpans{ + Resource: &rv1.Resource{ + Attributes: []*cv1.KeyValue{ + { + Key: "service.name", + Value: &cv1.AnyValue{ + Value: &cv1.AnyValue_StringValue{ + StringValue: "longtest-service", + }, + }, + }, + { + Key: "sender", + Value: &cv1.AnyValue{ + Value: &cv1.AnyValue_StringValue{ + StringValue: "longtest", + }, + }, + }, + { + Key: "type", + Value: &cv1.AnyValue{ + Value: &cv1.AnyValue_StringValue{ + StringValue: "otlp", + }, + }, + }, + }, + DroppedAttributesCount: 0, + }, + ScopeSpans: []*v1.ScopeSpans{ + { + Spans: make([]*v1.Span, 10), + }, + }, + } + for j := range req.ResourceSpans[i].ScopeSpans[0].Spans { + kind := v1.Span_SPAN_KIND_CLIENT + if j%2 == 0 { + kind = v1.Span_SPAN_KIND_SERVER + } + req.ResourceSpans[i].ScopeSpans[0].Spans[j] = &v1.Span{ + TraceId: bTraceId, + SpanId: bSpanId, + ParentSpanId: nil, + Name: "longtest", + Kind: kind, + StartTimeUnixNano: uint64(time.Now(). + Add(time.Millisecond * time.Duration(-1*(l.random(500)))). + UnixNano()), + EndTimeUnixNano: uint64(time.Now().UnixNano()), + Attributes: []*cv1.KeyValue{ + { + Key: "container", + Value: &cv1.AnyValue{ + Value: &cv1.AnyValue_StringValue{ + StringValue: pickCont(), + }, + }, + }, + { + Key: "randomFloat", + Value: &cv1.AnyValue{ + Value: &cv1.AnyValue_StringValue{ + StringValue: fmt.Sprintf("%f", 50+(rand.Float64()*100-50)), + }, + }, + }, + }, + DroppedAttributesCount: 0, + Events: nil, + DroppedEventsCount: 0, + Links: nil, + DroppedLinksCount: 0, + Status: nil, + } + } + + } + return req + } + return l +} diff --git a/test/qryn_test_env/longtest/pqtSender.go b/test/qryn_test_env/longtest/pqtSender.go new file mode 100644 index 00000000..49b52fc4 --- /dev/null +++ b/test/qryn_test_env/longtest/pqtSender.go @@ -0,0 +1,59 @@ +package main + +import ( + "bytes" + "github.com/apache/arrow/go/v13/arrow" + _ "github.com/apache/arrow/go/v13/arrow" + "github.com/apache/arrow/go/v13/arrow/array" + "github.com/apache/arrow/go/v13/arrow/memory" + "github.com/apache/arrow/go/v13/parquet" + "github.com/apache/arrow/go/v13/parquet/pqarrow" + _ "github.com/apache/arrow/go/v13/parquet/pqarrow" + "math/rand" + "time" +) + +type PqtReq struct { + arrow.Record +} + +func (p *PqtReq) Serialize() ([]byte, error) { + defer p.Release() + buf := bytes.NewBuffer(make([]byte, 0, 1024)) + w, err := pqarrow.NewFileWriter(p.Schema(), buf, parquet.NewWriterProperties(), pqarrow.NewArrowWriterProperties()) + if err != nil { + return nil, err + } + err = w.Write(p) + if err != nil { + return nil, err + } + err = w.Close() + return buf.Bytes(), err +} + +func NewPqtSender(opts LogSenderOpts) ISender { + bld := array.NewRecordBuilder(memory.DefaultAllocator, arrow.NewSchema([]arrow.Field{ + {Name: "timestamp_ns", Type: arrow.PrimitiveTypes.Int64}, + {Name: "opaque_id", Type: arrow.BinaryTypes.String}, + {Name: "mos", Type: arrow.PrimitiveTypes.Float64}, + }, nil)) + + l := &GenericSender{ + LogSenderOpts: opts, + rnd: rand.New(rand.NewSource(time.Now().UnixNano())), + timeout: time.Second, + path: "/api/dedicated", + } + l.generate = func() IRequest { + for i := 0; i < opts.LinesPS; i++ { + bld.Field(0).(*array.Int64Builder).Append(time.Now().UnixNano()) + bld.Field(1).(*array.StringBuilder).Append(l.pickRandom(l.Containers)) + bld.Field(2).(*array.Float64Builder).Append(l.rnd.Float64() * 100) + } + return &PqtReq{ + Record: bld.NewRecord(), + } + } + return l +} diff --git a/test/qryn_test_env/longtest/sendStats.go b/test/qryn_test_env/longtest/sendStats.go new file mode 100644 index 00000000..b1aa4a06 --- /dev/null +++ b/test/qryn_test_env/longtest/sendStats.go @@ -0,0 +1,99 @@ +package main + +import ( + "math" + "strings" + "sync" + "time" +) + +type Stats struct { + stats []map[string]int64 + mtx sync.Mutex +} + +var stats = func() *Stats { + res := &Stats{ + stats: make([]map[string]int64, 1), + } + res.stats[0] = make(map[string]int64, 10) + t := time.NewTicker(time.Second) + go func() { + for range t.C { + res.mtx.Lock() + res.stats = append(res.stats, make(map[string]int64, 10)) + if len(res.stats) > 5 { + res.stats = res.stats[1:] + } + res.mtx.Unlock() + } + }() + return res +}() + +func (s *Stats) getOrDefault2(m map[string]int64, name string, def int64) int64 { + if val, ok := m[name]; ok { + return val + } + return def +} + +func (s *Stats) getOrDefault(name string, def int64) int64 { + return s.getOrDefault2(s.stats[len(s.stats)-1], name, def) +} + +func (s *Stats) Inc(name string) { + s.mtx.Lock() + defer s.mtx.Unlock() + s.stats[len(s.stats)-1][name] = s.getOrDefault(name, 0) + 1 +} + +func (s *Stats) Observe(name string, val int64) { + s.mtx.Lock() + defer s.mtx.Unlock() + min := s.getOrDefault(name+"_min", math.MaxInt64) + if min > val { + min = val + } + max := s.getOrDefault(name+"_max", math.MinInt64) + if max < val { + max = val + } + count := s.getOrDefault(name+"_count", 0) + 1 + sum := s.getOrDefault(name+"_sum", 0) + val + idx := len(s.stats) - 1 + s.stats[idx][name+"_min"] = min + s.stats[idx][name+"_max"] = max + s.stats[idx][name+"_count"] = count + s.stats[idx][name+"_sum"] = sum +} + +func (s *Stats) Collect() map[string]int64 { + s.mtx.Lock() + defer s.mtx.Unlock() + res := make(map[string]int64, 10) + for _, stats := range s.stats { + for k, v := range stats { + if strings.HasSuffix(k, "_min") { + a := s.getOrDefault2(res, k, math.MaxInt64) + if a < v { + res[k] = a + } else { + res[k] = v + } + continue + } + if strings.HasSuffix(k, "_max") { + a := s.getOrDefault2(res, k, math.MinInt64) + if a > v { + res[k] = a + } else { + res[k] = v + } + continue + } + res[k] = s.getOrDefault2(res, k, 0) + v + } + } + return res +} diff --git a/test/qryn_test_env/longtest/serviceGraphSender.go b/test/qryn_test_env/longtest/serviceGraphSender.go new file mode 100644 index 00000000..0850fb99 --- /dev/null +++ b/test/qryn_test_env/longtest/serviceGraphSender.go @@ -0,0 +1,95 @@ +package main + +import ( + "github.com/openzipkin/zipkin-go/model" + "math/rand" + "net" + "os" + "time" +) + +func NewSGSender(opts LogSenderOpts) ISender { + rnd := rand.New(rand.NewSource(time.Now().UnixNano())) + path := "/tempo/spans" + if os.Getenv("ZPATH") != "" { + path = os.Getenv("ZPATH") + } + l := &GenericSender{ + LogSenderOpts: opts, + rnd: rnd, + timeout: time.Second, + path: path, + } + pickCont := func() string { + return l.pickRandom(opts.Containers[:5]) + } + l.generate = func() IRequest { + req := make(ZipkinReq, opts.LinesPS) + high := rnd.Uint64() + dur := uint64(rnd.Float64() * 1000) + + for i := 0; i < opts.LinesPS; i += 2 { + client := "test2-" + pickCont() + server := "test2-" + pickCont() + req[i] = model.SpanModel{ + SpanContext: model.SpanContext{ + TraceID: model.TraceID{ + High: high, + Low: uint64(i / 100), + }, + ID: model.ID(i + 1), + }, + Name: "longtest-SG", + Timestamp: time.Now(), + Duration: time.Duration(dur) * time.Microsecond, + Kind: model.Client, + LocalEndpoint: &model.Endpoint{ + ServiceName: client, + IPv4: net.IPv4(192, 168, 0, 1), + IPv6: nil, + Port: 8080, + }, + RemoteEndpoint: &model.Endpoint{ + ServiceName: server, + IPv4: net.IPv4(192, 168, 0, 2), + IPv6: nil, + Port: 8080, + }, + Tags: map[string]string{ + "sender": "longtest-SG", + }, + } + req[i+1] = model.SpanModel{ + SpanContext: model.SpanContext{ + TraceID: model.TraceID{ + High: high, + Low: uint64(i / 100), + }, + ID: model.ID(i + 2), + ParentID: &[]model.ID{model.ID(i + 1)}[0], + }, + Name: "longtest-SG", + Timestamp: time.Now(), + Duration: time.Duration(dur/2) * time.Microsecond, + Kind: model.Server, + LocalEndpoint: &model.Endpoint{ + ServiceName: server, + IPv4: net.IPv4(192, 168, 0, 2), + IPv6: nil, + Port: 8080, + }, + RemoteEndpoint: &model.Endpoint{ + ServiceName: client, + IPv4: net.IPv4(192, 168, 0, 1), + IPv6: nil, + Port: 8080, + }, + Tags: map[string]string{ + "sender": "longtest-SG", + }, + } + } + return req + } + return l +} diff --git a/test/qryn_test_env/longtest/stats.go b/test/qryn_test_env/longtest/stats.go new file mode 100644 index 00000000..30cd2bce --- /dev/null +++ b/test/qryn_test_env/longtest/stats.go @@ -0,0 +1,24 @@ +package main + +import ( + "sync" + "time" +) + +type Stat struct { + Timings map[string]int64 + mtx sync.Mutex +} + +func (s *Stat) AddTiming(timing time.Duration) { + s.mtx.Lock() + defer s.mtx.Unlock() + +} + +func (s *Stat) getOrDefault(k string, def int64) int64 { + if _, ok := s.Timings[k]; !ok { + return def + } + return s.Timings[k] +} diff --git a/test/qryn_test_env/longtest/timerSender.go b/test/qryn_test_env/longtest/timerSender.go new file mode 100644 index 00000000..2a4ef126 --- /dev/null +++ b/test/qryn_test_env/longtest/timerSender.go @@ -0,0 +1,48 @@ +package main + +import ( + "github.com/prometheus/prometheus/prompb" + "math/rand" + "sync" + "time" +) + +func NewTimeSender(opts LogSenderOpts) ISender { + var l *GenericSender + hdrs := opts.Headers + opts.Headers = map[string]string{} + for k, v := range hdrs { + opts.Headers[k] = v + } + opts.Headers["Content-Type"] = "application/x-protobuf" + opts.Headers["Content-Encoding"] = "snappy" + l = &GenericSender{ + LogSenderOpts: opts, + mtx: sync.Mutex{}, + rnd: rand.New(rand.NewSource(time.Now().UnixNano())), + timeout: time.Second * 15, + path: "/api/v1/prom/remote/write", + generate: func() IRequest { + req := make(PromReq, l.LinesPS) + for i := 0; i < l.LinesPS; i++ { + container := l.Containers[i%len(l.Containers)] + req[i] = prompb.TimeSeries{ + Labels: []prompb.Label{ + {Name: "orgid", Value: opts.Headers["X-Scope-OrgID"]}, + {Name: "__name__", Value: "current_time"}, + {Name: "container", Value: container}, + {Name: "sender", Value: "logmetrics"}, + }, + Samples: []prompb.Sample{ + { + Timestamp: time.Now().UnixMilli(), + Value: float64(time.Now().Unix()), + }, + }, + } + } + return req + }, + } + return l +} diff --git a/test/qryn_test_env/longtest/zipkinSender.go b/test/qryn_test_env/longtest/zipkinSender.go new file mode 100644 index 00000000..94e48e26 --- /dev/null +++ b/test/qryn_test_env/longtest/zipkinSender.go @@ -0,0 +1,72 @@ +package main + +import ( + "encoding/json" + "fmt" + "github.com/openzipkin/zipkin-go/model" + "math/rand" + "net" + "os" + "time" +) + +type ZipkinReq []model.SpanModel + +func (z ZipkinReq) Serialize() ([]byte, error) { + return json.Marshal(z) +} + +func NewZipkinSender(opts LogSenderOpts) ISender { + rnd := rand.New(rand.NewSource(time.Now().UnixNano())) + path := "/tempo/spans" + if os.Getenv("ZPATH") != "" { + path = os.Getenv("ZPATH") + } + l := &GenericSender{ + LogSenderOpts: opts, + rnd: rnd, + timeout: time.Second, + path: path, + } + pickCont := func() string { + return l.pickRandom(opts.Containers) + } + pickLine := func() string { + return l.pickRandom(opts.Lines) + } + l.generate = func() IRequest { + req := make(ZipkinReq, opts.LinesPS) + high := rnd.Uint64() + + for i := 0; i < opts.LinesPS; i++ { + req[i] = model.SpanModel{ + SpanContext: model.SpanContext{ + TraceID: model.TraceID{ + High: high, + Low: uint64(i / 100), + }, + ID: model.ID(i + 1), + }, + Name: "longtest", + Timestamp: time.Now(), + Duration: 1000, + LocalEndpoint: &model.Endpoint{ + ServiceName: "longtest-service", + IPv4: net.IPv4(192, 168, 0, 1), + IPv6: nil, + Port: 8080, + }, + Annotations: []model.Annotation{ + {time.Now(), pickLine()}, + }, + Tags: map[string]string{ + "sender": "longtest", + "randomContainer": pickCont(), + "randomFloat": fmt.Sprintf("%f", 50+(rand.Float64()*100-50)), + }, + } + } + return req + } + return l +} diff --git a/test/qryn_test_env/otel/otel-collector-config.yaml b/test/qryn_test_env/otel/otel-collector-config.yaml new file mode 100644 index 00000000..27bed126 --- /dev/null +++ b/test/qryn_test_env/otel/otel-collector-config.yaml @@ -0,0 +1,116 @@ +receivers: + loki: + use_incoming_timestamp: true + protocols: + http: + endpoint: 0.0.0.0:3100 + grpc: + endpoint: 0.0.0.0:3200 + syslog: + protocol: rfc5424 + tcp: + listen_address: "0.0.0.0:5514" + fluentforward: + endpoint: 0.0.0.0:24224 + splunk_hec: + endpoint: 0.0.0.0:8088 + otlp: + protocols: + grpc: + endpoint: 0.0.0.0:4317 + http: + endpoint: 0.0.0.0:4318 + jaeger: + protocols: + grpc: + endpoint: 0.0.0.0:14250 + thrift_http: + endpoint: 0.0.0.0:14268 + zipkin: + endpoint: 0.0.0.0:9411 + skywalking: + protocols: + grpc: + endpoint: 0.0.0.0:11800 + http: + endpoint: 0.0.0.0:12800 + prometheus: + config: + scrape_configs: + - job_name: 'otel-collector' + scrape_interval: 5s + static_configs: + - targets: ['exporter:8080'] + - job_name: 'qryn' + scrape_interval: 5s + static_configs: + - targets: ['qryn:3100'] + influxdb: + endpoint: 0.0.0.0:8086 + pyroscopereceiver: + +processors: + batch: + send_batch_size: 10000 + timeout: 5s + memory_limiter: + check_interval: 2s + limit_mib: 1800 + spike_limit_mib: 500 + resourcedetection/system: + detectors: ['system'] + system: + hostname_sources: ['os'] + resource: + attributes: + - key: service.name + value: "serviceName" + action: upsert + +exporters: + qryn: + dsn: tcp://clickhouse-server:9000/qryn?username=qryn&password=demo + timeout: 10s + sending_queue: + queue_size: 100 + retry_on_failure: + enabled: true + initial_interval: 5s + max_interval: 30s + max_elapsed_time: 300s + logs: + format: raw + otlp: + endpoint: localhost:4317 + tls: + insecure: true + clickhouseprofileexporter: + dsn: clickhouse://clickhouse-server:9000/qryn?username=qryn&password=demo + +extensions: + health_check: + pprof: + zpages: + pyroscope: + +service: + telemetry: + logs: + level: "info" + extensions: [pprof, zpages, health_check, pyroscope] + pipelines: + logs: + receivers: [fluentforward, otlp, loki] + processors: [memory_limiter, resourcedetection/system, resource, batch] + exporters: [qryn] + traces: + receivers: [otlp, jaeger, zipkin, skywalking] + processors: [memory_limiter, resourcedetection/system, resource, batch] + exporters: [qryn] + metrics: + receivers: [prometheus, influxdb] + processors: [memory_limiter, resourcedetection/system, resource, batch] + exporters: [qryn] + logs/profiles: + receivers: [pyroscopereceiver] + exporters: [clickhouseprofileexporter]