SNOW-716374: reapply telemetry change of application and test panda arrow result format (#370)

Author: sfc-gh-aling

.github/workflows/build_test.yml

@@ -98,7 +98,6 @@ jobs:
           .tox/coverage.xml
 
   test_connector_regression:
-   if: ${{ false }}  # disable temporarily
    name: Connector Regression Test ${{ matrix.os.download_name }}-${{ matrix.python-version }}-${{ matrix.cloud-provider }}
    needs: lint
    runs-on: ${{ matrix.os.image_name }}
@@ -142,7 +141,7 @@ jobs:
   combine-coverage:
     if: ${{ success() || failure() }}
     name: Combine coverage
-    needs: [test]
+    needs: [test, test_connector_regression]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2

DESCRIPTION.md

@@ -9,10 +9,14 @@ Source code is also available at:
 
 # Release Notes
 
+- v1.4.7(Unreleased)
+
+  - Re-applied the application name of driver connection `SnowflakeConnection` to `SnowflakeSQLAlchemy`.
+
 - v1.4.6(Feb 8, 2023)
 
-- Bumped snowflake-connector-python dependency to newest version which supports Python 3.11.
-- Reverted the change of application name introduced in v1.4.5 until support gets added.
+  - Bumped snowflake-connector-python dependency to newest version which supports Python 3.11.
+  - Reverted the change of application name introduced in v1.4.5 until support gets added.
 
 - v1.4.5(Dec 7, 2022)
 

setup.cfg

@@ -3,7 +3,6 @@ universal = 1
 
 [metadata]
 name = snowflake-sqlalchemy
-version = 1.4.6
 description = Snowflake SQLAlchemy Dialect
 long_description = file: DESCRIPTION.md
 long_description_content_type = text/markdown

setup.py

@@ -2,6 +2,16 @@
 # Copyright (c) 2012-2022 Snowflake Computing Inc. All rights reserved.
 #
 
+import os
+
 from setuptools import setup
 
-setup()
+SQLALCHEMY_SRC_DIR = os.path.join("src", "snowflake", "sqlalchemy")
+VERSION = (1, 1, 1, None)  # Default
+with open(os.path.join(SQLALCHEMY_SRC_DIR, "version.py"), encoding="utf-8") as f:
+    exec(f.read())
+    version = ".".join([str(v) for v in VERSION if v is not None])
+
+setup(
+    version=version,
+)

src/snowflake/sqlalchemy/_constants.py

@@ -1,14 +1,12 @@
 #
 # Copyright (c) 2012-2022 Snowflake Computing Inc. All rights reserved.
 #
-import pkg_resources
+from .version import VERSION
 
 # parameters needed for usage tracking
 PARAM_APPLICATION = "application"
 PARAM_INTERNAL_APPLICATION_NAME = "internal_application_name"
 PARAM_INTERNAL_APPLICATION_VERSION = "internal_application_version"
 
 APPLICATION_NAME = "SnowflakeSQLAlchemy"
-SNOWFLAKE_SQLALCHEMY_VERSION = pkg_resources.get_distribution(
-    "snowflake-sqlalchemy"
-).version
+SNOWFLAKE_SQLALCHEMY_VERSION = ".".join([str(v) for v in VERSION if v is not None])

src/snowflake/sqlalchemy/snowdialect.py

@@ -61,6 +61,7 @@
     _CUSTOM_Float,
     _CUSTOM_Time,
 )
+from .util import _update_connection_application_name
 
 colspecs = {
     Date: _CUSTOM_Date,
@@ -107,6 +108,9 @@
 }
 
 
+_ENABLE_SQLALCHEMY_AS_APPLICATION_NAME = True
+
+
 class SnowflakeDialect(default.DefaultDialect):
     name = "snowflake"
     driver = "snowflake"
@@ -834,6 +838,18 @@ def get_table_comment(self, connection, table_name, schema=None, **kw):
             else None
         }
 
+    def connect(self, *cargs, **cparams):
+        return (
+            super().connect(
+                *cargs,
+                **_update_connection_application_name(**cparams)
+                if _ENABLE_SQLALCHEMY_AS_APPLICATION_NAME
+                else cparams,
+            )
+            if _ENABLE_SQLALCHEMY_AS_APPLICATION_NAME
+            else super().connect(*cargs, **cparams)
+        )
+
 
 @sa_vnt.listens_for(Table, "before_create")
 def check_table(table, connection, _ddl_runner, **kw):

