fix: track more platform vars, integration with sentry

Author: oesteban

fmriprep/cli/workflow.py

@@ -34,6 +34,12 @@ def build_workflow(config_file, retval):
     if msg is not None:
         build_log.warning(msg)
 
+    dset_desc_path = config.execution.bids_dir / 'dataset_description.json'
+    if dset_desc_path.exists():
+        from hashlib import sha256
+        desc_content = dset_desc_path.read_bytes()
+        config.execution.bids_description_hash = sha256(desc_content).hexdigest()
+
     # First check that bids_dir looks like a BIDS folder
     config.init_layout()
     subject_list = collect_participants(

fmriprep/config.py

@@ -141,14 +141,14 @@ def redirect_warnings(message, category, filename, lineno, file=None, line=None)
 DEFAULT_MEMORY_MIN_GB = 0.01
 
 _exec_env = os.name
+_docker_ver = None
 # special variable set in the container
 if os.getenv('IS_DOCKER_8395080871'):
     _exec_env = 'singularity'
     _cgroup = Path('/proc/1/cgroup')
     if _cgroup.exists() and 'docker' in _cgroup.read_text():
-        _exec_env = 'docker'
-        if os.getenv('DOCKER_VERSION_8395080871'):
-            _exec_env = 'fmriprep-docker'
+        _docker_ver = os.getenv('DOCKER_VERSION_8395080871')
+        _exec_env = 'fmriprep-docker' if _docker_ver else 'docker'
     del _cgroup
 
 _fs_license = os.getenv('FS_LICENSE')
@@ -160,6 +160,32 @@ def redirect_warnings(message, category, filename, lineno, file=None, line=None)
     os.path.join(os.getenv('HOME'), '.cache', 'templateflow'))
 )
 
+try:
+    from psutil import virtual_memory
+    _free_mem_at_start = round(virtual_memory().free / 1024**3, 1)
+except Exception:
+    _free_mem_at_start = None
+
+_oc_limit = 'n/a'
+_oc_policy = 'n/a'
+try:
+    # Memory policy may have a large effect on types of errors experienced
+    _proc_oc_path = Path('/proc/sys/vm/overcommit_memory')
+    if _proc_oc_path.exists():
+        _oc_policy = {
+            '0': 'heuristic', '1': 'always', '2': 'never'
+        }.get(_proc_oc_path.read_text().strip(), 'unknown')
+        if _oc_policy != 'never':
+            _proc_oc_kbytes = Path('/proc/sys/vm/overcommit_kbytes')
+            if _proc_oc_kbytes.exists():
+                _oc_limit = _proc_oc_kbytes.read_text().strip()
+            if _oc_limit in ('0', 'n/a') and Path('/proc/sys/vm/overcommit_ratio').exists():
+                _oc_limit = '{}%'.format(
+                    Path('/proc/sys/vm/overcommit_ratio').read_text().strip()
+                )
+except Exception:
+    pass
+
 
 class _Config:
     """An abstract class forbidding instantiation."""
@@ -206,6 +232,8 @@ class nipype(_Config):
 
     crashfile_format = 'txt'
     """The file format for crashfiles, either text or pickle."""
+    free_mem = _free_mem_at_start
+    """Free memory at start."""
     get_linked_libs = False
     """Run NiPype's tool to enlist linked libraries for every interface."""
     memory_gb = None
@@ -214,6 +242,10 @@ class nipype(_Config):
     """Number of processes (compute tasks) that can be run in parallel (multiprocessing only)."""
     omp_nthreads = os.cpu_count()
     """Number of CPUs a single process can access for multithreaded execution."""
