# type: () -> Optional[str]

try:

with open(os.path.devnull, "w+") as null:

# prevent command prompt windows from popping up on windows

startupinfo = None

if sys.platform == "win32" or sys.platform == "cygwin":

startupinfo = subprocess.STARTUPINFO()

startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW

revision = (

subprocess.Popen(

["git", "rev-parse", "HEAD"],

startupinfo=startupinfo,

stdout=subprocess.PIPE,

stderr=null,

stdin=null,

)

.communicate()[0]

.strip()

.decode("utf-8")

)

except (OSError, IOError, FileNotFoundError):

return None

# type: () -> Optional[str]

"""Try to guess a default release."""

release = os.environ.get("SENTRY_RELEASE")

if release:

return release

release = get_git_revision()

if release:

return release

for var in (

"HEROKU_SLUG_COMMIT",

"SOURCE_VERSION",

"CODEBUILD_RESOLVED_SOURCE_VERSION",

"CIRCLE_SHA1",

"GAE_DEPLOYMENT_ID",

):

release = os.environ.get(var)

if release:

return release

# type: (List[str]) -> str

"""Return the SDK name including the name of the used web framework."""

# Note: I can not use for example sentry_sdk.integrations.django.DjangoIntegration.identifier

# here because if django is not installed the integration is not accessible.

framework_integrations = [

"django",

"flask",

"fastapi",

"bottle",

"falcon",

"quart",

"sanic",

"starlette",

"chalice",

"serverless",

"pyramid",

"tornado",

"aiohttp",

"aws_lambda",

"gcp",

"beam",

"asgi",

"wsgi",

]

for integration in framework_integrations:

if integration in installed_integrations:

return "sentry.python.{}".format(integration)

__slots__ = ()

def __enter__(self):

# type: () -> ContextManager[Any]

return self

def __exit__(self, ty, value, tb):

# type: (Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]) -> bool

if ty is not None and value is not None:

capture_internal_exception((ty, value, tb))

# type: (ExcInfo) -> None

hub = _get_debug_hub()

if hub is not None:

# type: (Optional[ExcInfo]) -> Dict[str, Optional[ExcInfo]]

"""Creates a hint with the exc info filled in."""

if exc_info is None:

exc_info = sys.exc_info()

else:

exc_info = exc_info_from_error(exc_info)

if exc_info[0] is None:

exc_info = None

"""Represents a DSN."""

def __init__(self, value):

# type: (Union[Dsn, str]) -> None

if isinstance(value, Dsn):

self.__dict__ = dict(value.__dict__)

return

parts = urlparse.urlsplit(text_type(value))

if parts.scheme not in ("http", "https"):

raise BadDsn("Unsupported scheme %r" % parts.scheme)

self.scheme = parts.scheme

if parts.hostname is None:

raise BadDsn("Missing hostname")

self.host = parts.hostname

if parts.port is None:

self.port = self.scheme == "https" and 443 or 80 # type: int

else:

self.port = parts.port

if not parts.username:

raise BadDsn("Missing public key")

self.public_key = parts.username

self.secret_key = parts.password

path = parts.path.rsplit("/", 1)

try:

self.project_id = text_type(int(path.pop()))

except (ValueError, TypeError):

raise BadDsn("Invalid project in DSN (%r)" % (parts.path or "")[1:])

self.path = "/".join(path) + "/"

@property

def netloc(self):

# type: () -> str

"""The netloc part of a DSN."""

rv = self.host

if (self.scheme, self.port) not in (("http", 80), ("https", 443)):

rv = "%s:%s" % (rv, self.port)

return rv

def to_auth(self, client=None):

# type: (Optional[Any]) -> Auth

"""Returns the auth info object for this dsn."""

return Auth(

scheme=self.scheme,

host=self.netloc,

path=self.path,

project_id=self.project_id,

public_key=self.public_key,

secret_key=self.secret_key,

client=client,

)

def __str__(self):

# type: () -> str