src/snowflake/sqlalchemy/version.py

@@ -0,0 +1,6 @@
+#
+# Copyright (c) 2012-2022 Snowflake Computing Inc. All rights reserved.
+#
+# Update this for the versions
+# Don't change the forth version number from None
+VERSION = (1, 4, 7, None)

tests/conftest.py

@@ -13,8 +13,16 @@
 from sqlalchemy import create_engine
 
 import snowflake.connector
+import snowflake.connector.connection
 from snowflake.connector.compat import IS_WINDOWS
 from snowflake.sqlalchemy import URL, dialect
+from snowflake.sqlalchemy._constants import (
+    APPLICATION_NAME,
+    PARAM_APPLICATION,
+    PARAM_INTERNAL_APPLICATION_NAME,
+    PARAM_INTERNAL_APPLICATION_VERSION,
+    SNOWFLAKE_SQLALCHEMY_VERSION,
+)
 
 from .parameters import CONNECTION_PARAMETERS
 
@@ -23,6 +31,17 @@
 INTERNAL_SKIP_TAGS = {"external"}
 RUNNING_ON_GH = os.getenv("GITHUB_ACTIONS") == "true"
 
+snowflake.connector.connection.DEFAULT_CONFIGURATION[PARAM_APPLICATION] = (
+    APPLICATION_NAME,
+    (type(None), str),
+)
+snowflake.connector.connection.DEFAULT_CONFIGURATION[
+    PARAM_INTERNAL_APPLICATION_NAME
+] = (APPLICATION_NAME, (type(None), str))
+snowflake.connector.connection.DEFAULT_CONFIGURATION[
+    PARAM_INTERNAL_APPLICATION_VERSION
+] = (SNOWFLAKE_SQLALCHEMY_VERSION, (type(None), str))
+
 TEST_SCHEMA = f"sqlalchemy_tests_{str(uuid.uuid4()).replace('-', '_')}"
 
 create_engine_with_future_flag = create_engine

tests/connector_regression

@@ -36,6 +36,8 @@
 from sqlalchemy.pool import NullPool
 from sqlalchemy.sql import and_, not_, or_, select
 
