How to use the ddtrace.ext.errors function in ddtrace

def test_unhandled_exception(self):

        def exc_resolver(*args):
            raise Exception('Testing stuff')

        tracer, schema = get_traced_schema(resolver=exc_resolver)
        result = traced_graphql(schema, '{ hello }')
        span = tracer.writer.pop()[0]
        assert span.get_metric(INVALID) == 0
        assert span.error == 1
        assert span.get_metric(CLIENT_ERROR) == 0
        assert span.get_metric(DATA_EMPTY) == 0

        error_stack = span.get_tag(ddtrace_errors.ERROR_STACK)
        assert 'Testing stuff' in error_stack
        assert 'Traceback' in error_stack

        error_msg = span.get_tag(ddtrace_errors.ERROR_MSG)
        assert 'Testing stuff' in error_msg

        error_type = span.get_tag(ddtrace_errors.ERROR_TYPE)
        assert 'Exception' in error_type

        try:
            raise Exception('Testing stuff')
        except Exception as exc:
            _error = exc

        def _tg(*args, **kwargs):
            def func(*args, **kwargs):

def test_execute_exception(self):
        """Exceptions should result in appropriate span tagging."""
        from vertica_python.errors import VerticaSyntaxError

        conn, cur = self.test_conn

        with conn, pytest.raises(VerticaSyntaxError):
            cur.execute('INVALID QUERY')

        spans = self.test_tracer.writer.pop()
        assert len(spans) == 2

        # check all the metadata
        assert spans[0].service == 'vertica'
        assert spans[0].error == 1
        assert 'INVALID QUERY' in spans[0].get_tag(errors.ERROR_MSG)
        error_type = 'vertica_python.errors.VerticaSyntaxError'
        assert spans[0].get_tag(errors.ERROR_TYPE) == error_type
        assert spans[0].get_tag(errors.ERROR_STACK)

        assert spans[1].resource == 'COMMIT;'

retries = 3
        try:
            self.http.request("GET", "http://fakesubdomain." + SOCKET, retries=retries)
        except Exception:
            pass
        else:
            assert 0, "expected error"

        spans = self.tracer.writer.pop()
        assert len(spans) == 4  # Default retry behavior is 3 retries + original request
        for i, s in enumerate(spans):
            assert s.get_tag(http.METHOD) == "GET"
            if i > 0:
                assert s.get_tag(http.RETRIES_REMAIN) == str(retries - i)
            assert s.error == 1
            assert "Failed to establish a new connection" in s.get_tag(errors.MSG)
            assert "Failed to establish a new connection" in s.get_tag(errors.STACK)
            assert "Traceback (most recent call last)" in s.get_tag(errors.STACK)
            assert "urllib3.exceptions.MaxRetryError" in s.get_tag(errors.TYPE)

def test_traceback_with_error(self):
        s = Span(None, 'test.span')
        try:
            1 / 0
        except ZeroDivisionError:
            s.set_traceback()
        else:
            assert 0, 'should have failed'

        assert s.error
        assert 'by zero' in s.get_tag(errors.ERROR_MSG)
        assert 'ZeroDivisionError' in s.get_tag(errors.ERROR_TYPE)

def test_route_exception(self):
        def route_error() -> str:
            raise Exception('Error message')
        app = molten.App(routes=[molten.Route('/error', route_error)])
        client = TestClient(app)
        response = client.get('/error')
        spans = self.tracer.writer.pop()
        self.assertEqual(response.status_code, 500)
        span = spans[0]
        route_error_span = spans[-1]
        self.assertEqual(span.service, 'molten')
        self.assertEqual(span.name, 'molten.request')
        self.assertEqual(span.resource, 'GET /error')
        self.assertEqual(span.error, 1)
        # error tags only set for route function span and not root span
        self.assertIsNone(span.get_tag(errors.ERROR_MSG))
        self.assertEqual(route_error_span.get_tag(errors.ERROR_MSG), 'Error message')

import traceback
        from ddtrace.ext import errors

        stack_trace = str(traceback.format_stack())
        nop_span.log_kv({
            'event': 'error',
            'error': 3,
            'message': 'my error message',
            'stack': stack_trace,
        })

        # Ensure error flag is set...
        assert nop_span._dd_span.error
        # ...and that error tags are set with the correct key
        assert nop_span._get_tag(errors.ERROR_STACK) == stack_trace
        assert nop_span._get_tag(errors.ERROR_MSG) == 'my error message'
        assert nop_span._get_tag(errors.ERROR_TYPE) == '3'

def _remove_exc_info(self):
        """ Remove all exception related information from the span. """
        self.error = 0
        self._remove_tag(errors.ERROR_MSG)
        self._remove_tag(errors.ERROR_TYPE)
        self._remove_tag(errors.ERROR_STACK)

def set_traceback(self, limit=20):
        """ If the current stack has an exception, tag the span with the
            relevant error info. If not, set the span to the current python stack.
        """
        (exc_type, exc_val, exc_tb) = sys.exc_info()

        if (exc_type and exc_val and exc_tb):
            self.set_exc_info(exc_type, exc_val, exc_tb)
        else:
            tb = ''.join(traceback.format_stack(limit=limit + 1)[:-1])
            self.set_tag(errors.ERROR_STACK, tb)  # FIXME[gabin] Want to replace 'error.stack' tag with 'python.stack'

""" Tag the span with an error tuple as from `sys.exc_info()`. """
        if not (exc_type and exc_val and exc_tb):
            return  # nothing to do

        self.error = 1

        # get the traceback
        buff = StringIO()
        traceback.print_exception(exc_type, exc_val, exc_tb, file=buff, limit=20)
        tb = buff.getvalue()

        # readable version of type (e.g. exceptions.ZeroDivisionError)
        exc_type_str = '%s.%s' % (exc_type.__module__, exc_type.__name__)

        self.set_tag(errors.ERROR_MSG, exc_val)
        self.set_tag(errors.ERROR_TYPE, exc_type_str)
        self.set_tag(errors.ERROR_STACK, tb)

if not (exc_type and exc_val and exc_tb):
            return  # nothing to do

        self.error = 1

        # get the traceback
        buff = StringIO()
        traceback.print_exception(exc_type, exc_val, exc_tb, file=buff, limit=20)
        tb = buff.getvalue()

        # readable version of type (e.g. exceptions.ZeroDivisionError)
        exc_type_str = '%s.%s' % (exc_type.__module__, exc_type.__name__)

        self.set_tag(errors.ERROR_MSG, exc_val)
        self.set_tag(errors.ERROR_TYPE, exc_type_str)
        self.set_tag(errors.ERROR_STACK, tb)