return "%s://%s%s@%s%s%s" % (

self.scheme,

self.public_key,

self.secret_key and "@" + self.secret_key or "",

self.netloc,

self.path,

self.project_id,

"""Helper object that represents the auth info."""

def __init__(

self,

scheme,

host,

project_id,

public_key,

secret_key=None,

version=7,

client=None,

path="/",

):

# type: (str, str, str, str, Optional[str], int, Optional[Any], str) -> None

self.scheme = scheme

self.host = host

self.path = path

self.project_id = project_id

self.public_key = public_key

self.secret_key = secret_key

self.version = version

self.client = client

@property

def store_api_url(self):

# type: () -> str

"""Returns the API url for storing events.

Deprecated: use get_api_url instead.

"""

return self.get_api_url(type="store")

def get_api_url(

self, type="store" # type: EndpointType

):

# type: (...) -> str

"""Returns the API url for storing events."""

return "%s://%s%sapi/%s/%s/" % (

self.scheme,

self.host,

self.path,

self.project_id,

type,

)

def to_header(self):

# type: () -> str

"""Returns the auth header a string."""

rv = [("sentry_key", self.public_key), ("sentry_version", self.version)]

if self.client is not None:

rv.append(("sentry_client", self.client))

if self.secret_key is not None:

rv.append(("sentry_secret", self.secret_key))

"""

Meta information for a data field in the event payload.

This is to tell Relay that we have tampered with the fields value.

See:

https://github.com/getsentry/relay/blob/be12cd49a0f06ea932ed9b9f93a655de5d6ad6d1/relay-general/src/types/meta.rs#L407-L423

"""

__slots__ = ("value", "metadata")

def __init__(self, value, metadata):

# type: (Optional[Any], Dict[str, Any]) -> None

self.value = value

self.metadata = metadata

def __eq__(self, other):

# type: (Any) -> bool

if not isinstance(other, AnnotatedValue):

return False

return self.value == other.value and self.metadata == other.metadata

@classmethod

def removed_because_raw_data(cls):

# type: () -> AnnotatedValue

"""The value was removed because it could not be parsed. This is done for request body values that are not json nor a form."""

return AnnotatedValue(

value="",

metadata={

"rem": [ # Remark

[

"!raw", # Unparsable raw data

"x", # The fields original value was removed

]

]

},

)

@classmethod

def removed_because_over_size_limit(cls):

# type: () -> AnnotatedValue

"""The actual value was removed because the size of the field exceeded the configured maximum size (specified with the max_request_body_size sdk option)"""

return AnnotatedValue(

value="",

metadata={

"rem": [ # Remark

[

"!config", # Because of configured maximum size

"x", # The fields original value was removed

]

]

},

)

@classmethod

def substituted_because_contains_sensitive_data(cls):

# type: () -> AnnotatedValue

"""The actual value was removed because it contained sensitive information."""

return AnnotatedValue(

value=SENSITIVE_DATA_SUBSTITUTE,

metadata={

"rem": [ # Remark

[

"!config", # Because of SDK configuration (in this case the config is the hard coded removal of certain django cookies)

"s", # The fields original value was substituted

]

]

},

# type: (Optional[type]) -> Optional[str]

mod = getattr(cls, "__module__", None)

if mod not in (None, "builtins", "__builtins__"):

return mod

# type: (FrameType) -> bool

try:

mod = frame.f_globals["__name__"]

if mod.startswith("sentry_sdk."):

return True

except (AttributeError, KeyError):

pass

for flag_name in "__traceback_hide__", "__tracebackhide__":

try:

if frame.f_locals[flag_name]:

return True

except Exception:

pass

# type: (Optional[TracebackType]) -> Iterator[TracebackType]

tb_ = tb # type: Optional[TracebackType]

while tb_ is not None:

if not should_hide_frame(tb_.tb_frame):

yield tb_

filename, # type: str

lineno, # type: int

max_length=None, # type: Optional[int]

loader=None, # type: Optional[Any]

module=None, # type: Optional[str]

):

# type: (...) -> Tuple[List[Annotated[str]], Optional[Annotated[str]], List[Annotated[str]]]

context_lines = 5

source = None

if loader is not None and hasattr(loader, "get_source"):

try:

source_str = loader.get_source(module) # type: Optional[str]

except (ImportError, IOError):

source_str = None

if source_str is not None:

source = source_str.splitlines()

if source is None:

try:

source = linecache.getlines(filename)

except (OSError, IOError):

return [], None, []

if not source:

return [], None, []

lower_bound = max(0, lineno - context_lines)

upper_bound = min(lineno + 1 + context_lines, len(source))

try:

pre_context = [

strip_string(line.strip("\r\n"), max_length=max_length)

for line in source[lower_bound:lineno]

]

context_line = strip_string(source[lineno].strip("\r\n"), max_length=max_length)

post_context = [

strip_string(line.strip("\r\n"), max_length=max_length)

for line in source[(lineno + 1) : upper_bound]

]

return pre_context, context_line, post_context

except IndexError:

# the file may have changed since it was loaded into memory

frame, # type: FrameType

tb_lineno, # type: int

max_value_length=None, # type: Optional[int]

):

