I see already reported on the forum that coverage.py and gevent don't play
nicely with each other.  I think I have a fix for that:

    def switch(self):
        cur = getcurrent()
        assert cur is not self, 'Cannot switch to MAINLOOP from MAINLOOP'
        exc_type, exc_value = sys.exc_info()[:2]
*        trace = sys.gettrace()
        sys.settrace(None)
*        try:
            switch_out = getattr(cur, 'switch_out', None)
            if switch_out is not None:
                try:
                    switch_out()
                except:
                    traceback.print_exc()
            sys.exc_clear()
            return greenlet.switch(self)
        finally:
            core.set_exc_info(exc_type, exc_value)
*            sys.settrace(trace)

*I am fairly new to python and gevent, so I'm not sure if this might break
anything for anyone else, but it seems to restore coverage reporting.  The
issue seems to be that sys.settrace() used by coverage.py doesn't like to
see the gevent frames without expecting them.  changing the trace to None
and restoring after hub.switch seems to fix the issue and restore correct
coverage results.  Note to coverage users: you have to specifically enable
"timid" in coverage tools.  I'm not sure why this doesn't help with the
pre-compiled trace function.

Has anyone tried anything like this?  Any issues you can think of?

Jonathan

That helps!  I can now handle spawned greenlets, but I'm still a little
unclear on the event loop callbacks.  Is there an example you can point me
to?

Not sure if python uses the same terms, but I'm used to describing my
location with the terms thread, stack and frame.  A thread is a path of
execution through the program (possibly simultaneous with other threads), a
stack  describes the nested calls made by the thread, a frame is a single
layer on the stack (a function call, with associated local variables and
arguments).

The issue I was raising with "gevent frame" was that the coverage trace
function kept a representation of the stack and expected it to remain the
same.  So if we are running coverage on a function with a blocking call in
the middle, the stack before and after that blocking call may look
different.  After the blocking call, the stack starts with gevent's
Hub.switch() but before the blocking call the stack looked different -- the
trace function found a frame there that hadn't been there before the
blocking function.

The latest implementation works for our project's unit tests but requires
that both coverage and gevent have slight changes.  Here are public
repositories in case anyone wants to try out the combination.  One caveat
-- so far, this works for line coverage metrics, but disables branch
coverage.  There is certainly work to do, but for now I'm just hoping
anyone out there can point out cases that won't show correct coverage
metrics or places I might break gevent.

Each project for now just has two commits.  The first is the untouched
original code from the gevent or coverage repository.  The next commit is
my changes.  Just a few lines in a couple files.

coverage source <https://github.com/newbrough/coverage> - edited trace
function to ignore the unexpected change to the stack after a blocking call
gevent source <https://github.com/newbrough/gevent> - edited Hub.switch to
save and restore the trace function; Greenlet.__init__ to apply the global
trace function set with threading.settrace