recce-nightly 1.2.0.20250506__py3-none-any.whl → 1.26.0.20251124__py3-none-any.whl

recce/event/__init__.py

@@ -10,17 +10,21 @@ from typing import Dict
 
 import sentry_sdk
 
-from recce import is_ci_env, get_version, get_runner
+from recce import get_runner, get_version, is_ci_env, is_recce_cloud_instance
 from recce import yaml as pyml
 from recce.event.collector import Collector
 from recce.git import current_branch, hosting_repo
-from recce.github import is_github_codespace, get_github_codespace_info, get_github_codespace_name, \
-    get_github_codespace_available_at
-
-USER_HOME = os.path.expanduser('~')
-RECCE_USER_HOME = os.path.join(USER_HOME, '.recce')
-RECCE_USER_PROFILE = os.path.join(RECCE_USER_HOME, 'profile.yml')
-RECCE_USER_EVENT_PATH = os.path.join(RECCE_USER_HOME, '.unsend_events.json')
+from recce.github import (
+    get_github_codespace_available_at,
+    get_github_codespace_info,
+    get_github_codespace_name,
+    is_github_codespace,
+)
+
+USER_HOME = os.path.expanduser("~")
+RECCE_USER_HOME = os.path.join(USER_HOME, ".recce")
+RECCE_USER_PROFILE = os.path.join(RECCE_USER_HOME, "profile.yml")
+RECCE_USER_EVENT_PATH = os.path.join(RECCE_USER_HOME, ".unsend_events.json")
 
 __version__ = get_version()
 _collector = Collector()
@@ -33,13 +37,13 @@ def init():
 
     # Amplitude init
     _collector.set_api_key(api_key)
-    _collector.set_user_id(user_profile.get('user_id'))
+    _collector.set_user_id(user_profile.get("user_id"))
     _collector.set_unsend_events_file(RECCE_USER_EVENT_PATH)
 
     # Sentry init
     sentry_env = _get_sentry_env()
     sentry_dns = _get_sentry_dns()
-    release_version = __version__ if sentry_env != 'development' else None
+    release_version = __version__ if sentry_env != "development" else None
     sentry_sdk.init(
         dsn=sentry_dns,
         environment=sentry_env,
@@ -47,58 +51,63 @@ def init():
         # Set traces_sample_rate to 1.0 to capture 100%
         # of transactions for performance monitoring.
         # We recommend adjusting this value in production.
-        traces_sample_rate=1.0
+        traces_sample_rate=1.0,
     )
-    sentry_sdk.set_tag('recce.version', __version__)
-    sentry_sdk.set_tag('platform', sys.platform)
-    sentry_sdk.set_tag('is_ci_env', is_ci_env())
-    sentry_sdk.set_tag('is_github_codespace', is_github_codespace())
-    sentry_sdk.set_tag('system_timezone', get_system_timezone())
+    sentry_sdk.set_tag("recce.version", __version__)
+    sentry_sdk.set_tag("platform", sys.platform)
+    sentry_sdk.set_tag("is_ci_env", is_ci_env())
+    sentry_sdk.set_tag("is_github_codespace", is_github_codespace())
+    sentry_sdk.set_tag("is_recce_cloud_instance", is_recce_cloud_instance())
+    sentry_sdk.set_tag("system_timezone", get_system_timezone())
 
 
 def get_user_id():
-    return load_user_profile().get('user_id')
+    return load_user_profile().get("user_id")
 
 
 def get_recce_api_token():
-    return load_user_profile().get('api_token')
+    return load_user_profile().get("api_token")
+
+
+def update_recce_api_token(token):
+    return update_user_profile({"api_token": token})
 
 
 def is_anonymous_tracking():
-    return load_user_profile().get('anonymous_tracking', False)
+    return load_user_profile().get("anonymous_tracking", False)
 
 
 def _get_sentry_dns():
-    dns_file = os.path.normpath(os.path.join(os.path.dirname(__file__), 'SENTRY_DNS'))
-    with open(dns_file) as f:
+    dns_file = os.path.normpath(os.path.join(os.path.dirname(__file__), "SENTRY_DNS"))
+    with open(dns_file, encoding="utf-8") as f:
         dns = f.read().strip()
         return dns
 
 
 def _get_sentry_env():