# type: (...) -> Tuple[List[Annotated[str]], Optional[Annotated[str]], List[Annotated[str]]]

try:

abs_path = frame.f_code.co_filename # type: Optional[str]

except Exception:

abs_path = None

try:

module = frame.f_globals["__name__"]

except Exception:

return [], None, []

try:

loader = frame.f_globals["__loader__"]

except Exception:

loader = None

lineno = tb_lineno - 1

if lineno is not None and abs_path:

return get_lines_from_file(

abs_path, lineno, max_value_length, loader=loader, module=module

)

# type: (Any) -> str

try:

return text_type(value)

except Exception:

# type: (Any) -> str

try:

rv = repr(value).decode("utf-8", "replace")

# At this point `rv` contains a bunch of literal escape codes, like

# this (exaggerated example):

#

# u"\\x2f"

#

# But we want to show this string as:

#

# u"/"

try:

# unicode-escape does this job, but can only decode latin1. So we

# attempt to encode in latin1.

return rv.encode("latin1").decode("unicode-escape")

except Exception:

# Since usually strings aren't latin1 this can break. In those

# cases we just give up.

return rv

except Exception:

# If e.g. the call to `repr` already fails

# type: (Any) -> str

try:

return repr(value)

except Exception:

# type: (Optional[str], Optional[str]) -> Optional[str]

if not abs_path or not module:

return abs_path

try:

if abs_path.endswith(".pyc"):

abs_path = abs_path[:-1]

base_module = module.split(".", 1)[0]

if base_module == module:

return os.path.basename(abs_path)

base_module_path = sys.modules[base_module].__file__

if not base_module_path:

return abs_path

return abs_path.split(base_module_path.rsplit(os.sep, 2)[0], 1)[-1].lstrip(

os.sep

)

except Exception:

frame,

tb_lineno=None,

include_local_variables=True,

include_source_context=True,

max_value_length=None,

):

# type: (FrameType, Optional[int], bool, bool, Optional[int]) -> Dict[str, Any]

f_code = getattr(frame, "f_code", None)

if not f_code:

abs_path = None

function = None

else:

abs_path = frame.f_code.co_filename

function = frame.f_code.co_name

try:

module = frame.f_globals["__name__"]

except Exception:

module = None

if tb_lineno is None:

tb_lineno = frame.f_lineno

rv = {

"filename": filename_for_module(module, abs_path) or None,

"abs_path": os.path.abspath(abs_path) if abs_path else None,

"function": function or "<unknown>",

"module": module,

"lineno": tb_lineno,

} # type: Dict[str, Any]

if include_source_context:

rv["pre_context"], rv["context_line"], rv["post_context"] = get_source_context(

frame, tb_lineno, max_value_length

)

if include_local_variables:

rv["vars"] = copy(frame.f_locals)

include_local_variables=True, # type: bool

include_source_context=True, # type: bool

