# Buggy code
def update(self):
    """Update the processes stats."""
    # Reset the stats
    self.processlist = []
    self.processcount = {"total": 0, "running": 0, "sleeping": 0, "thread": 0}

    # Do not process if disable tag is set
    if self.disable_tag:
        return

    # Get the time since last update
    time_since_update = getTimeSinceLastUpdate("process_disk")

    # Build an internal dict with only mandatories stats (sort keys)
    processdict = {}
    excluded_processes = set()
    for proc in psutil.process_iter():
        # Ignore kernel threads if needed
        if self.no_kernel_threads and not WINDOWS and is_kernel_thread(proc):
            continue

        # If self.max_processes is None: Only retreive mandatory stats
        # Else: retreive mandatory and standard stats
        s = self.__get_process_stats(
            proc, mandatory_stats=True, standard_stats=self.max_processes is None
        )
        # Continue to the next process if it has to be filtered
        if s is None or (
            self.is_filtered(s["cmdline"]) and self.is_filtered(s["name"])
        ):
            excluded_processes.add(proc)
            continue
        # Ok add the process to the list
        processdict[proc] = s
        # ignore the 'idle' process on Windows and *BSD
        # ignore the 'kernel_task' process on OS X
        # waiting for upstream patch from psutil
        if (
            BSD
            and processdict[proc]["name"] == "idle"
            or WINDOWS
            and processdict[proc]["name"] == "System Idle Process"
            or OSX
            and processdict[proc]["name"] == "kernel_task"
        ):
            continue
        # Update processcount (global statistics)
        try:
            self.processcount[str(proc.status())] += 1
        except KeyError:
            # Key did not exist, create it
            try:
                self.processcount[str(proc.status())] = 1
            except psutil.NoSuchProcess:
                pass
        except psutil.NoSuchProcess:
            pass
        else:
            self.processcount["total"] += 1
        # Update thread number (global statistics)
        try:
            self.processcount["thread"] += proc.num_threads()
        except Exception:
            pass

    if self._enable_tree:
        self.process_tree = ProcessTreeNode.build_tree(
            processdict,
            self.sort_key,
            self.sort_reverse,
            self.no_kernel_threads,
            excluded_processes,
        )

        for i, node in enumerate(self.process_tree):
            # Only retreive stats for visible processes (max_processes)
            if self.max_processes is not None and i >= self.max_processes:
                break

            # add standard stats
            new_stats = self.__get_process_stats(
                node.process,
                mandatory_stats=False,
                standard_stats=True,
                extended_stats=False,
            )
            if new_stats is not None:
                node.stats.update(new_stats)

            # Add a specific time_since_update stats for bitrate
            node.stats["time_since_update"] = time_since_update

    else:
        # Process optimization
        # Only retreive stats for visible processes (max_processes)
        if self.max_processes is not None:
            # Sort the internal dict and cut the top N (Return a list of tuple)
            # tuple=key (proc), dict (returned by __get_process_stats)
            try:
                processiter = sorted(
                    iteritems(processdict),
                    key=lambda x: x[1][self.sort_key],
                    reverse=self.sort_reverse,
                )
            except (KeyError, TypeError) as e:
                logger.error(
                    "Cannot sort process list by {0}: {1}".format(self.sort_key, e)
                )
                logger.error("%s" % str(iteritems(processdict)[0]))
                # Fallback to all process (issue #423)
                processloop = iteritems(processdict)
                first = False
            else:
                processloop = processiter[0 : self.max_processes]
                first = True
        else:
            # Get all processes stats
            processloop = iteritems(processdict)
            first = False

        for i in processloop:
            # Already existing mandatory stats
            procstat = i[1]
            if self.max_processes is not None:
                # Update with standard stats
                # and extended stats but only for TOP (first) process
                s = self.__get_process_stats(
                    i[0],
                    mandatory_stats=False,
                    standard_stats=True,
                    extended_stats=first,
                )
                if s is None:
                    continue
                procstat.update(s)
            # Add a specific time_since_update stats for bitrate
            procstat["time_since_update"] = time_since_update
            # Update process list
            self.processlist.append(procstat)
            # Next...
            first = False

    # Build the all processes list used by the monitored list
    self.allprocesslist = itervalues(processdict)

    # Clean internals caches if timeout is reached
    if self.cache_timer.finished():
        self.username_cache = {}
        self.cmdline_cache = {}
        # Restart the timer
        self.cache_timer.reset()


