Python Client.captureMessage方法代码示例

# 需要导入模块: from raven.base import Client [as 别名]
# 或者: from raven.base.Client import captureMessage [as 别名]
class ThreadedTransportTest(TestCase):
    def setUp(self):
        self.url = "threaded+requests+http://some_username:[email protected]:8143/1"
        self.client = Client(dsn=self.url)

    @mock.patch('raven.transport.requests.post')
    def test_does_send(self, send):
        self.client.captureMessage(message='foo')

        time.sleep(0.1)

        self.assertEqual(send.call_count, 1)
        expected_url = 'http://localhost:8143/api/1/store/'
        self.assertEqual(expected_url, send.call_args[0][0])

    def test_shutdown_waits_for_send(self):
        url = urlparse(self.url)
        transport = DummyThreadedScheme(url)
        transport.send_delay = 0.5

        data = self.client.build_msg('raven.events.Message', message='foo')
        transport.async_send(data, None, None, None)

        time.sleep(0.1)

        # this should wait for the message to get sent
        transport.get_worker().main_thread_terminated()

        self.assertEqual(len(transport.events), 1)

# 需要导入模块: from raven.base import Client [as 别名]
# 或者: from raven.base.Client import captureMessage [as 别名]
class ThreadedTransportTest(TestCase):
    def setUp(self):
        self.url = "threaded+http://some_username:[email protected]:8143/1"
        self.client = Client(dsn=self.url)

    @mock.patch('raven.transport.http.HTTPTransport.send')
    def test_does_send(self, send):
        self.client.captureMessage(message='foo')

        time.sleep(0.1)

        # TODO: This test could be more precise by ensuring it's sending the same params that are sent
        # to the ThreadedHTTPTransport.send() method
        self.assertEqual(send.call_count, 1)

    def test_shutdown_waits_for_send(self):
        url = urlparse(self.url)
        transport = DummyThreadedScheme(url)
        transport.send_delay = 0.5

        data = self.client.build_msg('raven.events.Message', message='foo')
        transport.async_send(data, None, None, None)

        time.sleep(0.1)

        # this should wait for the message to get sent
        transport.get_worker().main_thread_terminated()

        self.assertEqual(len(transport.events), 1)

# 需要导入模块: from raven.base import Client [as 别名]
# 或者: from raven.base.Client import captureMessage [as 别名]
    def test_send(self, fake_client):
        url = "https://user:[email protected]:1234/1"
        timeout = 1
        verify_ssl = 1
        ca_certs = "/some/path/somefile"

        fake = fake_client.return_value
        raven_client = Client(
            dsn="tornado+{0}?timeout={1}&verify_ssl={2}&ca_certs={3}".
            format(url, timeout, verify_ssl, ca_certs))

        raven_client.captureMessage(message="test")

        # make sure an instance of HTTPClient was created, since we are not in
        # an IOLoop
        fake_client.assert_called_once_with()
        fake_fetch = fake.fetch

        # make sure we called fetch() which does the sending
        self.assertEqual(fake_fetch.call_count, 1)
        # only verify the special kwargs that we should be passing through,
        # no need to verify the urls and whatnot
        args, kwargs = fake_fetch.call_args
        self.assertEqual(kwargs["connect_timeout"], timeout)
        self.assertEqual(kwargs["validate_cert"], bool(verify_ssl))
        self.assertEqual(kwargs["ca_certs"], ca_certs)

# 需要导入模块: from raven.base import Client [as 别名]
# 或者: from raven.base.Client import captureMessage [as 别名]
class SentryReporter(object):
    def __init__(self, sentry_dsn, **unused):
        if Client is None:
            raise RavenNotAvailable('Raven is not installed, maybe run "pip install raven"')

        self.client = Client(sentry_dsn)

    def report(self, traceback):
        environ = traceback.context.get('environ', {})
        data = {
            'sentry.interfaces.Http': {
                'method': environ.get('REQUEST_METHOD'),
                'url': get_current_url(environ, strip_querystring=True),
                'query_string': environ.get('QUERY_STRING'),
                # TODO
                # 'data': environ.get('wsgi.input'),
                'headers': dict(get_headers(environ)),
                'env': dict(get_environ(environ)),
            }
        }

        is_backlash_event = getattr(traceback.exc_value, 'backlash_event', False)
        if is_backlash_event:
            # Just a Stack Dump request from backlash
            self.client.captureMessage(traceback.exception, data=data,
                                       stack=traceback.frames)
        else:
            # This is a real crash
            self.client.captureException(data=data)

# 需要导入模块: from raven.base import Client [as 别名]
# 或者: from raven.base.Client import captureMessage [as 别名]
class RequestsTransportTest(TestCase):
    def setUp(self):
        self.client = Client(
            dsn="requests+http://some_username:[email protected]:8143/1",
        )

    @mock.patch('raven.transport.requests.post')
    def test_does_send(self, post):
        self.client.captureMessage(message='foo')
        self.assertEqual(post.call_count, 1)
        expected_url = 'http://localhost:8143/api/1/store/'
        self.assertEqual(expected_url, post.call_args[0][0])

# 需要导入模块: from raven.base import Client [as 别名]
# 或者: from raven.base.Client import captureMessage [as 别名]
class ThreadedTransportTest(TestCase):
    def setUp(self):
        self.client = Client(
            dsn="threaded+http://some_username:[email protected]:8143/1",
        )

    @mock.patch('raven.transport.http.HTTPTransport.send')
    def test_does_send(self, send):
        self.client.captureMessage(message='foo')

        time.sleep(0.1)

        # TODO: This test could be more precise by ensuring it's sending the same params that are sent
        # to the ThreadedHTTPTransport.send() method
        self.assertEqual(send.call_count, 1)