-    if '.dev' in __version__:
-        return 'development'
-    elif re.match(r'^\d+\.\d+\.\d+\.\d{8}[a|b|rc]?.*$', __version__):
-        return 'nightly'
-    elif 'a' in __version__:
-        return 'alpha'
-    elif 'b' in __version__:
-        return 'beta'
-    elif 'rc' in __version__:
-        return 'release-candidate'
-    return 'production'
+    if ".dev" in __version__:
+        return "development"
+    elif re.match(r"^\d+\.\d+\.\d+\.\d{8}[a|b|rc]?.*$", __version__):
+        return "nightly"
+    elif "a" in __version__:
+        return "alpha"
+    elif "b" in __version__:
+        return "beta"
+    elif "rc" in __version__:
+        return "release-candidate"
+    return "production"
 
 
 def _get_api_key():
-    if os.getenv('RECCE_EVENT_API_KEY'):
+    if os.getenv("RECCE_EVENT_API_KEY"):
         # For local testing purpose
-        return os.getenv('RECCE_EVENT_API_KEY')
+        return os.getenv("RECCE_EVENT_API_KEY")
 
-    config_file = os.path.abspath(os.path.join(os.path.dirname(__file__), 'CONFIG'))
+    config_file = os.path.abspath(os.path.join(os.path.dirname(__file__), "CONFIG"))
     try:
-        with open(config_file) as fh:
+        with open(config_file, encoding="utf-8") as fh:
             config = pyml.load(fh)
-            return config.get('event_api_key')
+            return config.get("event_api_key")
     except Exception:
         return None
 
@@ -108,15 +117,15 @@ def _generate_user_profile():
         os.makedirs(RECCE_USER_HOME, exist_ok=True)
     except Exception:
         # TODO: should show warning message but not raise exception
-        print('Please disable command tracking to continue.')
+        print("Please disable command tracking to continue.")
         exit(1)
     if is_github_codespace() is True:
-        salted_name = f'codespace-{get_github_codespace_name()}'
+        salted_name = f"codespace-{get_github_codespace_name()}"
         user_id = hashlib.sha256(salted_name.encode()).hexdigest()
     else:
         user_id = uuid.uuid4().hex
-    with open(RECCE_USER_PROFILE, 'w+') as f:
-        pyml.dump({'user_id': user_id, 'anonymous_tracking': True}, f)
+    with open(RECCE_USER_PROFILE, "w+", encoding="utf-8") as f:
+        pyml.dump({"user_id": user_id, "anonymous_tracking": True}, f)
     return dict(user_id=user_id, anonymous_tracking=True)
 
 
@@ -125,9 +134,9 @@ def load_user_profile():
         if not os.path.exists(RECCE_USER_PROFILE):
             user_profile = _generate_user_profile()
         else:
-            with open(RECCE_USER_PROFILE, 'r') as f:
+            with open(RECCE_USER_PROFILE, "r", encoding="utf-8") as f:
                 user_profile = pyml.load(f)
-                if user_profile.get('user_id') is None:
+                if user_profile is None or user_profile.get("user_id") is None:
                     user_profile = _generate_user_profile()
 
         return user_profile
@@ -136,7 +145,7 @@ def load_user_profile():
 def update_user_profile(update_values):
     original = load_user_profile()
     original.update(update_values)
-    with open(RECCE_USER_PROFILE, 'w+') as f:
+    with open(RECCE_USER_PROFILE, "w+", encoding="utf-8") as f:
         pyml.dump(original, f)
     return original
 
@@ -146,10 +155,10 @@ def flush_events(command=None):
 
 
 def should_log_event():
-    with open(RECCE_USER_PROFILE, 'r') as f:
+    with open(RECCE_USER_PROFILE, "r", encoding="utf-8") as f:
         user_profile = pyml.load(f)
     # TODO: default anonymous_tracking to false if field is not present
-    tracking = user_profile.get('anonymous_tracking', False)
+    tracking = user_profile.get("anonymous_tracking", False)
     tracking = tracking and isinstance(tracking, bool)
     if not tracking:
         return False
@@ -166,18 +175,18 @@ def log_event(prop, event_type, **kwargs):
 
     repo = hosting_repo()
     if repo is not None:
