code: def apply_to_event(self, event, hint=None):
          # type: (Dict[str, Any], Dict[str, Any]) -> Optional[Dict[str, Any]]
          
  
          def _drop(event, cause, ty):
              # type: (Dict[str, Any], Callable, str) -> Optional[Any]
              logger.info("%s (%s) dropped event (%s)", ty, cause, event)
              return None
  
          if self._level is not None:
              event["level"] = self._level
  
          event.setdefault("breadcrumbs", []).extend(self._breadcrumbs)
          if event.get("user") is None and self._user is not None:
              event["user"] = self._user
  
          if event.get("transaction") is None and self._transaction is not None:
              event["transaction"] = self._transaction
  
          if event.get("fingerprint") is None and self._fingerprint is not None:
              event["fingerprint"] = self._fingerprint
  
          if self._extras:
              event.setdefault("extra", {}).update(object_to_json(self._extras))
  
          if self._tags:
              event.setdefault("tags", {}).update(self._tags)
  
          if self._contexts:
              event.setdefault("contexts", {}).update(self._contexts)
  
          if self._span is not None:
              event.setdefault("contexts", {})["trace"] = {
                  "trace_id": self._span.trace_id,
                  "span_id": self._span.span_id,
              }
  
          exc_info = hint.get("exc_info") if hint is not None else None
          if exc_info is not None:
              for processor in self._error_processors:
                  new_event = processor(event, exc_info)
                  if new_event is None:
                      return _drop(event, processor, "error processor")
                  event = new_event
  
          for processor in chain(global_event_processors, self._event_processors):
              new_event = event
              with capture_internal_exceptions():
                  new_event = processor(event, hint)
              if new_event is None:
                  return _drop(event, processor, "event processor")
              event = new_event
  
          return event
docs: Applies the information contained on the scope to the given event.