max_value_length=None, # type: Optional[int]

):

# type: (...) -> Dict[str, Any]

__tracebackhide__ = True

frames = []

f = sys._getframe() # type: Optional[FrameType]

while f is not None:

if not should_hide_frame(f):

frames.append(

serialize_frame(

f,

include_local_variables=include_local_variables,

include_source_context=include_source_context,

max_value_length=max_value_length,

)

)

f = f.f_back

frames.reverse()

# type: (Optional[BaseException]) -> str

return (

getattr(exc_value, "message", "")

or getattr(exc_value, "detail", "")

or safe_str(exc_value)

exc_type, # type: Optional[type]

exc_value, # type: Optional[BaseException]

tb, # type: Optional[TracebackType]

client_options=None, # type: Optional[Dict[str, Any]]

mechanism=None, # type: Optional[Dict[str, Any]]

exception_id=None, # type: Optional[int]

parent_id=None, # type: Optional[int]

source=None, # type: Optional[str]

):

# type: (...) -> Dict[str, Any]

"""

Creates a dict that goes into the events `exception.values` list and is ingestible by Sentry.

See the Exception Interface documentation for more details:

https://develop.sentry.dev/sdk/event-payloads/exception/

"""

exception_value = {} # type: Dict[str, Any]

exception_value["mechanism"] = (

mechanism.copy() if mechanism else {"type": "generic", "handled": True}

)

if exception_id is not None:

exception_value["mechanism"]["exception_id"] = exception_id

if exc_value is not None:

errno = get_errno(exc_value)

else:

errno = None

if errno is not None:

exception_value["mechanism"].setdefault("meta", {}).setdefault(

"errno", {}

).setdefault("number", errno)

if source is not None:

exception_value["mechanism"]["source"] = source

is_root_exception = exception_id == 0

if not is_root_exception and parent_id is not None:

exception_value["mechanism"]["parent_id"] = parent_id

exception_value["mechanism"]["type"] = "chained"

if is_root_exception and "type" not in exception_value["mechanism"]:

exception_value["mechanism"]["type"] = "generic"

is_exception_group = BaseExceptionGroup is not None and isinstance(

exc_value, BaseExceptionGroup

)

if is_exception_group:

exception_value["mechanism"]["is_exception_group"] = True

exception_value["module"] = get_type_module(exc_type)

exception_value["type"] = get_type_name(exc_type)

exception_value["value"] = get_error_message(exc_value)

if client_options is None:

include_local_variables = True

include_source_context = True

max_value_length = DEFAULT_MAX_VALUE_LENGTH # fallback

else:

include_local_variables = client_options["include_local_variables"]

include_source_context = client_options["include_source_context"]

max_value_length = client_options["max_value_length"]

frames = [

serialize_frame(

tb.tb_frame,

tb_lineno=tb.tb_lineno,

include_local_variables=include_local_variables,

include_source_context=include_source_context,

max_value_length=max_value_length,

)

for tb in iter_stacks(tb)

]

if frames:

exception_value["stacktrace"] = {"frames": frames}

# type: (ExcInfo) -> Iterator[ExcInfo]

exc_type, exc_value, tb = exc_info

seen_exceptions = []

seen_exception_ids = set() # type: Set[int]

while (

exc_type is not None

and exc_value is not None

and id(exc_value) not in seen_exception_ids

):

yield exc_type, exc_value, tb

# Avoid hashing random types we don't know anything

# about. Use the list to keep a ref so that the `id` is

# not used for another object.

seen_exceptions.append(exc_value)

seen_exception_ids.add(id(exc_value))

if exc_value.__suppress_context__:

cause = exc_value.__cause__

else:

cause = exc_value.__context__

if cause is None:

break

exc_type = type(cause)

exc_value = cause

exc_type, # type: Optional[type]

exc_value, # type: Optional[BaseException]

tb, # type: Optional[TracebackType]

client_options=None, # type: Optional[Dict[str, Any]]

mechanism=None, # type: Optional[Dict[str, Any]]