-        prop['repository'] = sha256(repo.encode()).hexdigest()
+        prop["repository"] = sha256(repo.encode()).hexdigest()
 
     branch = current_branch()
     if branch is not None:
-        prop['branch'] = sha256(branch.encode()).hexdigest()
+        prop["branch"] = sha256(branch.encode()).hexdigest()
 
     runner = get_runner()
     if runner is not None:
-        prop['runner_type'] = runner
+        prop["runner_type"] = runner
 
-        if runner == 'github codespaces':
-            prop['codespaces_name'] = get_github_codespace_name()
+        if runner == "github codespaces":
+            prop["codespaces_name"] = get_github_codespace_name()
 
     payload = dict(
         **prop,
@@ -191,11 +200,11 @@ def log_api_event(endpoint_name, prop):
         **prop,
         endpoint_name=endpoint_name,
     )
-    log_event(prop, 'api_event')
+    log_event(prop, "api_event")
     _collector.schedule_flush()
 
 
-def log_load_state(command='server', single_env=False):
+def log_load_state(command="server", single_env=False):
     from recce.models import CheckDAO
 
     checks = 0
@@ -213,10 +222,10 @@ def log_load_state(command='server', single_env=False):
     )
 
     if command == "server":
-        prop['single_env'] = single_env
+        prop["single_env"] = single_env
 
-    log_event(prop, 'load_state')
-    if command == 'server':
+    log_event(prop, "load_state")
+    if command == "server":
         _collector.schedule_flush()
 
 
@@ -227,31 +236,29 @@ def log_codespaces_events(command):
         return
 
     user_prop = dict(
-        location=codespace.get('location'),
-        is_prebuild=codespace.get('prebuild', False),
+        location=codespace.get("location"),
+        is_prebuild=codespace.get("prebuild", False),
     )
 
     prop = dict(
-        machine=codespace.get('machine', {}).get('display_name'),
+        machine=codespace.get("machine", {}).get("display_name"),
         codespaces_name=get_github_codespace_name(),
     )
 
     # Codespace created event, send once
-    codespace_created_at = load_user_profile().get('codespace_created_at')
+    codespace_created_at = load_user_profile().get("codespace_created_at")
     if codespace_created_at is None:
-        created_at = datetime.fromisoformat(codespace.get('created_at'))
-        prop['state'] = 'created'
-        _collector.log_event(prop, 'codespace_instance', event_triggered_at=created_at,
-                             user_properties=user_prop)
-        update_user_profile({'codespace_created_at': codespace.get('created_at')})
+        created_at = datetime.fromisoformat(codespace.get("created_at"))
+        prop["state"] = "created"
+        _collector.log_event(prop, "codespace_instance", event_triggered_at=created_at, user_properties=user_prop)
+        update_user_profile({"codespace_created_at": codespace.get("created_at")})
 
     # Codespace available event, send multiple times as start/stop it
     available_at = get_github_codespace_available_at(codespace)
-    if available_at and available_at.isoformat() != load_user_profile().get('codespace_available_at'):
-        prop['state'] = 'available'
-        _collector.log_event(prop, 'codespace_instance', event_triggered_at=available_at,
-                             user_properties=user_prop)
-        update_user_profile({'codespace_available_at': available_at.isoformat()})
+    if available_at and available_at.isoformat() != load_user_profile().get("codespace_available_at"):
+        prop["state"] = "available"
+        _collector.log_event(prop, "codespace_instance", event_triggered_at=available_at, user_properties=user_prop)
+        update_user_profile({"codespace_available_at": available_at.isoformat()})
 
     # Codespace instance event should be flushed immediately
     _collector.send_events()
@@ -259,20 +266,25 @@ def log_codespaces_events(command):
 
 def log_single_env_event():
     prop = dict(
-        action='launch_server',
+        action="launch_server",
     )
-    log_event(prop, '[Experiment] single_environment')
+    log_event(prop, "[Experiment] single_environment")
     _collector.schedule_flush()
 
 
 def log_performance(feature_name: str, metrics: Dict):
     prop = metrics
-    log_event(prop, f'[Performance] {feature_name}')
+    log_event(prop, f"[Performance] {feature_name}")
+    _collector.schedule_flush()
+
+
+def log_connected_to_cloud():
+    log_event({"action": "connected_to_cloud"}, "Connect OSS to Cloud")
     _collector.schedule_flush()
 
 
 def capture_exception(e):
