def send_encoded(self, message, auth_header=None, **kwargs):
"""
Given an already serialized message, signs the message and passes the
payload off to ``send_remote`` for each server specified in the servers
configuration.
callback can be specified as a keyword argument
"""
if not auth_header:
timestamp = time.time()
auth_header = get_auth_header(
protocol=self.protocol_version,
timestamp=timestamp,
client='raven-python/%s' % (raven.VERSION,),
api_key=self.public_key,
api_secret=self.secret_key,
)
for url in self.servers:
headers = {
'X-Sentry-Auth': auth_header,
'Content-Type': 'application/octet-stream',
}
self.send_remote(
url=url, data=message, headers=headers,
callback=kwargs.get('callback', None)
)
def send_encoded(self, message, auth_header=None, **kwargs):
"""
Given an already serialized message, signs the message and passes the
payload off to ``send_remote``.
"""
client_string = 'raven-python/%s' % (raven.VERSION, )
if not auth_header:
timestamp = time.time()
auth_header = get_auth_header(
protocol=self.protocol_version,
timestamp=timestamp,
client=client_string,
api_key=self.remote.public_key,
api_secret=self.remote.secret_key,
)
headers = {
'User-Agent': client_string,
'X-Sentry-Auth': auth_header,
'Content-Encoding': self.get_content_encoding(),
'Content-Type': 'application/octet-stream',
}
return self.send_remote(url=self.remote.store_endpoint,
data=message,
headers=headers,
**kwargs)
def send_encoded(self, message, public_key=None, auth_header=None, **kwargs):
"""
Given an already serialized message, signs the message and passes the
payload off to ``send_remote`` for each server specified in the servers
configuration.
"""
if not self.servers:
warnings.warn('Raven client has no remote servers configured')
return
client_string = 'raven-python/%s' % (raven.VERSION,)
if not auth_header:
timestamp = time.time()
auth_header = get_auth_header(
protocol=self.protocol_version,
timestamp=timestamp,
client=client_string,
api_key=public_key or self.public_key
)
for url in self.servers:
headers = {
'User-Agent': client_string,
'X-Sentry-Auth': auth_header,
'Content-Type': 'application/octet-stream',
}
self.send_remote(url=url, data=message, headers=headers)
def send(self, **data):
"""
Sends the message to the server.
If ``servers`` was passed into the constructor, this will serialize the data and pipe it to
each server using ``send_remote()``. Otherwise, this will communicate with ``sentry.models.GroupedMessage``
directly.
"""
message = base64.b64encode(json.dumps(data).encode('zlib'))
for url in self.servers:
timestamp = time.time()
signature = get_signature(message, timestamp, self.secret_key or self.key)
headers = {
'X-Sentry-Auth': get_auth_header(signature, timestamp, 'raven/%s' % (raven.VERSION,), self.public_key),
'Content-Type': 'application/octet-stream',
}
try:
self.send_remote(url=url, data=message, headers=headers)
except urllib2.HTTPError, e:
body = e.read()
self.logger.error('Unable to reach Sentry log server: %s (url: %%s, body: %%s)' % (e,), url, body,
exc_info=True, extra={'data': {'body': body, 'remote_url': url}})
self.logger.log(data.pop('level', None) or logging.ERROR, data.pop('message', None))
except urllib2.URLError, e:
self.logger.error('Unable to reach Sentry log server: %s (url: %%s)' % (e,), url,
exc_info=True, extra={'data': {'remote_url': url}})
self.logger.log(data.pop('level', None) or logging.ERROR, data.pop('message', None))
def send_encoded(self,
message,
public_key=None,
auth_header=None,
**kwargs):
"""
Given an already serialized message, signs the message and passes the
payload off to ``send_remote`` for each server specified in the servers
configuration.
"""
if not self.servers:
warnings.warn('Raven client has no remote servers configured')
return
if not auth_header:
timestamp = time.time()
auth_header = get_auth_header(
protocol=self.protocol_version,
timestamp=timestamp,
client='raven-python/%s' % (raven.VERSION, ),
api_key=public_key or self.public_key)
for url in self.servers:
headers = {
'X-Sentry-Auth': auth_header,
'Content-Type': 'application/octet-stream',
}
self.send_remote(url=url, data=message, headers=headers)
def send_encoded(self, message, auth_header=None, **kwargs):
"""
Given an already serialized message, signs the message and passes the
payload off to ``send_remote`` for each server specified in the servers
configuration.
"""
client_string = "raven-python/%s" % (raven.VERSION,)
if not auth_header:
timestamp = time.time()
auth_header = get_auth_header(
protocol=self.protocol_version,
timestamp=timestamp,
client=client_string,
api_key=self.remote.public_key,
api_secret=self.remote.secret_key,
)
headers = {
"User-Agent": client_string,
"X-Sentry-Auth": auth_header,
"Content-Encoding": self.get_content_encoding(),
"Content-Type": "application/octet-stream",
}
self.send_remote(url=self.remote.store_endpoint, data=message, headers=headers, **kwargs)
def send_encoded(self, message, auth_header=None, **kwargs):
"""
Given an already serialized message, signs the message and passes the
payload off to ``send_remote`` for each server specified in the servers
configuration.
"""
client_string = 'raven-python/%s' % (raven.VERSION,)
if not auth_header:
timestamp = time.time()
auth_header = get_auth_header(
protocol=self.protocol_version,
timestamp=timestamp,
client=client_string,
api_key=self.public_key,
api_secret=self.secret_key,
)
for url in self.servers:
headers = {
'User-Agent': client_string,
'X-Sentry-Auth': auth_header,
'Content-Type': 'application/octet-stream',
}
self.send_remote(url=url, data=message, headers=headers)
def send_encoded(self, message, auth_header=None, **kwargs):
"""
Given an already serialized message, signs the message and passes the
payload off to ``send_remote``.
"""
client_string = 'raven-python/%s' % (raven.VERSION,)
if not auth_header:
timestamp = time.time()
auth_header = get_auth_header(
protocol=self.protocol_version,
timestamp=timestamp,
client=client_string,
api_key=self.remote.public_key,
api_secret=self.remote.secret_key,
)
headers = {
'User-Agent': client_string,
'X-Sentry-Auth': auth_header,
'Content-Encoding': self.get_content_encoding(),
'Content-Type': 'application/octet-stream',
}
self.send_remote(
url=self.remote.store_endpoint,
data=message,
headers=headers,
**kwargs
)
def send(self, **data):
"""
Sends the message to the server.
If ``servers`` was passed into the constructor, this will serialize the data and pipe it to
each server using ``send_remote()``. Otherwise, this will communicate with ``sentry.models.GroupedMessage``
directly.
"""
message = base64.b64encode(json.dumps(data).encode('zlib'))
for url in self.servers:
timestamp = time.time()
signature = get_signature(message, timestamp, self.secret_key or self.key)
headers = {
'X-Sentry-Auth': get_auth_header(signature, timestamp, 'raven/%s' % (raven.VERSION,), self.public_key),
'Content-Type': 'application/octet-stream',
}
try:
self.send_remote(url=url, data=message, headers=headers)
except urllib2.HTTPError, e:
body = e.read()
self.logger.error('Unable to reach Sentry log server: %s (url: %%s, body: %%s)' % (e,), url, body,
exc_info=True, extra={'data': {'body': body, 'remote_url': url}})
self.logger.log(data.pop('level', None) or logging.ERROR, data.pop('message', None))
except urllib2.URLError, e:
self.logger.error('Unable to reach Sentry log server: %s (url: %%s)' % (e,), url,
exc_info=True, extra={'data': {'remote_url': url}})
self.logger.log(data.pop('level', None) or logging.ERROR, data.pop('message', None))
def send_encoded(self, message, public_key=None, auth_header=None, **kwargs):
"""
Given an already serialized message, signs the message and passes the
payload off to ``send_remote`` for each server specified in the servers
configuration.
callback can be specified as a keyword argument
"""
if not self.servers:
warnings.warn("Raven client has no remote servers configured")
return
if not auth_header:
timestamp = time.time()
auth_header = get_auth_header(
protocol=self.protocol_version,
timestamp=timestamp,
client="raven-python/%s" % (raven.VERSION,),
api_key=public_key or self.public_key,
)
for url in self.servers:
headers = {"X-Sentry-Auth": auth_header, "Content-Type": "application/octet-stream"}
self.send_remote(url=url, data=message, headers=headers, callback=kwargs.get("callback", None))
def send(self, **kwargs):
# Report the issue to an upstream Sentry if active
# NOTE: we don't want to check self.is_enabled() like normal, since
# is_enabled behavior is overridden in this class. We explicitly
# want to check if the remote is active.
if self.remote.is_active():
from sentry import options
# Append some extra tags that are useful for remote reporting
super_kwargs = copy.deepcopy(kwargs)
super_kwargs['tags']['install-id'] = options.get(
'sentry:install-id')
super(SentryInternalClient, self).send(**super_kwargs)
if not is_current_event_safe():
return
# These imports all need to be internal to this function as this class
# is set up by django while still parsing LOGGING settings and we
# cannot import this stuff until settings are finalized.
from sentry.models import ProjectKey
from sentry.web.api import StoreView
from django.test import RequestFactory
key = None
if settings.SENTRY_PROJECT_KEY is not None:
key = ProjectKey.objects.filter(
id=settings.SENTRY_PROJECT_KEY,
project=settings.SENTRY_PROJECT).first()
if key is None:
key = ProjectKey.get_default(settings.SENTRY_PROJECT)
if key is None:
return
client_string = 'raven-python/%s' % (raven.VERSION, )
headers = {
'HTTP_X_SENTRY_AUTH':
get_auth_header(
protocol=self.protocol_version,
timestamp=time.time(),
client=client_string,
api_key=key.public_key,
api_secret=key.secret_key,
),
'HTTP_CONTENT_ENCODING':
self.get_content_encoding(),
}
self.request_factory = self.request_factory or RequestFactory()
request = self.request_factory.post(
'/api/store',
data=self.encode(kwargs),
content_type='application/octet-stream',
**headers)
StoreView.as_view()(
request,
project_id=six.text_type(settings.SENTRY_PROJECT),
)
def send(self, **kwargs):
# These imports all need to be internal to this function as this class
# is set up by django while still parsing LOGGING settings and we
# cannot import this stuff until settings are finalized.
from sentry.web.api import StoreView
from django.test import RequestFactory
# Report the issue to an upstream Sentry if active
# NOTE: we don't want to check self.is_enabled() like normal, since
# is_enabled behavior is overridden in this class. We explicitly
# want to check if the remote is active.
if self.remote.is_active():
from sentry import options
# Append some extra tags that are useful for remote reporting
super_kwargs = copy.deepcopy(kwargs)
super_kwargs['tags']['install-id'] = options.get('sentry:install-id')
super(SentryInternalClient, self).send(**super_kwargs)
if not is_current_event_safe():
self.error_logger.warn('internal-error.unsafe-stacktrace')
return
key = self.project_key
if key is None:
return
client_string = 'raven-python/{}'.format(raven.VERSION)
headers = {
'HTTP_X_SENTRY_AUTH': get_auth_header(
protocol=self.protocol_version,
timestamp=time(),
client=client_string,
api_key=key.public_key,
api_secret=key.secret_key,
),
'HTTP_CONTENT_ENCODING': self.get_content_encoding(),
}
self.request_factory = self.request_factory or RequestFactory()
request = self.request_factory.post(
'/api/{}/store/'.format(key.project_id),
data=self.encode(kwargs),
content_type='application/octet-stream',
**headers
)
resp = StoreView.as_view()(
request,
project_id=six.text_type(key.project_id),
)
if resp.status_code != 200:
self.error_logger.warn('internal-error.invalid-response', extra={
'project_id': settings.SENTRY_PROJECT,
'project_key': settings.SENTRY_PROJECT_KEY,
'status_code': resp.status_code,
})
def send(self, **kwargs):
# Report the issue to an upstream Sentry if active
# NOTE: we don't want to check self.is_enabled() like normal, since
# is_enabled behavior is overridden in this class. We explicitly
# want to check if the remote is active.
if self.remote.is_active():
from sentry import options
# Append some extra tags that are useful for remote reporting
super_kwargs = copy.deepcopy(kwargs)
super_kwargs['tags']['install-id'] = options.get('sentry:install-id')
super(SentryInternalClient, self).send(**super_kwargs)
if not is_current_event_safe():
return
# These imports all need to be internal to this function as this class
# is set up by django while still parsing LOGGING settings and we
# cannot import this stuff until settings are finalized.
from sentry.models import ProjectKey
from sentry.web.api import StoreView
from django.test import RequestFactory
key = None
if settings.SENTRY_PROJECT_KEY is not None:
key = ProjectKey.objects.filter(
id=settings.SENTRY_PROJECT_KEY,
project=settings.SENTRY_PROJECT).first()
if key is None:
key = ProjectKey.get_default(settings.SENTRY_PROJECT)
if key is None:
return
client_string = 'raven-python/%s' % (raven.VERSION,)
headers = {
'HTTP_X_SENTRY_AUTH': get_auth_header(
protocol=self.protocol_version,
timestamp=time.time(),
client=client_string,
api_key=key.public_key,
api_secret=key.secret_key,
),
'HTTP_CONTENT_ENCODING': self.get_content_encoding(),
}
self.request_factory = self.request_factory or RequestFactory()
request = self.request_factory.post(
'/api/store',
data=self.encode(kwargs),
content_type='application/octet-stream',
**headers
)
StoreView.as_view()(
request,
project_id=six.text_type(settings.SENTRY_PROJECT),
)
def test_no_secret_key(self):
dsn = 'https://[email protected]/1'
res = RemoteConfig.from_string(dsn)
assert res.project == '1'
assert res.base_url == 'https://sentry.local'
assert res.store_endpoint == 'https://sentry.local/api/1/store/'
assert res.public_key == 'foo'
assert res.secret_key is None
assert res.options == {}
assert res.is_active()
assert get_auth_header(protocol=7, timestamp=42,
client='raven-python/1.0',
api_key=res.public_key) == (
'Sentry sentry_timestamp=42, sentry_client=raven-python/1.0, '
'sentry_version=7, sentry_key=foo')
def test_no_secret_key(self):
dsn = 'https://[email protected]/1'
res = RemoteConfig.from_string(dsn)
assert res.project == '1'
assert res.base_url == 'https://sentry.local'
assert res.store_endpoint == 'https://sentry.local/api/1/store/'
assert res.public_key == 'foo'
assert res.secret_key is None
assert res.options == {}
assert get_auth_header(
protocol=7,
timestamp=42,
client='raven-python/1.0',
api_key=res.public_key) == (
'Sentry sentry_timestamp=42, sentry_client=raven-python/1.0, '
'sentry_version=7, sentry_key=foo')
def send(self, **data):
"""
Sends the message to the server.
If ``servers`` was passed into the constructor, this will serialize the data and pipe it to
each server using ``send_remote()``. Otherwise, this will communicate with ``sentry.models.GroupedMessage``
directly.
"""
message = base64.b64encode(json.dumps(data).encode('zlib'))
for url in self.servers:
timestamp = time.time()
signature = get_signature(message, timestamp, self.secret_key or self.key)
headers = {
'X-Sentry-Auth': get_auth_header(signature, timestamp, 'raven/%s' % (raven.VERSION,), self.public_key),
'Content-Type': 'application/octet-stream',
}
self.send_remote(url=url, data=message, headers=headers)
def send_encoded(self, message):
"""
Given an already serialized message, signs the message and passes the payload
off to ``send_remote`` for each server specified in the servers configuration.
"""
for url in self.servers:
timestamp = time.time()
signature = get_signature(message, timestamp, self.secret_key or self.key)
headers = {
'X-Sentry-Auth': get_auth_header(
protocol=self.protocol_version,
signature=signature,
timestamp=timestamp,
client='raven-python/%s' % (raven.VERSION,),
api_key=self.public_key
),
'Content-Type': 'application/octet-stream',
}
self.send_remote(url=url, data=message, headers=headers)
def send_encoded(self, message):
"""
Given an already serialized message, signs the message and passes the payload
off to ``send_remote`` for each server specified in the servers configuration.
"""
for url in self.servers:
timestamp = time.time()
signature = get_signature(message, timestamp, self.secret_key
or self.key)
headers = {
'X-Sentry-Auth':
get_auth_header(protocol=self.protocol_version,
signature=signature,
timestamp=timestamp,
client='raven-python/%s' % (raven.VERSION, ),
api_key=self.public_key),
'Content-Type':
'application/octet-stream',
}
self.send_remote(url=url, data=message, headers=headers)
def send(self, **kwargs):
"""
Sends the message to the server.
If ``servers`` was passed into the constructor, this will serialize the data and pipe it to
each server using ``send_remote()``. Otherwise, this will communicate with ``sentry.models.GroupedMessage``
directly.
"""
message = base64.b64encode(json.dumps(kwargs).encode("zlib"))
for url in self.servers:
timestamp = time.time()
signature = get_signature(self.key, message, timestamp)
headers = {
"Authorization": get_auth_header(
signature, timestamp, "%s/%s" % (self.__class__.__name__, raven.VERSION)
),
"Content-Type": "application/octet-stream",
}
try:
self.send_remote(url=url, data=message, headers=headers)
except urllib2.HTTPError, e:
body = e.read()
logger.error(
"Unable to reach Sentry log server: %s (url: %%s, body: %%s)" % (e,),
url,
body,
exc_info=True,
extra={"data": {"body": body, "remote_url": url}},
)
logger.log(kwargs.pop("level", None) or logging.ERROR, kwargs.pop("message", None))
except urllib2.URLError, e:
logger.error(
"Unable to reach Sentry log server: %s (url: %%s)" % (e,),
url,
exc_info=True,
extra={"data": {"remote_url": url}},
)
logger.log(kwargs.pop("level", None) or logging.ERROR, kwargs.pop("message", None))