+import snowflake.connector.errors
+import snowflake.sqlalchemy.snowdialect
 from snowflake.connector import Error, ProgrammingError, connect
 from snowflake.sqlalchemy import URL, MergeInto, dialect
 from snowflake.sqlalchemy._constants import (
@@ -99,35 +101,22 @@ def _create_users_addresses_tables_without_sequence(engine_testaccount, metadata
     return users, addresses
 
 
-def verify_engine_connection(engine, verify_app_name):
+def verify_engine_connection(engine):
     with engine.connect() as conn:
         results = conn.execute(text("select current_version()")).fetchone()
-        if verify_app_name:
-            assert conn.connection.driver_connection.application == APPLICATION_NAME
-            assert (
-                conn.connection.driver_connection._internal_application_name
-                == APPLICATION_NAME
-            )
-            assert (
-                conn.connection.driver_connection._internal_application_version
-                == SNOWFLAKE_SQLALCHEMY_VERSION
-            )
+        assert conn.connection.driver_connection.application == APPLICATION_NAME
+        assert (
+            conn.connection.driver_connection._internal_application_name
+            == APPLICATION_NAME
+        )
+        assert (
+            conn.connection.driver_connection._internal_application_version
+            == SNOWFLAKE_SQLALCHEMY_VERSION
+        )
         assert results is not None
 
 
-@pytest.mark.parametrize(
-    "verify_app_name",
-    [
-        False,
-        pytest.param(
-            True,
-            marks=pytest.mark.xfail(
-                reason="Pending backend service to recognize SnowflakeSQLAlchemy as a valid client app id"
-            ),
-        ),
-    ],
-)
-def test_connect_args(verify_app_name):
+def test_connect_args():
     """
     Tests connect string
 
@@ -148,7 +137,7 @@ def test_connect_args(verify_app_name):
         )
     )
     try:
-        verify_engine_connection(engine, verify_app_name)
+        verify_engine_connection(engine)
     finally:
         engine.dispose()
 
@@ -163,7 +152,7 @@ def test_connect_args(verify_app_name):
         )
     )
     try:
-        verify_engine_connection(engine, verify_app_name)
+        verify_engine_connection(engine)
     finally:
         engine.dispose()
 
@@ -179,7 +168,7 @@ def test_connect_args(verify_app_name):
         )
     )
     try:
-        verify_engine_connection(engine, verify_app_name)
+        verify_engine_connection(engine)
     finally:
         engine.dispose()
 
@@ -1785,3 +1774,84 @@ def test_normalize_and_denormalize_empty_string_column_name(engine_testaccount):
             and columns[0]["name"] == "col"
             and columns[1]["name"] == ""
         )
+
+
+def test_snowflake_sqlalchemy_as_valid_client_type():
+    engine = create_engine(
+        URL(
+            user=CONNECTION_PARAMETERS["user"],
+            password=CONNECTION_PARAMETERS["password"],
+            account=CONNECTION_PARAMETERS["account"],
+            host=CONNECTION_PARAMETERS["host"],
+            port=CONNECTION_PARAMETERS["port"],
+            protocol=CONNECTION_PARAMETERS["protocol"],
+        ),
+        connect_args={"internal_application_name": "UnknownClient"},
+    )
+    with engine.connect() as conn:
+        with pytest.raises(snowflake.connector.errors.NotSupportedError):
+            conn.exec_driver_sql("select 1").cursor.fetch_pandas_all()
+
+    engine = create_engine(
+        URL(
+            user=CONNECTION_PARAMETERS["user"],
+            password=CONNECTION_PARAMETERS["password"],
+            account=CONNECTION_PARAMETERS["account"],
+            host=CONNECTION_PARAMETERS["host"],
+            port=CONNECTION_PARAMETERS["port"],
+            protocol=CONNECTION_PARAMETERS["protocol"],
+        )
+    )
+    with engine.connect() as conn:
+        conn.exec_driver_sql("select 1").cursor.fetch_pandas_all()
+
+    try:
+        snowflake.sqlalchemy.snowdialect._ENABLE_SQLALCHEMY_AS_APPLICATION_NAME = False
+        origin_app = snowflake.connector.connection.DEFAULT_CONFIGURATION["application"]
+        origin_internal_app_name = snowflake.connector.connection.DEFAULT_CONFIGURATION[
+            "internal_application_name"
+        ]
+        origin_internal_app_version = (
+            snowflake.connector.connection.DEFAULT_CONFIGURATION[
+                "internal_application_version"
+            ]
+        )
+        snowflake.connector.connection.DEFAULT_CONFIGURATION["application"] = (
+            None,
+            (type(None), str),
+        )
+        snowflake.connector.connection.DEFAULT_CONFIGURATION[
+            "internal_application_name"
+        ] = ("PythonConnector", (type(None), str))
+        snowflake.connector.connection.DEFAULT_CONFIGURATION[
+            "internal_application_version"
+        ] = ("3.0.0", (type(None), str))
+        engine = create_engine(
+            URL(
+                user=CONNECTION_PARAMETERS["user"],
+                password=CONNECTION_PARAMETERS["password"],
+                account=CONNECTION_PARAMETERS["account"],
+                host=CONNECTION_PARAMETERS["host"],
+                port=CONNECTION_PARAMETERS["port"],
+                protocol=CONNECTION_PARAMETERS["protocol"],
+            )
+        )
+        with engine.connect() as conn:
+            conn.exec_driver_sql("select 1").cursor.fetch_pandas_all()
+            assert (
+                conn.connection.driver_connection._internal_application_name
+                == "PythonConnector"
+            )
+            assert (
+                conn.connection.driver_connection._internal_application_version
+                == "3.0.0"
+            )
+    finally:
+        snowflake.sqlalchemy.snowdialect._ENABLE_SQLALCHEMY_AS_APPLICATION_NAME = True
+        snowflake.connector.connection.DEFAULT_CONFIGURATION["application"] = origin_app
+        snowflake.connector.connection.DEFAULT_CONFIGURATION[
+            "internal_application_name"
+        ] = origin_internal_app_name
+        snowflake.connector.connection.DEFAULT_CONFIGURATION[
+            "internal_application_version"
+        ] = origin_internal_app_version