-    user_id = load_user_profile().get('user_id')
+    user_id = load_user_profile().get("user_id")
     if is_ci_env() is True:
         user_id = f"{user_id}_CI"
 

recce/event/collector.py

@@ -4,20 +4,19 @@ import platform
 import sys
 import time
 from contextlib import contextmanager
-from datetime import datetime
+from datetime import datetime, timezone
 from json import JSONDecodeError
-from datetime import timezone
 
 import portalocker
 import requests
 
-from recce import __version__, is_ci_env
+from recce import __version__, is_ci_env, is_recce_cloud_instance
 from recce.github import is_github_codespace
 
 
 class Collector:
     def __init__(self):
-        self._api_endpoint = 'https://api.amplitude.com/2/httpapi'
+        self._api_endpoint = "https://api.amplitude.com/2/httpapi"
         self._api_key = None
         self._user_id = None
 
@@ -26,6 +25,7 @@ class Collector:
         self._upload_threshold = 10
         self._is_ci: bool = is_ci_env()
         self._is_github_codespace: bool = is_github_codespace()
+        self._is_recce_cloud_instance: bool = is_recce_cloud_instance()
         self._flush_timer = None
 
     def schedule_flush(self):
@@ -35,6 +35,7 @@ class Collector:
 
         # send async thread
         import threading
+
         if self._flush_timer:
             try:
                 self._flush_timer.cancel()
@@ -59,11 +60,18 @@ class Collector:
         self._unsend_events_file = unsend_events_file
         self._check_required_files()
 
-    def _log_event(self, user_id, event_type, created_at, user_properties, event_properties, ):
+    def _log_event(
+        self,
+        user_id,
+        event_type,
+        created_at,
+        user_properties,
+        event_properties,
+    ):
         event = dict(
             user_id=user_id,
             event_type=event_type,
-            ip='$remote',
+            ip="$remote",
             time=int(time.mktime(created_at.timetuple())),
             user_properties=user_properties,
             event_properties=event_properties,
@@ -91,7 +99,7 @@ class Collector:
         else:
             # Convert to UTC timezone
             created_at = event_triggered_at.astimezone(timezone.utc)
-        python_version = f'{sys.version_info.major}.{sys.version_info.minor}'
+        python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
 
         # when the recce is running in automation use cases
         # replace the user id with project_id to avoid so many unique user id
@@ -102,6 +110,7 @@ class Collector:
             python_version=python_version,
             is_ci=self._is_ci,
             is_github_codespace=self._is_github_codespace,
+            is_recce_cloud_instance=self._is_recce_cloud_instance,
         )
 
         if user_properties is not None:
@@ -120,17 +129,18 @@ class Collector:
         if not os.path.exists(user_home):
             os.makedirs(user_home, exist_ok=True)
         if not os.path.exists(self._unsend_events_file):
-            with portalocker.Lock(self._unsend_events_file, 'w+', timeout=5) as f:
-                f.write(json.dumps({'unsend_events': []}))
+            with portalocker.Lock(self._unsend_events_file, "w+", timeout=5) as f:
+                f.write(json.dumps({"unsend_events": []}))
 
     def _is_full(self):
-        with portalocker.Lock(self._unsend_events_file, 'r+', timeout=5) as f:
+        with portalocker.Lock(self._unsend_events_file, "r+", timeout=5) as f:
             o = json.loads(f.read())
-            return len(o.get('unsend_events', [])) >= self._upload_threshold
+            return len(o.get("unsend_events", [])) >= self._upload_threshold
 
     @contextmanager
     def load_json(self):
-        with portalocker.Lock(self._unsend_events_file, 'r+', timeout=5) as f:
+        with portalocker.Lock(self._unsend_events_file, "r+", timeout=5) as f:
+            o = None
             try:
                 o = json.loads(f.read())
                 yield o
@@ -140,15 +150,16 @@ class Collector:
             finally:
                 f.seek(0)
                 f.truncate()
-                f.write(json.dumps(o))
+                if o is not None:
+                    f.write(json.dumps(o))
 
     def send_events(self):
         with self.load_json() as o:
             payload = dict(
                 api_key=self._api_key,
-                events=o['unsend_events'],
+                events=o["unsend_events"],
             )
