analytics: refactor into a module

dvc/analytics.py

@@ -1,256 +1,131 @@
-"""Collect and send usage analytics"""
-from __future__ import unicode_literals
-
-import errno
 import json
 import logging
-import os
+import platform
+import requests
+import sys
+import tempfile
+import uuid
 
-from dvc import __version__
-from dvc.utils import env2bool
-from dvc.utils.compat import str
+import distro
 
+from dvc import __version__
+from dvc.config import Config, to_bool
+from dvc.daemon import daemon
+from dvc.exceptions import NotDvcRepoError
+from dvc.lock import Lock, LockError
+from dvc.repo import Repo
+from dvc.scm import SCM
+from dvc.utils import env2bool, is_binary, makedirs
 
 logger = logging.getLogger(__name__)
 
 
-class Analytics(object):
-    """Class for collecting and sending usage analytics.
-
-    Args:
-        info (dict): optional existing analytics report.
+def collect_and_send_report(arguments=None, exit_code=None):
     """
+    Query the system to fill a report and send it on a detached process.
 
-    URL = "https://analytics.dvc.org"
-    TIMEOUT_POST = 5
-
-    USER_ID_FILE = "user_id"
-
-    PARAM_DVC_VERSION = "dvc_version"
-    PARAM_USER_ID = "user_id"
-    PARAM_SYSTEM_INFO = "system_info"
-
-    PARAM_OS = "os"
-
-    PARAM_WINDOWS_VERSION_MAJOR = "windows_version_major"
-    PARAM_WINDOWS_VERSION_MINOR = "windows_version_minor"
-    PARAM_WINDOWS_VERSION_BUILD = "windows_version_build"
-    PARAM_WINDOWS_VERSION_SERVICE_PACK = "windows_version_service_pack"
-
-    PARAM_MAC_VERSION = "mac_version"
-
-    PARAM_LINUX_DISTRO = "linux_distro"
-    PARAM_LINUX_DISTRO_VERSION = "linux_distro_version"
-    PARAM_LINUX_DISTRO_LIKE = "linux_distro_like"
-
-    PARAM_SCM_CLASS = "scm_class"
-    PARAM_IS_BINARY = "is_binary"
-    PARAM_CMD_CLASS = "cmd_class"
-    PARAM_CMD_RETURN_CODE = "cmd_return_code"
-
-    def __init__(self, info=None):
-        from dvc.config import Config
-        from dvc.lock import Lock
-
-        if info is None:
-            info = {}
-
-        self.info = info
+    A temporary file is used as a mean of communication between the
+    current and detached process.
+    """
+    report = {
+        "cmd_class": arguments.func.__name__,
+        "cmd_return_code": exit_code,
+        "dvc_version": __version__,
+        "is_binary": is_binary(),
+        "scm_class": scm_in_use(),
+        "system_info": system_info(),
+        "user_id": find_or_create_user_id(),
+    }
 
-        cdir = Config.get_global_config_dir()
-        try:
-            os.makedirs(cdir)
-        except OSError as exc:
-            if exc.errno != errno.EEXIST:
-                raise
+    with tempfile.NamedTemporaryFile(delete=False, mode="w") as fobj:
+        json.dump(report, fobj)
+        daemon(["analytics", fobj.name])
 
-        self.user_id_file = os.path.join(cdir, self.USER_ID_FILE)
-        self.user_id_file_lock = Lock(self.user_id_file + ".lock")
 
-    @staticmethod
-    def load(path):
-        """Loads analytics report from json file specified by path.
+def is_enabled():
+    if env2bool("DVC_TEST"):
+        return False
 