+    overcommit_policy = _oc_policy
+    """Linux's kernel virtual memory overcommit policy."""
+    overcommit_limit = _oc_limit
+    """Linux's kernel virtual memory overcommit limits."""
     plugin = 'MultiProc'
     """NiPype's execution plugin."""
     plugin_args = {
@@ -255,6 +287,8 @@ class execution(_Config):
     """Run in sloppy mode (meaning, suboptimal parameters that minimize run-time)."""
     echo_idx = None
     """Select a particular echo for multi-echo EPI datasets."""
+    exec_docker_version = _docker_ver
+    """Version of Docker Engine."""
     exec_env = _exec_env
     """A string representing the execution platform."""
     fs_license_file = _fs_license
@@ -288,6 +322,7 @@ class execution(_Config):
     templateflow_home = _templateflow_home
     """The root folder of the TemplateFlow client."""
     templateflow_version = _tf_ver
+    """The TemplateFlow client version installed."""
     version = __version__
     """*fMRIPrep*'s version."""
     work_dir = Path('work').absolute()
@@ -315,6 +350,9 @@ class execution(_Config):
 del _nipype_ver
 del _templateflow_home
 del _tf_ver
+del _free_mem_at_start
+del _oc_limit
+del _oc_policy
 
 
 class workflow(_Config):

fmriprep/utils/sentry.py

@@ -1,8 +1,7 @@
 # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
 # vi: set ft=python sts=4 ts=4 sw=4 et:
-"""Stripped out routines for Sentry"""
+"""Stripped out routines for Sentry."""
 import os
-from pathlib import Path
 import re
 from niworkflows.utils.misc import read_crashfile
 import sentry_sdk
@@ -43,66 +42,24 @@
 
 
 def sentry_setup():
-    from os import cpu_count
-    import psutil
-    import hashlib
-
-    exec_env = config.execution.exec_env
-    environment = "prod"
-    release = config.execution.version
-    if not release:
-        environment = "dev"
-        release = "dev"
-    elif int(os.getenv('FMRIPREP_DEV', '0')) or ('+' in release):
-        environment = "dev"
+    """Set-up sentry."""
+    release = config.execution.version or "dev"
+    environment = "dev" if (
+        os.getenv('FMRIPREP_DEV', '').lower in ('1', 'on', 'yes', 'y', 'true')
+        or ('+' in release)
+    ) else "prod"
 
     sentry_sdk.init("https://[email protected]/1137693",
                     release=release,
                     environment=environment,
                     before_send=before_send)
     with sentry_sdk.configure_scope() as scope:
-        scope.set_tag('exec_env', exec_env)
-
-        if exec_env == 'fmriprep-docker':
-            scope.set_tag('docker_version', os.getenv('DOCKER_VERSION_8395080871'))
-
-        dset_desc_path = config.execution.bids_dir / 'dataset_description.json'
-        if dset_desc_path.exists():
-            desc_content = dset_desc_path.read_bytes()
-            scope.set_tag('dset_desc_sha256', hashlib.sha256(desc_content).hexdigest())
-
-        free_mem_at_start = round(psutil.virtual_memory().free / 1024**3, 1)
-        scope.set_tag('free_mem_at_start', free_mem_at_start)
-        scope.set_tag('cpu_count', cpu_count())
-
-        # Memory policy may have a large effect on types of errors experienced
-        overcommit_memory = Path('/proc/sys/vm/overcommit_memory')
-        if overcommit_memory.exists():
-            policy = {'0': 'heuristic',
-                      '1': 'always',
-                      '2': 'never'}.get(overcommit_memory.read_text().strip(), 'unknown')
-            scope.set_tag('overcommit_memory', policy)
-            if policy == 'never':
-                overcommit_kbytes = Path('/proc/sys/vm/overcommit_memory')
-                kb = overcommit_kbytes.read_text().strip()
-                if kb != '0':
-                    limit = '{}kB'.format(kb)
-                else:
-                    overcommit_ratio = Path('/proc/sys/vm/overcommit_ratio')
-                    limit = '{}%'.format(overcommit_ratio.read_text().strip())
-                scope.set_tag('overcommit_limit', limit)
-            else:
-                scope.set_tag('overcommit_limit', 'n/a')
-        else:
-            scope.set_tag('overcommit_memory', 'n/a')
-            scope.set_tag('overcommit_limit', 'n/a')
-
         for k, v in config.get(flat=True).items():
             scope.set_tag(k, v)
 
 
 def process_crashfile(crashfile):
-    """Parse the contents of a crashfile and submit sentry messages"""
+    """Parse the contents of a crashfile and submit sentry messages."""
     crash_info = read_crashfile(str(crashfile))
     with sentry_sdk.push_scope() as scope:
         scope.level = 'fatal'
@@ -169,7 +126,7 @@ def process_crashfile(crashfile):
 
 
 def before_send(event, hints):
-    # Filtering log messages about crashed nodes
+    """Filter log messages about crashed nodes."""
     if 'logentry' in event and 'message' in event['logentry']:
         msg = event['logentry']['message']
         if msg.startswith("could not run node:"):
@@ -193,7 +150,7 @@ def before_send(event, hints):
 
 def _chunks(string, length=CHUNK_SIZE):
     """
-    Splits a string into smaller chunks
+    Split a string into smaller chunks.
 
     >>> list(_chunks('some longer string.', length=3))
     ['som', 'e l', 'ong', 'er ', 'str', 'ing', '.']