-            o['unsend_events'] = []
+            o["unsend_events"] = []
         try:
             requests.post(self._api_endpoint, json=payload)
         except Exception:
@@ -157,17 +168,17 @@ class Collector:
 
     def _store_to_file(self, event):
         with self.load_json() as o:
-            events = o.get('unsend_events', None)
+            events = o.get("unsend_events", None)
             if events is None:
-                o['unsend_events'] = []
+                o["unsend_events"] = []
 
-            o['unsend_events'].append(event)
+            o["unsend_events"].append(event)
 
     def _cleanup_unsend_events(self):
         with self.load_json() as o:
-            events = o.get('unsend_events', None)
+            events = o.get("unsend_events", None)
             if events is None:
-                o['unsend_events'] = []
+                o["unsend_events"] = []
 
-            while len(o['unsend_events']) > self._delete_threshold:
-                o['unsend_events'].pop(0)
+            while len(o["unsend_events"]) > self._delete_threshold:
+                o["unsend_events"].pop(0)

recce/event/track.py

@@ -18,8 +18,8 @@ from recce.git import current_branch, hosting_repo
 
 console = Console()
 
-_enable_traceback: bool = os.environ.get('RECCE_PRINT_TRACEBACK') == '1'
-logger = logging.getLogger('uvicorn')
+_enable_traceback: bool = os.environ.get("RECCE_PRINT_TRACEBACK") == "1"
+logger = logging.getLogger("uvicorn")
 
 
 class TrackCommand(Command):
@@ -39,11 +39,23 @@ class TrackCommand(Command):
         deprecated: bool = False,
         beta: bool = False,
     ) -> None:
-        super(TrackCommand, self).__init__(name, context_settings, callback, params, help, epilog, short_help,
-                                           options_metavar, add_help_option, no_args_is_help, hidden, deprecated)
+        super(TrackCommand, self).__init__(
+            name,
+            context_settings,
+            callback,
+            params,
+            help,
+            epilog,
+            short_help,
+            options_metavar,
+            add_help_option,
+            no_args_is_help,
+            hidden,
+            deprecated,
+        )
 
     def _show_error_message(self, msg, params):
-        if params.get('debug'):
+        if params.get("debug"):
             console.print_exception(show_locals=True)
         else:
             print(traceback.format_exc())
@@ -51,39 +63,39 @@ class TrackCommand(Command):
             # console.out(msg, highlight=False)
 
     def _show_hint_message(self, hint):
-        console.print(f'[bold yellow]Hint[/bold yellow]:\n  {escape(hint)}')
+        console.print(f"[bold yellow]Hint[/bold yellow]:\n  {escape(hint)}")
 
     def invoke(self, ctx: Context) -> t.Any:
         status = False
         start_time = time.time()
-        reason = 'error'
-        event.set_exception_tag('command', ctx.command.name)
+        reason = "error"
+        event.set_exception_tag("command", ctx.command.name)
         event.log_codespaces_events(ctx.command.name)
 
         try:
             ret = super(TrackCommand, self).invoke(ctx)
             if ret is None or ret == 0:
                 status = True
-                reason = 'ok'
+                reason = "ok"
             else:
-                reason = 'error'
+                reason = "error"
                 sys.exit(ret)
             return ret
         except RecceException as e:
             logger.debug(traceback.format_exc())
             console.log("[Error] " + str(e))
-            reason = 'error'
+            reason = "error"
             sys.exit(1)
         except SystemExit as e:
-            reason = 'error'
+            reason = "error"
             raise e
         except KeyboardInterrupt as e:
-            reason = 'aborted'
+            reason = "aborted"
             raise e
         except Exception as e:
             self._show_error_message(str(e), ctx.params)
             event.capture_exception(e)
-            reason = 'fatal'
+            reason = "fatal"
             event.flush_exceptions()
             sys.exit(1)
         finally:
@@ -93,32 +105,32 @@ class TrackCommand(Command):
             branch = current_branch()
             command = ctx.command.name
             duration = end_time - start_time
