def _create_noop_hub():
def transport(event):
with capture_internal_exceptions():
metrics.incr('internal.uncaptured.events', skip_internal=False)
sdk_logger.warn('internal-error.noop-hub')
return sentry_sdk.Hub(sentry_sdk.Client(transport=transport))
def init_sentry_client_from_config(raw_config: config.RawConfig,
**kwargs: Any) -> None:
"""Configure the Sentry client.
This expects one configuration option and can take many optional ones:
``sentry.dsn``
The DSN provided by Sentry. If blank, the reporter will discard events.
``sentry.environment`` (optional)
The environment your application is running in.
``sentry.sample_rate`` (optional)
Percentage of errors to report. (e.g. "37%")
``sentry.ignore_errors`` (optional)
A comma-delimited list of exception names, unqualified (e.g.
ServerTimeout) or fully qualified (e.g.
baseplate.observers.timeout.ServerTimeout) to not notify sentry about.
Note: a minimal list of common exceptions is hard-coded in Baseplate,
this option only extends that list.
Example usage::
init_sentry_client_from_config(app_config)
:param raw_config: The application configuration which should have
settings for the error reporter.
"""
cfg = config.parse_config(
raw_config,
{
"sentry": {
"dsn":
config.Optional(config.String, default=None),
"environment":
config.Optional(config.String, default=None),
"sample_rate":
config.Optional(config.Percent, default=1),
"ignore_errors":
config.Optional(config.TupleOf(config.String), default=()),
}
},
)
if cfg.sentry.dsn:
kwargs.setdefault("dsn", cfg.sentry.dsn)
if cfg.sentry.environment:
kwargs.setdefault("environment", cfg.sentry.environment)
kwargs.setdefault("sample_rate", cfg.sentry.sample_rate)
ignore_errors: List[Union[type, str]] = []
ignore_errors.extend(ALWAYS_IGNORE_ERRORS)
ignore_errors.extend(cfg.sentry.ignore_errors)
kwargs.setdefault("ignore_errors", ignore_errors)
kwargs.setdefault("with_locals", False)
client = sentry_sdk.Client(**kwargs)
sentry_sdk.Hub.current.bind_client(client)
def register(cfg: Optional['CliConfig'] = None):
global cli_config, client
if cfg is None:
from pros.config.cli_config import cli_config as get_cli_config
cli_config = get_cli_config()
else:
cli_config = cfg
assert cli_config is not None
if cli_config.offer_sentry is False:
return
import sentry_sdk as sentry
from pros.upgrade import get_platformv2
client = sentry.Client(
'https://[email protected]/1226033',
before_send=prompt_to_send,
release=ui.get_version()
)
sentry.Hub.current.bind_client(client)
with sentry.configure_scope() as scope:
scope.set_tag('platformv2', get_platformv2().name)
def _get_client(self, dsn):
client = self._clients_by_dsn.get(dsn)
if client is None:
if sentry_sdk is None:
logger.warning('sentry_sdk is not installed')
return None
client = sentry_sdk.Client(dsn)
self._clients_by_dsn[dsn] = client
return client
def get_exception_event():
event = {}
def transport(e):
nonlocal event
event = e
client = sentry_sdk.Client(transport=transport)
hub = sentry_sdk.Hub(client)
hub.capture_exception()
assert event
return event
def _sentry_client(
disabled: bool = False,
) -> sentry_sdk.Client:
"""
Initialize sentry. You can override the default values with the following env vars:
1. CORTEX_TELEMETRY_SENTRY_DSN
2. CORTEX_TELEMETRY_SENTRY_ENVIRONMENT
3. CORTEX_TELEMETRY_DISABLE
"""
dsn = CORTEX_TELEMETRY_SENTRY_DSN
environment = CORTEX_TELEMETRY_SENTRY_ENVIRONMENT
if disabled or os.getenv("CORTEX_TELEMETRY_DISABLE", "").lower() == "true":
return
if os.getenv("CORTEX_TELEMETRY_SENTRY_DSN", "") != "":
dsn = os.environ["CORTEX_TELEMETRY_SENTRY_DSN"]
if os.getenv("CORTEX_TELEMETRY_SENTRY_ENVIRONMENT", "") != "":
environment = os.environ["CORTEX_TELEMETRY_SENTRY_ENVIRONMENT"]
client = sentry_sdk.Client(
dsn=dsn,
environment=environment,
release=CORTEX_VERSION,
ignore_errors=[CortexBinaryException], # exclude CortexBinaryException exceptions
in_app_include=["cortex"], # for better grouping of events in sentry
attach_stacktrace=True,
default_integrations=False, # disable all default integrations
auto_enabling_integrations=False,
integrations=[
DedupeIntegration(), # prevent duplication of events
StdlibIntegration(), # adds breadcrumbs (aka more info)
ModulesIntegration(), # adds info about installed modules
],
# debug=True,
)
return client
def send_event(self, project_id, payload=None):
if payload is None:
payload = {"message": "Hello, World!"}
if isinstance(payload, dict):
client = sentry_sdk.Client(self.dsn, default_integrations=False)
client.capture_event(payload)
client.close()
elif isinstance(payload, bytes):
response = self.post(
"/api/%s/store/" % project_id,
data=payload,
headers={
"Content-Type":
"application/octet-stream",
"X-Sentry-Auth":
("Sentry sentry_version=5, sentry_timestamp=1535376240291, "
"sentry_client=raven-node/2.6.3, "
"sentry_key={}".format(self.dsn_public_key)),
},
)
response.raise_for_status()
else:
raise ValueError(f"Invalid type {type(payload)} for payload.")
def inner(*a, **kw):
hub = sentry_sdk.Hub.current
client = sentry_sdk.Client(*a, **kw)
client.options["_experiments"]["fast_serialize"] = fast_serialize
hub.bind_client(client)
monkeypatch_test_transport(sentry_sdk.Hub.current.client)
def inner(*a, **kw):
hub = sentry_sdk.Hub.current
client = sentry_sdk.Client(*a, **kw)
hub.bind_client(client)
monkeypatch_test_transport(sentry_sdk.Hub.current.client)
passed=passed,
messages=messages,
awaiting_input=awaiting_input,
output=output,
output_parts=output_parts,
birdseye_objects=birdseye_objects,
error=error,
)
# Check that JSON encoding works here
# because failures in the queue pickling are silent
json_pickler.dumps(result)
return result
# Import eagerly
sentry_sdk.Hub(sentry_sdk.Client(transport=lambda e: None))
def get_exception_event():
event = {}
def transport(e):
nonlocal event
event = e
client = sentry_sdk.Client(transport=transport)
hub = sentry_sdk.Hub(client)
hub.capture_exception()
assert event
return event
from types import ModuleType
from typing import Any, Callable, Dict, List, Optional
import sentry_sdk
import wrapt
from sentry_sdk.integrations import aws_lambda
from . import config
# https://docs.sentry.io/error-reporting/configuration/?platform=python#common-options
sentry_client = sentry_sdk.Hub(
sentry_sdk.Client(
dsn=
"https://[email protected]/5469393",
release=f"sentiment_flanders@{config.__version__}",
environment=config.get_workspace(),
traces_sample_rate=1.0,
# https://github.com/getsentry/sentry-python/issues/227
integrations=[aws_lambda.AwsLambdaIntegration()],
))
@wrapt.decorator
def log_function_with_sentry(wrapped: Callable[..., Any], instance: Any,
args: List[Any], kwargs: Dict[str, Any]) -> Any:
"""Attaches Sentry integrations to a function."""
with sentry_client:
try:
return wrapped(*args, **kwargs)
except Exception as e:
sentry_sdk.capture_exception(e)
def get_sentry_client(sentry_dsn):
return sentry_sdk.Client(sentry_dsn, release=__version__)