diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 00000000..cb8f9e90 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,100 @@ +name: Build and Release + +on: + push: + branches: + - main + - devel + tags: + - "v*" + workflow_dispatch: + inputs: + create_release: + description: "Create a draft release (for testing)" + required: false + type: boolean + default: false + +jobs: + build-and-release: + name: Build and Release + runs-on: ubuntu-latest + permissions: + contents: write # Needed to create releases + + steps: + - name: Checkout code + uses: actions/checkout@v4 + with: + fetch-depth: 0 # Required for git history access + + - name: Install build dependencies + run: | + sudo apt-get update + sudo apt-get install -y libcairo2 libpango-1.0-0 libpangocairo-1.0-0 libgdk-pixbuf2.0-0 libffi-dev pandoc + python -m pip install --upgrade pip + pip install -r requirements.txt + + - name: Get Version + id: get_version + run: | + if [[ "${{ github.ref_type }}" == "tag" ]]; then + VERSION_NUMBER="${{ github.ref_name }}" + VERSION_NUMBER="${VERSION_NUMBER#v}" + else + VERSION_NUMBER=$(grep '^VERSION' src/dtagent/version.py | cut -d '"' -f 2) + if [[ -z "$VERSION_NUMBER" ]]; then + echo "Error: Failed to extract version from src/dtagent/version.py. File may be missing or format may be incorrect." + exit 1 + fi + fi + echo "VERSION=${VERSION_NUMBER}" >> $GITHUB_OUTPUT + + - name: Clean up previous build artifacts + run: | + rm -f dynatrace_snowflake_observability_agent-*.zip + rm -f Dynatrace-Snowflake-Observability-Agent-*.pdf + + - name: Run package script + id: package + run: | + chmod +x *.sh + ./package.sh full + BUILD_NUMBER=$(grep 'BUILD =' build/_version.py | awk '{print $3}') + echo "ZIP_NAME=dynatrace_snowflake_observability_agent-${{ steps.get_version.outputs.VERSION }}.${BUILD_NUMBER}.zip" >> $GITHUB_OUTPUT + echo "PDF_NAME=Dynatrace-Snowflake-Observability-Agent-${{ steps.get_version.outputs.VERSION }}.pdf" >> $GITHUB_OUTPUT + + - name: Upload build artifacts + if: github.ref_type != 'tag' && inputs.create_release == false + uses: actions/upload-artifact@v4 + with: + name: dsoa-package-${{ steps.get_version.outputs.VERSION }} + path: | + ${{ steps.package.outputs.ZIP_NAME }} + ${{ steps.package.outputs.PDF_NAME }} + + - name: Extract Release Notes from CHANGELOG + id: extract_release_notes + if: github.ref_type == 'tag' || inputs.create_release == true + run: | + VERSION_HEADER="## Dynatrace Snowflake Observability Agent ${{ steps.get_version.outputs.VERSION }}" + # Use awk to find the section for the current version and print until the next ## heading + awk -v header="$VERSION_HEADER" ' + $0 == header { in_section=1; next } + /^## / { if (in_section) exit } + in_section { print } + ' CHANGELOG.md > release_notes.md + + - name: Create GitHub Release + if: github.ref_type == 'tag' || inputs.create_release == true + uses: softprops/action-gh-release@v2 + with: + tag_name: ${{ github.ref_name }} + name: Dynatrace Snowflake Observability Agent ${{ steps.get_version.outputs.VERSION }} + body_path: release_notes.md + draft: ${{ inputs.create_release == true }} + files: | + ${{ steps.package.outputs.ZIP_NAME }} + ${{ steps.package.outputs.PDF_NAME }} + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.gitignore b/.gitignore index 38981f69..71316f79 100644 --- a/.gitignore +++ b/.gitignore @@ -8,7 +8,7 @@ snowflake.local.yml output/** log.* *.log -*credentials.json +*credentials*.json *.pyc build/* package/* diff --git a/.vscode/settings.json b/.vscode/settings.json index cef5761a..4583c522 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -42,11 +42,13 @@ "dashboarding", "DATEADD", "deadsnakes", + "dedup", "devel", "docstrings", "doesn't", "dsoa", "DTAGENT", + "Dynatrace", "ECAC", "ensurepath", "externalbrowser", @@ -61,6 +63,8 @@ "jsonstrip", "judgements", "Kamatchi", + "kvlist", + "LDATA", "libcairo", "libgdk", "libpango", @@ -98,6 +102,7 @@ "snowflakedb", "snowpark", "SNOWPIPE", + "softprops", "specversion", "spendings", "SQLERRM", diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 5206ed23..f3717a0a 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -140,11 +140,65 @@ The build process for the Dynatrace Snowflake Observability Agent package involv ## Setting up development environment -You will need [Python 3.9](https://www.python.org/) or newer and [git](https://git-scm.com/). -If you are on Windows, you will need to install WSL2. Please refer to the `Prerequisites` in [the installation documentation](INSTALL.md) for more details. +This guide was created for developers who want to contribute to the Dynatrace Snowflake Observability Agent. If you only want to install and use the agent, please refer to the [INSTALL.md](INSTALL.md) guide. -The recommended setup is to use [VS Code](https://code.visualstudio.com/) with [Snowflake plugin](https://marketplace.visualstudio.com/items?itemName=snowflake.snowflake-vsc). Though neither of those are necessary, and any IDE that supports python and SQL should do. -On Windows, after installing WSL, it is necessary to open your IDE of choice using WSL (see [Setting up WSL on VS Code guide)](https://learn.microsoft.com/en-us/windows/wsl/tutorials/wsl-vscode). +### Prerequisites + +You will need the following software installed: + +* [Python](https://www.python.org/) (3.9 or newer) +* [Git](https://git-scm.com/) +* On Windows, [WSL2](https://learn.microsoft.com/en-us/windows/wsl/install) is required. + +The recommended setup is to use [VS Code](https://code.visualstudio.com/) with the [Snowflake plugin](https://marketplace.visualstudio.com/items?itemName=snowflake.snowflake-vsc). + +### Environment Setup + +1. **Clone the repository:** + + ```bash + git clone https://github.com/dynatrace-oss/dynatrace-snowflake-observability-agent.git + cd dynatrace-snowflake-observability-agent + ``` + +1. **Create and activate a virtual environment:** + + ```bash + python -m venv .venv + source .venv/bin/activate + ``` + +1. **Install dependencies:** + + The `setup.sh` script can help install most of the required tools. + + ```bash + ./setup.sh + ``` + + Alternatively, you can install them manually. You will need the dependencies for running the agent (see `INSTALL.md`) plus the development dependencies. + +### System Dependencies + +For **Ubuntu/Debian**: + + ```bash + sudo apt-get update + sudo apt-get install -y pango cairo gdk-pixbuf libffi pandoc + ``` + +For **macOS** (using [Homebrew](https://brew.sh/)): + + ```bash + brew install pango cairo gdk-pixbuf libffi pandoc + ``` + +Additional **Python packages** for all platforms are listed in `requirements.txt`. +Install them using pip: + + ```bash + pip install -r requirements.txt + ``` ## Building Dynatrace Snowflake Observability Agent diff --git a/INSTALL.md b/INSTALL.md index e45231d8..e2b57e3f 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -2,10 +2,65 @@ Dynatrace Snowflake Observability Agent comes in the form of a series of SQL scripts (accompanied with a few configuration files), which need to be deployed at Snowflake by executing them in the correct order. +This document assumes you are installing from the distribution package (`dynatrace_snowflake_observability_agent-*.zip`). If you are a developer and want to build from source, please refer to the [CONTRIBUTING.md](CONTRIBUTING.md) guide. + +## Prerequisites + +Before you can deploy the agent, you need to ensure the following tools are installed on your system. + +### Windows Users +On Windows, it is necessary to install Windows Subsystem for Linux (WSL) version 2.0 or higher. The deployment scripts must be run through WSL. See [Install WSL guide](https://learn.microsoft.com/en-us/windows/wsl/install) for more details. + +### All Users +You will need the following command-line tools: + +* **bash**: The deployment scripts are written in bash. +* **Snowflake CLI**: For connecting to and deploying objects in Snowflake. +* **jq**: For processing JSON files. +* **gawk**: For text processing. + +You can run the included `./setup.sh` script, which will attempt to install these dependencies for you. + +Alternatively, you can install them manually: + +#### Snowflake CLI +Install using `pipx` (recommended): + +```bash +# If you do not have pipx installed, run: +# on Ubuntu/Debian +sudo apt install pipx +# on macOS +brew install pipx + +# With pipx installed, run: +pipx install snowflake-cli-labs +``` + +Or on macOS with Homebrew: + +```bash +brew tap snowflakedb/snowflake-cli +brew install snowflake-cli +``` + +#### jq and gawk + +On **Ubuntu/Debian**: + +```bash +sudo apt install jq gawk +``` + +On **macOS** (with Homebrew): + +```bash +brew install jq gawk +``` + ## Deploying Dynatrace Snowflake Observability Agent The default option to install Dynatrace Snowflake Observability Agent is from the distribution package. -Should you require to install Dynatrace Snowflake Observability Agent from the sources, please check the [Installing Dynatrace Snowflake Observability Agent from sources](#installing-dynatrace-snowflake-observability-agent-from-sources) section before continuing here. To deploy Dynatrace Snowflake Observability Agent, run the `./deploy.sh` command: ```bash @@ -152,7 +207,8 @@ To list your currently defined connections run: snow connection list ``` -Here is an example of how to fill in the form to configure connection based on external browser authentication, which is a recommended way for users authenticating with external SSO: +Here is an example of how to fill in the form to configure connection based on external browser authentication, +which is a recommended way for users authenticating with external SSO: ```bash Snowflake account name: ${YOUR_SNOWFLAKE_ACCOUNT_NAME.REGION_NAME} @@ -172,111 +228,10 @@ Path to private key file [optional]: You can also run this command to fill in the required and recommended parts: ```bash -snow connection add --connection-name snow_agent_$config_name --account ${YOUR_SNOWFLAKE_ACCOUNT_NAME.REGION_NAME} --user ${YOUR_USERNAME} --authenticator externalbrowser +snow connection add --connection-name snow_agent_$config_name \ + --account ${YOUR_SNOWFLAKE_ACCOUNT_NAME.REGION_NAME} \ + --user ${YOUR_USERNAME} \ + --authenticator externalbrowser ``` If you have any issues setting up the connection check [the SnowCli documentation](https://docs.snowflake.com/en/user-guide/snowsql). - -## Prerequisites - -### Windows Subsystem for Linux - -On Windows it is necessary to install Windows Subsystem for Linux before proceeding with the following steps. Dynatrace Snowflake Observability Agent must be executed through WSL to guarantee proper functioning: WSL version 2.0 or higher is recommended (see [Install WSL guide)](https://learn.microsoft.com/en-us/windows/wsl/install): - -### MacOS - -You will need `brew` installed and up to date (XCode) Command Line Tools. - -To install `brew` go to [Brew installation](https://docs.brew.sh/Installation) -To update Command Line Tools you need to run - -```bash -xcode-select --install -``` - -or go to Software Update in System Settings - -## Installing Dynatrace Snowflake Observability Agent from sources - -For the development purposes you can install Dynatrace Snowflake Observability Agent from sources. - -### Getting local copy of Dynatrace Snowflake Observability Agent - -To get the source code of Dynatrace Snowflake Observability Agent you will need `git` installed. -Run the following command: - -```bash -git clone https://github.com/dynatrace-oss/dynatrace-snowflake-observability-agent.git -``` - -Otherwise you should receive a package with Dynatrace Snowflake Observability Agent named `dynatrace_snowflake_observability_agent-$version.zip` which you should unpack. - -### Installing necessary software - -You can simply run `./setup.sh` to install all necessary software on your MacOS or Ubuntu. - -#### Creating virtual environment - -Once you have Python (only versions 3.9 through 3.11 are supported) installed, it is a good practice to operate with Python code within a virtual environment (see [Virtual Environment Guide](https://docs.python.org/3/library/venv.html)). To create and active one run: - -```bash -python -m venv .venv -source .venv/bin/activate -``` - -#### Installing required packages - -Packages necessary to run the program should be installed using following commands. - -We need [Snowflake CLI](https://github.com/snowflakedb/snowflake-cli) installed either via pipx - -```bash -# if You do not have pipx installed, run -sudo apt install pipx -# with pipx installed, run -pipx install snowflake-cli-labs -``` - -or Homebrew (macOS only): - -```bash -brew tap snowflakedb/snowflake-cli -brew install snowflake-cli -snow --help -``` - -Once this is done install the remaining Python packages: - -```bash -pip install -r requirements.txt -``` - -Finally, you need to install few more development tools: - -* [jq](https://github.com/jqlang/jq) - -In Windows WSL / Ubuntu linux run: - -```bash -sudo apt install jq -``` - -On macOS run: - -```bash -brew install jq -``` - -* gawk - -In Windows WSL / Ubuntu linux run: - -```bash -sudo apt install gawk -``` - -On macOS run: - -```bash -brew install gawk -``` diff --git a/PLUGINS.md b/PLUGINS.md index 78315715..850dbae8 100644 --- a/PLUGINS.md +++ b/PLUGINS.md @@ -51,6 +51,8 @@ fetch logs } ``` +If you have any concerns about getting correct results reported by this plugin, please refer to [Root Cause Analysis: Missing Long-Running Queries](docs/debug/active-queries-faq/readme.md). + [Show semantics for this plugin](SEMANTICS.md#active_queries_semantics_sec) ### Active Queries default configuration diff --git a/README.md b/README.md index 8bd7f01a..9b777fab 100644 --- a/README.md +++ b/README.md @@ -12,6 +12,7 @@ Table of content: * [Plugins](PLUGINS.md) * [Semantic dictionary](SEMANTICS.md) * [How to install](INSTALL.md) +* [Example dashboards](docs/dashboards) * [Changelog](CHANGELOG.md) * [Contributing](CONTRIBUTING.md) * [Appendix](APPENDIX.md) diff --git a/decode_logs.py b/decode_logs.py new file mode 100644 index 00000000..5b6dae2d --- /dev/null +++ b/decode_logs.py @@ -0,0 +1,57 @@ +#!/usr/bin/env python3 +"""Script to decode OTLP protobuf logs to JSON""" + +import base64 +import json +import sys +from opentelemetry.proto.collector.logs.v1.logs_service_pb2 import ExportLogsServiceRequest + + +def decode_protobuf_logs(base64_data: str) -> str: + """Decode base64 encoded protobuf logs to JSON""" + # Decode base64 to bytes + protobuf_bytes = base64.b64decode(base64_data) + + # Parse protobuf + request = ExportLogsServiceRequest() + request.ParseFromString(protobuf_bytes) + + # Convert to dict/JSON + def message_to_dict(message): + """Convert protobuf message to dict""" + result = {} + for field in message.DESCRIPTOR.fields: + value = getattr(message, field.name) + if field.type == field.TYPE_MESSAGE: + if field.label == field.LABEL_REPEATED: + result[field.name] = [message_to_dict(item) for item in value] + else: + result[field.name] = message_to_dict(value) + elif field.label == field.LABEL_REPEATED: + result[field.name] = list(value) + else: + if isinstance(value, bytes): + result[field.name] = value.decode("utf-8", errors="replace") + else: + result[field.name] = value + return result + + logs_dict = message_to_dict(request) + return json.dumps(logs_dict, indent=2) + + +if __name__ == "__main__": + if len(sys.argv) != 2: + print("Usage: python decode_logs.py ") + sys.exit(1) + + file_path = sys.argv[1] + with open(file_path, "r", encoding="utf-8") as f: + base64_data = f.read().strip() + + try: + json_output = decode_protobuf_logs(base64_data) + print(json_output) + except (ValueError, base64.binascii.Error) as e: + print(f"Error decoding: {e}", file=sys.stderr) + sys.exit(1) diff --git a/docs/dashboards/costs-monitoring/costs-monitoring.yaml b/docs/dashboards/costs-monitoring/costs-monitoring.yaml new file mode 100644 index 00000000..2f83087b --- /dev/null +++ b/docs/dashboards/costs-monitoring/costs-monitoring.yaml @@ -0,0 +1,1307 @@ +# +# Copyright (c) 2025 Dynatrace Open Source +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the Software), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# DASHBOARD: Costs Monitoring 0.9.2 +# DESCRIPTION: Snowflake Cost Monitoring dashboard +# OWNER: sebastian.kruk +# PLUGINS: query_history, resource_monitors, warehouse_usage +# TAGS: costs +# +version: 19 +variables: + - version: 2 + key: Accounts + type: query + visible: true + editable: true + input: |- + fetch events + | filter db.system == "snowflake" + | filter isNotNull(deployment.environment) + | fields deployment.environment + | dedup deployment.environment + | sort deployment.environment asc + multiple: true + defaultValue: + - 3420b2ac-f1cf-4b24-b62d-61ba1ba8ed05* + - version: 2 + key: Prefix + type: query + visible: true + editable: true + input: |- + fetch events + | filter db.system == "snowflake" + | filter isNotNull(snowflake.resource_monitor.name) + | filter in(deployment.environment, array($Accounts)) + | parse `snowflake.resource_monitor.name`, """DATA:env "_" LDATA""" + | append [ + fetch events + | filter db.system == "snowflake" + | filter isNotNull(snowflake.warehouse.name) + | filter in(deployment.environment, array($Accounts)) + | parse `snowflake.warehouse.name`, """DATA:env "_" LDATA""" + ] + | fields env + | dedup env + | sort env asc + multiple: true + defaultValue: + - 3420b2ac-f1cf-4b24-b62d-61ba1ba8ed05* + - version: 2 + key: Resource_Monitors + type: query + visible: true + editable: true + input: |- + fetch events + | filter db.system == "snowflake" + | filter isNotNull(snowflake.resource_monitor.name) + | filter in(deployment.environment, array($Accounts)) + | filter iAny(startsWith(snowflake.resource_monitor.name, concat(array($Prefix)[], "_"))) + | fields snowflake.resource_monitor.name + | dedup snowflake.resource_monitor.name + | sort snowflake.resource_monitor.name asc + multiple: true + defaultValue: + - 3420b2ac-f1cf-4b24-b62d-61ba1ba8ed05* + - version: 2 + key: Warehouses + type: query + visible: true + editable: true + input: |- + fetch events + | filter db.system == "snowflake" + | filter isNotNull(snowflake.warehouse.name) + | filter in(deployment.environment, array($Accounts)) + | filter isNull(snowflake.resource_monitor.name) or in(snowflake.resource_monitor.name, array($Resource_Monitors)) + | fields snowflake.warehouse.name + | dedup snowflake.warehouse.name + | sort snowflake.warehouse.name asc + multiple: true + defaultValue: + - 3420b2ac-f1cf-4b24-b62d-61ba1ba8ed05* + - version: 2 + key: Slow_Query_Min + type: text + visible: true + editable: true + defaultValue: "60" +tiles: + "0": + title: Credits used + type: data + query: |- + timeseries snowflake.credits.quota.used = max(snowflake.credits.quota.used), by: { + snowflake.resource_monitor.name, + deployment.environment, + service.name + } + | filter in(deployment.environment, array($Accounts)) + and iAny(startsWith(snowflake.resource_monitor.name, concat(array($Prefix)[], "_"))) + and in(snowflake.resource_monitor.name, array($Resource_Monitors)) + // and in(snowflake.warehouse.name, array($Warehouses)) + | fieldsAdd snow_account = coalesce(deployment.environment, service.name) + | fieldsRemove deployment.environment, service.name + | summarize { + snowflake.credits.quota.used = max(snowflake.credits.quota.used[]) + }, by: { + timeframe, + interval, + snowflake.resource_monitor.name, + snow_account + } + visualization: lineChart + visualizationSettings: + chartSettings: + truncationMode: middle + leftYAxisSettings: + label: Credits Used + isLabelVisible: true + xAxisLabel: timeframe + xAxisScaling: analyzedTimeframe + fieldMapping: + leftAxisValues: + - snowflake.credits.quota.used + timestamp: timeframe + gapPolicy: connect + legend: + position: bottom + legend: + ratio: 18 + thresholds: [] + dataMapping: + displayedFields: + - snowflake.resource_monitor.name + - snow_account + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 100 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "1": + type: markdown + content: '# Resource Monitors' + davis: + componentState: + inputData: null + "2": + title: Credits quota + type: data + query: |- + timeseries snowflake.credits.quota = max(snowflake.credits.quota), by: { + snowflake.resource_monitor.name, + deployment.environment, + service.name + } + | filter in(deployment.environment, array($Accounts)) + and iAny(startsWith(snowflake.resource_monitor.name, concat(array($Prefix)[], "_"))) + and in(snowflake.resource_monitor.name, array($Resource_Monitors)) + // and in(snowflake.warehouse.name, array($Warehouses)) + | fieldsAdd snow_account = coalesce(deployment.environment, service.name) + | fieldsRemove deployment.environment, service.name + | summarize { + snowflake.credits.quota = max(snowflake.credits.quota[]) + }, by: { + timeframe, + interval, + snowflake.resource_monitor.name, + snow_account + } + visualization: davis + visualizationSettings: + autoSelectVisualization: false + thresholds: [] + chartSettings: + gapPolicy: connect + circleChartSettings: + groupingThresholdType: relative + groupingThresholdValue: 0 + valueType: relative + categoryOverrides: {} + categoricalBarChartSettings: + categoryAxis: snowflake.resource_monitor.name + categoryAxisLabel: snowflake.resource_monitor.name + valueAxis: interval + valueAxisLabel: interval + hiddenLegendFields: + - snowflake.resource_monitor + fieldMapping: + timestamp: timeframe + leftAxisValues: + - snowflake.credits.quota + singleValue: + labelMode: custom + label: "" + prefixIcon: "" + recordField: snowflake.resource_monitor.name + autoscale: true + alignment: center + colorThresholdTarget: value + table: + rowDensity: condensed + enableSparklines: false + hiddenColumns: [] + lineWrapIds: [] + columnWidths: {} + columnTypeOverrides: + - fields: + - snowflake.credits.quota + value: sparkline + id: 1755691686510 + honeycomb: + shape: hexagon + legend: auto + dataMappings: + value: interval + displayedFields: + - snowflake.resource_monitor.name + colorMode: color-palette + colorPalette: blue + histogram: + dataMappings: + - valueAxis: interval + rangeAxis: "" + valueBoundaries: + min: + mode: auto + max: + mode: auto + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 100 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: true + componentState: + selectedAnalyzerName: dt.statistics.ui.anomaly_detection.AutoAdaptiveAnomalyDetectionAnalyzer + inputData: + dt.statistics.ui.anomaly_detection.AutoAdaptiveAnomalyDetectionAnalyzer: + generalParameters: + timeframe: + startTime: "2025-09-19T07:19:49.111Z" + endTime: "2025-10-03T07:19:49.111Z" + resolveDimensionalQueryData: true + logVerbosity: INFO + numberOfSignalFluctuations: 1 + alertCondition: OUTSIDE + alertOnMissingData: false + violatingSamples: 1 + slidingWindow: 10 + dealertingSamples: 3 + davisVisualization: + isAvailable: true + settings: + visibleSections: VISUALIZATION + "3": + title: Credits quota used + type: data + query: |- + timeseries snowflake.credits.quota.used_pct = max(snowflake.credits.quota.used_pct), by: { + snowflake.resource_monitor.name, + deployment.environment, + service.name + } + | filter in(deployment.environment, array($Accounts)) + and iAny(startsWith(snowflake.resource_monitor.name, concat(array($Prefix)[], "_"))) + and in(snowflake.resource_monitor.name, array($Resource_Monitors)) + // and in(snowflake.warehouse.name, array($Warehouses)) + | fieldsAdd snow_account = coalesce(deployment.environment, service.name) + | fieldsRemove deployment.environment, service.name + | summarize { + snowflake.credits.quota.used_pct = max(snowflake.credits.quota.used_pct[]) + }, by: { + timeframe, + interval, + snowflake.resource_monitor.name, + snow_account + } + visualization: lineChart + visualizationSettings: + chartSettings: + truncationMode: middle + leftYAxisSettings: + label: Percentage Quota Used + isLabelVisible: true + xAxisLabel: timeframe + xAxisScaling: analyzedTimeframe + fieldMapping: + leftAxisValues: + - snowflake.credits.quota.used_pct + timestamp: timeframe + gapPolicy: connect + legend: + position: bottom + legend: + ratio: 18 + thresholds: + - id: 1 + field: "" + title: Percentage used + isEnabled: true + rules: + - id: 0 + color: + Default: 'var(--dt-colors-charts-categorical-color-09-default, #649438)' + comparator: < + label: "" + value: 50 + - id: 1 + color: + Default: 'var(--dt-colors-charts-categorical-color-14-default, #d56b1a)' + comparator: < + label: "" + value: 99 + - id: 2 + color: + Default: 'var(--dt-colors-charts-categorical-color-12-default, #cd3741)' + comparator: ≥ + label: "" + value: 100 + dataMapping: + displayedFields: + - snowflake.resource_monitor.name + - snow_account + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 100 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "4": + type: markdown + content: '# Warehouses' + davis: + componentState: + inputData: null + "5": + title: Warehouses without resource monitors + type: data + query: |2 + fetch logs + | filter db.system == "snowflake" + | filter dsoa.run.context == "resource_monitors" + | filter in(deployment.environment, array($Accounts)) + | sort timestamp asc + | summarize { + timestamp = takeLast(timestamp), + loglevel = takeLast(loglevel) + }, by: { + deployment.environment, snowflake.warehouse.name + } + | filterOut loglevel == "INFO" + | sort loglevel asc, timestamp desc + | fields + `Last seen`=timestamp, + `Account`=deployment.environment, + `Warehouse`=coalesce(snowflake.warehouse.name, "-"), + `Level`=loglevel, + `Explanation`=if(loglevel == "WARN", + concat("Warehouse ", snowflake.warehouse.name, " does not have Resource Monitor assigned"), + else: concat("Account ", deployment.environment, " does not have global resource monitor defined")) + visualization: table + visualizationSettings: + table: + columnWidths: + '["snow_account"]': 303.71875 + '["Explanation"]': 1161 + thresholds: + - id: 1 + field: Level + title: "" + isEnabled: true + rules: + - id: 0 + color: + Default: 'var(--dt-colors-charts-categorical-color-09-default, #649438)' + comparator: = + label: "" + value: INFO + - id: 1 + color: + Default: 'var(--dt-colors-charts-categorical-color-14-default, #d56b1a)' + comparator: = + label: "" + value: WARN + - id: 2 + color: + Default: 'var(--dt-colors-charts-categorical-color-12-default, #cd3741)' + comparator: = + label: "" + value: ERROR + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 100 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "6": + title: Query execution time per warehouse + type: data + query: | + timeseries snowflake.time.execution = sum(snowflake.time.execution), by: { + snowflake.warehouse.name, + deployment.environment, + service.name + } + | filter in(deployment.environment, array($Accounts)) + and iAny(startsWith(snowflake.warehouse.name, concat(array($Prefix)[], "_"))) + // and in(snowflake.resource_monitor.name, array($Resource_Monitors)) + and in(snowflake.warehouse.name, array($Warehouses)) + | fieldsAdd snow_account = coalesce(deployment.environment, service.name) + | fieldsRemove service.name, deployment.environment + | summarize { + snowflake.time.execution = sum(snowflake.time.execution[]) + }, by: { + timeframe, + interval, + // snowflake.warehouse.name, + snow_account + } + visualization: barChart + visualizationSettings: + chartSettings: + truncationMode: middle + leftYAxisSettings: + label: Execution Time + isLabelVisible: true + xAxisLabel: timeframe + xAxisScaling: analyzedTimeframe + fieldMapping: + leftAxisValues: + - snowflake.time.execution + timestamp: timeframe + legend: + ratio: 13 + thresholds: [] + dataMapping: + displayedFields: + - snow_account + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 100 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "7": + title: Queued overload time per warehouse + type: data + query: |- + timeseries snowflake.time.queued.overload = sum(snowflake.time.queued.overload), by: { + snowflake.warehouse.name, + deployment.environment, + service.name + } + | fieldsAdd key = concat(deployment.environment, "|", snowflake.warehouse.name) + | joinNested rs = [ + fetch events + | filter db.system == "snowflake" + | filter isNotNull(snowflake.warehouse.event) + | filter isNotNull(snowflake.resource_monitor.name) and isNotNull(snowflake.warehouse.name) + | summarize {count()}, by: { + snowflake.resource_monitor.name, + snowflake.warehouse.name, + deployment.environment} + | fieldsAdd key = concat(deployment.environment, "|", snowflake.warehouse.name) + ], on: {left[key] == right[key]} + , fields: {snowflake.resource_monitor.name} + | expand rs = rs + | fieldsAdd snowflake.resource_monitor.name = rs[snowflake.resource_monitor.name] + | fieldsRemove rs + | filter in(deployment.environment, array($Accounts)) + and iAny(startsWith(snowflake.warehouse.name, concat(array($Prefix)[], "_"))) + and (isNull(snowflake.resource_monitor.name) or in(snowflake.resource_monitor.name, array($Resource_Monitors))) + and in(snowflake.warehouse.name, array($Warehouses)) + | fieldsRemove snowflake.resource_monitor.name + | fieldsAdd snow_account = coalesce(deployment.environment, service.name) + | fieldsRemove deployment.environment, service.name + | summarize { + snowflake.time.queued.overload = sum(snowflake.time.queued.overload[]) + }, by: { + timeframe, + interval, + snowflake.warehouse.name, + snow_account + } + visualization: barChart + visualizationSettings: + dataMapping: + displayedFields: + - snowflake.warehouse.name + - snow_account + chartSettings: + leftYAxisSettings: + label: Queued Overload Time + isLabelVisible: true + xAxisLabel: timeframe + xAxisScaling: analyzedTimeframe + tooltip: + seriesDisplayMode: multi-line + fieldMapping: + leftAxisValues: + - snowflake.time.queued.overload + timestamp: timeframe + legend: + ratio: 20 + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 100 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "8": + title: Queued provisioning time per warehouse + type: data + query: |- + timeseries snowflake.time.queued.provisioning = sum(snowflake.time.queued.provisioning), by: { + snowflake.warehouse.name, + deployment.environment, + service.name + } + | fieldsAdd key = concat(deployment.environment, "|", snowflake.warehouse.name) + | joinNested rs = [ + fetch events + | filter db.system == "snowflake" + | filter isNotNull(snowflake.warehouse.event) + | filter isNotNull(snowflake.resource_monitor.name) and isNotNull(snowflake.warehouse.name) + | summarize {count()}, by: { + snowflake.resource_monitor.name, + snowflake.warehouse.name, + deployment.environment} + | fieldsAdd key = concat(deployment.environment, "|", snowflake.warehouse.name) + ], on: {left[key] == right[key]} + , fields: {snowflake.resource_monitor.name} + | expand rs = rs + | fieldsAdd snowflake.resource_monitor.name = rs[snowflake.resource_monitor.name] + | fieldsRemove rs + | filter in(deployment.environment, array($Accounts)) + and iAny(startsWith(snowflake.warehouse.name, concat(array($Prefix)[], "_"))) + and (isNull(snowflake.resource_monitor.name) or in(snowflake.resource_monitor.name, array($Resource_Monitors))) + and in(snowflake.warehouse.name, array($Warehouses)) + | fieldsRemove snowflake.resource_monitor.name + | fieldsAdd snow_account = coalesce(deployment.environment, service.name) + | fieldsRemove deployment.environment, service.name + | summarize { + ssnowflake.time.queued.provisioning = sum(snowflake.time.queued.provisioning[]) + }, by: { + timeframe, + interval, + snowflake.warehouse.name, + snow_account + } + visualization: barChart + visualizationSettings: + dataMapping: + displayedFields: + - snowflake.warehouse.name + - snow_account + chartSettings: + truncationMode: middle + xAxisLabel: timeframe + xAxisScaling: analyzedTimeframe + fieldMapping: + leftAxisValues: + - ssnowflake.time.queued.provisioning + timestamp: timeframe + legend: + ratio: 21 + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 100 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "9": + title: Credits quota usage preditiction + type: data + query: |- + timeseries snowflake.credits.quota.used_pct = max(snowflake.credits.quota.used_pct), by: { + snowflake.resource_monitor.name, + deployment.environment, + service.name + }, interval: 24h + , from: -15d + , to: -1d + | filter in(deployment.environment, array($Accounts)) + and iAny(startsWith(snowflake.resource_monitor.name, concat(array($Prefix)[], "_"))) + and in(snowflake.resource_monitor.name, array($Resource_Monitors)) + // and in(snowflake.warehouse.name, array($Warehouses)) + | fieldsAdd snow_account = coalesce(deployment.environment, service.name) + | fieldsRemove deployment.environment, service.name + | sort snowflake.credits.quota.used_pct desc + // | limit 10 + visualization: davis + visualizationSettings: + autoSelectVisualization: false + thresholds: + - id: 1 + field: "" + title: Percentage used + isEnabled: true + rules: + - id: 0 + color: + Default: 'var(--dt-colors-charts-categorical-color-09-default, #649438)' + comparator: < + label: "" + value: 50 + - id: 1 + color: + Default: 'var(--dt-colors-charts-categorical-color-14-default, #d56b1a)' + comparator: < + label: "" + value: 99 + - id: 2 + color: + Default: 'var(--dt-colors-charts-categorical-color-12-default, #cd3741)' + comparator: ≥ + label: "" + value: 100 + chartSettings: + xAxisScaling: analyzedTimeframe + gapPolicy: connect + circleChartSettings: + groupingThresholdType: relative + groupingThresholdValue: 0 + valueType: relative + categoryOverrides: {} + categoricalBarChartSettings: + categoryAxis: + - snowflake.resource_monitor.name + - snow_account + categoryAxisLabel: snowflake.resource_monitor.name,snow_account + valueAxis: + - interval + valueAxisLabel: interval + tooltipVariant: single + hiddenLegendFields: + - snowflake.resource_monitor + - interval + fieldMapping: + timestamp: timeframe + leftAxisValues: + - snowflake.credits.quota.used_pct + truncationMode: middle + valueRepresentation: absolute + xAxisLabel: timeframe + xAxisIsLabelVisible: false + leftYAxisSettings: + isLabelVisible: true + label: Percentage Quota Used + singleValue: + trend: + trendType: auto + isVisible: true + labelMode: custom + label: "" + prefixIcon: "" + recordField: snowflake.resource_monitor.name + autoscale: true + alignment: center + colorThresholdTarget: value + table: + rowDensity: condensed + enableSparklines: false + hiddenColumns: [] + lineWrapIds: [] + columnWidths: {} + columnTypeOverrides: + - fields: + - snowflake.credits.quota.used_pct + value: sparkline + id: 1756104321690 + honeycomb: + shape: hexagon + legend: auto + dataMappings: + value: interval + displayedFields: + - snowflake.resource_monitor.name + - snow_account + colorMode: color-palette + colorPalette: blue + histogram: + dataMappings: + - valueAxis: interval + rangeAxis: "" + variant: single + displayedFields: + - snowflake.resource_monitor.name + valueBoundaries: + min: + mode: auto + max: + mode: auto + legend: + showLegend: false + position: auto + ratio: 18 + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 100 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: true + componentState: + selectedAnalyzerName: dt.statistics.ui.ForecastAnalyzer + inputData: + dt.statistics.ui.ForecastAnalyzer: + generalParameters: + timeframe: + startTime: now()-14d + endTime: now() + resolveDimensionalQueryData: true + logVerbosity: INFO + forecastHorizon: 7 + forecastOffset: 0 + davisVisualization: + isAvailable: true + settings: + visibleSections: VISUALIZATION + "10": + type: markdown + content: '# Slow queries' + davis: + componentState: + inputData: null + "11": + title: Count of queries slower then $Slow_Query_Min min by user over time + type: data + query: | + fetch logs + | filter db.system == "snowflake" + | filter dsoa.run.context == "query_history" + | filter isNotNull(snowflake.query.id) + | fieldsAdd snowflake.time.running.in_min = toLong(snowflake.time.total_elapsed)/1000/60 + | filter toLong(snowflake.time.running.in_min) > toDouble($Slow_Query_Min) + | fieldsAdd key = concat(deployment.environment, "|", snowflake.warehouse.name) + | joinNested rs = [ + fetch events + | filter db.system == "snowflake" + | filter isNotNull(snowflake.warehouse.event) + | filter isNotNull(snowflake.resource_monitor.name) and isNotNull(snowflake.warehouse.name) + | summarize {count()}, by: { + snowflake.resource_monitor.name, + snowflake.warehouse.name, + deployment.environment} + | fieldsAdd key = concat(deployment.environment, "|", snowflake.warehouse.name) + ], on: {left[key] == right[key]} + , fields: {snowflake.resource_monitor.name} + | expand rs = rs + | fieldsAdd snowflake.resource_monitor.name = rs[snowflake.resource_monitor.name] + | fieldsRemove rs + | filter in(deployment.environment, array($Accounts)) + and iAny(startsWith(snowflake.warehouse.name, concat(array($Prefix)[], "_"))) + and in(snowflake.resource_monitor.name, array($Resource_Monitors)) + and in(snowflake.warehouse.name, array($Warehouses)) + | fieldsRemove snowflake.resource_monitor.name + | makeTimeseries count(), by: { db.user } + //, interval: 1h + visualization: barChart + visualizationSettings: + chartSettings: + legend: + position: bottom + tooltip: + seriesDisplayMode: multi-line + legend: + ratio: 19 + autoSelectVisualization: false + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "12": + title: Top 100 slowest queries running longer than $Slow_Query_Min minutes + type: data + query: | + fetch logs, scanLimitGBytes:-1 + | filter db.system == "snowflake" + | filter dsoa.run.context == "query_history" + | filter isNotNull(snowflake.query.id) + | fieldsAdd snowflake.time.running.in_min = toLong(snowflake.time.total_elapsed)/1000/60 + | filter toLong(snowflake.time.running.in_min) > toDouble($Slow_Query_Min) + | fieldsAdd key = concat(deployment.environment, "|", snowflake.warehouse.name) + | joinNested rs = [ + fetch events + | filter db.system == "snowflake" + | filter isNotNull(snowflake.warehouse.event) + | filter isNotNull(snowflake.resource_monitor.name) and isNotNull(snowflake.warehouse.name) + | summarize {count()}, by: { + snowflake.resource_monitor.name, + snowflake.warehouse.name, + deployment.environment} + | fieldsAdd key = concat(deployment.environment, "|", snowflake.warehouse.name) + ], on: {left[key] == right[key]} + , fields: {snowflake.resource_monitor.name} + | expand rs = rs + | fieldsAdd snowflake.resource_monitor.name = rs[snowflake.resource_monitor.name] + | fieldsRemove rs + | filter in(deployment.environment, array($Accounts)) + and iAny(startsWith(snowflake.warehouse.name, concat(array($Prefix)[], "_"))) + and in(snowflake.resource_monitor.name, array($Resource_Monitors)) + and in(snowflake.warehouse.name, array($Warehouses)) + | fieldsAdd snowflake.time.duration = toDuration(1000*1000*toLong(snowflake.time.total_elapsed)) + | sort snowflake.time.total_elapsed desc + | limit 100 + | fields + `Duration`=snowflake.time.duration, + `Start Time`=timestamp-snowflake.time.duration, + `Query ID`=snowflake.query.id, + `User`=db.user, + `Account`=deployment.environment, + `Warehouse`=snowflake.warehouse.name, + `Resource Monitor`=coalesce(snowflake.resource_monitor.name, "-"), + `Query SQL`=substring(db.query.text, to: 15) + visualization: table + visualizationSettings: + table: + columnTypeOverrides: + - fields: + - content + id: 1759145367565 + value: log-content + autoSelectVisualization: false + unitsOverrides: + - identifier: snowflake.time.running.in_min + unitCategory: time + baseUnit: minute + displayUnit: null + decimals: 2 + suffix: "" + delimiter: false + added: 1759145749114 + - identifier: snowflake.time.running + unitCategory: time + baseUnit: millisecond + displayUnit: null + decimals: 2 + suffix: "" + delimiter: false + added: 1759145797490 + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "13": + title: Queries currently running longer than $Slow_Query_Min minutes + type: data + query: | + fetch logs, from: -12h + | filter isNotNull(snowflake.query.id) + | filter dsoa.run.context == "active_queries" + | filter isNotNull(snowflake.time.running) + | fieldsAdd snowflake.time.running.in_min = toLong(snowflake.time.running)/1000/60 + | filter toLong(snowflake.time.running.in_min) > toDouble($Slow_Query_Min) + | fieldsAdd key = concat(deployment.environment, "|", snowflake.warehouse.name) + | joinNested rs = [ + fetch events + | filter db.system == "snowflake" + | filter isNotNull(snowflake.warehouse.event) + | filter isNotNull(snowflake.resource_monitor.name) and isNotNull(snowflake.warehouse.name) + | summarize {count()}, by: { + snowflake.resource_monitor.name, + snowflake.warehouse.name, + deployment.environment} + | fieldsAdd key = concat(deployment.environment, "|", snowflake.warehouse.name) + ], on: {left[key] == right[key]} + , fields: {snowflake.resource_monitor.name} + | expand rs = rs + | fieldsAdd snowflake.resource_monitor.name = rs[snowflake.resource_monitor.name] + | fieldsRemove rs + | filter in(deployment.environment, array($Accounts)) + and iAny(startsWith(snowflake.warehouse.name, concat(array($Prefix)[], "_"))) + and in(snowflake.resource_monitor.name, array($Resource_Monitors)) + and in(snowflake.warehouse.name, array($Warehouses)) + | sort timestamp asc + | summarize { + timestamp = takeLast(timestamp), + snowflake.time.running = takeLast(snowflake.time.running), + snowflake.time.running.in_min = takeLast(snowflake.time.running.in_min), + dsoa.run.last_id = takeLast(dsoa.run.id) + }, by: { + dsoa.run.id, + snowflake.query.id, + snowflake.warehouse.name, + deployment.environment, + db.query.text, + db.user + } + | filter dsoa.run.last_id == dsoa.run.id + | join [ + fetch logs, from: -12h + | filter isNotNull(snowflake.query.id) + | filter dsoa.run.context == "query_history" + | filter in(deployment.environment, array($Accounts)) + and iAny(startsWith(snowflake.warehouse.name, concat(array($Prefix)[], "_"))) + and in(snowflake.resource_monitor.name, array($Resource_Monitors)) + and in(snowflake.warehouse.name, array($Warehouses)) + | fields snowflake.query.id, is_finished = true + ] + , on: {left[snowflake.query.id] == right[snowflake.query.id]} + , kind:leftOuter + , fields: {is_finished} + | filterOut is_finished + | fieldsRemove is_finished + | fieldsAdd snowflake.time.duration = toDuration(1000*1000*toLong(snowflake.time.running)) + | fields + `Start Time`=timestamp - snowflake.time.duration, + `Duration`=snowflake.time.duration, + `Query ID`=snowflake.query.id, + `User`=db.user, + `Warehouse`=snowflake.warehouse.name, + `Account`=deployment.environment, + `Query SQL`=db.query.text + visualization: table + visualizationSettings: + autoSelectVisualization: true + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "14": + title: Slow queries that might exhaust credits + type: data + query: |- + fetch logs, from: -12h + | filter isNotNull(snowflake.query.id) + | filter dsoa.run.context == "active_queries" + | filter isNotNull(snowflake.time.running) + | fieldsAdd snowflake.time.running.in_min = toLong(snowflake.time.running)/1000/60 + | filter toLong(snowflake.time.running.in_min) > 5 + | sort timestamp asc + | summarize { + timestamp = takeLast(timestamp), + snowflake.time.running = takeLast(snowflake.time.running), + snowflake.time.running.in_min = takeLast(snowflake.time.running.in_min), + dsoa.run.last_id = takeLast(dsoa.run.id) + }, by: { + dsoa.run.id, + snowflake.query.id, + snowflake.query.hash, + snowflake.warehouse.name, + snowflake.warehouse.size, + deployment.environment, + db.query.text, + db.user + } + | filter dsoa.run.last_id == dsoa.run.id + // --- filter out finished queries -- + | join [ + fetch logs, from: -12h + | filter isNotNull(snowflake.query.id) + | filter dsoa.run.context == "query_history" + | fields snowflake.query.id, is_finished = true + ] + , on: {left[snowflake.query.id] == right[snowflake.query.id]} + , kind:leftOuter + , fields: {is_finished} + | filterOut is_finished + | fieldsRemove is_finished + // -- filter out queries without resource monitor + | fieldsAdd join_key = concat(deployment.environment, "|", snowflake.warehouse.name) + | join [ + fetch events + | filter db.system == "snowflake" + | filter dsoa.run.context == "resource_monitors" + | filter snowflake.resource_monitor.name != "ACCOUNT_GLOBAL_MONITOR" + | filter isNotNull(snowflake.warehouse.name) and isNotNull(snowflake.resource_monitor.name) + | summarize snowflake.credits.quota.remaining = toDouble(takeLast(snowflake.credits.quota.remaining)), + by: {join_key = concat(deployment.environment, "|", snowflake.warehouse.name), + snowflake.warehouse.size, + snowflake.resource_monitor.name} + ] + , on: { left[join_key] == right[join_key]} + , fields: {snowflake.resource_monitor.name, snowflake.credits.quota.remaining} + , kind:leftOuter + | fieldsRemove join_key + | filterOut isNull(snowflake.resource_monitor.name) + // ------ + | filter in(deployment.environment, array($Accounts)) + and iAny(startsWith(snowflake.warehouse.name, concat(array($Prefix)[], "_"))) + and in(snowflake.resource_monitor.name, array($Resource_Monitors)) + and in(snowflake.warehouse.name, array($Warehouses)) + // in case it starts running slowly + // | sort snowflake.time.running desc + // | limit 10 + | join [ + fetch logs, from:-7d + | filter db.system == "snowflake" + | filter dsoa.run.context == "query_history" + | filter snowflake.time.total_elapsed > 30*60*1000 // were running over half-hour + | summarize {snowflake.time.total_elapsed = toLong(max(snowflake.time.total_elapsed))/1000}, by: {snowflake.query.hash} + ] + , on: { left[snowflake.query.hash] == right[snowflake.query.hash] } + , fields: {snowflake.time.total_elapsed} + , kind:leftOuter + | lookup [ + data + record(snowflake.warehouse.size = "X-Small", snowflake.warehouse.cost = 1), + record(snowflake.warehouse.size = "Small", snowflake.warehouse.cost = 2), + record(snowflake.warehouse.size = "Medium", snowflake.warehouse.cost = 4), + record(snowflake.warehouse.size = "Large", snowflake.warehouse.cost = 8), + record(snowflake.warehouse.size = "X-Large", snowflake.warehouse.cost = 16), + record(snowflake.warehouse.size = "XX-Large", snowflake.warehouse.cost = 32), + record(snowflake.warehouse.size = "XXX-Large", snowflake.warehouse.cost = 64) + ], sourceField:snowflake.warehouse.size + , lookupField:snowflake.warehouse.size + , fields:{snowflake.warehouse.cost} + | fieldsAdd + snowflake.query.credits.current = snowflake.warehouse.cost*snowflake.time.running/1000/60/60, // credits are per hour + snowflake.query.credits.estimated = snowflake.warehouse.cost*snowflake.time.total_elapsed/60/60 // credits are per hour + | fieldsAdd + snowflake.query.credits.expected = snowflake.query.credits.estimated - snowflake.query.credits.current + | filter snowflake.query.credits.expected > snowflake.credits.quota.remaining + | fieldsAdd snowflake.time.duration = toDuration(1000*1000*toLong(snowflake.time.running)) + | fields + `Start Time`=timestamp - snowflake.time.duration, + `Duration`=snowflake.time.duration, + `Time Elapsed`=coalesce(snowflake.time.total_elapsed, snowflake.time.duration), + `Current Costs`=coalesce(snowflake.query.credits.current, 0), + `Estimated Costs`=coalesce(snowflake.query.credits.estimated, 0), + `Expected Costs`=coalesce(snowflake.query.credits.expected, 0), + `Query SQL`=substring(db.query.text, to: 15), + `Query Hash`=snowflake.query.hash, + `Account`=deployment.environment, + `Warehouse`=snowflake.warehouse.name, + `Warehouse Size`=coalesce(snowflake.warehouse.size, "-"), + `Warehouse Costs`=coalesce(snowflake.warehouse.cost, "-") + visualization: table + visualizationSettings: + autoSelectVisualization: true + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "15": + title: Delays in resuming and suspending warehouses + type: data + query: |- + fetch logs + | filter db.system == "snowflake" + | filter dsoa.run.context == "warehouse_usage" + | filter contains(snowflake.warehouse.event.name, "WAREHOUSE") + | fieldsAdd key = concat(deployment.environment, "|", snowflake.warehouse.name) + | filter in(deployment.environment, array($Accounts)) + and iAny(startsWith(snowflake.warehouse.name, concat(array($Prefix)[], "_"))) + and in(snowflake.warehouse.name, array($Warehouses)) + | joinNested rs = [ + fetch events + | filter db.system == "snowflake" + | filter isNotNull(snowflake.warehouse.event) + | filter in(deployment.environment, array($Accounts)) + and iAny(startsWith(snowflake.warehouse.name, concat(array($Prefix)[], "_"))) + // and (isNull(snowflake.resource_monitor.name) or in(snowflake.resource_monitor.name, array($Resource_Monitors))) + and in(snowflake.warehouse.name, array($Warehouses)) + | summarize {count()}, by: { + snowflake.resource_monitor.name, + snowflake.warehouse.name, + deployment.environment} + | fieldsAdd key = concat(deployment.environment, "|", snowflake.warehouse.name) + ], on: {left[key] == right[key]} + , fields: {snowflake.resource_monitor.name} + | expand rs = rs + | fieldsAdd snowflake.resource_monitor.name = rs[snowflake.resource_monitor.name] + | fieldsRemove rs + | filter (isNull(snowflake.resource_monitor.name) or in(snowflake.resource_monitor.name, array($Resource_Monitors))) + | fieldsRemove snowflake.resource_monitor.name + | parse `observed_timestamp`, """JSONTIMESTAMP:ots""" + | fieldsAdd obs_timestamp = asTimestamp(ots) + | sort obs_timestamp asc + | fields obs_timestamp, + deployment.environment, + snowflake.warehouse.name, + snowflake.warehouse.event.name, + snowflake.warehouse.event.state, + snowflake.warehouse.cluster.number, + warehouse_state = if(snowflake.warehouse.event.name == "WAREHOUSE_CONSISTENT", "FINISHED", else: "STARTING"), + warehouse_action = if(snowflake.warehouse.event.name == "RESUME_WAREHOUSE", "RESUME", + else: if(snowflake.warehouse.event.name == "SUSPEND_WAREHOUSE", "SUSPEND")) + | fieldsAdd event_start = if(warehouse_state == "STARTING", obs_timestamp), + event_finish = if(warehouse_state == "FINISHED", obs_timestamp) + | summarize { + start_events = arrayRemoveNulls(collectArray(event_start)), + finish_events = arrayRemoveNulls(collectArray(event_finish)), + warehouse_action = arrayRemoveNulls(collectArray(warehouse_action)) + }, by: { + deployment.environment, + snowflake.warehouse.name + } + | fieldsAdd warehouse_events = record( ts = start_events[], event_delay = finish_events[] - start_events[], warehouse_action = warehouse_action[]) + | expand warehouse_events + | fields event_timestamp = warehouse_events[ts], + deployment.environment, + snowflake.warehouse.name, + event_delay = warehouse_events[event_delay], + warehouse_action = warehouse_events[warehouse_action] + | filterOut isNull(event_timestamp) + | makeTimeseries event_delay = sum(event_delay) + , by: {warehouse_action, snowflake.warehouse.name, deployment.environment} + , time: event_timestamp + // , interval: 1h + visualization: barChart + visualizationSettings: + autoSelectVisualization: false + unitsOverrides: + - identifier: event_delay + unitCategory: time + baseUnit: nanosecond + displayUnit: null + decimals: 2 + suffix: "" + delimiter: false + added: 1759150685068 + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null +layouts: + "0": + x: 0 + "y": 31 + w: 12 + h: 5 + "1": + x: 0 + "y": 30 + w: 24 + h: 1 + "2": + x: 12 + "y": 31 + w: 12 + h: 5 + "3": + x: 0 + "y": 36 + w: 12 + h: 5 + "4": + x: 0 + "y": 0 + w: 24 + h: 1 + "5": + x: 0 + "y": 1 + w: 24 + h: 5 + "6": + x: 0 + "y": 6 + w: 24 + h: 5 + "7": + x: 0 + "y": 11 + w: 24 + h: 6 + "8": + x: 0 + "y": 17 + w: 24 + h: 7 + "9": + x: 12 + "y": 36 + w: 12 + h: 5 + "10": + x: 0 + "y": 41 + w: 24 + h: 1 + "11": + x: 0 + "y": 50 + w: 24 + h: 5 + "12": + x: 0 + "y": 55 + w: 24 + h: 3 + "13": + x: 0 + "y": 42 + w: 24 + h: 4 + "14": + x: 0 + "y": 46 + w: 24 + h: 4 + "15": + x: 0 + "y": 24 + w: 24 + h: 6 +settings: + defaultTimeframe: + value: + from: now()-14d + to: now() + enabled: true +importedWithCode: false diff --git a/docs/dashboards/costs-monitoring/img/rs-credits-analysis.png b/docs/dashboards/costs-monitoring/img/rs-credits-analysis.png new file mode 100644 index 00000000..0e5f96ea Binary files /dev/null and b/docs/dashboards/costs-monitoring/img/rs-credits-analysis.png differ diff --git a/docs/dashboards/costs-monitoring/img/slow-queries-analysis.png b/docs/dashboards/costs-monitoring/img/slow-queries-analysis.png new file mode 100644 index 00000000..e7087e53 Binary files /dev/null and b/docs/dashboards/costs-monitoring/img/slow-queries-analysis.png differ diff --git a/docs/dashboards/costs-monitoring/img/whs-analysis.png b/docs/dashboards/costs-monitoring/img/whs-analysis.png new file mode 100644 index 00000000..2a58f924 Binary files /dev/null and b/docs/dashboards/costs-monitoring/img/whs-analysis.png differ diff --git a/docs/dashboards/costs-monitoring/img/whs-missing-rs.png b/docs/dashboards/costs-monitoring/img/whs-missing-rs.png new file mode 100644 index 00000000..b76e37c7 Binary files /dev/null and b/docs/dashboards/costs-monitoring/img/whs-missing-rs.png differ diff --git a/docs/dashboards/costs-monitoring/img/whs-resume-suspend-delay.png b/docs/dashboards/costs-monitoring/img/whs-resume-suspend-delay.png new file mode 100644 index 00000000..1e6dbf21 Binary files /dev/null and b/docs/dashboards/costs-monitoring/img/whs-resume-suspend-delay.png differ diff --git a/docs/dashboards/costs-monitoring/readme.md b/docs/dashboards/costs-monitoring/readme.md new file mode 100644 index 00000000..061cdb25 --- /dev/null +++ b/docs/dashboards/costs-monitoring/readme.md @@ -0,0 +1,26 @@ +# Dashboard: Costs Monitoring + +This dashboard provides insights into the costs associated with your Snowflake usage. It includes visualizations and metrics that help you monitor and analyze your spending patterns, identify cost drivers, and optimize your resource allocation. + +## Cost Monitoring + +- Tracks credits used over time. +- Displays the credit quota for resource monitors. +- Shows the percentage of credit quota used, with forecasting to predict future usage. +![Monitoring Credits Consumption](./img/rs-credits-analysis.png) +- Identifies warehouses that are not assigned to a resource monitor, which can lead to uncontrolled costs. +![Missing Resource Monitors Monitoring Warehouses](./img/whs-missing-rs.png) + +## Warehouse Performance + +- Visualizes query execution time, queued overload time, and queued provisioning time per warehouse. +![Warehouse Performance Metrics](./img/whs-analysis.png) +- Shows delays in resuming and suspending warehouses. +![Warehouse Resume and Suspend Delays](./img/whs-resume-suspend-delay.png) + +## Slow Query Analysis + +- Identifies queries running longer than a configurable threshold. +- Lists currently active slow queries, with additional analysis to detect queries which might exhaust warehouse credits. +- Provides details on historical slow queries, including the user, warehouse, and query text. +![Slow Queries Analysis Section](./img/slow-queries-analysis.png) diff --git a/docs/dashboards/self-monitoring/img/01-plugin-execution-overview.png b/docs/dashboards/self-monitoring/img/01-plugin-execution-overview.png new file mode 100644 index 00000000..d9ea6e67 Binary files /dev/null and b/docs/dashboards/self-monitoring/img/01-plugin-execution-overview.png differ diff --git a/docs/dashboards/self-monitoring/img/02-plugin-execution-times.png b/docs/dashboards/self-monitoring/img/02-plugin-execution-times.png new file mode 100644 index 00000000..35ae139a Binary files /dev/null and b/docs/dashboards/self-monitoring/img/02-plugin-execution-times.png differ diff --git a/docs/dashboards/self-monitoring/img/03-plugin-tasks-executions.png b/docs/dashboards/self-monitoring/img/03-plugin-tasks-executions.png new file mode 100644 index 00000000..923de830 Binary files /dev/null and b/docs/dashboards/self-monitoring/img/03-plugin-tasks-executions.png differ diff --git a/docs/dashboards/self-monitoring/readme.md b/docs/dashboards/self-monitoring/readme.md new file mode 100644 index 00000000..b9a2e6c2 --- /dev/null +++ b/docs/dashboards/self-monitoring/readme.md @@ -0,0 +1,22 @@ +# Dashboard: DSOA Self-Monitoring + +This dashboard provides a comprehensive overview of the Dynatrace Snowflake Open Source Agent (DSOA) itself, focusing on its operational health, performance, and resource consumption. It is designed to help administrators monitor the agent's activity, identify performance bottlenecks, and troubleshoot any issues that may arise during its execution. + +## Agent Health and Performance + +- Displays the number of monitored Snowflake accounts. +- Shows the volume of log lines produced by the agent, categorized by data type. +- Tracks the total elapsed time and execution count for each plugin, helping to identify the most resource-intensive tasks. +![Agent Health Overview](./img/01-plugin-execution-overview.png) + +## Plugin Execution Analysis + +- Visualizes the execution time for each plugin, based on both business events and query history. This allows for a detailed analysis of how long each data collection task takes to complete. +- Helps in identifying performance trends and spotting anomalies in plugin execution times. +![Plugin Execution Time](./img/02-plugin-execution-times.png) + +## Execution Failures and Details + +- Monitors for any failed plugin executions, providing immediate visibility into operational errors. +- Lists the most recent plugin executions with their status and environment, allowing for quick inspection and troubleshooting. +![Plugin Execution Failures](./img/03-plugin-tasks-executions.png) diff --git a/docs/dashboards/self-monitoring/self-monitoring.yaml b/docs/dashboards/self-monitoring/self-monitoring.yaml new file mode 100644 index 00000000..678567c3 --- /dev/null +++ b/docs/dashboards/self-monitoring/self-monitoring.yaml @@ -0,0 +1,558 @@ +# +# Copyright (c) 2025 Dynatrace Open Source +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the Software), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# DASHBOARD: DSOA Self Monitoring +# DESCRIPTION: Self-monitoring dashboard for Dynatrace Snowflake Open Source Agent (DSOA). +# OWNER: sebastian.kruk +# PLUGINS: query_history +# TAGS: self-monitoring +# +version: 19 +variables: + - key: Accounts + version: 2 + type: query + visible: true + editable: true + input: |- + fetch logs + | filter db.system == "snowflake" + | fields deployment.environment + | dedup deployment.environment + | sort deployment.environment + multiple: true + defaultValue: + - 3420b2ac-f1cf-4b24-b62d-61ba1ba8ed05* + - key: Plugin_Names + visible: true + type: query + version: 2 + editable: true + input: |- + fetch logs + | filter db.system == "snowflake" + | filter dsoa.run.context == "query_history" + | filter in(deployment.environment, array($Accounts)) + | filter matchesPattern(db.query.text, + """'call DTAGENT' ('_' LD:tag)? '_DB.APP.DTAGENT(ARRAY_CONSTRUCT(' ARRAY{SQS:plugin_name ', '?}{1,}:plugin_names '))'""") + | parse `db.query.text`, """'call DTAGENT' ('_' LD:env_tag)? '_DB.APP.DTAGENT(ARRAY_CONSTRUCT(' ARRAY{SQS:plugin_name ', '?}{1,}:plugin_names '))'""" + | expand plugin_name = plugin_names + | fields plugin_name + | dedup plugin_name + | sort plugin_name + multiple: true + defaultValue: + - 3420b2ac-f1cf-4b24-b62d-61ba1ba8ed05* + - key: Plugin_Contexts + visible: true + type: query + version: 2 + editable: true + input: |- + fetch logs + | filter db.system == "snowflake" + | filter dsoa.run.context == "query_history" + | filter in(deployment.environment, array($Accounts)) + | filter matchesPattern(db.query.text, + """'call DTAGENT' ('_' LD:tag)? '_DB.APP.DTAGENT(ARRAY_CONSTRUCT(' ARRAY{SQS:plugin_name ', '?}{1,}:plugin_names '))'""") + | parse `db.query.text`, """'call DTAGENT' ('_' LD:env_tag)? '_DB.APP.DTAGENT(ARRAY_CONSTRUCT(' ARRAY{SQS:plugin_name ', '?}{1,}:plugin_names '))'""" + | expand plugin_name = plugin_names + | fields plugin_name + | filter in(plugin_name, array($Plugin_Names)) + | dedup plugin_name + | join [ + data json:"""[ + { + "plugin_name": "dynamic_tables", + "contexts": [ + "dynamic_tables", + "dynamic_table_refresh_history", + "dynamic_table_graph_history" + ] + }, + { + "plugin_name": "event_log", + "contexts": [ + "event_log", + "event_log_metrics", + "event_log_spans" + ] + }, + { + "plugin_name": "login_history", + "contexts": [ + "login_history", + "sessions" + ] + }, + { + "plugin_name": "shares", + "contexts": [ + "shares", + "outbound_shares", + "inbound_shares" + ] + }, + { + "plugin_name": "tasks", + "contexts": [ + "serverless_tasks", + "task_versions", + "task_history" + ] + }, + { + "plugin_name": "warehouse_usage", + "contexts": [ + "warehouse_usage", + "warehouse_usage_load", + "warehouse_usage_metering" + ] + } + ]""" + ] + , on:{plugin_name} + , fields: {contexts} + , kind: leftOuter + | fields contexts = coalesce(contexts, array(plugin_name)) + | expand context = contexts + | fields context + | dedup context + | sort context + multiple: true + defaultValue: + - 3420b2ac-f1cf-4b24-b62d-61ba1ba8ed05* +tiles: + "1": + title: Plugin execution time (bizevents) + type: data + query: |- + fetch bizevents + | filter db.system == "snowflake" + | filter dsoa.run.context == "self-monitoring" + | filter in(deployment.environment, array($Accounts)) + | filter in(dsoa.task.name, array($Plugin_Names)) + | sort timestamp asc + | summarize { + timestamp = takeFirst(timestamp), + dsoa.run.duration = max(timestamp) - min(timestamp), + count = count() + }, by: { + deployment.environment, + deployment.environment.tag = env_tag, + dsoa.task.exec.id, + dsoa.task.name + } + | filter count > 1 + | makeTimeseries { + dsoa.run.duration = sum(dsoa.run.duration) + }, by: { + dsoa.run.context = dsoa.task.name + } + visualization: lineChart + visualizationSettings: + chartSettings: + truncationMode: middle + xAxisLabel: timeframe + xAxisScaling: auto + fieldMapping: + leftAxisValues: + - dsoa.run.duration + timestamp: timeframe + curve: smooth + gapPolicy: connect + dataMapping: + displayedFields: + - dsoa.run.context + thresholds: [] + unitsOverrides: + - identifier: snowagent.run.duration + unitCategory: time + baseUnit: nanosecond + displayUnit: null + decimals: 2 + suffix: "" + delimiter: false + added: 1727938388826 + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "2": + title: Failed plugin executions + type: data + query: | + fetch logs + | filter db.system == "snowflake" + | filter dsoa.run.context == "query_history" + | filter in(deployment.environment, array($Accounts)) + | filter snowflake.query.execution_status != "SUCCESS" + | filter matchesPattern(db.query.text, + """'call DTAGENT' ('_' LD:tag)? '_DB.APP.DTAGENT(ARRAY_CONSTRUCT(' ARRAY{SQS:plugin_name ', '?}{1,}:plugin_names '))'""") + | parse `db.query.text`, """'call DTAGENT' ('_' LD:env_tag)? '_DB.APP.DTAGENT(ARRAY_CONSTRUCT(' ARRAY{SQS:plugin_name ', '?}{1,}:plugin_names '))'""" + | expand plugin_name = plugin_names + | fields plugin_name, timestamp, snowflake.query.execution_status + | makeTimeseries count(), by: { + plugin_name, snowflake.query.execution_status + } + visualization: barChart + visualizationSettings: + chartSettings: + truncationMode: middle + xAxisLabel: timeframe + xAxisScaling: analyzedTimeframe + fieldMapping: + leftAxisValues: + - count() + timestamp: timeframe + thresholds: [] + unitsOverrides: + - identifier: sum(snowflake.total_elapsed_time) + unitCategory: time + baseUnit: millisecond + displayUnit: null + decimals: 2 + suffix: "" + delimiter: false + added: 1727938388826 + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "3": + title: Plugin execution count + type: data + query: |- + fetch bizevents + | filter db.system == "snowflake" + | filter dsoa.run.context == "self-monitoring" + | filter in(deployment.environment, array($Accounts)) + | filter in(dsoa.task.name, array($Plugin_Names)) + | sort timestamp asc + | summarize { + count = count() + }, by: { + deployment.environment, + dsoa.task.exec.id, + dsoa.task.name + } + | filter count > 1 + | summarize { + dsoa.run.duration = count() + }, by: { + dsoa.run.context = dsoa.task.name + } + visualization: honeycomb + visualizationSettings: + honeycomb: + colorMode: color-palette + colorPalette: blue + dataMappings: + value: dsoa.run.duration + displayedFields: + - dsoa.run.context + legend: + position: right + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "4": + title: Plugin total elapse time + type: data + query: |- + fetch bizevents + | filter db.system == "snowflake" + | filter dsoa.run.context == "self-monitoring" + | filter in(deployment.environment, array($Accounts)) + | filter in(dsoa.task.name, array($Plugin_Names)) + | sort timestamp asc + | summarize { + dsoa.run.duration = takeLast(timestamp) - takeFirst(timestamp), + count = count() + }, by: { + deployment.environment, + dsoa.task.exec.id, + dsoa.task.name + } + | filter count > 1 + | summarize { + dsoa.run.duration = sum(dsoa.run.duration) + }, by: { + dsoa.run.context = dsoa.task.name + } + visualization: honeycomb + visualizationSettings: + honeycomb: + colorMode: color-palette + colorPalette: orange + dataMappings: + value: dsoa.run.duration + displayedFields: + - dsoa.run.context + legend: + position: right + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "5": + title: Log lines produced per data type + type: data + query: | + fetch logs + | filter db.system == "snowflake" + | filter in(deployment.environment, array($Accounts)) + | filter in(dsoa.run.context, array($Plugin_Contexts)) + | summarize by: { + plugin_name = dsoa.run.context + }, { + count() + } + visualization: honeycomb + visualizationSettings: + honeycomb: + legend: + position: right + dataMappings: + value: count() + displayedFields: + - plugin_name + colorPalette: blue + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "8": + title: Plugin executions + type: data + query: |- + fetch bizevents + | filter db.system == "snowflake" + | filter dsoa.run.context == "self-monitoring" + | filter in(deployment.environment, array($Accounts)) + | filter in(dsoa.task.name, array($Plugin_Names)) + | sort timestamp desc + | fields timestamp, dsoa.task.name, deployment.environment + | limit 50 + visualization: table + visualizationSettings: + table: + columnWidths: + '["deployment.environment"]': 132.984375 + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "9": + title: Accounts + type: data + query: |- + fetch logs + | filter db.system == "snowflake" + | filter in(deployment.environment, array($Accounts)) + | summarize by: { + deployment.environment, host.name + }, { + count() + } + visualization: honeycomb + visualizationSettings: + honeycomb: + shape: square + dataMappings: + value: count() + displayedFields: + - deployment.environment + colorPalette: blue + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "10": + title: Query execution time by plugin + type: data + query: |- + fetch logs + | filter db.system == "snowflake" + | filter dsoa.run.context == "query_history" + | filter in(deployment.environment, array($Accounts)) + | filter matchesPattern(db.query.text, + """'call DTAGENT' ('_' LD:tag)? '_DB.APP.DTAGENT(ARRAY_CONSTRUCT(' ARRAY{SQS:plugin_name ', '?}{1,}:plugin_names '))'""") + | parse `db.query.text`, """'call DTAGENT' ('_' LD:env_tag)? '_DB.APP.DTAGENT(ARRAY_CONSTRUCT(' ARRAY{SQS:plugin_name ', '?}{1,}:plugin_names '))'""" + | fieldsAdd plugins_count = arraySize(plugin_names) + | expand plugin_name = plugin_names + | filter in(plugin_name, array($Plugin_Names)) + | fields plugin_name, timestamp, snowflake.query.execution_status, + snowflake.time.total_elapsed = toLong(snowflake.time.total_elapsed) / plugins_count, + snowflake.time.execution = toLong(snowflake.time.execution) / plugins_count, + snowflake.time.compilation = toLong(snowflake.time.compilation) / plugins_count + | makeTimeseries sum(snowflake.time.total_elapsed), by: { + plugin_name + } + visualization: lineChart + visualizationSettings: + chartSettings: + truncationMode: middle + xAxisLabel: timeframe + xAxisScaling: auto + fieldMapping: + leftAxisValues: + - sum(snowflake.time.total_elapsed) + timestamp: timeframe + curve: smooth + gapPolicy: connect + dataMapping: + displayedFields: + - plugin_name + thresholds: [] + unitsOverrides: + - identifier: sum(snowflake.time.total_elapsed) + unitCategory: time + baseUnit: millisecond + displayUnit: null + decimals: 2 + suffix: "" + delimiter: false + added: 1727938388826 + legend: + showLegend: false + position: auto + ratio: 10 + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null +layouts: + "1": + x: 0 + "y": 7 + w: 24 + h: 6 + "2": + x: 0 + "y": 19 + w: 15 + h: 6 + "3": + x: 18 + "y": 0 + w: 6 + h: 7 + "4": + x: 11 + "y": 0 + w: 7 + h: 7 + "5": + x: 3 + "y": 0 + w: 8 + h: 7 + "8": + x: 15 + "y": 19 + w: 9 + h: 6 + "9": + x: 0 + "y": 0 + w: 3 + h: 7 + "10": + x: 0 + "y": 13 + w: 24 + h: 6 +importedWithCode: false +settings: + defaultTimeframe: + value: + from: now()-24h + to: now() + enabled: true diff --git a/docs/dashboards/snowflake-security/img/01-trust-center.png b/docs/dashboards/snowflake-security/img/01-trust-center.png new file mode 100644 index 00000000..dec5b32d Binary files /dev/null and b/docs/dashboards/snowflake-security/img/01-trust-center.png differ diff --git a/docs/dashboards/snowflake-security/img/02-admin-activity.png b/docs/dashboards/snowflake-security/img/02-admin-activity.png new file mode 100644 index 00000000..40bc0cbc Binary files /dev/null and b/docs/dashboards/snowflake-security/img/02-admin-activity.png differ diff --git a/docs/dashboards/snowflake-security/img/03-login-problems.png b/docs/dashboards/snowflake-security/img/03-login-problems.png new file mode 100644 index 00000000..f259a2a2 Binary files /dev/null and b/docs/dashboards/snowflake-security/img/03-login-problems.png differ diff --git a/docs/dashboards/snowflake-security/img/04-logins-by-auth-type.png b/docs/dashboards/snowflake-security/img/04-logins-by-auth-type.png new file mode 100644 index 00000000..52499220 Binary files /dev/null and b/docs/dashboards/snowflake-security/img/04-logins-by-auth-type.png differ diff --git a/docs/dashboards/snowflake-security/readme.md b/docs/dashboards/snowflake-security/readme.md new file mode 100644 index 00000000..1884ed84 --- /dev/null +++ b/docs/dashboards/snowflake-security/readme.md @@ -0,0 +1,31 @@ +# Dashboard: Snowflake Security + +This dashboard provides insights into the security aspects of your Snowflake accounts. It includes visualizations and metrics that help you monitor user authentication, login issues, administrative activity, and security compliance based on Snowflake's Trust Center. + +## Consolidating Trust Center Findings for Enhanced Security Management + +- Centralizes findings from Snowflake's internal Trust Center, which consolidates security-related tests and queries to provide a comprehensive overview of vulnerabilities and compliance issues. +- Enables efficient comparison of findings across multiple accounts to identify those with the most pressing security problems, a process that would otherwise require manual logins to each account. +- Allows security teams to prioritize and address critical security concerns efficiently, improving risk management and ensuring compliance with industry standards. +![Trust Center monitoring](./img/01-trust-center.png) + +## Query History of Users with Excessive Privileges + +- Monitors the query history of users with excessive privileges (e.g., admin roles) to safeguard sensitive data and detect potential misuse. +- Analyzes query patterns and helps identify unusual or unauthorized access to sensitive information, ensuring that powerful accounts are used responsibly. +- This proactive oversight helps maintain data integrity, prevent insider threats, and enforce strict access controls. +![Admin activity monitoring](./img/02-admin-activity.png) + +## Monitoring Failed Login Attempts for Early Threat Detection + +- Tracks failed login attempts to identify potential brute force attacks and unauthorized access attempts, enabling the Incident Detection and Response (IDR) team to take immediate action. +- By analyzing patterns of failed logins, it helps detect ongoing attacks and allows for a swift response to prevent security breaches. +- Provides a detailed log of login incidents for further investigation and forensic analysis. +![Problems with login to Snowflake](./img/03-login-problems.png) + +## Enforcing Secure Authentication Methods + +- Identifies which users need to be migrated to stronger authentication methods like Multi-Factor Authentication (MFA) or Single Sign-On (SSO), as Snowflake will soon discontinue support for logins using only a username and password. +- For service accounts, it helps ensure they are configured with secure, non-password methods such as Key-Pair Authentication, Programmatic Access Tokens (PAT), External OAuth, or Workload Identity Federation (WIF). +- Tracks authentication methods used by both human and service users to monitor the transition to more secure practices. +![Login Analysis](./img/04-logins-by-auth-type.png) diff --git a/docs/dashboards/snowflake-security/snowflake-security.yaml b/docs/dashboards/snowflake-security/snowflake-security.yaml new file mode 100644 index 00000000..7ed1adbc --- /dev/null +++ b/docs/dashboards/snowflake-security/snowflake-security.yaml @@ -0,0 +1,1056 @@ +# +# Copyright (c) 2025 Dynatrace Open Source +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the Software), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# DASHBOARD: Snowflake Security +# DESCRIPTION: Snowflake Security monitoring - login issues, admin activity, trust center issues +# OWNER: sebastian.kruk +# PLUGINS: login_history, query_history, trust_center +# TAGS: security +# +version: 19 +variables: + - version: 2 + key: Environment + type: query + visible: true + editable: true + input: |- + fetch logs + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "login_history" + | fields deployment.environment + | dedup deployment.environment + | sort deployment.environment asc + multiple: true + defaultValue: + - 3420b2ac-f1cf-4b24-b62d-61ba1ba8ed05* + - version: 2 + key: Snowflake_Role_Name + type: query + visible: true + editable: true + input: |- + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "query_history" + | filter in(deployment.environment, array($Environment)) + | filter in(snowflake.role.name, + array(splitString($Additional_ADMIN_Roles, "|"), + {"ACCOUNTADMIN", "SECURITYADMIN", "SYSADMIN", "USERADMIN"} + ) + ) + | fields snowflake.role.name + | dedup snowflake.role.name + | sort snowflake.role.name + multiple: true + defaultValue: + - 3420b2ac-f1cf-4b24-b62d-61ba1ba8ed05* + - version: 2 + key: Query_Execution_Status + type: query + visible: true + editable: true + input: |- + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "query_history" + | filter in(deployment.environment, array($Environment)) + | filter in(snowflake.role.name, array($Snowflake_Role_Name)) + | fields snowflake.query.execution_status + | dedup snowflake.query.execution_status + | sort snowflake.query.execution_status asc + multiple: true + defaultValue: + - 3420b2ac-f1cf-4b24-b62d-61ba1ba8ed05* + - version: 2 + key: Operation_Name + type: query + visible: true + editable: true + input: |- + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "query_history" + | filter in(deployment.environment, array($Environment)) + | filter in(snowflake.role.name, array($Snowflake_Role_Name)) + | fields db.operation.name + | dedup db.operation.name + | sort db.operation.name + multiple: true + defaultValue: + - 3420b2ac-f1cf-4b24-b62d-61ba1ba8ed05* + - version: 2 + key: TrustCenter_Risk_Level + type: query + visible: true + editable: true + input: |- + fetch logs + | filter db.system == "snowflake" + and (dsoa.run.context == "trust_center" or snowagent.run.context == "trust_center") + and in(deployment.environment, array($Environment)) + | summarize risk_level = collectDistinct(record(level=vulnerability.risk.level, id=coalesce( + if(vulnerability.risk.level == "CRITICAL", 0), + if(vulnerability.risk.level == "HIGH", 1), + if(vulnerability.risk.level == "MEDIUM", 2), + if(vulnerability.risk.level == "LOW", 3), + 4 + ))) + | expand risk_level + | sort risk_level[id] + | summarize risk_level = collectDistinct(risk_level[level]) + multiple: true + defaultValue: + - 3420b2ac-f1cf-4b24-b62d-61ba1ba8ed05* + - version: 2 + key: Login_Problems + type: query + visible: true + editable: true + input: |- + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "login_history" + | filter isNotNull(error.code) + | filter in(deployment.environment, array($Environment)) + | filter if(in("Human user", array($Logins_User_Types)), matchesValue(db.user, "*.*")) + or if(in("Service user", array($Logins_User_Types)), not matchesValue(db.user, "*.*")) + | fields status.message + | dedup status.message + | sort status.message asc + multiple: true + defaultValue: + - 3420b2ac-f1cf-4b24-b62d-61ba1ba8ed05* + - version: 2 + key: Logins_User_Types + type: query + visible: true + editable: true + input: data record(login_user_type = "Human user"), record(login_user_type = "Service user") + multiple: true + defaultValue: + - 3420b2ac-f1cf-4b24-b62d-61ba1ba8ed05* + - version: 2 + key: Exclude_SYSTEM_user + type: query + visible: true + editable: true + input: data record(sysusr = "Yes"), record(sysusr = "No") + multiple: false + - version: 2 + key: Exclude_our_system_users + type: query + visible: false + editable: true + input: | + fetch logs + | filter db.system == "snowflake" + and db.user == "TERRAFORM_USER" + | summarize db_user = collectDistinct(db.user) + // | fields db_user_and_all = array("*", db_user) + multiple: false + - version: 2 + key: Additional_ADMIN_Roles + type: query + visible: false + editable: true + input: data record(roles="DEMIGOD|DTAGENT_ADMIN") + multiple: false + defaultValue: DEMIGOD|DTAGENT_ADMIN +tiles: + "2": + title: Top 10 users with login problems + type: data + query: | + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "login_history" + | filter isNotNull(error.code) + // -- BEGIN: env filters + | filter in(deployment.environment, array($Environment)) + | filter if(in("Human user", array($Logins_User_Types)), matchesValue(db.user, "*.*")) + or if(in("Service user", array($Logins_User_Types)), not matchesValue(db.user, "*.*")) + | filter in(status.message, array($Login_Problems)) + // -- END: env filters| fields timestamp, db.user, deployment.environment, status.message + | fieldsAdd db.user=hashSha1(db.user) + | summarize cnt = count(), by: { + db.user + } + | sort cnt desc + | limit 10 + visualization: categoricalBarChart + visualizationSettings: + chartSettings: + truncationMode: middle + legend: + hidden: true + categoricalBarChartSettings: + categoryAxisLabel: db.user + categoryAxis: + - db.user + valueAxis: + - cnt + valueAxisLabel: cnt + colorPalette: fireplace + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 100 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "3": + title: Top 10 client IP addresses with login problems + type: data + query: | + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "login_history" + | filter isNotNull(error.code) + // -- BEGIN: env filters + | filter in(deployment.environment, array($Environment)) + | filter if(in("Human user", array($Logins_User_Types)), matchesValue(db.user, "*.*")) + or if(in("Service user", array($Logins_User_Types)), not matchesValue(db.user, "*.*")) + | filter in(status.message, array($Login_Problems)) + | parse `client.environment`, """JSON{ + DATA:application + }(strict=false):client""" + | fieldsAdd client.application = coalesce(client[application], client.application.id) + // | filter ($client_application == "*" or client.application == $client_application) + | filterOut client.ip == "0.0.0.0" + // -- END: env filters + | fields timestamp, db.user, deployment.environment, client.ip=substring(client.ip, from:0, to:3) + | summarize cnt = count(), by: { + client.ip + } + | sort cnt desc + | limit 10 + visualization: categoricalBarChart + visualizationSettings: + chartSettings: + truncationMode: middle + legend: + hidden: true + categoricalBarChartSettings: + categoryAxisLabel: client.ip + categoryAxis: + - client.ip + valueAxis: + - cnt + valueAxisLabel: cnt + colorPalette: fireplace + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 100 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "6": + type: markdown + content: '### Problems with login to Snowflake' + davis: + componentState: + inputData: null + "9": + type: markdown + content: | + ### Logins by people and service users by authentication type + davis: + componentState: + inputData: null + "17": + title: Admin roles activity over time + description: admin activity monitoring + type: data + query: | + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "query_history" + and in(snowflake.role.name, array($Snowflake_Role_Name)) + and in(deployment.environment, array($Environment)) + and in(snowflake.query.execution_status, $Query_Execution_Status) + and in(db.operation.name, array($Operation_Name)) + // | filter db.sql.table=="query_history" + | filterOut if($Exclude_SYSTEM_user == "Yes", db.user == "SYSTEM") or in(db.user, $Exclude_our_system_users) + | fields db.user, snowflake.role.name, content, timestamp + | makeTimeseries cnt = count(), by: { + db.user, + snowflake.role.name + } + , bins: 20 + // | sort cnt desc + visualization: barChart + visualizationSettings: + dataMapping: + displayedFields: + - snowflake.role.name + - db.user + chartSettings: + truncationMode: start + xAxisLabel: timeframe + xAxisScaling: analyzedTimeframe + colorPalette: blue + tooltip: + variant: shared + seriesDisplayMode: multi-line + fieldMapping: + leftAxisValues: + - cnt + timestamp: timeframe + legend: + ratio: 11 + autoSelectVisualization: false + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + timeframe: + tileTimeframe: + from: now()-2h + to: now() + tileTimeframeEnabled: false + "19": + type: markdown + content: | + ### Admin activity monitoring + davis: + componentState: + inputData: null + "20": + title: Top 10 Users with admin activity + description: admin activity monitoring + type: data + query: |- + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "query_history" + and in(deployment.environment, array($Environment)) + and in(snowflake.role.name, array($Snowflake_Role_Name)) + and in(snowflake.query.execution_status, array($Query_Execution_Status)) + and in(db.operation.name, array($Operation_Name)) + | filterOut if($Exclude_SYSTEM_user == "Yes", db.user == "SYSTEM") or in(db.user, $Exclude_our_system_users) + | fields db.user, snowflake.role.name, content, timestamp + | summarize cnt = count(), by: { + db.user + } + | sort cnt desc + | limit 10 + visualization: categoricalBarChart + visualizationSettings: + chartSettings: + truncationMode: middle + categoricalBarChartSettings: + categoryAxisLabel: db.user + categoryAxis: + - db.user + valueAxis: + - cnt + valueAxisLabel: cnt + colorPalette: blue-turquoise + autoSelectVisualization: false + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + timeframe: + tileTimeframe: + from: now()-2h + to: now() + tileTimeframeEnabled: false + "21": + title: Security Violations - Table + type: data + query: | + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "trust_center" + and in(deployment.environment, array($Environment)) + and in(vulnerability.risk.level, array($TrustCenter_Risk_Level)) + | fields timestamp, status.message, event.category, vulnerability.risk.level, snowflake.trust_center.scanner.type, + snowflake.trust_center.scanner.id, deployment.environment + | append [ + fetch events + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "trust_center" + and in(deployment.environment, array($Environment)) + and in(vulnerability.risk.level, array($TrustCenter_Risk_Level)) + | fields timestamp, vulnerability.risk.level, snowflake.trust_center.scanner.id, deployment.environment + ] + | sort timestamp desc + | summarize { + last_timestamp = takeFirst(timestamp) + }, by: { + status.message, + event.category, + vulnerability.risk.level, + snowflake.trust_center.scanner.type, + snowflake.trust_center.scanner.id, + deployment.environment + } + | fields + `Scan Date`=formatTimestamp(last_timestamp, format:"yyyy-MM-dd"), + `Problem Descriptions`=status.message, + `Problem Category`=event.category, + `Risk Level`=vulnerability.risk.level, + `Scanner Type`=snowflake.trust_center.scanner.type, + `Scanner ID`=snowflake.trust_center.scanner.id, + `Environment`=deployment.environment + visualization: table + visualizationSettings: + table: + sortBy: + columnId: '["Scan Time"]' + direction: descending + columnWidths: + '["event.category"]': 265.5 + '["status.message"]': 746 + '["Problem Descriptions"]': 534 + columnTypeOverrides: + - fields: + - content + id: 1740574981135 + value: log-content + autoSelectVisualization: true + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + timeframe: + tileTimeframe: + from: now()-30d + to: now() + tileTimeframeEnabled: false + "22": + title: List of admin activity (limit to last 1k results) + description: admin activity monitoring + type: data + query: | + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "query_history" + and in(deployment.environment, array($Environment)) + and in(snowflake.role.name, array($Snowflake_Role_Name)) + and isNotNull(db.query.text) + and in(snowflake.query.execution_status, array($Query_Execution_Status)) + and in(db.operation.name, array($Operation_Name)) + | filterOut if($Exclude_SYSTEM_user == "Yes", db.user == "SYSTEM") or in(db.user, $Exclude_our_system_users) + // | filter db.sql.table=="query_history" + | fields db.user, snowflake.role.name, deployment.environment, db.query.text, timestamp, db.operation.name, + snowflake.query.execution_status + | sort timestamp desc + | limit 1000 + visualization: table + visualizationSettings: + table: + columnWidths: + '["deployment.environment"]': 172 + columnTypeOverrides: + - fields: + - content + id: 1740575161776 + value: log-content + autoSelectVisualization: false + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + timeframe: + tileTimeframe: + from: now()-2h + to: now() + tileTimeframeEnabled: false + "23": + title: Top Role name with admin activity + description: admin activity monitoring + type: data + query: |- + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "query_history" + and in(deployment.environment, array($Environment)) + and in(snowflake.role.name, array($Snowflake_Role_Name)) + and in(snowflake.query.execution_status, array($Query_Execution_Status)) + and in(db.operation.name, array($Operation_Name)) + | filterOut if($Exclude_SYSTEM_user == "Yes", db.user == "SYSTEM") or in(db.user, $Exclude_our_system_users) + | fields db.user, snowflake.role.name, content, timestamp + | summarize cnt = count(), by: { + snowflake.role.name + } + | sort cnt desc + | limit 10 + visualization: categoricalBarChart + visualizationSettings: + chartSettings: + truncationMode: middle + categoricalBarChartSettings: + categoryAxisLabel: snowflake.role.name + categoryAxis: + - snowflake.role.name + valueAxis: + - cnt + valueAxisLabel: cnt + colorPalette: blue + autoSelectVisualization: false + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + timeframe: + tileTimeframe: + from: now()-2h + to: now() + tileTimeframeEnabled: false + "24": + type: markdown + content: '### Trust Center monitoring' + davis: + componentState: + inputData: null + "25": + title: Security Violations + type: data + query: | + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "trust_center" + and in(deployment.environment, array($Environment)) + and in(vulnerability.risk.level, array($TrustCenter_Risk_Level)) + | fields timestamp, vulnerability.risk.level, snowflake.trust_center.scanner.id, deployment.environment + | fieldsAdd full_date = timestamp(getYear(timestamp), getMonth(timestamp), getDayOfMonth(timestamp), 0, 0, 0) + | append [ + fetch events + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "trust_center" + and in(deployment.environment, array($Environment)) + and in(vulnerability.risk.level, array($TrustCenter_Risk_Level)) + | fields timestamp, vulnerability.risk.level, snowflake.trust_center.scanner.id, deployment.environment + | fieldsAdd full_date = timestamp(getYear(timestamp), getMonth(timestamp), getDayOfMonth(timestamp), 0, 0, 0) + ] + | makeTimeseries countDistinct(snowflake.trust_center.scanner.id), by: { + vulnerability.risk.level, deployment.environment + } + visualization: areaChart + visualizationSettings: + autoSelectVisualization: false + dataMapping: + displayedFields: + - vulnerability.risk.level + - deployment.environment + chartSettings: + truncationMode: middle + xAxisLabel: timeframe + xAxisScaling: analyzedTimeframe + seriesOverrides: + - seriesId: + - LOW + override: + color: + Default: 'var(--dt-colors-charts-logstatus-none-default, #2c2f3f)' + - seriesId: + - MEDIUM + override: + color: + Default: 'var(--dt-colors-charts-categorical-color-01-default, #134fc9)' + fieldMapping: + leftAxisValues: + - countDistinct(snowflake.trust_center.scanner.id) + timestamp: timeframe + gapPolicy: connect + legend: + ratio: 15 + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "26": + title: Distinct users by authentication type + type: data + query: | + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "login_history" + // -- BEGIN: env filters + | filter in(deployment.environment, array($Environment)) + | filter if(in("Human user", array($Logins_User_Types)), matchesValue(db.user, "*.*")) + or if(in("Service user", array($Logins_User_Types)), not matchesValue(db.user, "*.*")) + | filter exists(authentication.factor.first) + | fields db.user, authentication.factor.first + | summarize countDistinct(db.user), by: { + authentication.factor.first + } + visualization: pieChart + visualizationSettings: + chartSettings: + truncationMode: middle + legend: + position: right + categoricalBarChartSettings: + valueAxis: + - countDistinct(db.user) + valueAxisLabel: countDistinct(db.user) + categoryAxis: + - authentication.factor.first + categoryAxisLabel: authentication.factor.first + circleChartSettings: + valueType: relative + groupingThresholdType: relative + legend: + ratio: 47 + autoSelectVisualization: false + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "27": + title: Distinct users using password + type: data + query: | + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "login_history" + // -- BEGIN: env filters + | filter in(deployment.environment, array($Environment)) + | filter if(in("Human user", array($Logins_User_Types)), matchesValue(db.user, "*.*")) + or if(in("Service user", array($Logins_User_Types)), not matchesValue(db.user, "*.*")) + | filter exists(authentication.factor.first) + and matchesValue(authentication.factor.first, "PASSWORD") + | fields db.user + | summarize countDistinct(db.user) + visualization: singleValue + visualizationSettings: + singleValue: + labelMode: none + label: countDistinct(db.user) + recordField: countDistinct(db.user) + prefixIcon: "" + trend: + isVisible: true + autoSelectVisualization: false + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "28": + title: Human logins history using password - full list + type: data + query: |- + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "login_history" + // -- BEGIN: env filters + | filter in(deployment.environment, array($Environment)) + | filter if(in("Human user", array($Logins_User_Types)), matchesValue(db.user, "*.*")) + or if(in("Service user", array($Logins_User_Types)), not matchesValue(db.user, "*.*")) + | filter exists(authentication.factor.first) + AND matchesValue(authentication.factor.first, "PASSWORD") + | summarize { + last_timestamp = takeLast(timestamp) + }, by:{ + deployment.environment, + db.user, + authentication.factor.first, + authentication.factor.second = coalesce(authentication.factor.second, "-") + } + | sort last_timestamp desc + | fields + `Last attempt`=last_timestamp, + `Environment`=deployment.environment, + `User`=hashSha1(db.user), + `First Auth Factor`=authentication.factor.first, + `Second Auth Factor`=authentication.factor.second + visualization: table + visualizationSettings: + table: + columnTypeOverrides: + - fields: + - content + id: 1741081597133 + value: log-content + autoSelectVisualization: false + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "30": + title: Top 10 Deployment Environment + type: data + query: |- + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "query_history" + and in(deployment.environment, array($Environment)) + and in(snowflake.role.name, array($Snowflake_Role_Name)) + and in(snowflake.query.execution_status, array($Query_Execution_Status)) + and in(db.operation.name, array($Operation_Name)) + | filterOut if($Exclude_SYSTEM_user == "Yes", db.user == "SYSTEM") or in(db.user, $Exclude_our_system_users) + | fields deployment.environment, timestamp + | summarize cnt = count(), by: { + deployment.environment + } + | sort cnt desc + | limit 10 + visualization: categoricalBarChart + visualizationSettings: + chartSettings: + truncationMode: middle + categoricalBarChartSettings: + categoryAxisLabel: deployment.environment + categoryAxis: + - deployment.environment + valueAxis: + - cnt + valueAxisLabel: cnt + colorPalette: brown + autoSelectVisualization: false + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 1 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "31": + title: Login incidents over time + type: data + query: | + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "login_history" + | filter isNotNull(error.code) + // -- BEGIN: env filters + | filter in(deployment.environment, array($Environment)) + | filter if(in("Human user", array($Logins_User_Types)), matchesValue(db.user, "*.*")) + or if(in("Service user", array($Logins_User_Types)), not matchesValue(db.user, "*.*")) + | filter in(status.message, array($Login_Problems)) + // -- END: env filters| fields timestamp, db.user, deployment.environment, status.message + | makeTimeseries count(), by: { + status.message, + deployment.environment + } + , bins: 20 + visualization: barChart + visualizationSettings: + chartSettings: + truncationMode: middle + legend: + hidden: true + colorPalette: fireplace + tooltip: + variant: shared + seriesDisplayMode: multi-line + legend: + ratio: 19 + autoSelectVisualization: false + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 100 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "32": + title: Top 10 environments with login problems + type: data + query: | + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "login_history" + | filter isNotNull(error.code) + // -- BEGIN: env filters + | filter in(deployment.environment, array($Environment)) + | filter if(in("Human user", array($Logins_User_Types)), matchesValue(db.user, "*.*")) + or if(in("Service user", array($Logins_User_Types)), not matchesValue(db.user, "*.*")) + | filter in(status.message, array($Login_Problems)) + // -- END: env filters| fields timestamp, db.user, deployment.environment, status.message + | summarize cnt = count(), by: { + deployment.environment + } + | sort cnt desc + | limit 10 + visualization: categoricalBarChart + visualizationSettings: + chartSettings: + truncationMode: middle + legend: + hidden: true + categoricalBarChartSettings: + categoryAxisLabel: deployment.environment + categoryAxis: + - deployment.environment + valueAxis: + - cnt + valueAxisLabel: cnt + colorPalette: fireplace + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 100 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null + "33": + title: Login incidents over time + type: data + query: |- + fetch logs + | filter db.system == "snowflake" + | filter coalesce(dsoa.run.context, snowagent.run.context, service.namespace) == "login_history" + | filter isNotNull(error.code) + // -- BEGIN: env filters + | filter in(deployment.environment, array($Environment)) + | filter if(in("Human user", array($Logins_User_Types)), matchesValue(db.user, "*.*")) + or if(in("Service user", array($Logins_User_Types)), not matchesValue(db.user, "*.*")) + | filter in(status.message, array($Login_Problems)) + // -- END: env filters| fields timestamp, db.user, deployment.environment, status.message + | fields `Timestamp`=timestamp, + `Environment`=deployment.environment, + `User`=hashSha1(db.user), + `Login Problem`=status.message + visualization: table + visualizationSettings: + autoSelectVisualization: false + thresholds: [] + querySettings: + maxResultRecords: 1000 + defaultScanLimitGbytes: 500 + maxResultMegaBytes: 100 + defaultSamplingRatio: 10 + enableSampling: false + davis: + enabled: false + davisVisualization: + isAvailable: true + componentState: + inputData: null +layouts: + "2": + x: 11 + "y": 46 + w: 13 + h: 6 + "3": + x: 11 + "y": 40 + w: 13 + h: 6 + "6": + x: 0 + "y": 33 + w: 24 + h: 1 + "9": + x: 0 + "y": 52 + w: 24 + h: 1 + "17": + x: 0 + "y": 14 + w: 24 + h: 7 + "19": + x: 0 + "y": 13 + w: 24 + h: 1 + "20": + x: 7 + "y": 21 + w: 9 + h: 6 + "21": + x: 0 + "y": 7 + w: 24 + h: 6 + "22": + x: 0 + "y": 27 + w: 24 + h: 6 + "23": + x: 16 + "y": 21 + w: 8 + h: 6 + "24": + x: 0 + "y": 0 + w: 24 + h: 1 + "25": + x: 0 + "y": 1 + w: 24 + h: 6 + "26": + x: 0 + "y": 53 + w: 7 + h: 7 + "27": + x: 7 + "y": 53 + w: 4 + h: 7 + "28": + x: 11 + "y": 53 + w: 13 + h: 7 + "30": + x: 0 + "y": 21 + w: 7 + h: 6 + "31": + x: 0 + "y": 34 + w: 24 + h: 6 + "32": + x: 0 + "y": 40 + w: 11 + h: 6 + "33": + x: 0 + "y": 46 + w: 11 + h: 6 +importedWithCode: false +settings: + defaultTimeframe: + value: + from: now()-7d + to: now() + enabled: true diff --git a/docs/active-queries-faq/dsoa-active-queries-example.png b/docs/debug/active-queries-faq/dsoa-active-queries-example.png similarity index 100% rename from docs/active-queries-faq/dsoa-active-queries-example.png rename to docs/debug/active-queries-faq/dsoa-active-queries-example.png diff --git a/docs/active-queries-faq/dsoa-active-queries-notebook-checking-missing-queries.png b/docs/debug/active-queries-faq/dsoa-active-queries-notebook-checking-missing-queries.png similarity index 100% rename from docs/active-queries-faq/dsoa-active-queries-notebook-checking-missing-queries.png rename to docs/debug/active-queries-faq/dsoa-active-queries-notebook-checking-missing-queries.png diff --git a/docs/active-queries-faq/dsoa-active-queries-notebook-finding-missing-queries.png b/docs/debug/active-queries-faq/dsoa-active-queries-notebook-finding-missing-queries.png similarity index 100% rename from docs/active-queries-faq/dsoa-active-queries-notebook-finding-missing-queries.png rename to docs/debug/active-queries-faq/dsoa-active-queries-notebook-finding-missing-queries.png diff --git a/docs/active-queries-faq/dsoa-active-queries-notebook-plugin-executions.png b/docs/debug/active-queries-faq/dsoa-active-queries-notebook-plugin-executions.png similarity index 100% rename from docs/active-queries-faq/dsoa-active-queries-notebook-plugin-executions.png rename to docs/debug/active-queries-faq/dsoa-active-queries-notebook-plugin-executions.png diff --git a/docs/active-queries-faq/dsoa-active-queries-notebook-status-reported.png b/docs/debug/active-queries-faq/dsoa-active-queries-notebook-status-reported.png similarity index 100% rename from docs/active-queries-faq/dsoa-active-queries-notebook-status-reported.png rename to docs/debug/active-queries-faq/dsoa-active-queries-notebook-status-reported.png diff --git a/docs/active-queries-faq/dsoa-active-queries-processing-log.png b/docs/debug/active-queries-faq/dsoa-active-queries-processing-log.png similarity index 100% rename from docs/active-queries-faq/dsoa-active-queries-processing-log.png rename to docs/debug/active-queries-faq/dsoa-active-queries-processing-log.png diff --git a/docs/active-queries-faq/dsoa-active-queries-snowflake-function-validation.png b/docs/debug/active-queries-faq/dsoa-active-queries-snowflake-function-validation.png similarity index 100% rename from docs/active-queries-faq/dsoa-active-queries-snowflake-function-validation.png rename to docs/debug/active-queries-faq/dsoa-active-queries-snowflake-function-validation.png diff --git a/docs/active-queries-faq/dsoa-active-queries-tasks-log-db-perspective.png b/docs/debug/active-queries-faq/dsoa-active-queries-tasks-log-db-perspective.png similarity index 100% rename from docs/active-queries-faq/dsoa-active-queries-tasks-log-db-perspective.png rename to docs/debug/active-queries-faq/dsoa-active-queries-tasks-log-db-perspective.png diff --git a/docs/active-queries-faq/dsoa-active-queries-tasks-monitoring-screen.png b/docs/debug/active-queries-faq/dsoa-active-queries-tasks-monitoring-screen.png similarity index 100% rename from docs/active-queries-faq/dsoa-active-queries-tasks-monitoring-screen.png rename to docs/debug/active-queries-faq/dsoa-active-queries-tasks-monitoring-screen.png diff --git a/docs/active-queries-faq/dsoa-active-queries-test-dashboard-0.7.0.json b/docs/debug/active-queries-faq/dsoa-active-queries-test-dashboard-0.7.0.json similarity index 100% rename from docs/active-queries-faq/dsoa-active-queries-test-dashboard-0.7.0.json rename to docs/debug/active-queries-faq/dsoa-active-queries-test-dashboard-0.7.0.json diff --git a/docs/active-queries-faq/dsoa-active-queries-test-dashboard-0.8.2.json b/docs/debug/active-queries-faq/dsoa-active-queries-test-dashboard-0.8.2.json similarity index 100% rename from docs/active-queries-faq/dsoa-active-queries-test-dashboard-0.8.2.json rename to docs/debug/active-queries-faq/dsoa-active-queries-test-dashboard-0.8.2.json diff --git a/docs/active-queries-faq/dsoa-active-queries-test-dashboard.json b/docs/debug/active-queries-faq/dsoa-active-queries-test-dashboard.json similarity index 100% rename from docs/active-queries-faq/dsoa-active-queries-test-dashboard.json rename to docs/debug/active-queries-faq/dsoa-active-queries-test-dashboard.json diff --git a/docs/active-queries-faq/index.md b/docs/debug/active-queries-faq/readme.md similarity index 100% rename from docs/active-queries-faq/index.md rename to docs/debug/active-queries-faq/readme.md diff --git a/docs/active-queries-faq/t00_test_missing_active_queries.off.sql b/docs/debug/active-queries-faq/t00_test_missing_active_queries.off.sql similarity index 100% rename from docs/active-queries-faq/t00_test_missing_active_queries.off.sql rename to docs/debug/active-queries-faq/t00_test_missing_active_queries.off.sql diff --git a/package.sh b/package.sh index 5a2d7523..ba02f0b7 100755 --- a/package.sh +++ b/package.sh @@ -30,6 +30,20 @@ # = - which will remove :DEV tags from deploy.sh # +# Function to check if a command exists +command_exists() { + command -v "$1" >/dev/null 2>&1 +} + +# Check for required commands +required_commands=("pylint" "python" "pandoc" "zip") +for cmd in "${required_commands[@]}"; do + if ! command_exists "$cmd"; then + echo "Error: Required command '$cmd' is not installed. Please install it before running this script." + exit 1 + fi +done + PARAM=$1 # Resetting the package directory diff --git a/pytest.ini b/pytest.ini index 8896a26a..bee27adb 100644 --- a/pytest.ini +++ b/pytest.ini @@ -2,4 +2,6 @@ pythonpath = src addopts = --ignore-glob=**/otel_*_test.py log_cli = false -log_cli_level = DEBUG \ No newline at end of file +log_cli_level = DEBUG +markers = + xdist_group: mark test to be executed in named group \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 1ea48eff..4216d811 100644 --- a/requirements.txt +++ b/requirements.txt @@ -27,10 +27,12 @@ toml tzlocal #%DEV: streamlit -snowflake-snowpark-python +snowflake-snowpark-python==1.40.0 +snowflake-connector-python[secure-local-storage] opentelemetry-api==1.26.0 opentelemetry-sdk==1.26.0 opentelemetry-exporter-otlp-proto-http==1.26.0 +opentelemetry-proto==1.26.0 snowflake-core==1.5.1 uuid jsonstrip @@ -40,7 +42,10 @@ inflect markdown2 weasyprint pyyaml +# github tests pylint flake8 -pylint +black +sqlfluff +yamllint #%:DEV diff --git a/src/build/update_docs.py b/src/build/update_docs.py index 162c23c9..2728dcb8 100644 --- a/src/build/update_docs.py +++ b/src/build/update_docs.py @@ -1,5 +1,5 @@ """ -Parses and builds the documentation from all instruments-def.yml, info.md, config.md, and the default config files. +Parses and builds the documentation from all instruments-def.yml, readme.md, config.md, and the default config files. """ # @@ -124,7 +124,7 @@ def _generate_semantics_tables(json_data: Dict, plugin_name: str, no_global_cont def _generate_plugins_info(dtagent_plugins_path: str) -> Tuple[str, List]: - """Gathers plugin info from info.md files and their default config files.""" + """Gathers plugin info from readme.md files and their default config files.""" __content = "" __plugins_toc = [] @@ -134,7 +134,7 @@ def _generate_plugins_info(dtagent_plugins_path: str) -> Tuple[str, List]: plugin_path = os.path.join(dtagent_plugins_path, plugin_folder) if os.path.isdir(plugin_path): - f_info_md = os.path.join(plugin_path, "info.md") + f_info_md = os.path.join(plugin_path, "readme.md") f_config_md = os.path.join(plugin_path, "config.md") config_file_name = f"{plugin_folder.split('.')[0]}-config.json" config_file_path = os.path.join(plugin_path, config_file_name) @@ -311,8 +311,8 @@ def generate_readme_content(dtagent_conf_path: str, dtagent_plugins_path: str) - A tuple containing the content for: readme_full_content, readme_short_content, plugins_content, semantics_content, appendix_content """ - # Add the content of src/dtagent.conf/info.md to README.md - readme_short_content = readme_full_content = _read_file(os.path.join(dtagent_conf_path, "info.md")) + # Add the content of src/dtagent.conf/readme.md to README.md + readme_short_content = readme_full_content = _read_file(os.path.join(dtagent_conf_path, "readme.md")) plugins_content = "" semantics_content = "" appendix_content = "" @@ -367,6 +367,9 @@ def generate_readme_content(dtagent_conf_path: str, dtagent_plugins_path: str) - readme_full_content += appendix_content readme_full_content += _lower_headers_one_level(copyright_content) + readme_full_content = re.sub( + r"\]\(docs\/", "](https://github.com/dynatrace-oss/dynatrace-snowflake-observability-agent/tree/main/docs/", readme_full_content + ) # replace internal links to docs with absolute links to GitHub readme_full_content = re.sub(r"\b[A-Z_]+\.md#", "#", readme_full_content) # removing references between .md files readme_full_content = ( diff --git a/src/dtagent.conf/otel-config.json b/src/dtagent.conf/otel-config.json index 74888a4e..c265709b 100644 --- a/src/dtagent.conf/otel-config.json +++ b/src/dtagent.conf/otel-config.json @@ -1,6 +1,10 @@ { "OTEL": { "MAX_CONSECUTIVE_API_FAILS": 10, + "LOGS": { + "EXPORT_TIMEOUT_MILLIS": 10000, + "MAX_EXPORT_BATCH_SIZE": 100 + }, "SPANS": { "EXPORT_TIMEOUT_MILLIS": 10000, "MAX_EXPORT_BATCH_SIZE": 50, diff --git a/src/dtagent.conf/info.md b/src/dtagent.conf/readme.md similarity index 96% rename from src/dtagent.conf/info.md rename to src/dtagent.conf/readme.md index 8353a661..08b6a594 100644 --- a/src/dtagent.conf/info.md +++ b/src/dtagent.conf/readme.md @@ -12,5 +12,6 @@ Table of content: * [Plugins](PLUGINS.md) * [Semantic dictionary](SEMANTICS.md) * [How to install](INSTALL.md) +* [Example dashboards](docs/dashboards) * [Changelog](CHANGELOG.md) * [Contributing](CONTRIBUTING.md) diff --git a/src/dtagent/agent.py b/src/dtagent/agent.py index 0852b300..f0d224f9 100644 --- a/src/dtagent/agent.py +++ b/src/dtagent/agent.py @@ -111,7 +111,7 @@ def process(self, sources: List, run_proc: bool = True) -> Dict: self.report_execution_status(status="STARTED", task_name=source, exec_id=exec_id) if is_regular_mode(self._session): - self._session.query_tag = f"dsoa.version:{ str(VERSION) }.plugin:{ c_source.__name__ }.{ exec_id }" + self._session.query_tag = f"dsoa.version:{str(VERSION)}.plugin:{c_source.__name__}.{exec_id}" if inspect.isclass(c_source): # diff --git a/src/dtagent/connector.py b/src/dtagent/connector.py index 3dbaa879..379c3410 100644 --- a/src/dtagent/connector.py +++ b/src/dtagent/connector.py @@ -164,7 +164,9 @@ def _get_source_rows(self, source: Union[str, dict, list]) -> Generator[Dict, No for row_dict in source: yield row_dict - def send_data(self, source: Union[str, dict, list], exec_id: str = get_now_timestamp_formatted()) -> Tuple[int, int, int, int, int]: + def send_data( + self, source_data: Union[str, dict, list], exec_id: str = get_now_timestamp_formatted() + ) -> Tuple[int, int, int, int, int]: """Sends telemetry data from given source based on the parameters provided to the stored procedure Args: @@ -180,7 +182,7 @@ def send_data(self, source: Union[str, dict, list], exec_id: str = get_now_times entries_cnt, logs_cnt, metrics_cnt, events_cnt, bizevents_cnt, davis_events_cnt = (0, 0, 0, 0, 0, 0) if self._auto_mode: entries_cnt, logs_cnt, metrics_cnt, events_cnt = self._log_entries( - lambda: self._get_source_rows(source), + lambda: self._get_source_rows(source_data), self.__context_name, report_logs=self._send_logs, report_metrics=self._send_metrics, @@ -190,17 +192,20 @@ def send_data(self, source: Union[str, dict, list], exec_id: str = get_now_times ) else: if self._send_logs or self._send_davis_events: - for row_dict in self._get_source_rows(source): + for row_dict in self._get_source_rows(source_data): from dtagent.util import _cleanup_dict # COMPILE_REMOVE processed_last_timestamp = row_dict.get("timestamp", None) - event_dict = _cleanup_dict({"timestamp": processed_last_timestamp, **row_dict}) + _message = row_dict.get("_message", None) + clean_dict = { + k: v for k, v in _cleanup_dict({"timestamp": processed_last_timestamp, **row_dict}).items() if k != "_message" + } s_log_level = "INFO" if row_dict.get("status.code", "OK") == "OK" else "ERROR" if self._send_logs: self._logs.send_log( - row_dict.get("_message", f"Log entry sent with {self.__context_name}"), - extra=event_dict, + message=_message or f"Log entry sent with {self.__context_name}", + extra=clean_dict, log_level=getattr(logging, s_log_level, logging.INFO), context=self.__context, ) @@ -209,9 +214,9 @@ def send_data(self, source: Union[str, dict, list], exec_id: str = get_now_times if self._send_davis_events: try: davis_events_cnt += self._davis_events.report_via_api( - query_data=row_dict, + query_data=clean_dict, event_type=(EventType[row_dict["event.type"]] if "event.type" in row_dict else EventType.CUSTOM_INFO), - title=row_dict.get("_message", f"Log entry sent with {self.__context_name}"), + title=_message or f"Event sent with {self.__context_name}", context=self.__context, ) except ValueError as e: @@ -222,7 +227,7 @@ def send_data(self, source: Union[str, dict, list], exec_id: str = get_now_times entries_cnt += 1 else: - entries_cnt = sum(1 for _ in self._get_source_rows(source)) + entries_cnt = sum(1 for _ in self._get_source_rows(source_data)) if self._send_biz_events or self._send_events: import itertools @@ -253,11 +258,12 @@ def __chunked_iterable(iterable, size) -> Generator[List, None, None]: while chunk := list(itertools.islice(it, size)): yield chunk - for chunk in __chunked_iterable(self._get_source_rows(source), chunk_size): + for chunk in __chunked_iterable(self._get_source_rows(source_data), chunk_size): if self._send_biz_events: bizevents_cnt += self._biz_events.report_via_api( query_data=chunk, event_type=EventType.CUSTOM_INFO, + title=f"BizEvent sent with {self.__context_name}", context=self.__context, is_data_structured=False, ) @@ -265,6 +271,7 @@ def __chunked_iterable(iterable, size) -> Generator[List, None, None]: events_cnt += self._events.report_via_api( query_data=chunk, event_type=EventType.CUSTOM_INFO, + title=f"Event sent with {self.__context_name}", context=self.__context, is_data_structured=False, ) diff --git a/src/dtagent/otel/__init__.py b/src/dtagent/otel/__init__.py index 7c890487..ea5a74ca 100644 --- a/src/dtagent/otel/__init__.py +++ b/src/dtagent/otel/__init__.py @@ -52,7 +52,7 @@ def _log_warning(response: requests.Response, _payload, source: str = "data") -> response.status_code, response.reason, response.text, - _payload, + str(_payload)[:100], ) diff --git a/src/dtagent/otel/events/bizevents.py b/src/dtagent/otel/events/bizevents.py index 17358b7d..be3cc064 100644 --- a/src/dtagent/otel/events/bizevents.py +++ b/src/dtagent/otel/events/bizevents.py @@ -98,7 +98,7 @@ def _pack_event_data( # event data with bizevents specific extra info | _cleanup_data( { - "type": event_type, + "type": str(event_data.get("event.type", event_type)), "data": event_data | _event_extra, } ) diff --git a/src/dtagent/otel/events/generic.py b/src/dtagent/otel/events/generic.py index 35446bc2..a04f5eaf 100644 --- a/src/dtagent/otel/events/generic.py +++ b/src/dtagent/otel/events/generic.py @@ -33,7 +33,6 @@ from types import NoneType from typing import Any, Dict, List, Optional, Tuple, Union, Generator -from inflect import k import requests from dtagent.context import CONTEXT_NAME @@ -91,22 +90,28 @@ def __limit_to_api(properties: Dict[str, str]) -> Dict: return properties - title = str(event_data.get("_MESSAGE", "")) or kwargs.get("title", "Dynatrace Snowflake Observability Agent event") - event_data_extended = kwargs.get("additional_payload", {}) | _unpack_payload(event_data) + title = ( + str(event_data.get("_MESSAGE", "")) + or str(event_data.get("_message", "")) + or kwargs.get("title", "Dynatrace Snowflake Observability Agent event") + ) + event_data_extended = kwargs.get("additional_payload", {}) | { + k: v for k, v in event_data.items() if k not in ("_MESSAGE", "_message") + } start_ts = get_timestamp_in_ms(event_data, kwargs.get("start_time_key", "START_TIME"), 1e6, None) end_ts = get_timestamp_in_ms(event_data, kwargs.get("end_time_key", "END_TIME"), 1e6, None) # we have map non-simple types to string, as events are not capable of mapping lists - for key, value in event_data_extended.items(): - if not isinstance(value, (int, float, str, bool, NoneType)): - event_data_extended[key] = str(value) + # for key, value in event_data_extended.items(): + # if not isinstance(value, (int, float, str, bool, NoneType)): + # event_data_extended[key] = str(value) if isinstance(event_type, EventType) and event_type not in EventType: raise ValueError(f"{event_type} is not a valid EventType value") event_payload = { - "eventType": str(event_type), + "eventType": str(event_data.get("event.type", event_type)), "title": title, "properties": __limit_to_api( _pack_values_to_json_strings( diff --git a/src/dtagent/otel/logs.py b/src/dtagent/otel/logs.py index 1edc61bb..c1046dd9 100644 --- a/src/dtagent/otel/logs.py +++ b/src/dtagent/otel/logs.py @@ -73,7 +73,9 @@ def __init__(self, *args, **kwargs): endpoint=f'{self._configuration.get("logs.http")}', headers={"Authorization": f'Api-Token {self._configuration.get("dt.token")}'}, session=CustomLoggingSession(), - ) + ), + export_timeout_millis=self._configuration.get(otel_module="logs", key="export_timeout_millis", default_value=10000), + max_export_batch_size=self._configuration.get(otel_module="logs", key="max_export_batch_size", default_value=100), ) ) handler = LoggingHandler(level=logging.NOTSET, logger_provider=self._otel_logger_provider) @@ -145,6 +147,12 @@ def __adjust_log_attribute(key: str, value: Any) -> Any: OtelManager.verify_communication() + def flush_logs(self) -> None: + """flushes remaining logs.""" + + if self._otel_logger_provider: + self._otel_logger_provider.force_flush() + def shutdown_logger(self) -> None: """flushes remaining logs and shuts down the logger.""" diff --git a/src/dtagent/otel/otel_manager.py b/src/dtagent/otel/otel_manager.py index c4cbc03f..2e51ecdc 100644 --- a/src/dtagent/otel/otel_manager.py +++ b/src/dtagent/otel/otel_manager.py @@ -106,7 +106,7 @@ def send(self, request, **kwargs): response: requests.Response = super().send(request, **kwargs) if response.status_code >= 300: OtelManager.increase_current_fail_count(response) - _log_warning(response, response.request.body, source=response.url.rsplit("/", 1)[-1]) + _log_warning(response, response.request.body[:-100], source=response.url.rsplit("/", 1)[-1]) else: OtelManager.set_current_fail_count(0) return response diff --git a/src/dtagent/plugins/__init__.py b/src/dtagent/plugins/__init__.py index 1a9d98b5..488d3fc7 100644 --- a/src/dtagent/plugins/__init__.py +++ b/src/dtagent/plugins/__init__.py @@ -175,7 +175,7 @@ def _process_span_rows( context_name (str): name of the Plugin calling run_uuid (str): stringified uuid unique to run query_id_col_name (str): name of the column containing the query id. Defaults to QUERY_ID - parent_query_id_col_name (str): name of the column containing pareny query id. Defaults to PARENT_QUERY_ID + parent_query_id_col_name (str): name of the column containing parent query id. Defaults to PARENT_QUERY_ID log_completion (bool): indicator whether to log the completion of reporting the payload to DTAGENT_DB.STATUS.LOG_PROCESSED_MEASUREMENTS update_status (bool): indicator whether to log the processed ids to DTAGENT_DB.STATUS.UPDATE_PROCESSED_QUERIES f_log_events (Callable): function specifying how events should be logged. Only takes a single, unpacked row as param diff --git a/src/dtagent/plugins/active_queries.config/info.md b/src/dtagent/plugins/active_queries.config/readme.md similarity index 91% rename from src/dtagent/plugins/active_queries.config/info.md rename to src/dtagent/plugins/active_queries.config/readme.md index c187029f..c5b19fd2 100644 --- a/src/dtagent/plugins/active_queries.config/info.md +++ b/src/dtagent/plugins/active_queries.config/readme.md @@ -31,3 +31,5 @@ fetch logs dsoa.run.id } ``` + +If you have any concerns about getting correct results reported by this plugin, please refer to [Root Cause Analysis: Missing Long-Running Queries](docs/debug/active-queries-faq/readme.md). diff --git a/src/dtagent/plugins/budgets.config/info.md b/src/dtagent/plugins/budgets.config/readme.md similarity index 100% rename from src/dtagent/plugins/budgets.config/info.md rename to src/dtagent/plugins/budgets.config/readme.md diff --git a/src/dtagent/plugins/data_schemas.config/info.md b/src/dtagent/plugins/data_schemas.config/readme.md similarity index 100% rename from src/dtagent/plugins/data_schemas.config/info.md rename to src/dtagent/plugins/data_schemas.config/readme.md diff --git a/src/dtagent/plugins/data_volume.config/info.md b/src/dtagent/plugins/data_volume.config/readme.md similarity index 100% rename from src/dtagent/plugins/data_volume.config/info.md rename to src/dtagent/plugins/data_volume.config/readme.md diff --git a/src/dtagent/plugins/dynamic_tables.config/info.md b/src/dtagent/plugins/dynamic_tables.config/readme.md similarity index 100% rename from src/dtagent/plugins/dynamic_tables.config/info.md rename to src/dtagent/plugins/dynamic_tables.config/readme.md diff --git a/src/dtagent/plugins/event_log.config/info.md b/src/dtagent/plugins/event_log.config/readme.md similarity index 100% rename from src/dtagent/plugins/event_log.config/info.md rename to src/dtagent/plugins/event_log.config/readme.md diff --git a/src/dtagent/plugins/event_usage.config/instruments-def.yml b/src/dtagent/plugins/event_usage.config/instruments-def.yml index ddba174b..ac226012 100644 --- a/src/dtagent/plugins/event_usage.config/instruments-def.yml +++ b/src/dtagent/plugins/event_usage.config/instruments-def.yml @@ -20,7 +20,7 @@ metrics: __description: Number of credits billed for loading data into the event table during the START_TIME and END_TIME window. - displayName: Credits Used for Event Table + displayName: Snowflake Credits Used unit: credits snowflake.data.ingested: __example: "10485760" diff --git a/src/dtagent/plugins/event_usage.config/info.md b/src/dtagent/plugins/event_usage.config/readme.md similarity index 100% rename from src/dtagent/plugins/event_usage.config/info.md rename to src/dtagent/plugins/event_usage.config/readme.md diff --git a/src/dtagent/plugins/login_history.config/info.md b/src/dtagent/plugins/login_history.config/readme.md similarity index 100% rename from src/dtagent/plugins/login_history.config/info.md rename to src/dtagent/plugins/login_history.config/readme.md diff --git a/src/dtagent/plugins/query_history.config/instruments-def.yml b/src/dtagent/plugins/query_history.config/instruments-def.yml index 48ceb296..9a99e3b3 100644 --- a/src/dtagent/plugins/query_history.config/instruments-def.yml +++ b/src/dtagent/plugins/query_history.config/instruments-def.yml @@ -406,7 +406,7 @@ metrics: snowflake.time.compilation: __example: "5000" __description: Compilation time (in milliseconds) - displayName: Compilation Time + displayName: Query Compilation Time unit: ms snowflake.time.execution: __example: "100000" diff --git a/src/dtagent/plugins/query_history.config/info.md b/src/dtagent/plugins/query_history.config/readme.md similarity index 100% rename from src/dtagent/plugins/query_history.config/info.md rename to src/dtagent/plugins/query_history.config/readme.md diff --git a/src/dtagent/plugins/resource_monitors.config/instruments-def.yml b/src/dtagent/plugins/resource_monitors.config/instruments-def.yml index 1a7f4659..6193a709 100644 --- a/src/dtagent/plugins/resource_monitors.config/instruments-def.yml +++ b/src/dtagent/plugins/resource_monitors.config/instruments-def.yml @@ -110,7 +110,7 @@ metrics: snowflake.acceleration.scale_factor.max: __example: "2" __description: Maximal scale factor for query acceleration in the given warehouse - displayName: Query Acceleration Max Scale Factor + displayName: Query Acceleration Upper Limit Scale Factor unit: factor snowflake.compute.available: __example: "60" diff --git a/src/dtagent/plugins/resource_monitors.config/info.md b/src/dtagent/plugins/resource_monitors.config/readme.md similarity index 100% rename from src/dtagent/plugins/resource_monitors.config/info.md rename to src/dtagent/plugins/resource_monitors.config/readme.md diff --git a/src/dtagent/plugins/shares.config/info.md b/src/dtagent/plugins/shares.config/readme.md similarity index 100% rename from src/dtagent/plugins/shares.config/info.md rename to src/dtagent/plugins/shares.config/readme.md diff --git a/src/dtagent/plugins/tasks.config/instruments-def.yml b/src/dtagent/plugins/tasks.config/instruments-def.yml index 187b6974..586a1116 100644 --- a/src/dtagent/plugins/tasks.config/instruments-def.yml +++ b/src/dtagent/plugins/tasks.config/instruments-def.yml @@ -231,5 +231,5 @@ metrics: __description: Number of credits billed for serverless task usage during the START_TIME and END_TIME window. - displayName: Serverless Tasks Credits Used + displayName: Snowflake Credits Used unit: credits diff --git a/src/dtagent/plugins/tasks.config/info.md b/src/dtagent/plugins/tasks.config/readme.md similarity index 100% rename from src/dtagent/plugins/tasks.config/info.md rename to src/dtagent/plugins/tasks.config/readme.md diff --git a/src/dtagent/plugins/trust_center.config/info.md b/src/dtagent/plugins/trust_center.config/readme.md similarity index 100% rename from src/dtagent/plugins/trust_center.config/info.md rename to src/dtagent/plugins/trust_center.config/readme.md diff --git a/src/dtagent/plugins/users.config/info.md b/src/dtagent/plugins/users.config/readme.md similarity index 100% rename from src/dtagent/plugins/users.config/info.md rename to src/dtagent/plugins/users.config/readme.md diff --git a/src/dtagent/plugins/warehouse_usage.config/instruments-def.yml b/src/dtagent/plugins/warehouse_usage.config/instruments-def.yml index 5a8e20f3..c888b614 100644 --- a/src/dtagent/plugins/warehouse_usage.config/instruments-def.yml +++ b/src/dtagent/plugins/warehouse_usage.config/instruments-def.yml @@ -95,7 +95,7 @@ metrics: - warehouse_usage_metering __example: "10" __description: The total number of credits used by the warehouse. - displayName: Total Credits Used + displayName: Snowflake Credits Used unit: credits snowflake.load.blocked: __context_names: diff --git a/src/dtagent/plugins/warehouse_usage.config/info.md b/src/dtagent/plugins/warehouse_usage.config/readme.md similarity index 100% rename from src/dtagent/plugins/warehouse_usage.config/info.md rename to src/dtagent/plugins/warehouse_usage.config/readme.md diff --git a/test/__init__.py b/test/__init__.py index 06661b7d..c2621052 100644 --- a/test/__init__.py +++ b/test/__init__.py @@ -23,7 +23,12 @@ # import json import os +from contextlib import contextmanager +import re from typing import Any, Dict, List +import functools +import datetime +from unittest.mock import patch, Mock from snowflake import snowpark @@ -39,6 +44,7 @@ ) +@functools.lru_cache(maxsize=1) def _get_credentials() -> Dict: """ { @@ -47,7 +53,6 @@ def _get_credentials() -> Dict: "password": "", "role": "", # Optional "warehouse": "", # Optional - "database": "", # Optional "schema": "" # Optional } """ @@ -56,9 +61,14 @@ def _get_credentials() -> Dict: if os.path.isfile(credentials_path): with open(credentials_path, "r", encoding="utf-8") as f: credentials = json.loads(f.read()) + return credentials or {"local_testing": True} +def is_local_testing() -> bool: + return _get_credentials().get("local_testing", False) + + def _get_session() -> snowpark.Session: # Import the Session class from the snowflake.snowpark package from snowflake.snowpark import Session @@ -80,10 +90,11 @@ def get_last_measurement_update(self, session: snowpark.Session, source: str): class TestDynatraceSnowAgent(DynatraceSnowAgent): - from unittest.mock import patch def __init__(self, session: snowpark.Session, config: Configuration) -> None: self._local_configuration = config + self._local_configuration._config["otel"]["spans"]["max_export_batch_size"] = 1 + self._local_configuration._config["otel"]["logs"]["max_export_batch_size"] = 1 super().__init__(session) def _get_config(self, session: snowpark.Session) -> Configuration: @@ -94,65 +105,39 @@ def _get_config(self, session: snowpark.Session) -> Configuration: ["DIRECT_ROLES", "ALL_ROLES", "ALL_PRIVILEGES"], ) - @patch("dtagent.otel.otel_manager.CustomLoggingSession.send") - @patch("dtagent.otel.metrics.requests.post") - @patch("dtagent.otel.events.generic.requests.post") - @patch("dtagent.otel.events.davis.requests.post") - @patch("dtagent.otel.events.bizevents.requests.post") def process( self, sources: List, run_proc: bool = True, - mock_bizevents_post=None, - mock_davis_post=None, - mock_events_post=None, - mock_metrics_post=None, - mock_otel_post=None, ) -> Dict: from dtagent.otel.otel_manager import OtelManager + from test._mocks.telemetry import MockTelemetryClient - # FIXME we need to detect if we run the test against real endpoint or mock - OtelManager.reset_current_fail_count() - mock_events_post.side_effect = side_effect_function - mock_davis_post.side_effect = side_effect_function - mock_bizevents_post.side_effect = side_effect_function - mock_metrics_post.side_effect = side_effect_function - mock_otel_post.side_effect = side_effect_function - return super().process(sources, run_proc) - + process_results = {} -def _overwrite_plugin_local_config_key(test_conf: TestConfiguration, plugin_name: str, key_name: str, new_value: Any): - # added to make sure we always run tests for each mode in users plugin - test_conf._config["plugins"][plugin_name][key_name] = new_value - return test_conf - - -def side_effect_function(*args, **kwargs): - from unittest.mock import MagicMock - from dtagent.otel.events.generic import GenericEvents - from dtagent.otel.events.bizevents import BizEvents - from dtagent.otel.events.davis import DavisEvents - from dtagent.otel.logs import Logs - from dtagent.otel.metrics import Metrics - from dtagent.otel.spans import Spans - - mock_response = MagicMock() + OtelManager.reset_current_fail_count() - request_url = args[0].url if hasattr(args[0], "url") else str(args[0]) + if is_local_testing(): + mock_client = MockTelemetryClient(sources[0] if sources else None) + with mock_client.mock_telemetry_sending(): + import time - mock_response.status_code = 500 + process_results = super().process(sources, run_proc) + self._logs.flush_logs() + self._spans.flush_traces() + time.sleep(5) + mock_client.store_or_test_results() + else: + process_results = super().process(sources, run_proc) - if ( - request_url.endswith(BizEvents.ENDPOINT_PATH) - or request_url.endswith(GenericEvents.ENDPOINT_PATH) - or request_url.endswith(Metrics.ENDPOINT_PATH) - ): # For BizEvents, OpenPipeline Events, and Metrics - mock_response.status_code = 202 + return process_results - if request_url.endswith(DavisEvents.ENDPOINT_PATH): # For events - mock_response.status_code = 201 + def teardown(self) -> None: + self._logs.flush_logs() + self._spans.flush_traces() - if request_url.endswith(Logs.ENDPOINT_PATH) or request_url.endswith(Spans.ENDPOINT_PATH): # For logs and spans - mock_response.status_code = 200 - return mock_response +def _overwrite_plugin_local_config_key(test_conf: TestConfiguration, plugin_name: str, key_name: str, new_value: Any): + # added to make sure we always run tests for each mode in users plugin + test_conf._config["plugins"][plugin_name][key_name] = new_value + return test_conf diff --git a/test/_mocks/__init__.py b/test/_mocks/__init__.py new file mode 100644 index 00000000..5d81ecad --- /dev/null +++ b/test/_mocks/__init__.py @@ -0,0 +1,23 @@ +# +# +# Copyright (c) 2025 Dynatrace Open Source +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# diff --git a/test/_mocks/telemetry.py b/test/_mocks/telemetry.py new file mode 100644 index 00000000..c5ab54bd --- /dev/null +++ b/test/_mocks/telemetry.py @@ -0,0 +1,451 @@ +# +# +# Copyright (c) 2025 Dynatrace Open Source +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# +import os +import json +import re +import datetime +from typing import Any, Dict, List +from contextlib import contextmanager +from unittest.mock import MagicMock, patch, Mock + +from git import Union + + +class MockTelemetryClient: + + def __init__(self, test_source: str): + self.test_source = test_source + if self.test_source: + self.test_results_dir = f"test/test_results/{self.test_source}/" + self.expected_results = self._load_test_results() + else: + self.test_results_dir = None + self.expected_results = {} + self.is_test_results_missing = not self.expected_results + self.test_results: Dict[str, List[Any]] = {} + + def store_or_test_results(self): + """ + Store the collected test results into files for future reference. + """ + # Remove duplicates while preserving order + dedup_results = {} + for telemetry_type, content in self.test_results.items(): + seen = set() + dedup_results[telemetry_type] = [] + for item in content: + # Convert dicts to a hashable type for deduplication + key = json.dumps(item, sort_keys=True) if isinstance(item, dict) else str(item) + if key not in seen: + seen.add(key) + dedup_results[telemetry_type].append(item) + self.test_results = dedup_results + + # store or test results + if self.is_test_results_missing: + for telemetry_type, content in self.test_results.items(): + self._save_telemetry_test_data(telemetry_type, content) + else: + # otherwise we will test if save_test_results would match expected results + for telemetry_type, expected_content in self.expected_results.items(): + actual_content = self.test_results.get(telemetry_type, []) + + # Sort both lists for comparison, handling dicts by serializing with sorted keys + def sort_key(item): + if isinstance(item, dict): + return json.dumps(item, sort_keys=True) + return str(item) + + sorted_actual = sorted(actual_content, key=sort_key) + sorted_expected = sorted(expected_content, key=sort_key) + import difflib + + if sorted_actual != sorted_expected: + _, filepath = self._determine_file_name(telemetry_type) + if telemetry_type == "metrics": + diff = "\n".join( + difflib.unified_diff(sorted_expected, sorted_actual, fromfile="expected", tofile="actual", lineterm="") + ) + else: + expected_str = json.dumps(sorted_expected, indent=2, sort_keys=True) + actual_str = json.dumps(sorted_actual, indent=2, sort_keys=True) + diff = "\n".join( + difflib.unified_diff( + expected_str.splitlines(), actual_str.splitlines(), fromfile="expected", tofile="actual", lineterm="" + ) + ) + assert ( + sorted_actual == sorted_expected + ), f"Telemetry type {telemetry_type} does not match expected results from {filepath}:\n\nDiff:\n{diff}" + + @contextmanager + def mock_telemetry_sending(self): + with ( + patch("requests.sessions.Session.post") as mock_session_post, + patch("dtagent.otel.metrics.requests.post") as mock_metrics, + patch("dtagent.otel.events.generic.requests.post") as mock_generic_events, + patch("dtagent.otel.events.davis.requests.post") as mock_davis_events, + patch("dtagent.otel.events.bizevents.requests.post") as mock_bizevents, + patch("snowflake.snowpark.Session.sql") as mock_sql, + ): + # Set up HTTP mocks + mock_session_post.side_effect = self._side_effect_function + mock_metrics.side_effect = self._side_effect_function + mock_generic_events.side_effect = self._side_effect_function + mock_davis_events.side_effect = self._side_effect_function + mock_bizevents.side_effect = self._side_effect_function + + # Set up session.sql mock to prevent actual Snowflake calls + current_time = datetime.datetime.now(datetime.timezone.utc) + one_hour_ago = current_time - datetime.timedelta(hours=1) + mock_sql_instance = Mock() + mock_row = Mock() + mock_row.__getitem__ = Mock(return_value=one_hour_ago) + mock_sql_instance.collect.return_value = [mock_row] + mock_sql.return_value = mock_sql_instance + + yield + + def _load_test_results(self) -> Dict[str, Any]: + """ + Load expected test results from files into a dictionary. + """ + telemetry_types = ["logs", "spans", "metrics", "events", "biz_events"] + expected_results = {} + for telemetry_type in telemetry_types: + data = self._load_telemetry_test_data(telemetry_type) + if data is not None: + expected_results[telemetry_type] = data if telemetry_type != "metrics" else data.split("\n") + return expected_results + + def _determine_file_name(self, telemetry_type: str) -> tuple[str, str]: + """ + Determines file path and extension based on given telemetry type + + Args: + telemetry_type (str): telemetry type name + + Returns: + tuple[str, str]: file path and extension for given telemetry type + """ + ext = "txt" if telemetry_type == "metrics" else "json" + filepath = os.path.join(self.test_results_dir, f"{telemetry_type}.{ext}") if self.test_results_dir else None + return ext, filepath + + def _load_telemetry_test_data(self, telemetry_type: str) -> Any: + """ + Load telemetry test data from a file. + + Args: + telemetry_type: The type of telemetry data ("logs", "spans", "metrics", "events", "biz_events"). + + Returns: + The loaded telemetry data. + """ + ext, filepath = self._determine_file_name(telemetry_type) + + if filepath and os.path.exists(filepath): + with open(filepath, "r", encoding="utf-8") as f: + if ext == "json": + try: + return json.load(f) + except json.JSONDecodeError as e: + print(f"Error decoding JSON from file {filepath}: {e}") + + return f.read() + return None + + def _save_telemetry_test_data(self, telemetry_type: str, content: List[Union[str, dict, bytes]]) -> None: + """ + Save telemetry test data to a file. + + Args: + telemetry_type: The type of telemetry data ("logs", "spans", "metrics", "events", "biz_events"). + data: The telemetry data to save. + """ + ext, filepath = self._determine_file_name(telemetry_type) + + if filepath: + os.makedirs(os.path.dirname(filepath), exist_ok=True) + + with open(filepath, "w", encoding="utf-8") as f: + if ext == "json": + try: + json.dump(content, f, indent=2, default=str) # Convert non-serializable to string + except (TypeError, ValueError, OSError) as e: + print(f"Error saving JSON to {filepath}: {e}") + else: + f.write("\n".join(content)) + + def _decode_object_from_protobuf(self, protobuf_bytes: bytes, telemetry_type: str = "logs") -> List[Dict[str, Any]]: + """ + Decode protobuf logs to extract key-value pairs from log bodies. + + Args: + protobuf_bytes: The binary protobuf data from OpenTelemetry logs + telemetry_type: The type of telemetry data ("logs" or "spans"). + + Returns: + A list of dictionaries representing the extracted key-value pairs. + """ + from opentelemetry.proto.collector.logs.v1.logs_service_pb2 import ExportLogsServiceRequest + from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import ExportTraceServiceRequest + + def __extract_value(kv_pair): + """Extracts the value from a key-value pair in prodbuf stream based on its type. + + Args: + kv_pair: The key-value pair to extract the value from. + + Returns: + The extracted value. + """ + value_field = getattr(kv_pair, "value", kv_pair) + extracted_value = None + if value_field.HasField("string_value"): + extracted_value = value_field.string_value + elif value_field.HasField("int_value"): + extracted_value = value_field.int_value + elif value_field.HasField("double_value"): + extracted_value = value_field.double_value + elif value_field.HasField("bool_value"): + extracted_value = value_field.bool_value + elif value_field.HasField("bytes_value"): + extracted_value = value_field.bytes_value.hex() + elif value_field.HasField("array_value"): + extracted_value = [__extract_value(v) for v in value_field.array_value.values] + elif value_field.HasField("kvlist_value"): + extracted_value = {kv.key: __extract_value(kv) for kv in value_field.kvlist_value.values} + else: + extracted_value = str(value_field) + + return extracted_value + + request = ExportLogsServiceRequest() if telemetry_type == "logs" else ExportTraceServiceRequest() + request.ParseFromString(protobuf_bytes) + + kv_data = [] + for resource in getattr(request, f"resource_{telemetry_type}"): + for scope in getattr(resource, f"scope_{telemetry_type}"): + for record in scope.log_records if telemetry_type == "logs" else scope.spans: + kv_datum = {} + kv_pairs = None + if telemetry_type == "logs": + if record.body.HasField("kvlist_value"): + kv_pairs = record.body.kvlist_value.values + elif telemetry_type == "spans": + kv_pairs = record.attributes + + for event in record.events: + event_name = event.name + kv_datum[f"event_{event_name}_name"] = event_name + for kv_pair in event.attributes: + key = f"event_{event_name}_{kv_pair.key}" + value = __extract_value(kv_pair) + kv_datum[key] = value + if kv_pairs: + for kv_pair in kv_pairs: + key = kv_pair.key + value = __extract_value(kv_pair) + kv_datum[key] = value + + if kv_datum: + kv_data.append(kv_datum) + + return kv_data + + def _side_effect_function(self, *args, **kwargs): + """ + Side effect function to handle telemetry data processing. + It ensures proper status codes are set for different telemetry types. + It collects sent telemetry data into test_results for later verification. + It also checks against expected_results if available. + """ + + def __determine_telemetry_type(url: str, mock_response: MagicMock) -> str: + """ + Returns telemetry type based on the URL for the request. + Sets the correct status code for the mock response. + + Args: + url (str): The URL for the request. + mock_response (MagicMock): The mock response object to set the status code on. + + Returns: + str: The determined telemetry type. + """ + from dtagent.otel.events.bizevents import BizEvents + from dtagent.otel.events.generic import GenericEvents + from dtagent.otel.events.davis import DavisEvents + from dtagent.otel.logs import Logs + from dtagent.otel.metrics import Metrics + from dtagent.otel.spans import Spans + + telemetry_type = None + + if url.endswith(BizEvents.ENDPOINT_PATH): + telemetry_type = "biz_events" + mock_response.status_code = 202 + elif url.endswith(GenericEvents.ENDPOINT_PATH): + telemetry_type = "events" + mock_response.status_code = 202 + elif url.endswith(DavisEvents.ENDPOINT_PATH): + telemetry_type = "davis_events" + mock_response.status_code = 201 + elif url.endswith(Logs.ENDPOINT_PATH): + telemetry_type = "logs" + mock_response.status_code = 200 + elif url.endswith(Spans.ENDPOINT_PATH): + telemetry_type = "spans" + mock_response.status_code = 200 + elif url.endswith(Metrics.ENDPOINT_PATH): + telemetry_type = "metrics" + mock_response.status_code = 202 + + return telemetry_type + + def __determine_url_and_data(args, kwargs) -> tuple[str, Any]: + """ + Handle both requests.post mocks (args[0] is url) and CustomLoggingSession.send mocks (args[0] is request) + + Args: + *args: Positional arguments + **kwargs: Keyword arguments + + Returns: + tuple[str, Any]: A tuple containing the URL and data for the request. + """ + if args and hasattr(args[0], "url"): + url = args[0].url + elif "url" in kwargs: + url = kwargs["url"] + else: + url = args[0] + + if args and hasattr(args[0], "body"): + data = args[0].body + else: + data = kwargs.get("data", "") + + return url, data + + def __cleanup_telemetry_dict(data_dict: Dict[str, Any]) -> Dict[str, Any]: + """ + Remove dynamic fields from telemetry data dictionary for comparison. + + Args: + data_dict (Dict[str, Any]): The telemetry data dictionary. + + Returns: + Dict[str, Any]: The cleaned telemetry data dictionary. + """ + # Remove fields changing values per run + cleaned_dict = { + k: __cleanup_telemetry_dict(v) if isinstance(v, dict) else v + for k, v in data_dict.items() + if k.lower() + not in ( + # update by agent to fit the current run + "observed_timestamp", + "observed_at", + "timestamp", + "end_time", + "start_time", + "time", + "starttime", + "endtime", + "event.start", + "event.end", + # from event tests + "test.ts", + "test.event.dtagent.start_time", + "test.event.dtagent.end_time", + "test.event.dtagent.datetime", + # id in biz events and events is unique per event + "id", + # each agent run has a different run id + "dsoa.run.id", + "dsoa.task.exec.id", + # DSOA versions + "app.version", + "app.short_version", + "telemetry.exporter.version", + ) + } + return cleaned_dict + + def __cleanup_metric_lines(lines: str) -> List[str]: + """ + Remove dynamic fields from metric lines for comparison and turns a multiline string into a list of lines. + + Args: + lines (List[str]): The list of metric lines. + """ + processed_lines = [] + for line in lines.split("\n"): + if not line.strip().startswith("#"): + line = re.sub(r"(\s\d{13})\s*$", " 0", line) + processed_lines.append(line) + return processed_lines + + # Use the global test source instead of inspecting the stack + source_context = self.test_source + + # Determine telemetry_type based on url and set up mock response + mock_response = MagicMock() + url, data = __determine_url_and_data(args, kwargs) + telemetry_type = __determine_telemetry_type(url, mock_response) + content = None + + # we are going to store the content into test_results + if data and telemetry_type and source_context: + if isinstance(data, (dict, str)): + content = data + elif isinstance(data, bytes): + if telemetry_type in ("logs", "spans"): + content = self._decode_object_from_protobuf(data, telemetry_type=telemetry_type) + else: + content = data.hex() + if content: + if telemetry_type != "metrics" and isinstance(content, (str, bytes)): + try: + content = json.loads(content) + except (json.JSONDecodeError, TypeError) as e: + print(f"Error decoding JSON from API call payload {content}: {e}") + if telemetry_type not in self.test_results: + self.test_results[telemetry_type] = [] + + if telemetry_type == "metrics" and isinstance(content, str): + content = __cleanup_metric_lines(content) + + for item in content if isinstance(content, list) else [content]: + if isinstance(item, dict): + item = __cleanup_telemetry_dict(item) + + self.test_results[telemetry_type].append(item) + + if mock_response.status_code >= 300: + print(f"###### PROBLEM SENDING {telemetry_type} TELEMETRY TO {url}; ERROR CODE: {mock_response.status_code} ######") + + return mock_response diff --git a/test/_utils.py b/test/_utils.py index ca7d29cd..7052caff 100644 --- a/test/_utils.py +++ b/test/_utils.py @@ -29,11 +29,13 @@ import json import fnmatch import jsonstrip +from unittest.mock import patch, Mock from snowflake import snowpark from dtagent.config import Configuration from dtagent.connector import TelemetrySender from dtagent import config from dtagent.util import is_select_for_table +from test._mocks.telemetry import MockTelemetryClient TEST_CONFIG_FILE_NAME = "./test/conf/config-download.json" @@ -78,12 +80,13 @@ def _logging_findings( dtagent, log_tag: str, log_level: logging, - show_detailed_logs: int, + show_detailed_logs: bool, ): + from test import is_local_testing if log_level != "": logging.basicConfig(level=log_level) - if show_detailed_logs != 0: + if show_detailed_logs: from dtagent import LOG, LL_TRACE console_handler = logging.StreamHandler() # Console handler @@ -94,11 +97,11 @@ def _logging_findings( print(LOG.getEffectiveLevel()) results = dtagent.process([str(log_tag)], False) - print(f"!!!! RESULTS = {results}") - dtagent.teardown() session.close() + print(f"!!!! RESULTS = {results}") + def _safe_get_unpickled_entries(pickles: dict, table_name: str, *args, **kwargs) -> Generator[Dict, None, None]: """ @@ -107,8 +110,6 @@ def _safe_get_unpickled_entries(pickles: dict, table_name: str, *args, **kwargs) Args: pickles (dict): Dictionary mapping table names to pickle file paths. table_name (str): The name of the table to retrieve unpickled entries for. - *args: Additional positional arguments passed to the underlying unpickling function. - **kwargs: Additional keyword arguments passed to the underlying unpickling function. Returns: Generator[Dict, None, None]: A generator yielding dictionaries representing unpickled entries for the specified table. @@ -130,10 +131,18 @@ def _get_unpickled_entries( ) -> Generator[Dict, None, None]: import pandas as pd + ndjson_name = os.path.splitext(pickle_name)[0] + ".ndjson" + # if os.path.exists(ndjson_name): + # # Read from safer NDJSON format + # pandas_df = pd.read_json(ndjson_name, lines=True) + # print(f"Read from NDJSON {ndjson_name}") + # else: + # Fallback to pickle and generate NDJSON pandas_df = pd.read_pickle(pickle_name) - print(f"Unpickled {pickle_name}") - ##### + + collected_rows = [] + if limit is not None: if 0 < len(pandas_df) < limit: n_repeats = limit // len(pandas_df) @@ -153,8 +162,14 @@ def _get_unpickled_entries( if adjust_ts: _adjust_timestamp(row_dict, start_time=start_time, end_time=end_time) + collected_rows.append(row_dict) yield row_dict + if not os.path.exists(ndjson_name): + with open(ndjson_name, "w", encoding="utf-8") as f: + for row in collected_rows: + f.write(json.dumps(row) + "\n") + def should_pickle(pickle_files: list) -> bool: @@ -220,16 +235,24 @@ def _flush_logs(self) -> None: def telemetry_test_sender( - session: snowpark.Session, sources: str, params: dict, limit_results: int = 2, config: TestConfiguration = None + session: snowpark.Session, sources: str, params: dict, limit_results: int = 2, config: TestConfiguration = None, test_source: str = None ) -> Tuple[int, int, int, int, int]: """ Invokes send_data function on a LocalTelemetrySender instance, which uses pickled data for testing purposes Returns: - Tuple[int, int, int, int, int]: Count of objects, log lines, metrics, events, bizevents, and davis events sent + Tuple[int, int, int, int, int, int]: Count of objects, log lines, metrics, events, bizevents, and davis events sent """ + config._config["otel"]["spans"]["max_export_batch_size"] = 1 + config._config["otel"]["logs"]["max_export_batch_size"] = 1 + sender = LocalTelemetrySender(session, params, limit_results=limit_results, config=config) - results = sender.send_data(sources) - sender.teardown() + + mock_client = MockTelemetryClient(test_source) + with mock_client.mock_telemetry_sending(): + results = sender.send_data(sources) + sender._logs.shutdown_logger() + sender._spans.shutdown_tracer() + mock_client.store_or_test_results() return results @@ -303,7 +326,7 @@ def read_clean_json_from_file(file_path: str) -> List[Dict]: Returns: List[Dict]: dictionary based on the content of the JSON/JSONC file """ - logging.debug("Reading file: %s", file_path) + logging.debug("Reading clean json file: %s", file_path) with open(file_path, "r", encoding="utf-8") as file: @@ -327,7 +350,7 @@ def read_clean_yml_from_file(file_path: str) -> List[Dict]: """ import yaml - logging.debug("Reading file: %s", file_path) + logging.debug("Reading clean yml file: %s", file_path) with open(file_path, "r", encoding="utf-8") as f: data = yaml.safe_load(f) diff --git a/test/core/test_connector.py b/test/core/test_connector.py index d7b07cce..f90b8ac6 100644 --- a/test/core/test_connector.py +++ b/test/core/test_connector.py @@ -27,9 +27,9 @@ from unittest.mock import patch from dtagent.util import get_now_timestamp, get_now_timestamp_formatted -from test import _get_credentials, _get_session -from test import _utils, side_effect_function +from test import _get_session, _utils from test._utils import LocalTelemetrySender, read_clean_json_from_file, telemetry_test_sender +from test._mocks.telemetry import MockTelemetryClient from snowflake import snowpark LOG = logging.getLogger("DTAGENT_TEST") @@ -54,22 +54,13 @@ class TestTelemetrySender: * sending all data from a given (custom structure) view as logs, events, and bizevents """ - @patch("dtagent.otel.otel_manager.CustomLoggingSession.send") - @patch("dtagent.otel.metrics.requests.post") - @patch("dtagent.otel.events.generic.requests.post") - @patch("dtagent.otel.events.davis.requests.post") - @patch("dtagent.otel.events.bizevents.requests.post") - def test_viewsend(self, mock_bizevents_post, mock_davis_post, mock_events_post, mock_metrics_post, mock_otel_post): + import pytest + + @pytest.mark.xdist_group(name="test_telemetry") + def test_viewsend(self): # ): import random rows_cnt = random.randint(10, 20) - mock_davis_post.side_effect = side_effect_function - mock_events_post.side_effect = side_effect_function - mock_bizevents_post.side_effect = side_effect_function - mock_metrics_post.side_effect = side_effect_function - mock_otel_post.side_effect = side_effect_function - mock_metrics_post.side_effect = side_effect_function - mock_otel_post.side_effect = side_effect_function session = _get_session() results = telemetry_test_sender( @@ -86,20 +77,11 @@ def test_viewsend(self, mock_bizevents_post, mock_davis_post, mock_events_post, assert results[-2] == rows_cnt # biz_events assert results[-1] == rows_cnt # davis_events - @patch("dtagent.otel.otel_manager.CustomLoggingSession.send") - @patch("dtagent.otel.metrics.requests.post") - @patch("dtagent.otel.events.generic.requests.post") - @patch("dtagent.otel.events.davis.requests.post") - @patch("dtagent.otel.events.bizevents.requests.post") - def test_large_view_send_as_be(self, mock_bizevents_post, mock_davis_post, mock_events_post, mock_metrics_post, mock_otel_post): + @pytest.mark.xdist_group(name="test_telemetry") + def test_large_view_send_as_be(self): import random rows_cnt = random.randint(410, 500) - mock_davis_post.side_effect = side_effect_function - mock_events_post.side_effect = side_effect_function - mock_bizevents_post.side_effect = side_effect_function - mock_metrics_post.side_effect = side_effect_function - mock_otel_post.side_effect = side_effect_function LOG.debug("We will send %s rows as BizEvents", rows_cnt) @@ -110,6 +92,7 @@ def test_large_view_send_as_be(self, mock_bizevents_post, mock_davis_post, mock_ {"auto_mode": False, "logs": False, "events": False, "bizevents": True}, limit_results=rows_cnt, config=_utils.get_config(), + test_source=None, # we don to record tests with variable data size ) LOG.debug("We have sent %d rows as BizEvents", results[-1]) @@ -120,17 +103,8 @@ def test_large_view_send_as_be(self, mock_bizevents_post, mock_davis_post, mock_ assert results[-2] == rows_cnt # bizevents assert results[-1] == 0 # bizevents - @patch("dtagent.otel.otel_manager.CustomLoggingSession.send") - @patch("dtagent.otel.metrics.requests.post") - @patch("dtagent.otel.events.generic.requests.post") - @patch("dtagent.otel.events.davis.requests.post") - @patch("dtagent.otel.events.bizevents.requests.post") - def test_dtagent_bizevents(self, mock_bizevents_post, mock_davis_post, mock_events_post, mock_metrics_post, mock_otel_post): - mock_davis_post.side_effect = side_effect_function - mock_events_post.side_effect = side_effect_function - mock_bizevents_post.side_effect = side_effect_function - mock_metrics_post.side_effect = side_effect_function - mock_otel_post.side_effect = side_effect_function + @pytest.mark.xdist_group(name="test_telemetry") + def test_connector_bizevents(self): session = _get_session() sender = LocalTelemetrySender( @@ -138,31 +112,25 @@ def test_dtagent_bizevents(self, mock_bizevents_post, mock_davis_post, mock_even {"auto_mode": False, "logs": False, "events": False, "bizevents": True}, config=_utils.get_config(), ) - results = sender.send_data( - [ - { - "event.provider": str(sender._configuration.get(context="resource.attributes", key="host.name")), - "dsoa.task.exec.id": get_now_timestamp_formatted(), - "dsoa.task.name": "test_events", - "dsoa.task.exec.status": "FINISHED", - } - ] - ) - sender.teardown() + data = [ + { + "event.provider": str(sender._configuration.get(context="resource.attributes", key="host.name")), + "dsoa.task.exec.id": get_now_timestamp_formatted(), + "dsoa.task.name": "test_events", + "dsoa.task.exec.status": "FINISHED", + } + ] + mock_client = MockTelemetryClient("test_connector_bizevents") + with mock_client.mock_telemetry_sending(): + results = sender.send_data(data) + sender._logs.shutdown_logger() + sender._spans.shutdown_tracer() + mock_client.store_or_test_results() assert results[-2] == 1 - @patch("dtagent.otel.otel_manager.CustomLoggingSession.send") - @patch("dtagent.otel.metrics.requests.post") - @patch("dtagent.otel.events.generic.requests.post") - @patch("dtagent.otel.events.davis.requests.post") - @patch("dtagent.otel.events.bizevents.requests.post") - def test_automode(self, mock_bizevents_post, mock_davis_post, mock_events_post, mock_metrics_post, mock_otel_post): - mock_davis_post.side_effect = side_effect_function - mock_events_post.side_effect = side_effect_function - mock_bizevents_post.side_effect = side_effect_function - mock_metrics_post.side_effect = side_effect_function - mock_otel_post.side_effect = side_effect_function + @pytest.mark.xdist_group(name="test_telemetry") + def test_automode(self): session = _get_session() structured_test_data = read_clean_json_from_file("test/test_data/telemetry_structured.json") @@ -171,36 +139,62 @@ def test_automode(self, mock_bizevents_post, mock_davis_post, mock_events_post, # Results are (Count of objects, log lines, metrics, events, bizevents, and davis events sent) # sending all data from a given (standard structure) view - assert (2, 2, 2, 3, 0, 0) == telemetry_test_sender(session, "APP.V_DATA_VOLUME", {}, config=_utils.get_config()) + assert (2, 2, 2, 3, 0, 0) == telemetry_test_sender( + session, "APP.V_DATA_VOLUME", {}, config=_utils.get_config(), test_source="test_automode/000" + ) # sending data from a given (standard structure) view, excluding metrics - assert (2, 2, 0, 3, 0, 0) == telemetry_test_sender(session, "APP.V_DATA_VOLUME", {"metrics": False}, config=_utils.get_config()) + assert (2, 2, 0, 3, 0, 0) == telemetry_test_sender( + session, "APP.V_DATA_VOLUME", {"metrics": False}, config=_utils.get_config(), test_source="test_automode/001" + ) # sending data from a given (standard structure) view, excluding events - assert (2, 2, 2, 0, 0, 0) == telemetry_test_sender(session, "APP.V_DATA_VOLUME", {"events": False}, config=_utils.get_config()) + assert (2, 2, 2, 0, 0, 0) == telemetry_test_sender( + session, "APP.V_DATA_VOLUME", {"events": False}, config=_utils.get_config(), test_source="test_automode/002" + ) # sending data from a given (standard structure) view, excluding logs - assert (2, 0, 2, 3, 0, 0) == telemetry_test_sender(session, "APP.V_DATA_VOLUME", {"logs": False}, config=_utils.get_config()) + assert (2, 0, 2, 3, 0, 0) == telemetry_test_sender( + session, "APP.V_DATA_VOLUME", {"logs": False}, config=_utils.get_config(), test_source="test_automode/003" + ) # sending all data from a given (standard structure) object - assert (1, 1, 1, 2, 0, 0) == telemetry_test_sender(session, structured_test_data[0], {}, config=_utils.get_config()) + assert (1, 1, 1, 2, 0, 0) == telemetry_test_sender( + session, structured_test_data[0], {}, config=_utils.get_config(), test_source="test_automode/004" + ) # sending all data from a given (standard structure) view - assert (2, 2, 2, 3, 0, 0) == telemetry_test_sender(session, structured_test_data, {}, config=_utils.get_config()) + assert (2, 2, 2, 3, 0, 0) == telemetry_test_sender( + session, structured_test_data, {}, config=_utils.get_config(), test_source="test_automode/005" + ) # sending data from a given (standard structure) view, excluding metrics - assert (2, 2, 0, 3, 0, 0) == telemetry_test_sender(session, structured_test_data, {"metrics": False}, config=_utils.get_config()) + assert (2, 2, 0, 3, 0, 0) == telemetry_test_sender( + session, structured_test_data, {"metrics": False}, config=_utils.get_config(), test_source="test_automode/006" + ) # sending data from a given (standard structure) view, excluding events - assert (2, 2, 2, 0, 0, 0) == telemetry_test_sender(session, structured_test_data, {"events": False}, config=_utils.get_config()) + assert (2, 2, 2, 0, 0, 0) == telemetry_test_sender( + session, structured_test_data, {"events": False}, config=_utils.get_config(), test_source="test_automode/007" + ) # sending data from a given (standard structure) view, excluding logs - assert (2, 0, 2, 3, 0, 0) == telemetry_test_sender(session, structured_test_data, {"logs": False}, config=_utils.get_config()) + assert (2, 0, 2, 3, 0, 0) == telemetry_test_sender( + session, structured_test_data, {"logs": False}, config=_utils.get_config(), test_source="test_automode/008" + ) # sending all data from a given (custom structure) view as logs assert (3, 3, 0, 0, 0, 0) == telemetry_test_sender( - session, unstructured_test_data, {"auto_mode": False}, config=_utils.get_config() + session, unstructured_test_data, {"auto_mode": False}, config=_utils.get_config(), test_source="test_automode/009" ) # sending all data from a given (custom structure) view as events assert (3, 0, 0, 3, 0, 0) == telemetry_test_sender( - session, unstructured_test_data, {"auto_mode": False, "logs": False, "events": True}, config=_utils.get_config() + session, + unstructured_test_data, + {"auto_mode": False, "logs": False, "events": True}, + config=_utils.get_config(), + test_source="test_automode/010", ) # sending all data from a given (custom structure) view as bizevents assert (3, 0, 0, 0, 3, 0) == telemetry_test_sender( - session, unstructured_test_data, {"auto_mode": False, "logs": False, "bizevents": True}, config=_utils.get_config() + session, + unstructured_test_data, + {"auto_mode": False, "logs": False, "bizevents": True}, + config=_utils.get_config(), + test_source="test_automode/011", ) # sending all data from a given (custom structure) view as logs, events, and bizevents assert (3, 3, 0, 3, 3, 0) == telemetry_test_sender( @@ -208,6 +202,7 @@ def test_automode(self, mock_bizevents_post, mock_davis_post, mock_events_post, unstructured_test_data, {"auto_mode": False, "logs": True, "events": True, "bizevents": True}, config=_utils.get_config(), + test_source="test_automode/012", ) # sending single data point from a given (custom structure) view as logs, events, and bizevents assert (1, 1, 0, 1, 1, 0) == telemetry_test_sender( @@ -215,6 +210,7 @@ def test_automode(self, mock_bizevents_post, mock_davis_post, mock_events_post, unstructured_test_data[0], {"auto_mode": False, "logs": True, "events": True, "bizevents": True}, config=_utils.get_config(), + test_source="test_automode/013", ) # sending single data point from a given (custom structure) with datetime objects view as logs, events, and bizevents assert (1, 1, 0, 1, 1, 0) == telemetry_test_sender( @@ -222,4 +218,5 @@ def test_automode(self, mock_bizevents_post, mock_davis_post, mock_events_post, unstructured_test_data[0] | {"observed_at": get_now_timestamp()}, {"auto_mode": False, "logs": True, "events": True, "bizevents": True}, config=_utils.get_config(), + test_source="test_automode/014", ) diff --git a/test/otel/test_events.py b/test/otel/test_events.py index 13df770c..408e3d40 100644 --- a/test/otel/test_events.py +++ b/test/otel/test_events.py @@ -26,8 +26,8 @@ from dtagent.otel.events import EventType from dtagent.context import get_context_by_name from dtagent.util import get_now_timestamp, get_now_timestamp_formatted -from test import side_effect_function from test._utils import get_config +from test._mocks.telemetry import MockTelemetryClient class TestEvents: @@ -50,201 +50,212 @@ def test_eventtype_enum(self): assert isinstance(t, EventType), "event type should be of EventType" assert str(t) == "CUSTOM_ALERT", "event type {t} should render in capital letters" - @patch("dtagent.otel.events.davis.requests.post") - def test_send_events_directly(self, mock_events_post): + def test_send_events_directly(self): + + def _test_send_events_directly(test_mode="davis"): + import time + + mock_client = MockTelemetryClient(f"test_send_{test_mode}_events_directly") + with mock_client.mock_telemetry_sending(): + events = self._dtagent._get_davis_events() if test_mode == "davis" else self._dtagent._get_events() + + events_sent = events.send_events( + event_type=EventType.CUSTOM_INFO, title="Dynatrace Snowflake Observability Agent test event 1", events_data=[{}] + ) + assert events_sent + events.flush_events() >= 0 + + events_sent += events.send_events( + # this will be reported as Availability problem + event_type=EventType.AVAILABILITY_EVENT, + title="Dynatrace Snowflake Observability Agent test event 2", + events_data=[{}], + additional_payload={ + "test.event.dtagent.number": 10, + "test.event.dtagent.text": "some text", + "test.event.dtagent.bool": True, + "test.event.dtagent.list": [1, 2, 3], + "test.event.dtagent.dict": {"k1": "v1", "k2": 2}, + "test.event.dtagent.datetime": get_now_timestamp(), + }, + timeout=30, + ) + assert events_sent + events.flush_events() >= 0 + + events_sent += events.send_events( + event_type=EventType.CUSTOM_ANNOTATION, + title="Dynatrace Snowflake Observability Agent test event 3", + events_data=[{}], + additional_payload={ + "test.event.dtagent.info": "timeout", + }, + timeout=30, + ) + assert events_sent + events.flush_events() >= 0 + + current_time_ms = int(time.time() * 1000) + ten_minutes_ago_ms = current_time_ms - (10 * 60 * 1000) + fifteen_minutes_from_now_ms = current_time_ms + (15 * 60 * 1000) + + events_sent += events.send_events( + # this will be reported as Custom problem + event_type=EventType.CUSTOM_ALERT, + title="Dynatrace Snowflake Observability Agent test event 4", + events_data=[{}], + additional_payload={ + "test.event.dtagent.info": "10 min in the past", + }, + start_time=ten_minutes_ago_ms, + timeout=15, + ) + assert events_sent + events.flush_events() >= 0 + + events_sent += events.send_events( + event_type=EventType.CUSTOM_DEPLOYMENT, + title="Dynatrace Snowflake Observability Agent test event 5", + events_data=[{}], + additional_payload={ + "test.event.dtagent.info": "15 min in the future", + }, + end_time=fifteen_minutes_from_now_ms, + ) + assert events_sent + events.flush_events() >= 0 + + events_sent += events.send_events( + event_type=EventType.CUSTOM_DEPLOYMENT, + title="Dynatrace Snowflake Observability Agent test event 6", + events_data=[{}], + additional_payload={ + "test.event.dtagent.info": "15 min in the future", + }, + context=get_context_by_name("data_volume"), + end_time=fifteen_minutes_from_now_ms, + ) + assert events_sent + events.flush_events() >= 0 + + mock_client.store_or_test_results() + + _test_send_events_directly(test_mode="davis") + _test_send_events_directly(test_mode="generic") + + def test_send_bizevents_directly(self): import time - mock_events_post.side_effect = side_effect_function events = self._dtagent._get_davis_events() - events_sent = events.send_events( - events_data={}, - event_type=EventType.CUSTOM_INFO, - title="Dynatrace Snowflake Observability Agent test event 1", - ) - assert events_sent + events.flush_events() >= 0 - - events_sent = events.send_events( - # this will be reported as Availability problem - events_data=[ - { - "test.event.dtagent.number": 10, - "test.event.dtagent.text": "some text", - "test.event.dtagent.bool": True, - "test.event.dtagent.list": [1, 2, 3], - "test.event.dtagent.dict": {"k1": "v1", "k2": 2}, - "test.event.dtagent.datetime": get_now_timestamp(), - } - ], - event_type=EventType.AVAILABILITY_EVENT, - title="Dynatrace Snowflake Observability Agent test event 2", - timeout=30, - ) - assert events_sent + events.flush_events() >= 0 - - events_sent = events.send_events( - events_data=[ - { - "test.event.dtagent.info": "timeout", - } - ], - event_type=EventType.CUSTOM_ANNOTATION, - title="Dynatrace Snowflake Observability Agent test event 3", - timeout=30, - ) - assert events_sent + events.flush_events() >= 0 - - current_time_ms = int(time.time() * 1000) - ten_minutes_ago_ms = current_time_ms - (10 * 60 * 1000) - fifteen_minutes_from_now_ms = current_time_ms + (15 * 60 * 1000) - - events_sent = events.send_events( - # this will be reported as Custom problem - events_data=[ - { - "test.event.dtagent.info": "10 min in the past", - } - ], - event_type=EventType.CUSTOM_ALERT, - title="Dynatrace Snowflake Observability Agent test event 4", - start_time=ten_minutes_ago_ms, - timeout=15, - ) - assert events_sent + events.flush_events() >= 0 - - events_sent = events.send_events( - events_data=[ - { - "test.event.dtagent.info": "15 min in the future", - } - ], - event_type=EventType.CUSTOM_DEPLOYMENT, - title="Dynatrace Snowflake Observability Agent test event 5", - end_time=fifteen_minutes_from_now_ms, - ) - assert events_sent + events.flush_events() >= 0 - - events_sent = events.send_events( - events_data=[ - { - "test.event.dtagent.info": "15 min in the future", - } - ], - event_type=EventType.CUSTOM_DEPLOYMENT, - title="Dynatrace Snowflake Observability Agent test event 6", - context=get_context_by_name("data_volume"), - end_time=fifteen_minutes_from_now_ms, - ) - assert events_sent + events.flush_events() >= 0 - - @patch("dtagent.otel.events.bizevents.requests.post") - def test_send_bizevents_directly(self, mock_events_post): - import time + mock_client = MockTelemetryClient("test_send_bizevents_directly") + with mock_client.mock_telemetry_sending(): + events = self._dtagent._get_biz_events() + + events_sent = events.send_events( + [ + { + "test.bizevent.message": "Dynatrace Snowflake Observability Agent test event 123", + "test.ts": get_now_timestamp_formatted(), + } + ] + ) + assert events_sent >= 0 + + new_events_sent = events.send_events( + [ + { + "test.event.dtagent.number": 10, + "test.event.dtagent.text": "some text", + "test.event.dtagent.bool": True, + } + ] + ) - mock_events_post.side_effect = side_effect_function - events = self._dtagent._get_biz_events() - - events_sent = events.send_events( - [{"test.bizevent.message": "Dynatrace Snowflake Observability Agent test event 123", "test.ts": get_now_timestamp_formatted()}] - ) - assert events_sent >= 0 - - new_events_sent = events.send_events( - [ - { - "test.event.dtagent.number": 10, - "test.event.dtagent.text": "some text", - "test.event.dtagent.bool": True, - } - ] - ) - - assert new_events_sent >= 0 - events_sent += new_events_sent - - current_time_ms = int(time.time() * 1000) - ten_minutes_ago_ms = current_time_ms - (10 * 60 * 1000) - fifteen_minutes_from_now_ms = current_time_ms + (15 * 60 * 1000) - - new_events_sent = events.send_events( - [ - {"test.event.dtagent.info": "timeout", "event.type": str(EventType.CUSTOM_ANNOTATION)}, - { - "test.event.dtagent.info": "10 min in the past", - "test.event.dtagent.start_time": ten_minutes_ago_ms, - }, - { - "test.event.dtagent.info": "15 min in the future", - "test.event.dtagent.start_time": ten_minutes_ago_ms, - "test.event.dtagent.end_time": fifteen_minutes_from_now_ms, - "test.event.dtagent.timeout": 15, - }, - ] - ) - assert new_events_sent >= 0 - events_sent += new_events_sent - - new_events_sent = events.flush_events() - assert new_events_sent >= 0 - events_sent += new_events_sent - - assert events_sent == 5 - - @patch("dtagent.otel.events.davis.requests.post") - def test_send_results_as_events(self, mock_events_post): - from test import _utils + assert new_events_sent >= 0 + events_sent += new_events_sent + + current_time_ms = int(time.time() * 1000) + ten_minutes_ago_ms = current_time_ms - (10 * 60 * 1000) + fifteen_minutes_from_now_ms = current_time_ms + (15 * 60 * 1000) + + new_events_sent = events.send_events( + [ + {"test.event.dtagent.info": "timeout", "event.type": str(EventType.CUSTOM_ANNOTATION)}, + { + "test.event.dtagent.info": "10 min in the past", + "test.event.dtagent.start_time": ten_minutes_ago_ms, + }, + { + "test.event.dtagent.info": "15 min in the future", + "test.event.dtagent.start_time": ten_minutes_ago_ms, + "test.event.dtagent.end_time": fifteen_minutes_from_now_ms, + "test.event.dtagent.timeout": 15, + }, + ] + ) + assert new_events_sent >= 0 + events_sent += new_events_sent - mock_events_post.side_effect = side_effect_function - events = self._dtagent._get_davis_events() + new_events_sent = events.flush_events() + assert new_events_sent >= 0 + events_sent += new_events_sent - PICKLE_NAME = "test/test_data/data_volume.pkl" - for row_dict in _utils._get_unpickled_entries(PICKLE_NAME, limit=2): + assert events_sent == 5 + mock_client.store_or_test_results() - events_sent = events.report_via_api( - query_data=row_dict, - event_type=EventType.CUSTOM_INFO, - title="Test event for Data Volume", - ) - assert events_sent + events.flush_events() > 0 - - @patch("dtagent.otel.events.bizevents.requests.post") - def test_send_results_as_bizevents(self, mock_events_post): + def test_send_results_as_events(self): from test import _utils - mock_events_post.side_effect = side_effect_function - bizevents = self._dtagent._get_biz_events() + mock_client = MockTelemetryClient("test_send_results_as_events") + with mock_client.mock_telemetry_sending(): + events = self._dtagent._get_events() + + PICKLE_NAME = "test/test_data/data_volume.pkl" + for row_dict in _utils._get_unpickled_entries(PICKLE_NAME, limit=2): + events_sent = events.report_via_api( + query_data=row_dict, + event_type=EventType.CUSTOM_INFO, + title="Test event for Data Volume", + ) + assert events_sent + events.flush_events() > 0 - PICKLE_NAME = "test/test_data/data_volume.pkl" + mock_client.store_or_test_results() - events_sent = bizevents.report_via_api( - query_data=_utils._get_unpickled_entries(PICKLE_NAME, limit=2), - event_type=str(EventType.CUSTOM_INFO), - context=get_context_by_name("data_volume"), - ) + def test_send_results_as_bizevents(self): + from test import _utils - events_sent += bizevents.flush_events() + mock_client = MockTelemetryClient("test_send_results_as_bizevents") + with mock_client.mock_telemetry_sending(): + bizevents = self._dtagent._get_biz_events() - assert events_sent == 2 + PICKLE_NAME = "test/test_data/data_volume.pkl" - @patch("dtagent.otel.events.bizevents.requests.post") - def test_dtagent_bizevents(self, mock_events_post): - mock_events_post.side_effect = side_effect_function - bizevents = self._dtagent._get_biz_events() + events_sent = bizevents.report_via_api( + query_data=_utils._get_unpickled_entries(PICKLE_NAME, limit=2), + event_type=str(EventType.CUSTOM_INFO), + context=get_context_by_name("data_volume"), + ) - cnt = bizevents.report_via_api( - context=get_context_by_name("self-monitoring"), - event_type="dsoa.task", - query_data=[ - { - "event.provider": str(self._dtagent._configuration.get(context="resource.attributes", key="host.name")), - "dsoa.task.exec.id": get_now_timestamp_formatted(), - "dsoa.task.name": "test_events", - "dsoa.task.exec.status": "FINISHED", - } - ], - is_data_structured=False, - ) + events_sent += bizevents.flush_events() + + assert events_sent == 2 + mock_client.store_or_test_results() + + def test_dtagent_bizevents(self): + mock_client = MockTelemetryClient("test_dtagent_bizevents") + with mock_client.mock_telemetry_sending(): + bizevents = self._dtagent._get_biz_events() + + cnt = bizevents.report_via_api( + context=get_context_by_name("self-monitoring"), + event_type="dsoa.task", + query_data=[ + { + "event.provider": str(self._dtagent._configuration.get(context="resource.attributes", key="host.name")), + "dsoa.task.exec.id": get_now_timestamp_formatted(), + "dsoa.task.name": "test_events", + "dsoa.task.exec.status": "FINISHED", + } + ], + is_data_structured=False, + ) - cnt += bizevents.flush_events() + cnt += bizevents.flush_events() - assert cnt == 1 + assert cnt == 1 + mock_client.store_or_test_results() diff --git a/test/plugins/test_active_queries.py b/test/plugins/test_active_queries.py index 6a932919..ce98768b 100644 --- a/test/plugins/test_active_queries.py +++ b/test/plugins/test_active_queries.py @@ -22,8 +22,11 @@ # # class TestActiveQueries: + import pytest + PICKLES = {"SELECT * FROM TABLE(DTAGENT_DB.APP.F_ACTIVE_QUERIES_INSTRUMENTED())": "test/test_data/active_queries.pkl"} + @pytest.mark.xdist_group(name="test_telemetry") def test_active_queries(self): import logging from unittest.mock import patch @@ -52,9 +55,7 @@ def __local_get_plugin_class(source: str): # ====================================================================== session = _get_session() - utils._logging_findings( - session, TestDynatraceSnowAgent(session, utils.get_config()), "test_active_queries", logging.DEBUG, show_detailed_logs=1 - ) + utils._logging_findings(session, TestDynatraceSnowAgent(session, utils.get_config()), "test_active_queries", logging.DEBUG, True) if __name__ == "__main__": diff --git a/test/plugins/test_budgets.py b/test/plugins/test_budgets.py index 94e1f4dc..bf584392 100644 --- a/test/plugins/test_budgets.py +++ b/test/plugins/test_budgets.py @@ -22,11 +22,14 @@ # # class TestBudgets: + import pytest + PICKLES = { "APP.V_BUDGET_DETAILS": "test/test_data/budgets.pkl", "APP.V_BUDGET_SPENDINGS": "test/test_data/budget_spendings.pkl", } + @pytest.mark.xdist_group(name="test_telemetry") def test_budgets(self): from unittest.mock import patch from typing import Dict, Generator @@ -55,9 +58,7 @@ def __local_get_plugin_class(source: str): import logging session = _get_session() - utils._logging_findings( - session, TestDynatraceSnowAgent(session, utils.get_config()), "test_budget", logging.INFO, show_detailed_logs=0 - ) + utils._logging_findings(session, TestDynatraceSnowAgent(session, utils.get_config()), "test_budget", logging.INFO, False) if __name__ == "__main__": diff --git a/test/plugins/test_data_schemas.py b/test/plugins/test_data_schemas.py index b1289acb..727c22e4 100644 --- a/test/plugins/test_data_schemas.py +++ b/test/plugins/test_data_schemas.py @@ -22,8 +22,11 @@ # # class TestDataSchemas: + import pytest + PICKLES = {"APP.V_DATA_SCHEMAS": "test/test_data/data_schemas.pkl"} + @pytest.mark.xdist_group(name="test_telemetry") def test_data_schemas(self): from typing import Dict, Generator from dtagent.plugins.data_schemas import DataSchemasPlugin @@ -50,9 +53,7 @@ def __local_get_plugin_class(source: str): import logging session = _get_session() - utils._logging_findings( - session, TestDynatraceSnowAgent(session, utils.get_config()), "test_data_schemas", logging.INFO, show_detailed_logs=0 - ) + utils._logging_findings(session, TestDynatraceSnowAgent(session, utils.get_config()), "test_data_schemas", logging.INFO, False) if __name__ == "__main__": diff --git a/test/plugins/test_data_volume.py b/test/plugins/test_data_volume.py index 09662cf2..a6b02260 100644 --- a/test/plugins/test_data_volume.py +++ b/test/plugins/test_data_volume.py @@ -22,8 +22,11 @@ # # class TestDataVol: + import pytest + PICKLES = {"APP.V_DATA_VOLUME": "test/test_data/data_volume.pkl"} + @pytest.mark.xdist_group(name="test_telemetry") def test_data_vol(self): from typing import Dict, Generator from dtagent.plugins.data_volume import DataVolumePlugin @@ -50,9 +53,7 @@ def __local_get_plugin_class(source: str): import logging session = _get_session() - utils._logging_findings( - session, TestDynatraceSnowAgent(session, utils.get_config()), "test_data_volume", logging.INFO, show_detailed_logs=0 - ) + utils._logging_findings(session, TestDynatraceSnowAgent(session, utils.get_config()), "test_data_volume", logging.INFO, False) if __name__ == "__main__": diff --git a/test/plugins/test_dynamic_tables.py b/test/plugins/test_dynamic_tables.py index c777bbdb..767dab43 100644 --- a/test/plugins/test_dynamic_tables.py +++ b/test/plugins/test_dynamic_tables.py @@ -22,12 +22,15 @@ # # class TestDynamicTables: + import pytest + PICKLES = { "APP.V_DYNAMIC_TABLES_INSTRUMENTED": "test/test_data/dynamic_tables.pkl", "APP.V_DYNAMIC_TABLE_REFRESH_HISTORY_INSTRUMENTED": "test/test_data/dynamic_table_refresh_history.pkl", "APP.V_DYNAMIC_TABLE_GRAPH_HISTORY_INSTRUMENTED": "test/test_data/dynamic_table_graph_history.pkl", } + @pytest.mark.xdist_group(name="test_telemetry") def test_dynamic_tables(self): import logging from unittest.mock import patch @@ -56,9 +59,7 @@ def __local_get_plugin_class(source: str): # ====================================================================== session = _get_session() - utils._logging_findings( - session, TestDynatraceSnowAgent(session, utils.get_config()), "test_dynamic_tables", logging.DEBUG, show_detailed_logs=1 - ) + utils._logging_findings(session, TestDynatraceSnowAgent(session, utils.get_config()), "test_dynamic_tables", logging.DEBUG, True) if __name__ == "__main__": diff --git a/test/plugins/test_event_log.py b/test/plugins/test_event_log.py index 164478d6..2c36fcc2 100644 --- a/test/plugins/test_event_log.py +++ b/test/plugins/test_event_log.py @@ -22,12 +22,15 @@ # # class TestEventLog: + import pytest + PICKLES = { "APP.V_EVENT_LOG": "test/test_data/event_log.pkl", "APP.V_EVENT_LOG_METRICS_INSTRUMENTED": "test/test_data/event_log_metrics.pkl", "APP.V_EVENT_LOG_SPANS_INSTRUMENTED": "test/test_data/event_log_spans.pkl", } + @pytest.mark.xdist_group(name="test_telemetry") def test_event_log(self): import logging from unittest.mock import patch @@ -58,9 +61,7 @@ def __local_get_plugin_class(source: str): # ====================================================================== session = _get_session() - utils._logging_findings( - session, TestDynatraceSnowAgent(session, utils.get_config()), "test_event_log", logging.INFO, show_detailed_logs=0 - ) + utils._logging_findings(session, TestDynatraceSnowAgent(session, utils.get_config()), "test_event_log", logging.INFO, False) if __name__ == "__main__": diff --git a/test/plugins/test_event_usage.py b/test/plugins/test_event_usage.py index 878017ee..a93ce049 100644 --- a/test/plugins/test_event_usage.py +++ b/test/plugins/test_event_usage.py @@ -22,8 +22,11 @@ # # class TestEventUsage: + import pytest + PICKLES = {"APP.V_EVENT_USAGE_HISTORY": "test/test_data/event_usage.pkl"} + @pytest.mark.xdist_group(name="test_telemetry") def test_event_usage(self): import logging from unittest.mock import patch @@ -52,9 +55,7 @@ def __local_get_plugin_class(source: str): # ====================================================================== session = _get_session() - utils._logging_findings( - session, TestDynatraceSnowAgent(session, utils.get_config()), "test_event_usage", logging.INFO, show_detailed_logs=0 - ) + utils._logging_findings(session, TestDynatraceSnowAgent(session, utils.get_config()), "test_event_usage", logging.INFO, False) if __name__ == "__main__": diff --git a/test/plugins/test_login_history.py b/test/plugins/test_login_history.py index 67ae3e24..aff14c39 100644 --- a/test/plugins/test_login_history.py +++ b/test/plugins/test_login_history.py @@ -22,8 +22,11 @@ # # class TestLoginHist: + import pytest + PICKLES = {"APP.V_LOGIN_HISTORY": "test/test_data/login_history.pkl", "APP.V_SESSIONS": "test/test_data/sessions.pkl"} + @pytest.mark.xdist_group(name="test_telemetry") def test_login_hist(self): import logging from unittest.mock import patch @@ -51,9 +54,7 @@ def __local_get_plugin_class(source: str): # ====================================================================== session = _get_session() - utils._logging_findings( - session, TestDynatraceSnowAgent(session, utils.get_config()), "test_login_history", logging.INFO, show_detailed_logs=0 - ) + utils._logging_findings(session, TestDynatraceSnowAgent(session, utils.get_config()), "test_login_history", logging.INFO, False) if __name__ == "__main__": diff --git a/test/plugins/test_query_history.py b/test/plugins/test_query_history.py index 03b7f7b2..e3f8576f 100644 --- a/test/plugins/test_query_history.py +++ b/test/plugins/test_query_history.py @@ -22,8 +22,11 @@ # # class TestQueryHist: + import pytest + PICKLES = {"APP.V_RECENT_QUERIES": "test/test_data/recent_queries2.pkl"} + @pytest.mark.xdist_group(name="test_telemetry") def test_query_hist(self): import logging from unittest.mock import patch @@ -89,9 +92,7 @@ def __local_get_plugin_class(source: str): session = _get_session() # when sending spans log level cannot be set, hence "" to omit it in the utils - utils._logging_findings( - session, TestSpanDynatraceSnowAgent(session, utils.get_config()), "test_query_history", logging.INFO, show_detailed_logs=0 - ) + utils._logging_findings(session, TestSpanDynatraceSnowAgent(session, utils.get_config()), "test_query_history", logging.INFO, False) if __name__ == "__main__": diff --git a/test/plugins/test_resource_monitors.py b/test/plugins/test_resource_monitors.py index 185e7daf..20b5aeaa 100644 --- a/test/plugins/test_resource_monitors.py +++ b/test/plugins/test_resource_monitors.py @@ -22,10 +22,13 @@ # # class TestResMon: + import pytest + T_DATA_RESMON = "APP.V_RESOURCE_MONITORS" T_DATA_WHS = "APP.V_WAREHOUSES" PICKLES = {T_DATA_RESMON: "test/test_data/resource_monitors.pkl", T_DATA_WHS: "test/test_data/warehouses.pkl"} + @pytest.mark.xdist_group(name="test_telemetry") def test_res_mon(self): import logging from unittest.mock import patch @@ -61,9 +64,7 @@ def __local_get_plugin_class(source: str): # ====================================================================== session = _get_session() - utils._logging_findings( - session, TestDynatraceSnowAgent(session, utils.get_config()), "test_resource_monitors", logging.INFO, show_detailed_logs=0 - ) + utils._logging_findings(session, TestDynatraceSnowAgent(session, utils.get_config()), "test_resource_monitors", logging.INFO, False) if __name__ == "__main__": diff --git a/test/plugins/test_shares.py b/test/plugins/test_shares.py index 943f0ccf..251f4f44 100644 --- a/test/plugins/test_shares.py +++ b/test/plugins/test_shares.py @@ -22,12 +22,15 @@ # # class TestShares: + import pytest + PICKLES = { "APP.V_INBOUND_SHARE_TABLES": "test/test_data/inbound_shares.pkl", "APP.V_OUTBOUND_SHARE_TABLES": "test/test_data/outbound_shares.pkl", "APP.V_SHARE_EVENTS": "test/test_data/shares.pkl", } + @pytest.mark.xdist_group(name="test_telemetry") def test_shares(self): import logging from unittest.mock import patch @@ -60,9 +63,7 @@ def __local_get_plugin_class(source: str): # ====================================================================== session = _get_session() - utils._logging_findings( - session, TestDynatraceSnowAgent(session, utils.get_config()), "test_shares", logging.INFO, show_detailed_logs=0 - ) + utils._logging_findings(session, TestDynatraceSnowAgent(session, utils.get_config()), "test_shares", logging.INFO, False) if __name__ == "__main__": diff --git a/test/plugins/test_tasks.py b/test/plugins/test_tasks.py index 0b9b685c..46816f4c 100644 --- a/test/plugins/test_tasks.py +++ b/test/plugins/test_tasks.py @@ -22,12 +22,15 @@ # # class TestTasks: + import pytest + PICKLES = { "APP.V_SERVERLESS_TASKS": "test/test_data/tasks_serverless.pkl", "APP.V_TASK_HISTORY": "test/test_data/tasks_history.pkl", "APP.V_TASK_VERSIONS": "test/test_data/tasks_versions.pkl", } + @pytest.mark.xdist_group(name="test_telemetry") def test_tasks(self): from typing import Generator, Dict @@ -57,9 +60,7 @@ def __local_get_plugin_class(source: str): import logging - utils._logging_findings( - session, TestDynatraceSnowAgent(session, utils.get_config()), "test_tasks", logging.INFO, show_detailed_logs=1 - ) + utils._logging_findings(session, TestDynatraceSnowAgent(session, utils.get_config()), "test_tasks", logging.INFO, True) if __name__ == "__main__": diff --git a/test/plugins/test_trust_center.py b/test/plugins/test_trust_center.py index b2604c0d..cb45de83 100644 --- a/test/plugins/test_trust_center.py +++ b/test/plugins/test_trust_center.py @@ -22,11 +22,14 @@ # # class TestTrustCenter: + import pytest + PICKLES = { "APP.V_TRUST_CENTER_METRICS": "test/test_data/trust_center_metrics.pkl", "APP.V_TRUST_CENTER_INSTRUMENTED": "test/test_data/trust_center_instr.pkl", } + @pytest.mark.xdist_group(name="test_telemetry") def test_trust_center(self): from typing import Generator, Dict @@ -54,9 +57,7 @@ def __local_get_plugin_class(source: str): # ====================================================================== session = _get_session() - utils._logging_findings( - session, TestDynatraceSnowAgent(session, utils.get_config()), "test_trust_center", logging.INFO, show_detailed_logs=0 - ) + utils._logging_findings(session, TestDynatraceSnowAgent(session, utils.get_config()), "test_trust_center", logging.INFO, False) if __name__ == "__main__": diff --git a/test/plugins/test_users.py b/test/plugins/test_users.py index 9cbb9fe2..42262619 100644 --- a/test/plugins/test_users.py +++ b/test/plugins/test_users.py @@ -22,6 +22,8 @@ # # class TestUsers: + import pytest + PICKLES = { "APP.V_USERS_INSTRUMENTED": "test/test_data/users_hist.pkl", "APP.V_USERS_ALL_PRIVILEGES_INSTRUMENTED": "test/test_data/users_all_privileges.pkl", @@ -30,6 +32,7 @@ class TestUsers: "APP.V_USERS_REMOVED_DIRECT_ROLES_INSTRUMENTED": "test/test_data/users_roles_direct_removed.pkl", } + @pytest.mark.xdist_group(name="test_telemetry") def test_users(self): import logging @@ -51,7 +54,9 @@ def test_users(self): class TestUsersPlugin(UsersPlugin): def _get_table_rows(self, t_data: str) -> Generator[Dict, None, None]: - return utils._safe_get_unpickled_entries(TestUsers.PICKLES, t_data, limit=2) + for r in utils._safe_get_unpickled_entries(TestUsers.PICKLES, t_data, limit=2): + print(f"USER DATA at {t_data}: {r}") + yield r def __local_get_plugin_class(source: str): return TestUsersPlugin @@ -61,9 +66,7 @@ def __local_get_plugin_class(source: str): # ====================================================================== session = _get_session() - utils._logging_findings( - session, TestDynatraceSnowAgent(session, utils.get_config()), "test_users", logging.INFO, show_detailed_logs=0 - ) + utils._logging_findings(session, TestDynatraceSnowAgent(session, utils.get_config()), "test_users", logging.INFO, False) if __name__ == "__main__": diff --git a/test/plugins/test_warehouse_usage.py b/test/plugins/test_warehouse_usage.py index 4f6daedc..4fef4df1 100644 --- a/test/plugins/test_warehouse_usage.py +++ b/test/plugins/test_warehouse_usage.py @@ -22,12 +22,15 @@ # # class TestWhUsage: + import pytest + PICKLES = { "APP.V_WAREHOUSE_EVENT_HISTORY": "test/test_data/wh_usage_events.pkl", "APP.V_WAREHOUSE_LOAD_HISTORY": "test/test_data/wh_usage_loads.pkl", "APP.V_WAREHOUSE_METERING_HISTORY": "test/test_data/wh_usage_metering.pkl", } + @pytest.mark.xdist_group(name="test_telemetry") def test_wh_usage(self): from dtagent.plugins.warehouse_usage import WarehouseUsagePlugin from dtagent import plugins @@ -54,9 +57,7 @@ def __local_get_plugin_class(source: str): # ====================================================================== session = _get_session() - utils._logging_findings( - session, TestDynatraceSnowAgent(session, utils.get_config()), "test_warehouse_usage", logging.INFO, show_detailed_logs=1 - ) + utils._logging_findings(session, TestDynatraceSnowAgent(session, utils.get_config()), "test_warehouse_usage", logging.INFO, True) if __name__ == "__main__": diff --git a/test/test_data/active_queries.ndjson b/test/test_data/active_queries.ndjson new file mode 100644 index 00000000..90a933bc --- /dev/null +++ b/test/test_data/active_queries.ndjson @@ -0,0 +1,2 @@ +{"TIMESTAMP": 1760681128413537000, "QUERY_ID": "01bad30c-0413-9153-0040-e003054c7e46", "SESSION_ID": 18260702047616278, "NAME": "SQL query SUCCESS at DTAGENT_SKRUK_DB", "_MESSAGE": "SQL query SUCCESS at DTAGENT_SKRUK_DB", "START_TIME": 1760681128413537000, "END_TIME": 1760681128541537000, "DIMENSIONS": "{\n \"db.namespace\": \"DTAGENT_SKRUK_DB\",\n \"db.user\": \"SYSTEM\",\n \"snowflake.query.execution_status\": \"SUCCESS\",\n \"snowflake.role.name\": \"DTAGENT_SKRUK_ADMIN\",\n \"snowflake.warehouse.name\": \"DTAGENT_SKRUK_WH\"\n}", "ATTRIBUTES": "{\n \"db.operation.name\": \"SELECT\",\n \"db.query.text\": \"SELECT * FROM CONFIG.CONFIGURATIONS\",\n \"session.id\": 18260702047616278,\n \"snowflake.query.hash\": \"84326d52fdc36120cb311c5f4d8d4d6b\",\n \"snowflake.query.hash_version\": 2,\n \"snowflake.query.id\": \"01bad30c-0413-9153-0040-e003054c7e46\",\n \"snowflake.query.parametrized_hash\": \"84326d52fdc36120cb311c5f4d8d4d6b\",\n \"snowflake.query.parametrized_hash_version\": 1,\n \"snowflake.query.tag\": \"dt_snowagent:2025-03-06_10:20:48.705959\",\n \"snowflake.schema.name\": \"APP\",\n \"snowflake.warehouse.type\": \"STANDARD\"\n}", "METRICS": "{\n \"snowflake.data.written_to_result\": 1781,\n \"snowflake.rows.written_to_result\": 60,\n \"snowflake.time.compilation\": 127,\n \"snowflake.time.execution\": 1,\n \"snowflake.time.total_elapsed\": 128\n}"} +{"TIMESTAMP": 1760681128438911000, "QUERY_ID": "01bad30c-0413-90fb-0040-e003054cc3da", "SESSION_ID": 18260702047672238, "NAME": "SQL query SUCCESS at DTAGENT_SKRUK_DB", "_MESSAGE": "SQL query SUCCESS at DTAGENT_SKRUK_DB", "START_TIME": 1760681128438911000, "END_TIME": 1760681128575911000, "DIMENSIONS": "{\n \"db.namespace\": \"DTAGENT_SKRUK_DB\",\n \"db.user\": \"SYSTEM\",\n \"snowflake.query.execution_status\": \"SUCCESS\",\n \"snowflake.role.name\": \"DTAGENT_SKRUK_ADMIN\",\n \"snowflake.warehouse.name\": \"DTAGENT_SKRUK_WH\"\n}", "ATTRIBUTES": "{\n \"db.operation.name\": \"SELECT\",\n \"db.query.text\": \"SELECT * FROM CONFIG.CONFIGURATIONS\",\n \"session.id\": 18260702047672238,\n \"snowflake.query.hash\": \"84326d52fdc36120cb311c5f4d8d4d6b\",\n \"snowflake.query.hash_version\": 2,\n \"snowflake.query.id\": \"01bad30c-0413-90fb-0040-e003054cc3da\",\n \"snowflake.query.parametrized_hash\": \"84326d52fdc36120cb311c5f4d8d4d6b\",\n \"snowflake.query.parametrized_hash_version\": 1,\n \"snowflake.query.tag\": \"dt_snowagent:2025-03-06_10:20:48.723769\",\n \"snowflake.schema.name\": \"APP\",\n \"snowflake.warehouse.type\": \"STANDARD\"\n}", "METRICS": "{\n \"snowflake.data.written_to_result\": 1781,\n \"snowflake.rows.written_to_result\": 60,\n \"snowflake.time.compilation\": 135,\n \"snowflake.time.execution\": 2,\n \"snowflake.time.total_elapsed\": 137\n}"} diff --git a/test/test_data/budget_spendings.ndjson b/test/test_data/budget_spendings.ndjson new file mode 100644 index 00000000..e69de29b diff --git a/test/test_data/budgets.ndjson b/test/test_data/budgets.ndjson new file mode 100644 index 00000000..ad5f2c2b --- /dev/null +++ b/test/test_data/budgets.ndjson @@ -0,0 +1 @@ +{"_MESSAGE": "Budget details for DTAGENT_BUDGET", "TIMESTAMP": 1760681128908108000, "EVENT_TIMESTAMPS": "{\n \"snowflake.budget.created_on\": 1723624213723000000\n}", "DIMENSIONS": "{\n \"db.namespace\": \"DTAGENT_DB\",\n \"snowflake.budget.name\": \"DTAGENT_BUDGET\",\n \"snowflake.schema.name\": \"APP\"\n}", "ATTRIBUTES": "{\n \"snowflake.budget.owner\": \"ACCOUNTADMIN\",\n \"snowflake.budget.owner.role_type\": \"ROLE\",\n \"snowflake.budget.resource\": [\n {\n \"snowflake.budget.resource.domain\": \"DATABASE\",\n \"snowflake.budget.resource.name\": \"DTAGENT_DB\"\n },\n {\n \"snowflake.budget.resource.domain\": \"WAREHOUSE\",\n \"snowflake.budget.resource.name\": \"DTAGENT_WH\"\n }\n ]\n}", "METRICS": "{\n \"snowflake.credits.limit\": 10\n}"} diff --git a/test/test_data/data_schemas.ndjson b/test/test_data/data_schemas.ndjson new file mode 100644 index 00000000..439c8f4d --- /dev/null +++ b/test/test_data/data_schemas.ndjson @@ -0,0 +1,2 @@ +{"_MESSAGE": "Objects accessed by query 01b165f1-0604-1812-0040-e0030291d142 run by STEFAN.SCHWEIGER", "TIMESTAMP": 1760681129358951000, "ATTRIBUTES": {"snowflake.query.id": "01b165f1-0604-1812-0040-e0030291d142", "snowflake.query.object.modified_by_ddl.domain": "Schema", "snowflake.query.object.modified_by_ddl.id": 1154, "snowflake.query.object.modified_by_ddl.name": "CHARGEBACK_HRC_TEST_DB.LI_TEST", "snowflake.query.object.modified_by_ddl.operation_type": "CREATE", "snowflake.query.user": "STEFAN.SCHWEIGER"}, "EVENT_TIMESTAMPS": "{\n \"snowflake.query.start_time\": 1704191128131000000\n}"} +{"_MESSAGE": "Objects accessed by query 01b165fb-0604-1945-0040-e0030291c3be run by STEFAN.SCHWEIGER", "TIMESTAMP": 1760681129381471000, "ATTRIBUTES": {"snowflake.query.id": "01b165fb-0604-1945-0040-e0030291c3be", "snowflake.query.object.modified_by_ddl.domain": "Table", "snowflake.query.object.modified_by_ddl.id": 719874, "snowflake.query.object.modified_by_ddl.name": "CHARGEBACK_HRC_TEST_DB.LI_TEST.DAILY_COSTS", "snowflake.query.object.modified_by_ddl.operation_type": "CREATE", "snowflake.query.object.modified_by_ddl.properties": "{\"columns\": {\"BOOKING_DATE\": {\"objectId\": {\"value\": 1680388}, \"subOperationType\": \"ADD\"}, \"CAPABILITY_ID\": {\"objectId\": {\"value\": 1680391}, \"subOperationType\": \"ADD\"}, \"COSTS\": {\"objectId\": {\"value\": 1680392}, \"subOperationType\": \"ADD\"}, \"ENVIRONMENT_ID\": {\"objectId\": {\"value\": 1680390}, \"subOperationType\": \"ADD\"}, \"SUBSCRIPTION_UUID\": {\"objectId\": {\"value\": 1680386}, \"subOperationType\": \"ADD\"}, \"UPDATED_AT\": {\"objectId\": {\"value\": 1680389}, \"subOperationType\": \"ADD\"}, \"USAGE_DATE\": {\"objectId\": {\"value\": 1680387}, \"subOperationType\": \"ADD\"}}, \"creationMode\": {\"value\": \"CREATE\"}}", "snowflake.query.user": "STEFAN.SCHWEIGER"}, "EVENT_TIMESTAMPS": "{\n \"snowflake.query.start_time\": 1704191707101000000\n}"} diff --git a/test/test_data/data_volume.ndjson b/test/test_data/data_volume.ndjson new file mode 100644 index 00000000..73df9ea9 --- /dev/null +++ b/test/test_data/data_volume.ndjson @@ -0,0 +1,2 @@ +{"START_TIME": 1760681129584400000, "DIMENSIONS": "{\n \"db.collection.name\": \"DEV_DB.PUBLIC.SALESMANAGERREGIONS\",\n \"db.namespace\": \"DEV_DB\"\n}", "ATTRIBUTES": "{\n \"snowflake.table.type\": \"BASE TABLE\"\n}", "EVENT_TIMESTAMPS": "{\n \"snowflake.table.update\": 1736851468626000000\n}", "METRICS": "{\n \"snowflake.data.rows\": 6,\n \"snowflake.data.size\": 1024,\n \"snowflake.table.time_since.last_update\": 81983\n}"} +{"START_TIME": 1760681129603810000, "DIMENSIONS": "{\n \"db.collection.name\": \"DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE\",\n \"db.namespace\": \"DTAGENT_DB\"\n}", "ATTRIBUTES": "{\n \"snowflake.table.type\": \"BASE TABLE\"\n}", "EVENT_TIMESTAMPS": "{\n \"snowflake.table.ddl\": 1733122324468000000,\n \"snowflake.table.update\": 1741707972204000000\n}", "METRICS": "{\n \"snowflake.data.rows\": 0,\n \"snowflake.data.size\": 0,\n \"snowflake.table.time_since.last_ddl\": 144135,\n \"snowflake.table.time_since.last_update\": 1041\n}"} diff --git a/test/test_data/dynamic_table_graph_history.ndjson b/test/test_data/dynamic_table_graph_history.ndjson new file mode 100644 index 00000000..8aec51c5 --- /dev/null +++ b/test/test_data/dynamic_table_graph_history.ndjson @@ -0,0 +1,2 @@ +{"TIMESTAMP": 1760681129900236000, "NAME": "DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET", "DIMENSIONS": "{\n \"db.collection.name\": \"EMPLOYEE_DET\",\n \"db.namespace\": \"DYNAMIC_TABLE_DB\",\n \"snowflake.schema.name\": \"DYNAMIC_TABLE_SCH\",\n \"snowflake.table.full_name\": \"DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET\"\n}", "ATTRIBUTES": "{\n \"db.query.text\": \"SELECT A.EMP_ID,A.EMP_NAME,A.EMP_ADDRESS, B.SKILL_ID,B.SKILL_NAME,B.SKILL_LEVEL\\n FROM EMPLOYEE A, EMPLOYEE_SKILL B\\n WHERE A.EMP_ID=B.EMP_ID\\n ORDER BY B.SKILL_ID ;\",\n \"snowflake.table.dynamic.graph.alter_trigger\": [\n \"CREATE_DYNAMIC_TABLE\"\n ],\n \"snowflake.table.dynamic.graph.inputs\": [\n {\n \"kind\": \"TABLE\",\n \"name\": \"DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE\"\n },\n {\n \"kind\": \"TABLE\",\n \"name\": \"DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_SKILL\"\n }\n ],\n \"snowflake.table.dynamic.lag.target.type\": \"USER_DEFINED\",\n \"snowflake.table.dynamic.scheduling.state\": \"ACTIVE\"\n}", "METRICS": "{\n \"snowflake.table.dynamic.lag.target.value\": 60\n}", "EVENT_TIMESTAMPS": "{\n \"snowflake.table.dynamic.graph.valid_from\": 1732132427448000000\n}"} +{"TIMESTAMP": 1760681129923424000, "NAME": "DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET", "DIMENSIONS": "{\n \"db.collection.name\": \"EMPLOYEE_DET\",\n \"db.namespace\": \"DYNAMIC_TABLE_DB\",\n \"snowflake.schema.name\": \"DYNAMIC_TABLE_SCH\",\n \"snowflake.table.full_name\": \"DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET\"\n}", "ATTRIBUTES": "{\n \"db.query.text\": \"SELECT A.EMP_ID,A.EMP_NAME,A.EMP_ADDRESS, B.SKILL_ID,B.SKILL_NAME,B.SKILL_LEVEL\\n FROM EMPLOYEE A, EMPLOYEE_SKILL B\\n WHERE A.EMP_ID=B.EMP_ID\\n ORDER BY B.SKILL_ID ;\",\n \"snowflake.table.dynamic.graph.alter_trigger\": [\n \"CREATE_DYNAMIC_TABLE\"\n ],\n \"snowflake.table.dynamic.graph.inputs\": [\n {\n \"kind\": \"TABLE\",\n \"name\": \"DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE\"\n },\n {\n \"kind\": \"TABLE\",\n \"name\": \"DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_SKILL\"\n }\n ],\n \"snowflake.table.dynamic.lag.target.type\": \"USER_DEFINED\",\n \"snowflake.table.dynamic.scheduling.state\": \"ACTIVE\"\n}", "METRICS": "{\n \"snowflake.table.dynamic.lag.target.value\": 60\n}", "EVENT_TIMESTAMPS": "{\n \"snowflake.table.dynamic.graph.valid_from\": 1732132427448000000\n}"} diff --git a/test/test_data/dynamic_table_refresh_history.ndjson b/test/test_data/dynamic_table_refresh_history.ndjson new file mode 100644 index 00000000..9657b361 --- /dev/null +++ b/test/test_data/dynamic_table_refresh_history.ndjson @@ -0,0 +1,2 @@ +{"TIMESTAMP": 1760681129848366000, "START_TIME": 1760681129848366000, "END_TIME": 1760681130215366064, "NAME": "DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET", "DIMENSIONS": "{\n \"db.collection.name\": \"EMPLOYEE_DET\",\n \"db.namespace\": \"DYNAMIC_TABLE_DB\",\n \"snowflake.schema.name\": \"DYNAMIC_TABLE_SCH\",\n \"snowflake.table.full_name\": \"DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET\"\n}", "ATTRIBUTES": "{\n \"snowflake.query.id\": \"01baf403-0413-a61d-0040-e0030579d1e2\",\n \"snowflake.table.dynamic.graph.valid_from\": \"2024-11-20 19:53:47.448 Z\",\n \"snowflake.table.dynamic.refresh.action\": \"NO_DATA\",\n \"snowflake.table.dynamic.refresh.code\": \"SUCCESS\",\n \"snowflake.table.dynamic.refresh.completion_target\": \"2025-03-12 06:59:41.695 Z\",\n \"snowflake.table.dynamic.refresh.data_timestamp\": \"2025-03-12 06:59:29.695 Z\",\n \"snowflake.table.dynamic.refresh.end\": \"2025-03-12 06:59:31.035 Z\",\n \"snowflake.table.dynamic.refresh.start\": \"2025-03-12 06:59:30.668 Z\",\n \"snowflake.table.dynamic.refresh.state\": \"SUCCEEDED\",\n \"snowflake.table.dynamic.refresh.trigger\": \"SCHEDULED\"\n}", "METRICS": "{\n \"snowflake.partitions.added\": 0,\n \"snowflake.partitions.removed\": 0,\n \"snowflake.rows.copied\": 0,\n \"snowflake.rows.deleted\": 0,\n \"snowflake.rows.inserted\": 0\n}", "EVENT_TIMESTAMPS": "{}"} +{"TIMESTAMP": 1760681129874005000, "START_TIME": 1760681129874005000, "END_TIME": 1760681130284004872, "NAME": "DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET", "DIMENSIONS": "{\n \"db.collection.name\": \"EMPLOYEE_DET\",\n \"db.namespace\": \"DYNAMIC_TABLE_DB\",\n \"snowflake.schema.name\": \"DYNAMIC_TABLE_SCH\",\n \"snowflake.table.full_name\": \"DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET\"\n}", "ATTRIBUTES": "{\n \"snowflake.query.id\": \"01baf404-0413-a501-0040-e003057a220e\",\n \"snowflake.table.dynamic.graph.valid_from\": \"2024-11-20 19:53:47.448 Z\",\n \"snowflake.table.dynamic.refresh.action\": \"NO_DATA\",\n \"snowflake.table.dynamic.refresh.code\": \"SUCCESS\",\n \"snowflake.table.dynamic.refresh.completion_target\": \"2025-03-12 07:00:29.695 Z\",\n \"snowflake.table.dynamic.refresh.data_timestamp\": \"2025-03-12 07:00:17.695 Z\",\n \"snowflake.table.dynamic.refresh.end\": \"2025-03-12 07:00:19.468 Z\",\n \"snowflake.table.dynamic.refresh.start\": \"2025-03-12 07:00:19.058 Z\",\n \"snowflake.table.dynamic.refresh.state\": \"SUCCEEDED\",\n \"snowflake.table.dynamic.refresh.trigger\": \"SCHEDULED\"\n}", "METRICS": "{\n \"snowflake.partitions.added\": 0,\n \"snowflake.partitions.removed\": 0,\n \"snowflake.rows.copied\": 0,\n \"snowflake.rows.deleted\": 0,\n \"snowflake.rows.inserted\": 0\n}", "EVENT_TIMESTAMPS": "{}"} diff --git a/test/test_data/dynamic_tables.ndjson b/test/test_data/dynamic_tables.ndjson new file mode 100644 index 00000000..befb23cd --- /dev/null +++ b/test/test_data/dynamic_tables.ndjson @@ -0,0 +1,2 @@ +{"TIMESTAMP": 1760681129798674000, "NAME": "DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET", "DIMENSIONS": "{\n \"db.collection.name\": \"EMPLOYEE_DET\",\n \"db.namespace\": \"DYNAMIC_TABLE_DB\",\n \"snowflake.schema.name\": \"DYNAMIC_TABLE_SCH\",\n \"snowflake.table.full_name\": \"DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET\"\n}", "ATTRIBUTES": "{\n \"snowflake.table.dynamic.lag.target.type\": \"USER_DEFINED\",\n \"snowflake.table.dynamic.latest.code\": \"SUCCESS\",\n \"snowflake.table.dynamic.latest.data_timestamp\": \"2025-03-12 08:58:41.695 Z\",\n \"snowflake.table.dynamic.latest.state\": \"SUCCEEDED\",\n \"snowflake.table.dynamic.scheduling.state\": \"ACTIVE\"\n}", "METRICS": "{\n \"snowflake.table.dynamic.lag.max\": 68,\n \"snowflake.table.dynamic.lag.mean\": 25,\n \"snowflake.table.dynamic.lag.target.time_above\": 13,\n \"snowflake.table.dynamic.lag.target.value\": 60,\n \"snowflake.table.dynamic.lag.target.within_ratio\": 1\n}", "EVENT_TIMESTAMPS": "{}"} +{"TIMESTAMP": 1760681129822905000, "NAME": "DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET", "DIMENSIONS": "{\n \"db.collection.name\": \"EMPLOYEE_DET\",\n \"db.namespace\": \"DYNAMIC_TABLE_DB\",\n \"snowflake.schema.name\": \"DYNAMIC_TABLE_SCH\",\n \"snowflake.table.full_name\": \"DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET\"\n}", "ATTRIBUTES": "{\n \"snowflake.table.dynamic.lag.target.type\": \"USER_DEFINED\",\n \"snowflake.table.dynamic.latest.code\": \"SUCCESS\",\n \"snowflake.table.dynamic.latest.data_timestamp\": \"2025-03-12 08:58:41.695 Z\",\n \"snowflake.table.dynamic.latest.state\": \"SUCCEEDED\",\n \"snowflake.table.dynamic.scheduling.state\": \"ACTIVE\"\n}", "METRICS": "{\n \"snowflake.table.dynamic.lag.max\": 68,\n \"snowflake.table.dynamic.lag.mean\": 25,\n \"snowflake.table.dynamic.lag.target.time_above\": 13,\n \"snowflake.table.dynamic.lag.target.value\": 60,\n \"snowflake.table.dynamic.lag.target.within_ratio\": 1\n}", "EVENT_TIMESTAMPS": "{}"} diff --git a/test/test_data/event_log.ndjson b/test/test_data/event_log.ndjson new file mode 100644 index 00000000..6757486f --- /dev/null +++ b/test/test_data/event_log.ndjson @@ -0,0 +1,2 @@ +{"TIMESTAMP": 1760681130358911000, "_MESSAGE": "New Event Log entry from DTAGENT_DB", "RECORD_TYPE": "LOG", "_RECORD": "{\n \"severity_text\": \"WARN\"\n}", "_RECORD_ATTRIBUTES": "{\n \"code.filepath\": \"/usr/lib/python_udf/5dc6be55a3cd750f7a845533bacb523ed5bf419a303f987f5c6daae4105f654e/lib/python3.10/site-packages/opentelemetry/attributes/__init__.py\",\n \"code.function\": \"_clean_attribute\",\n \"code.lineno\": 101\n}", "_RESOURCE_ATTRIBUTES": "{\n \"db.user\": \"SYSTEM\",\n \"snow.database.id\": 621,\n \"snow.database.name\": \"DTAGENT_DB\",\n \"snow.executable.id\": 50838,\n \"snow.executable.name\": \"DTAGENT(SOURCES ARRAY):OBJECT\",\n \"snow.executable.runtime.version\": \"3.10\",\n \"snow.executable.type\": \"PROCEDURE\",\n \"snow.owner.id\": 566820,\n \"snow.owner.name\": \"DTAGENT_ADMIN\",\n \"snow.query.id\": \"01ba3baf-0412-e3aa-0051-0c031e2209d2\",\n \"snow.schema.id\": 6140,\n \"snow.schema.name\": \"APP\",\n \"snow.session.id\": 22812680207694358,\n \"snow.session.role.primary.id\": 566820,\n \"snow.session.role.primary.name\": \"DTAGENT_ADMIN\",\n \"snow.user.id\": 0,\n \"snow.warehouse.id\": 4637,\n \"snow.warehouse.name\": \"DTAGENT_WH\",\n \"telemetry.sdk.language\": \"python\"\n}", "OBSERVED_TIMESTAMP": 1738931596703169536, "_SCOPE": "{\n \"name\": \"opentelemetry.attributes\"\n}", "_CONTENT": "Invalid type dict for attribute 'snowflake.query.operator.stats' value. Expected one of ['bool', 'str', 'bytes', 'int', 'float'] or a sequence of those types", "_VALUE_OBJECT": null, "START_TIME": NaN, "TRACE_ID": null, "SPAN_ID": null, "_RESERVED": null} +{"TIMESTAMP": 1760681130382846000, "_MESSAGE": "New Event Log entry from DTAGENT_DB", "RECORD_TYPE": "LOG", "_RECORD": "{\n \"severity_text\": \"INFO\"\n}", "_RECORD_ATTRIBUTES": "{\n \"code.filepath\": \"_udf_code.py\",\n \"code.function\": \"send_log\",\n \"code.lineno\": 982\n}", "_RESOURCE_ATTRIBUTES": "{\n \"db.user\": \"SYSTEM\",\n \"snow.database.id\": 621,\n \"snow.database.name\": \"DTAGENT_DB\",\n \"snow.executable.id\": 50838,\n \"snow.executable.name\": \"DTAGENT(SOURCES ARRAY):OBJECT\",\n \"snow.executable.runtime.version\": \"3.10\",\n \"snow.executable.type\": \"PROCEDURE\",\n \"snow.owner.id\": 566820,\n \"snow.owner.name\": \"DTAGENT_ADMIN\",\n \"snow.query.id\": \"01ba3baf-0412-e3aa-0051-0c031e2209d2\",\n \"snow.schema.id\": 6140,\n \"snow.schema.name\": \"APP\",\n \"snow.session.id\": 22812680207694358,\n \"snow.session.role.primary.id\": 566820,\n \"snow.session.role.primary.name\": \"DTAGENT_ADMIN\",\n \"snow.user.id\": 0,\n \"snow.warehouse.id\": 4637,\n \"snow.warehouse.name\": \"DTAGENT_WH\",\n \"telemetry.sdk.language\": \"python\"\n}", "OBSERVED_TIMESTAMP": 1738931596703718912, "_SCOPE": "{\n \"name\": \"DTAGENT_OTLP\"\n}", "_CONTENT": "{'content': \"UPDATE state.datasources SET last_transform = '2025-02-07 12:26:07.0', last_extract = '2025-02-07 12:26:07.0', last_extract_id = 1738922400000 WHERE datasource = 'Spine.UnassignedConsumption'\", 'observed_timestamp': '1738931596695276978', 'timestamp': '1738931596695276978', 'end_time': 1738931597092276978, 'snowflake.credits.cloud_services': 4.7e-05, 'snowflake.data.scanned': 44032, 'snowflake.data.scanned_from_cache': 1.0, 'snowflake.data.written': 22016, 'snowflake.data.written_to_result': 29, 'snowflake.load.used': 100, 'snowflake.partitions.scanned': 1, 'snowflake.partitions.total': 1, 'snowflake.rows.updated': 1, 'snowflake.rows.written_to_result': 1, 'snowflake.time.compilation': 151, 'snowflake.time.execution': 246, 'snowflake.time.total_elapsed': 397, 'db.query.text': \"UPDATE state.datasources SET last_transform = '2025-02-07 12:26:07.0', last_extract = '2025-02-07 12:26:07.0', last_extract_id = 1738922400000 WHERE datasource = 'Spine.UnassignedConsumption'\", 'session.id': 22812680207694162, 'snowflake.cluster_number': 1, 'snowflake.database.id': 12, 'snowflake.query.hash': 'aa51eb519059545967e1ee3488f6b72d', 'snowflake.query.hash_version': 2, 'snowflake.query.id': '01ba3baa-0412-e34b-0051-0c031e22131e', 'snowflake.query.parametrized_hash': 'f54058eaf4569b014a656c4ad646646a', 'snowflake.query.parametrized_hash_version': 1, 'snowflake.query.tag': {'start_ts': 1738931166455, 'action': 'ingest', 'module': 'consumption', 'task': 'UnassignedConsumption', 'js_id': 8277366}, 'snowflake.query.transaction_id': 1738931171652000000, 'snowflake.release_version': '9.1.18', 'snowflake.role.type': 'ROLE', 'snowflake.warehouse.cluster.number': 1, 'snowflake.warehouse.id': 1249, 'snowflake.warehouse.size': 'X-Small', 'snowflake.warehouse.type': 'STANDARD', 'db.collection.name': 'SPRINT_DB.STATE.DATASOURCES', 'db.namespace': 'SPRINT_DB', 'db.operation.name': 'UPDATE', 'db.snowflake.dbs': ['SPRINT_DB'], 'db.snowflake.tables': ['SPRINT_DB.STATE.DATASOURCES'], 'db.user': 'SPRINT_PIPELINE', 'snowflake.query.execution_status': 'SUCCESS', 'snowflake.role.name': 'SPRINT_PIPELINE_ROLE', 'snowflake.warehouse.name': 'SPRINT_ETL_PIPELINE_WH', 'snowagent.run.context': 'query_history', 'snowagent.run.id': '5c0188ef23e84fb99fd31ffddd8d0dcd'}", "_VALUE_OBJECT": "{\n \"content\": \"UPDATE state.datasources SET last_transform = '2025-02-07 12:26:07.0', last_extract = '2025-02-07 12:26:07.0', last_extract_id = 1738922400000 WHERE datasource = 'Spine.UnassignedConsumption'\",\n \"db.collection.name\": \"SPRINT_DB.STATE.DATASOURCES\",\n \"db.namespace\": \"SPRINT_DB\",\n \"db.operation.name\": \"UPDATE\",\n \"db.query.text\": \"UPDATE state.datasources SET last_transform = '2025-02-07 12:26:07.0', last_extract = '2025-02-07 12:26:07.0', last_extract_id = 1738922400000 WHERE datasource = 'Spine.UnassignedConsumption'\",\n \"db.snowflake.dbs\": [\n \"SPRINT_DB\"\n ],\n \"db.snowflake.tables\": [\n \"SPRINT_DB.STATE.DATASOURCES\"\n ],\n \"db.user\": \"SPRINT_PIPELINE\",\n \"end_time\": 1738931597092276978,\n \"observed_timestamp\": \"1738931596695276978\",\n \"session.id\": 22812680207694162,\n \"snowagent.run.context\": \"query_history\",\n \"snowagent.run.id\": \"5c0188ef23e84fb99fd31ffddd8d0dcd\",\n \"snowflake.cluster_number\": 1,\n \"snowflake.credits.cloud_services\": 4.700000000000000e-05,\n \"snowflake.data.scanned\": 44032,\n \"snowflake.data.scanned_from_cache\": 1,\n \"snowflake.data.written\": 22016,\n \"snowflake.data.written_to_result\": 29,\n \"snowflake.database.id\": 12,\n \"snowflake.load.used\": 100,\n \"snowflake.partitions.scanned\": 1,\n \"snowflake.partitions.total\": 1,\n \"snowflake.query.execution_status\": \"SUCCESS\",\n \"snowflake.query.hash\": \"aa51eb519059545967e1ee3488f6b72d\",\n \"snowflake.query.hash_version\": 2,\n \"snowflake.query.id\": \"01ba3baa-0412-e34b-0051-0c031e22131e\",\n \"snowflake.query.parametrized_hash\": \"f54058eaf4569b014a656c4ad646646a\",\n \"snowflake.query.parametrized_hash_version\": 1,\n \"snowflake.query.tag\": {\n \"action\": \"ingest\",\n \"js_id\": 8277366,\n \"module\": \"consumption\",\n \"start_ts\": 1738931166455,\n \"task\": \"UnassignedConsumption\"\n },\n \"snowflake.query.transaction_id\": 1738931171652000000,\n \"snowflake.release_version\": \"9.1.18\",\n \"snowflake.role.name\": \"SPRINT_PIPELINE_ROLE\",\n \"snowflake.role.type\": \"ROLE\",\n \"snowflake.rows.updated\": 1,\n \"snowflake.rows.written_to_result\": 1,\n \"snowflake.time.compilation\": 151,\n \"snowflake.time.execution\": 246,\n \"snowflake.time.total_elapsed\": 397,\n \"snowflake.warehouse.cluster.number\": 1,\n \"snowflake.warehouse.id\": 1249,\n \"snowflake.warehouse.name\": \"SPRINT_ETL_PIPELINE_WH\",\n \"snowflake.warehouse.size\": \"X-Small\",\n \"snowflake.warehouse.type\": \"STANDARD\",\n \"timestamp\": \"1738931596695276978\"\n}", "START_TIME": NaN, "TRACE_ID": null, "SPAN_ID": null, "_RESERVED": null} diff --git a/test/test_data/event_log_metrics.ndjson b/test/test_data/event_log_metrics.ndjson new file mode 100644 index 00000000..808bdede --- /dev/null +++ b/test/test_data/event_log_metrics.ndjson @@ -0,0 +1,2 @@ +{"TIMESTAMP": 1760681130313840000, "DIMENSIONS": "{\n \"db.namespace\": \"DTAGENT_SKRUK_DB\",\n \"db.user\": \"SYSTEM\",\n \"snow.database.id\": 632,\n \"snow.database.name\": \"DTAGENT_SKRUK_DB\",\n \"snow.executable.id\": 51528,\n \"snow.executable.name\": \"DTAGENT(SOURCES ARRAY):OBJECT\",\n \"snow.executable.runtime.version\": \"3.11\",\n \"snow.executable.type\": \"PROCEDURE\",\n \"snow.owner.id\": 567463,\n \"snow.owner.name\": \"DTAGENT_SKRUK_ADMIN\",\n \"snow.query.id\": \"01ba3bba-0412-e356-0051-0c031e222a46\",\n \"snow.schema.id\": 6165,\n \"snow.schema.name\": \"APP\",\n \"snow.session.id\": 22812680207736954,\n \"snow.session.role.primary.id\": 567463,\n \"snow.session.role.primary.name\": \"DTAGENT_SKRUK_ADMIN\",\n \"snow.user.id\": 0,\n \"snow.warehouse.id\": 4649,\n \"snow.warehouse.name\": \"DTAGENT_SKRUK_WH\",\n \"snowflake.query.id\": \"01ba3bba-0412-e356-0051-0c031e222a46\",\n \"snowflake.role.name\": \"DTAGENT_SKRUK_ADMIN\",\n \"snowflake.schema.name\": \"APP\",\n \"snowflake.warehouse.name\": \"DTAGENT_SKRUK_WH\",\n \"telemetry.sdk.language\": \"python\"\n}", "METRICS": "{\n \"process.cpu.utilization\": {\n \"gauge\": 0\n },\n \"process.memory.usage\": {\n \"sum\": 0\n }\n}", "_INSTRUMENTS_DEF": "{\n \"process.cpu.utilization\": {\n \"displayName\": \"Snowflake metric: process.cpu.utilization\",\n \"unit\": \"1\"\n },\n \"process.memory.usage\": {\n \"displayName\": \"Snowflake metric: process.memory.usage\",\n \"unit\": \"bytes\"\n }\n}"} +{"TIMESTAMP": 1760681130336171000, "DIMENSIONS": "{\n \"db.namespace\": \"DTAGENT_SKRUK_DB\",\n \"db.user\": \"SYSTEM\",\n \"snow.database.id\": 632,\n \"snow.database.name\": \"DTAGENT_SKRUK_DB\",\n \"snow.executable.id\": 51528,\n \"snow.executable.name\": \"DTAGENT(SOURCES ARRAY):OBJECT\",\n \"snow.executable.runtime.version\": \"3.11\",\n \"snow.executable.type\": \"PROCEDURE\",\n \"snow.owner.id\": 567463,\n \"snow.owner.name\": \"DTAGENT_SKRUK_ADMIN\",\n \"snow.query.id\": \"01ba3bba-0412-e3aa-0051-0c031e22516a\",\n \"snow.schema.id\": 6165,\n \"snow.schema.name\": \"APP\",\n \"snow.session.id\": 22812680207694442,\n \"snow.session.role.primary.id\": 567463,\n \"snow.session.role.primary.name\": \"DTAGENT_SKRUK_ADMIN\",\n \"snow.user.id\": 0,\n \"snow.warehouse.id\": 4649,\n \"snow.warehouse.name\": \"DTAGENT_SKRUK_WH\",\n \"snowflake.query.id\": \"01ba3bba-0412-e3aa-0051-0c031e22516a\",\n \"snowflake.role.name\": \"DTAGENT_SKRUK_ADMIN\",\n \"snowflake.schema.name\": \"APP\",\n \"snowflake.warehouse.name\": \"DTAGENT_SKRUK_WH\",\n \"telemetry.sdk.language\": \"python\"\n}", "METRICS": "{\n \"process.cpu.utilization\": {\n \"gauge\": 0\n },\n \"process.memory.usage\": {\n \"sum\": 0\n }\n}", "_INSTRUMENTS_DEF": "{\n \"process.cpu.utilization\": {\n \"displayName\": \"Snowflake metric: process.cpu.utilization\",\n \"unit\": \"1\"\n },\n \"process.memory.usage\": {\n \"displayName\": \"Snowflake metric: process.memory.usage\",\n \"unit\": \"bytes\"\n }\n}"} diff --git a/test/test_data/event_log_spans.ndjson b/test/test_data/event_log_spans.ndjson new file mode 100644 index 00000000..dbfbb433 --- /dev/null +++ b/test/test_data/event_log_spans.ndjson @@ -0,0 +1,2 @@ +{"QUERY_ID": "01ba3bc5-0412-e34b-0051-0c031e22184a", "SESSION_ID": "22812680207733670", "NAME": "LOG_PROCESSED_MEASUREMENTS(MEASUREMENTS_SOURCE VARCHAR, LAST_TIMESTAMP VARCHAR, LAST_ID VARCHAR, ENTRIES_COUNT VARCHAR):VARCHAR(16777216)", "START_TIME": 1760681130311440000, "END_TIME": 1760681130867380918, "STATUS_CODE": "OK", "TIMESTAMP": 1760681130311440000, "_SPAN_ID": "1fc735d0031735ea", "_TRACE_ID": "01ba3bc525c20677b026cf555d0c5a82", "_PARENT_SPAN_ID": null, "_SPAN_KIND": "SPAN_KIND_INTERNAL", "_RECORD": "{\n \"kind\": \"SPAN_KIND_INTERNAL\",\n \"name\": \"snow.auto_instrumented\",\n \"status\": {\n \"code\": \"STATUS_CODE_UNSET\"\n }\n}", "DIMENSIONS": "{\n \"db.namespace\": \"DTAGENT_SKRUK_DB\",\n \"db.user\": \"SEBASTIAN.KRUK\",\n \"snow.database.id\": 632,\n \"snow.database.name\": \"DTAGENT_SKRUK_DB\",\n \"snow.executable.id\": 51719,\n \"snow.executable.name\": \"LOG_PROCESSED_MEASUREMENTS(MEASUREMENTS_SOURCE VARCHAR, LAST_TIMESTAMP VARCHAR, LAST_ID VARCHAR, ENTRIES_COUNT VARCHAR):VARCHAR(16777216)\",\n \"snow.executable.type\": \"PROCEDURE\",\n \"snow.owner.id\": 567463,\n \"snow.owner.name\": \"DTAGENT_SKRUK_ADMIN\",\n \"snow.query.id\": \"01ba3bc5-0412-e34b-0051-0c031e22184a\",\n \"snow.schema.id\": 6167,\n \"snow.schema.name\": \"STATUS\",\n \"snow.session.id\": 22812680207733670,\n \"snow.session.role.primary.id\": 567483,\n \"snow.session.role.primary.name\": \"DTAGENT_SKRUK_VIEWER\",\n \"snow.user.id\": 361,\n \"snow.warehouse.id\": 4649,\n \"snow.warehouse.name\": \"DTAGENT_SKRUK_WH\",\n \"snowflake.query.id\": \"01ba3bc5-0412-e34b-0051-0c031e22184a\",\n \"snowflake.role.name\": \"DTAGENT_SKRUK_VIEWER\",\n \"snowflake.schema.name\": \"STATUS\",\n \"snowflake.warehouse.name\": \"DTAGENT_SKRUK_WH\",\n \"telemetry.sdk.language\": \"sql\"\n}"} +{"QUERY_ID": "01ba3bcc-0412-e352-0051-0c031e22c1a6", "SESSION_ID": "22812680207726014", "NAME": "LOG_PROCESSED_MEASUREMENTS(MEASUREMENTS_SOURCE VARCHAR, LAST_TIMESTAMP VARCHAR, LAST_ID VARCHAR, ENTRIES_COUNT VARCHAR):VARCHAR(16777216)", "START_TIME": 1760681130312327000, "END_TIME": 1760681130947252537, "STATUS_CODE": "OK", "TIMESTAMP": 1760681130312327000, "_SPAN_ID": "0235c0abc1e8a9ce", "_TRACE_ID": "01ba3bcc4289735fc8d0fe322b035cd1", "_PARENT_SPAN_ID": null, "_SPAN_KIND": "SPAN_KIND_INTERNAL", "_RECORD": "{\n \"kind\": \"SPAN_KIND_INTERNAL\",\n \"name\": \"snow.auto_instrumented\",\n \"status\": {\n \"code\": \"STATUS_CODE_UNSET\"\n }\n}", "DIMENSIONS": "{\n \"db.namespace\": \"DTAGENT_SKRUK_DB\",\n \"db.user\": \"SYSTEM\",\n \"snow.database.id\": 632,\n \"snow.database.name\": \"DTAGENT_SKRUK_DB\",\n \"snow.executable.id\": 51719,\n \"snow.executable.name\": \"LOG_PROCESSED_MEASUREMENTS(MEASUREMENTS_SOURCE VARCHAR, LAST_TIMESTAMP VARCHAR, LAST_ID VARCHAR, ENTRIES_COUNT VARCHAR):VARCHAR(16777216)\",\n \"snow.executable.type\": \"PROCEDURE\",\n \"snow.owner.id\": 567463,\n \"snow.owner.name\": \"DTAGENT_SKRUK_ADMIN\",\n \"snow.query.id\": \"01ba3bcc-0412-e352-0051-0c031e22c1a6\",\n \"snow.schema.id\": 6167,\n \"snow.schema.name\": \"STATUS\",\n \"snow.session.id\": 22812680207726014,\n \"snow.session.role.primary.id\": 567463,\n \"snow.session.role.primary.name\": \"DTAGENT_SKRUK_ADMIN\",\n \"snow.user.id\": 0,\n \"snow.warehouse.id\": 4649,\n \"snow.warehouse.name\": \"DTAGENT_SKRUK_WH\",\n \"snowflake.query.id\": \"01ba3bcc-0412-e352-0051-0c031e22c1a6\",\n \"snowflake.role.name\": \"DTAGENT_SKRUK_ADMIN\",\n \"snowflake.schema.name\": \"STATUS\",\n \"snowflake.warehouse.name\": \"DTAGENT_SKRUK_WH\",\n \"telemetry.sdk.language\": \"sql\"\n}"} diff --git a/test/test_data/event_usage.ndjson b/test/test_data/event_usage.ndjson new file mode 100644 index 00000000..8be5bfb5 --- /dev/null +++ b/test/test_data/event_usage.ndjson @@ -0,0 +1,2 @@ +{"START_TIME": 1760681130776361000, "END_TIME": 1760681190776361000, "DIMENSIONS": "{}", "METRICS": "{\n \"snowflake.credits.used\": 0.001007024,\n \"snowflake.data.ingested\": 736\n}"} +{"START_TIME": 1760681130800238000, "END_TIME": 1760681190800238000, "DIMENSIONS": "{}", "METRICS": "{\n \"snowflake.credits.used\": 0.000215595,\n \"snowflake.data.ingested\": 0\n}"} diff --git a/test/test_data/inbound_shares.ndjson b/test/test_data/inbound_shares.ndjson new file mode 100644 index 00000000..7258a616 --- /dev/null +++ b/test/test_data/inbound_shares.ndjson @@ -0,0 +1,2 @@ +{"_MESSAGE": "Inbound share details for BIET_MONITORING_SHARE", "DIMENSIONS": "{\n \"db.namespace\": \"CI360_SHARE_MONITORING_DB\",\n \"snowflake.share.name\": \"BIET_MONITORING_SHARE\"\n}", "ATTRIBUTES": "{\n \"snowflake.share.has_details_reported\": true,\n \"snowflake.share.is_secure_objects_only\": \"\",\n \"snowflake.share.kind\": \"INBOUND\",\n \"snowflake.share.listing_global_name\": \"\",\n \"snowflake.share.owner\": \"\",\n \"snowflake.share.shared_from\": \"WMBJBCQ.CI360TESTACCOUNT\",\n \"snowflake.share.shared_to\": \"\"\n}", "EVENT_TIMESTAMPS": "{}"} +{"_MESSAGE": "Inbound share details for BIET_MONITORING_SHARE", "DIMENSIONS": "{\n \"db.namespace\": \"DT_SHARE_MONITORING_DB\",\n \"snowflake.share.name\": \"BIET_MONITORING_SHARE\"\n}", "ATTRIBUTES": "{\n \"snowflake.share.has_details_reported\": true,\n \"snowflake.share.is_secure_objects_only\": \"\",\n \"snowflake.share.kind\": \"INBOUND\",\n \"snowflake.share.listing_global_name\": \"\",\n \"snowflake.share.owner\": \"\",\n \"snowflake.share.shared_from\": \"WMBJBCQ.DYNATRACEDIGITALBUSINESSDW\",\n \"snowflake.share.shared_to\": \"\"\n}", "EVENT_TIMESTAMPS": "{}"} diff --git a/test/test_data/login_history.ndjson b/test/test_data/login_history.ndjson new file mode 100644 index 00000000..e1281c80 --- /dev/null +++ b/test/test_data/login_history.ndjson @@ -0,0 +1,2 @@ +{"TIMESTAMP": 1760681131197570000, "_message": "LOGIN: SEBASTIAN.KRUK", "DIMENSIONS": "{\n \"client.ip\": \"82.177.196.146\",\n \"client.type\": \"OTHER\",\n \"db.user\": \"SEBASTIAN.KRUK\",\n \"event.name\": \"LOGIN\"\n}", "ATTRIBUTES": "{\n \"authentiacation.factor.first\": \"SAML2_ASSERTION\",\n \"client.version\": \"1.22.1\",\n \"event.id\": 18260702004593906,\n \"event.related_id\": 0,\n \"status.code\": \"OK\"\n}"} +{"TIMESTAMP": 1760681131222874000, "_message": "LOGIN: SNOWAGENT_ADMIN", "DIMENSIONS": "{\n \"client.ip\": \"52.29.224.53\",\n \"client.type\": \"OTHER\",\n \"db.user\": \"SNOWAGENT_ADMIN\",\n \"event.name\": \"LOGIN\"\n}", "ATTRIBUTES": "{\n \"authentiacation.factor.first\": \"PASSWORD\",\n \"client.version\": \"1.21.0\",\n \"event.id\": 18260702004595858,\n \"event.related_id\": 0,\n \"status.code\": \"OK\"\n}"} diff --git a/test/test_data/outbound_shares.ndjson b/test/test_data/outbound_shares.ndjson new file mode 100644 index 00000000..d31e0f35 --- /dev/null +++ b/test/test_data/outbound_shares.ndjson @@ -0,0 +1,2 @@ +{"_MESSAGE": "Outbound share details for DATA_SCIENTIST_DEVEL_DS_CI360_SHARE", "DIMENSIONS": "{\n \"db.namespace\": \"DATA_SCIENTIST_DEV_DB\",\n \"snowflake.grant.name\": \"DATA_SCIENTIST_DEV_DB\",\n \"snowflake.share.name\": \"DATA_SCIENTIST_DEVEL_DS_CI360_SHARE\"\n}", "ATTRIBUTES": "{\n \"snowflake.grant.by\": \"DEMIGOD\",\n \"snowflake.grant.grantee\": \"DEVDYNATRACEDIGITALBUSINESSDW.DATA_SCIENTIST_DEVEL_DS_CI360_SHARE\",\n \"snowflake.grant.on\": \"DATABASE\",\n \"snowflake.grant.option\": \"false\",\n \"snowflake.grant.privilege\": \"USAGE\",\n \"snowflake.grant.to\": \"SHARE\",\n \"snowflake.share.is_secure_objects_only\": \"true\",\n \"snowflake.share.kind\": \"OUTBOUND\",\n \"snowflake.share.listing_global_name\": \"\",\n \"snowflake.share.owner\": \"DEMIGOD\",\n \"snowflake.share.shared_from\": \"WMBJBCQ.DEVDYNATRACEDIGITALBUSINESSDW\",\n \"snowflake.share.shared_to\": \"WMBJBCQ.CI360TESTACCOUNT\"\n}", "EVENT_TIMESTAMPS": "{\n \"snowflake.grant.created_on\": 1687246726499000000\n}"} +{"_MESSAGE": "Outbound share details for DATA_SCIENTIST_DEVEL_DS_CI360_SHARE", "DIMENSIONS": "{\n \"db.namespace\": \"DATA_SCIENTIST_DEV_DB\",\n \"snowflake.grant.name\": \"DATA_SCIENTIST_DEV_DB.ACCOUNT_EXPERIENCE\",\n \"snowflake.share.name\": \"DATA_SCIENTIST_DEVEL_DS_CI360_SHARE\"\n}", "ATTRIBUTES": "{\n \"snowflake.grant.by\": \"INTEGRATION_CONSUMPTION_FORECASTING_ROLE\",\n \"snowflake.grant.grantee\": \"DEVDYNATRACEDIGITALBUSINESSDW.DATA_SCIENTIST_DEVEL_DS_CI360_SHARE\",\n \"snowflake.grant.on\": \"SCHEMA\",\n \"snowflake.grant.option\": \"false\",\n \"snowflake.grant.privilege\": \"USAGE\",\n \"snowflake.grant.to\": \"SHARE\",\n \"snowflake.share.is_secure_objects_only\": \"true\",\n \"snowflake.share.kind\": \"OUTBOUND\",\n \"snowflake.share.listing_global_name\": \"\",\n \"snowflake.share.owner\": \"DEMIGOD\",\n \"snowflake.share.shared_from\": \"WMBJBCQ.DEVDYNATRACEDIGITALBUSINESSDW\",\n \"snowflake.share.shared_to\": \"WMBJBCQ.CI360TESTACCOUNT\"\n}", "EVENT_TIMESTAMPS": "{\n \"snowflake.grant.created_on\": 1668416468928000000\n}"} diff --git a/test/test_data/recent_queries2.ndjson b/test/test_data/recent_queries2.ndjson new file mode 100644 index 00000000..9d5aebaf --- /dev/null +++ b/test/test_data/recent_queries2.ndjson @@ -0,0 +1,3 @@ +{"QUERY_ID": "01bcb05d-0415-b618-0047-e383330c174a", "QUERY_OPERATOR_STATS": null, "PARENT_QUERY_ID": "01bcb05d-0415-b618-0047-e383330c172e", "SESSION_ID": 20234875336090534, "NAME": "select DTAGENT_DB", "START_TIME": 1760681131568692000, "END_TIME": 1760681133488692000, "_SPAN_ID": null, "_TRACE_ID": null, "STATUS_CODE": "OK", "DIMENSIONS": "{\n \"db.collection.name\": \"DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG\",\n \"db.namespace\": \"DTAGENT_DB\",\n \"db.operation.name\": \"SELECT\",\n \"db.snowflake.dbs\": [\n \"DTAGENT_DB\"\n ],\n \"db.user\": \"SYSTEM\",\n \"snowflake.query.execution_status\": \"SUCCESS\",\n \"snowflake.role.name\": \"DTAGENT_ADMIN\",\n \"snowflake.warehouse.name\": \"DTAGENT_WH\"\n}", "ATTRIBUTES": "{\n \"db.query.text\": \"with cte_all_queries as (\\n (\\n select * from TABLE(result_scan(:QID_0))\\n )\\n union all\\n (\\n select * from TABLE(result_scan(:QID_1))\\n where END_TIME > DTAGENT_DB.APP.F_LAST_PROCESSED_TS('active_queries')\\n )\\n )\\n , cte_active_queries as (\\n select \\n START_TIME,\\n END_TIME,\\n\\n QUERY_ID,\\n SESSION_ID,\\n DATABASE_NAME,\\n SCHEMA_NAME,\\n\\n QUERY_TEXT,\\n QUERY_TYPE,\\n QUERY_TAG,\\n QUERY_HASH,\\n QUERY_HASH_VERSION,\\n QUERY_PARAMETERIZED_HASH,\\n QUERY_PARAMETERIZED_HASH_VERSION,\\n\\n USER_NAME,\\n ROLE_NAME,\\n\\n WAREHOUSE_NAME,\\n WAREHOUSE_TYPE,\\n\\n EXECUTION_STATUS,\\n ERROR_CODE,\\n ERROR_MESSAGE,\\n\\n // metrics\\n RUNNING_TIME,\\n EXECUTION_TIME,\\n COMPILATION_TIME,\\n TOTAL_ELAPSED_TIME,\\n BYTES_WRITTEN_TO_RESULT,\\n ROWS_WRITTEN_TO_RESULT,\\n from cte_all_queries aq\\n where\\n ( array_size(DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])) = 0\\n or array_contains(EXECUTION_STATUS::variant, DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])::array) )\\n )\\n select \\n qh.END_TIME::timestamp_ltz as TIMESTAMP,\\n\\n qh.query_id as QUERY_ID,\\n qh.session_id as SESSION_ID,\\n\\n CONCAT(\\n 'SQL query ',\\n qh.execution_status,\\n ' at ',\\n COALESCE(qh.database_name, '')\\n ) as NAME,\\n NAME as _MESSAGE,\\n\\n \\n extract(epoch_nanosecond from qh.start_time) as START_TIME,\\n extract(epoch_nanosecond from qh.end_time) as END_TIME,\\n\\n \\n OBJECT_CONSTRUCT(\\n 'db.namespace', qh.database_name,\\n 'snowflake.warehouse.name', qh.warehouse_name,\\n 'db.user', qh.user_name,\\n 'snowflake.role.name', qh.role_name,\\n 'snowflake.query.execution_status', qh.execution_status\\n ) as DIMENSIONS,\\n \\n OBJECT_CONSTRUCT(\\n 'db.query.text', qh.query_text,\\n 'db.operation.name', qh.query_type,\\n 'session.id', qh.session_id,\\n 'snowflake.query.id', qh.query_id,\\n 'snowflake.query.tag', qh.query_tag,\\n 'snowflake.query.hash', qh.query_hash,\\n 'snowflake.query.hash_version', qh.query_hash_version,\\n 'snowflake.query.parametrized_hash', qh.query_parameterized_hash,\\n 'snowflake.query.parametrized_hash_version', qh.query_parameterized_hash_version,\\n 'snowflake.error.code', qh.error_code,\\n 'snowflake.error.message', qh.error_message,\\n 'snowflake.warehouse.type', qh.warehouse_type,\\n 'snowflake.schema.name', qh.schema_name\\n ) as ATTRIBUTES,\\n \\n OBJECT_CONSTRUCT(\\n 'snowflake.time.running', qh.running_time,\\n 'snowflake.time.execution', qh.execution_time,\\n 'snowflake.time.compilation', qh.compilation_time,\\n 'snowflake.time.total_elapsed', qh.total_elapsed_time,\\n 'snowflake.data.written_to_result', qh.bytes_written_to_result,\\n 'snowflake.rows.written_to_result', qh.rows_written_to_result\\n ) as METRICS\\n from \\n cte_active_queries qh\\n order by \\n TIMESTAMP asc\",\n \"db.snowflake.tables\": [\n \"DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG\",\n \"DTAGENT_DB.CONFIG.CONFIGURATIONS\"\n ],\n \"db.snowflake.views\": [],\n \"session.id\": 20234875336090534,\n \"snowflake.cluster_number\": 1,\n \"snowflake.database.id\": 1868,\n \"snowflake.query.hash\": \"dbf5cf366b64603513aa8097d5d3174c\",\n \"snowflake.query.hash_version\": 2,\n \"snowflake.query.id\": \"01bcb05d-0415-b618-0047-e383330c174a\",\n \"snowflake.query.is_client_generated\": false,\n \"snowflake.query.parametrized_hash\": \"dbf5cf366b64603513aa8097d5d3174c\",\n \"snowflake.query.parametrized_hash_version\": 1,\n \"snowflake.query.parent_id\": \"01bcb05d-0415-b618-0047-e383330c172e\",\n \"snowflake.query.tag\": \"dt_snowagent.version:0.8.1.plugin:ActiveQueriesPlugin.2025-05-30T04:53:15.857Z\",\n \"snowflake.query.transaction_id\": 0,\n \"snowflake.release_version\": \"9.14.2\",\n \"snowflake.role.type\": \"ROLE\",\n \"snowflake.schema.id\": 40234,\n \"snowflake.schema.name\": \"APP\",\n \"snowflake.warehouse.cluster.number\": 1,\n \"snowflake.warehouse.id\": 3726,\n \"snowflake.warehouse.size\": \"X-Small\",\n \"snowflake.warehouse.type\": \"STANDARD\"\n}", "METRICS": "{\n \"snowflake.acceleration.data.scanned\": 0,\n \"snowflake.acceleration.partitions.scanned\": 0,\n \"snowflake.acceleration.scale_factor.max\": 0,\n \"snowflake.credits.cloud_services\": 9.200000000000000e-05,\n \"snowflake.data.deleted\": 0,\n \"snowflake.data.read.from_result\": 0,\n \"snowflake.data.scanned\": 5640704,\n \"snowflake.data.scanned_from_cache\": 0.000000000000000e+00,\n \"snowflake.data.sent_over_the_network\": 0,\n \"snowflake.data.spilled.local\": 0,\n \"snowflake.data.spilled.remote\": 0,\n \"snowflake.data.transferred.inbound\": 0,\n \"snowflake.data.transferred.outbound\": 0,\n \"snowflake.data.written\": 0,\n \"snowflake.data.written_to_result\": 117512,\n \"snowflake.external_functions.data.received\": 0,\n \"snowflake.external_functions.data.sent\": 0,\n \"snowflake.external_functions.invocations\": 0,\n \"snowflake.external_functions.rows.received\": 0,\n \"snowflake.external_functions.rows.sent\": 0,\n \"snowflake.load.used\": 100,\n \"snowflake.partitions.scanned\": 47,\n \"snowflake.partitions.total\": 43,\n \"snowflake.rows.deleted\": 0,\n \"snowflake.rows.inserted\": 0,\n \"snowflake.rows.unloaded\": 0,\n \"snowflake.rows.updated\": 0,\n \"snowflake.rows.written_to_result\": 798,\n \"snowflake.time.child_queries_wait\": 0,\n \"snowflake.time.compilation\": 520,\n \"snowflake.time.execution\": 1381,\n \"snowflake.time.list_external_files\": 19,\n \"snowflake.time.queued.overload\": 0,\n \"snowflake.time.queued.provisioning\": 0,\n \"snowflake.time.repair\": 0,\n \"snowflake.time.total_elapsed\": 1920,\n \"snowflake.time.transaction_blocked\": 0\n}", "IS_PARENT": false, "IS_ROOT": false} +{"QUERY_ID": "01bcb05d-0415-b618-0047-e383330c172e", "QUERY_OPERATOR_STATS": null, "PARENT_QUERY_ID": "01bcb05d-0415-b618-0047-e383330c172a", "SESSION_ID": 20234875336090534, "NAME": "call DTAGENT_DB", "START_TIME": 1760681131568872000, "END_TIME": 1760681138304872000, "_SPAN_ID": "4328cfa95b61ec83", "_TRACE_ID": "01bcb05d68938b78428142dea30a6160", "STATUS_CODE": "OK", "DIMENSIONS": "{\n \"db.collection.name\": \"DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG\",\n \"db.namespace\": \"DTAGENT_DB\",\n \"db.operation.name\": \"CALL\",\n \"db.snowflake.dbs\": [\n \"DTAGENT_DB\"\n ],\n \"db.user\": \"SYSTEM\",\n \"snowflake.query.execution_status\": \"SUCCESS\",\n \"snowflake.role.name\": \"DTAGENT_ADMIN\",\n \"snowflake.warehouse.name\": \"DTAGENT_WH\"\n}", "ATTRIBUTES": "{\n \"db.query.text\": \"with cte_all_queries as (\\n (\\n select * from TABLE(DTAGENT_DB.APP.F_GET_RUNNING_QUERIES())\\n )\\n union all\\n (\\n select * from TABLE(DTAGENT_DB.APP.F_GET_FINISHED_QUERIES())\\n where END_TIME > DTAGENT_DB.APP.F_LAST_PROCESSED_TS('active_queries')\\n )\\n )\\n , cte_active_queries as (\\n select \\n START_TIME,\\n END_TIME,\\n\\n QUERY_ID,\\n SESSION_ID,\\n DATABASE_NAME,\\n SCHEMA_NAME,\\n\\n QUERY_TEXT,\\n QUERY_TYPE,\\n QUERY_TAG,\\n QUERY_HASH,\\n QUERY_HASH_VERSION,\\n QUERY_PARAMETERIZED_HASH,\\n QUERY_PARAMETERIZED_HASH_VERSION,\\n\\n USER_NAME,\\n ROLE_NAME,\\n\\n WAREHOUSE_NAME,\\n WAREHOUSE_TYPE,\\n\\n EXECUTION_STATUS,\\n ERROR_CODE,\\n ERROR_MESSAGE,\\n\\n // metrics\\n RUNNING_TIME,\\n EXECUTION_TIME,\\n COMPILATION_TIME,\\n TOTAL_ELAPSED_TIME,\\n BYTES_WRITTEN_TO_RESULT,\\n ROWS_WRITTEN_TO_RESULT,\\n from cte_all_queries aq\\n where\\n ( array_size(DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])) = 0\\n or array_contains(EXECUTION_STATUS::variant, DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])::array) )\\n )\\n select \\n qh.END_TIME::timestamp_ltz as TIMESTAMP,\\n\\n qh.query_id as QUERY_ID,\\n qh.session_id as SESSION_ID,\\n\\n CONCAT(\\n 'SQL query ',\\n qh.execution_status,\\n ' at ',\\n COALESCE(qh.database_name, '')\\n ) as NAME,\\n NAME as _MESSAGE,\\n\\n \\n extract(epoch_nanosecond from qh.start_time) as START_TIME,\\n extract(epoch_nanosecond from qh.end_time) as END_TIME,\\n\\n \\n OBJECT_CONSTRUCT(\\n 'db.namespace', qh.database_name,\\n 'snowflake.warehouse.name', qh.warehouse_name,\\n 'db.user', qh.user_name,\\n 'snowflake.role.name', qh.role_name,\\n 'snowflake.query.execution_status', qh.execution_status\\n ) as DIMENSIONS,\\n \\n OBJECT_CONSTRUCT(\\n 'db.query.text', qh.query_text,\\n 'db.operation.name', qh.query_type,\\n 'session.id', qh.session_id,\\n 'snowflake.query.id', qh.query_id,\\n 'snowflake.query.tag', qh.query_tag,\\n 'snowflake.query.hash', qh.query_hash,\\n 'snowflake.query.hash_version', qh.query_hash_version,\\n 'snowflake.query.parametrized_hash', qh.query_parameterized_hash,\\n 'snowflake.query.parametrized_hash_version', qh.query_parameterized_hash_version,\\n 'snowflake.error.code', qh.error_code,\\n 'snowflake.error.message', qh.error_message,\\n 'snowflake.warehouse.type', qh.warehouse_type,\\n 'snowflake.schema.name', qh.schema_name\\n ) as ATTRIBUTES,\\n \\n OBJECT_CONSTRUCT(\\n 'snowflake.time.running', qh.running_time,\\n 'snowflake.time.execution', qh.execution_time,\\n 'snowflake.time.compilation', qh.compilation_time,\\n 'snowflake.time.total_elapsed', qh.total_elapsed_time,\\n 'snowflake.data.written_to_result', qh.bytes_written_to_result,\\n 'snowflake.rows.written_to_result', qh.rows_written_to_result\\n ) as METRICS\\n from \\n cte_active_queries qh\\n order by \\n TIMESTAMP asc\",\n \"db.snowflake.tables\": [\n \"DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG\",\n \"DTAGENT_DB.CONFIG.CONFIGURATIONS\"\n ],\n \"db.snowflake.views\": [],\n \"session.id\": 20234875336090534,\n \"snowflake.cluster_number\": 1,\n \"snowflake.database.id\": 1868,\n \"snowflake.query.hash\": \"0d8c82d99d518393458b4a68bc8c2930\",\n \"snowflake.query.hash_version\": 2,\n \"snowflake.query.id\": \"01bcb05d-0415-b618-0047-e383330c172e\",\n \"snowflake.query.is_client_generated\": false,\n \"snowflake.query.parametrized_hash\": \"0d8c82d99d518393458b4a68bc8c2930\",\n \"snowflake.query.parametrized_hash_version\": 1,\n \"snowflake.query.parent_id\": \"01bcb05d-0415-b618-0047-e383330c172a\",\n \"snowflake.query.tag\": \"dt_snowagent.version:0.8.1.plugin:ActiveQueriesPlugin.2025-05-30T04:53:15.857Z\",\n \"snowflake.query.transaction_id\": 0,\n \"snowflake.release_version\": \"9.14.2\",\n \"snowflake.role.type\": \"ROLE\",\n \"snowflake.schema.id\": 40234,\n \"snowflake.schema.name\": \"APP\",\n \"snowflake.warehouse.cluster.number\": 1,\n \"snowflake.warehouse.id\": 3726,\n \"snowflake.warehouse.size\": \"X-Small\",\n \"snowflake.warehouse.type\": \"STANDARD\"\n}", "METRICS": "{\n \"snowflake.acceleration.data.scanned\": 0,\n \"snowflake.acceleration.partitions.scanned\": 0,\n \"snowflake.acceleration.scale_factor.max\": 0,\n \"snowflake.credits.cloud_services\": 2.700000000000000e-05,\n \"snowflake.data.deleted\": 0,\n \"snowflake.data.read.from_result\": 0,\n \"snowflake.data.scanned\": 0,\n \"snowflake.data.scanned_from_cache\": 0.000000000000000e+00,\n \"snowflake.data.sent_over_the_network\": 0,\n \"snowflake.data.spilled.local\": 0,\n \"snowflake.data.spilled.remote\": 0,\n \"snowflake.data.transferred.inbound\": 0,\n \"snowflake.data.transferred.outbound\": 0,\n \"snowflake.data.written\": 0,\n \"snowflake.data.written_to_result\": 640,\n \"snowflake.external_functions.data.received\": 0,\n \"snowflake.external_functions.data.sent\": 0,\n \"snowflake.external_functions.invocations\": 0,\n \"snowflake.external_functions.rows.received\": 0,\n \"snowflake.external_functions.rows.sent\": 0,\n \"snowflake.load.used\": 100,\n \"snowflake.partitions.scanned\": 0,\n \"snowflake.partitions.total\": 0,\n \"snowflake.rows.deleted\": 0,\n \"snowflake.rows.inserted\": 0,\n \"snowflake.rows.unloaded\": 0,\n \"snowflake.rows.updated\": 0,\n \"snowflake.rows.written_to_result\": 798,\n \"snowflake.time.child_queries_wait\": 0,\n \"snowflake.time.compilation\": 158,\n \"snowflake.time.execution\": 6578,\n \"snowflake.time.list_external_files\": 0,\n \"snowflake.time.queued.overload\": 0,\n \"snowflake.time.queued.provisioning\": 0,\n \"snowflake.time.repair\": 0,\n \"snowflake.time.total_elapsed\": 6736,\n \"snowflake.time.transaction_blocked\": 0\n}", "IS_PARENT": true, "IS_ROOT": false} +{"QUERY_ID": "01bcb05d-0415-b618-0047-e383330c172a", "QUERY_OPERATOR_STATS": null, "PARENT_QUERY_ID": null, "SESSION_ID": 20234875336090534, "NAME": "call DTAGENT_DB", "START_TIME": 1760681131569144000, "END_TIME": 1760681138581144000, "_SPAN_ID": "4a57ce274789b2ec", "_TRACE_ID": "01bcb05d68938b78428142dea30a6160", "STATUS_CODE": "OK", "DIMENSIONS": "{\n \"db.namespace\": \"DTAGENT_DB\",\n \"db.operation.name\": \"CALL\",\n \"db.user\": \"SYSTEM\",\n \"snowflake.query.execution_status\": \"SUCCESS\",\n \"snowflake.role.name\": \"DTAGENT_ADMIN\",\n \"snowflake.warehouse.name\": \"DTAGENT_WH\"\n}", "ATTRIBUTES": "{\n \"db.query.text\": \"CALL DTAGENT_DB.APP.F_ACTIVE_QUERIES_INSTRUMENTED();\\n\",\n \"session.id\": 20234875336090534,\n \"snowflake.cluster_number\": 1,\n \"snowflake.database.id\": 1868,\n \"snowflake.query.hash\": \"e86eb140052655351696b76a32722b70\",\n \"snowflake.query.hash_version\": 2,\n \"snowflake.query.id\": \"01bcb05d-0415-b618-0047-e383330c172a\",\n \"snowflake.query.is_client_generated\": false,\n \"snowflake.query.parametrized_hash\": \"e86eb140052655351696b76a32722b70\",\n \"snowflake.query.parametrized_hash_version\": 1,\n \"snowflake.query.tag\": \"dt_snowagent.version:0.8.1.plugin:ActiveQueriesPlugin.2025-05-30T04:53:15.857Z\",\n \"snowflake.query.transaction_id\": 0,\n \"snowflake.release_version\": \"9.14.2\",\n \"snowflake.role.type\": \"ROLE\",\n \"snowflake.schema.id\": 40234,\n \"snowflake.schema.name\": \"APP\",\n \"snowflake.warehouse.cluster.number\": 1,\n \"snowflake.warehouse.id\": 3726,\n \"snowflake.warehouse.size\": \"X-Small\",\n \"snowflake.warehouse.type\": \"STANDARD\"\n}", "METRICS": "{\n \"snowflake.acceleration.data.scanned\": 0,\n \"snowflake.acceleration.partitions.scanned\": 0,\n \"snowflake.acceleration.scale_factor.max\": 0,\n \"snowflake.credits.cloud_services\": 1.000000000000000e-05,\n \"snowflake.data.deleted\": 0,\n \"snowflake.data.read.from_result\": 0,\n \"snowflake.data.scanned\": 0,\n \"snowflake.data.scanned_from_cache\": 0.000000000000000e+00,\n \"snowflake.data.sent_over_the_network\": 0,\n \"snowflake.data.spilled.local\": 0,\n \"snowflake.data.spilled.remote\": 0,\n \"snowflake.data.transferred.inbound\": 0,\n \"snowflake.data.transferred.outbound\": 0,\n \"snowflake.data.written\": 0,\n \"snowflake.data.written_to_result\": 640,\n \"snowflake.external_functions.data.received\": 0,\n \"snowflake.external_functions.data.sent\": 0,\n \"snowflake.external_functions.invocations\": 0,\n \"snowflake.external_functions.rows.received\": 0,\n \"snowflake.external_functions.rows.sent\": 0,\n \"snowflake.load.used\": 100,\n \"snowflake.partitions.scanned\": 0,\n \"snowflake.partitions.total\": 0,\n \"snowflake.rows.deleted\": 0,\n \"snowflake.rows.inserted\": 0,\n \"snowflake.rows.unloaded\": 0,\n \"snowflake.rows.updated\": 0,\n \"snowflake.rows.written_to_result\": 798,\n \"snowflake.time.child_queries_wait\": 0,\n \"snowflake.time.compilation\": 43,\n \"snowflake.time.execution\": 6969,\n \"snowflake.time.list_external_files\": 0,\n \"snowflake.time.queued.overload\": 0,\n \"snowflake.time.queued.provisioning\": 0,\n \"snowflake.time.repair\": 0,\n \"snowflake.time.total_elapsed\": 7012,\n \"snowflake.time.transaction_blocked\": 0\n}", "IS_PARENT": true, "IS_ROOT": true} diff --git a/test/test_data/resource_monitors.ndjson b/test/test_data/resource_monitors.ndjson new file mode 100644 index 00000000..dcbcf4a5 --- /dev/null +++ b/test/test_data/resource_monitors.ndjson @@ -0,0 +1,2 @@ +{"START_TIME": 1760681131956968000, "IS_ACCOUNT_LEVEL": true, "IS_ACTIVE": true, "_MESSAGE": "Resource Monitor details for ACCOUNT_GLOBAL_MONITOR", "DIMENSIONS": "{\n \"snowflake.resource_monitor.name\": \"ACCOUNT_GLOBAL_MONITOR\"\n}", "ATTRIBUTES": "{\n \"snowflake.resource_monitor.frequency\": \"DAILY\",\n \"snowflake.resource_monitor.is_active\": true,\n \"snowflake.resource_monitor.level\": \"ACCOUNT\",\n \"snowflake.warehouses.names\": [\n \"SYSTEM$STREAMLIT_NOTEBOOK_WH\",\n \"UNMONITORED_WH\"\n ]\n}", "EVENT_TIMESTAMPS": "{\n \"snowflake.resource_monitor.created_on\": 1722126338621000000,\n \"snowflake.resource_monitor.start_time\": 1722126338665000000\n}", "METRICS": "{\n \"snowflake.credits.quota\": \"15.00\",\n \"snowflake.credits.quota.remaining\": \"8.79\",\n \"snowflake.credits.quota.used\": \"6.21\",\n \"snowflake.credits.quota.used_pct\": 41.4,\n \"snowflake.resource_monitor.warehouses\": 2\n}"} +{"START_TIME": 1760681131979831000, "IS_ACCOUNT_LEVEL": false, "IS_ACTIVE": true, "_MESSAGE": "Resource Monitor details for NATIVE_APP_QUICKSTART_RS", "DIMENSIONS": "{\n \"snowflake.resource_monitor.name\": \"NATIVE_APP_QUICKSTART_RS\"\n}", "ATTRIBUTES": "{\n \"snowflake.resource_monitor.frequency\": \"DAILY\",\n \"snowflake.resource_monitor.is_active\": true,\n \"snowflake.resource_monitor.level\": \"WAREHOUSE\",\n \"snowflake.warehouses.names\": [\n \"NATIVE_APP_QUICKSTART_WH\"\n ]\n}", "EVENT_TIMESTAMPS": "{\n \"snowflake.resource_monitor.created_on\": 1728174328873000000,\n \"snowflake.resource_monitor.start_time\": 1728174328890000000\n}", "METRICS": "{\n \"snowflake.credits.quota\": \"1.00\",\n \"snowflake.credits.quota.remaining\": \"1.00\",\n \"snowflake.credits.quota.used\": \"0.00\",\n \"snowflake.credits.quota.used_pct\": 0,\n \"snowflake.resource_monitor.warehouses\": 1\n}"} diff --git a/test/test_data/sessions.ndjson b/test/test_data/sessions.ndjson new file mode 100644 index 00000000..e69de29b diff --git a/test/test_data/shares.ndjson b/test/test_data/shares.ndjson new file mode 100644 index 00000000..2ffc67b6 --- /dev/null +++ b/test/test_data/shares.ndjson @@ -0,0 +1,2 @@ +{"_MESSAGE": "Share details for Monte Carlo", "DIMENSIONS": "{\n \"db.namespace\": \"\",\n \"snowflake.share.name\": \"Monte Carlo\"\n}", "ATTRIBUTES": "{\n \"snowflake.share.is_secure_objects_only\": \"\",\n \"snowflake.share.kind\": \"INBOUND\",\n \"snowflake.share.listing_global_name\": \"\",\n \"snowflake.share.owner\": \"\",\n \"snowflake.share.shared_from\": \"JKMKTPS.DKA87615\",\n \"snowflake.share.shared_to\": \"\"\n}", "EVENT_TIMESTAMPS": "{\n \"snowflake.share.created_on\": 1633629486209000000\n}"} +{"_MESSAGE": "Share details for ACCOUNT_USAGE", "DIMENSIONS": "{\n \"db.namespace\": \"SNOWFLAKE\",\n \"snowflake.share.name\": \"ACCOUNT_USAGE\"\n}", "ATTRIBUTES": "{\n \"snowflake.share.is_secure_objects_only\": \"\",\n \"snowflake.share.kind\": \"INBOUND\",\n \"snowflake.share.listing_global_name\": \"\",\n \"snowflake.share.owner\": \"\",\n \"snowflake.share.shared_from\": \"SNOWFLAKE\",\n \"snowflake.share.shared_to\": \"\"\n}", "EVENT_TIMESTAMPS": "{\n \"snowflake.share.created_on\": 1568850151405000000\n}"} diff --git a/test/test_data/tasks_history.ndjson b/test/test_data/tasks_history.ndjson new file mode 100644 index 00000000..2e1f7c06 --- /dev/null +++ b/test/test_data/tasks_history.ndjson @@ -0,0 +1,2 @@ +{"TIMESTAMP": 1760681132696576000, "_MESSAGE": "New Tasks History entry for DTAGENT_DB", "DIMENSIONS": "{\n \"db.namespace\": \"DTAGENT_DB\",\n \"snowflake.schema.name\": \"APP\",\n \"snowflake.task.name\": \"TASK_DTAGENT_USERS\"\n}", "ATTRIBUTES": "{\n \"snowflake.task.graph.root_id\": \"01bb391a-b277-2d03-0000-000000000d2d\",\n \"snowflake.task.graph.version\": 2,\n \"snowflake.task.run.attempt\": 1,\n \"snowflake.task.run.group_id\": \"484a88f5-af2d-4d24-9bea-f4adf7c23c1b\",\n \"snowflake.task.run.id\": 1745884800000,\n \"snowflake.task.run.scheduled_from\": \"SCHEDULE\",\n \"snowflake.task.run.scheduled_time\": \"2025-04-29 00:00:00.000 Z\",\n \"snowflake.task.run.state\": \"SCHEDULED\"\n}"} +{"TIMESTAMP": 1760681132724116000, "_MESSAGE": "New Tasks History entry for DTAGENT_DB", "DIMENSIONS": "{\n \"db.namespace\": \"DTAGENT_DB\",\n \"snowflake.schema.name\": \"APP\",\n \"snowflake.task.name\": \"TASK_DTAGENT_DATA_SCHEMAS\"\n}", "ATTRIBUTES": "{\n \"snowflake.task.graph.root_id\": \"01bb391a-0307-d549-0000-000000000d22\",\n \"snowflake.task.graph.version\": 2,\n \"snowflake.task.run.attempt\": 1,\n \"snowflake.task.run.group_id\": \"b3a683bb-c10c-4ce6-b24d-5babf7c4dd79\",\n \"snowflake.task.run.id\": 1745869628961,\n \"snowflake.task.run.scheduled_from\": \"SCHEDULE\",\n \"snowflake.task.run.scheduled_time\": \"2025-04-28 19:47:08.961 Z\",\n \"snowflake.task.run.state\": \"SCHEDULED\"\n}"} diff --git a/test/test_data/tasks_serverless.ndjson b/test/test_data/tasks_serverless.ndjson new file mode 100644 index 00000000..e69de29b diff --git a/test/test_data/tasks_versions.ndjson b/test/test_data/tasks_versions.ndjson new file mode 100644 index 00000000..e69de29b diff --git a/test/test_data/trust_center_instr.ndjson b/test/test_data/trust_center_instr.ndjson new file mode 100644 index 00000000..889e3d21 --- /dev/null +++ b/test/test_data/trust_center_instr.ndjson @@ -0,0 +1,2 @@ +{"_MESSAGE": "[MEDIUM] Native Apps Event Sharing Check Ensure Event Table is configured for Native Application event sharing", "_SEVERITY": "MEDIUM", "STATUS_CODE": "OK", "START_TIME": 1760681133160916000, "EVENT_START": 1758043263598000000, "EVENT_END": 1758043267087000000, "TIMESTAMP": 1760681133160916000, "DIMENSIONS": "{\n \"event.category\": \"Vulnerability management\",\n \"snowflake.trust_center.scanner.id\": \"SECURITY_ESSENTIALS_NA_CONSUMER_ES_CHECK\",\n \"snowflake.trust_center.scanner.package.id\": \"SECURITY_ESSENTIALS\",\n \"snowflake.trust_center.scanner.type\": \"Vulnerability\",\n \"vulnerability.risk.level\": \"MEDIUM\"\n}", "ATTRIBUTES": "{\n \"error.code\": \"SECURITY_ESSENTIALS_NA_CONSUMER_ES_CHECK\",\n \"event.id\": 252009,\n \"event.kind\": \"SECURITY_EVENT\",\n \"snowflake.trust_center.scanner.description\": \"Ensure Event Table is configured for Native Application event sharing\",\n \"snowflake.trust_center.scanner.name\": \"Native Apps Event Sharing Check\",\n \"snowflake.trust_center.scanner.package.name\": \"Security Essentials\",\n \"status.message\": \"[MEDIUM] Native Apps Event Sharing Check Ensure Event Table is configured for Native Application event sharing\"\n}"} +{"_MESSAGE": "[CRITICAL] 3.1 Ensure that an account-level network policy has been configured to only allow access from trusted IP addresses", "_SEVERITY": "CRITICAL", "STATUS_CODE": "OK", "START_TIME": 1760681133185199000, "EVENT_START": 1758043265132000000, "EVENT_END": 1758043272074000000, "TIMESTAMP": 1760681133185199000, "DIMENSIONS": "{\n \"event.category\": \"Vulnerability management\",\n \"snowflake.trust_center.scanner.id\": \"SECURITY_ESSENTIALS_CIS3_1\",\n \"snowflake.trust_center.scanner.package.id\": \"SECURITY_ESSENTIALS\",\n \"snowflake.trust_center.scanner.type\": \"Vulnerability\",\n \"vulnerability.risk.level\": \"CRITICAL\"\n}", "ATTRIBUTES": "{\n \"error.code\": \"SECURITY_ESSENTIALS_CIS3_1\",\n \"event.id\": 252010,\n \"event.kind\": \"SECURITY_EVENT\",\n \"snowflake.trust_center.scanner.description\": \"Ensure that an account-level network policy has been configured to only allow access from trusted IP addresses\",\n \"snowflake.trust_center.scanner.name\": \"3.1\",\n \"snowflake.trust_center.scanner.package.name\": \"Security Essentials\",\n \"status.message\": \"[CRITICAL] 3.1 Ensure that an account-level network policy has been configured to only allow access from trusted IP addresses\"\n}"} diff --git a/test/test_data/trust_center_metrics.ndjson b/test/test_data/trust_center_metrics.ndjson new file mode 100644 index 00000000..e8e36a2b --- /dev/null +++ b/test/test_data/trust_center_metrics.ndjson @@ -0,0 +1,2 @@ +{"TIMESTAMP": 1760681133116400000, "DIMENSIONS": "{\n \"event.category\": \"Warning\",\n \"snowflake.trust_center.scanner.id\": \"CIS_BENCHMARKS_CIS2_5\",\n \"snowflake.trust_center.scanner.package.id\": \"CIS_BENCHMARKS\",\n \"snowflake.trust_center.scanner.type\": \"Vulnerability\",\n \"vulnerability.risk.level\": \"LOW\"\n}", "ATTRIBUTES": "{}", "METRICS": "{\n \"snowflake.trust_center.findings\": 0\n}"} +{"TIMESTAMP": 1760681133138871000, "DIMENSIONS": "{\n \"event.category\": \"Warning\",\n \"snowflake.trust_center.scanner.id\": \"CIS_BENCHMARKS_CIS2_7\",\n \"snowflake.trust_center.scanner.package.id\": \"CIS_BENCHMARKS\",\n \"snowflake.trust_center.scanner.type\": \"Vulnerability\",\n \"vulnerability.risk.level\": \"LOW\"\n}", "ATTRIBUTES": "{}", "METRICS": "{\n \"snowflake.trust_center.findings\": 0\n}"} diff --git a/test/test_data/users_all_privileges.ndjson b/test/test_data/users_all_privileges.ndjson new file mode 100644 index 00000000..06edb8db --- /dev/null +++ b/test/test_data/users_all_privileges.ndjson @@ -0,0 +1,2 @@ +{"DIMENSIONS": "{\n \"db.user\": \"PIPELINE\"\n}", "ATTRIBUTES": "{\n \"snowflake.user.privilege\": \"REFERENCES:TABLE\",\n \"snowflake.user.privilege.granted_by\": [\n \"SECURITYADMIN\"\n ],\n \"snowflake.user.privilege.grants\": \"FACT_HOSTS,TMP_DEMO_LOCAL_TEMPORARY,DIM_ENVIRONMENT,CDH_MAINFRAME_MSU_HISTORY,CDH_DDU_METRICS_BY_METRIC_HISTORY,CDH_DDU_TRACES_BY_ENTITY_HISTORY,CDH_ODIN_AGENT_HISTORY,CDH_DEEP_MONITORING_SETTINGS_HISTORY,DIM_PRODUCT,DISCOVERED_CLOUD_SERVICES_REPORT,CDH_SERVICE_HISTORY,FACT_ENTITY_TAG_COVERAGE,CDH_COMPETITOR_JS_FRAMEWORK_USAGE_HISTORY,FACT_API_USER_AGENT_USAGE,DIM_EXTENSION,TENANT_STATUS,CDH_PROBLEM_EVENT_METADATA_HISTORY,CDH_CUSTOM_SESSIONS_APPLICATION_TECHNOLOGY_BILLING_TYPE_HISTORY,CDH_DDU_TRACES_BY_DESCRIPTION_HISTORY,CDH_PROBLEM_ROOT_CAUSE_GROUP_HISTORY,DIM_DEVICE_TYPE,DIM_PROCESS_GROUP,DC_JIRA_REQUESTS,FACT_COLUMN_PROTECTION,CDH_CONTAINER_GROUP_HISTORY,SFDC_PROJECT,CDH_CLUSTER_NETWORK_ZONE_STATS_HISTORY,DIM_HOST,REPORTS_EXECUTION_LOG,DIM_PROBLEM_EVENT_STATUS,CDH_JS_FRAMEWORK_USAGE_HISTORY,FACT_CUSTOMER_ACCOUNTS,DAVIS_CHANNEL_CONFIGURATION,CDH_DEEP_MONITORING_SETTINGS_FEATURES_HISTORY,FACT_CF_FOUNDATIONS,CDH_INTERNAL_ENTITY_MODEL_CAPPING_INFORMATION_HISTORY,R,BAS_AUDIT_FIELD,DIM_CLOUD_APPLICATION_INSTANCE_TYPE,WOOPRA_PAGEVIEW,DIM_CLOUD_APPLICATION_TYPE,DIM_SESSION_CITY,DIM_AREA,BILLING_USAGE,RUM_PAGEVIEW,TIM,FACT_CLOUD_APPLICATION_INSTANCES,DIM_SESSION_REGION,BAS_USER,FACT_TABLE_USAGE,DAVIS_USER,DIM_AGENT_ATTRIBUTES,ALECKI_INT,MANAGED_CLUSTER,DIM_HOST_ATTRIBUTES_HISTORY,CONTRACT,CDH_TOTAL_FDI_EVENT_COUNT_HISTORY,TENANT_LICENSE,DAVIS_USAGE,ENVIRONMENT_USAGE_DAILY_SUMMARY_VIEW,DIM_DEM_GOALS,FACT_PROBLEMS,DIM_USAGE_TYPE,INFRASTRUCTURE_SOLUTION_ACCOUNTS,INTERCOM_CONVERSATION_PARTS,CDH_SESSION_STORAGE_USAGE_HISTORY,ALECKI_ALL,CDH_METRIC_EVENT_CONFIG_THRESHOLD_BASED_MODEL_HISTORY,Z,CDH_FEATURE_FLAG_HISTORY,SFDC_ACCOUNT,PRIMKEY,CDH_METRIC_QUERY_STATS_HISTORY,ALECKI_VARCHAR,CDH_SYNTHETIC_MONITOR_LOCATION_HISTORY,PARTNER_REFERRAL,FACT_OPPORTUNITIES,EMPLOYEE_COUNT,CDH_BILLING_APP_SESSIONS_HISTORY,TENANT,DIM_PRODUCT_USER,SQL_LOG,TENANT_LAST_ACCESS_DATE,FACT_ACTIVE_GATE_UPDATE_STATUS,DIM_CLOUD_APPLICATION_NAMESPACE,DIM_OPPORTUNITY_STAGE,BI_STATUS,FACT_AGENT_TECHNOLOGIES,DIM_ACTIVE_GATE,ALECKI_DATE,CDH_ACTIVE_GATE_MODULES_STATUSES_HISTORY,CDH_ODIN_AGENT_ME_IDENTIFIER_HISTORY,DIM_API_ENDPOINT,DEF_EXAMPLE,CDH_TENANT_NETWORK_ZONE_STATS_HISTORY,FACT_APPLICATIONS,CDH_PLUGIN_METRIC_STATS_HISTORY,CDH_TAG_COVERAGE_HISTORY,TYPES,DIM_QUALITY_TYPE,DIM_ENVIRONMENT_ATTRIBUTES,CDH_SOFTWARE_COMPONENT_DETAILS_EVIDENCE_HISTORY,DIM_KUBERNETES_CLUSTER,CDH_SOFTWARE_COMPONENT_DETAILS_HISTORY,FACT_TAG_COVERAGE,DIM_PRODUCT_BEHAVIORAL_EVENT,CDH_REQUEST_ATTRIBUTE_STATS_HISTORY,FACT_CONTRACT_USAGE,CDH_SECURITY_PROBLEM_HISTORY,DIM_AGENT,TENANT_USAGE_DAILY_SUMMARY,TENANT_USAGE_DAILY_SUMMARY_VIEW,FACT_API_USAGE_AGGR,FACT_PRODUCT_PAGE_VIEWS,DIM_DT_ACCOUNT,FACT_PROCESS_TECHNOLOGIES,DIM_POWERBI_COLUMN,CDH_TILE_FILTER_CONFIG_HISTORY,CDH_APPLICATION_HISTORY,CDH_ENVIRONMENT_RAW,CDH_PROBLEM_RANKED_ENTITY_HISTORY,ALECKI_DECIMAL,ACCOUNT_STATUS,DIM_CUSTOMER,CDH_SYNTHETIC_MONITOR_HISTORY,DIM_CLUSTER_ATTRIBUTES,MONTHLY_CONSUMPTION_EXT,CDH_FDI_EVENT_INSTANCE_CLASSES_HISTORY,CDH_CUSTOM_SESSIONS_APPLICATION_TECHNOLOGY_TYPE_HISTORY,DIM_GEOGRAPHY,FACT_CUSTOMER_SUPPORT,CDH_METRIC_EVENT_CONFIG_NAME_FILTER_HISTORY,COMPANY,CDH_CONTAINER_MEMORY_USAGE_HISTORY,DIM_PRODUCT_PAGE,DEC,CDH_LOG_MONITORING_STATS_HISTORY,DIM_ACTIVE_GATE_MODULE,DIM_VERSION,CDH_CF_FOUNDATION_HOST_HISTORY,INTERCOM_COMPANIES,CDH_CLOUD_APPLICATION_INSTANCE_HISTORY,HASHED_VALUES,DIM_POC,CDH_CONTAINER_GROUP_INSTANCE_HISTORY,DIM_CF_FOUNDATION,CDH_VULNERABILITY_MATCHING_METADATA_HISTORY,AUTOPROV_EVENTS_FEATURES,DIM_COUNTRY,CDH_METRIC_EVENT_CONFIG_HISTORY,DIM_TRIAL,CDH_DATABASE_INSIGHTS_ENDPOINT_DETAILS_HISTORY,FACT_CONTRACT_LATEST_USAGE,DIM_METRIC,CONTRACT_BILLING_INFO,DIM_ACTIVE_GATE_TYPE,DIM_DT_ACCOUNT_ATTRIBUTES,CDH_FDI_EVENT_METADATA_HISTORY,CDH_MOBILE_AGENT_VERSION_USAGE_HISTORY,RUM_BEHAVIORAL_EVENT_PROPERTIES,FACT_CONTAINER_GROUP_INSTANCES,CDH_MOBILE_CRASHES_BY_RETRIEVAL_DELAY_HISTORY,CDH_VIRTUALIZATION_HISTORY,CDH_ALERTING_PROFILE_HISTORY,CDH_DEEP_MONITORING_SETTINGS_FEATURE_V2_HISTORY,TENANT_USAGE,BILLING_PROVIDER,CDH_CLUSTER_HISTORY,REGION,MONTHLY_USAGE,DIM_CONTAINERIZATION_TYPE,CDH_ACTIVE_GATE_HISTORY,BI_TEST_5K,CDH_DASHBOARD_CONFIG_HISTORY,ALECKI_MIXT,DIM_POWERBI_MEASURE,DIM_VERSIONED_MODULE,CDH_FDI_EVENT_TYPE_AGGREGATIONS_HISTORY,CDH_PROBLEM_EVIDENCE_HISTORY_ARCHIVE,TABLE_LOAD_INFO,FACT_PRODUCT_PAGE_VIEWS_DAILY_AGGR,SQL_LOG_PIPELINE,BI_TEST_16M,SFDC_TENANT,PROMO_USAGE,CDH_CONDITIONAL_PROCEDURES_RULES_HISTORY,FACT_USER_GROUP_MAP,CDH_DASHBOARD_CONFIG_TILE_HISTORY,QUERY_STATS,TIME_ZONE,CDH_CLUSTER_TAGS_HISTORY,CDH_LOG_MONITORING_METRIC_STATS_HISTORY,DIM_VERBATIM_TYPE,DIM_REGION,CDH_UEM_CONFIG_PROPERTY_TAG_HISTORY,DIM_PROBLEM,CDH_DISCOVERED_VIRTUALIZATION_SERVICE_TYPES,MANAGED_LICENSE,USAGE_CREDITS,CDH_SOFTWARE_COMPONENT_PGI_HISTORY,DATA_VOLUME,DIM_ACTIVE_GATE_OS,ALECKI_CHAR,ALECKI_LONG,BAS_AUDIT_ENTRY,FACT_SERVICE_TECHNOLOGIES,FACT_CLOUD_APPLICATIONS,DIM_USER,WOOPRA_ACTION_PROPERTIES,DIM_EXTENSION_METRIC_GROUP,CDH_MONITORED_VIRTUALIZATION_SERVICE_TYPES,CDH_MOBILE_OS_VERSION_USAGE_HISTORY,DIM_PROBLEM_EVIDENCE_TYPE,TIM_CLONE,SFDC_POC,JIRA_ISSUES,FACT_HOST_TECHNOLOGIES,CDH_FDI_EVENT_HISTORY,CDH_ENVIRONMENTS,TENANT_USAGE_SUMMARY,CDH_SETTING_HISTORY,RR,DIM_HOST_ATTRIBUTES,DIM_SESSION_BROWSER,INTERCOM_CONVERSATIONS,SESSION_REPLAYS_REPORT,FACT_PRODUCT_BEHAVIORAL_EVENTS_AGGR,BI_TEST_1K,RUM_SESSION,DIM_TECHNOLOGY,DIM_PRODUCT_TYPE,ACCOUNT,INTERCOM_CONVERSATION_TAGS,CDH_ALERTING_PROFILE_SEVERITY_RULE_HISTORY,ALECKI_ALL_TYPES,SERVICE,CDH_KUBERNETES_NODE_HISTORY,DIM_CLUSTER,JOBSTATUS,SFDC_ASSIGNMENT,DIM_OPPORTUNITY_TYPE,BILLING_SERVICE_TYPE,FACT_PROCESS_ATTRIBUTES,CDH_PLUGIN_STATE_HISTORY,DIM_SERVICE,CDH_TAG_COVERAGE_ENTITIES_HISTORY,INTERCOM_CONTACTS,FACT_ACTIVE_GATE_MODULES_STATUSES,FACT_COLUMN_USAGE,CDH_DATABASE_INSIGHTS_HISTORY,SFDC_OPPORTUNITY,ISSUE_JIRA_REQUESTS,DIM_CONTRACT,FACT_VERSIONED_MODULES,SFDC_TRIAL,WOOPRA_SESSION,RUM_BEHAVIORAL_EVENTS,DIM_POC_PRODUCT,CDH_SOFTWARE_COMPONENT_DETAILS_PACKAGE_HISTORY,CDH_PREFERENCES_SETTINGS_HISTORY,CDH_SECURITY_PROBLEM_MUTE_STATE_HISTORY,CDH_CLUSTER_EMERGENCY_EMAILS_HISTORY,CDH_INTEGRATION_HISTORY,CDH_SECURITY_PROBLEM_SC_HISTORY,ALECKI_DOUBLE,DIM_CONTRACT_LIMIT_ATTRIBUTES,DIM_SCREEN_RESOLUTION,SERVICE_USAGE_SUMMARY,CDH_TOKEN_STATS_HISTORY,CDH_VERSIONED_MODULE_V2_HISTORY,FACT_ACCOUNT_VERTICALS,FACT_CUSTOMERS,FACT_PROBLEM_EVIDENCE,DIM_TABLE,SYSTEM_PROPERTIES,CDH_SECURITY_PROBLEM_ASSESSMENT_HISTORY,FACT_TRIALS,DIM_DATE,MONITORED_CLOUD_SERVICES_REPORT,CDH_VISITSTORE2_METRICS_HISTORY,CDH_SOFTWARE_COMPONENT_HISTORY,FACT_KUBERNETES_NODES,CDH_HOST_TECH_HISTORY,CDH_SOFTWARE_COMPONENT_DETAILS_VERSION_HISTORY,CDH_TOKEN_STATS_PERMISSION_HISTORY,FACT_POC,CDH_VISIT_STORE_USAGE_HISTORY,SFDC_TASK,FACT_CLOUD_APPLICATION_NAMESPACES,REFERRAL_CODE,DIM_CONTAINER_GROUP_INSTANCE,DAILY_USAGE,FACT_SESSIONS_DAILY_AGGR,CDH_CF_FOUNDATION_HISTORY,TIM2,CDH_HOST_HISTORY,CDH_CUSTOM_CHART_STATS_HISTORY,CDH_ACTIVE_GATE_UPDATE_STATUS_HISTORY,DTU_ACTIVITIES,DAVIS_ACCOUNT_LINK,CDH_AGENT_HISTORY,DIM_DT_ONE,CLOUD_ADOPTION,FACT_AGENTS,BAS_AUDIT_ENTITY,WOOPRA_ACTION,INTERCOM_ADMINS,ENVIRONMENT_USAGE_DAILY_SUMMARY,DIM_TABLE_STATUS,DIM_KUBERNETES_NODE,DIM_CONTAINER_PROVIDER_TYPE,HOST_USAGE_DAILY_SUMMARY,DC_AUDIT_LOG,CDH_CLOUD_NETWORK_INGRESS_HISTORY,CDH_VIRTUALIZATION_SUBSCRIPTION_HISTORY,DIM_AGENT_ENVIRONMENT,CDH_VERSIONED_MODULE_HISTORY,CDH_PLUGIN_HOST_DETAILS_HISTORY,CDH_UEM_CONFIG_TENANT_HISTORY,ENVIRONMENT_USAGE_SUMMARY,FACT_TABLE_GROUP_OWNERS,T,CDH_LOG_MONITORING_ES_STATS_HISTORY,CDH_METRIC_EVENT_CONFIG_ID_FILTER_HISTORY,CDH_PROBLEM_HISTORY,CDH_UEM_CONFIG_METADATA_CAPTURING_SETTINGS_HISTORY,DATASOURCES,DIM_SERVICE_TYPE,DIM_CUSTOMER_TASK,DIM_SESSION_OS,DIM_POWERBI_TABLE,SERVICE_USAGE_DAILY_SUMMARY,DIM_AGENT_TECHNOLOGY_TYPE,MANAGED_LICENSE_QUOTA,CDH_UEM_CONFIG_HISTORY,CDH_API_USAGE_HISTORY,DIM_API_USER_AGENT,TABLE_EXTRACT_INFO,xyz,DIM_APPLICATION,CDH_PROBLEM_EVIDENCE_HISTORY,REF,CDH_CLOUD_APPLICATION_NAMESPACE_HISTORY,CDH_CLOUD_NETWORK_SERVICE_HISTORY,DIM_SESSION_CONTINENT,DIM_CONDITIONAL_PROCEDURE,CDH_RELEASE_HISTORY,LIMITS,PROCESS_STATUS,INFRASTRUCTURE_SOLUTION_ENVIRONMENTS,AUTOPROV_EVENTS,BILLING_ACCOUNT,FACT_TABLE,CDH_CLOUD_APPLICATION_HISTORY,WOOPRA_PAGES,DIM_PROBLEM_SOURCE,ROLE,CDH_BILLING_SYNTHETIC_USAGE_HISTORY,CDH_FDI_EVENT_ENTITY_TYPE_AGGREGATIONS_HISTORY,CDH_PROBLEM_IMPACTED_ENTITIES_HISTORY,CLOUD_USAGE_REPORT,CDH_EXTENDED_TENANT_CONFIG_HISTORY,CDH_API_USER_AGENT_USAGE_HISTORY,DIM_COMPETITOR,DIM_OPPORTUNITY,FACT_PROBLEM_NATURAL_EVENTS,MC_ACCOUNT,FACT_PROBLEM_RANKED_ENTITIES,ALECKI_BOOLEAN,CDH_EXTRACT_STATISTICS,CDH_CONDITIONAL_PROCEDURES_HISTORY,CDH_CLUSTER_CONTACTS_HISTORY,CDH_ENDED_SESSIONS_HISTORY,FACT_CONDITIONAL_PROCEDURE_ENTITY_RULES,CDH_PROBLEM_NATURAL_EVENT_HISTORY,DIM_TABLE_GROUP,SFDC_MANAGED_LICENSE,DIM_CLOUD_APPLICATION_INSTANCE,DIM_CLOUD_APPLICATION,DIM_CONTAINER_GROUP,FACT_CUSTOMER_TASKS,DIM_POC_ACCOUNT,FACT_SESSIONS,DIM_POWERBI_STATE,DIM_HOST_TECHNOLOGY,CDH_CLOUD_NETWORK_POLICY_HISTORY,FACT_PROBLEM_IMPACTED_ENTITIES,CDH_SLO_HISTORY,FACT_PROCESSES,SQL_PERFORMANCE,CDH_DEEP_MONITORING_SETTINGS_V2_HISTORY,DIM_LICENSE,DIM_CURRENCY,PACKAGE,CDH_EXTENSION_HISTORY,UPGRADE_EXECUTION,R2,UNIQUE_HOSTS_TECHNOLOGY_HISTORY,MONTHLY_CONSUMPTION_REPORT,MONTHLY_CONSUMPTION_STAGING,CDH_PROBLEM_CAPPING_INFORMATION_HISTORY,FACT_CONTAINER_GROUPS,DIM_POWERBI_MODEL,PROMO_CODE,BI_TEST_200,ALECKI_FLOAT,REPORT_STATUS,TENANT_SUB_ENVIRONMENT,DIM_PROBLEM_EVENT_TYPE,INTERCOM_USERS,ENVIRONMENT_SERVICE_DAILY_SUMMARY,FACT_API_USAGE,BI_TEST_65K,FACT_COLUMN,DIM_VERTICAL,FACT_OPPORTUNITY_PRODUCTS,CDH_PROBLEM_EVENT_INSTANCE_CLASSES_HISTORY,USERS_AND_QUERIES_COUNT_STATS,CONTRACT_PRICING,EXTENSION_REPOSITORY_INFO,FACT_PRODUCT_BEHAVIORAL_EVENTS,CDH_PROCESS_HISTORY,SYNTHETIC_LOCATIONS,ALECKI_SHORT,WOOPRA_PAGEVIEW_BAS,BILLING_REQUEST,CDH_CLUSTERS,SFDC_DYNATRACE_ACCOUNT,DIM_APPLICATION_TYPE,MANAGED_ACCOUNT,ETL_DAILY_INGESTED_DATA_VOLUME,ALECKI_TIMESTAMP,DAVIS_TENANT,FACT_SERVICES,ENVIRONMENT_SERVICE_SUMMARY,DIM_CLOUD_APPLICATION_INSTANCE_PHASE,FACT_ACTIVE_GATES,CDH_METRIC_EVENT_CONFIG_COUNT_HISTORY,DIM_COLUMN,FACT_DATA_QUALITY_ISSUES,SFDC_OPPORTUNITY_PRODUCT,DIM_PROCESS,FACT_ENVIRONMENT_USAGE,BI_TEST_100,CDH_CONTAINER_MEMORY_LIMIT_HISTORY,FACT_DDU_METRICS,ALECKI_TIMESTAMP_TZ,FACT_COLUMN_DEPENDENCIES\",\n \"snowflake.user.privilege.last_altered\": 1615479617462000000\n}"} +{"DIMENSIONS": "{\n \"db.user\": \"ANDRZEJLECKI\"\n}", "ATTRIBUTES": "{\n \"snowflake.user.privilege\": \"REFERENCES:VIEW\",\n \"snowflake.user.privilege.granted_by\": [\n \"SECURITYADMIN\"\n ],\n \"snowflake.user.privilege.grants\": \"FACT_PROBLEM_IMPACTED_ENTITIES,FACT_OPPORTUNITY_PRODUCTS,DIM_API_ENDPOINT,CDH_PROBLEM_EVENT_METADATA_HISTORY,FACT_AGENT_TECHNOLOGIES,CDH_SOFTWARE_COMPONENT_DETAILS_VERSION_HISTORY,SFDC_TENANT,CDH_CONTAINER_GROUP_HISTORY,CDH_PROBLEM_NATURAL_EVENT_HISTORY,BAS_MANAGED_LICENSE,CDH_COMPETITOR_JS_FRAMEWORK_USAGE_HISTORY,VW_REP_DATE_DIMENSION,DEHASH_TENANT,CDH_TOKEN_STATS_HISTORY,CDH_CONDITIONAL_PROCEDURES_HISTORY,V_KEY_USER_ACTION,FACT_APPLICATIONS,CDH_PROBLEM_CAPPING_INFORMATION_HISTORY,CDH_PROBLEM_IMPACTED_ENTITIES_HISTORY,DIM_VERTICAL,BAS_PROMO_USAGE,INTERCOM_CONTACTS,CDH_CLOUD_APPLICATION_NAMESPACE_HISTORY,CDH_API_USER_AGENT_USAGE_HISTORY,DIM_CLOUD_APPLICATION_INSTANCE,FACT_PROBLEMS,FACT_POC,FACT_ACTIVE_GATES,AUTOPROV_EVENTS,CDH_DISCOVERED_VIRTUALIZATION_SERVICE_TYPES,CDH_DASHBOARD_CONFIG_HISTORY,CDH_LOG_MONITORING_STATS_HISTORY,CDH_JS_FRAMEWORK_USAGE_HISTORY,V_LOG_EVENTS,DIM_PROBLEM_EVENT_STATUS,RUM_BEHAVIORAL_EVENT_PROPERTIES,DIM_POC,CDH_SESSION_STORAGE_USAGE_HISTORY,DIM_DT_ONE,DIM_SERVICE_TYPE,CDH_SECURITY_PROBLEM_ASSESSMENT_HISTORY,DIM_CF_FOUNDATION,BAS_TENANT_SUB_ENVIRONMENT,RUM_SESSION,CDH_ALERTING_PROFILE_SEVERITY_RULE_HISTORY,FACT_API_USAGE,JIRA_ISSUES,FACT_ENVIRONMENT_UNITS_CONSUMPTION,BAS_ENVIRONMENT_SERVICE_SUMMARY,CDH_ODIN_AGENT_HISTORY,DIM_PROBLEM_EVENT_TYPE,DIM_SESSION_OS,BAS_COMPANY,FACT_DDU_METRICS,BAS_SFDC_TRIAL,BAS_ROLE,V_CLOUD_AUTOMATION_SOLUTION,CDH_INTERNAL_ENTITY_MODEL_CAPPING_INFORMATION_HISTORY,DIM_HOST_ATTRIBUTES,CDH_FDI_EVENT_HISTORY,CDH_METRIC_EVENT_CONFIG_THRESHOLD_BASED_MODEL_HISTORY,CDH_SETTING_HISTORY,DIM_PROCESS,DIM_POC_PRODUCT,DIM_APPLICATION,DIM_TECHNOLOGY,DIM_PRODUCT_BEHAVIORAL_EVENT,BAS_BILLING_PROVIDER,CDH_TILE_FILTER_CONFIG_HISTORY,CDH_CLOUD_NETWORK_SERVICE_HISTORY,BAS_USER,BAS_TIME_ZONE,BAS_AUDIT_ENTITY,CDH_SYNTHETIC_MONITOR_LOCATION_HISTORY,BAS_CONTRACT,CDH_REQUEST_ATTRIBUTE_STATS_HISTORY,MONTHLY_CONSUMPTION_EXT,DIM_SALES_REGION,CDH_METRIC_EVENT_CONFIG_NAME_FILTER_HISTORY,BAS_ACCOUNT_STATUS,V_APPS_AND_MICROSERVICES_OPENT,CDH_ACTIVE_GATE_UPDATE_STATUS_HISTORY,CDH_UEM_CONFIG_HISTORY,CONTRACT_CONSUMPTION_LATEST,WOOPRA_ACTION,CDH_SECURITY_PROBLEM_HISTORY,DAVIS_USER,DIM_ACTIVE_GATE_MODULE,DAVIS_TENANT,INTERCOM_USERS,CDH_ENVIRONMENTS,CDH_SYNTHETIC_MONITOR_HISTORY,DIM_ENVIRONMENT,RUM_PAGEVIEW,DIM_EXTENSION_METRIC_GROUP,CDH_TOKEN_STATS_PERMISSION_HISTORY,CDH_CUSTOM_SESSIONS_APPLICATION_TECHNOLOGY_TYPE_HISTORY,DIM_SERVICE,DIM_SESSION_CITY,V_RUM_PROPERTIES,V_DEM_CUSTOM_APPLICATION_SESSION,CDH_VIRTUALIZATION_SUBSCRIPTION_HISTORY,V_COVID_19_CONSUMPTION,CDH_CLOUD_APPLICATION_HISTORY,CDH_SOFTWARE_COMPONENT_PGI_HISTORY,INTERCOM_CONVERSATION_PARTS,CDH_CLOUD_NETWORK_INGRESS_HISTORY,CDH_TAG_COVERAGE_HISTORY,WOOPRA_PAGEVIEW,CDH_FDI_EVENT_METADATA_HISTORY,V_COLUMN_USAGE_LOG,WOOPRA_PAGEVIEW_BAS,CDH_FDI_EVENT_ENTITY_TYPE_AGGREGATIONS_HISTORY,DIM_SESSION_CONTINENT,TYPES_V,DIM_HOST_TECHNOLOGY,CDH_CLUSTERS,BAS_BILLING_SERVICE_TYPE,FACT_HOSTS_AGG_MONTH,CDH_FDI_EVENT_TYPE_AGGREGATIONS_HISTORY,DIM_VERBATIM_TYPE,CDH_METRIC_EVENT_CONFIG_HISTORY,CDH_FEATURE_FLAG_HISTORY,DAILY_USAGE,BAS_AUDIT_ENTRY,CDH_CLUSTER_TAGS_HISTORY,DIM_LICENSE,BAS_BILLING_USAGE,CDH_ACTIVE_GATE_MODULES_STATUSES_HISTORY,CDH_ACTIVE_GATE_HISTORY,CDH_PROBLEM_RANKED_ENTITY_HISTORY,CDH_METRIC_EVENT_CONFIG_COUNT_HISTORY,SFDC_OPPORTUNITY,CDH_HOST_TECH_HISTORY,DIM_CONTAINER_GROUP_INSTANCE,CDH_INTEGRATION_HISTORY,EXTENSION_REPOSITORY_INFO,VW_REP_SNOWFLAKE_STORAGE_USAGE_MONTHLY_SUMMARY,CDH_VIRTUALIZATION_HISTORY,CDH_BILLING_SYNTHETIC_USAGE_HISTORY,FACT_CF_FOUNDATIONS,CDH_CLUSTER_HISTORY,DIM_DT_ACCOUNT,DIM_USAGE_TYPE,DIM_OPPORTUNITY,CDH_CUSTOM_CHART_STATS_HISTORY,DIM_CURRENCY,INTERCOM_CONVERSATIONS,DIM_CLUSTER,CDH_MONITORED_VIRTUALIZATION_SERVICE_TYPES,DIM_CONTAINERIZATION_TYPE,V_DEM_STAR_RATING,DIM_DEVICE_TYPE,CDH_CUSTOM_SESSIONS_APPLICATION_TECHNOLOGY_BILLING_TYPE_HISTORY,DIM_OPPORTUNITY_TYPE,FACT_TRIALS,CDH_TENANT_NETWORK_ZONE_STATS_HISTORY,CDH_CLOUD_APPLICATION_INSTANCE_HISTORY,DIM_SCREEN_RESOLUTION,BAS_TENANT,DAVIS_CHANNEL_CONFIGURATION,RUM_BEHAVIORAL_EVENTS,CDH_FDI_EVENT_INSTANCE_CLASSES_HISTORY,DIM_METRIC,DIM_COMPETITOR,FACT_PROBLEM_EVIDENCE,DIM_CLOUD_APPLICATION_NAMESPACE,DIM_PRODUCT_PAGE,CDH_SECURITY_PROBLEM_MUTE_STATE_HISTORY,DIM_PROCESS_GROUP,CDH_APPLICATION_HISTORY,CDH_PLUGIN_HOST_DETAILS_HISTORY,CDH_MAINFRAME_MSU_HISTORY,DIM_TRIAL,CDH_CLUSTER_CONTACTS_HISTORY,V_ABUSIVE_TRIALS,FACT_API_USER_AGENT_USAGE,DIM_API_USER_AGENT,BAS_ACCOUNT,DEHASH_CLUSTER,DIM_APPLICATION_TYPE,BAS_ENVIRONMENT_USAGE_SUMMARY,SFDC_TASK,CDH_CONTAINER_GROUP_INSTANCE_HISTORY,FACT_PROCESS_TECHNOLOGIES,CDH_PLUGIN_STATE_HISTORY,BAS_TENANT_USAGE_SUMMARY,FACT_SERVICES,A,CDH_METRIC_QUERY_STATS_HISTORY,CDH_CF_FOUNDATION_HISTORY,BAS_TENANT_USAGE,CDH_CF_FOUNDATION_HOST_HISTORY,REFERRAL_CODE,DIM_KUBERNETES_NODE,CDH_SECURITY_PROBLEM_SC_HISTORY,UNIQUE_HOSTS_TECHNOLOGY_HISTORY_NEW,DIM_VERSIONED_MODULE,CDH_ALERTING_PROFILE_HISTORY,CDH_TOTAL_FDI_EVENT_COUNT_HISTORY,MC_MANAGED_LICENSE_QUOTA,SFDC_OPPORTUNITY_PRODUCT,DIM_CONTRACT_LIMIT_ATTRIBUTES,FACT_AGENTS,DIM_CUSTOMER,FACT_CONTAINER_GROUP_INSTANCES,DIM_DATE,BAS_TENANT_LICENSE,SFDC_PROJECT,CONTRACT_CONSUMPTION,CDH_UEM_CONFIG_PROPERTY_TAG_HISTORY,BAS_TENANT_USAGE_DAILY_SUMMARY_VIEW,BAS_TENANT_STATUS,V_DEM_GOALS,CDH_MOBILE_OS_VERSION_USAGE_HISTORY,DIM_HOST_ATTRIBUTES_HISTORY,BAS_EMPLOYEE_COUNT,CDH_SOFTWARE_COMPONENT_DETAILS_HISTORY,FACT_CUSTOMER_ACCOUNTS,DIM_PROBLEM_EVIDENCE_TYPE,CDH_EXTENSION_HISTORY,FACT_CONTAINER_GROUPS,DIM_CLOUD_APPLICATION_INSTANCE_PHASE,FACT_CUSTOMER_TASKS,DIM_AGENT,CUSTOMER_ACCOUNT_MAPPING,CDH_SOFTWARE_COMPONENT_DETAILS_PACKAGE_HISTORY,DIM_PROBLEM,CDH_CLUSTER_EMERGENCY_EMAILS_HISTORY,CDH_PROCESS_HISTORY,PAYING_ACCOUNTS_MONTHLY,CDH_VISITSTORE2_METRICS_HISTORY,CDH_PREFERENCES_SETTINGS_HISTORY,X,FACT_CONTRACT_LATEST_USAGE,CDH_RELEASE_HISTORY,CDH_TAG_COVERAGE_ENTITIES_HISTORY,V_APPS_AND_MICROSERVICES_SERVERLESS_USAGE,CDH_DEEP_MONITORING_SETTINGS_FEATURE_V2_HISTORY,CDH_PROBLEM_EVIDENCE_HISTORY,BAS_TENANT_LAST_ACCESS_DATE,FACT_SESSIONS,FACT_CUSTOMERS,CDH_CONTAINER_MEMORY_LIMIT_HISTORY,DIM_SESSION_BROWSER,INTERCOM_CONVERSATION_TAGS,DIM_ENVIRONMENT_ATTRIBUTES,V_CLOUD_USAGE_REPORT,BAS_MONTHLY_USAGE,DIM_AREA,BAS_MANAGED_LICENSE_QUOTA,MONITORED_CLOUD_SERVICES_REPORT,VW_REP_SNOWFLAKE_WAREHOUSE_METERING_HISTORY,CDH_AGENT_HISTORY,FACT_HOSTS_AGG,DIM_GEOGRAPHY,DISCOVERED_CLOUD_SERVICES_REPORT,FACT_CONTRACT_USAGE,DIM_ACTIVE_GATE_OS,CDH_DEEP_MONITORING_SETTINGS_V2_HISTORY,DIM_COUNTRY,BAS_MANAGED_CLUSTER,FACT_HOSTS,BAS_MANAGED_ACCOUNT,VW_REP_SNOWFLAKE_PIPE_USAGE_HISTORY,V_CLOUD_INTEGRATION_USAGE,CDH_CONTAINER_MEMORY_USAGE_HISTORY,CDH_DDU_TRACES_BY_ENTITY_HISTORY,FACT_HOST_TECHNOLOGIES,DIM_ACTIVE_GATE,DIM_CONTAINER_PROVIDER_TYPE,DTU_ACTIVITIES,CDH_DEEP_MONITORING_SETTINGS_HISTORY,BAS_SERVICE_USAGE_DAILY_SUMMARY,SYNTHETIC_LOCATIONS,CDH_SOFTWARE_COMPONENT_DETAILS_EVIDENCE_HISTORY,CDH_ENVIRONMENT_RAW,CDH_EXTENDED_TENANT_CONFIG_HISTORY,BAS_LIMITS,CDH_CLOUD_NETWORK_POLICY_HISTORY,BAS_PACKAGE,FACT_ENTITY_TAG_COVERAGE,FACT_CLOUD_APPLICATION_INSTANCES,V_CONVERSION_GOALS,FACT_PROCESSES,DIM_POC_ACCOUNT,DIM_AGENT_TECHNOLOGY_TYPE,FACT_ACCOUNT_VERTICALS,DIM_CLUSTER_ATTRIBUTES,PARTNER_REFERRAL,BAS_ENVIRONMENT_SERVICE_DAILY_SUMMARY,CDH_UEM_CONFIG_METADATA_CAPTURING_SETTINGS_HISTORY,INTERCOM_ADMINS,DIM_DEM_GOALS,CDH_ENDED_SESSIONS_HISTORY,DIM_EXTENSION,FACT_CLOUD_APPLICATION_NAMESPACES,CDH_BILLING_APP_SESSIONS_HISTORY,FACT_KUBERNETES_NODES,DEHASH_ACCOUNT,INFRASTRUCTURE_SOLUTION_ACCOUNTS,CDH_DDU_METRICS_BY_METRIC_HISTORY,DIM_PROBLEM_SOURCE,DIM_HOST,DIM_KUBERNETES_CLUSTER,DIM_ACTIVE_GATE_TYPE,INFRASTRUCTURE_SOLUTION_ENVIRONMENTS_NEW,SFDC_ACCOUNT,DIM_CUSTOMER_TASK,FACT_VERSIONED_MODULES,CDH_ENVIRONMENT,DIM_AGENT_ATTRIBUTES,BAS_BILLING_REQUEST,DIM_CONDITIONAL_PROCEDURE,MC_ACCOUNT,V_INFRASTRUCTURE_SOLUTION,CDH_SOFTWARE_COMPONENT_HISTORY,CDH_SLO_HISTORY,CLOUD_USAGE_REPORT,V_DT_VALUE_METRICS,CDH_VISIT_STORE_USAGE_HISTORY,CDH_ODIN_AGENT_ME_IDENTIFIER_HISTORY,FACT_PROBLEM_NATURAL_EVENTS,BAS_AUDIT_FIELD,DIM_UNIQUE_ENVIRONMENTS,AUTOPROV_EVENTS_FEATURES,CDH_MOBILE_AGENT_VERSION_USAGE_HISTORY,BAS_REGION,WOOPRA_SESSION,CDH_VULNERABILITY_MATCHING_METADATA_HISTORY,BAS_SERVICE_USAGE_SUMMARY,INFRASTRUCTURE_SOLUTION_ACCOUNTS_NEW,WOOPRA_ACTION_PROPERTIES,FACT_CLOUD_APPLICATIONS,DIM_SESSION_REGION,CDH_VERSIONED_MODULE_V2_HISTORY,CDH_SERVICE_HISTORY,INTERCOM_COMPANIES,DIM_DT_ACCOUNT_ATTRIBUTES,SESSION_REPLAYS_REPORT,FACT_ENVIRONMENT_USAGE,BAS_USAGE_CREDITS,DIM_DT_ACCOUNT_CURRENT_ATTRIBUTES,V_UNIQUE_HOST_TECHNOLOGIES,SFDC_MANAGED_LICENSE,CDH_CLUSTER_NETWORK_ZONE_STATS_HISTORY,CDH_API_USAGE_HISTORY,DAVIS_USAGE,CDH_CONDITIONAL_PROCEDURES_RULES_HISTORY,FACT_OPPORTUNITIES,BAS_ENVIRONMENT_USAGE_DAILY_SUMMARY_VIEW,BAS_SERVICE,CDH_PROBLEM_HISTORY,SFDC_DYNATRACE_ACCOUNT,FACT_ACTIVE_GATE_UPDATE_STATUS,FACT_ACTIVE_GATE_MODULES_STATUSES,BAS_CONTRACT_PRICING,CDH_PROBLEM_EVENT_INSTANCE_CLASSES_HISTORY,V_ACCOUNT_STAR_RATING,CDH_DATABASE_INSIGHTS_ENDPOINT_DETAILS_HISTORY,DIM_PRODUCT_TYPE,FACT_PROCESS_ATTRIBUTES,MONTHLY_CONSUMPTION_STAGING,FACT_CUSTOMER_SUPPORT,BAS_TENANT_USAGE_DAILY_SUMMARY,DIM_CLOUD_APPLICATION,FACT_PRODUCT_BEHAVIORAL_EVENTS,DIM_PRODUCT,DIM_VERSION,CDH_METRIC_EVENT_CONFIG_ID_FILTER_HISTORY,BAS_PROMO_CODE,CDH_PROBLEM_ROOT_CAUSE_GROUP_HISTORY,SFDC_POC,DIM_CONTAINER_GROUP,DAVIS_ACCOUNT_LINK,CDH_UEM_CONFIG_TENANT_HISTORY,DIM_CONTRACT,CDH_PROBLEM_EVIDENCE_HISTORY_ARCHIVE,CLOUD_ADOPTION,INFRASTRUCTURE_SOLUTION_ENVIRONMENTS,BAS_CONTRACT_BILLING_INFO,DIM_PRODUCT_USER,SFDC_ASSIGNMENT,DIM_OPPORTUNITY_STAGE,UNIQUE_HOSTS_TECHNOLOGY_HISTORY,FACT_SERVICE_TECHNOLOGIES,MONTHLY_CONSUMPTION_REPORT,CDH_DASHBOARD_CONFIG_TILE_HISTORY,DIM_CLOUD_APPLICATION_TYPE,B,CDH_KUBERNETES_NODE_HISTORY,FACT_TAG_COVERAGE,FACT_PRODUCT_PAGE_VIEWS,FACT_CONDITIONAL_PROCEDURE_ENTITY_RULES,CDH_LOG_MONITORING_ES_STATS_HISTORY,CDH_PLUGIN_METRIC_STATS_HISTORY,BAS_ENVIRONMENT_USAGE_DAILY_SUMMARY,CDH_HOST_HISTORY,CDH_VERSIONED_MODULE_HISTORY,BAS_BILLING_ACCOUNT,FACT_PROBLEM_RANKED_ENTITIES,DIM_CLOUD_APPLICATION_INSTANCE_TYPE,CDH_DEEP_MONITORING_SETTINGS_FEATURES_HISTORY,BAS_HOST_USAGE_DAILY_SUMMARY,CDH_LOG_MONITORING_METRIC_STATS_HISTORY,DIM_REGION,CDH_DATABASE_INSIGHTS_HISTORY,CDH_MOBILE_CRASHES_BY_RETRIEVAL_DELAY_HISTORY,WOOPRA_PAGES,CDH_DDU_TRACES_BY_DESCRIPTION_HISTORY\",\n \"snowflake.user.privilege.last_altered\": 1615219846703000000\n}"} diff --git a/test/test_data/users_all_roles.ndjson b/test/test_data/users_all_roles.ndjson new file mode 100644 index 00000000..8fe6e8f3 --- /dev/null +++ b/test/test_data/users_all_roles.ndjson @@ -0,0 +1,2 @@ +{"DIMENSIONS": "{\n \"db.user\": \"ARTURBORGATTO\"\n}", "ATTRIBUTES": "{\n \"snowflake.user.roles.granted\": \"BI_MODELER,SCRATCHPAD_ROLE,DATAMODEL_UPGRADER,BI_REPORTING,COLDSTORE,PIPELINE,DEV_SF_DATAMODELUPGRADER_ROLE\",\n \"snowflake.user.roles.granted_by\": [\n \"SECURITYADMIN\"\n ],\n \"snowflake.user.roles.last_altered\": 1615219847000000000\n}"} +{"DIMENSIONS": "{\n \"db.user\": \"TERRAFORM_USER\"\n}", "ATTRIBUTES": "{\n \"snowflake.user.roles.granted\": \"TEST_DB_OWNER_ROLE,REPORTS_FINANCIAL,EXTENSIONREPOSITORYINFO_BASIC,DEVACT_BASIC,DEVEL_DATAMODEL_UPGRADER_ROLE,DAVIS_FULL,SANDBOX_TEST_DATAMODEL_UPGRADER_ROLE,SANDBOX_TEST_READONLY_USER_ROLE,BI_MODELER,REPORTS_BASIC,JIRA_SENSITIVE,POWERBILOG_BASIC,BI_BASIC,INTERCOM_FINANCIAL,SANDBOX_TEST_DB_OWNER_ROLE,POWERBILOG_FULL,INTERCOM_SENSITIVE,REPORTS_FULL,SANDBOX_TEST_PIPELINE_ROLE,INTERNALCOSTS_FINANCIAL,DEVELCLONE_BI_REPORTING,WOOPRA_FINANCIAL,IEM_BASIC,INTERNALCOSTS_SENSITIVE,BI_FINANCIAL,POWERBILOG_FINANCIAL,DEVACT_FINANCIAL,DAVIS_BASIC,APPSEC_SENSITIVE,METADATA_FINANCIAL,JIRA_FULL,UNIVERSITY_FULL,RAW_FULL,ZENDESK_SENSITIVE,CONSUMPTION_FULL,INTERCOM_BASIC,DATAMODEL_UPGRADER,DEVEL_SYSADMIN_ROLE,SOFTCOMP_FINANCIAL,RUM_FULL,SNOWFLAKE_FINANCE,WOOPRA_BASIC,REPORTS_CONSUMPTION,CONSUMPTION_SENSITIVE,DEVEL_SECURITYADMIN_ROLE,DEVELCLONE_PIPELINE,AUTOPROV_BASIC,CONSUMPTION_FINANCIAL,REPORTS_SENSITIVE,CONSUMPTION_BASIC,METADATAAUDIT_SENSITIVE,LIMA_SENSITIVE,LIMA_BASIC,SYSADMIN,SFM_SENSITIVE,IEM_FULL,WOOPRA_SENSITIVE,TEST_POWERBI_ROLE,DEVEL_PIPELINE_ROLE,TEST_DATAMODEL_UPGRADER_ROLE,DEV_SF_DATAMODELUPGRADER_ROLE,LIMA_FULL,WOOPRA_FULL,CDH_FINANCIAL,DEVEL_COLDSTORE_ROLE,TEAMS_FULL,BAS_SENSITIVE,BI_REPORTING,ALL_FINANCIAL,SYNTHETIC_FINANCIAL,REVENUE_SENSITIVE,SANDBOX_TEST_COLDSTORE_ROLE,SALESFORCE_FINANCIAL,COMMUNITY_FINANCIAL,PIPELINE,APPSEC_FULL,INTERNALCOSTS_FULL,DATAQUALITY_FINANCIAL,SANDBOX_ANDRZEJ_BI_MODELER,SOFTCOMP_FULL,INTERCOM_FULL,BAS_FINANCIAL,SALESFORCE_SENSITIVE,EXTENSIONREPOSITORYINFO_FULL,ZENDESK_FINANCIAL,UNIVERSITY_SENSITIVE,METADATA_BASIC,RNDWORKLOGS_FINANCIAL,EMPLOYEES_SENSITIVE,DATAQUALITY_SENSITIVE,MONITORING,ALL_SENSITIVE,INTERNALCOSTS_BASIC,ALL_FULL,DEVEL_BI_MODELER_ROLE,REPORTS_TECHNOLOGY,TEAMS_SENSITIVE,DEVEL_BI_REPORTING_ROLE,DEVACT_FULL,TERRAFORM_USER_ROLE,RUM_FINANCIAL,EXTENSIONREPOSITORYINFO_FINANCIAL,AUTOPROV_FULL,UNIVERSITY_FINANCIAL,METADATAAUDIT_FINANCIAL,SCRATCHPAD_ROLE,POWERBI_MODEL,IEM_FINANCIAL,TEST_ETL_DQ_CHECKS_ROLE,SOFTCOMP_SENSITIVE,SYNTHETIC_FULL,COMMUNITY_BASIC,SANDBOX_TEST_BI_REPORTING_ROLE,COMMUNITY_FULL,JIRA_BASIC,COLDSTORE,SOFTCOMP_BASIC,SANDBOX_TEST_POWERBI_ROLE,METADATA_FULL,ZENDESK_BASIC,SFM_FULL,JIRA_FINANCIAL,COMMUNITY_SENSITIVE,EMPLOYEES_FULL,TEST_BI_REPORTING_ROLE,TEST_PIPELINE_ROLE,CDH_BASIC,DAVIS_SENSITIVE,IEM_SENSITIVE,METADATAAUDIT_FULL,AUTOPROV_FINANCIAL,DAVIS_FINANCIAL,EXTENSIONREPOSITORYINFO_SENSITIVE,RUM_SENSITIVE,APPSEC_BASIC,EMPLOYEES_FINANCIAL,RUM_BASIC,CDH_SENSITIVE,METADATA_SENSITIVE,SYNTHETIC_BASIC,ALL_BASIC,SECURITYADMIN,TEST_BI_PREDICTIONS_ROLE,SANDBOX_TEST_BI_PREDICTIONS_ROLE,SFM_FINANCIAL,TEAMS_FINANCIAL,DATAQUALITY_BASIC,TEAMS_BASIC,BI_SENSITIVE,RNDWORKLOGS_FULL,TEST_SYSADMIN,BAS_BASIC,TEST_COLDSTORE_ROLE,DEVELCLONE_BI_MODELER,REVENUE_FULL,APPSEC_FINANCIAL,SALESFORCE_FULL,EMPLOYEES_BASIC,BAS_FULL,AUTOPROV_SENSITIVE,DATAQUALITY_FULL,CDH_FULL,REVENUE_BASIC,RNDWORKLOGS_SENSITIVE,SANDBOX_ANDRZEJ_BI_REPORTING,METADATAAUDIT_BASIC,POWERBILOG_SENSITIVE,REVENUE_FINANCIAL,ANY_BASIC,SANDBOX_TEST_BI_MODELER_ROLE,SANDBOX_ANDRZEJ_PIPELINE,DEVOPS_ROLE,SALESFORCE_BASIC,TEST_BI_MODELER_ROLE,LIMA_FINANCIAL,SANDBOX_ANDRZEJ_DATAMODEL_UPGRADER,ZENDESK_FULL,DEVELCLONE_DATAMODEL_UPGRADER,UNIVERSITY_BASIC,RNDWORKLOGS_BASIC,SYNTHETIC_SENSITIVE,SFM_BASIC,DEVACT_SENSITIVE\",\n \"snowflake.user.roles.granted_by\": [\n \"DEMIGOD\"\n ],\n \"snowflake.user.roles.last_altered\": 1649326499175000000\n}"} diff --git a/test/test_data/users_hist.ndjson b/test/test_data/users_hist.ndjson new file mode 100644 index 00000000..819c0597 --- /dev/null +++ b/test/test_data/users_hist.ndjson @@ -0,0 +1,2 @@ +{"LOGIN": "TERRAFORM_USER", "_MESSAGE": "User details for TERRAFORM_USER", "TIMESTAMP": 1760681133549152000, "DIMENSIONS": "{\n \"db.user\": \"TERRAFORM_USER\"\n}", "ATTRIBUTES": "{\n \"snowflake.user.created_on\": 1649326301806000000,\n \"snowflake.user.default.secondary_role\": \"[]\",\n \"snowflake.user.display_name\": \"TERRAFORM_USER\",\n \"snowflake.user.ext_authn.duo\": false,\n \"snowflake.user.has_password\": true,\n \"snowflake.user.id\": 512,\n \"snowflake.user.is_disabled\": false,\n \"snowflake.user.is_locked\": false,\n \"snowflake.user.last_success_login\": 1725288701845000000,\n \"snowflake.user.must_change_password\": false,\n \"snowflake.user.name\": \"TERRAFORM_USER\",\n \"snowflake.user.owner\": \"SECURITYADMIN\",\n \"snowflake.user.password_last_set_time\": 1720426231840000000\n}"} +{"LOGIN": "TEST_PIPELINE", "_MESSAGE": "User details for TEST_PIPELINE", "TIMESTAMP": 1760681133570755000, "DIMENSIONS": "{\n \"db.user\": \"TEST_PIPELINE\"\n}", "ATTRIBUTES": "{\n \"snowflake.user.created_on\": 1679517316002000000,\n \"snowflake.user.default.namespace\": \"TEST_DB.ETL\",\n \"snowflake.user.default.role\": \"TEST_PIPELINE_ROLE\",\n \"snowflake.user.default.secondary_role\": \"[]\",\n \"snowflake.user.default.warehouse\": \"TEST_ETL_PIPELINE_WH\",\n \"snowflake.user.display_name\": \"TEST_PIPELINE\",\n \"snowflake.user.ext_authn.duo\": false,\n \"snowflake.user.has_password\": true,\n \"snowflake.user.id\": 623,\n \"snowflake.user.is_disabled\": false,\n \"snowflake.user.is_locked\": false,\n \"snowflake.user.last_success_login\": 1743512296000000000,\n \"snowflake.user.must_change_password\": false,\n \"snowflake.user.name\": \"TEST_PIPELINE\",\n \"snowflake.user.owner\": \"SECURITYADMIN\",\n \"snowflake.user.password_last_set_time\": 1679517316030000000\n}"} diff --git a/test/test_data/users_roles_direct.ndjson b/test/test_data/users_roles_direct.ndjson new file mode 100644 index 00000000..e69de29b diff --git a/test/test_data/users_roles_direct_removed.ndjson b/test/test_data/users_roles_direct_removed.ndjson new file mode 100644 index 00000000..870bcb13 --- /dev/null +++ b/test/test_data/users_roles_direct_removed.ndjson @@ -0,0 +1,2 @@ +{"_MESSAGE": "User direct roles removed since 1970-01-01 00:00:00.000 Z", "DIMENSIONS": "{\n \"db.user\": \"DEV_SF_BI_MODELER\"\n}", "ATTRIBUTES": "{\n \"snowflake.user.roles.direct.removed\": \"SCRATCHPAD_ROLESCRATCHPAD_ROLESCRATCHPAD_ROLE\",\n \"snowflake.user.roles.direct.removed_on\": 1621598400000000000\n}"} +{"_MESSAGE": "User direct roles removed since 1970-01-01 00:00:00.000 Z", "DIMENSIONS": "{\n \"db.user\": \"DEVEL_PIPELINE\"\n}", "ATTRIBUTES": "{\n \"snowflake.user.roles.direct.removed\": \"DEVEL_PIPELINE_ROLE\",\n \"snowflake.user.roles.direct.removed_on\": 1622116800000000000\n}"} diff --git a/test/test_data/warehouses.ndjson b/test/test_data/warehouses.ndjson new file mode 100644 index 00000000..fcf1e9d6 --- /dev/null +++ b/test/test_data/warehouses.ndjson @@ -0,0 +1,2 @@ +{"START_TIME": 1760681131999454000, "IS_UNMONITORED": false, "_MESSAGE": "Warehouse details for COMPUTE_WH", "DIMENSIONS": "{\n \"snowflake.resource_monitor.name\": \"COMPUTE_RS\",\n \"snowflake.warehouse.name\": \"COMPUTE_WH\"\n}", "ATTRIBUTES": "{\n \"snowflake.credits.quota\": \"1.00\",\n \"snowflake.credits.quota.remaining\": \"0.94\",\n \"snowflake.credits.quota.used\": \"0.06\",\n \"snowflake.resource_monitor.frequency\": \"DAILY\",\n \"snowflake.resource_monitor.level\": \"WAREHOUSE\",\n \"snowflake.warehouse.execution_state\": \"SUSPENDED\",\n \"snowflake.warehouse.has_query_acceleration_enabled\": \"false\",\n \"snowflake.warehouse.is_auto_resume\": \"true\",\n \"snowflake.warehouse.is_auto_suspend\": 10,\n \"snowflake.warehouse.is_current\": \"N\",\n \"snowflake.warehouse.is_default\": \"N\",\n \"snowflake.warehouse.owner\": \"SYSADMIN\",\n \"snowflake.warehouse.owner.role_type\": \"ROLE\",\n \"snowflake.warehouse.scaling_policy\": \"STANDARD\",\n \"snowflake.warehouse.size\": \"X-Small\",\n \"snowflake.warehouse.type\": \"STANDARD\"\n}", "EVENT_TIMESTAMPS": "{\n \"snowflake.warehouse.created_on\": 1614961356578000000,\n \"snowflake.warehouse.resumed_on\": 1741738203231000000,\n \"snowflake.warehouse.updated_on\": 1741738203231000000\n}", "METRICS": "{\n \"snowflake.acceleration.scale_factor.max\": \"8\",\n \"snowflake.compute.available\": \"\",\n \"snowflake.compute.other\": \"\",\n \"snowflake.compute.provisioning\": \"\",\n \"snowflake.compute.quiescing\": \"\",\n \"snowflake.queries.queued\": 0,\n \"snowflake.queries.running\": 0,\n \"snowflake.warehouse.clusters.max\": 1,\n \"snowflake.warehouse.clusters.min\": 1,\n \"snowflake.warehouse.clusters.started\": 0\n}"} +{"START_TIME": 1760681132022405000, "IS_UNMONITORED": false, "_MESSAGE": "Warehouse details for DEVELCLONE_WH", "DIMENSIONS": "{\n \"snowflake.resource_monitor.name\": \"DEVELCLONE_RS\",\n \"snowflake.warehouse.name\": \"DEVELCLONE_WH\"\n}", "ATTRIBUTES": "{\n \"snowflake.credits.quota\": \"1.00\",\n \"snowflake.credits.quota.remaining\": \"1.00\",\n \"snowflake.credits.quota.used\": \"0.00\",\n \"snowflake.resource_monitor.frequency\": \"DAILY\",\n \"snowflake.resource_monitor.level\": \"WAREHOUSE\",\n \"snowflake.warehouse.execution_state\": \"SUSPENDED\",\n \"snowflake.warehouse.has_query_acceleration_enabled\": \"false\",\n \"snowflake.warehouse.is_auto_resume\": \"true\",\n \"snowflake.warehouse.is_auto_suspend\": 600,\n \"snowflake.warehouse.is_current\": \"N\",\n \"snowflake.warehouse.is_default\": \"N\",\n \"snowflake.warehouse.owner\": \"SYSADMIN\",\n \"snowflake.warehouse.owner.role_type\": \"ROLE\",\n \"snowflake.warehouse.scaling_policy\": \"ECONOMY\",\n \"snowflake.warehouse.size\": \"Small\",\n \"snowflake.warehouse.type\": \"STANDARD\"\n}", "EVENT_TIMESTAMPS": "{\n \"snowflake.warehouse.created_on\": 1623296570505000000,\n \"snowflake.warehouse.resumed_on\": 1723467521001000000,\n \"snowflake.warehouse.updated_on\": 1728174334355000000\n}", "METRICS": "{\n \"snowflake.acceleration.scale_factor.max\": \"8\",\n \"snowflake.compute.available\": \"\",\n \"snowflake.compute.other\": \"\",\n \"snowflake.compute.provisioning\": \"\",\n \"snowflake.compute.quiescing\": \"\",\n \"snowflake.queries.queued\": 0,\n \"snowflake.queries.running\": 0,\n \"snowflake.warehouse.clusters.max\": 1,\n \"snowflake.warehouse.clusters.min\": 1,\n \"snowflake.warehouse.clusters.started\": 0\n}"} diff --git a/test/test_data/wh_usage_events.ndjson b/test/test_data/wh_usage_events.ndjson new file mode 100644 index 00000000..e69de29b diff --git a/test/test_data/wh_usage_loads.ndjson b/test/test_data/wh_usage_loads.ndjson new file mode 100644 index 00000000..e69de29b diff --git a/test/test_data/wh_usage_metering.ndjson b/test/test_data/wh_usage_metering.ndjson new file mode 100644 index 00000000..e69de29b diff --git a/test/test_results/test_active_queries/biz_events.json b/test/test_results/test_active_queries/biz_events.json new file mode 100644 index 00000000..627bd959 --- /dev/null +++ b/test/test_results/test_active_queries/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_active_queries", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_active_queries", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_active_queries/logs.json b/test/test_results/test_active_queries/logs.json new file mode 100644 index 00000000..e367d024 --- /dev/null +++ b/test/test_results/test_active_queries/logs.json @@ -0,0 +1,52 @@ +[ + { + "content": "SQL query SUCCESS at DTAGENT_SKRUK_DB", + "snowflake.data.written_to_result": 1781, + "snowflake.rows.written_to_result": 60, + "snowflake.time.compilation": 127, + "snowflake.time.execution": 1, + "snowflake.time.total_elapsed": 128, + "db.operation.name": "SELECT", + "db.query.text": "SELECT * FROM CONFIG.CONFIGURATIONS", + "session.id": 18260702047616278, + "snowflake.query.hash": "84326d52fdc36120cb311c5f4d8d4d6b", + "snowflake.query.hash_version": 2, + "snowflake.query.id": "01bad30c-0413-9153-0040-e003054c7e46", + "snowflake.query.parametrized_hash": "84326d52fdc36120cb311c5f4d8d4d6b", + "snowflake.query.parametrized_hash_version": 1, + "snowflake.query.tag": "dt_snowagent:2025-03-06_10:20:48.705959", + "snowflake.schema.name": "APP", + "snowflake.warehouse.type": "STANDARD", + "db.namespace": "DTAGENT_SKRUK_DB", + "db.user": "SYSTEM", + "snowflake.query.execution_status": "SUCCESS", + "snowflake.role.name": "DTAGENT_SKRUK_ADMIN", + "snowflake.warehouse.name": "DTAGENT_SKRUK_WH", + "dsoa.run.context": "active_queries" + }, + { + "content": "SQL query SUCCESS at DTAGENT_SKRUK_DB", + "snowflake.data.written_to_result": 1781, + "snowflake.rows.written_to_result": 60, + "snowflake.time.compilation": 135, + "snowflake.time.execution": 2, + "snowflake.time.total_elapsed": 137, + "db.operation.name": "SELECT", + "db.query.text": "SELECT * FROM CONFIG.CONFIGURATIONS", + "session.id": 18260702047672238, + "snowflake.query.hash": "84326d52fdc36120cb311c5f4d8d4d6b", + "snowflake.query.hash_version": 2, + "snowflake.query.id": "01bad30c-0413-90fb-0040-e003054cc3da", + "snowflake.query.parametrized_hash": "84326d52fdc36120cb311c5f4d8d4d6b", + "snowflake.query.parametrized_hash_version": 1, + "snowflake.query.tag": "dt_snowagent:2025-03-06_10:20:48.723769", + "snowflake.schema.name": "APP", + "snowflake.warehouse.type": "STANDARD", + "db.namespace": "DTAGENT_SKRUK_DB", + "db.user": "SYSTEM", + "snowflake.query.execution_status": "SUCCESS", + "snowflake.role.name": "DTAGENT_SKRUK_ADMIN", + "snowflake.warehouse.name": "DTAGENT_SKRUK_WH", + "dsoa.run.context": "active_queries" + } +] \ No newline at end of file diff --git a/test/test_results/test_active_queries/metrics.txt b/test/test_results/test_active_queries/metrics.txt new file mode 100644 index 00000000..c0ae7658 --- /dev/null +++ b/test/test_results/test_active_queries/metrics.txt @@ -0,0 +1,13 @@ +snowflake.data.written_to_result,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_SKRUK_DB",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_SKRUK_ADMIN",snowflake.warehouse.name="DTAGENT_SKRUK_WH" 1781 +#snowflake.data.written_to_result gauge dt.meta.displayName="Bytes Written to Result",dt.meta.unit="bytes" +snowflake.rows.written_to_result,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_SKRUK_DB",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_SKRUK_ADMIN",snowflake.warehouse.name="DTAGENT_SKRUK_WH" 60 +#snowflake.rows.written_to_result gauge dt.meta.displayName="Rows Written to Result",dt.meta.unit="rows" +snowflake.time.compilation,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_SKRUK_DB",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_SKRUK_ADMIN",snowflake.warehouse.name="DTAGENT_SKRUK_WH" 127 +#snowflake.time.compilation gauge dt.meta.displayName="Query Compilation Time",dt.meta.unit="ms" +snowflake.time.execution,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_SKRUK_DB",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_SKRUK_ADMIN",snowflake.warehouse.name="DTAGENT_SKRUK_WH" 1 +#snowflake.time.execution gauge dt.meta.displayName="Execution Time",dt.meta.unit="ms" +snowflake.time.total_elapsed,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_SKRUK_DB",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_SKRUK_ADMIN",snowflake.warehouse.name="DTAGENT_SKRUK_WH" 128 +#snowflake.time.total_elapsed gauge dt.meta.displayName="Total Elapsed Time",dt.meta.unit="ms" +snowflake.time.compilation,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_SKRUK_DB",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_SKRUK_ADMIN",snowflake.warehouse.name="DTAGENT_SKRUK_WH" 135 +snowflake.time.execution,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_SKRUK_DB",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_SKRUK_ADMIN",snowflake.warehouse.name="DTAGENT_SKRUK_WH" 2 +snowflake.time.total_elapsed,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_SKRUK_DB",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_SKRUK_ADMIN",snowflake.warehouse.name="DTAGENT_SKRUK_WH" 137 \ No newline at end of file diff --git a/test/test_results/test_automode/000/biz_events.json b/test/test_results/test_automode/000/biz_events.json new file mode 100644 index 00000000..c667feed --- /dev/null +++ b/test/test_results/test_automode/000/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_automode/000/events.json b/test/test_results/test_automode/000/events.json new file mode 100644 index 00000000..f8ecdf79 --- /dev/null +++ b/test/test_results/test_automode/000/events.json @@ -0,0 +1,66 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "Table event snowflake.table.update.", + "properties": { + "snowflake.event.trigger": "snowflake.table.update", + "snowflake.table.update": 1736851468626000000, + "snowflake.data.rows": 6, + "snowflake.data.size": 1024, + "snowflake.table.time_since.last_update": 81983, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DEV_DB.PUBLIC.SALESMANAGERREGIONS", + "db.namespace": "DEV_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Table event snowflake.table.ddl.", + "properties": { + "snowflake.event.trigger": "snowflake.table.ddl", + "snowflake.table.ddl": 1733122324468000000, + "snowflake.table.update": 1741707972204000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 144135, + "snowflake.table.time_since.last_update": 1041, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Table event snowflake.table.update.", + "properties": { + "snowflake.event.trigger": "snowflake.table.update", + "snowflake.table.ddl": 1733122324468000000, + "snowflake.table.update": 1741707972204000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 144135, + "snowflake.table.time_since.last_update": 1041, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/000/logs.json b/test/test_results/test_automode/000/logs.json new file mode 100644 index 00000000..79d01dde --- /dev/null +++ b/test/test_results/test_automode/000/logs.json @@ -0,0 +1,32 @@ +[ + { + "content": "telemetry_sender", + "snowflake.table.update": 1736851468626000000, + "snowflake.data.rows": 6, + "snowflake.data.size": 1024, + "snowflake.table.time_since.last_update": 81983, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DEV_DB.PUBLIC.SALESMANAGERREGIONS", + "db.namespace": "DEV_DB", + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "telemetry_sender", + "snowflake.table.ddl": 1733122324468000000, + "snowflake.table.update": 1741707972204000000, + "snowflake.table.time_since.last_ddl": 144135, + "snowflake.table.time_since.last_update": 1041, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 2, + "log_lines": 2, + "metrics": 2, + "events": 3, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/000/metrics.txt b/test/test_results/test_automode/000/metrics.txt new file mode 100644 index 00000000..d36f1889 --- /dev/null +++ b/test/test_results/test_automode/000/metrics.txt @@ -0,0 +1,11 @@ +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALESMANAGERREGIONS",db.namespace="DEV_DB" 6 0 +#snowflake.data.rows gauge dt.meta.displayName="Row Count",dt.meta.unit="rows" +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALESMANAGERREGIONS",db.namespace="DEV_DB" 1024 0 +#snowflake.data.size gauge dt.meta.displayName="Table Size in Bytes",dt.meta.unit="bytes" +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALESMANAGERREGIONS",db.namespace="DEV_DB" 81983 0 +#snowflake.table.time_since.last_update gauge dt.meta.displayName="Time Since Last Update",dt.meta.unit="min" +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 0 +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 0 +snowflake.table.time_since.last_ddl,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 144135 0 +#snowflake.table.time_since.last_ddl gauge dt.meta.displayName="Time Since Last DDL",dt.meta.unit="min" +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 1041 0 \ No newline at end of file diff --git a/test/test_results/test_automode/001/biz_events.json b/test/test_results/test_automode/001/biz_events.json new file mode 100644 index 00000000..c667feed --- /dev/null +++ b/test/test_results/test_automode/001/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_automode/001/events.json b/test/test_results/test_automode/001/events.json new file mode 100644 index 00000000..f8ecdf79 --- /dev/null +++ b/test/test_results/test_automode/001/events.json @@ -0,0 +1,66 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "Table event snowflake.table.update.", + "properties": { + "snowflake.event.trigger": "snowflake.table.update", + "snowflake.table.update": 1736851468626000000, + "snowflake.data.rows": 6, + "snowflake.data.size": 1024, + "snowflake.table.time_since.last_update": 81983, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DEV_DB.PUBLIC.SALESMANAGERREGIONS", + "db.namespace": "DEV_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Table event snowflake.table.ddl.", + "properties": { + "snowflake.event.trigger": "snowflake.table.ddl", + "snowflake.table.ddl": 1733122324468000000, + "snowflake.table.update": 1741707972204000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 144135, + "snowflake.table.time_since.last_update": 1041, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Table event snowflake.table.update.", + "properties": { + "snowflake.event.trigger": "snowflake.table.update", + "snowflake.table.ddl": 1733122324468000000, + "snowflake.table.update": 1741707972204000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 144135, + "snowflake.table.time_since.last_update": 1041, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/001/logs.json b/test/test_results/test_automode/001/logs.json new file mode 100644 index 00000000..bf11243c --- /dev/null +++ b/test/test_results/test_automode/001/logs.json @@ -0,0 +1,31 @@ +[ + { + "content": "telemetry_sender", + "snowflake.table.update": 1736851468626000000, + "snowflake.data.rows": 6, + "snowflake.data.size": 1024, + "snowflake.table.time_since.last_update": 81983, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DEV_DB.PUBLIC.SALESMANAGERREGIONS", + "db.namespace": "DEV_DB", + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "telemetry_sender", + "snowflake.table.ddl": 1733122324468000000, + "snowflake.table.update": 1741707972204000000, + "snowflake.table.time_since.last_ddl": 144135, + "snowflake.table.time_since.last_update": 1041, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 2, + "log_lines": 2, + "events": 3, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/002/biz_events.json b/test/test_results/test_automode/002/biz_events.json new file mode 100644 index 00000000..c667feed --- /dev/null +++ b/test/test_results/test_automode/002/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_automode/002/logs.json b/test/test_results/test_automode/002/logs.json new file mode 100644 index 00000000..091177b6 --- /dev/null +++ b/test/test_results/test_automode/002/logs.json @@ -0,0 +1,31 @@ +[ + { + "content": "telemetry_sender", + "snowflake.table.update": 1736851468626000000, + "snowflake.data.rows": 6, + "snowflake.data.size": 1024, + "snowflake.table.time_since.last_update": 81983, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DEV_DB.PUBLIC.SALESMANAGERREGIONS", + "db.namespace": "DEV_DB", + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "telemetry_sender", + "snowflake.table.ddl": 1733122324468000000, + "snowflake.table.update": 1741707972204000000, + "snowflake.table.time_since.last_ddl": 144135, + "snowflake.table.time_since.last_update": 1041, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 2, + "log_lines": 2, + "metrics": 2, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/002/metrics.txt b/test/test_results/test_automode/002/metrics.txt new file mode 100644 index 00000000..d36f1889 --- /dev/null +++ b/test/test_results/test_automode/002/metrics.txt @@ -0,0 +1,11 @@ +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALESMANAGERREGIONS",db.namespace="DEV_DB" 6 0 +#snowflake.data.rows gauge dt.meta.displayName="Row Count",dt.meta.unit="rows" +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALESMANAGERREGIONS",db.namespace="DEV_DB" 1024 0 +#snowflake.data.size gauge dt.meta.displayName="Table Size in Bytes",dt.meta.unit="bytes" +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALESMANAGERREGIONS",db.namespace="DEV_DB" 81983 0 +#snowflake.table.time_since.last_update gauge dt.meta.displayName="Time Since Last Update",dt.meta.unit="min" +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 0 +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 0 +snowflake.table.time_since.last_ddl,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 144135 0 +#snowflake.table.time_since.last_ddl gauge dt.meta.displayName="Time Since Last DDL",dt.meta.unit="min" +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 1041 0 \ No newline at end of file diff --git a/test/test_results/test_automode/003/biz_events.json b/test/test_results/test_automode/003/biz_events.json new file mode 100644 index 00000000..c667feed --- /dev/null +++ b/test/test_results/test_automode/003/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_automode/003/events.json b/test/test_results/test_automode/003/events.json new file mode 100644 index 00000000..f8ecdf79 --- /dev/null +++ b/test/test_results/test_automode/003/events.json @@ -0,0 +1,66 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "Table event snowflake.table.update.", + "properties": { + "snowflake.event.trigger": "snowflake.table.update", + "snowflake.table.update": 1736851468626000000, + "snowflake.data.rows": 6, + "snowflake.data.size": 1024, + "snowflake.table.time_since.last_update": 81983, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DEV_DB.PUBLIC.SALESMANAGERREGIONS", + "db.namespace": "DEV_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Table event snowflake.table.ddl.", + "properties": { + "snowflake.event.trigger": "snowflake.table.ddl", + "snowflake.table.ddl": 1733122324468000000, + "snowflake.table.update": 1741707972204000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 144135, + "snowflake.table.time_since.last_update": 1041, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Table event snowflake.table.update.", + "properties": { + "snowflake.event.trigger": "snowflake.table.update", + "snowflake.table.ddl": 1733122324468000000, + "snowflake.table.update": 1741707972204000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 144135, + "snowflake.table.time_since.last_update": 1041, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/003/logs.json b/test/test_results/test_automode/003/logs.json new file mode 100644 index 00000000..49f83806 --- /dev/null +++ b/test/test_results/test_automode/003/logs.json @@ -0,0 +1,9 @@ +[ + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 2, + "metrics": 2, + "events": 3, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/003/metrics.txt b/test/test_results/test_automode/003/metrics.txt new file mode 100644 index 00000000..d36f1889 --- /dev/null +++ b/test/test_results/test_automode/003/metrics.txt @@ -0,0 +1,11 @@ +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALESMANAGERREGIONS",db.namespace="DEV_DB" 6 0 +#snowflake.data.rows gauge dt.meta.displayName="Row Count",dt.meta.unit="rows" +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALESMANAGERREGIONS",db.namespace="DEV_DB" 1024 0 +#snowflake.data.size gauge dt.meta.displayName="Table Size in Bytes",dt.meta.unit="bytes" +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALESMANAGERREGIONS",db.namespace="DEV_DB" 81983 0 +#snowflake.table.time_since.last_update gauge dt.meta.displayName="Time Since Last Update",dt.meta.unit="min" +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 0 +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 0 +snowflake.table.time_since.last_ddl,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 144135 0 +#snowflake.table.time_since.last_ddl gauge dt.meta.displayName="Time Since Last DDL",dt.meta.unit="min" +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 1041 0 \ No newline at end of file diff --git a/test/test_results/test_automode/004/biz_events.json b/test/test_results/test_automode/004/biz_events.json new file mode 100644 index 00000000..c667feed --- /dev/null +++ b/test/test_results/test_automode/004/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_automode/004/events.json b/test/test_results/test_automode/004/events.json new file mode 100644 index 00000000..caeead62 --- /dev/null +++ b/test/test_results/test_automode/004/events.json @@ -0,0 +1,46 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "Table event data_update.", + "properties": { + "snowflake.event.trigger": "data_update", + "data_update": 1731675389099000000, + "ddl": 1731436379508000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 4030, + "snowflake.table.time_since.last_update": 46, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Table event ddl.", + "properties": { + "snowflake.event.trigger": "ddl", + "data_update": 1731675389099000000, + "ddl": 1731436379508000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 4030, + "snowflake.table.time_since.last_update": 46, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/004/logs.json b/test/test_results/test_automode/004/logs.json new file mode 100644 index 00000000..5eac7c02 --- /dev/null +++ b/test/test_results/test_automode/004/logs.json @@ -0,0 +1,21 @@ +[ + { + "content": "telemetry_sender", + "data_update": 1731675389099000000, + "ddl": 1731436379508000000, + "snowflake.table.time_since.last_ddl": 4030, + "snowflake.table.time_since.last_update": 46, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 1, + "log_lines": 1, + "metrics": 1, + "events": 2, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/004/metrics.txt b/test/test_results/test_automode/004/metrics.txt new file mode 100644 index 00000000..531eddb7 --- /dev/null +++ b/test/test_results/test_automode/004/metrics.txt @@ -0,0 +1,8 @@ +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 0 +#snowflake.data.rows gauge dt.meta.displayName="Row Count",dt.meta.unit="rows" +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 0 +#snowflake.data.size gauge dt.meta.displayName="Table Size in Bytes",dt.meta.unit="bytes" +snowflake.table.time_since.last_ddl,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 4030 0 +#snowflake.table.time_since.last_ddl gauge dt.meta.displayName="Time Since Last DDL",dt.meta.unit="min" +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 46 0 +#snowflake.table.time_since.last_update gauge dt.meta.displayName="Time Since Last Update",dt.meta.unit="min" \ No newline at end of file diff --git a/test/test_results/test_automode/005/biz_events.json b/test/test_results/test_automode/005/biz_events.json new file mode 100644 index 00000000..c667feed --- /dev/null +++ b/test/test_results/test_automode/005/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_automode/005/events.json b/test/test_results/test_automode/005/events.json new file mode 100644 index 00000000..c07593e9 --- /dev/null +++ b/test/test_results/test_automode/005/events.json @@ -0,0 +1,66 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "Table event data_update.", + "properties": { + "snowflake.event.trigger": "data_update", + "data_update": 1731675389099000000, + "ddl": 1731436379508000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 4030, + "snowflake.table.time_since.last_update": 46, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Table event ddl.", + "properties": { + "snowflake.event.trigger": "ddl", + "data_update": 1731675389099000000, + "ddl": 1731436379508000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 4030, + "snowflake.table.time_since.last_update": 46, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Table event data_update.", + "properties": { + "snowflake.event.trigger": "data_update", + "data_update": 1707344711267000000, + "snowflake.data.rows": 2, + "snowflake.data.size": 2048, + "snowflake.table.time_since.last_update": 405557, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DEV_DB.PUBLIC.SALES", + "db.namespace": "DEV_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/005/logs.json b/test/test_results/test_automode/005/logs.json new file mode 100644 index 00000000..64841e3b --- /dev/null +++ b/test/test_results/test_automode/005/logs.json @@ -0,0 +1,32 @@ +[ + { + "content": "telemetry_sender", + "data_update": 1731675389099000000, + "ddl": 1731436379508000000, + "snowflake.table.time_since.last_ddl": 4030, + "snowflake.table.time_since.last_update": 46, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "telemetry_sender", + "data_update": 1707344711267000000, + "snowflake.data.rows": 2, + "snowflake.data.size": 2048, + "snowflake.table.time_since.last_update": 405557, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DEV_DB.PUBLIC.SALES", + "db.namespace": "DEV_DB", + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 2, + "log_lines": 2, + "metrics": 2, + "events": 3, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/005/metrics.txt b/test/test_results/test_automode/005/metrics.txt new file mode 100644 index 00000000..bd3031ac --- /dev/null +++ b/test/test_results/test_automode/005/metrics.txt @@ -0,0 +1,11 @@ +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 0 +#snowflake.data.rows gauge dt.meta.displayName="Row Count",dt.meta.unit="rows" +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 0 +#snowflake.data.size gauge dt.meta.displayName="Table Size in Bytes",dt.meta.unit="bytes" +snowflake.table.time_since.last_ddl,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 4030 0 +#snowflake.table.time_since.last_ddl gauge dt.meta.displayName="Time Since Last DDL",dt.meta.unit="min" +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 46 0 +#snowflake.table.time_since.last_update gauge dt.meta.displayName="Time Since Last Update",dt.meta.unit="min" +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALES",db.namespace="DEV_DB" 2 0 +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALES",db.namespace="DEV_DB" 2048 0 +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALES",db.namespace="DEV_DB" 405557 0 \ No newline at end of file diff --git a/test/test_results/test_automode/006/biz_events.json b/test/test_results/test_automode/006/biz_events.json new file mode 100644 index 00000000..c667feed --- /dev/null +++ b/test/test_results/test_automode/006/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_automode/006/events.json b/test/test_results/test_automode/006/events.json new file mode 100644 index 00000000..c07593e9 --- /dev/null +++ b/test/test_results/test_automode/006/events.json @@ -0,0 +1,66 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "Table event data_update.", + "properties": { + "snowflake.event.trigger": "data_update", + "data_update": 1731675389099000000, + "ddl": 1731436379508000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 4030, + "snowflake.table.time_since.last_update": 46, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Table event ddl.", + "properties": { + "snowflake.event.trigger": "ddl", + "data_update": 1731675389099000000, + "ddl": 1731436379508000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 4030, + "snowflake.table.time_since.last_update": 46, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Table event data_update.", + "properties": { + "snowflake.event.trigger": "data_update", + "data_update": 1707344711267000000, + "snowflake.data.rows": 2, + "snowflake.data.size": 2048, + "snowflake.table.time_since.last_update": 405557, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DEV_DB.PUBLIC.SALES", + "db.namespace": "DEV_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/006/logs.json b/test/test_results/test_automode/006/logs.json new file mode 100644 index 00000000..288d7e5a --- /dev/null +++ b/test/test_results/test_automode/006/logs.json @@ -0,0 +1,31 @@ +[ + { + "content": "telemetry_sender", + "data_update": 1731675389099000000, + "ddl": 1731436379508000000, + "snowflake.table.time_since.last_ddl": 4030, + "snowflake.table.time_since.last_update": 46, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "telemetry_sender", + "data_update": 1707344711267000000, + "snowflake.data.rows": 2, + "snowflake.data.size": 2048, + "snowflake.table.time_since.last_update": 405557, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DEV_DB.PUBLIC.SALES", + "db.namespace": "DEV_DB", + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 2, + "log_lines": 2, + "events": 3, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/007/biz_events.json b/test/test_results/test_automode/007/biz_events.json new file mode 100644 index 00000000..c667feed --- /dev/null +++ b/test/test_results/test_automode/007/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_automode/007/logs.json b/test/test_results/test_automode/007/logs.json new file mode 100644 index 00000000..42f20293 --- /dev/null +++ b/test/test_results/test_automode/007/logs.json @@ -0,0 +1,31 @@ +[ + { + "content": "telemetry_sender", + "data_update": 1731675389099000000, + "ddl": 1731436379508000000, + "snowflake.table.time_since.last_ddl": 4030, + "snowflake.table.time_since.last_update": 46, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "telemetry_sender", + "data_update": 1707344711267000000, + "snowflake.data.rows": 2, + "snowflake.data.size": 2048, + "snowflake.table.time_since.last_update": 405557, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DEV_DB.PUBLIC.SALES", + "db.namespace": "DEV_DB", + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 2, + "log_lines": 2, + "metrics": 2, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/007/metrics.txt b/test/test_results/test_automode/007/metrics.txt new file mode 100644 index 00000000..bd3031ac --- /dev/null +++ b/test/test_results/test_automode/007/metrics.txt @@ -0,0 +1,11 @@ +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 0 +#snowflake.data.rows gauge dt.meta.displayName="Row Count",dt.meta.unit="rows" +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 0 +#snowflake.data.size gauge dt.meta.displayName="Table Size in Bytes",dt.meta.unit="bytes" +snowflake.table.time_since.last_ddl,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 4030 0 +#snowflake.table.time_since.last_ddl gauge dt.meta.displayName="Time Since Last DDL",dt.meta.unit="min" +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 46 0 +#snowflake.table.time_since.last_update gauge dt.meta.displayName="Time Since Last Update",dt.meta.unit="min" +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALES",db.namespace="DEV_DB" 2 0 +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALES",db.namespace="DEV_DB" 2048 0 +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALES",db.namespace="DEV_DB" 405557 0 \ No newline at end of file diff --git a/test/test_results/test_automode/008/biz_events.json b/test/test_results/test_automode/008/biz_events.json new file mode 100644 index 00000000..c667feed --- /dev/null +++ b/test/test_results/test_automode/008/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_automode/008/events.json b/test/test_results/test_automode/008/events.json new file mode 100644 index 00000000..c07593e9 --- /dev/null +++ b/test/test_results/test_automode/008/events.json @@ -0,0 +1,66 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "Table event data_update.", + "properties": { + "snowflake.event.trigger": "data_update", + "data_update": 1731675389099000000, + "ddl": 1731436379508000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 4030, + "snowflake.table.time_since.last_update": 46, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Table event ddl.", + "properties": { + "snowflake.event.trigger": "ddl", + "data_update": 1731675389099000000, + "ddl": 1731436379508000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 4030, + "snowflake.table.time_since.last_update": 46, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Table event data_update.", + "properties": { + "snowflake.event.trigger": "data_update", + "data_update": 1707344711267000000, + "snowflake.data.rows": 2, + "snowflake.data.size": 2048, + "snowflake.table.time_since.last_update": 405557, + "snowflake.table_type": "BASE TABLE", + "db.collection.name": "DEV_DB.PUBLIC.SALES", + "db.namespace": "DEV_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/008/logs.json b/test/test_results/test_automode/008/logs.json new file mode 100644 index 00000000..49f83806 --- /dev/null +++ b/test/test_results/test_automode/008/logs.json @@ -0,0 +1,9 @@ +[ + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 2, + "metrics": 2, + "events": 3, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/008/metrics.txt b/test/test_results/test_automode/008/metrics.txt new file mode 100644 index 00000000..bd3031ac --- /dev/null +++ b/test/test_results/test_automode/008/metrics.txt @@ -0,0 +1,11 @@ +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 0 +#snowflake.data.rows gauge dt.meta.displayName="Row Count",dt.meta.unit="rows" +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 0 +#snowflake.data.size gauge dt.meta.displayName="Table Size in Bytes",dt.meta.unit="bytes" +snowflake.table.time_since.last_ddl,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 4030 0 +#snowflake.table.time_since.last_ddl gauge dt.meta.displayName="Time Since Last DDL",dt.meta.unit="min" +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 46 0 +#snowflake.table.time_since.last_update gauge dt.meta.displayName="Time Since Last Update",dt.meta.unit="min" +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALES",db.namespace="DEV_DB" 2 0 +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALES",db.namespace="DEV_DB" 2048 0 +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALES",db.namespace="DEV_DB" 405557 0 \ No newline at end of file diff --git a/test/test_results/test_automode/009/biz_events.json b/test/test_results/test_automode/009/biz_events.json new file mode 100644 index 00000000..c667feed --- /dev/null +++ b/test/test_results/test_automode/009/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_automode/009/logs.json b/test/test_results/test_automode/009/logs.json new file mode 100644 index 00000000..1261cfcd --- /dev/null +++ b/test/test_results/test_automode/009/logs.json @@ -0,0 +1,58 @@ +[ + { + "content": "This is a test object 1", + "status.code": "OK", + "value.int": 10, + "value.str": "test", + "value.bool": true, + "value.list": [ + 1, + 2, + 3 + ], + "value.dict": { + "k": "v", + "k2": 2 + }, + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "This is a test object 2", + "status.code": "OK", + "event.type": "PERFORMANCE_EVENT", + "value.int": 10000000, + "value.str": "test 2", + "value.list": [ + 1, + 2 + ], + "value.dict": { + "k": 1, + "k2": 2 + }, + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "Log entry sent with telemetry_sender", + "status.code": "ERROR", + "event.type": "ERROR_EVENT", + "test.message": "This is a test object 3", + "value.int": -10, + "value.str": "error test", + "value.list": [ + 1, + 3 + ], + "value.dict": { + "k": false, + "k2": true + }, + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 3, + "log_lines": 3, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/010/biz_events.json b/test/test_results/test_automode/010/biz_events.json new file mode 100644 index 00000000..0e79047f --- /dev/null +++ b/test/test_results/test_automode/010/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/010/events.json b/test/test_results/test_automode/010/events.json new file mode 100644 index 00000000..96880342 --- /dev/null +++ b/test/test_results/test_automode/010/events.json @@ -0,0 +1,58 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "This is a test object 1", + "properties": { + "status.code": "OK", + "value.int": 10, + "value.str": "test", + "value.bool": true, + "value.list": "[1, \"2\", 3]", + "value.dict": "{\"k\": \"v\", \"k2\": 2}", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "PERFORMANCE_EVENT", + "title": "This is a test object 2", + "properties": { + "status.code": "OK", + "event.type": "PERFORMANCE_EVENT", + "value.int": 10000000, + "value.str": "test 2", + "value.bool": false, + "value.list": "[\"1\", \"2\"]", + "value.dict": "{\"k\": 1, \"k2\": 2}", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "ERROR_EVENT", + "title": "Event sent with telemetry_sender", + "properties": { + "status.code": "ERROR", + "event.type": "ERROR_EVENT", + "test.message": "This is a test object 3", + "value.int": -10, + "value.str": "error test", + "value.list": "[1, 3]", + "value.dict": "{\"k\": false, \"k2\": true}", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/010/logs.json b/test/test_results/test_automode/010/logs.json new file mode 100644 index 00000000..1212c8f3 --- /dev/null +++ b/test/test_results/test_automode/010/logs.json @@ -0,0 +1,8 @@ +[ + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 3, + "events": 3, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/011/biz_events.json b/test/test_results/test_automode/011/biz_events.json new file mode 100644 index 00000000..73369494 --- /dev/null +++ b/test/test_results/test_automode/011/biz_events.json @@ -0,0 +1,125 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "CUSTOM_INFO", + "data": { + "status.code": "OK", + "_message": "This is a test object 1", + "value.int": 10, + "value.str": "test", + "value.bool": true, + "value.list": [ + 1, + 2, + 3 + ], + "value.dict": { + "k": "v", + "k2": 2 + }, + "app.bundle": "telemetry_sender", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "PERFORMANCE_EVENT", + "data": { + "status.code": "OK", + "_message": "This is a test object 2", + "event.type": "PERFORMANCE_EVENT", + "value.int": 10000000, + "value.str": "test 2", + "value.bool": false, + "value.list": [ + 1, + 2 + ], + "value.dict": { + "k": 1, + "k2": 2 + }, + "app.bundle": "telemetry_sender", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "ERROR_EVENT", + "data": { + "status.code": "ERROR", + "test.message": "This is a test object 3", + "event.type": "ERROR_EVENT", + "value.int": -10, + "value.str": "error test", + "value.bool": null, + "value.list": [ + 1, + 3 + ], + "value.dict": { + "k": false, + "k2": true + }, + "app.bundle": "telemetry_sender", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/011/logs.json b/test/test_results/test_automode/011/logs.json new file mode 100644 index 00000000..a161081c --- /dev/null +++ b/test/test_results/test_automode/011/logs.json @@ -0,0 +1,8 @@ +[ + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 3, + "biz_events": 3, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/012/biz_events.json b/test/test_results/test_automode/012/biz_events.json new file mode 100644 index 00000000..7a431436 --- /dev/null +++ b/test/test_results/test_automode/012/biz_events.json @@ -0,0 +1,125 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "CUSTOM_INFO", + "data": { + "status.code": "OK", + "_message": "This is a test object 1", + "value.int": 10, + "value.str": "test", + "value.bool": true, + "value.list": [ + 1, + 2, + 3 + ], + "value.dict": { + "k": "v", + "k2": 2 + }, + "app.bundle": "telemetry_sender", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "PERFORMANCE_EVENT", + "data": { + "status.code": "OK", + "_message": "This is a test object 2", + "event.type": "PERFORMANCE_EVENT", + "value.int": 10000000, + "value.str": "test 2", + "value.bool": false, + "value.list": [ + 1, + 2 + ], + "value.dict": { + "k": 1, + "k2": 2 + }, + "app.bundle": "telemetry_sender", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "ERROR_EVENT", + "data": { + "status.code": "ERROR", + "event.type": "ERROR_EVENT", + "test.message": "This is a test object 3", + "value.int": -10, + "value.str": "error test", + "value.bool": null, + "value.list": [ + 1, + 3 + ], + "value.dict": { + "k": false, + "k2": true + }, + "app.bundle": "telemetry_sender", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/012/events.json b/test/test_results/test_automode/012/events.json new file mode 100644 index 00000000..96880342 --- /dev/null +++ b/test/test_results/test_automode/012/events.json @@ -0,0 +1,58 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "This is a test object 1", + "properties": { + "status.code": "OK", + "value.int": 10, + "value.str": "test", + "value.bool": true, + "value.list": "[1, \"2\", 3]", + "value.dict": "{\"k\": \"v\", \"k2\": 2}", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "PERFORMANCE_EVENT", + "title": "This is a test object 2", + "properties": { + "status.code": "OK", + "event.type": "PERFORMANCE_EVENT", + "value.int": 10000000, + "value.str": "test 2", + "value.bool": false, + "value.list": "[\"1\", \"2\"]", + "value.dict": "{\"k\": 1, \"k2\": 2}", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "eventType": "ERROR_EVENT", + "title": "Event sent with telemetry_sender", + "properties": { + "status.code": "ERROR", + "event.type": "ERROR_EVENT", + "test.message": "This is a test object 3", + "value.int": -10, + "value.str": "error test", + "value.list": "[1, 3]", + "value.dict": "{\"k\": false, \"k2\": true}", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/012/logs.json b/test/test_results/test_automode/012/logs.json new file mode 100644 index 00000000..6f5f02dd --- /dev/null +++ b/test/test_results/test_automode/012/logs.json @@ -0,0 +1,60 @@ +[ + { + "content": "This is a test object 1", + "status.code": "OK", + "value.int": 10, + "value.str": "test", + "value.bool": true, + "value.list": [ + 1, + 2, + 3 + ], + "value.dict": { + "k": "v", + "k2": 2 + }, + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "This is a test object 2", + "status.code": "OK", + "event.type": "PERFORMANCE_EVENT", + "value.int": 10000000, + "value.str": "test 2", + "value.list": [ + 1, + 2 + ], + "value.dict": { + "k": 1, + "k2": 2 + }, + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "Log entry sent with telemetry_sender", + "status.code": "ERROR", + "event.type": "ERROR_EVENT", + "test.message": "This is a test object 3", + "value.int": -10, + "value.str": "error test", + "value.list": [ + 1, + 3 + ], + "value.dict": { + "k": false, + "k2": true + }, + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 3, + "log_lines": 3, + "events": 3, + "biz_events": 3, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/013/biz_events.json b/test/test_results/test_automode/013/biz_events.json new file mode 100644 index 00000000..d53e8e89 --- /dev/null +++ b/test/test_results/test_automode/013/biz_events.json @@ -0,0 +1,67 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "CUSTOM_INFO", + "data": { + "status.code": "OK", + "_message": "This is a test object 1", + "value.int": 10, + "value.str": "test", + "value.bool": true, + "value.list": [ + 1, + 2, + 3 + ], + "value.dict": { + "k": "v", + "k2": 2 + }, + "app.bundle": "telemetry_sender", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_automode/013/events.json b/test/test_results/test_automode/013/events.json new file mode 100644 index 00000000..d34456c4 --- /dev/null +++ b/test/test_results/test_automode/013/events.json @@ -0,0 +1,20 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "This is a test object 1", + "properties": { + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "status.code": "OK", + "telemetry.exporter.name": "dynatrace.snowagent", + "value.bool": true, + "value.dict": "{\"k\": \"v\", \"k2\": 2}", + "value.int": 10, + "value.list": "[1, \"2\", 3]", + "value.str": "test", + "dsoa.run.context": "telemetry_sender" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/013/logs.json b/test/test_results/test_automode/013/logs.json new file mode 100644 index 00000000..ea2783f8 --- /dev/null +++ b/test/test_results/test_automode/013/logs.json @@ -0,0 +1,27 @@ +[ + { + "content": "This is a test object 1", + "status.code": "OK", + "value.int": 10, + "value.str": "test", + "value.bool": true, + "value.list": [ + 1, + 2, + 3 + ], + "value.dict": { + "k": "v", + "k2": 2 + }, + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 1, + "log_lines": 1, + "events": 1, + "biz_events": 1, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/014/biz_events.json b/test/test_results/test_automode/014/biz_events.json new file mode 100644 index 00000000..d53e8e89 --- /dev/null +++ b/test/test_results/test_automode/014/biz_events.json @@ -0,0 +1,67 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "CUSTOM_INFO", + "data": { + "status.code": "OK", + "_message": "This is a test object 1", + "value.int": 10, + "value.str": "test", + "value.bool": true, + "value.list": [ + 1, + 2, + 3 + ], + "value.dict": { + "k": "v", + "k2": 2 + }, + "app.bundle": "telemetry_sender", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_automode/014/events.json b/test/test_results/test_automode/014/events.json new file mode 100644 index 00000000..d34456c4 --- /dev/null +++ b/test/test_results/test_automode/014/events.json @@ -0,0 +1,20 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "This is a test object 1", + "properties": { + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "status.code": "OK", + "telemetry.exporter.name": "dynatrace.snowagent", + "value.bool": true, + "value.dict": "{\"k\": \"v\", \"k2\": 2}", + "value.int": 10, + "value.list": "[1, \"2\", 3]", + "value.str": "test", + "dsoa.run.context": "telemetry_sender" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_automode/014/logs.json b/test/test_results/test_automode/014/logs.json new file mode 100644 index 00000000..ea2783f8 --- /dev/null +++ b/test/test_results/test_automode/014/logs.json @@ -0,0 +1,27 @@ +[ + { + "content": "This is a test object 1", + "status.code": "OK", + "value.int": 10, + "value.str": "test", + "value.bool": true, + "value.list": [ + 1, + 2, + 3 + ], + "value.dict": { + "k": "v", + "k2": 2 + }, + "dsoa.run.context": "telemetry_sender" + }, + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 1, + "log_lines": 1, + "events": 1, + "biz_events": 1, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_budget/biz_events.json b/test/test_results/test_budget/biz_events.json new file mode 100644 index 00000000..b1b87120 --- /dev/null +++ b/test/test_results/test_budget/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_budget", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_budget", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_budget/logs.json b/test/test_results/test_budget/logs.json new file mode 100644 index 00000000..b9300167 --- /dev/null +++ b/test/test_results/test_budget/logs.json @@ -0,0 +1,23 @@ +[ + { + "content": "Budget details for DTAGENT_BUDGET", + "snowflake.budget.created_on": 1723624213723000000, + "snowflake.credits.limit": 10, + "snowflake.budget.owner": "ACCOUNTADMIN", + "snowflake.budget.owner.role_type": "ROLE", + "snowflake.budget.resource": [ + { + "snowflake.budget.resource.domain": "DATABASE", + "snowflake.budget.resource.name": "DTAGENT_DB" + }, + { + "snowflake.budget.resource.domain": "WAREHOUSE", + "snowflake.budget.resource.name": "DTAGENT_WH" + } + ], + "db.namespace": "DTAGENT_DB", + "snowflake.budget.name": "DTAGENT_BUDGET", + "snowflake.schema.name": "APP", + "dsoa.run.context": "budgets" + } +] \ No newline at end of file diff --git a/test/test_results/test_budget/metrics.txt b/test/test_results/test_budget/metrics.txt new file mode 100644 index 00000000..7fca07e7 --- /dev/null +++ b/test/test_results/test_budget/metrics.txt @@ -0,0 +1,2 @@ +snowflake.credits.limit,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",snowflake.budget.name="DTAGENT_BUDGET",snowflake.schema.name="APP" 10 +#snowflake.credits.limit gauge dt.meta.displayName="Budget Spending Limit",dt.meta.unit="credits" \ No newline at end of file diff --git a/test/test_results/test_connector_bizevents/biz_events.json b/test/test_results/test_connector_bizevents/biz_events.json new file mode 100644 index 00000000..46beab01 --- /dev/null +++ b/test/test_results/test_connector_bizevents/biz_events.json @@ -0,0 +1,56 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "CUSTOM_INFO", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_events", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "telemetry_sender", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_connector_bizevents/logs.json b/test/test_results/test_connector_bizevents/logs.json new file mode 100644 index 00000000..655b14c0 --- /dev/null +++ b/test/test_results/test_connector_bizevents/logs.json @@ -0,0 +1,8 @@ +[ + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 1, + "biz_events": 1, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_coonector_bizevents/biz_events.json b/test/test_results/test_coonector_bizevents/biz_events.json new file mode 100644 index 00000000..cde1595c --- /dev/null +++ b/test/test_results/test_coonector_bizevents/biz_events.json @@ -0,0 +1,56 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "CUSTOM_INFO", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_events", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "telemetry_sender", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "telemetry_sender" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "telemetry_sender", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_coonector_bizevents/logs.json b/test/test_results/test_coonector_bizevents/logs.json new file mode 100644 index 00000000..655b14c0 --- /dev/null +++ b/test/test_results/test_coonector_bizevents/logs.json @@ -0,0 +1,8 @@ +[ + { + "content": "New entry to STATUS.LOG_PROCESSED_MEASUREMENTS from telemetry_sender", + "entries": 1, + "biz_events": 1, + "dsoa.run.context": "self_monitoring" + } +] \ No newline at end of file diff --git a/test/test_results/test_data_schemas/biz_events.json b/test/test_results/test_data_schemas/biz_events.json new file mode 100644 index 00000000..9a0ed7e0 --- /dev/null +++ b/test/test_results/test_data_schemas/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_data_schemas", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_data_schemas", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_data_schemas/events.json b/test/test_results/test_data_schemas/events.json new file mode 100644 index 00000000..ef82a3ae --- /dev/null +++ b/test/test_results/test_data_schemas/events.json @@ -0,0 +1,43 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "Objects accessed by query 01b165f1-0604-1812-0040-e0030291d142 run by STEFAN.SCHWEIGER", + "properties": { + "snowflake.object.event": "snowflake.object.ddl", + "snowflake.query.start_time": 1704191128131000000, + "snowflake.query.id": "01b165f1-0604-1812-0040-e0030291d142", + "snowflake.query.object.modified_by_ddl.domain": "Schema", + "snowflake.query.object.modified_by_ddl.id": 1154, + "snowflake.query.object.modified_by_ddl.name": "CHARGEBACK_HRC_TEST_DB.LI_TEST", + "snowflake.query.object.modified_by_ddl.operation_type": "CREATE", + "snowflake.query.user": "STEFAN.SCHWEIGER", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "data_schemas" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Objects accessed by query 01b165fb-0604-1945-0040-e0030291c3be run by STEFAN.SCHWEIGER", + "properties": { + "snowflake.object.event": "snowflake.object.ddl", + "snowflake.query.start_time": 1704191707101000000, + "snowflake.query.id": "01b165fb-0604-1945-0040-e0030291c3be", + "snowflake.query.object.modified_by_ddl.domain": "Table", + "snowflake.query.object.modified_by_ddl.id": 719874, + "snowflake.query.object.modified_by_ddl.name": "CHARGEBACK_HRC_TEST_DB.LI_TEST.DAILY_COSTS", + "snowflake.query.object.modified_by_ddl.operation_type": "CREATE", + "snowflake.query.object.modified_by_ddl.properties": "{\"columns\": {\"BOOKING_DATE\": {\"objectId\": {\"value\": 1680388}, \"subOperationType\": \"ADD\"}, \"CAPABILITY_ID\": {\"objectId\": {\"value\": 1680391}, \"subOperationType\": \"ADD\"}, \"COSTS\": {\"objectId\": {\"value\": 1680392}, \"subOperationType\": \"ADD\"}, \"ENVIRONMENT_ID\": {\"objectId\": {\"value\": 1680390}, \"subOperationType\": \"ADD\"}, \"SUBSCRIPTION_UUID\": {\"objectId\": {\"value\": 1680386}, \"subOperationType\": \"ADD\"}, \"UPDATED_AT\": {\"objectId\": {\"value\": 1680389}, \"subOperationType\": \"ADD\"}, \"USAGE_DATE\": {\"objectId\": {\"value\": 1680387}, \"subOperationType\": \"ADD\"}}, \"creationMode\": {\"value\": \"CREATE\"}}", + "snowflake.query.user": "STEFAN.SCHWEIGER", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "data_schemas" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_data_volume/biz_events.json b/test/test_results/test_data_volume/biz_events.json new file mode 100644 index 00000000..d3ae90aa --- /dev/null +++ b/test/test_results/test_data_volume/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_data_volume", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_data_volume", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_data_volume/metrics.txt b/test/test_results/test_data_volume/metrics.txt new file mode 100644 index 00000000..92f55991 --- /dev/null +++ b/test/test_results/test_data_volume/metrics.txt @@ -0,0 +1,11 @@ +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALESMANAGERREGIONS",db.namespace="DEV_DB" 6 +#snowflake.data.rows gauge dt.meta.displayName="Row Count",dt.meta.unit="rows" +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALESMANAGERREGIONS",db.namespace="DEV_DB" 1024 +#snowflake.data.size gauge dt.meta.displayName="Table Size in Bytes",dt.meta.unit="bytes" +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DEV_DB.PUBLIC.SALESMANAGERREGIONS",db.namespace="DEV_DB" 81983 +#snowflake.table.time_since.last_update gauge dt.meta.displayName="Time Since Last Update",dt.meta.unit="min" +snowflake.data.rows,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 +snowflake.data.size,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 0 +snowflake.table.time_since.last_ddl,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 144135 +#snowflake.table.time_since.last_ddl gauge dt.meta.displayName="Time Since Last DDL",dt.meta.unit="min" +snowflake.table.time_since.last_update,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE",db.namespace="DTAGENT_DB" 1041 \ No newline at end of file diff --git a/test/test_results/test_dtagent_bizevents/biz_events.json b/test/test_results/test_dtagent_bizevents/biz_events.json new file mode 100644 index 00000000..b8bd3a72 --- /dev/null +++ b/test/test_results/test_dtagent_bizevents/biz_events.json @@ -0,0 +1,20 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_events", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_dynamic_tables/biz_events.json b/test/test_results/test_dynamic_tables/biz_events.json new file mode 100644 index 00000000..77d7053d --- /dev/null +++ b/test/test_results/test_dynamic_tables/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_dynamic_tables", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_dynamic_tables", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_dynamic_tables/logs.json b/test/test_results/test_dynamic_tables/logs.json new file mode 100644 index 00000000..34477e1d --- /dev/null +++ b/test/test_results/test_dynamic_tables/logs.json @@ -0,0 +1,82 @@ +[ + { + "content": "dynamic_tables", + "snowflake.table.dynamic.lag.max": 68, + "snowflake.table.dynamic.lag.mean": 25, + "snowflake.table.dynamic.lag.target.time_above": 13, + "snowflake.table.dynamic.lag.target.value": 60, + "snowflake.table.dynamic.lag.target.within_ratio": 1, + "snowflake.table.dynamic.lag.target.type": "USER_DEFINED", + "snowflake.table.dynamic.latest.code": "SUCCESS", + "snowflake.table.dynamic.latest.data_timestamp": "2025-03-12 08:58:41.695 Z", + "snowflake.table.dynamic.latest.state": "SUCCEEDED", + "snowflake.table.dynamic.scheduling.state": "ACTIVE", + "db.collection.name": "EMPLOYEE_DET", + "db.namespace": "DYNAMIC_TABLE_DB", + "snowflake.schema.name": "DYNAMIC_TABLE_SCH", + "snowflake.table.full_name": "DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET", + "dsoa.run.context": "dynamic_tables" + }, + { + "content": "dynamic_table_refresh_history", + "snowflake.query.id": "01baf403-0413-a61d-0040-e0030579d1e2", + "snowflake.table.dynamic.graph.valid_from": "2024-11-20 19:53:47.448 Z", + "snowflake.table.dynamic.refresh.action": "NO_DATA", + "snowflake.table.dynamic.refresh.code": "SUCCESS", + "snowflake.table.dynamic.refresh.completion_target": "2025-03-12 06:59:41.695 Z", + "snowflake.table.dynamic.refresh.data_timestamp": "2025-03-12 06:59:29.695 Z", + "snowflake.table.dynamic.refresh.end": "2025-03-12 06:59:31.035 Z", + "snowflake.table.dynamic.refresh.start": "2025-03-12 06:59:30.668 Z", + "snowflake.table.dynamic.refresh.state": "SUCCEEDED", + "snowflake.table.dynamic.refresh.trigger": "SCHEDULED", + "db.collection.name": "EMPLOYEE_DET", + "db.namespace": "DYNAMIC_TABLE_DB", + "snowflake.schema.name": "DYNAMIC_TABLE_SCH", + "snowflake.table.full_name": "DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET", + "dsoa.run.context": "dynamic_table_refresh_history" + }, + { + "content": "dynamic_table_refresh_history", + "snowflake.query.id": "01baf404-0413-a501-0040-e003057a220e", + "snowflake.table.dynamic.graph.valid_from": "2024-11-20 19:53:47.448 Z", + "snowflake.table.dynamic.refresh.action": "NO_DATA", + "snowflake.table.dynamic.refresh.code": "SUCCESS", + "snowflake.table.dynamic.refresh.completion_target": "2025-03-12 07:00:29.695 Z", + "snowflake.table.dynamic.refresh.data_timestamp": "2025-03-12 07:00:17.695 Z", + "snowflake.table.dynamic.refresh.end": "2025-03-12 07:00:19.468 Z", + "snowflake.table.dynamic.refresh.start": "2025-03-12 07:00:19.058 Z", + "snowflake.table.dynamic.refresh.state": "SUCCEEDED", + "snowflake.table.dynamic.refresh.trigger": "SCHEDULED", + "db.collection.name": "EMPLOYEE_DET", + "db.namespace": "DYNAMIC_TABLE_DB", + "snowflake.schema.name": "DYNAMIC_TABLE_SCH", + "snowflake.table.full_name": "DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET", + "dsoa.run.context": "dynamic_table_refresh_history" + }, + { + "content": "dynamic_table_graph_history", + "snowflake.table.dynamic.graph.valid_from": 1732132427448000000, + "snowflake.table.dynamic.lag.target.value": 60, + "db.query.text": "SELECT A.EMP_ID,A.EMP_NAME,A.EMP_ADDRESS, B.SKILL_ID,B.SKILL_NAME,B.SKILL_LEVEL\n FROM EMPLOYEE A, EMPLOYEE_SKILL B\n WHERE A.EMP_ID=B.EMP_ID\n ORDER BY B.SKILL_ID ;", + "snowflake.table.dynamic.graph.alter_trigger": [ + "CREATE_DYNAMIC_TABLE" + ], + "snowflake.table.dynamic.graph.inputs": [ + { + "kind": "TABLE", + "name": "DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE" + }, + { + "kind": "TABLE", + "name": "DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_SKILL" + } + ], + "snowflake.table.dynamic.lag.target.type": "USER_DEFINED", + "snowflake.table.dynamic.scheduling.state": "ACTIVE", + "db.collection.name": "EMPLOYEE_DET", + "db.namespace": "DYNAMIC_TABLE_DB", + "snowflake.schema.name": "DYNAMIC_TABLE_SCH", + "snowflake.table.full_name": "DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET", + "dsoa.run.context": "dynamic_table_graph_history" + } +] \ No newline at end of file diff --git a/test/test_results/test_dynamic_tables/metrics.txt b/test/test_results/test_dynamic_tables/metrics.txt new file mode 100644 index 00000000..7e884ecc --- /dev/null +++ b/test/test_results/test_dynamic_tables/metrics.txt @@ -0,0 +1,20 @@ +snowflake.table.dynamic.lag.max,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="EMPLOYEE_DET",db.namespace="DYNAMIC_TABLE_DB",snowflake.schema.name="DYNAMIC_TABLE_SCH",snowflake.table.full_name="DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET" 68 +#snowflake.table.dynamic.lag.max gauge dt.meta.displayName="Maximum Lag Time",dt.meta.unit="seconds" +snowflake.table.dynamic.lag.mean,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="EMPLOYEE_DET",db.namespace="DYNAMIC_TABLE_DB",snowflake.schema.name="DYNAMIC_TABLE_SCH",snowflake.table.full_name="DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET" 25 +#snowflake.table.dynamic.lag.mean gauge dt.meta.displayName="Mean Lag Time",dt.meta.unit="seconds" +snowflake.table.dynamic.lag.target.time_above,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="EMPLOYEE_DET",db.namespace="DYNAMIC_TABLE_DB",snowflake.schema.name="DYNAMIC_TABLE_SCH",snowflake.table.full_name="DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET" 13 +#snowflake.table.dynamic.lag.target.time_above gauge dt.meta.displayName="Time Above Target Lag",dt.meta.unit="seconds" +snowflake.table.dynamic.lag.target.value,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="EMPLOYEE_DET",db.namespace="DYNAMIC_TABLE_DB",snowflake.schema.name="DYNAMIC_TABLE_SCH",snowflake.table.full_name="DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET" 60 +#snowflake.table.dynamic.lag.target.value gauge dt.meta.displayName="Target Lag Time",dt.meta.unit="seconds" +snowflake.table.dynamic.lag.target.within_ratio,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="EMPLOYEE_DET",db.namespace="DYNAMIC_TABLE_DB",snowflake.schema.name="DYNAMIC_TABLE_SCH",snowflake.table.full_name="DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET" 1 +#snowflake.table.dynamic.lag.target.within_ratio gauge dt.meta.displayName="Time Within Target Lag Ratio",dt.meta.unit="ratio" +snowflake.partitions.added,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="EMPLOYEE_DET",db.namespace="DYNAMIC_TABLE_DB",snowflake.schema.name="DYNAMIC_TABLE_SCH",snowflake.table.full_name="DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET" 0 +#snowflake.partitions.added gauge dt.meta.displayName="Partitions Added",dt.meta.unit="partitions" +snowflake.partitions.removed,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="EMPLOYEE_DET",db.namespace="DYNAMIC_TABLE_DB",snowflake.schema.name="DYNAMIC_TABLE_SCH",snowflake.table.full_name="DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET" 0 +#snowflake.partitions.removed gauge dt.meta.displayName="Partitions Removed",dt.meta.unit="partitions" +snowflake.rows.copied,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="EMPLOYEE_DET",db.namespace="DYNAMIC_TABLE_DB",snowflake.schema.name="DYNAMIC_TABLE_SCH",snowflake.table.full_name="DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET" 0 +#snowflake.rows.copied gauge dt.meta.displayName="Rows Copied",dt.meta.unit="rows" +snowflake.rows.deleted,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="EMPLOYEE_DET",db.namespace="DYNAMIC_TABLE_DB",snowflake.schema.name="DYNAMIC_TABLE_SCH",snowflake.table.full_name="DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET" 0 +#snowflake.rows.deleted gauge dt.meta.displayName="Rows Deleted",dt.meta.unit="rows" +snowflake.rows.inserted,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="EMPLOYEE_DET",db.namespace="DYNAMIC_TABLE_DB",snowflake.schema.name="DYNAMIC_TABLE_SCH",snowflake.table.full_name="DYNAMIC_TABLE_DB.DYNAMIC_TABLE_SCH.EMPLOYEE_DET" 0 +#snowflake.rows.inserted gauge dt.meta.displayName="Rows Inserted",dt.meta.unit="rows" \ No newline at end of file diff --git a/test/test_results/test_event_log/biz_events.json b/test/test_results/test_event_log/biz_events.json new file mode 100644 index 00000000..295362d6 --- /dev/null +++ b/test/test_results/test_event_log/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_event_log", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_event_log", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_event_log/logs.json b/test/test_results/test_event_log/logs.json new file mode 100644 index 00000000..3c007891 --- /dev/null +++ b/test/test_results/test_event_log/logs.json @@ -0,0 +1,184 @@ +[ + { + "content": "event_log_metrics", + "process.cpu.utilization": { + "gauge": 0 + }, + "process.memory.usage": { + "sum": 0 + }, + "db.namespace": "DTAGENT_SKRUK_DB", + "db.user": "SYSTEM", + "snow.database.id": 632, + "snow.database.name": "DTAGENT_SKRUK_DB", + "snow.executable.id": 51528, + "snow.executable.name": "DTAGENT(SOURCES ARRAY):OBJECT", + "snow.executable.runtime.version": 3.11, + "snow.executable.type": "PROCEDURE", + "snow.owner.id": 567463, + "snow.owner.name": "DTAGENT_SKRUK_ADMIN", + "snow.query.id": "01ba3bba-0412-e356-0051-0c031e222a46", + "snow.schema.id": 6165, + "snow.schema.name": "APP", + "snow.session.id": 22812680207736954, + "snow.session.role.primary.id": 567463, + "snow.session.role.primary.name": "DTAGENT_SKRUK_ADMIN", + "snow.warehouse.id": 4649, + "snow.warehouse.name": "DTAGENT_SKRUK_WH", + "snowflake.query.id": "01ba3bba-0412-e356-0051-0c031e222a46", + "snowflake.role.name": "DTAGENT_SKRUK_ADMIN", + "snowflake.schema.name": "APP", + "snowflake.warehouse.name": "DTAGENT_SKRUK_WH", + "telemetry.sdk.language": "python", + "dsoa.run.context": "event_log_metrics" + }, + { + "content": "event_log_metrics", + "process.cpu.utilization": { + "gauge": 0 + }, + "process.memory.usage": { + "sum": 0 + }, + "db.namespace": "DTAGENT_SKRUK_DB", + "db.user": "SYSTEM", + "snow.database.id": 632, + "snow.database.name": "DTAGENT_SKRUK_DB", + "snow.executable.id": 51528, + "snow.executable.name": "DTAGENT(SOURCES ARRAY):OBJECT", + "snow.executable.runtime.version": 3.11, + "snow.executable.type": "PROCEDURE", + "snow.owner.id": 567463, + "snow.owner.name": "DTAGENT_SKRUK_ADMIN", + "snow.query.id": "01ba3bba-0412-e3aa-0051-0c031e22516a", + "snow.schema.id": 6165, + "snow.schema.name": "APP", + "snow.session.id": 22812680207694442, + "snow.session.role.primary.id": 567463, + "snow.session.role.primary.name": "DTAGENT_SKRUK_ADMIN", + "snow.warehouse.id": 4649, + "snow.warehouse.name": "DTAGENT_SKRUK_WH", + "snowflake.query.id": "01ba3bba-0412-e3aa-0051-0c031e22516a", + "snowflake.role.name": "DTAGENT_SKRUK_ADMIN", + "snowflake.schema.name": "APP", + "snowflake.warehouse.name": "DTAGENT_SKRUK_WH", + "telemetry.sdk.language": "python", + "dsoa.run.context": "event_log_metrics" + }, + { + "content": "Invalid type dict for attribute 'snowflake.query.operator.stats' value. Expected one of ['bool', 'str', 'bytes', 'int', 'float'] or a sequence of those types", + "db.user": "SYSTEM", + "snow.database.id": 621, + "snow.database.name": "DTAGENT_DB", + "snow.executable.id": 50838, + "snow.executable.name": "DTAGENT(SOURCES ARRAY):OBJECT", + "snow.executable.runtime.version": 3.1, + "snow.executable.type": "PROCEDURE", + "snow.owner.id": 566820, + "snow.owner.name": "DTAGENT_ADMIN", + "snow.query.id": "01ba3baf-0412-e3aa-0051-0c031e2209d2", + "snow.schema.id": 6140, + "snow.schema.name": "APP", + "snow.session.id": 22812680207694358, + "snow.session.role.primary.id": 566820, + "snow.session.role.primary.name": "DTAGENT_ADMIN", + "snow.warehouse.id": 4637, + "snow.warehouse.name": "DTAGENT_WH", + "telemetry.sdk.language": "python", + "code.filepath": "/usr/lib/python_udf/5dc6be55a3cd750f7a845533bacb523ed5bf419a303f987f5c6daae4105f654e/lib/python3.10/site-packages/opentelemetry/attributes/__init__.py", + "code.function": "_clean_attribute", + "code.lineno": 101, + "severity_text": "WARN", + "snowflake.event.scope.name": "opentelemetry.attributes", + "record_type": "LOG", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "event_log" + }, + { + "content": "UPDATE state.datasources SET last_transform = '2025-02-07 12:26:07.0', last_extract = '2025-02-07 12:26:07.0', last_extract_id = 1738922400000 WHERE datasource = 'Spine.UnassignedConsumption'", + "db.collection.name": "SPRINT_DB.STATE.DATASOURCES", + "db.namespace": "SPRINT_DB", + "db.operation.name": "UPDATE", + "db.query.text": "UPDATE state.datasources SET last_transform = '2025-02-07 12:26:07.0', last_extract = '2025-02-07 12:26:07.0', last_extract_id = 1738922400000 WHERE datasource = 'Spine.UnassignedConsumption'", + "db.snowflake.dbs": [ + "SPRINT_DB" + ], + "db.snowflake.tables": [ + "SPRINT_DB.STATE.DATASOURCES" + ], + "db.user": "SYSTEM", + "session.id": 22812680207694162, + "snowagent.run.context": "query_history", + "snowagent.run.id": "5c0188ef23e84fb99fd31ffddd8d0dcd", + "snowflake.cluster_number": 1, + "snowflake.credits.cloud_services": 4.7e-05, + "snowflake.data.scanned": 44032, + "snowflake.data.scanned_from_cache": 1, + "snowflake.data.written": 22016, + "snowflake.data.written_to_result": 29, + "snowflake.database.id": 12, + "snowflake.load.used": 100, + "snowflake.partitions.scanned": 1, + "snowflake.partitions.total": 1, + "snowflake.query.execution_status": "SUCCESS", + "snowflake.query.hash": "aa51eb519059545967e1ee3488f6b72d", + "snowflake.query.hash_version": 2, + "snowflake.query.id": "01ba3baa-0412-e34b-0051-0c031e22131e", + "snowflake.query.parametrized_hash": "f54058eaf4569b014a656c4ad646646a", + "snowflake.query.parametrized_hash_version": 1, + "snowflake.query.tag": { + "action": "ingest", + "js_id": 8277366, + "module": "consumption", + "start_ts": 1738931166455, + "task": "UnassignedConsumption" + }, + "snowflake.query.transaction_id": 1738931171652000000, + "snowflake.release_version": "9.1.18", + "snowflake.role.name": "SPRINT_PIPELINE_ROLE", + "snowflake.role.type": "ROLE", + "snowflake.rows.updated": 1, + "snowflake.rows.written_to_result": 1, + "snowflake.time.compilation": 151, + "snowflake.time.execution": 246, + "snowflake.time.total_elapsed": 397, + "snowflake.warehouse.cluster.number": 1, + "snowflake.warehouse.id": 1249, + "snowflake.warehouse.name": "SPRINT_ETL_PIPELINE_WH", + "snowflake.warehouse.size": "X-Small", + "snowflake.warehouse.type": "STANDARD", + "snow.database.id": 621, + "snow.database.name": "DTAGENT_DB", + "snow.executable.id": 50838, + "snow.executable.name": "DTAGENT(SOURCES ARRAY):OBJECT", + "snow.executable.runtime.version": 3.1, + "snow.executable.type": "PROCEDURE", + "snow.owner.id": 566820, + "snow.owner.name": "DTAGENT_ADMIN", + "snow.query.id": "01ba3baf-0412-e3aa-0051-0c031e2209d2", + "snow.schema.id": 6140, + "snow.schema.name": "APP", + "snow.session.id": 22812680207694358, + "snow.session.role.primary.id": 566820, + "snow.session.role.primary.name": "DTAGENT_ADMIN", + "snow.warehouse.id": 4637, + "snow.warehouse.name": "DTAGENT_WH", + "telemetry.sdk.language": "python", + "code.filepath": "_udf_code.py", + "code.function": "send_log", + "code.lineno": 982, + "severity_text": "INFO", + "snowflake.event.scope.name": "DTAGENT_OTLP", + "record_type": "LOG", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "event_log" + } +] \ No newline at end of file diff --git a/test/test_results/test_event_log/metrics.txt b/test/test_results/test_event_log/metrics.txt new file mode 100644 index 00000000..c939bd92 --- /dev/null +++ b/test/test_results/test_event_log/metrics.txt @@ -0,0 +1,6 @@ +process.cpu.utilization,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_SKRUK_DB",db.user="SYSTEM",snow.database.id="632",snow.database.name="DTAGENT_SKRUK_DB",snow.executable.id="51528",snow.executable.name="DTAGENT(SOURCES ARRAY):OBJECT",snow.executable.runtime.version="3.11",snow.executable.type="PROCEDURE",snow.owner.id="567463",snow.owner.name="DTAGENT_SKRUK_ADMIN",snow.query.id="01ba3bba-0412-e356-0051-0c031e222a46",snow.schema.id="6165",snow.schema.name="APP",snow.session.id="22812680207736954",snow.session.role.primary.id="567463",snow.session.role.primary.name="DTAGENT_SKRUK_ADMIN",snow.user.id="0",snow.warehouse.id="4649",snow.warehouse.name="DTAGENT_SKRUK_WH",snowflake.query.id="01ba3bba-0412-e356-0051-0c031e222a46",snowflake.role.name="DTAGENT_SKRUK_ADMIN",snowflake.schema.name="APP",snowflake.warehouse.name="DTAGENT_SKRUK_WH",telemetry.sdk.language="python" 0 +#process.cpu.utilization gauge dt.meta.displayName="Process CPU Utilization",dt.meta.unit="1" +process.memory.usage,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_SKRUK_DB",db.user="SYSTEM",snow.database.id="632",snow.database.name="DTAGENT_SKRUK_DB",snow.executable.id="51528",snow.executable.name="DTAGENT(SOURCES ARRAY):OBJECT",snow.executable.runtime.version="3.11",snow.executable.type="PROCEDURE",snow.owner.id="567463",snow.owner.name="DTAGENT_SKRUK_ADMIN",snow.query.id="01ba3bba-0412-e356-0051-0c031e222a46",snow.schema.id="6165",snow.schema.name="APP",snow.session.id="22812680207736954",snow.session.role.primary.id="567463",snow.session.role.primary.name="DTAGENT_SKRUK_ADMIN",snow.user.id="0",snow.warehouse.id="4649",snow.warehouse.name="DTAGENT_SKRUK_WH",snowflake.query.id="01ba3bba-0412-e356-0051-0c031e222a46",snowflake.role.name="DTAGENT_SKRUK_ADMIN",snowflake.schema.name="APP",snowflake.warehouse.name="DTAGENT_SKRUK_WH",telemetry.sdk.language="python" 0 +#process.memory.usage gauge dt.meta.displayName="Process Memory Usage",dt.meta.unit="bytes" +process.cpu.utilization,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_SKRUK_DB",db.user="SYSTEM",snow.database.id="632",snow.database.name="DTAGENT_SKRUK_DB",snow.executable.id="51528",snow.executable.name="DTAGENT(SOURCES ARRAY):OBJECT",snow.executable.runtime.version="3.11",snow.executable.type="PROCEDURE",snow.owner.id="567463",snow.owner.name="DTAGENT_SKRUK_ADMIN",snow.query.id="01ba3bba-0412-e3aa-0051-0c031e22516a",snow.schema.id="6165",snow.schema.name="APP",snow.session.id="22812680207694442",snow.session.role.primary.id="567463",snow.session.role.primary.name="DTAGENT_SKRUK_ADMIN",snow.user.id="0",snow.warehouse.id="4649",snow.warehouse.name="DTAGENT_SKRUK_WH",snowflake.query.id="01ba3bba-0412-e3aa-0051-0c031e22516a",snowflake.role.name="DTAGENT_SKRUK_ADMIN",snowflake.schema.name="APP",snowflake.warehouse.name="DTAGENT_SKRUK_WH",telemetry.sdk.language="python" 0 +process.memory.usage,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_SKRUK_DB",db.user="SYSTEM",snow.database.id="632",snow.database.name="DTAGENT_SKRUK_DB",snow.executable.id="51528",snow.executable.name="DTAGENT(SOURCES ARRAY):OBJECT",snow.executable.runtime.version="3.11",snow.executable.type="PROCEDURE",snow.owner.id="567463",snow.owner.name="DTAGENT_SKRUK_ADMIN",snow.query.id="01ba3bba-0412-e3aa-0051-0c031e22516a",snow.schema.id="6165",snow.schema.name="APP",snow.session.id="22812680207694442",snow.session.role.primary.id="567463",snow.session.role.primary.name="DTAGENT_SKRUK_ADMIN",snow.user.id="0",snow.warehouse.id="4649",snow.warehouse.name="DTAGENT_SKRUK_WH",snowflake.query.id="01ba3bba-0412-e3aa-0051-0c031e22516a",snowflake.role.name="DTAGENT_SKRUK_ADMIN",snowflake.schema.name="APP",snowflake.warehouse.name="DTAGENT_SKRUK_WH",telemetry.sdk.language="python" 0 \ No newline at end of file diff --git a/test/test_results/test_event_log/spans.json b/test/test_results/test_event_log/spans.json new file mode 100644 index 00000000..b0f5fe1f --- /dev/null +++ b/test/test_results/test_event_log/spans.json @@ -0,0 +1,58 @@ +[ + { + "db.namespace": "DTAGENT_SKRUK_DB", + "db.user": "SEBASTIAN.KRUK", + "snow.database.id": 632, + "snow.database.name": "DTAGENT_SKRUK_DB", + "snow.executable.id": 51719, + "snow.executable.name": "LOG_PROCESSED_MEASUREMENTS(MEASUREMENTS_SOURCE VARCHAR, LAST_TIMESTAMP VARCHAR, LAST_ID VARCHAR, ENTRIES_COUNT VARCHAR):VARCHAR(16777216)", + "snow.executable.type": "PROCEDURE", + "snow.owner.id": 567463, + "snow.owner.name": "DTAGENT_SKRUK_ADMIN", + "snow.query.id": "01ba3bc5-0412-e34b-0051-0c031e22184a", + "snow.schema.id": 6167, + "snow.schema.name": "STATUS", + "snow.session.id": 22812680207733670, + "snow.session.role.primary.id": 567483, + "snow.session.role.primary.name": "DTAGENT_SKRUK_VIEWER", + "snow.user.id": 361, + "snow.warehouse.id": 4649, + "snow.warehouse.name": "DTAGENT_SKRUK_WH", + "snowflake.query.id": "01ba3bc5-0412-e34b-0051-0c031e22184a", + "snowflake.role.name": "DTAGENT_SKRUK_VIEWER", + "snowflake.schema.name": "STATUS", + "snowflake.warehouse.name": "DTAGENT_SKRUK_WH", + "telemetry.sdk.language": "sql", + "dsoa.run.context": "event_log_spans", + "dsoa.debug.span.events.added": 0, + "dsoa.debug.span.events.failed": 0 + }, + { + "db.namespace": "DTAGENT_SKRUK_DB", + "db.user": "SYSTEM", + "snow.database.id": 632, + "snow.database.name": "DTAGENT_SKRUK_DB", + "snow.executable.id": 51719, + "snow.executable.name": "LOG_PROCESSED_MEASUREMENTS(MEASUREMENTS_SOURCE VARCHAR, LAST_TIMESTAMP VARCHAR, LAST_ID VARCHAR, ENTRIES_COUNT VARCHAR):VARCHAR(16777216)", + "snow.executable.type": "PROCEDURE", + "snow.owner.id": 567463, + "snow.owner.name": "DTAGENT_SKRUK_ADMIN", + "snow.query.id": "01ba3bcc-0412-e352-0051-0c031e22c1a6", + "snow.schema.id": 6167, + "snow.schema.name": "STATUS", + "snow.session.id": 22812680207726014, + "snow.session.role.primary.id": 567463, + "snow.session.role.primary.name": "DTAGENT_SKRUK_ADMIN", + "snow.user.id": 0, + "snow.warehouse.id": 4649, + "snow.warehouse.name": "DTAGENT_SKRUK_WH", + "snowflake.query.id": "01ba3bcc-0412-e352-0051-0c031e22c1a6", + "snowflake.role.name": "DTAGENT_SKRUK_ADMIN", + "snowflake.schema.name": "STATUS", + "snowflake.warehouse.name": "DTAGENT_SKRUK_WH", + "telemetry.sdk.language": "sql", + "dsoa.run.context": "event_log_spans", + "dsoa.debug.span.events.added": 0, + "dsoa.debug.span.events.failed": 0 + } +] \ No newline at end of file diff --git a/test/test_results/test_event_usage/biz_events.json b/test/test_results/test_event_usage/biz_events.json new file mode 100644 index 00000000..44b7c4e5 --- /dev/null +++ b/test/test_results/test_event_usage/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_event_usage", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_event_usage", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_event_usage/logs.json b/test/test_results/test_event_usage/logs.json new file mode 100644 index 00000000..ce8a5210 --- /dev/null +++ b/test/test_results/test_event_usage/logs.json @@ -0,0 +1,13 @@ +[ + { + "content": "Event Usage", + "snowflake.credits.used": 0.001007024, + "snowflake.data.ingested": 736, + "dsoa.run.context": "event_usage" + }, + { + "content": "Event Usage", + "snowflake.credits.used": 0.000215595, + "dsoa.run.context": "event_usage" + } +] \ No newline at end of file diff --git a/test/test_results/test_event_usage/metrics.txt b/test/test_results/test_event_usage/metrics.txt new file mode 100644 index 00000000..8532b9b1 --- /dev/null +++ b/test/test_results/test_event_usage/metrics.txt @@ -0,0 +1,6 @@ +snowflake.credits.used,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com" 0.001007024 +#snowflake.credits.used gauge dt.meta.displayName="Snowflake Credits Used",dt.meta.unit="credits" +snowflake.data.ingested,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com" 736 +#snowflake.data.ingested gauge dt.meta.displayName="Bytes Ingested for Event Table",dt.meta.unit="bytes" +snowflake.credits.used,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com" 0.000215595 +snowflake.data.ingested,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com" 0 \ No newline at end of file diff --git a/test/test_results/test_login_history/biz_events.json b/test/test_results/test_login_history/biz_events.json new file mode 100644 index 00000000..0614c469 --- /dev/null +++ b/test/test_results/test_login_history/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_login_history", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_login_history", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_login_history/logs.json b/test/test_results/test_login_history/logs.json new file mode 100644 index 00000000..95ddfd36 --- /dev/null +++ b/test/test_results/test_login_history/logs.json @@ -0,0 +1,26 @@ +[ + { + "content": "login_history", + "authentiacation.factor.first": "SAML2_ASSERTION", + "client.version": "1.22.1", + "event.id": 18260702004593906, + "status.code": "OK", + "client.ip": "82.177.196.146", + "client.type": "OTHER", + "db.user": "SEBASTIAN.KRUK", + "event.name": "LOGIN", + "dsoa.run.context": "login_history" + }, + { + "content": "login_history", + "authentiacation.factor.first": "PASSWORD", + "client.version": "1.21.0", + "event.id": 18260702004595858, + "status.code": "OK", + "client.ip": "52.29.224.53", + "client.type": "OTHER", + "db.user": "SNOWAGENT_ADMIN", + "event.name": "LOGIN", + "dsoa.run.context": "login_history" + } +] \ No newline at end of file diff --git a/test/test_results/test_query_history/biz_events.json b/test/test_results/test_query_history/biz_events.json new file mode 100644 index 00000000..807ca632 --- /dev/null +++ b/test/test_results/test_query_history/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_query_history", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_query_history", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_query_history/logs.json b/test/test_results/test_query_history/logs.json new file mode 100644 index 00000000..8dff1766 --- /dev/null +++ b/test/test_results/test_query_history/logs.json @@ -0,0 +1,129 @@ +[ + { + "content": "CALL DTAGENT_DB.APP.F_ACTIVE_QUERIES_INSTRUMENTED();\n", + "snowflake.credits.cloud_services": 1e-05, + "snowflake.data.written_to_result": 640, + "snowflake.load.used": 100, + "snowflake.rows.written_to_result": 798, + "snowflake.time.compilation": 43, + "snowflake.time.execution": 6969, + "snowflake.time.total_elapsed": 7012, + "db.query.text": "CALL DTAGENT_DB.APP.F_ACTIVE_QUERIES_INSTRUMENTED();\n", + "session.id": 20234875336090534, + "snowflake.cluster_number": 1, + "snowflake.database.id": 1868, + "snowflake.query.hash": "e86eb140052655351696b76a32722b70", + "snowflake.query.hash_version": 2, + "snowflake.query.id": "01bcb05d-0415-b618-0047-e383330c172a", + "snowflake.query.parametrized_hash": "e86eb140052655351696b76a32722b70", + "snowflake.query.parametrized_hash_version": 1, + "snowflake.query.tag": "dt_snowagent.version:0.8.1.plugin:ActiveQueriesPlugin.2025-05-30T04:53:15.857Z", + "snowflake.release_version": "9.14.2", + "snowflake.role.type": "ROLE", + "snowflake.schema.id": 40234, + "snowflake.schema.name": "APP", + "snowflake.warehouse.cluster.number": 1, + "snowflake.warehouse.id": 3726, + "snowflake.warehouse.size": "X-Small", + "snowflake.warehouse.type": "STANDARD", + "db.namespace": "DTAGENT_DB", + "db.operation.name": "CALL", + "db.user": "SYSTEM", + "snowflake.query.execution_status": "SUCCESS", + "snowflake.role.name": "DTAGENT_ADMIN", + "snowflake.warehouse.name": "DTAGENT_WH", + "dsoa.run.context": "query_history" + }, + { + "content": "with cte_all_queries as (\n (\n select * from TABLE(DTAGENT_DB.APP.F_GET_RUNNING_QUERIES())\n )\n union all\n (\n select * from TABLE(DTAGENT_DB.APP.F_GET_FINISHED_QUERIES())\n where END_TIME > DTAGENT_DB.APP.F_LAST_PROCESSED_TS('active_queries')\n )\n )\n , cte_active_queries as (\n select \n START_TIME,\n END_TIME,\n\n QUERY_ID,\n SESSION_ID,\n DATABASE_NAME,\n SCHEMA_NAME,\n\n QUERY_TEXT,\n QUERY_TYPE,\n QUERY_TAG,\n QUERY_HASH,\n QUERY_HASH_VERSION,\n QUERY_PARAMETERIZED_HASH,\n QUERY_PARAMETERIZED_HASH_VERSION,\n\n USER_NAME,\n ROLE_NAME,\n\n WAREHOUSE_NAME,\n WAREHOUSE_TYPE,\n\n EXECUTION_STATUS,\n ERROR_CODE,\n ERROR_MESSAGE,\n\n // metrics\n RUNNING_TIME,\n EXECUTION_TIME,\n COMPILATION_TIME,\n TOTAL_ELAPSED_TIME,\n BYTES_WRITTEN_TO_RESULT,\n ROWS_WRITTEN_TO_RESULT,\n from cte_all_queries aq\n where\n ( array_size(DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])) = 0\n or array_contains(EXECUTION_STATUS::variant, DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])::array) )\n )\n select \n qh.END_TIME::timestamp_ltz as TIMESTAMP,\n\n qh.query_id as QUERY_ID,\n qh.session_id as SESSION_ID,\n\n CONCAT(\n 'SQL query ',\n qh.execution_status,\n ' at ',\n COALESCE(qh.database_name, '')\n ) as NAME,\n NAME as _MESSAGE,\n\n \n extract(epoch_nanosecond from qh.start_time) as START_TIME,\n extract(epoch_nanosecond from qh.end_time) as END_TIME,\n\n \n OBJECT_CONSTRUCT(\n 'db.namespace', qh.database_name,\n 'snowflake.warehouse.name', qh.warehouse_name,\n 'db.user', qh.user_name,\n 'snowflake.role.name', qh.role_name,\n 'snowflake.query.execution_status', qh.execution_status\n ) as DIMENSIONS,\n \n OBJECT_CONSTRUCT(\n 'db.query.text', qh.query_text,\n 'db.operation.name', qh.query_type,\n 'session.id', qh.session_id,\n 'snowflake.query.id', qh.query_id,\n 'snowflake.query.tag', qh.query_tag,\n 'snowflake.query.hash', qh.query_hash,\n 'snowflake.query.hash_version', qh.query_hash_version,\n 'snowflake.query.parametrized_hash', qh.query_parameterized_hash,\n 'snowflake.query.parametrized_hash_version', qh.query_parameterized_hash_version,\n 'snowflake.error.code', qh.error_code,\n 'snowflake.error.message', qh.error_message,\n 'snowflake.warehouse.type', qh.warehouse_type,\n 'snowflake.schema.name', qh.schema_name\n ) as ATTRIBUTES,\n \n OBJECT_CONSTRUCT(\n 'snowflake.time.running', qh.running_time,\n 'snowflake.time.execution', qh.execution_time,\n 'snowflake.time.compilation', qh.compilation_time,\n 'snowflake.time.total_elapsed', qh.total_elapsed_time,\n 'snowflake.data.written_to_result', qh.bytes_written_to_result,\n 'snowflake.rows.written_to_result', qh.rows_written_to_result\n ) as METRICS\n from \n cte_active_queries qh\n order by \n TIMESTAMP asc", + "snowflake.credits.cloud_services": 2.7e-05, + "snowflake.data.written_to_result": 640, + "snowflake.load.used": 100, + "snowflake.rows.written_to_result": 798, + "snowflake.time.compilation": 158, + "snowflake.time.execution": 6578, + "snowflake.time.total_elapsed": 6736, + "db.query.text": "with cte_all_queries as (\n (\n select * from TABLE(DTAGENT_DB.APP.F_GET_RUNNING_QUERIES())\n )\n union all\n (\n select * from TABLE(DTAGENT_DB.APP.F_GET_FINISHED_QUERIES())\n where END_TIME > DTAGENT_DB.APP.F_LAST_PROCESSED_TS('active_queries')\n )\n )\n , cte_active_queries as (\n select \n START_TIME,\n END_TIME,\n\n QUERY_ID,\n SESSION_ID,\n DATABASE_NAME,\n SCHEMA_NAME,\n\n QUERY_TEXT,\n QUERY_TYPE,\n QUERY_TAG,\n QUERY_HASH,\n QUERY_HASH_VERSION,\n QUERY_PARAMETERIZED_HASH,\n QUERY_PARAMETERIZED_HASH_VERSION,\n\n USER_NAME,\n ROLE_NAME,\n\n WAREHOUSE_NAME,\n WAREHOUSE_TYPE,\n\n EXECUTION_STATUS,\n ERROR_CODE,\n ERROR_MESSAGE,\n\n // metrics\n RUNNING_TIME,\n EXECUTION_TIME,\n COMPILATION_TIME,\n TOTAL_ELAPSED_TIME,\n BYTES_WRITTEN_TO_RESULT,\n ROWS_WRITTEN_TO_RESULT,\n from cte_all_queries aq\n where\n ( array_size(DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])) = 0\n or array_contains(EXECUTION_STATUS::variant, DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])::array) )\n )\n select \n qh.END_TIME::timestamp_ltz as TIMESTAMP,\n\n qh.query_id as QUERY_ID,\n qh.session_id as SESSION_ID,\n\n CONCAT(\n 'SQL query ',\n qh.execution_status,\n ' at ',\n COALESCE(qh.database_name, '')\n ) as NAME,\n NAME as _MESSAGE,\n\n \n extract(epoch_nanosecond from qh.start_time) as START_TIME,\n extract(epoch_nanosecond from qh.end_time) as END_TIME,\n\n \n OBJECT_CONSTRUCT(\n 'db.namespace', qh.database_name,\n 'snowflake.warehouse.name', qh.warehouse_name,\n 'db.user', qh.user_name,\n 'snowflake.role.name', qh.role_name,\n 'snowflake.query.execution_status', qh.execution_status\n ) as DIMENSIONS,\n \n OBJECT_CONSTRUCT(\n 'db.query.text', qh.query_text,\n 'db.operation.name', qh.query_type,\n 'session.id', qh.session_id,\n 'snowflake.query.id', qh.query_id,\n 'snowflake.query.tag', qh.query_tag,\n 'snowflake.query.hash', qh.query_hash,\n 'snowflake.query.hash_version', qh.query_hash_version,\n 'snowflake.query.parametrized_hash', qh.query_parameterized_hash,\n 'snowflake.query.parametrized_hash_version', qh.query_parameterized_hash_version,\n 'snowflake.error.code', qh.error_code,\n 'snowflake.error.message', qh.error_message,\n 'snowflake.warehouse.type', qh.warehouse_type,\n 'snowflake.schema.name', qh.schema_name\n ) as ATTRIBUTES,\n \n OBJECT_CONSTRUCT(\n 'snowflake.time.running', qh.running_time,\n 'snowflake.time.execution', qh.execution_time,\n 'snowflake.time.compilation', qh.compilation_time,\n 'snowflake.time.total_elapsed', qh.total_elapsed_time,\n 'snowflake.data.written_to_result', qh.bytes_written_to_result,\n 'snowflake.rows.written_to_result', qh.rows_written_to_result\n ) as METRICS\n from \n cte_active_queries qh\n order by \n TIMESTAMP asc", + "db.snowflake.tables": [ + "DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG", + "DTAGENT_DB.CONFIG.CONFIGURATIONS" + ], + "session.id": 20234875336090534, + "snowflake.cluster_number": 1, + "snowflake.database.id": 1868, + "snowflake.query.hash": "0d8c82d99d518393458b4a68bc8c2930", + "snowflake.query.hash_version": 2, + "snowflake.query.id": "01bcb05d-0415-b618-0047-e383330c172e", + "snowflake.query.parametrized_hash": "0d8c82d99d518393458b4a68bc8c2930", + "snowflake.query.parametrized_hash_version": 1, + "snowflake.query.parent_id": "01bcb05d-0415-b618-0047-e383330c172a", + "snowflake.query.tag": "dt_snowagent.version:0.8.1.plugin:ActiveQueriesPlugin.2025-05-30T04:53:15.857Z", + "snowflake.release_version": "9.14.2", + "snowflake.role.type": "ROLE", + "snowflake.schema.id": 40234, + "snowflake.schema.name": "APP", + "snowflake.warehouse.cluster.number": 1, + "snowflake.warehouse.id": 3726, + "snowflake.warehouse.size": "X-Small", + "snowflake.warehouse.type": "STANDARD", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG", + "db.namespace": "DTAGENT_DB", + "db.operation.name": "CALL", + "db.snowflake.dbs": [ + "DTAGENT_DB" + ], + "db.user": "SYSTEM", + "snowflake.query.execution_status": "SUCCESS", + "snowflake.role.name": "DTAGENT_ADMIN", + "snowflake.warehouse.name": "DTAGENT_WH", + "dsoa.run.context": "query_history" + }, + { + "content": "with cte_all_queries as (\n (\n select * from TABLE(result_scan(:QID_0))\n )\n union all\n (\n select * from TABLE(result_scan(:QID_1))\n where END_TIME > DTAGENT_DB.APP.F_LAST_PROCESSED_TS('active_queries')\n )\n )\n , cte_active_queries as (\n select \n START_TIME,\n END_TIME,\n\n QUERY_ID,\n SESSION_ID,\n DATABASE_NAME,\n SCHEMA_NAME,\n\n QUERY_TEXT,\n QUERY_TYPE,\n QUERY_TAG,\n QUERY_HASH,\n QUERY_HASH_VERSION,\n QUERY_PARAMETERIZED_HASH,\n QUERY_PARAMETERIZED_HASH_VERSION,\n\n USER_NAME,\n ROLE_NAME,\n\n WAREHOUSE_NAME,\n WAREHOUSE_TYPE,\n\n EXECUTION_STATUS,\n ERROR_CODE,\n ERROR_MESSAGE,\n\n // metrics\n RUNNING_TIME,\n EXECUTION_TIME,\n COMPILATION_TIME,\n TOTAL_ELAPSED_TIME,\n BYTES_WRITTEN_TO_RESULT,\n ROWS_WRITTEN_TO_RESULT,\n from cte_all_queries aq\n where\n ( array_size(DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])) = 0\n or array_contains(EXECUTION_STATUS::variant, DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])::array) )\n )\n select \n qh.END_TIME::timestamp_ltz as TIMESTAMP,\n\n qh.query_id as QUERY_ID,\n qh.session_id as SESSION_ID,\n\n CONCAT(\n 'SQL query ',\n qh.execution_status,\n ' at ',\n COALESCE(qh.database_name, '')\n ) as NAME,\n NAME as _MESSAGE,\n\n \n extract(epoch_nanosecond from qh.start_time) as START_TIME,\n extract(epoch_nanosecond from qh.end_time) as END_TIME,\n\n \n OBJECT_CONSTRUCT(\n 'db.namespace', qh.database_name,\n 'snowflake.warehouse.name', qh.warehouse_name,\n 'db.user', qh.user_name,\n 'snowflake.role.name', qh.role_name,\n 'snowflake.query.execution_status', qh.execution_status\n ) as DIMENSIONS,\n \n OBJECT_CONSTRUCT(\n 'db.query.text', qh.query_text,\n 'db.operation.name', qh.query_type,\n 'session.id', qh.session_id,\n 'snowflake.query.id', qh.query_id,\n 'snowflake.query.tag', qh.query_tag,\n 'snowflake.query.hash', qh.query_hash,\n 'snowflake.query.hash_version', qh.query_hash_version,\n 'snowflake.query.parametrized_hash', qh.query_parameterized_hash,\n 'snowflake.query.parametrized_hash_version', qh.query_parameterized_hash_version,\n 'snowflake.error.code', qh.error_code,\n 'snowflake.error.message', qh.error_message,\n 'snowflake.warehouse.type', qh.warehouse_type,\n 'snowflake.schema.name', qh.schema_name\n ) as ATTRIBUTES,\n \n OBJECT_CONSTRUCT(\n 'snowflake.time.running', qh.running_time,\n 'snowflake.time.execution', qh.execution_time,\n 'snowflake.time.compilation', qh.compilation_time,\n 'snowflake.time.total_elapsed', qh.total_elapsed_time,\n 'snowflake.data.written_to_result', qh.bytes_written_to_result,\n 'snowflake.rows.written_to_result', qh.rows_written_to_result\n ) as METRICS\n from \n cte_active_queries qh\n order by \n TIMESTAMP asc", + "snowflake.credits.cloud_services": 9.2e-05, + "snowflake.data.scanned": 5640704, + "snowflake.data.written_to_result": 117512, + "snowflake.load.used": 100, + "snowflake.partitions.scanned": 47, + "snowflake.partitions.total": 43, + "snowflake.rows.written_to_result": 798, + "snowflake.time.compilation": 520, + "snowflake.time.execution": 1381, + "snowflake.time.list_external_files": 19, + "snowflake.time.total_elapsed": 1920, + "db.query.text": "with cte_all_queries as (\n (\n select * from TABLE(result_scan(:QID_0))\n )\n union all\n (\n select * from TABLE(result_scan(:QID_1))\n where END_TIME > DTAGENT_DB.APP.F_LAST_PROCESSED_TS('active_queries')\n )\n )\n , cte_active_queries as (\n select \n START_TIME,\n END_TIME,\n\n QUERY_ID,\n SESSION_ID,\n DATABASE_NAME,\n SCHEMA_NAME,\n\n QUERY_TEXT,\n QUERY_TYPE,\n QUERY_TAG,\n QUERY_HASH,\n QUERY_HASH_VERSION,\n QUERY_PARAMETERIZED_HASH,\n QUERY_PARAMETERIZED_HASH_VERSION,\n\n USER_NAME,\n ROLE_NAME,\n\n WAREHOUSE_NAME,\n WAREHOUSE_TYPE,\n\n EXECUTION_STATUS,\n ERROR_CODE,\n ERROR_MESSAGE,\n\n // metrics\n RUNNING_TIME,\n EXECUTION_TIME,\n COMPILATION_TIME,\n TOTAL_ELAPSED_TIME,\n BYTES_WRITTEN_TO_RESULT,\n ROWS_WRITTEN_TO_RESULT,\n from cte_all_queries aq\n where\n ( array_size(DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])) = 0\n or array_contains(EXECUTION_STATUS::variant, DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])::array) )\n )\n select \n qh.END_TIME::timestamp_ltz as TIMESTAMP,\n\n qh.query_id as QUERY_ID,\n qh.session_id as SESSION_ID,\n\n CONCAT(\n 'SQL query ',\n qh.execution_status,\n ' at ',\n COALESCE(qh.database_name, '')\n ) as NAME,\n NAME as _MESSAGE,\n\n \n extract(epoch_nanosecond from qh.start_time) as START_TIME,\n extract(epoch_nanosecond from qh.end_time) as END_TIME,\n\n \n OBJECT_CONSTRUCT(\n 'db.namespace', qh.database_name,\n 'snowflake.warehouse.name', qh.warehouse_name,\n 'db.user', qh.user_name,\n 'snowflake.role.name', qh.role_name,\n 'snowflake.query.execution_status', qh.execution_status\n ) as DIMENSIONS,\n \n OBJECT_CONSTRUCT(\n 'db.query.text', qh.query_text,\n 'db.operation.name', qh.query_type,\n 'session.id', qh.session_id,\n 'snowflake.query.id', qh.query_id,\n 'snowflake.query.tag', qh.query_tag,\n 'snowflake.query.hash', qh.query_hash,\n 'snowflake.query.hash_version', qh.query_hash_version,\n 'snowflake.query.parametrized_hash', qh.query_parameterized_hash,\n 'snowflake.query.parametrized_hash_version', qh.query_parameterized_hash_version,\n 'snowflake.error.code', qh.error_code,\n 'snowflake.error.message', qh.error_message,\n 'snowflake.warehouse.type', qh.warehouse_type,\n 'snowflake.schema.name', qh.schema_name\n ) as ATTRIBUTES,\n \n OBJECT_CONSTRUCT(\n 'snowflake.time.running', qh.running_time,\n 'snowflake.time.execution', qh.execution_time,\n 'snowflake.time.compilation', qh.compilation_time,\n 'snowflake.time.total_elapsed', qh.total_elapsed_time,\n 'snowflake.data.written_to_result', qh.bytes_written_to_result,\n 'snowflake.rows.written_to_result', qh.rows_written_to_result\n ) as METRICS\n from \n cte_active_queries qh\n order by \n TIMESTAMP asc", + "db.snowflake.tables": [ + "DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG", + "DTAGENT_DB.CONFIG.CONFIGURATIONS" + ], + "session.id": 20234875336090534, + "snowflake.cluster_number": 1, + "snowflake.database.id": 1868, + "snowflake.query.hash": "dbf5cf366b64603513aa8097d5d3174c", + "snowflake.query.hash_version": 2, + "snowflake.query.id": "01bcb05d-0415-b618-0047-e383330c174a", + "snowflake.query.parametrized_hash": "dbf5cf366b64603513aa8097d5d3174c", + "snowflake.query.parametrized_hash_version": 1, + "snowflake.query.parent_id": "01bcb05d-0415-b618-0047-e383330c172e", + "snowflake.query.tag": "dt_snowagent.version:0.8.1.plugin:ActiveQueriesPlugin.2025-05-30T04:53:15.857Z", + "snowflake.release_version": "9.14.2", + "snowflake.role.type": "ROLE", + "snowflake.schema.id": 40234, + "snowflake.schema.name": "APP", + "snowflake.warehouse.cluster.number": 1, + "snowflake.warehouse.id": 3726, + "snowflake.warehouse.size": "X-Small", + "snowflake.warehouse.type": "STANDARD", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG", + "db.namespace": "DTAGENT_DB", + "db.operation.name": "SELECT", + "db.snowflake.dbs": [ + "DTAGENT_DB" + ], + "db.user": "SYSTEM", + "snowflake.query.execution_status": "SUCCESS", + "snowflake.role.name": "DTAGENT_ADMIN", + "snowflake.warehouse.name": "DTAGENT_WH", + "dsoa.run.context": "query_history" + } +] \ No newline at end of file diff --git a/test/test_results/test_query_history/metrics.txt b/test/test_results/test_query_history/metrics.txt new file mode 100644 index 00000000..1aee36f4 --- /dev/null +++ b/test/test_results/test_query_history/metrics.txt @@ -0,0 +1,148 @@ +snowflake.acceleration.data.scanned,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.acceleration.data.scanned gauge dt.meta.displayName="Query Acceleration Bytes Scanned",dt.meta.unit="bytes" +snowflake.acceleration.partitions.scanned,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.acceleration.partitions.scanned gauge dt.meta.displayName="Query Acceleration Partitions Scanned",dt.meta.unit="partitions" +snowflake.acceleration.scale_factor.max,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.acceleration.scale_factor.max gauge dt.meta.displayName="Query Acceleration Upper Limit Scale Factor",dt.meta.unit="factor" +snowflake.credits.cloud_services,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 9.2e-05 +#snowflake.credits.cloud_services gauge dt.meta.displayName="Cloud Services Credits Used",dt.meta.unit="credits" +snowflake.data.deleted,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.data.deleted gauge dt.meta.displayName="Bytes Deleted",dt.meta.unit="bytes" +snowflake.data.read.from_result,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.data.read.from_result gauge dt.meta.displayName="Bytes Read from Result",dt.meta.unit="bytes" +snowflake.data.scanned,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 5640704 +#snowflake.data.scanned gauge dt.meta.displayName="Bytes Scanned",dt.meta.unit="bytes" +snowflake.data.scanned_from_cache,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0.0 +#snowflake.data.scanned_from_cache gauge dt.meta.displayName="Percentage Scanned from Cache",dt.meta.unit="percent" +snowflake.data.sent_over_the_network,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.data.sent_over_the_network gauge dt.meta.displayName="Bytes Sent Over the Network",dt.meta.unit="bytes" +snowflake.data.spilled.local,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.data.spilled.local gauge dt.meta.displayName="Bytes Spilled to Local Storage",dt.meta.unit="bytes" +snowflake.data.spilled.remote,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.data.spilled.remote gauge dt.meta.displayName="Bytes Spilled to Remote Storage",dt.meta.unit="bytes" +snowflake.data.transferred.inbound,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.data.transferred.inbound gauge dt.meta.displayName="Inbound Data Transfer Bytes",dt.meta.unit="bytes" +snowflake.data.transferred.outbound,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.data.transferred.outbound gauge dt.meta.displayName="Outbound Data Transfer Bytes",dt.meta.unit="bytes" +snowflake.data.written,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.data.written gauge dt.meta.displayName="Bytes Written",dt.meta.unit="bytes" +snowflake.data.written_to_result,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 117512 +#snowflake.data.written_to_result gauge dt.meta.displayName="Bytes Written to Result",dt.meta.unit="bytes" +snowflake.external_functions.data.received,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.external_functions.data.received gauge dt.meta.displayName="External Function Total Received Bytes",dt.meta.unit="bytes" +snowflake.external_functions.data.sent,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.external_functions.data.sent gauge dt.meta.displayName="External Function Total Sent Bytes",dt.meta.unit="bytes" +snowflake.external_functions.invocations,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.external_functions.invocations gauge dt.meta.displayName="External Function Total Invocations",dt.meta.unit="count" +snowflake.external_functions.rows.received,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.external_functions.rows.received gauge dt.meta.displayName="External Function Total Received Rows",dt.meta.unit="rows" +snowflake.external_functions.rows.sent,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.external_functions.rows.sent gauge dt.meta.displayName="External Function Total Sent Rows",dt.meta.unit="rows" +snowflake.load.used,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 100 +#snowflake.load.used gauge dt.meta.displayName="Query Load Percent",dt.meta.unit="percent" +snowflake.partitions.scanned,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 47 +#snowflake.partitions.scanned gauge dt.meta.displayName="Partitions Scanned",dt.meta.unit="partitions" +snowflake.partitions.total,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 43 +#snowflake.partitions.total gauge dt.meta.displayName="Partitions Total",dt.meta.unit="partitions" +snowflake.rows.deleted,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.rows.deleted gauge dt.meta.displayName="Rows Deleted",dt.meta.unit="rows" +snowflake.rows.inserted,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.rows.inserted gauge dt.meta.displayName="Rows Inserted",dt.meta.unit="rows" +snowflake.rows.unloaded,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.rows.unloaded gauge dt.meta.displayName="Rows Unloaded",dt.meta.unit="rows" +snowflake.rows.updated,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.rows.updated gauge dt.meta.displayName="Rows Updated",dt.meta.unit="rows" +snowflake.rows.written_to_result,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 798 +#snowflake.rows.written_to_result gauge dt.meta.displayName="Rows Written to Result",dt.meta.unit="rows" +snowflake.time.child_queries_wait,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.time.child_queries_wait gauge dt.meta.displayName="Child Queries Wait Time",dt.meta.unit="ms" +snowflake.time.compilation,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 520 +#snowflake.time.compilation gauge dt.meta.displayName="Query Compilation Time",dt.meta.unit="ms" +snowflake.time.execution,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 1381 +#snowflake.time.execution gauge dt.meta.displayName="Execution Time",dt.meta.unit="ms" +snowflake.time.list_external_files,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 19 +#snowflake.time.list_external_files gauge dt.meta.displayName="List External Files Time",dt.meta.unit="ms" +snowflake.time.queued.overload,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.time.queued.overload gauge dt.meta.displayName="Queued Overload Time",dt.meta.unit="ms" +snowflake.time.queued.provisioning,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.time.queued.provisioning gauge dt.meta.displayName="Queued Provisioning Time",dt.meta.unit="ms" +snowflake.time.repair,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.time.repair gauge dt.meta.displayName="Queued Repair Time",dt.meta.unit="ms" +snowflake.time.total_elapsed,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 1920 +#snowflake.time.total_elapsed gauge dt.meta.displayName="Total Elapsed Time",dt.meta.unit="ms" +snowflake.time.transaction_blocked,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="SELECT",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +#snowflake.time.transaction_blocked gauge dt.meta.displayName="Transaction Blocked Time",dt.meta.unit="ms" +snowflake.acceleration.data.scanned,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.acceleration.partitions.scanned,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.acceleration.scale_factor.max,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.credits.cloud_services,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 2.7e-05 +snowflake.data.deleted,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.read.from_result,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.scanned,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.scanned_from_cache,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0.0 +snowflake.data.sent_over_the_network,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.spilled.local,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.spilled.remote,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.transferred.inbound,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.transferred.outbound,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.written,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.written_to_result,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 640 +snowflake.external_functions.data.received,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.external_functions.data.sent,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.external_functions.invocations,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.external_functions.rows.received,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.external_functions.rows.sent,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.load.used,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 100 +snowflake.partitions.scanned,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.partitions.total,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.rows.deleted,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.rows.inserted,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.rows.unloaded,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.rows.updated,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.rows.written_to_result,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 798 +snowflake.time.child_queries_wait,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.time.compilation,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 158 +snowflake.time.execution,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 6578 +snowflake.time.list_external_files,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.time.queued.overload,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.time.queued.provisioning,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.time.repair,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.time.total_elapsed,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 6736 +snowflake.time.transaction_blocked,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.collection.name="DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.snowflake.dbs="['DTAGENT_DB']",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.acceleration.data.scanned,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.acceleration.partitions.scanned,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.acceleration.scale_factor.max,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.credits.cloud_services,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 1e-05 +snowflake.data.deleted,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.read.from_result,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.scanned,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.scanned_from_cache,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0.0 +snowflake.data.sent_over_the_network,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.spilled.local,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.spilled.remote,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.transferred.inbound,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.transferred.outbound,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.written,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.data.written_to_result,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 640 +snowflake.external_functions.data.received,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.external_functions.data.sent,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.external_functions.invocations,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.external_functions.rows.received,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.external_functions.rows.sent,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.load.used,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 100 +snowflake.partitions.scanned,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.partitions.total,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.rows.deleted,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.rows.inserted,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.rows.unloaded,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.rows.updated,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.rows.written_to_result,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 798 +snowflake.time.child_queries_wait,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.time.compilation,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 43 +snowflake.time.execution,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 6969 +snowflake.time.list_external_files,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.time.queued.overload,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.time.queued.provisioning,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.time.repair,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 +snowflake.time.total_elapsed,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 7012 +snowflake.time.transaction_blocked,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",db.namespace="DTAGENT_DB",db.operation.name="CALL",db.user="SYSTEM",snowflake.query.execution_status="SUCCESS",snowflake.role.name="DTAGENT_ADMIN",snowflake.warehouse.name="DTAGENT_WH" 0 \ No newline at end of file diff --git a/test/test_results/test_query_history/spans.json b/test/test_results/test_query_history/spans.json new file mode 100644 index 00000000..8e8ed824 --- /dev/null +++ b/test/test_results/test_query_history/spans.json @@ -0,0 +1,224 @@ +[ + { + "snowflake.acceleration.data.scanned": 0, + "snowflake.acceleration.partitions.scanned": 0, + "snowflake.acceleration.scale_factor.max": 0, + "snowflake.credits.cloud_services": 9.2e-05, + "snowflake.data.deleted": 0, + "snowflake.data.read.from_result": 0, + "snowflake.data.scanned": 5640704, + "snowflake.data.scanned_from_cache": 0.0, + "snowflake.data.sent_over_the_network": 0, + "snowflake.data.spilled.local": 0, + "snowflake.data.spilled.remote": 0, + "snowflake.data.transferred.inbound": 0, + "snowflake.data.transferred.outbound": 0, + "snowflake.data.written": 0, + "snowflake.data.written_to_result": 117512, + "snowflake.external_functions.data.received": 0, + "snowflake.external_functions.data.sent": 0, + "snowflake.external_functions.invocations": 0, + "snowflake.external_functions.rows.received": 0, + "snowflake.external_functions.rows.sent": 0, + "snowflake.load.used": 100, + "snowflake.partitions.scanned": 47, + "snowflake.partitions.total": 43, + "snowflake.rows.deleted": 0, + "snowflake.rows.inserted": 0, + "snowflake.rows.unloaded": 0, + "snowflake.rows.updated": 0, + "snowflake.rows.written_to_result": 798, + "snowflake.time.child_queries_wait": 0, + "snowflake.time.compilation": 520, + "snowflake.time.execution": 1381, + "snowflake.time.list_external_files": 19, + "snowflake.time.queued.overload": 0, + "snowflake.time.queued.provisioning": 0, + "snowflake.time.repair": 0, + "snowflake.time.total_elapsed": 1920, + "snowflake.time.transaction_blocked": 0, + "db.query.text": "with cte_all_queries as (\n (\n select * from TABLE(result_scan(:QID_0))\n )\n union all\n (\n select * from TABLE(result_scan(:QID_1))\n where END_TIME > DTAGENT_DB.APP.F_LAST_PROCESSED_TS('active_queries')\n )\n )\n , cte_active_queries as (\n select \n START_TIME,\n END_TIME,\n\n QUERY_ID,\n SESSION_ID,\n DATABASE_NAME,\n SCHEMA_NAME,\n\n QUERY_TEXT,\n QUERY_TYPE,\n QUERY_TAG,\n QUERY_HASH,\n QUERY_HASH_VERSION,\n QUERY_PARAMETERIZED_HASH,\n QUERY_PARAMETERIZED_HASH_VERSION,\n\n USER_NAME,\n ROLE_NAME,\n\n WAREHOUSE_NAME,\n WAREHOUSE_TYPE,\n\n EXECUTION_STATUS,\n ERROR_CODE,\n ERROR_MESSAGE,\n\n // metrics\n RUNNING_TIME,\n EXECUTION_TIME,\n COMPILATION_TIME,\n TOTAL_ELAPSED_TIME,\n BYTES_WRITTEN_TO_RESULT,\n ROWS_WRITTEN_TO_RESULT,\n from cte_all_queries aq\n where\n ( array_size(DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])) = 0\n or array_contains(EXECUTION_STATUS::variant, DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])::array) )\n )\n select \n qh.END_TIME::timestamp_ltz as TIMESTAMP,\n\n qh.query_id as QUERY_ID,\n qh.session_id as SESSION_ID,\n\n CONCAT(\n 'SQL query ',\n qh.execution_status,\n ' at ',\n COALESCE(qh.database_name, '')\n ) as NAME,\n NAME as _MESSAGE,\n\n \n extract(epoch_nanosecond from qh.start_time) as START_TIME,\n extract(epoch_nanosecond from qh.end_time) as END_TIME,\n\n \n OBJECT_CONSTRUCT(\n 'db.namespace', qh.database_name,\n 'snowflake.warehouse.name', qh.warehouse_name,\n 'db.user', qh.user_name,\n 'snowflake.role.name', qh.role_name,\n 'snowflake.query.execution_status', qh.execution_status\n ) as DIMENSIONS,\n \n OBJECT_CONSTRUCT(\n 'db.query.text', qh.query_text,\n 'db.operation.name', qh.query_type,\n 'session.id', qh.session_id,\n 'snowflake.query.id', qh.query_id,\n 'snowflake.query.tag', qh.query_tag,\n 'snowflake.query.hash', qh.query_hash,\n 'snowflake.query.hash_version', qh.query_hash_version,\n 'snowflake.query.parametrized_hash', qh.query_parameterized_hash,\n 'snowflake.query.parametrized_hash_version', qh.query_parameterized_hash_version,\n 'snowflake.error.code', qh.error_code,\n 'snowflake.error.message', qh.error_message,\n 'snowflake.warehouse.type', qh.warehouse_type,\n 'snowflake.schema.name', qh.schema_name\n ) as ATTRIBUTES,\n \n OBJECT_CONSTRUCT(\n 'snowflake.time.running', qh.running_time,\n 'snowflake.time.execution', qh.execution_time,\n 'snowflake.time.compilation', qh.compilation_time,\n 'snowflake.time.total_elapsed', qh.total_elapsed_time,\n 'snowflake.data.written_to_result', qh.bytes_written_to_result,\n 'snowflake.rows.written_to_result', qh.rows_written_to_result\n ) as METRICS\n from \n cte_active_queries qh\n order by \n TIMESTAMP asc", + "db.snowflake.tables": [ + "DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG", + "DTAGENT_DB.CONFIG.CONFIGURATIONS" + ], + "session.id": 20234875336090534, + "snowflake.cluster_number": 1, + "snowflake.database.id": 1868, + "snowflake.query.hash": "dbf5cf366b64603513aa8097d5d3174c", + "snowflake.query.hash_version": 2, + "snowflake.query.id": "01bcb05d-0415-b618-0047-e383330c174a", + "snowflake.query.is_client_generated": false, + "snowflake.query.parametrized_hash": "dbf5cf366b64603513aa8097d5d3174c", + "snowflake.query.parametrized_hash_version": 1, + "snowflake.query.parent_id": "01bcb05d-0415-b618-0047-e383330c172e", + "snowflake.query.tag": "dt_snowagent.version:0.8.1.plugin:ActiveQueriesPlugin.2025-05-30T04:53:15.857Z", + "snowflake.query.transaction_id": 0, + "snowflake.release_version": "9.14.2", + "snowflake.role.type": "ROLE", + "snowflake.schema.id": 40234, + "snowflake.schema.name": "APP", + "snowflake.warehouse.cluster.number": 1, + "snowflake.warehouse.id": 3726, + "snowflake.warehouse.size": "X-Small", + "snowflake.warehouse.type": "STANDARD", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG", + "db.namespace": "DTAGENT_DB", + "db.operation.name": "SELECT", + "db.snowflake.dbs": [ + "DTAGENT_DB" + ], + "db.user": "SYSTEM", + "snowflake.query.execution_status": "SUCCESS", + "snowflake.role.name": "DTAGENT_ADMIN", + "snowflake.warehouse.name": "DTAGENT_WH", + "dsoa.run.context": "query_history", + "dsoa.debug.span.events.added": 0, + "dsoa.debug.span.events.failed": 0 + }, + { + "snowflake.acceleration.data.scanned": 0, + "snowflake.acceleration.partitions.scanned": 0, + "snowflake.acceleration.scale_factor.max": 0, + "snowflake.credits.cloud_services": 2.7e-05, + "snowflake.data.deleted": 0, + "snowflake.data.read.from_result": 0, + "snowflake.data.scanned": 0, + "snowflake.data.scanned_from_cache": 0.0, + "snowflake.data.sent_over_the_network": 0, + "snowflake.data.spilled.local": 0, + "snowflake.data.spilled.remote": 0, + "snowflake.data.transferred.inbound": 0, + "snowflake.data.transferred.outbound": 0, + "snowflake.data.written": 0, + "snowflake.data.written_to_result": 640, + "snowflake.external_functions.data.received": 0, + "snowflake.external_functions.data.sent": 0, + "snowflake.external_functions.invocations": 0, + "snowflake.external_functions.rows.received": 0, + "snowflake.external_functions.rows.sent": 0, + "snowflake.load.used": 100, + "snowflake.partitions.scanned": 0, + "snowflake.partitions.total": 0, + "snowflake.rows.deleted": 0, + "snowflake.rows.inserted": 0, + "snowflake.rows.unloaded": 0, + "snowflake.rows.updated": 0, + "snowflake.rows.written_to_result": 798, + "snowflake.time.child_queries_wait": 0, + "snowflake.time.compilation": 158, + "snowflake.time.execution": 6578, + "snowflake.time.list_external_files": 0, + "snowflake.time.queued.overload": 0, + "snowflake.time.queued.provisioning": 0, + "snowflake.time.repair": 0, + "snowflake.time.total_elapsed": 6736, + "snowflake.time.transaction_blocked": 0, + "db.query.text": "with cte_all_queries as (\n (\n select * from TABLE(DTAGENT_DB.APP.F_GET_RUNNING_QUERIES())\n )\n union all\n (\n select * from TABLE(DTAGENT_DB.APP.F_GET_FINISHED_QUERIES())\n where END_TIME > DTAGENT_DB.APP.F_LAST_PROCESSED_TS('active_queries')\n )\n )\n , cte_active_queries as (\n select \n START_TIME,\n END_TIME,\n\n QUERY_ID,\n SESSION_ID,\n DATABASE_NAME,\n SCHEMA_NAME,\n\n QUERY_TEXT,\n QUERY_TYPE,\n QUERY_TAG,\n QUERY_HASH,\n QUERY_HASH_VERSION,\n QUERY_PARAMETERIZED_HASH,\n QUERY_PARAMETERIZED_HASH_VERSION,\n\n USER_NAME,\n ROLE_NAME,\n\n WAREHOUSE_NAME,\n WAREHOUSE_TYPE,\n\n EXECUTION_STATUS,\n ERROR_CODE,\n ERROR_MESSAGE,\n\n // metrics\n RUNNING_TIME,\n EXECUTION_TIME,\n COMPILATION_TIME,\n TOTAL_ELAPSED_TIME,\n BYTES_WRITTEN_TO_RESULT,\n ROWS_WRITTEN_TO_RESULT,\n from cte_all_queries aq\n where\n ( array_size(DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])) = 0\n or array_contains(EXECUTION_STATUS::variant, DTAGENT_DB.APP.F_GET_CONFIG_VALUE('plugins.active_queries.report_execution_status', [])::array) )\n )\n select \n qh.END_TIME::timestamp_ltz as TIMESTAMP,\n\n qh.query_id as QUERY_ID,\n qh.session_id as SESSION_ID,\n\n CONCAT(\n 'SQL query ',\n qh.execution_status,\n ' at ',\n COALESCE(qh.database_name, '')\n ) as NAME,\n NAME as _MESSAGE,\n\n \n extract(epoch_nanosecond from qh.start_time) as START_TIME,\n extract(epoch_nanosecond from qh.end_time) as END_TIME,\n\n \n OBJECT_CONSTRUCT(\n 'db.namespace', qh.database_name,\n 'snowflake.warehouse.name', qh.warehouse_name,\n 'db.user', qh.user_name,\n 'snowflake.role.name', qh.role_name,\n 'snowflake.query.execution_status', qh.execution_status\n ) as DIMENSIONS,\n \n OBJECT_CONSTRUCT(\n 'db.query.text', qh.query_text,\n 'db.operation.name', qh.query_type,\n 'session.id', qh.session_id,\n 'snowflake.query.id', qh.query_id,\n 'snowflake.query.tag', qh.query_tag,\n 'snowflake.query.hash', qh.query_hash,\n 'snowflake.query.hash_version', qh.query_hash_version,\n 'snowflake.query.parametrized_hash', qh.query_parameterized_hash,\n 'snowflake.query.parametrized_hash_version', qh.query_parameterized_hash_version,\n 'snowflake.error.code', qh.error_code,\n 'snowflake.error.message', qh.error_message,\n 'snowflake.warehouse.type', qh.warehouse_type,\n 'snowflake.schema.name', qh.schema_name\n ) as ATTRIBUTES,\n \n OBJECT_CONSTRUCT(\n 'snowflake.time.running', qh.running_time,\n 'snowflake.time.execution', qh.execution_time,\n 'snowflake.time.compilation', qh.compilation_time,\n 'snowflake.time.total_elapsed', qh.total_elapsed_time,\n 'snowflake.data.written_to_result', qh.bytes_written_to_result,\n 'snowflake.rows.written_to_result', qh.rows_written_to_result\n ) as METRICS\n from \n cte_active_queries qh\n order by \n TIMESTAMP asc", + "db.snowflake.tables": [ + "DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG", + "DTAGENT_DB.CONFIG.CONFIGURATIONS" + ], + "session.id": 20234875336090534, + "snowflake.cluster_number": 1, + "snowflake.database.id": 1868, + "snowflake.query.hash": "0d8c82d99d518393458b4a68bc8c2930", + "snowflake.query.hash_version": 2, + "snowflake.query.id": "01bcb05d-0415-b618-0047-e383330c172e", + "snowflake.query.is_client_generated": false, + "snowflake.query.parametrized_hash": "0d8c82d99d518393458b4a68bc8c2930", + "snowflake.query.parametrized_hash_version": 1, + "snowflake.query.parent_id": "01bcb05d-0415-b618-0047-e383330c172a", + "snowflake.query.tag": "dt_snowagent.version:0.8.1.plugin:ActiveQueriesPlugin.2025-05-30T04:53:15.857Z", + "snowflake.query.transaction_id": 0, + "snowflake.release_version": "9.14.2", + "snowflake.role.type": "ROLE", + "snowflake.schema.id": 40234, + "snowflake.schema.name": "APP", + "snowflake.warehouse.cluster.number": 1, + "snowflake.warehouse.id": 3726, + "snowflake.warehouse.size": "X-Small", + "snowflake.warehouse.type": "STANDARD", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_MEASUREMENTS_LOG", + "db.namespace": "DTAGENT_DB", + "db.operation.name": "CALL", + "db.snowflake.dbs": [ + "DTAGENT_DB" + ], + "db.user": "SYSTEM", + "snowflake.query.execution_status": "SUCCESS", + "snowflake.role.name": "DTAGENT_ADMIN", + "snowflake.warehouse.name": "DTAGENT_WH", + "dsoa.run.context": "query_history", + "dsoa.debug.span.events.added": 0, + "dsoa.debug.span.events.failed": 0 + }, + { + "snowflake.acceleration.data.scanned": 0, + "snowflake.acceleration.partitions.scanned": 0, + "snowflake.acceleration.scale_factor.max": 0, + "snowflake.credits.cloud_services": 1e-05, + "snowflake.data.deleted": 0, + "snowflake.data.read.from_result": 0, + "snowflake.data.scanned": 0, + "snowflake.data.scanned_from_cache": 0.0, + "snowflake.data.sent_over_the_network": 0, + "snowflake.data.spilled.local": 0, + "snowflake.data.spilled.remote": 0, + "snowflake.data.transferred.inbound": 0, + "snowflake.data.transferred.outbound": 0, + "snowflake.data.written": 0, + "snowflake.data.written_to_result": 640, + "snowflake.external_functions.data.received": 0, + "snowflake.external_functions.data.sent": 0, + "snowflake.external_functions.invocations": 0, + "snowflake.external_functions.rows.received": 0, + "snowflake.external_functions.rows.sent": 0, + "snowflake.load.used": 100, + "snowflake.partitions.scanned": 0, + "snowflake.partitions.total": 0, + "snowflake.rows.deleted": 0, + "snowflake.rows.inserted": 0, + "snowflake.rows.unloaded": 0, + "snowflake.rows.updated": 0, + "snowflake.rows.written_to_result": 798, + "snowflake.time.child_queries_wait": 0, + "snowflake.time.compilation": 43, + "snowflake.time.execution": 6969, + "snowflake.time.list_external_files": 0, + "snowflake.time.queued.overload": 0, + "snowflake.time.queued.provisioning": 0, + "snowflake.time.repair": 0, + "snowflake.time.total_elapsed": 7012, + "snowflake.time.transaction_blocked": 0, + "db.query.text": "CALL DTAGENT_DB.APP.F_ACTIVE_QUERIES_INSTRUMENTED();\n", + "session.id": 20234875336090534, + "snowflake.cluster_number": 1, + "snowflake.database.id": 1868, + "snowflake.query.hash": "e86eb140052655351696b76a32722b70", + "snowflake.query.hash_version": 2, + "snowflake.query.id": "01bcb05d-0415-b618-0047-e383330c172a", + "snowflake.query.is_client_generated": false, + "snowflake.query.parametrized_hash": "e86eb140052655351696b76a32722b70", + "snowflake.query.parametrized_hash_version": 1, + "snowflake.query.tag": "dt_snowagent.version:0.8.1.plugin:ActiveQueriesPlugin.2025-05-30T04:53:15.857Z", + "snowflake.query.transaction_id": 0, + "snowflake.release_version": "9.14.2", + "snowflake.role.type": "ROLE", + "snowflake.schema.id": 40234, + "snowflake.schema.name": "APP", + "snowflake.warehouse.cluster.number": 1, + "snowflake.warehouse.id": 3726, + "snowflake.warehouse.size": "X-Small", + "snowflake.warehouse.type": "STANDARD", + "db.namespace": "DTAGENT_DB", + "db.operation.name": "CALL", + "db.user": "SYSTEM", + "snowflake.query.execution_status": "SUCCESS", + "snowflake.role.name": "DTAGENT_ADMIN", + "snowflake.warehouse.name": "DTAGENT_WH", + "dsoa.run.context": "query_history", + "dsoa.debug.span.events.added": 0, + "dsoa.debug.span.events.failed": 0 + } +] \ No newline at end of file diff --git a/test/test_results/test_resource_monitors/biz_events.json b/test/test_results/test_resource_monitors/biz_events.json new file mode 100644 index 00000000..cc70d390 --- /dev/null +++ b/test/test_results/test_resource_monitors/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_resource_monitors", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_resource_monitors", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_resource_monitors/metrics.txt b/test/test_results/test_resource_monitors/metrics.txt new file mode 100644 index 00000000..6c94d8fa --- /dev/null +++ b/test/test_results/test_resource_monitors/metrics.txt @@ -0,0 +1,33 @@ +snowflake.credits.quota,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="ACCOUNT_GLOBAL_MONITOR" 15.00 +#snowflake.credits.quota gauge dt.meta.displayName="Credits Quota",dt.meta.unit="credits" +snowflake.credits.quota.remaining,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="ACCOUNT_GLOBAL_MONITOR" 8.79 +#snowflake.credits.quota.remaining gauge dt.meta.displayName="Credits Remaining",dt.meta.unit="credits" +snowflake.credits.quota.used,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="ACCOUNT_GLOBAL_MONITOR" 6.21 +#snowflake.credits.quota.used gauge dt.meta.displayName="Credits Used",dt.meta.unit="credits" +snowflake.credits.quota.used_pct,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="ACCOUNT_GLOBAL_MONITOR" 41.4 +#snowflake.credits.quota.used_pct gauge dt.meta.displayName="Percentage Quota Used",dt.meta.unit="percent" +snowflake.resource_monitor.warehouses,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="ACCOUNT_GLOBAL_MONITOR" 2 +#snowflake.resource_monitor.warehouses gauge dt.meta.displayName="Warehouses Count",dt.meta.unit="warehouses" +snowflake.credits.quota,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="NATIVE_APP_QUICKSTART_RS" 1.00 +snowflake.credits.quota.remaining,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="NATIVE_APP_QUICKSTART_RS" 1.00 +snowflake.credits.quota.used,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="NATIVE_APP_QUICKSTART_RS" 0.00 +snowflake.credits.quota.used_pct,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="NATIVE_APP_QUICKSTART_RS" 0 +snowflake.resource_monitor.warehouses,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="NATIVE_APP_QUICKSTART_RS" 1 +snowflake.acceleration.scale_factor.max,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="COMPUTE_RS",snowflake.warehouse.name="COMPUTE_WH" 8 +#snowflake.acceleration.scale_factor.max gauge dt.meta.displayName="Query Acceleration Upper Limit Scale Factor",dt.meta.unit="factor" +snowflake.queries.queued,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="COMPUTE_RS",snowflake.warehouse.name="COMPUTE_WH" 0 +#snowflake.queries.queued gauge dt.meta.displayName="Queued Queries",dt.meta.unit="queries" +snowflake.queries.running,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="COMPUTE_RS",snowflake.warehouse.name="COMPUTE_WH" 0 +#snowflake.queries.running gauge dt.meta.displayName="Running Queries",dt.meta.unit="queries" +snowflake.warehouse.clusters.max,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="COMPUTE_RS",snowflake.warehouse.name="COMPUTE_WH" 1 +#snowflake.warehouse.clusters.max gauge dt.meta.displayName="Maximum Cluster Count",dt.meta.unit="clusters" +snowflake.warehouse.clusters.min,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="COMPUTE_RS",snowflake.warehouse.name="COMPUTE_WH" 1 +#snowflake.warehouse.clusters.min gauge dt.meta.displayName="Minimum Cluster Count",dt.meta.unit="clusters" +snowflake.warehouse.clusters.started,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="COMPUTE_RS",snowflake.warehouse.name="COMPUTE_WH" 0 +#snowflake.warehouse.clusters.started gauge dt.meta.displayName="Started Clusters",dt.meta.unit="clusters" +snowflake.acceleration.scale_factor.max,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="DEVELCLONE_RS",snowflake.warehouse.name="DEVELCLONE_WH" 8 +snowflake.queries.queued,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="DEVELCLONE_RS",snowflake.warehouse.name="DEVELCLONE_WH" 0 +snowflake.queries.running,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="DEVELCLONE_RS",snowflake.warehouse.name="DEVELCLONE_WH" 0 +snowflake.warehouse.clusters.max,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="DEVELCLONE_RS",snowflake.warehouse.name="DEVELCLONE_WH" 1 +snowflake.warehouse.clusters.min,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="DEVELCLONE_RS",snowflake.warehouse.name="DEVELCLONE_WH" 1 +snowflake.warehouse.clusters.started,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",snowflake.resource_monitor.name="DEVELCLONE_RS",snowflake.warehouse.name="DEVELCLONE_WH" 0 \ No newline at end of file diff --git a/test/test_results/test_send_bizevents_directly/biz_events.json b/test/test_results/test_send_bizevents_directly/biz_events.json new file mode 100644 index 00000000..b9ca6e5c --- /dev/null +++ b/test/test_results/test_send_bizevents_directly/biz_events.json @@ -0,0 +1,81 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.bizevent", + "data": { + "test.bizevent.message": "Dynatrace Snowflake Observability Agent test event 123", + "app.bundle": "bizevents", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.bizevent", + "data": { + "test.event.dtagent.number": 10, + "test.event.dtagent.text": "some text", + "test.event.dtagent.bool": true, + "app.bundle": "bizevents", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "CUSTOM_ANNOTATION", + "data": { + "test.event.dtagent.info": "timeout", + "event.type": "CUSTOM_ANNOTATION", + "app.bundle": "bizevents", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.bizevent", + "data": { + "test.event.dtagent.info": "10 min in the past", + "app.bundle": "bizevents", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.bizevent", + "data": { + "test.event.dtagent.info": "15 min in the future", + "test.event.dtagent.timeout": 15, + "app.bundle": "bizevents", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_send_davis_events_directly/davis_events.json b/test/test_results/test_send_davis_events_directly/davis_events.json new file mode 100644 index 00000000..6ef73885 --- /dev/null +++ b/test/test_results/test_send_davis_events_directly/davis_events.json @@ -0,0 +1,81 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "Dynatrace Snowflake Observability Agent test event 1", + "properties": { + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + } + }, + { + "eventType": "AVAILABILITY_EVENT", + "title": "Dynatrace Snowflake Observability Agent test event 2", + "properties": { + "test.event.dtagent.number": 10, + "test.event.dtagent.text": "some text", + "test.event.dtagent.bool": true, + "test.event.dtagent.list": "[1, 2, 3]", + "test.event.dtagent.dict": "{\"k1\": \"v1\", \"k2\": 2}", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + }, + "timeout": 30 + }, + { + "eventType": "CUSTOM_ANNOTATION", + "title": "Dynatrace Snowflake Observability Agent test event 3", + "properties": { + "test.event.dtagent.info": "timeout", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + }, + "timeout": 30 + }, + { + "eventType": "CUSTOM_ALERT", + "title": "Dynatrace Snowflake Observability Agent test event 4", + "properties": { + "test.event.dtagent.info": "10 min in the past", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + }, + "timeout": 15 + }, + { + "eventType": "CUSTOM_DEPLOYMENT", + "title": "Dynatrace Snowflake Observability Agent test event 5", + "properties": { + "test.event.dtagent.info": "15 min in the future", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + } + }, + { + "eventType": "CUSTOM_DEPLOYMENT", + "title": "Dynatrace Snowflake Observability Agent test event 6", + "properties": { + "test.event.dtagent.info": "15 min in the future", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "data_volume" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_send_generic_events_directly/events.json b/test/test_results/test_send_generic_events_directly/events.json new file mode 100644 index 00000000..6ef73885 --- /dev/null +++ b/test/test_results/test_send_generic_events_directly/events.json @@ -0,0 +1,81 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "Dynatrace Snowflake Observability Agent test event 1", + "properties": { + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + } + }, + { + "eventType": "AVAILABILITY_EVENT", + "title": "Dynatrace Snowflake Observability Agent test event 2", + "properties": { + "test.event.dtagent.number": 10, + "test.event.dtagent.text": "some text", + "test.event.dtagent.bool": true, + "test.event.dtagent.list": "[1, 2, 3]", + "test.event.dtagent.dict": "{\"k1\": \"v1\", \"k2\": 2}", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + }, + "timeout": 30 + }, + { + "eventType": "CUSTOM_ANNOTATION", + "title": "Dynatrace Snowflake Observability Agent test event 3", + "properties": { + "test.event.dtagent.info": "timeout", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + }, + "timeout": 30 + }, + { + "eventType": "CUSTOM_ALERT", + "title": "Dynatrace Snowflake Observability Agent test event 4", + "properties": { + "test.event.dtagent.info": "10 min in the past", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + }, + "timeout": 15 + }, + { + "eventType": "CUSTOM_DEPLOYMENT", + "title": "Dynatrace Snowflake Observability Agent test event 5", + "properties": { + "test.event.dtagent.info": "15 min in the future", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + } + }, + { + "eventType": "CUSTOM_DEPLOYMENT", + "title": "Dynatrace Snowflake Observability Agent test event 6", + "properties": { + "test.event.dtagent.info": "15 min in the future", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "data_volume" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_send_results_as_bizevents/biz_events.json b/test/test_results/test_send_results_as_bizevents/biz_events.json new file mode 100644 index 00000000..e0930b5f --- /dev/null +++ b/test/test_results/test_send_results_as_bizevents/biz_events.json @@ -0,0 +1,48 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "CUSTOM_INFO", + "data": { + "snowflake.table.update": 1736851468626000000, + "snowflake.data.rows": 6, + "snowflake.data.size": 1024, + "snowflake.table.time_since.last_update": 81983, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DEV_DB.PUBLIC.SALESMANAGERREGIONS", + "db.namespace": "DEV_DB", + "app.bundle": "data_volume", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "data_volume" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "CUSTOM_INFO", + "data": { + "snowflake.table.ddl": 1733122324468000000, + "snowflake.table.update": 1741707972204000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 144135, + "snowflake.table.time_since.last_update": 1041, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "app.bundle": "data_volume", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "data_volume" + } + } +] diff --git a/test/test_results/test_send_results_as_events/events.json b/test/test_results/test_send_results_as_events/events.json new file mode 100644 index 00000000..4fd6c01c --- /dev/null +++ b/test/test_results/test_send_results_as_events/events.json @@ -0,0 +1,40 @@ +[ + { + "eventType": "CUSTOM_INFO", + "title": "Test event for Data Volume", + "properties": { + "snowflake.table.update": 1736851468626000000, + "snowflake.data.rows": 6, + "snowflake.data.size": 1024, + "snowflake.table.time_since.last_update": 81983, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DEV_DB.PUBLIC.SALESMANAGERREGIONS", + "db.namespace": "DEV_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + } + }, + { + "eventType": "CUSTOM_INFO", + "title": "Test event for Data Volume", + "properties": { + "snowflake.table.ddl": 1733122324468000000, + "snowflake.table.update": 1741707972204000000, + "snowflake.data.rows": 0, + "snowflake.data.size": 0, + "snowflake.table.time_since.last_ddl": 144135, + "snowflake.table.time_since.last_update": 1041, + "snowflake.table.type": "BASE TABLE", + "db.collection.name": "DTAGENT_DB.STATUS.PROCESSED_QUERIES_CACHE", + "db.namespace": "DTAGENT_DB", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent" + } + } +] \ No newline at end of file diff --git a/test/test_results/test_shares/biz_events.json b/test/test_results/test_shares/biz_events.json new file mode 100644 index 00000000..ebab4a16 --- /dev/null +++ b/test/test_results/test_shares/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_shares", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_shares", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_shares/logs.json b/test/test_results/test_shares/logs.json new file mode 100644 index 00000000..2d012a6c --- /dev/null +++ b/test/test_results/test_shares/logs.json @@ -0,0 +1,56 @@ +[ + { + "content": "Outbound share details for DATA_SCIENTIST_DEVEL_DS_CI360_SHARE", + "snowflake.grant.created_on": 1687246726499000000, + "snowflake.grant.by": "DEMIGOD", + "snowflake.grant.grantee": "DEVDYNATRACEDIGITALBUSINESSDW.DATA_SCIENTIST_DEVEL_DS_CI360_SHARE", + "snowflake.grant.on": "DATABASE", + "snowflake.grant.privilege": "USAGE", + "snowflake.grant.to": "SHARE", + "snowflake.share.is_secure_objects_only": true, + "snowflake.share.kind": "OUTBOUND", + "snowflake.share.owner": "DEMIGOD", + "snowflake.share.shared_from": "WMBJBCQ.DEVDYNATRACEDIGITALBUSINESSDW", + "snowflake.share.shared_to": "WMBJBCQ.CI360TESTACCOUNT", + "db.namespace": "DATA_SCIENTIST_DEV_DB", + "snowflake.grant.name": "DATA_SCIENTIST_DEV_DB", + "snowflake.share.name": "DATA_SCIENTIST_DEVEL_DS_CI360_SHARE", + "dsoa.run.context": "outbound_shares" + }, + { + "content": "Outbound share details for DATA_SCIENTIST_DEVEL_DS_CI360_SHARE", + "snowflake.grant.created_on": 1668416468928000000, + "snowflake.grant.by": "INTEGRATION_CONSUMPTION_FORECASTING_ROLE", + "snowflake.grant.grantee": "DEVDYNATRACEDIGITALBUSINESSDW.DATA_SCIENTIST_DEVEL_DS_CI360_SHARE", + "snowflake.grant.on": "SCHEMA", + "snowflake.grant.privilege": "USAGE", + "snowflake.grant.to": "SHARE", + "snowflake.share.is_secure_objects_only": true, + "snowflake.share.kind": "OUTBOUND", + "snowflake.share.owner": "DEMIGOD", + "snowflake.share.shared_from": "WMBJBCQ.DEVDYNATRACEDIGITALBUSINESSDW", + "snowflake.share.shared_to": "WMBJBCQ.CI360TESTACCOUNT", + "db.namespace": "DATA_SCIENTIST_DEV_DB", + "snowflake.grant.name": "DATA_SCIENTIST_DEV_DB.ACCOUNT_EXPERIENCE", + "snowflake.share.name": "DATA_SCIENTIST_DEVEL_DS_CI360_SHARE", + "dsoa.run.context": "outbound_shares" + }, + { + "content": "Inbound share details for BIET_MONITORING_SHARE", + "snowflake.share.has_details_reported": true, + "snowflake.share.kind": "INBOUND", + "snowflake.share.shared_from": "WMBJBCQ.CI360TESTACCOUNT", + "db.namespace": "CI360_SHARE_MONITORING_DB", + "snowflake.share.name": "BIET_MONITORING_SHARE", + "dsoa.run.context": "inbound_shares" + }, + { + "content": "Inbound share details for BIET_MONITORING_SHARE", + "snowflake.share.has_details_reported": true, + "snowflake.share.kind": "INBOUND", + "snowflake.share.shared_from": "WMBJBCQ.DYNATRACEDIGITALBUSINESSDW", + "db.namespace": "DT_SHARE_MONITORING_DB", + "snowflake.share.name": "BIET_MONITORING_SHARE", + "dsoa.run.context": "inbound_shares" + } +] \ No newline at end of file diff --git a/test/test_results/test_tasks/biz_events.json b/test/test_results/test_tasks/biz_events.json new file mode 100644 index 00000000..08edbccb --- /dev/null +++ b/test/test_results/test_tasks/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_tasks", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_tasks", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_tasks/logs.json b/test/test_results/test_tasks/logs.json new file mode 100644 index 00000000..1656d19d --- /dev/null +++ b/test/test_results/test_tasks/logs.json @@ -0,0 +1,32 @@ +[ + { + "content": "New Tasks History entry for DTAGENT_DB", + "snowflake.task.graph.root_id": "01bb391a-b277-2d03-0000-000000000d2d", + "snowflake.task.graph.version": 2, + "snowflake.task.run.attempt": 1, + "snowflake.task.run.group_id": "484a88f5-af2d-4d24-9bea-f4adf7c23c1b", + "snowflake.task.run.id": 1745884800000, + "snowflake.task.run.scheduled_from": "SCHEDULE", + "snowflake.task.run.scheduled_time": "2025-04-29 00:00:00.000 Z", + "snowflake.task.run.state": "SCHEDULED", + "db.namespace": "DTAGENT_DB", + "snowflake.schema.name": "APP", + "snowflake.task.name": "TASK_DTAGENT_USERS", + "dsoa.run.context": "task_history" + }, + { + "content": "New Tasks History entry for DTAGENT_DB", + "snowflake.task.graph.root_id": "01bb391a-0307-d549-0000-000000000d22", + "snowflake.task.graph.version": 2, + "snowflake.task.run.attempt": 1, + "snowflake.task.run.group_id": "b3a683bb-c10c-4ce6-b24d-5babf7c4dd79", + "snowflake.task.run.id": 1745869628961, + "snowflake.task.run.scheduled_from": "SCHEDULE", + "snowflake.task.run.scheduled_time": "2025-04-28 19:47:08.961 Z", + "snowflake.task.run.state": "SCHEDULED", + "db.namespace": "DTAGENT_DB", + "snowflake.schema.name": "APP", + "snowflake.task.name": "TASK_DTAGENT_DATA_SCHEMAS", + "dsoa.run.context": "task_history" + } +] \ No newline at end of file diff --git a/test/test_results/test_trust_center/biz_events.json b/test/test_results/test_trust_center/biz_events.json new file mode 100644 index 00000000..31711418 --- /dev/null +++ b/test/test_results/test_trust_center/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_trust_center", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_trust_center", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_trust_center/logs.json b/test/test_results/test_trust_center/logs.json new file mode 100644 index 00000000..90043445 --- /dev/null +++ b/test/test_results/test_trust_center/logs.json @@ -0,0 +1,36 @@ +[ + { + "content": "TrustCenter event: [MEDIUM] Native Apps Event Sharing Check Ensure Event Table is configured for Native Application event sharing", + "status_code": "OK", + "error.code": "SECURITY_ESSENTIALS_NA_CONSUMER_ES_CHECK", + "event.id": 252009, + "event.kind": "SECURITY_EVENT", + "snowflake.trust_center.scanner.description": "Ensure Event Table is configured for Native Application event sharing", + "snowflake.trust_center.scanner.name": "Native Apps Event Sharing Check", + "snowflake.trust_center.scanner.package.name": "Security Essentials", + "status.message": "[MEDIUM] Native Apps Event Sharing Check Ensure Event Table is configured for Native Application event sharing", + "event.category": "Vulnerability management", + "snowflake.trust_center.scanner.id": "SECURITY_ESSENTIALS_NA_CONSUMER_ES_CHECK", + "snowflake.trust_center.scanner.package.id": "SECURITY_ESSENTIALS", + "snowflake.trust_center.scanner.type": "Vulnerability", + "vulnerability.risk.level": "MEDIUM", + "dsoa.run.context": "trust_center" + }, + { + "content": "TrustCenter event: [CRITICAL] 3.1 Ensure that an account-level network policy has been configured to only allow access from trusted IP addresses", + "status_code": "OK", + "error.code": "SECURITY_ESSENTIALS_CIS3_1", + "event.id": 252010, + "event.kind": "SECURITY_EVENT", + "snowflake.trust_center.scanner.description": "Ensure that an account-level network policy has been configured to only allow access from trusted IP addresses", + "snowflake.trust_center.scanner.name": 3.1, + "snowflake.trust_center.scanner.package.name": "Security Essentials", + "status.message": "[CRITICAL] 3.1 Ensure that an account-level network policy has been configured to only allow access from trusted IP addresses", + "event.category": "Vulnerability management", + "snowflake.trust_center.scanner.id": "SECURITY_ESSENTIALS_CIS3_1", + "snowflake.trust_center.scanner.package.id": "SECURITY_ESSENTIALS", + "snowflake.trust_center.scanner.type": "Vulnerability", + "vulnerability.risk.level": "CRITICAL", + "dsoa.run.context": "trust_center" + } +] \ No newline at end of file diff --git a/test/test_results/test_trust_center/metrics.txt b/test/test_results/test_trust_center/metrics.txt new file mode 100644 index 00000000..6bee687d --- /dev/null +++ b/test/test_results/test_trust_center/metrics.txt @@ -0,0 +1,3 @@ +snowflake.trust_center.findings,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",event.category="Warning",snowflake.trust_center.scanner.id="CIS_BENCHMARKS_CIS2_5",snowflake.trust_center.scanner.package.id="CIS_BENCHMARKS",snowflake.trust_center.scanner.type="Vulnerability",vulnerability.risk.level="LOW" 0 0 +#snowflake.trust_center.findings gauge dt.meta.displayName="Trust Center Findings Count",dt.meta.unit="count" +snowflake.trust_center.findings,db.system="snowflake",service.name="test.dsoa2025",deployment.environment="TEST",host.name="test.dsoa2025.snowflakecomputing.com",event.category="Warning",snowflake.trust_center.scanner.id="CIS_BENCHMARKS_CIS2_7",snowflake.trust_center.scanner.package.id="CIS_BENCHMARKS",snowflake.trust_center.scanner.type="Vulnerability",vulnerability.risk.level="LOW" 0 0 \ No newline at end of file diff --git a/test/test_results/test_users/biz_events.json b/test/test_results/test_users/biz_events.json new file mode 100644 index 00000000..17c8b6d5 --- /dev/null +++ b/test/test_results/test_users/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_users", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_users", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/test/test_results/test_users/logs.json b/test/test_results/test_users/logs.json new file mode 100644 index 00000000..b9c4b59f --- /dev/null +++ b/test/test_results/test_users/logs.json @@ -0,0 +1,87 @@ +[ + { + "content": "User details for TERRAFORM_USER", + "snowflake.user.created_on": 1649326301806000000, + "snowflake.user.display_name": "TERRAFORM_USER", + "snowflake.user.has_password": true, + "snowflake.user.id": 512, + "snowflake.user.last_success_login": 1725288701845000000, + "snowflake.user.name": "TERRAFORM_USER", + "snowflake.user.owner": "SECURITYADMIN", + "snowflake.user.password_last_set_time": 1720426231840000000, + "db.user": "TERRAFORM_USER", + "dsoa.run.context": "users" + }, + { + "content": "User details for TEST_PIPELINE", + "snowflake.user.created_on": 1679517316002000000, + "snowflake.user.default.namespace": "TEST_DB.ETL", + "snowflake.user.default.role": "TEST_PIPELINE_ROLE", + "snowflake.user.default.warehouse": "TEST_ETL_PIPELINE_WH", + "snowflake.user.display_name": "TEST_PIPELINE", + "snowflake.user.has_password": true, + "snowflake.user.id": 623, + "snowflake.user.last_success_login": 1743512296000000000, + "snowflake.user.name": "TEST_PIPELINE", + "snowflake.user.owner": "SECURITYADMIN", + "snowflake.user.password_last_set_time": 1679517316030000000, + "db.user": "TEST_PIPELINE", + "dsoa.run.context": "users" + }, + { + "content": "User direct roles removed since 1970-01-01 00:00:00.000 Z", + "snowflake.user.roles.direct.removed": "SCRATCHPAD_ROLESCRATCHPAD_ROLESCRATCHPAD_ROLE", + "snowflake.user.roles.direct.removed_on": 1621598400000000000, + "db.user": "DEV_SF_BI_MODELER", + "dsoa.run.context": "users" + }, + { + "content": "User direct roles removed since 1970-01-01 00:00:00.000 Z", + "snowflake.user.roles.direct.removed": "DEVEL_PIPELINE_ROLE", + "snowflake.user.roles.direct.removed_on": 1622116800000000000, + "db.user": "DEVEL_PIPELINE", + "dsoa.run.context": "users" + }, + { + "content": "users", + "snowflake.user.roles.granted": "BI_MODELER,SCRATCHPAD_ROLE,DATAMODEL_UPGRADER,BI_REPORTING,COLDSTORE,PIPELINE,DEV_SF_DATAMODELUPGRADER_ROLE", + "snowflake.user.roles.granted_by": [ + "SECURITYADMIN" + ], + "snowflake.user.roles.last_altered": 1615219847000000000, + "db.user": "ARTURBORGATTO", + "dsoa.run.context": "users" + }, + { + "content": "users", + "snowflake.user.roles.granted": "TEST_DB_OWNER_ROLE,REPORTS_FINANCIAL,EXTENSIONREPOSITORYINFO_BASIC,DEVACT_BASIC,DEVEL_DATAMODEL_UPGRADER_ROLE,DAVIS_FULL,SANDBOX_TEST_DATAMODEL_UPGRADER_ROLE,SANDBOX_TEST_READONLY_USER_ROLE,BI_MODELER,REPORTS_BASIC,JIRA_SENSITIVE,POWERBILOG_BASIC,BI_BASIC,INTERCOM_FINANCIAL,SANDBOX_TEST_DB_OWNER_ROLE,POWERBILOG_FULL,INTERCOM_SENSITIVE,REPORTS_FULL,SANDBOX_TEST_PIPELINE_ROLE,INTERNALCOSTS_FINANCIAL,DEVELCLONE_BI_REPORTING,WOOPRA_FINANCIAL,IEM_BASIC,INTERNALCOSTS_SENSITIVE,BI_FINANCIAL,POWERBILOG_FINANCIAL,DEVACT_FINANCIAL,DAVIS_BASIC,APPSEC_SENSITIVE,METADATA_FINANCIAL,JIRA_FULL,UNIVERSITY_FULL,RAW_FULL,ZENDESK_SENSITIVE,CONSUMPTION_FULL,INTERCOM_BASIC,DATAMODEL_UPGRADER,DEVEL_SYSADMIN_ROLE,SOFTCOMP_FINANCIAL,RUM_FULL,SNOWFLAKE_FINANCE,WOOPRA_BASIC,REPORTS_CONSUMPTION,CONSUMPTION_SENSITIVE,DEVEL_SECURITYADMIN_ROLE,DEVELCLONE_PIPELINE,AUTOPROV_BASIC,CONSUMPTION_FINANCIAL,REPORTS_SENSITIVE,CONSUMPTION_BASIC,METADATAAUDIT_SENSITIVE,LIMA_SENSITIVE,LIMA_BASIC,SYSADMIN,SFM_SENSITIVE,IEM_FULL,WOOPRA_SENSITIVE,TEST_POWERBI_ROLE,DEVEL_PIPELINE_ROLE,TEST_DATAMODEL_UPGRADER_ROLE,DEV_SF_DATAMODELUPGRADER_ROLE,LIMA_FULL,WOOPRA_FULL,CDH_FINANCIAL,DEVEL_COLDSTORE_ROLE,TEAMS_FULL,BAS_SENSITIVE,BI_REPORTING,ALL_FINANCIAL,SYNTHETIC_FINANCIAL,REVENUE_SENSITIVE,SANDBOX_TEST_COLDSTORE_ROLE,SALESFORCE_FINANCIAL,COMMUNITY_FINANCIAL,PIPELINE,APPSEC_FULL,INTERNALCOSTS_FULL,DATAQUALITY_FINANCIAL,SANDBOX_ANDRZEJ_BI_MODELER,SOFTCOMP_FULL,INTERCOM_FULL,BAS_FINANCIAL,SALESFORCE_SENSITIVE,EXTENSIONREPOSITORYINFO_FULL,ZENDESK_FINANCIAL,UNIVERSITY_SENSITIVE,METADATA_BASIC,RNDWORKLOGS_FINANCIAL,EMPLOYEES_SENSITIVE,DATAQUALITY_SENSITIVE,MONITORING,ALL_SENSITIVE,INTERNALCOSTS_BASIC,ALL_FULL,DEVEL_BI_MODELER_ROLE,REPORTS_TECHNOLOGY,TEAMS_SENSITIVE,DEVEL_BI_REPORTING_ROLE,DEVACT_FULL,TERRAFORM_USER_ROLE,RUM_FINANCIAL,EXTENSIONREPOSITORYINFO_FINANCIAL,AUTOPROV_FULL,UNIVERSITY_FINANCIAL,METADATAAUDIT_FINANCIAL,SCRATCHPAD_ROLE,POWERBI_MODEL,IEM_FINANCIAL,TEST_ETL_DQ_CHECKS_ROLE,SOFTCOMP_SENSITIVE,SYNTHETIC_FULL,COMMUNITY_BASIC,SANDBOX_TEST_BI_REPORTING_ROLE,COMMUNITY_FULL,JIRA_BASIC,COLDSTORE,SOFTCOMP_BASIC,SANDBOX_TEST_POWERBI_ROLE,METADATA_FULL,ZENDESK_BASIC,SFM_FULL,JIRA_FINANCIAL,COMMUNITY_SENSITIVE,EMPLOYEES_FULL,TEST_BI_REPORTING_ROLE,TEST_PIPELINE_ROLE,CDH_BASIC,DAVIS_SENSITIVE,IEM_SENSITIVE,METADATAAUDIT_FULL,AUTOPROV_FINANCIAL,DAVIS_FINANCIAL,EXTENSIONREPOSITORYINFO_SENSITIVE,RUM_SENSITIVE,APPSEC_BASIC,EMPLOYEES_FINANCIAL,RUM_BASIC,CDH_SENSITIVE,METADATA_SENSITIVE,SYNTHETIC_BASIC,ALL_BASIC,SECURITYADMIN,TEST_BI_PREDICTIONS_ROLE,SANDBOX_TEST_BI_PREDICTIONS_ROLE,SFM_FINANCIAL,TEAMS_FINANCIAL,DATAQUALITY_BASIC,TEAMS_BASIC,BI_SENSITIVE,RNDWORKLOGS_FULL,TEST_SYSADMIN,BAS_BASIC,TEST_COLDSTORE_ROLE,DEVELCLONE_BI_MODELER,REVENUE_FULL,APPSEC_FINANCIAL,SALESFORCE_FULL,EMPLOYEES_BASIC,BAS_FULL,AUTOPROV_SENSITIVE,DATAQUALITY_FULL,CDH_FULL,REVENUE_BASIC,RNDWORKLOGS_SENSITIVE,SANDBOX_ANDRZEJ_BI_REPORTING,METADATAAUDIT_BASIC,POWERBILOG_SENSITIVE,REVENUE_FINANCIAL,ANY_BASIC,SANDBOX_TEST_BI_MODELER_ROLE,SANDBOX_ANDRZEJ_PIPELINE,DEVOPS_ROLE,SALESFORCE_BASIC,TEST_BI_MODELER_ROLE,LIMA_FINANCIAL,SANDBOX_ANDRZEJ_DATAMODEL_UPGRADER,ZENDESK_FULL,DEVELCLONE_DATAMODEL_UPGRADER,UNIVERSITY_BASIC,RNDWORKLOGS_BASIC,SYNTHETIC_SENSITIVE,SFM_BASIC,DEVACT_SENSITIVE", + "snowflake.user.roles.granted_by": [ + "DEMIGOD" + ], + "snowflake.user.roles.last_altered": 1649326499175000000, + "db.user": "TERRAFORM_USER", + "dsoa.run.context": "users" + }, + { + "content": "users", + "snowflake.user.privilege": "REFERENCES:TABLE", + "snowflake.user.privilege.granted_by": [ + "SECURITYADMIN" + ], + "snowflake.user.privilege.grants": "FACT_HOSTS,TMP_DEMO_LOCAL_TEMPORARY,DIM_ENVIRONMENT,CDH_MAINFRAME_MSU_HISTORY,CDH_DDU_METRICS_BY_METRIC_HISTORY,CDH_DDU_TRACES_BY_ENTITY_HISTORY,CDH_ODIN_AGENT_HISTORY,CDH_DEEP_MONITORING_SETTINGS_HISTORY,DIM_PRODUCT,DISCOVERED_CLOUD_SERVICES_REPORT,CDH_SERVICE_HISTORY,FACT_ENTITY_TAG_COVERAGE,CDH_COMPETITOR_JS_FRAMEWORK_USAGE_HISTORY,FACT_API_USER_AGENT_USAGE,DIM_EXTENSION,TENANT_STATUS,CDH_PROBLEM_EVENT_METADATA_HISTORY,CDH_CUSTOM_SESSIONS_APPLICATION_TECHNOLOGY_BILLING_TYPE_HISTORY,CDH_DDU_TRACES_BY_DESCRIPTION_HISTORY,CDH_PROBLEM_ROOT_CAUSE_GROUP_HISTORY,DIM_DEVICE_TYPE,DIM_PROCESS_GROUP,DC_JIRA_REQUESTS,FACT_COLUMN_PROTECTION,CDH_CONTAINER_GROUP_HISTORY,SFDC_PROJECT,CDH_CLUSTER_NETWORK_ZONE_STATS_HISTORY,DIM_HOST,REPORTS_EXECUTION_LOG,DIM_PROBLEM_EVENT_STATUS,CDH_JS_FRAMEWORK_USAGE_HISTORY,FACT_CUSTOMER_ACCOUNTS,DAVIS_CHANNEL_CONFIGURATION,CDH_DEEP_MONITORING_SETTINGS_FEATURES_HISTORY,FACT_CF_FOUNDATIONS,CDH_INTERNAL_ENTITY_MODEL_CAPPING_INFORMATION_HISTORY,R,BAS_AUDIT_FIELD,DIM_CLOUD_APPLICATION_INSTANCE_TYPE,WOOPRA_PAGEVIEW,DIM_CLOUD_APPLICATION_TYPE,DIM_SESSION_CITY,DIM_AREA,BILLING_USAGE,RUM_PAGEVIEW,TIM,FACT_CLOUD_APPLICATION_INSTANCES,DIM_SESSION_REGION,BAS_USER,FACT_TABLE_USAGE,DAVIS_USER,DIM_AGENT_ATTRIBUTES,ALECKI_INT,MANAGED_CLUSTER,DIM_HOST_ATTRIBUTES_HISTORY,CONTRACT,CDH_TOTAL_FDI_EVENT_COUNT_HISTORY,TENANT_LICENSE,DAVIS_USAGE,ENVIRONMENT_USAGE_DAILY_SUMMARY_VIEW,DIM_DEM_GOALS,FACT_PROBLEMS,DIM_USAGE_TYPE,INFRASTRUCTURE_SOLUTION_ACCOUNTS,INTERCOM_CONVERSATION_PARTS,CDH_SESSION_STORAGE_USAGE_HISTORY,ALECKI_ALL,CDH_METRIC_EVENT_CONFIG_THRESHOLD_BASED_MODEL_HISTORY,Z,CDH_FEATURE_FLAG_HISTORY,SFDC_ACCOUNT,PRIMKEY,CDH_METRIC_QUERY_STATS_HISTORY,ALECKI_VARCHAR,CDH_SYNTHETIC_MONITOR_LOCATION_HISTORY,PARTNER_REFERRAL,FACT_OPPORTUNITIES,EMPLOYEE_COUNT,CDH_BILLING_APP_SESSIONS_HISTORY,TENANT,DIM_PRODUCT_USER,SQL_LOG,TENANT_LAST_ACCESS_DATE,FACT_ACTIVE_GATE_UPDATE_STATUS,DIM_CLOUD_APPLICATION_NAMESPACE,DIM_OPPORTUNITY_STAGE,BI_STATUS,FACT_AGENT_TECHNOLOGIES,DIM_ACTIVE_GATE,ALECKI_DATE,CDH_ACTIVE_GATE_MODULES_STATUSES_HISTORY,CDH_ODIN_AGENT_ME_IDENTIFIER_HISTORY,DIM_API_ENDPOINT,DEF_EXAMPLE,CDH_TENANT_NETWORK_ZONE_STATS_HISTORY,FACT_APPLICATIONS,CDH_PLUGIN_METRIC_STATS_HISTORY,CDH_TAG_COVERAGE_HISTORY,TYPES,DIM_QUALITY_TYPE,DIM_ENVIRONMENT_ATTRIBUTES,CDH_SOFTWARE_COMPONENT_DETAILS_EVIDENCE_HISTORY,DIM_KUBERNETES_CLUSTER,CDH_SOFTWARE_COMPONENT_DETAILS_HISTORY,FACT_TAG_COVERAGE,DIM_PRODUCT_BEHAVIORAL_EVENT,CDH_REQUEST_ATTRIBUTE_STATS_HISTORY,FACT_CONTRACT_USAGE,CDH_SECURITY_PROBLEM_HISTORY,DIM_AGENT,TENANT_USAGE_DAILY_SUMMARY,TENANT_USAGE_DAILY_SUMMARY_VIEW,FACT_API_USAGE_AGGR,FACT_PRODUCT_PAGE_VIEWS,DIM_DT_ACCOUNT,FACT_PROCESS_TECHNOLOGIES,DIM_POWERBI_COLUMN,CDH_TILE_FILTER_CONFIG_HISTORY,CDH_APPLICATION_HISTORY,CDH_ENVIRONMENT_RAW,CDH_PROBLEM_RANKED_ENTITY_HISTORY,ALECKI_DECIMAL,ACCOUNT_STATUS,DIM_CUSTOMER,CDH_SYNTHETIC_MONITOR_HISTORY,DIM_CLUSTER_ATTRIBUTES,MONTHLY_CONSUMPTION_EXT,CDH_FDI_EVENT_INSTANCE_CLASSES_HISTORY,CDH_CUSTOM_SESSIONS_APPLICATION_TECHNOLOGY_TYPE_HISTORY,DIM_GEOGRAPHY,FACT_CUSTOMER_SUPPORT,CDH_METRIC_EVENT_CONFIG_NAME_FILTER_HISTORY,COMPANY,CDH_CONTAINER_MEMORY_USAGE_HISTORY,DIM_PRODUCT_PAGE,DEC,CDH_LOG_MONITORING_STATS_HISTORY,DIM_ACTIVE_GATE_MODULE,DIM_VERSION,CDH_CF_FOUNDATION_HOST_HISTORY,INTERCOM_COMPANIES,CDH_CLOUD_APPLICATION_INSTANCE_HISTORY,HASHED_VALUES,DIM_POC,CDH_CONTAINER_GROUP_INSTANCE_HISTORY,DIM_CF_FOUNDATION,CDH_VULNERABILITY_MATCHING_METADATA_HISTORY,AUTOPROV_EVENTS_FEATURES,DIM_COUNTRY,CDH_METRIC_EVENT_CONFIG_HISTORY,DIM_TRIAL,CDH_DATABASE_INSIGHTS_ENDPOINT_DETAILS_HISTORY,FACT_CONTRACT_LATEST_USAGE,DIM_METRIC,CONTRACT_BILLING_INFO,DIM_ACTIVE_GATE_TYPE,DIM_DT_ACCOUNT_ATTRIBUTES,CDH_FDI_EVENT_METADATA_HISTORY,CDH_MOBILE_AGENT_VERSION_USAGE_HISTORY,RUM_BEHAVIORAL_EVENT_PROPERTIES,FACT_CONTAINER_GROUP_INSTANCES,CDH_MOBILE_CRASHES_BY_RETRIEVAL_DELAY_HISTORY,CDH_VIRTUALIZATION_HISTORY,CDH_ALERTING_PROFILE_HISTORY,CDH_DEEP_MONITORING_SETTINGS_FEATURE_V2_HISTORY,TENANT_USAGE,BILLING_PROVIDER,CDH_CLUSTER_HISTORY,REGION,MONTHLY_USAGE,DIM_CONTAINERIZATION_TYPE,CDH_ACTIVE_GATE_HISTORY,BI_TEST_5K,CDH_DASHBOARD_CONFIG_HISTORY,ALECKI_MIXT,DIM_POWERBI_MEASURE,DIM_VERSIONED_MODULE,CDH_FDI_EVENT_TYPE_AGGREGATIONS_HISTORY,CDH_PROBLEM_EVIDENCE_HISTORY_ARCHIVE,TABLE_LOAD_INFO,FACT_PRODUCT_PAGE_VIEWS_DAILY_AGGR,SQL_LOG_PIPELINE,BI_TEST_16M,SFDC_TENANT,PROMO_USAGE,CDH_CONDITIONAL_PROCEDURES_RULES_HISTORY,FACT_USER_GROUP_MAP,CDH_DASHBOARD_CONFIG_TILE_HISTORY,QUERY_STATS,TIME_ZONE,CDH_CLUSTER_TAGS_HISTORY,CDH_LOG_MONITORING_METRIC_STATS_HISTORY,DIM_VERBATIM_TYPE,DIM_REGION,CDH_UEM_CONFIG_PROPERTY_TAG_HISTORY,DIM_PROBLEM,CDH_DISCOVERED_VIRTUALIZATION_SERVICE_TYPES,MANAGED_LICENSE,USAGE_CREDITS,CDH_SOFTWARE_COMPONENT_PGI_HISTORY,DATA_VOLUME,DIM_ACTIVE_GATE_OS,ALECKI_CHAR,ALECKI_LONG,BAS_AUDIT_ENTRY,FACT_SERVICE_TECHNOLOGIES,FACT_CLOUD_APPLICATIONS,DIM_USER,WOOPRA_ACTION_PROPERTIES,DIM_EXTENSION_METRIC_GROUP,CDH_MONITORED_VIRTUALIZATION_SERVICE_TYPES,CDH_MOBILE_OS_VERSION_USAGE_HISTORY,DIM_PROBLEM_EVIDENCE_TYPE,TIM_CLONE,SFDC_POC,JIRA_ISSUES,FACT_HOST_TECHNOLOGIES,CDH_FDI_EVENT_HISTORY,CDH_ENVIRONMENTS,TENANT_USAGE_SUMMARY,CDH_SETTING_HISTORY,RR,DIM_HOST_ATTRIBUTES,DIM_SESSION_BROWSER,INTERCOM_CONVERSATIONS,SESSION_REPLAYS_REPORT,FACT_PRODUCT_BEHAVIORAL_EVENTS_AGGR,BI_TEST_1K,RUM_SESSION,DIM_TECHNOLOGY,DIM_PRODUCT_TYPE,ACCOUNT,INTERCOM_CONVERSATION_TAGS,CDH_ALERTING_PROFILE_SEVERITY_RULE_HISTORY,ALECKI_ALL_TYPES,SERVICE,CDH_KUBERNETES_NODE_HISTORY,DIM_CLUSTER,JOBSTATUS,SFDC_ASSIGNMENT,DIM_OPPORTUNITY_TYPE,BILLING_SERVICE_TYPE,FACT_PROCESS_ATTRIBUTES,CDH_PLUGIN_STATE_HISTORY,DIM_SERVICE,CDH_TAG_COVERAGE_ENTITIES_HISTORY,INTERCOM_CONTACTS,FACT_ACTIVE_GATE_MODULES_STATUSES,FACT_COLUMN_USAGE,CDH_DATABASE_INSIGHTS_HISTORY,SFDC_OPPORTUNITY,ISSUE_JIRA_REQUESTS,DIM_CONTRACT,FACT_VERSIONED_MODULES,SFDC_TRIAL,WOOPRA_SESSION,RUM_BEHAVIORAL_EVENTS,DIM_POC_PRODUCT,CDH_SOFTWARE_COMPONENT_DETAILS_PACKAGE_HISTORY,CDH_PREFERENCES_SETTINGS_HISTORY,CDH_SECURITY_PROBLEM_MUTE_STATE_HISTORY,CDH_CLUSTER_EMERGENCY_EMAILS_HISTORY,CDH_INTEGRATION_HISTORY,CDH_SECURITY_PROBLEM_SC_HISTORY,ALECKI_DOUBLE,DIM_CONTRACT_LIMIT_ATTRIBUTES,DIM_SCREEN_RESOLUTION,SERVICE_USAGE_SUMMARY,CDH_TOKEN_STATS_HISTORY,CDH_VERSIONED_MODULE_V2_HISTORY,FACT_ACCOUNT_VERTICALS,FACT_CUSTOMERS,FACT_PROBLEM_EVIDENCE,DIM_TABLE,SYSTEM_PROPERTIES,CDH_SECURITY_PROBLEM_ASSESSMENT_HISTORY,FACT_TRIALS,DIM_DATE,MONITORED_CLOUD_SERVICES_REPORT,CDH_VISITSTORE2_METRICS_HISTORY,CDH_SOFTWARE_COMPONENT_HISTORY,FACT_KUBERNETES_NODES,CDH_HOST_TECH_HISTORY,CDH_SOFTWARE_COMPONENT_DETAILS_VERSION_HISTORY,CDH_TOKEN_STATS_PERMISSION_HISTORY,FACT_POC,CDH_VISIT_STORE_USAGE_HISTORY,SFDC_TASK,FACT_CLOUD_APPLICATION_NAMESPACES,REFERRAL_CODE,DIM_CONTAINER_GROUP_INSTANCE,DAILY_USAGE,FACT_SESSIONS_DAILY_AGGR,CDH_CF_FOUNDATION_HISTORY,TIM2,CDH_HOST_HISTORY,CDH_CUSTOM_CHART_STATS_HISTORY,CDH_ACTIVE_GATE_UPDATE_STATUS_HISTORY,DTU_ACTIVITIES,DAVIS_ACCOUNT_LINK,CDH_AGENT_HISTORY,DIM_DT_ONE,CLOUD_ADOPTION,FACT_AGENTS,BAS_AUDIT_ENTITY,WOOPRA_ACTION,INTERCOM_ADMINS,ENVIRONMENT_USAGE_DAILY_SUMMARY,DIM_TABLE_STATUS,DIM_KUBERNETES_NODE,DIM_CONTAINER_PROVIDER_TYPE,HOST_USAGE_DAILY_SUMMARY,DC_AUDIT_LOG,CDH_CLOUD_NETWORK_INGRESS_HISTORY,CDH_VIRTUALIZATION_SUBSCRIPTION_HISTORY,DIM_AGENT_ENVIRONMENT,CDH_VERSIONED_MODULE_HISTORY,CDH_PLUGIN_HOST_DETAILS_HISTORY,CDH_UEM_CONFIG_TENANT_HISTORY,ENVIRONMENT_USAGE_SUMMARY,FACT_TABLE_GROUP_OWNERS,T,CDH_LOG_MONITORING_ES_STATS_HISTORY,CDH_METRIC_EVENT_CONFIG_ID_FILTER_HISTORY,CDH_PROBLEM_HISTORY,CDH_UEM_CONFIG_METADATA_CAPTURING_SETTINGS_HISTORY,DATASOURCES,DIM_SERVICE_TYPE,DIM_CUSTOMER_TASK,DIM_SESSION_OS,DIM_POWERBI_TABLE,SERVICE_USAGE_DAILY_SUMMARY,DIM_AGENT_TECHNOLOGY_TYPE,MANAGED_LICENSE_QUOTA,CDH_UEM_CONFIG_HISTORY,CDH_API_USAGE_HISTORY,DIM_API_USER_AGENT,TABLE_EXTRACT_INFO,xyz,DIM_APPLICATION,CDH_PROBLEM_EVIDENCE_HISTORY,REF,CDH_CLOUD_APPLICATION_NAMESPACE_HISTORY,CDH_CLOUD_NETWORK_SERVICE_HISTORY,DIM_SESSION_CONTINENT,DIM_CONDITIONAL_PROCEDURE,CDH_RELEASE_HISTORY,LIMITS,PROCESS_STATUS,INFRASTRUCTURE_SOLUTION_ENVIRONMENTS,AUTOPROV_EVENTS,BILLING_ACCOUNT,FACT_TABLE,CDH_CLOUD_APPLICATION_HISTORY,WOOPRA_PAGES,DIM_PROBLEM_SOURCE,ROLE,CDH_BILLING_SYNTHETIC_USAGE_HISTORY,CDH_FDI_EVENT_ENTITY_TYPE_AGGREGATIONS_HISTORY,CDH_PROBLEM_IMPACTED_ENTITIES_HISTORY,CLOUD_USAGE_REPORT,CDH_EXTENDED_TENANT_CONFIG_HISTORY,CDH_API_USER_AGENT_USAGE_HISTORY,DIM_COMPETITOR,DIM_OPPORTUNITY,FACT_PROBLEM_NATURAL_EVENTS,MC_ACCOUNT,FACT_PROBLEM_RANKED_ENTITIES,ALECKI_BOOLEAN,CDH_EXTRACT_STATISTICS,CDH_CONDITIONAL_PROCEDURES_HISTORY,CDH_CLUSTER_CONTACTS_HISTORY,CDH_ENDED_SESSIONS_HISTORY,FACT_CONDITIONAL_PROCEDURE_ENTITY_RULES,CDH_PROBLEM_NATURAL_EVENT_HISTORY,DIM_TABLE_GROUP,SFDC_MANAGED_LICENSE,DIM_CLOUD_APPLICATION_INSTANCE,DIM_CLOUD_APPLICATION,DIM_CONTAINER_GROUP,FACT_CUSTOMER_TASKS,DIM_POC_ACCOUNT,FACT_SESSIONS,DIM_POWERBI_STATE,DIM_HOST_TECHNOLOGY,CDH_CLOUD_NETWORK_POLICY_HISTORY,FACT_PROBLEM_IMPACTED_ENTITIES,CDH_SLO_HISTORY,FACT_PROCESSES,SQL_PERFORMANCE,CDH_DEEP_MONITORING_SETTINGS_V2_HISTORY,DIM_LICENSE,DIM_CURRENCY,PACKAGE,CDH_EXTENSION_HISTORY,UPGRADE_EXECUTION,R2,UNIQUE_HOSTS_TECHNOLOGY_HISTORY,MONTHLY_CONSUMPTION_REPORT,MONTHLY_CONSUMPTION_STAGING,CDH_PROBLEM_CAPPING_INFORMATION_HISTORY,FACT_CONTAINER_GROUPS,DIM_POWERBI_MODEL,PROMO_CODE,BI_TEST_200,ALECKI_FLOAT,REPORT_STATUS,TENANT_SUB_ENVIRONMENT,DIM_PROBLEM_EVENT_TYPE,INTERCOM_USERS,ENVIRONMENT_SERVICE_DAILY_SUMMARY,FACT_API_USAGE,BI_TEST_65K,FACT_COLUMN,DIM_VERTICAL,FACT_OPPORTUNITY_PRODUCTS,CDH_PROBLEM_EVENT_INSTANCE_CLASSES_HISTORY,USERS_AND_QUERIES_COUNT_STATS,CONTRACT_PRICING,EXTENSION_REPOSITORY_INFO,FACT_PRODUCT_BEHAVIORAL_EVENTS,CDH_PROCESS_HISTORY,SYNTHETIC_LOCATIONS,ALECKI_SHORT,WOOPRA_PAGEVIEW_BAS,BILLING_REQUEST,CDH_CLUSTERS,SFDC_DYNATRACE_ACCOUNT,DIM_APPLICATION_TYPE,MANAGED_ACCOUNT,ETL_DAILY_INGESTED_DATA_VOLUME,ALECKI_TIMESTAMP,DAVIS_TENANT,FACT_SERVICES,ENVIRONMENT_SERVICE_SUMMARY,DIM_CLOUD_APPLICATION_INSTANCE_PHASE,FACT_ACTIVE_GATES,CDH_METRIC_EVENT_CONFIG_COUNT_HISTORY,DIM_COLUMN,FACT_DATA_QUALITY_ISSUES,SFDC_OPPORTUNITY_PRODUCT,DIM_PROCESS,FACT_ENVIRONMENT_USAGE,BI_TEST_100,CDH_CONTAINER_MEMORY_LIMIT_HISTORY,FACT_DDU_METRICS,ALECKI_TIMESTAMP_TZ,FACT_COLUMN_DEPENDENCIES", + "snowflake.user.privilege.last_altered": 1615479617462000000, + "db.user": "PIPELINE", + "dsoa.run.context": "users" + }, + { + "content": "users", + "snowflake.user.privilege": "REFERENCES:VIEW", + "snowflake.user.privilege.granted_by": [ + "SECURITYADMIN" + ], + "snowflake.user.privilege.grants": "FACT_PROBLEM_IMPACTED_ENTITIES,FACT_OPPORTUNITY_PRODUCTS,DIM_API_ENDPOINT,CDH_PROBLEM_EVENT_METADATA_HISTORY,FACT_AGENT_TECHNOLOGIES,CDH_SOFTWARE_COMPONENT_DETAILS_VERSION_HISTORY,SFDC_TENANT,CDH_CONTAINER_GROUP_HISTORY,CDH_PROBLEM_NATURAL_EVENT_HISTORY,BAS_MANAGED_LICENSE,CDH_COMPETITOR_JS_FRAMEWORK_USAGE_HISTORY,VW_REP_DATE_DIMENSION,DEHASH_TENANT,CDH_TOKEN_STATS_HISTORY,CDH_CONDITIONAL_PROCEDURES_HISTORY,V_KEY_USER_ACTION,FACT_APPLICATIONS,CDH_PROBLEM_CAPPING_INFORMATION_HISTORY,CDH_PROBLEM_IMPACTED_ENTITIES_HISTORY,DIM_VERTICAL,BAS_PROMO_USAGE,INTERCOM_CONTACTS,CDH_CLOUD_APPLICATION_NAMESPACE_HISTORY,CDH_API_USER_AGENT_USAGE_HISTORY,DIM_CLOUD_APPLICATION_INSTANCE,FACT_PROBLEMS,FACT_POC,FACT_ACTIVE_GATES,AUTOPROV_EVENTS,CDH_DISCOVERED_VIRTUALIZATION_SERVICE_TYPES,CDH_DASHBOARD_CONFIG_HISTORY,CDH_LOG_MONITORING_STATS_HISTORY,CDH_JS_FRAMEWORK_USAGE_HISTORY,V_LOG_EVENTS,DIM_PROBLEM_EVENT_STATUS,RUM_BEHAVIORAL_EVENT_PROPERTIES,DIM_POC,CDH_SESSION_STORAGE_USAGE_HISTORY,DIM_DT_ONE,DIM_SERVICE_TYPE,CDH_SECURITY_PROBLEM_ASSESSMENT_HISTORY,DIM_CF_FOUNDATION,BAS_TENANT_SUB_ENVIRONMENT,RUM_SESSION,CDH_ALERTING_PROFILE_SEVERITY_RULE_HISTORY,FACT_API_USAGE,JIRA_ISSUES,FACT_ENVIRONMENT_UNITS_CONSUMPTION,BAS_ENVIRONMENT_SERVICE_SUMMARY,CDH_ODIN_AGENT_HISTORY,DIM_PROBLEM_EVENT_TYPE,DIM_SESSION_OS,BAS_COMPANY,FACT_DDU_METRICS,BAS_SFDC_TRIAL,BAS_ROLE,V_CLOUD_AUTOMATION_SOLUTION,CDH_INTERNAL_ENTITY_MODEL_CAPPING_INFORMATION_HISTORY,DIM_HOST_ATTRIBUTES,CDH_FDI_EVENT_HISTORY,CDH_METRIC_EVENT_CONFIG_THRESHOLD_BASED_MODEL_HISTORY,CDH_SETTING_HISTORY,DIM_PROCESS,DIM_POC_PRODUCT,DIM_APPLICATION,DIM_TECHNOLOGY,DIM_PRODUCT_BEHAVIORAL_EVENT,BAS_BILLING_PROVIDER,CDH_TILE_FILTER_CONFIG_HISTORY,CDH_CLOUD_NETWORK_SERVICE_HISTORY,BAS_USER,BAS_TIME_ZONE,BAS_AUDIT_ENTITY,CDH_SYNTHETIC_MONITOR_LOCATION_HISTORY,BAS_CONTRACT,CDH_REQUEST_ATTRIBUTE_STATS_HISTORY,MONTHLY_CONSUMPTION_EXT,DIM_SALES_REGION,CDH_METRIC_EVENT_CONFIG_NAME_FILTER_HISTORY,BAS_ACCOUNT_STATUS,V_APPS_AND_MICROSERVICES_OPENT,CDH_ACTIVE_GATE_UPDATE_STATUS_HISTORY,CDH_UEM_CONFIG_HISTORY,CONTRACT_CONSUMPTION_LATEST,WOOPRA_ACTION,CDH_SECURITY_PROBLEM_HISTORY,DAVIS_USER,DIM_ACTIVE_GATE_MODULE,DAVIS_TENANT,INTERCOM_USERS,CDH_ENVIRONMENTS,CDH_SYNTHETIC_MONITOR_HISTORY,DIM_ENVIRONMENT,RUM_PAGEVIEW,DIM_EXTENSION_METRIC_GROUP,CDH_TOKEN_STATS_PERMISSION_HISTORY,CDH_CUSTOM_SESSIONS_APPLICATION_TECHNOLOGY_TYPE_HISTORY,DIM_SERVICE,DIM_SESSION_CITY,V_RUM_PROPERTIES,V_DEM_CUSTOM_APPLICATION_SESSION,CDH_VIRTUALIZATION_SUBSCRIPTION_HISTORY,V_COVID_19_CONSUMPTION,CDH_CLOUD_APPLICATION_HISTORY,CDH_SOFTWARE_COMPONENT_PGI_HISTORY,INTERCOM_CONVERSATION_PARTS,CDH_CLOUD_NETWORK_INGRESS_HISTORY,CDH_TAG_COVERAGE_HISTORY,WOOPRA_PAGEVIEW,CDH_FDI_EVENT_METADATA_HISTORY,V_COLUMN_USAGE_LOG,WOOPRA_PAGEVIEW_BAS,CDH_FDI_EVENT_ENTITY_TYPE_AGGREGATIONS_HISTORY,DIM_SESSION_CONTINENT,TYPES_V,DIM_HOST_TECHNOLOGY,CDH_CLUSTERS,BAS_BILLING_SERVICE_TYPE,FACT_HOSTS_AGG_MONTH,CDH_FDI_EVENT_TYPE_AGGREGATIONS_HISTORY,DIM_VERBATIM_TYPE,CDH_METRIC_EVENT_CONFIG_HISTORY,CDH_FEATURE_FLAG_HISTORY,DAILY_USAGE,BAS_AUDIT_ENTRY,CDH_CLUSTER_TAGS_HISTORY,DIM_LICENSE,BAS_BILLING_USAGE,CDH_ACTIVE_GATE_MODULES_STATUSES_HISTORY,CDH_ACTIVE_GATE_HISTORY,CDH_PROBLEM_RANKED_ENTITY_HISTORY,CDH_METRIC_EVENT_CONFIG_COUNT_HISTORY,SFDC_OPPORTUNITY,CDH_HOST_TECH_HISTORY,DIM_CONTAINER_GROUP_INSTANCE,CDH_INTEGRATION_HISTORY,EXTENSION_REPOSITORY_INFO,VW_REP_SNOWFLAKE_STORAGE_USAGE_MONTHLY_SUMMARY,CDH_VIRTUALIZATION_HISTORY,CDH_BILLING_SYNTHETIC_USAGE_HISTORY,FACT_CF_FOUNDATIONS,CDH_CLUSTER_HISTORY,DIM_DT_ACCOUNT,DIM_USAGE_TYPE,DIM_OPPORTUNITY,CDH_CUSTOM_CHART_STATS_HISTORY,DIM_CURRENCY,INTERCOM_CONVERSATIONS,DIM_CLUSTER,CDH_MONITORED_VIRTUALIZATION_SERVICE_TYPES,DIM_CONTAINERIZATION_TYPE,V_DEM_STAR_RATING,DIM_DEVICE_TYPE,CDH_CUSTOM_SESSIONS_APPLICATION_TECHNOLOGY_BILLING_TYPE_HISTORY,DIM_OPPORTUNITY_TYPE,FACT_TRIALS,CDH_TENANT_NETWORK_ZONE_STATS_HISTORY,CDH_CLOUD_APPLICATION_INSTANCE_HISTORY,DIM_SCREEN_RESOLUTION,BAS_TENANT,DAVIS_CHANNEL_CONFIGURATION,RUM_BEHAVIORAL_EVENTS,CDH_FDI_EVENT_INSTANCE_CLASSES_HISTORY,DIM_METRIC,DIM_COMPETITOR,FACT_PROBLEM_EVIDENCE,DIM_CLOUD_APPLICATION_NAMESPACE,DIM_PRODUCT_PAGE,CDH_SECURITY_PROBLEM_MUTE_STATE_HISTORY,DIM_PROCESS_GROUP,CDH_APPLICATION_HISTORY,CDH_PLUGIN_HOST_DETAILS_HISTORY,CDH_MAINFRAME_MSU_HISTORY,DIM_TRIAL,CDH_CLUSTER_CONTACTS_HISTORY,V_ABUSIVE_TRIALS,FACT_API_USER_AGENT_USAGE,DIM_API_USER_AGENT,BAS_ACCOUNT,DEHASH_CLUSTER,DIM_APPLICATION_TYPE,BAS_ENVIRONMENT_USAGE_SUMMARY,SFDC_TASK,CDH_CONTAINER_GROUP_INSTANCE_HISTORY,FACT_PROCESS_TECHNOLOGIES,CDH_PLUGIN_STATE_HISTORY,BAS_TENANT_USAGE_SUMMARY,FACT_SERVICES,A,CDH_METRIC_QUERY_STATS_HISTORY,CDH_CF_FOUNDATION_HISTORY,BAS_TENANT_USAGE,CDH_CF_FOUNDATION_HOST_HISTORY,REFERRAL_CODE,DIM_KUBERNETES_NODE,CDH_SECURITY_PROBLEM_SC_HISTORY,UNIQUE_HOSTS_TECHNOLOGY_HISTORY_NEW,DIM_VERSIONED_MODULE,CDH_ALERTING_PROFILE_HISTORY,CDH_TOTAL_FDI_EVENT_COUNT_HISTORY,MC_MANAGED_LICENSE_QUOTA,SFDC_OPPORTUNITY_PRODUCT,DIM_CONTRACT_LIMIT_ATTRIBUTES,FACT_AGENTS,DIM_CUSTOMER,FACT_CONTAINER_GROUP_INSTANCES,DIM_DATE,BAS_TENANT_LICENSE,SFDC_PROJECT,CONTRACT_CONSUMPTION,CDH_UEM_CONFIG_PROPERTY_TAG_HISTORY,BAS_TENANT_USAGE_DAILY_SUMMARY_VIEW,BAS_TENANT_STATUS,V_DEM_GOALS,CDH_MOBILE_OS_VERSION_USAGE_HISTORY,DIM_HOST_ATTRIBUTES_HISTORY,BAS_EMPLOYEE_COUNT,CDH_SOFTWARE_COMPONENT_DETAILS_HISTORY,FACT_CUSTOMER_ACCOUNTS,DIM_PROBLEM_EVIDENCE_TYPE,CDH_EXTENSION_HISTORY,FACT_CONTAINER_GROUPS,DIM_CLOUD_APPLICATION_INSTANCE_PHASE,FACT_CUSTOMER_TASKS,DIM_AGENT,CUSTOMER_ACCOUNT_MAPPING,CDH_SOFTWARE_COMPONENT_DETAILS_PACKAGE_HISTORY,DIM_PROBLEM,CDH_CLUSTER_EMERGENCY_EMAILS_HISTORY,CDH_PROCESS_HISTORY,PAYING_ACCOUNTS_MONTHLY,CDH_VISITSTORE2_METRICS_HISTORY,CDH_PREFERENCES_SETTINGS_HISTORY,X,FACT_CONTRACT_LATEST_USAGE,CDH_RELEASE_HISTORY,CDH_TAG_COVERAGE_ENTITIES_HISTORY,V_APPS_AND_MICROSERVICES_SERVERLESS_USAGE,CDH_DEEP_MONITORING_SETTINGS_FEATURE_V2_HISTORY,CDH_PROBLEM_EVIDENCE_HISTORY,BAS_TENANT_LAST_ACCESS_DATE,FACT_SESSIONS,FACT_CUSTOMERS,CDH_CONTAINER_MEMORY_LIMIT_HISTORY,DIM_SESSION_BROWSER,INTERCOM_CONVERSATION_TAGS,DIM_ENVIRONMENT_ATTRIBUTES,V_CLOUD_USAGE_REPORT,BAS_MONTHLY_USAGE,DIM_AREA,BAS_MANAGED_LICENSE_QUOTA,MONITORED_CLOUD_SERVICES_REPORT,VW_REP_SNOWFLAKE_WAREHOUSE_METERING_HISTORY,CDH_AGENT_HISTORY,FACT_HOSTS_AGG,DIM_GEOGRAPHY,DISCOVERED_CLOUD_SERVICES_REPORT,FACT_CONTRACT_USAGE,DIM_ACTIVE_GATE_OS,CDH_DEEP_MONITORING_SETTINGS_V2_HISTORY,DIM_COUNTRY,BAS_MANAGED_CLUSTER,FACT_HOSTS,BAS_MANAGED_ACCOUNT,VW_REP_SNOWFLAKE_PIPE_USAGE_HISTORY,V_CLOUD_INTEGRATION_USAGE,CDH_CONTAINER_MEMORY_USAGE_HISTORY,CDH_DDU_TRACES_BY_ENTITY_HISTORY,FACT_HOST_TECHNOLOGIES,DIM_ACTIVE_GATE,DIM_CONTAINER_PROVIDER_TYPE,DTU_ACTIVITIES,CDH_DEEP_MONITORING_SETTINGS_HISTORY,BAS_SERVICE_USAGE_DAILY_SUMMARY,SYNTHETIC_LOCATIONS,CDH_SOFTWARE_COMPONENT_DETAILS_EVIDENCE_HISTORY,CDH_ENVIRONMENT_RAW,CDH_EXTENDED_TENANT_CONFIG_HISTORY,BAS_LIMITS,CDH_CLOUD_NETWORK_POLICY_HISTORY,BAS_PACKAGE,FACT_ENTITY_TAG_COVERAGE,FACT_CLOUD_APPLICATION_INSTANCES,V_CONVERSION_GOALS,FACT_PROCESSES,DIM_POC_ACCOUNT,DIM_AGENT_TECHNOLOGY_TYPE,FACT_ACCOUNT_VERTICALS,DIM_CLUSTER_ATTRIBUTES,PARTNER_REFERRAL,BAS_ENVIRONMENT_SERVICE_DAILY_SUMMARY,CDH_UEM_CONFIG_METADATA_CAPTURING_SETTINGS_HISTORY,INTERCOM_ADMINS,DIM_DEM_GOALS,CDH_ENDED_SESSIONS_HISTORY,DIM_EXTENSION,FACT_CLOUD_APPLICATION_NAMESPACES,CDH_BILLING_APP_SESSIONS_HISTORY,FACT_KUBERNETES_NODES,DEHASH_ACCOUNT,INFRASTRUCTURE_SOLUTION_ACCOUNTS,CDH_DDU_METRICS_BY_METRIC_HISTORY,DIM_PROBLEM_SOURCE,DIM_HOST,DIM_KUBERNETES_CLUSTER,DIM_ACTIVE_GATE_TYPE,INFRASTRUCTURE_SOLUTION_ENVIRONMENTS_NEW,SFDC_ACCOUNT,DIM_CUSTOMER_TASK,FACT_VERSIONED_MODULES,CDH_ENVIRONMENT,DIM_AGENT_ATTRIBUTES,BAS_BILLING_REQUEST,DIM_CONDITIONAL_PROCEDURE,MC_ACCOUNT,V_INFRASTRUCTURE_SOLUTION,CDH_SOFTWARE_COMPONENT_HISTORY,CDH_SLO_HISTORY,CLOUD_USAGE_REPORT,V_DT_VALUE_METRICS,CDH_VISIT_STORE_USAGE_HISTORY,CDH_ODIN_AGENT_ME_IDENTIFIER_HISTORY,FACT_PROBLEM_NATURAL_EVENTS,BAS_AUDIT_FIELD,DIM_UNIQUE_ENVIRONMENTS,AUTOPROV_EVENTS_FEATURES,CDH_MOBILE_AGENT_VERSION_USAGE_HISTORY,BAS_REGION,WOOPRA_SESSION,CDH_VULNERABILITY_MATCHING_METADATA_HISTORY,BAS_SERVICE_USAGE_SUMMARY,INFRASTRUCTURE_SOLUTION_ACCOUNTS_NEW,WOOPRA_ACTION_PROPERTIES,FACT_CLOUD_APPLICATIONS,DIM_SESSION_REGION,CDH_VERSIONED_MODULE_V2_HISTORY,CDH_SERVICE_HISTORY,INTERCOM_COMPANIES,DIM_DT_ACCOUNT_ATTRIBUTES,SESSION_REPLAYS_REPORT,FACT_ENVIRONMENT_USAGE,BAS_USAGE_CREDITS,DIM_DT_ACCOUNT_CURRENT_ATTRIBUTES,V_UNIQUE_HOST_TECHNOLOGIES,SFDC_MANAGED_LICENSE,CDH_CLUSTER_NETWORK_ZONE_STATS_HISTORY,CDH_API_USAGE_HISTORY,DAVIS_USAGE,CDH_CONDITIONAL_PROCEDURES_RULES_HISTORY,FACT_OPPORTUNITIES,BAS_ENVIRONMENT_USAGE_DAILY_SUMMARY_VIEW,BAS_SERVICE,CDH_PROBLEM_HISTORY,SFDC_DYNATRACE_ACCOUNT,FACT_ACTIVE_GATE_UPDATE_STATUS,FACT_ACTIVE_GATE_MODULES_STATUSES,BAS_CONTRACT_PRICING,CDH_PROBLEM_EVENT_INSTANCE_CLASSES_HISTORY,V_ACCOUNT_STAR_RATING,CDH_DATABASE_INSIGHTS_ENDPOINT_DETAILS_HISTORY,DIM_PRODUCT_TYPE,FACT_PROCESS_ATTRIBUTES,MONTHLY_CONSUMPTION_STAGING,FACT_CUSTOMER_SUPPORT,BAS_TENANT_USAGE_DAILY_SUMMARY,DIM_CLOUD_APPLICATION,FACT_PRODUCT_BEHAVIORAL_EVENTS,DIM_PRODUCT,DIM_VERSION,CDH_METRIC_EVENT_CONFIG_ID_FILTER_HISTORY,BAS_PROMO_CODE,CDH_PROBLEM_ROOT_CAUSE_GROUP_HISTORY,SFDC_POC,DIM_CONTAINER_GROUP,DAVIS_ACCOUNT_LINK,CDH_UEM_CONFIG_TENANT_HISTORY,DIM_CONTRACT,CDH_PROBLEM_EVIDENCE_HISTORY_ARCHIVE,CLOUD_ADOPTION,INFRASTRUCTURE_SOLUTION_ENVIRONMENTS,BAS_CONTRACT_BILLING_INFO,DIM_PRODUCT_USER,SFDC_ASSIGNMENT,DIM_OPPORTUNITY_STAGE,UNIQUE_HOSTS_TECHNOLOGY_HISTORY,FACT_SERVICE_TECHNOLOGIES,MONTHLY_CONSUMPTION_REPORT,CDH_DASHBOARD_CONFIG_TILE_HISTORY,DIM_CLOUD_APPLICATION_TYPE,B,CDH_KUBERNETES_NODE_HISTORY,FACT_TAG_COVERAGE,FACT_PRODUCT_PAGE_VIEWS,FACT_CONDITIONAL_PROCEDURE_ENTITY_RULES,CDH_LOG_MONITORING_ES_STATS_HISTORY,CDH_PLUGIN_METRIC_STATS_HISTORY,BAS_ENVIRONMENT_USAGE_DAILY_SUMMARY,CDH_HOST_HISTORY,CDH_VERSIONED_MODULE_HISTORY,BAS_BILLING_ACCOUNT,FACT_PROBLEM_RANKED_ENTITIES,DIM_CLOUD_APPLICATION_INSTANCE_TYPE,CDH_DEEP_MONITORING_SETTINGS_FEATURES_HISTORY,BAS_HOST_USAGE_DAILY_SUMMARY,CDH_LOG_MONITORING_METRIC_STATS_HISTORY,DIM_REGION,CDH_DATABASE_INSIGHTS_HISTORY,CDH_MOBILE_CRASHES_BY_RETRIEVAL_DELAY_HISTORY,WOOPRA_PAGES,CDH_DDU_TRACES_BY_DESCRIPTION_HISTORY", + "snowflake.user.privilege.last_altered": 1615219846703000000, + "db.user": "ANDRZEJLECKI", + "dsoa.run.context": "users" + } +] \ No newline at end of file diff --git a/test/test_results/test_warehouse_usage/biz_events.json b/test/test_results/test_warehouse_usage/biz_events.json new file mode 100644 index 00000000..3c8c762f --- /dev/null +++ b/test/test_results/test_warehouse_usage/biz_events.json @@ -0,0 +1,38 @@ +[ + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_warehouse_usage", + "dsoa.task.exec.status": "STARTED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + }, + { + "specversion": "1.0", + "source": "test.dsoa2025.snowflakecomputing.com", + "type": "dsoa.task", + "data": { + "event.provider": "test.dsoa2025.snowflakecomputing.com", + "dsoa.task.name": "test_warehouse_usage", + "dsoa.task.exec.status": "FINISHED", + "app.bundle": "self-monitoring", + "app.id": "dynatrace.snowagent", + "db.system": "snowflake", + "service.name": "test.dsoa2025", + "deployment.environment": "TEST", + "host.name": "test.dsoa2025.snowflakecomputing.com", + "telemetry.exporter.name": "dynatrace.snowagent", + "dsoa.run.context": "self-monitoring" + } + } +] diff --git a/tools/dashboard-json-to-yaml.sh b/tools/dashboard-json-to-yaml.sh new file mode 100755 index 00000000..a3197f27 --- /dev/null +++ b/tools/dashboard-json-to-yaml.sh @@ -0,0 +1,73 @@ +#!/usr/bin/env bash +# +# +# Copyright (c) 2025 Dynatrace Open Source +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# +DASHBOARD_FILE=$1 +YAML_FILE=$2 + +#DASHBOARD_NAME=`echo "${DASHBOARD_FILE_NAME%.*}" | tr '_-' ' ' | sed 's/\b\w/\U&/g'` +DASHBOARD_NAME=$(basename "${DASHBOARD_FILE%.*}" | tr '_-' ' ' | sed 's/\b\w/\U&/g') + +HEADER="# +# Copyright (c) 2025 Dynatrace Open Source +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# DASHBOARD: $DASHBOARD_NAME +# DESCRIPTION: +# OWNER: $(whoami) +# PLUGINS: +# TAGS: +#" + +echo "$HEADER" > "$YAML_FILE" + +jq ' + .tiles |= (to_entries | map( + .value.davis.davisVisualization.selectedOutputs |= empty | + .value.davis.componentState.inputData |= walk(if type == "object" and has("query") then del(.query) else . end) + ) | from_entries) | + walk( + if type == "object" then + (if has("input") then .input |= sub("\\s+\\n"; "\n"; "g") | .input |= sub("\\n\\s+$"; "\n"; "g") else . end) | + (if has("query") then .query |= sub("\\s+\\n"; "\n"; "g") | .query |= sub("\\n\\s+$"; "\n"; "g") else . end) + else . end + ) +' "$DASHBOARD_FILE" | \ +yq -P >> "$YAML_FILE" \ No newline at end of file diff --git a/tools/yaml-to-json.sh b/tools/yaml-to-json.sh new file mode 100755 index 00000000..b354e9e6 --- /dev/null +++ b/tools/yaml-to-json.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash +# +# +# Copyright (c) 2025 Dynatrace Open Source +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# +DASHBOARD_FILE=$1 + +yq -o json "$DASHBOARD_FILE" | jq . \ No newline at end of file