-        Args:
-            path (str): path to json file with analytics report.
-        """
-        with open(path, "r") as fobj:
-            analytics = Analytics(info=json.load(fobj))
-        os.unlink(path)
-        return analytics
+    enabled = to_bool(
+        Config(validate=False)
+        .config.get(Config.SECTION_CORE, {})
+        .get(Config.SECTION_CORE_ANALYTICS, "true")
+    )
 
-    def _write_user_id(self):
-        import uuid
+    logger.debug("Analytics is {}enabled.".format("" if enabled else "dis"))
 
-        with open(self.user_id_file, "w+") as fobj:
-            user_id = str(uuid.uuid4())
-            info = {self.PARAM_USER_ID: user_id}
-            json.dump(info, fobj)
-            return user_id
+    return enabled
 
-    def _read_user_id(self):
-        if not os.path.exists(self.user_id_file):
-            return None
 
-        with open(self.user_id_file, "r") as fobj:
-            try:
-                info = json.load(fobj)
-            except ValueError as exc:
-                logger.debug("Failed to load user_id: {}".format(exc))
-                return None
-
-            return info[self.PARAM_USER_ID]
+def send(path):
+    url = "https://analytics.dvc.org"
 
-    def _get_user_id(self):
-        from dvc.lock import LockError
+    with open(path) as fobj:
+        report = json.load(fobj)
 
-        try:
-            with self.user_id_file_lock:
-                user_id = self._read_user_id()
-                if user_id is None:
-                    user_id = self._write_user_id()
-                return user_id
-        except LockError:
-            msg = "Failed to acquire '{}'"
-            logger.debug(msg.format(self.user_id_file_lock.lockfile))
-
-    def _collect_windows(self):
-        import sys
+    requests.post(url, json=report, timeout=5)
 
-        version = sys.getwindowsversion()  # pylint: disable=no-member
-        info = {}
-        info[self.PARAM_OS] = "windows"
-        info[self.PARAM_WINDOWS_VERSION_MAJOR] = version.major
-        info[self.PARAM_WINDOWS_VERSION_MINOR] = version.minor
-        info[self.PARAM_WINDOWS_VERSION_BUILD] = version.build
-        info[self.PARAM_WINDOWS_VERSION_SERVICE_PACK] = version.service_pack
-        return info
-
-    def _collect_darwin(self):
-        import platform
-
-        info = {}
-        info[self.PARAM_OS] = "mac"
-        info[self.PARAM_MAC_VERSION] = platform.mac_ver()[0]
-        return info
-
-    def _collect_linux(self):
-        import distro
-
-        info = {}
-        info[self.PARAM_OS] = "linux"
-        info[self.PARAM_LINUX_DISTRO] = distro.id()
-        info[self.PARAM_LINUX_DISTRO_VERSION] = distro.version()
-        info[self.PARAM_LINUX_DISTRO_LIKE] = distro.like()
-        return info
-
-    def _collect_system_info(self):
-        import platform
-
-        system = platform.system()
 
-        if system == "Windows":
-            return self._collect_windows()
+def scm_in_use():
+    try:
+        scm = SCM(root_dir=Repo.find_root())
+        return type(scm).__name__
+    except NotDvcRepoError:
+        pass
 
-        if system == "Darwin":
-            return self._collect_darwin()
-
-        if system == "Linux":
-            return self._collect_linux()
-
-        raise NotImplementedError
-
-    def collect(self):
-        """Collect analytics report."""
-        from dvc.scm import SCM
-        from dvc.utils import is_binary
-        from dvc.repo import Repo
-        from dvc.exceptions import NotDvcRepoError
-
-        self.info[self.PARAM_DVC_VERSION] = __version__
-        self.info[self.PARAM_IS_BINARY] = is_binary()
-        self.info[self.PARAM_USER_ID] = self._get_user_id()
-
-        self.info[self.PARAM_SYSTEM_INFO] = self._collect_system_info()
-
-        try:
-            scm = SCM(root_dir=Repo.find_root())
-            self.info[self.PARAM_SCM_CLASS] = type(scm).__name__
-        except NotDvcRepoError:
-            pass
-
-    def collect_cmd(self, args, ret):
-        """Collect analytics info from a CLI command."""
-        from dvc.command.daemon import CmdDaemonAnalytics
-
-        assert isinstance(ret, int) or ret is None
-
-        if ret is not None:
-            self.info[self.PARAM_CMD_RETURN_CODE] = ret
-
-        if args is not None and hasattr(args, "func"):
-            assert args.func != CmdDaemonAnalytics
-            self.info[self.PARAM_CMD_CLASS] = args.func.__name__
-
-    def dump(self):
-        """Save analytics report to a temporary file.
-
-        Returns:
-            str: path to the temporary file that contains the analytics report.
-        """
-        import tempfile
 
-        with tempfile.NamedTemporaryFile(delete=False, mode="w") as fobj:
-            json.dump(self.info, fobj)
-            return fobj.name
+def system_info():
+    system = platform.system()
 
-    @staticmethod
-    def is_enabled(cmd=None):
-        from dvc.config import Config, to_bool
-        from dvc.command.daemon import CmdDaemonBase
+    if system == "Windows":
+        version = sys.getwindowsversion()
 
-        if env2bool("DVC_TEST"):
-            return False
+        return {
+            "os": "windows",
+            "windows_version_build": version.build,
+            "windows_version_major": version.major,
+            "windows_version_minor": version.minor,
+            "windows_version_service_pack": version.service_pack,
+        }
 
-        if isinstance(cmd, CmdDaemonBase):
-            return False
+    if system == "Darwin":
+        return {"os": "mac", "mac_version": platform.mac_ver()[0]}
 
-        core = Config(validate=False).config.get(Config.SECTION_CORE, {})
-        enabled = to_bool(core.get(Config.SECTION_CORE_ANALYTICS, "true"))
-        logger.debug(
-            "Analytics is {}.".format("enabled" if enabled else "disabled")
-        )
-        return enabled
+    if system == "Linux":
+        return {
+            "os": "linux",
+            "linux_distro": distro.id(),
+            "linux_distro_like": distro.like(),
+            "linux_distro_version": distro.version(),
+        }
 
-    @staticmethod
-    def send_cmd(cmd, args, ret):
-        """Collect and send analytics for CLI command.
+    return {"os": system.lower()}
 
-        Args:
-            args (list): parsed args for the CLI command.
-            ret (int): return value of the CLI command.
-        """
-        from dvc.daemon import daemon
 
-        if not Analytics.is_enabled(cmd):
-            return
+def find_or_create_user_id():
+    """
+    The user's ID is stored on a file under the global config directory.
 
-        analytics = Analytics()
-        analytics.collect_cmd(args, ret)
-        daemon(["analytics", analytics.dump()])
+    The file should contain a JSON with a "user_id" key:
 
-    def send(self):
-        """Collect and send analytics."""
-        import requests
+        {"user_id": "16fd2706-8baf-433b-82eb-8c7fada847da"}
 
-        if not self.is_enabled():
-            return
+    IDs are generated randomly with UUID.
+    """
+    config_dir = Config.get_global_config_dir()
+    fname = config_dir / "user_id"
+    lockfile = fname.with_suffix(".lock")
 
-        self.collect()
+    try:
+        with Lock(lockfile):
+            try:
+                user_id = json.load(fname.read_text())["user_id"]
+            except (FileNotFoundError, json.JSONDecodeError, AttributeError):
+                user_id = str(uuid.uuid4())
+                makedirs(fname.parent, exist_ok=True)
+                fname.write_text(json.dumps({"user_id": user_id}))
 
-        logger.debug("Sending analytics: {}".format(self.info))
+            return user_id
 
-        try:
-            requests.post(self.URL, json=self.info, timeout=self.TIMEOUT_POST)
-        except requests.exceptions.RequestException as exc:
-            logger.debug("Failed to send analytics: {}".format(str(exc)))
+    except LockError:
+        logger.debug("Failed to acquire {lock}".format(lockfile))

dvc/command/daemon.py

@@ -1,5 +1,7 @@
 from __future__ import unicode_literals
 
+import os
+
 from dvc.command.base import CmdBaseNoRepo
 from dvc.command.base import fix_subparsers
 
@@ -10,7 +12,6 @@ class CmdDaemonBase(CmdBaseNoRepo):
 
 class CmdDaemonUpdater(CmdDaemonBase):
     def run(self):
-        import os
         from dvc.repo import Repo
         from dvc.updater import Updater
 
@@ -24,10 +25,10 @@ def run(self):
 
 class CmdDaemonAnalytics(CmdDaemonBase):
     def run(self):
-        from dvc.analytics import Analytics
+        from dvc import analytics
 
-        analytics = Analytics.load(self.args.target)
-        analytics.send()
+        analytics.send(self.args.target)
+        os.path.remove(self.args.target)
 
         return 0