# 需要导入模块: from raven.base import Client [as 别名]
# 或者: from raven.base.Client import captureMessage [as 别名]
class ClientUDPTest(TestCase):
    def setUp(self):
        self.server_socket = socket(AF_INET, SOCK_DGRAM)
        self.server_socket.bind(("127.0.0.1", 0))
        self.client = Client(servers=["udp://%s:%s" % self.server_socket.getsockname()], key="BassOmatic")

    def test_delivery(self):
        self.client.captureMessage("test")
        data, address = self.server_socket.recvfrom(2 ** 16)
        self.assertTrue("\n\n" in data)
        header, payload = data.split("\n\n")
        for substring in ("sentry_timestamp=", "sentry_client="):
            self.assertTrue(substring in header)

    def tearDown(self):
        self.server_socket.close()

# 需要导入模块: from raven.base import Client [as 别名]
# 或者: from raven.base.Client import captureMessage [as 别名]
class GeventTransportTest(TestCase):
    def setUp(self):
        gevent.monkey.patch_socket()
        self.addCleanup(reload, socket)
        gevent.monkey.patch_time()
        self.addCleanup(reload, time)
        self.client = Client(
            dsn="gevent+http://some_username:[email protected]:8143/1",
        )

    @mock.patch.object(GeventedHTTPTransport, '_done')
    @mock.patch('raven.transport.http.HTTPTransport.send')
    def test_does_send(self, send, done):
        self.client.captureMessage(message='foo')
        time.sleep(0)
        self.assertEqual(send.call_count, 1)
        time.sleep(0)
        self.assertEquals(done.call_count, 1)

# 需要导入模块: from raven.base import Client [as 别名]
# 或者: from raven.base.Client import captureMessage [as 别名]
class GeventTransportTest(TestCase):

    def setUp(self):
        gevent.monkey.patch_socket()
        gevent.monkey.patch_time()
        self.client = Client(
            dsn="gevent+http://some_username:[email protected]:8143/1",
        )

    def tearDown(self):
        # Undo gevent monkey patching
        reload(socket)
        reload(time)

    @mock.patch('raven.transport.base.GeventedHTTPTransport._done')
    @mock.patch('raven.transport.base.HTTPTransport.send')
    def test_does_send(self, send, done):
        self.client.captureMessage(message='foo')
        time.sleep(0)
        self.assertEqual(send.call_count, 1)
        time.sleep(0)
        self.assertEquals(done.call_count, 1)

# 需要导入模块: from raven.base import Client [as 别名]
# 或者: from raven.base.Client import captureMessage [as 别名]
class ThreadedTransportTest(TestCase):
    def setUp(self):
        self.url = "threaded+http://some_username:[email protected]:8143/1"
        self.client = Client(dsn=self.url)

    @mock.patch('raven.transport.http.HTTPTransport.send')
    def test_does_send(self, send):
        self.client.captureMessage(message='foo')

        time.sleep(0.1)

        # TODO: This test could be more precise by ensuring it's sending the same params that are sent
        # to the ThreadedHTTPTransport.send() method
        self.assertEqual(send.call_count, 1)

    def test_shutdown_waits_for_send(self):
        url = urlparse(self.url)
        transport = DummyThreadedScheme()
        transport.send_delay = 0.5

        data = self.client.build_msg('raven.events.Message', message='foo')
        transport.async_send(url, data, None, None, None)

        time.sleep(0.1)

        # this should wait for the message to get sent
        transport.get_worker().main_thread_terminated()

        self.assertEqual(len(transport.events), 1)

    def test_fork_spawns_anew(self):
        url = urlparse(self.url)
        transport = DummyThreadedScheme()
        transport.send_delay = 0.5

        data = self.client.build_msg('raven.events.Message', message='foo')

        pid = os.fork()
        if pid == 0:
            time.sleep(0.1)

            transport.async_send(url, data, None, None, None)

            # this should wait for the message to get sent
            transport.get_worker().main_thread_terminated()

            self.assertEqual(len(transport.events), 1)
            # Use os._exit here so that py.test gets not confused about
            # what the hell we're doing here.
            os._exit(0)
        else:
            os.waitpid(pid, 0)

    def test_fork_with_active_worker(self):
        # Test threaded transport when forking with an active worker.
        # Forking a process doesn't clone the worker thread - make sure
        # logging from both processes still works.
        event1 = self.client.build_msg('raven.events.Message', message='parent')
        event2 = self.client.build_msg('raven.events.Message', message='child')
        url = urlparse(self.url)
        fd, filename = mkstemp()
        try:
            os.close(fd)
            transport = LoggingThreadedScheme(filename)

            # Log from the parent process - starts the worker thread
            transport.async_send(url, event1, None, None, None)
            childpid = os.fork()

            if childpid == 0:
                # Log from the child process
                transport.async_send(url, event2, None, None, None)

                # Ensure threaded worker has finished
                transport.get_worker().stop()
                os._exit(0)

            # Wait for the child process to finish
            os.waitpid(childpid, 0)
            assert os.path.isfile(filename)

            # Ensure threaded worker has finished
            transport.get_worker().stop()

            with open(filename, 'r') as logfile:
                events = dict(x.strip().split() for x in logfile.readlines())

            # Check parent and child both logged successfully
            assert events == {
                str(os.getpid()): 'parent',
                str(childpid): 'child',
            }
        finally:
            os.remove(filename)