-            target_path = ctx.params.get('target_path', None)
-            target_base_path = ctx.params.get('target_base_path', None)
+            target_path = ctx.params.get("target_path", None)
+            target_base_path = ctx.params.get("target_base_path", None)
             props = dict(
                 command=command,
                 status=status,
                 reason=reason,
                 duration=duration,
-                cloud=ctx.params.get('cloud', False),
-                review=ctx.params.get('review', False),
-                debug=ctx.params.get('debug', False),
+                cloud=ctx.params.get("cloud", False),
+                review=ctx.params.get("review", False),
+                debug=ctx.params.get("debug", False),
             )
 
             if runner is not None:
-                props['runner_type'] = runner
+                props["runner_type"] = runner
 
             if repo is not None:
-                props['repository'] = sha256(repo.encode()).hexdigest()
+                props["repository"] = sha256(repo.encode()).hexdigest()
 
             if branch is not None:
-                props['branch'] = sha256(branch.encode()).hexdigest()
+                props["branch"] = sha256(branch.encode()).hexdigest()
 
             if target_path is not None:
-                props['target_path'] = sha256(target_path.encode()).hexdigest()
+                props["target_path"] = sha256(target_path.encode()).hexdigest()
 
             if target_base_path is not None:
-                props['target_base_path'] = sha256(target_base_path.encode()).hexdigest()
+                props["target_base_path"] = sha256(target_base_path.encode()).hexdigest()
 
             try:
                 recce_context = load_context()
@@ -128,9 +140,19 @@ class TrackCommand(Command):
 
             if recce_context is not None:
                 if recce_context.adapter_type == "dbt":
-                    props['adapter_type'] = 'DBT'
+                    props["adapter_type"] = "DBT"
+                    # Add dbt warehouse type only for dbt adapter
+                    try:
+                        from recce.adapter.dbt_adapter import DbtAdapter
+
+                        dbt_adapter: DbtAdapter = recce_context.adapter
+                        warehouse_type = dbt_adapter.adapter.type()
+                        props["warehouse_type"] = warehouse_type
+                    except Exception:
+                        # If we can't get the warehouse type, skip it
+                        pass
                 elif recce_context.adapter_type == "sqlmesh":
-                    props['adapter_type'] = 'SQLMesh'
+                    props["adapter_type"] = "SQLMesh"
 
-            event.log_event(props, 'command', params=ctx.params)
+            event.log_event(props, "command", params=ctx.params)
             event.flush_events()

recce/exceptions.py

@@ -7,7 +7,7 @@ class RecceException(Exception):
 
 class RecceCancelException(RecceException):
     def __init__(self):
-        super().__init__('Cancelled', False)
+        super().__init__("Cancelled", False)
 
 
 class RecceConfigException(RecceException):

recce/git.py

@@ -1,12 +1,12 @@
 import os
 
-from git import Repo, InvalidGitRepositoryError
+from git import InvalidGitRepositoryError, Repo
 
 
 def current_default_branch():
     try:
         repo = Repo(search_parent_directories=True)
-        return repo.remotes.origin.refs['HEAD'].reference.remote_head
+        return repo.remotes.origin.refs["HEAD"].reference.remote_head
     except Exception:
         return None
 
@@ -53,19 +53,19 @@ def commit_hash_from_branch(branch: str, short_length: int = 7, short: bool = Fa
         return None
 
 
-def hosting_repo(remote: str = 'origin'):
+def hosting_repo(remote: str = "origin"):
     try:
         repo = Repo(search_parent_directories=True)
         origin_url = repo.remote(name=remote).url
         remote_repo = None
 
-        if origin_url.startswith('git@'):
+        if origin_url.startswith("git@"):
             # Handle git@github.com:user/repo.git
-            remote_repo = origin_url.split(':')[1].replace('.git', '')
+            remote_repo = origin_url.split(":")[1].replace(".git", "")
 
-        elif origin_url.startswith('https://') or origin_url.startswith('http://'):
+        elif origin_url.startswith("https://") or origin_url.startswith("http://"):
             # Handle https://github.com/user/repo.git or http://github.com/user/repo.git
-            remote_repo = '/'.join(origin_url.split('/')[-2:]).replace('.git', '')
+            remote_repo = "/".join(origin_url.split("/")[-2:]).replace(".git", "")
 
         return remote_repo
     except ValueError: