v6.0.2

HISTORY.rst

@@ -3,6 +3,50 @@ History
 -------
 
 
+6.0.2 (2016-01-06)
+++++++++++++++++++
+
+- upgrade wakatime-cli core to v4.1.9
+- improve C# dependency detection
+- correctly log exception tracebacks
+- log all unknown exceptions to wakatime.log file
+- disable urllib3 SSL warning from every request
+- detect dependencies from golang files
+- use api.wakatime.com for sending heartbeats
+
+
+6.0.1 (2016-01-01)
+++++++++++++++++++
+
+- use embedded python if system python is broken, or doesn't output a version number
+- log output from wakatime-cli in ST console when in debug mode
+
+
+6.0.0 (2015-12-01)
+++++++++++++++++++
+
+- use embeddable Python instead of installing on Windows
+
+
+5.0.1 (2015-10-06)
+++++++++++++++++++
+
+- look for python in system PATH again
+
+
+5.0.0 (2015-10-02)
+++++++++++++++++++
+
+- improve logging with levels and log function
+- switch registry warnings to debug log level
+
+
+4.0.20 (2015-10-01)
+++++++++++++++++++
+
+- correctly find python binary in non-Windows environments
+
+
 4.0.19 (2015-10-01)
 ++++++++++++++++++
 

README.md

@@ -1,13 +1,12 @@
 sublime-wakatime
 ================
 
-Sublime Text 2 & 3 plugin to quantify your coding using https://wakatime.com/.
+Metrics, insights, and time tracking automatically generated from your programming activity.
+
 
 Installation
 ------------
 
-Heads Up! For Sublime Text 2 on Windows & Linux, WakaTime depends on [Python](http://www.python.org/getit/) being installed to work correctly.
-    
 1. Install [Package Control](https://packagecontrol.io/installation).
 
 2. Using [Package Control](https://packagecontrol.io/docs/usage):

WakaTime.py

@@ -7,7 +7,7 @@ Website:     https://wakatime.com/
 ==========================================================="""
 
 
-__version__ = '4.0.19'
+__version__ = '6.0.2'
 
 
 import sublime
@@ -22,7 +22,8 @@ import threading
 import urllib
 import webbrowser
 from datetime import datetime
-from subprocess import Popen
+from zipfile import ZipFile
+from subprocess import Popen, STDOUT, PIPE
 try:
     import _winreg as winreg  # py2
 except ImportError:
@@ -32,6 +33,49 @@ except ImportError:
         winreg = None
 
 
+is_py2 = (sys.version_info[0] == 2)
+is_py3 = (sys.version_info[0] == 3)
+
+if is_py2:
+    def u(text):
+        if text is None:
+            return None
+        try:
+            return text.decode('utf-8')
+        except:
+            try:
+                return text.decode(sys.getdefaultencoding())
+            except:
+                try:
+                    return unicode(text)
+                except:
+                    return text
+
+elif is_py3:
+    def u(text):
+        if text is None:
+            return None
+        if isinstance(text, bytes):
+            try:
+                return text.decode('utf-8')
+            except:
+                try:
+                    return text.decode(sys.getdefaultencoding())
+                except:
+                    pass
+        try:
+            return str(text)
+        except:
+            return text
+
+else:
+    raise Exception('Unsupported Python version: {0}.{1}.{2}'.format(
+        sys.version_info[0],
+        sys.version_info[1],
+        sys.version_info[2],
+    ))
+
+
 # globals
 HEARTBEAT_FREQUENCY = 2
 ST_VERSION = int(sublime.version())
@@ -48,6 +92,13 @@ LOCK = threading.RLock()
 PYTHON_LOCATION = None
 
 
+# Log Levels
+DEBUG = 'DEBUG'
+INFO = 'INFO'
+WARNING = 'WARNING'
+ERROR = 'ERROR'
+
+
 # add wakatime package to path
 sys.path.insert(0, os.path.join(PLUGIN_DIR, 'packages'))
 try:
@@ -56,6 +107,20 @@ except ImportError:
     pass
 
 
+def log(lvl, message, *args, **kwargs):
+    try:
+        if lvl == DEBUG and not SETTINGS.get('debug'):
+            return
+        msg = message
+        if len(args) > 0:
+            msg = message.format(*args)
+        elif len(kwargs) > 0:
+            msg = message.format(**kwargs)
+        print('[WakaTime] [{lvl}] {msg}'.format(lvl=lvl, msg=msg))
+    except RuntimeError:
+        sublime.set_timeout(lambda: log(lvl, message, *args, **kwargs), 0)
+
+
 def createConfigFile():
     """Creates the .wakatime.cfg INI file in $HOME directory, if it does
     not already exist.
@@ -100,41 +165,47 @@ def prompt_api_key():
             window.show_input_panel('[WakaTime] Enter your wakatime.com api key:', default_key, got_key, None, None)
             return True
         else:
-            print('[WakaTime] Error: Could not prompt for api key because no window found.')
+            log(ERROR, 'Could not prompt for api key because no window found.')
     return False
 
 
 def python_binary():
-    global PYTHON_LOCATION
     if PYTHON_LOCATION is not None:
         return PYTHON_LOCATION
 
     # look for python in PATH and common install locations
     paths = [
-        "pythonw",
-        "python",
-        "/usr/local/bin/python",
-        "/usr/bin/python",
+        os.path.join(os.path.expanduser('~'), '.wakatime', 'python'),
+        None,
+        '/',
+        '/usr/local/bin/',
+        '/usr/bin/',
     ]
     for path in paths:
         path = find_python_in_folder(path)
         if path is not None:
-            PYTHON_LOCATION = path
+            set_python_binary_location(path)
             return path
 
     # look for python in windows registry
     path = find_python_from_registry(r'SOFTWARE\Python\PythonCore')
     if path is not None:
-        PYTHON_LOCATION = path
+        set_python_binary_location(path)
         return path
     path = find_python_from_registry(r'SOFTWARE\Wow6432Node\Python\PythonCore')
     if path is not None:
-        PYTHON_LOCATION = path
+        set_python_binary_location(path)
         return path
 
     return None
 
 
+def set_python_binary_location(path):
+    global PYTHON_LOCATION
+    PYTHON_LOCATION = path
+    log(DEBUG, 'Found Python at: {0}'.format(path))
+
+
 def find_python_from_registry(location, reg=None):
     if platform.system() != 'Windows' or winreg is None:
         return None
@@ -169,36 +240,55 @@ def find_python_from_registry(location, reg=None):
                     if path is not None:
                         path = find_python_in_folder(path)
                         if path is not None:
+                            log(DEBUG, 'Found python from {reg}\\{key}\\{version}\\{sub_key}.'.format(
+                                reg=reg,
+                                key=location,
+                                version=version,
+                                sub_key=sub_key,
+                            ))
                             return path
                 except WindowsError:
-                    print('[WakaTime] Warning: Could not read registry value "{reg}\\{key}\\{version}\\{sub_key}".'.format(
-                        reg='HKEY_CURRENT_USER',
+                    log(DEBUG, 'Could not read registry value "{reg}\\{key}\\{version}\\{sub_key}".'.format(
+                        reg=reg,
                         key=location,
                         version=version,
                         sub_key=sub_key,
                     ))
     except WindowsError:
-        print('[WakaTime] Warning: Could not read registry value "{reg}\\{key}".'.format(
-            reg='HKEY_CURRENT_USER',
-            key=location,
-        ))
+        if SETTINGS.get('debug'):
+            log(DEBUG, 'Could not read registry value "{reg}\\{key}".'.format(
+                reg=reg,
+                key=location,
+            ))
 
     return val
 
 
-def find_python_in_folder(folder):
-    path = os.path.realpath(os.path.join(folder, 'pythonw'))
+def find_python_in_folder(folder, headless=True):
+    pattern = re.compile(r'\d+\.\d+')
+
+    path = 'python'
+    if folder is not None:
+        path = os.path.realpath(os.path.join(folder, 'python'))
+    if headless:
+        path = u(path) + u('w')
+    log(DEBUG, u('Looking for Python at: {0}').format(path))
     try:
-        Popen([path, '--version'])
-        return path
+        process = Popen([path, '--version'], stdout=PIPE, stderr=STDOUT)
+        output, err = process.communicate()
+        output = u(output).strip()
+        retcode = process.poll()
+        log(DEBUG, u('Python Version Output: {0}').format(output))
+        if not retcode and pattern.search(output):
+            return path
     except:
-        pass
-    path = os.path.realpath(os.path.join(folder, 'python'))
-    try:
-        Popen([path, '--version'])
-        return path
-    except:
-        pass
+        log(DEBUG, u('Python Version Output: {0}').format(u(sys.exc_info()[1])))
+
+    if headless:
+        path = find_python_in_folder(folder, headless=False)
+        if path is not None:
+            return path
+
     return None
 
 
@@ -299,7 +389,7 @@ class SendHeartbeatThread(threading.Thread):
 
     def send_heartbeat(self):
         if not self.api_key:
-            print('[WakaTime] Error: missing api key.')
+            log(ERROR, 'missing api key.')
             return
         ua = 'sublime/%d sublime-wakatime/%s' % (ST_VERSION, __version__)
         cmd = [
@@ -325,16 +415,26 @@ class SendHeartbeatThread(threading.Thread):
             cmd.append('--verbose')
         if python_binary():
             cmd.insert(0, python_binary())
-            if self.debug:
-                print('[WakaTime] %s' % ' '.join(obfuscate_apikey(cmd)))
-            if platform.system() == 'Windows':
-                Popen(cmd, shell=False)
-            else:
-                with open(os.path.join(os.path.expanduser('~'), '.wakatime.log'), 'a') as stderr:
-                    Popen(cmd, stderr=stderr)
-            self.sent()
+            log(DEBUG, ' '.join(obfuscate_apikey(cmd)))
+            try:
+                if not self.debug:
+                    Popen(cmd)
+                    self.sent()
+                else:
+                    process = Popen(cmd, stdout=PIPE, stderr=STDOUT)
+                    output, err = process.communicate()
+                    output = u(output)
+                    retcode = process.poll()
+                    if (not retcode or retcode == 102) and not output:
+                        self.sent()
+                    if retcode:
+                        log(DEBUG if retcode == 102 else ERROR, 'wakatime-core exited with status: {0}'.format(retcode))
+                    if output:
+                        log(ERROR, u('wakatime-core output: {0}').format(output))
+            except:
+                log(ERROR, u(sys.exc_info()[1]))
         else:
-            print('[WakaTime] Error: Unable to find python binary.')
+            log(ERROR, 'Unable to find python binary.')
 
     def sent(self):
         sublime.set_timeout(self.set_status_bar, 0)
@@ -353,44 +453,57 @@ class SendHeartbeatThread(threading.Thread):
         }
 
 
-class InstallPython(threading.Thread):
-    """Non-blocking thread for installing Python on Windows machines.
+class DownloadPython(threading.Thread):
+    """Non-blocking thread for extracting embeddable Python on Windows machines.
     """
 
     def run(self):
-        print('[WakaTime] Downloading and installing python...')
-        url = 'https://www.python.org/ftp/python/3.4.3/python-3.4.3.msi'
-        if platform.architecture()[0] == '64bit':
-            url = 'https://www.python.org/ftp/python/3.4.3/python-3.4.3.amd64.msi'
-        python_msi = os.path.join(os.path.expanduser('~'), 'python.msi')
+        log(INFO, 'Downloading embeddable Python...')
+
+        ver = '3.5.0'
+        arch = 'amd64' if platform.architecture()[0] == '64bit' else 'win32'
+        url = 'https://www.python.org/ftp/python/{ver}/python-{ver}-embed-{arch}.zip'.format(
+            ver=ver,
+            arch=arch,
+        )
+
+        if not os.path.exists(os.path.join(os.path.expanduser('~'), '.wakatime')):
+            os.makedirs(os.path.join(os.path.expanduser('~'), '.wakatime'))
+
+        zip_file = os.path.join(os.path.expanduser('~'), '.wakatime', 'python.zip')
         try:
-            urllib.urlretrieve(url, python_msi)
+            urllib.urlretrieve(url, zip_file)
         except AttributeError:
-            urllib.request.urlretrieve(url, python_msi)
-        args = [
-            'msiexec',
-            '/i',
-            python_msi,
-            '/norestart',
-            '/qb!',
-        ]
-        Popen(args)
+            urllib.request.urlretrieve(url, zip_file)
+
+        log(INFO, 'Extracting Python...')
+        with ZipFile(zip_file) as zf:
+            path = os.path.join(os.path.expanduser('~'), '.wakatime', 'python')
+            zf.extractall(path)
+
+        try:
+            os.remove(zip_file)
+        except:
+            pass
+
+        log(INFO, 'Finished extracting Python.')
 
 
 def plugin_loaded():
     global SETTINGS
-    print('[WakaTime] Initializing WakaTime plugin v%s' % __version__)
+    log(INFO, 'Initializing WakaTime plugin v%s' % __version__)
+
+    SETTINGS = sublime.load_settings(SETTINGS_FILE)
 
     if not python_binary():
-        print('[WakaTime] Warning: Python binary not found.')
+        log(WARNING, 'Python binary not found.')
         if platform.system() == 'Windows':
-            thread = InstallPython()
+            thread = DownloadPython()
             thread.start()
         else:
             sublime.error_message("Unable to find Python binary!\nWakaTime needs Python to work correctly.\n\nGo to https://www.python.org/downloads")
             return
 
-    SETTINGS = sublime.load_settings(SETTINGS_FILE)
     after_loaded()
 
 

packages/wakatime/__about__.py

@@ -1,7 +1,7 @@
 __title__ = 'wakatime'
 __description__ = 'Common interface to the WakaTime api.'
 __url__ = 'https://github.com/wakatime/wakatime'
-__version_info__ = ('4', '1', '8')
+__version_info__ = ('4', '1', '9')
 __version__ = '.'.join(__version_info__)
 __author__ = 'Alan Hamlett'
 __author_email__ = 'alan@wakatime.com'

packages/wakatime/constants.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime.constants
+    ~~~~~~~~~~~~~~~~~~
+
+    Constant variable definitions.
+
+    :copyright: (c) 2016 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+
+SUCCESS = 0
+API_ERROR = 102
+CONFIG_FILE_PARSE_ERROR = 103

packages/wakatime/dependencies/go.py

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime.languages.go
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Parse dependencies from Go code.
+
+    :copyright: (c) 2016 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from . import TokenParser
+
+
+class GoParser(TokenParser):
+    state = None
+    parens = 0
+    aliases = 0
+    exclude = [
+        r'^"fmt"$',
+    ]
+
+    def parse(self):
+        for index, token, content in self.tokens:
+            self._process_token(token, content)
+        return self.dependencies
+
+    def _process_token(self, token, content):
+        if self.partial(token) == 'Namespace':
+            self._process_namespace(token, content)
+        elif self.partial(token) == 'Punctuation':
+            self._process_punctuation(token, content)
+        elif self.partial(token) == 'String':
+            self._process_string(token, content)
+        elif self.partial(token) == 'Text':
+            self._process_text(token, content)
+        elif self.partial(token) == 'Other':
+            self._process_other(token, content)
+        else:
+            self._process_misc(token, content)
+
+    def _process_namespace(self, token, content):
+        self.state = content
+        self.parens = 0
+        self.aliases = 0
+
+    def _process_string(self, token, content):
+        if self.state == 'import':
+            self.append(content, truncate=False)
+
+    def _process_punctuation(self, token, content):
+        if content == '(':
+            self.parens += 1
+        elif content == ')':
+            self.parens -= 1
+        elif content == '.':
+            self.aliases += 1
+        else:
+            self.state = None
+
+    def _process_text(self, token, content):
+        if self.state == 'import':
+            if content == "\n" and self.parens <= 0:
+                self.state = None
+                self.parens = 0
+                self.aliases = 0
+        else:
+            self.state = None
+
+    def _process_other(self, token, content):
+        if self.state == 'import':
+            self.aliases += 1
+        else:
+            self.state = None
+
+    def _process_misc(self, token, content):
+        self.state = None

packages/wakatime/logger.py

@@ -11,9 +11,10 @@
 
 import logging
 import os
-import sys
+import traceback
 
 from .compat import u
+from .packages.requests.packages import urllib3
 try:
     from collections import OrderedDict  # pragma: nocover
 except ImportError:  # pragma: nocover
@@ -70,8 +71,9 @@ class JsonFormatter(logging.Formatter):
             del data['plugin']
         return CustomEncoder().encode(data)
 
-    def formatException(self, exc_info):
-        return sys.exec_info[2].format_exc()
+
+def traceback_formatter(*args, **kwargs):
+    logging.getLogger('WakaTime').error(traceback.format_exc())
 
 
 def set_log_level(logger, args):
@@ -82,6 +84,7 @@ def set_log_level(logger, args):
 
 
 def setup_logging(args, version):
+    urllib3.disable_warnings()
     logger = logging.getLogger('WakaTime')
     for handler in logger.handlers:
         logger.removeHandler(handler)
@@ -102,6 +105,9 @@ def setup_logging(args, version):
     handler.setFormatter(formatter)
     logger.addHandler(handler)
 
+    # add custom traceback logging method
+    logger.traceback = traceback_formatter
+
     warnings_formatter = JsonFormatter(datefmt='%Y/%m/%d %H:%M:%S %z')
     warnings_formatter.setup(
         timestamp=args.timestamp,

packages/wakatime/main.py

@@ -30,6 +30,7 @@ sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), 'pac
 
 from .__about__ import __version__
 from .compat import u, open, is_py3
+from .constants import SUCCESS, API_ERROR, CONFIG_FILE_PARSE_ERROR
 from .logger import setup_logging
 from .offlinequeue import Queue
 from .packages import argparse
@@ -290,7 +291,7 @@ def send_heartbeat(project=None, branch=None, hostname=None, stats={}, key=None,
     """
 
     if not api_url:
-        api_url = 'https://wakatime.com/api/v1/heartbeats'
+        api_url = 'https://api.wakatime.com/api/v1/heartbeats'
     if not timeout:
         timeout = 30
     log.debug('Sending heartbeat to api at %s' % api_url)
@@ -408,63 +409,68 @@ def execute(argv=None):
 
     args, configs = parseArguments()
     if configs is None:
-        return 103 # config file parsing error
+        return CONFIG_FILE_PARSE_ERROR
 
     setup_logging(args, __version__)
 
-    exclude = should_exclude(args.entity, args.include, args.exclude)
-    if exclude is not False:
-        log.debug(u('Skipping because matches exclude pattern: {pattern}').format(
-            pattern=u(exclude),
-        ))
-        return 0
+    try:
+        exclude = should_exclude(args.entity, args.include, args.exclude)
+        if exclude is not False:
+            log.debug(u('Skipping because matches exclude pattern: {pattern}').format(
+                pattern=u(exclude),
+            ))
+            return SUCCESS
 
-    if args.entity_type != 'file' or os.path.isfile(args.entity):
+        if args.entity_type != 'file' or os.path.isfile(args.entity):
 
-        stats = get_file_stats(args.entity, entity_type=args.entity_type,
-                               lineno=args.lineno, cursorpos=args.cursorpos)
+            stats = get_file_stats(args.entity,
+                                   entity_type=args.entity_type,
+                                   lineno=args.lineno,
+                                   cursorpos=args.cursorpos)
 
-        project = args.project or args.alternate_project
-        branch = None
-        if args.entity_type == 'file':
-            project, branch = get_project_info(configs, args)
+            project = args.project or args.alternate_project
+            branch = None
+            if args.entity_type == 'file':
+                project, branch = get_project_info(configs, args)
 
-        kwargs = vars(args)
-        kwargs['project'] = project
-        kwargs['branch'] = branch
-        kwargs['stats'] = stats
-        kwargs['hostname'] = args.hostname or socket.gethostname()
-        kwargs['timeout'] = args.timeout
+            kwargs = vars(args)
+            kwargs['project'] = project
+            kwargs['branch'] = branch
+            kwargs['stats'] = stats
+            kwargs['hostname'] = args.hostname or socket.gethostname()
+            kwargs['timeout'] = args.timeout
 
-        if send_heartbeat(**kwargs):
-            queue = Queue()
-            while True:
-                heartbeat = queue.pop()
-                if heartbeat is None:
-                    break
-                sent = send_heartbeat(
-                    project=heartbeat['project'],
-                    entity=heartbeat['entity'],
-                    timestamp=heartbeat['time'],
-                    branch=heartbeat['branch'],
-                    hostname=kwargs['hostname'],
-                    stats=json.loads(heartbeat['stats']),
-                    key=args.key,
-                    isWrite=heartbeat['is_write'],
-                    plugin=heartbeat['plugin'],
-                    offline=args.offline,
-                    hidefilenames=args.hidefilenames,
-                    entity_type=heartbeat['type'],
-                    proxy=args.proxy,
-                    api_url=args.api_url,
-                    timeout=args.timeout,
-                )
-                if not sent:
-                    break
-            return 0 # success
+            if send_heartbeat(**kwargs):
+                queue = Queue()
+                while True:
+                    heartbeat = queue.pop()
+                    if heartbeat is None:
+                        break
+                    sent = send_heartbeat(
+                        project=heartbeat['project'],
+                        entity=heartbeat['entity'],
+                        timestamp=heartbeat['time'],
+                        branch=heartbeat['branch'],
+                        hostname=kwargs['hostname'],
+                        stats=json.loads(heartbeat['stats']),
+                        key=args.key,
+                        isWrite=heartbeat['is_write'],
+                        plugin=heartbeat['plugin'],
+                        offline=args.offline,
+                        hidefilenames=args.hidefilenames,
+                        entity_type=heartbeat['type'],
+                        proxy=args.proxy,
+                        api_url=args.api_url,
+                        timeout=args.timeout,
+                    )
+                    if not sent:
+                        break
+                return SUCCESS
 
-        return 102 # api error
+            return API_ERROR
 
-    else:
-        log.debug('File does not exist; ignoring this heartbeat.')
-        return 0
+        else:
+            log.debug('File does not exist; ignoring this heartbeat.')
+            return SUCCESS
+    except:
+        log.traceback()

packages/wakatime/projects/git.py

@@ -44,9 +44,9 @@ class Git(BaseProject):
                     with open(head, 'r', encoding=sys.getfilesystemencoding()) as fh:
                         return u(fh.readline().strip().rsplit('/', 1)[-1])
                 except:
-                    log.exception("Exception:")
+                    log.traceback()
             except IOError:  # pragma: nocover
-                log.exception("Exception:")
+                log.traceback()
         return None
 
     def _project_base(self):

packages/wakatime/projects/mercurial.py

@@ -42,9 +42,9 @@ class Mercurial(BaseProject):
                     with open(branch_file, 'r', encoding=sys.getfilesystemencoding()) as fh:
                         return u(fh.readline().strip().rsplit('/', 1)[-1])
                 except:
-                    log.exception("Exception:")
+                    log.traceback()
             except IOError:  # pragma: nocover
-                log.exception("Exception:")
+                log.traceback()
         return u('default')
 
     def _find_hg_config_dir(self, path):

packages/wakatime/projects/wakatime_project_file.py

@@ -41,9 +41,9 @@ class WakaTimeProjectFile(BaseProject):
                         self._project_name = u(fh.readline().strip())
                         self._project_branch = u(fh.readline().strip())
                 except:
-                    log.exception("Exception:")
+                    log.traceback()
             except IOError:  # pragma: nocover
-                log.exception("Exception:")
+                log.traceback()
 
             return True
         return False

packages/wakatime/session_cache.py

@@ -14,7 +14,6 @@ import logging
 import os
 import pickle
 import sys
-import traceback
 
 try:
     import sqlite3
@@ -58,7 +57,7 @@ class SessionCache(object):
             conn.commit()
             conn.close()
         except:  # pragma: nocover
-            log.error(traceback.format_exc())
+            log.traceback()
 
 
     def get(self):
@@ -73,7 +72,7 @@ class SessionCache(object):
         try:
             conn, c = self.connect()
         except:
-            log.error(traceback.format_exc())
+            log.traceback()
             return requests.session()
 
         session = None
@@ -84,12 +83,12 @@ class SessionCache(object):
             if row is not None:
                 session = pickle.loads(row[0])
         except:  # pragma: nocover
-            log.error(traceback.format_exc())
+            log.traceback()
 
         try:
             conn.close()
         except:  # pragma: nocover
-            log.error(traceback.format_exc())
+            log.traceback()
 
         return session if session is not None else requests.session()
 
@@ -106,4 +105,4 @@ class SessionCache(object):
             conn.commit()
             conn.close()
         except:
-            log.error(traceback.format_exc())
+            log.traceback()

packages/wakatime/stats.py

@@ -191,5 +191,5 @@ def get_file_contents(file_name):
             with open(file_name, 'r', encoding=sys.getfilesystemencoding()) as fh:
                 text = fh.read(512000)
         except:
-            log.exception("Exception:")
+            log.traceback()
     return text