exception_id=0, # type: int

parent_id=0, # type: int

source=None, # type: Optional[str]

):

# type: (...) -> Tuple[int, List[Dict[str, Any]]]

"""

Creates the list of exceptions.

This can include chained exceptions and exceptions from an ExceptionGroup.

See the Exception Interface documentation for more details:

https://develop.sentry.dev/sdk/event-payloads/exception/

"""

parent = single_exception_from_error_tuple(

exc_type=exc_type,

exc_value=exc_value,

tb=tb,

client_options=client_options,

mechanism=mechanism,

exception_id=exception_id,

parent_id=parent_id,

source=source,

)

exceptions = [parent]

parent_id = exception_id

exception_id += 1

should_supress_context = hasattr(exc_value, "__suppress_context__") and exc_value.__suppress_context__ # type: ignore

if should_supress_context:

# Add direct cause.

# The field `__cause__` is set when raised with the exception (using the `from` keyword).

exception_has_cause = (

exc_value

and hasattr(exc_value, "__cause__")

and exc_value.__cause__ is not None

)

if exception_has_cause:

cause = exc_value.__cause__ # type: ignore

(exception_id, child_exceptions) = exceptions_from_error(

exc_type=type(cause),

exc_value=cause,

tb=getattr(cause, "__traceback__", None),

client_options=client_options,

mechanism=mechanism,

exception_id=exception_id,

source="__cause__",

)

exceptions.extend(child_exceptions)

else:

# Add indirect cause.

# The field `__context__` is assigned if another exception occurs while handling the exception.

exception_has_content = (

exc_value

and hasattr(exc_value, "__context__")

and exc_value.__context__ is not None

)

if exception_has_content:

context = exc_value.__context__ # type: ignore

(exception_id, child_exceptions) = exceptions_from_error(

exc_type=type(context),

exc_value=context,

tb=getattr(context, "__traceback__", None),

client_options=client_options,

mechanism=mechanism,

exception_id=exception_id,

source="__context__",

)

exceptions.extend(child_exceptions)

# Add exceptions from an ExceptionGroup.

is_exception_group = exc_value and hasattr(exc_value, "exceptions")

if is_exception_group:

for idx, e in enumerate(exc_value.exceptions): # type: ignore

(exception_id, child_exceptions) = exceptions_from_error(

exc_type=type(e),

exc_value=e,

tb=getattr(e, "__traceback__", None),

client_options=client_options,

mechanism=mechanism,

exception_id=exception_id,

parent_id=parent_id,

source="exceptions[%s]" % idx,

)

exceptions.extend(child_exceptions)

exc_info, # type: ExcInfo

client_options=None, # type: Optional[Dict[str, Any]]

mechanism=None, # type: Optional[Dict[str, Any]]

):

# type: (...) -> List[Dict[str, Any]]

exc_type, exc_value, tb = exc_info

is_exception_group = BaseExceptionGroup is not None and isinstance(

exc_value, BaseExceptionGroup

)

if is_exception_group:

(_, exceptions) = exceptions_from_error(

exc_type=exc_type,

exc_value=exc_value,

tb=tb,

client_options=client_options,

mechanism=mechanism,

exception_id=0,

parent_id=0,

)

else:

exceptions = []

for exc_type, exc_value, tb in walk_exception_chain(exc_info):

exceptions.append(

single_exception_from_error_tuple(

exc_type, exc_value, tb, client_options, mechanism

)

)

exceptions.reverse()

# type: (str) -> str

try:

return text_type(value)

except UnicodeDecodeError:

# type: (Event) -> Iterator[Dict[str, Any]]

if "stacktrace" in event:

yield event["stacktrace"]

if "threads" in event:

for thread in event["threads"].get("values") or ():

if "stacktrace" in thread:

yield thread["stacktrace"]

if "exception" in event:

for exception in event["exception"].get("values") or ():

if "stacktrace" in exception:

# type: (Event) -> Iterator[Dict[str, Any]]

for stacktrace in iter_event_stacktraces(event):