# Traceback (KeyError)
Traceback (most recent call last):
File "/usr/local/lib/python3.5/site-packages/glances/core/glances_processes.py", line 666, in update
reverse=self.sort_reverse)
File "/usr/local/lib/python3.5/site-packages/glances/core/glances_processes.py", line 665, in <lambda>
key=lambda x: x[1][self.sort_key],
KeyError: 'io_counters'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
File "/usr/local/bin/glances", line 11, in <module>
sys.exit(main())
File "/usr/local/lib/python3.5/site-packages/glances/__init__.py", line 125, in main
standalone.serve_forever()
File "/usr/local/lib/python3.5/site-packages/glances/core/glances_standalone.py", line 108, in serve_forever
return self.__serve_forever()
File "/usr/local/lib/python3.5/site-packages/glances/core/glances_standalone.py", line 89, in __serve_forever
self.stats.update()
File "/usr/local/lib/python3.5/site-packages/glances/core/glances_stats.py", line 156, in update
self._plugins[p].update()
File "/usr/local/lib/python3.5/site-packages/glances/plugins/glances_processcount.py", line 58, in update
glances_processes.update()
File "/usr/local/lib/python3.5/site-packages/glances/core/glances_processes.py", line 669, in update
logger.error("%s" % str(processdict.items()[0]))
TypeError: 'dict_items' object does not support indexing

# Fixed code
def update(self):
    """Update the processes stats."""
    # Reset the stats
    self.processlist = []
    self.processcount = {"total": 0, "running": 0, "sleeping": 0, "thread": 0}

    # Do not process if disable tag is set
    if self.disable_tag:
        return

    # Get the time since last update
    time_since_update = getTimeSinceLastUpdate("process_disk")

    # Build an internal dict with only mandatories stats (sort keys)
    processdict = {}
    excluded_processes = set()
    for proc in psutil.process_iter():
        # Ignore kernel threads if needed
        if self.no_kernel_threads and not WINDOWS and is_kernel_thread(proc):
            continue

        # If self.max_processes is None: Only retreive mandatory stats
        # Else: retreive mandatory and standard stats
        s = self.__get_process_stats(
            proc, mandatory_stats=True, standard_stats=self.max_processes is None
        )
        # Continue to the next process if it has to be filtered
        if s is None or (
            self.is_filtered(s["cmdline"]) and self.is_filtered(s["name"])
        ):
            excluded_processes.add(proc)
            continue
        # Ok add the process to the list
        processdict[proc] = s
        # ignore the 'idle' process on Windows and *BSD
        # ignore the 'kernel_task' process on OS X
        # waiting for upstream patch from psutil
        if (
            BSD
            and processdict[proc]["name"] == "idle"
            or WINDOWS
            and processdict[proc]["name"] == "System Idle Process"
            or OSX
            and processdict[proc]["name"] == "kernel_task"
        ):
            continue
        # Update processcount (global statistics)
        try:
            self.processcount[str(proc.status())] += 1
        except KeyError:
            # Key did not exist, create it
            try:
                self.processcount[str(proc.status())] = 1
            except psutil.NoSuchProcess:
                pass
        except psutil.NoSuchProcess:
            pass
        else:
            self.processcount["total"] += 1
        # Update thread number (global statistics)
        try:
            self.processcount["thread"] += proc.num_threads()
        except Exception:
            pass

    if self._enable_tree:
        self.process_tree = ProcessTreeNode.build_tree(
            processdict,
            self.sort_key,
            self.sort_reverse,
            self.no_kernel_threads,
            excluded_processes,
        )

        for i, node in enumerate(self.process_tree):
            # Only retreive stats for visible processes (max_processes)
            if self.max_processes is not None and i >= self.max_processes:
                break

            # add standard stats
            new_stats = self.__get_process_stats(
                node.process,
                mandatory_stats=False,
                standard_stats=True,
                extended_stats=False,
            )
            if new_stats is not None:
                node.stats.update(new_stats)

            # Add a specific time_since_update stats for bitrate
            node.stats["time_since_update"] = time_since_update

    else:
        # Process optimization
        # Only retreive stats for visible processes (max_processes)
        if self.max_processes is not None:
            # Sort the internal dict and cut the top N (Return a list of tuple)
            # tuple=key (proc), dict (returned by __get_process_stats)
            try:
                processiter = sorted(
                    iteritems(processdict),
                    key=lambda x: x[1][self.sort_key],
                    reverse=self.sort_reverse,
                )
            except (KeyError, TypeError) as e:
                logger.error(
                    "Cannot sort process list by {0}: {1}".format(self.sort_key, e)
                )
                logger.error("{0}".format(listitems(processdict)[0]))
                # Fallback to all process (issue #423)
                processloop = iteritems(processdict)
                first = False
            else:
                processloop = processiter[0 : self.max_processes]
                first = True
        else:
            # Get all processes stats
            processloop = iteritems(processdict)
            first = False

        for i in processloop:
            # Already existing mandatory stats
            procstat = i[1]
            if self.max_processes is not None:
                # Update with standard stats
                # and extended stats but only for TOP (first) process
                s = self.__get_process_stats(
                    i[0],
                    mandatory_stats=False,
                    standard_stats=True,
                    extended_stats=first,
                )
                if s is None:
                    continue
                procstat.update(s)
            # Add a specific time_since_update stats for bitrate
            procstat["time_since_update"] = time_since_update
            # Update process list
            self.processlist.append(procstat)
            # Next...
            first = False

    # Build the all processes list used by the monitored list
    self.allprocesslist = itervalues(processdict)

    # Clean internals caches if timeout is reached
    if self.cache_timer.finished():
        self.username_cache = {}
        self.cmdline_cache = {}
        # Restart the timer
        self.cache_timer.reset()