diff --git a/MIGRATION_GUIDE.md b/MIGRATION_GUIDE.md
index df3ee6ea7d..c2e071a078 100644
--- a/MIGRATION_GUIDE.md
+++ b/MIGRATION_GUIDE.md
@@ -9,8 +9,20 @@ Looking to upgrade from Sentry SDK 2.x to 3.x? Here's a comprehensive list of wh
 
 ### Changed
 
+- The `Span()` constructor does not accept a `hub` parameter anymore.
+- `Span.finish()` does not accept a `hub` parameter anymore.
+- The `Profile()` constructor does not accept a `hub` parameter anymore.
+- A `Profile` object does not have a `.hub` property anymore.
+
 ### Removed
 
+- Class `Hub` has been removed.
+- Class `_ScopeManager` has been removed.
+- The context manager `auto_session_tracking()` has been removed. Use `track_session()` instead.
+- The context manager `auto_session_tracking_scope()` has been removed. Use `track_session()` instead.
+- Utility function `is_auto_session_tracking_enabled()` has been removed. There is no public replacement. There is a private `_is_auto_session_tracking_enabled()` (if you absolutely need this function) It accepts a `scope` parameter instead of the previously used `hub` parameter. 
+- Utility function `is_auto_session_tracking_enabled_scope()` has been removed. There is no public replacement. There is a private `_is_auto_session_tracking_enabled()` (if you absolutely need this function)
+
 ### Deprecated
 
 
diff --git a/docs/apidocs.rst b/docs/apidocs.rst
index a3c8a6e150..ffe265b276 100644
--- a/docs/apidocs.rst
+++ b/docs/apidocs.rst
@@ -2,9 +2,6 @@
 API Docs
 ========
 
-.. autoclass:: sentry_sdk.Hub
-    :members:
-
 .. autoclass:: sentry_sdk.Scope
     :members:
 
diff --git a/sentry_sdk/__init__.py b/sentry_sdk/__init__.py
index 8ff8dc703e..90cb01ec17 100644
--- a/sentry_sdk/__init__.py
+++ b/sentry_sdk/__init__.py
@@ -7,7 +7,6 @@
 from sentry_sdk.consts import VERSION  # noqa
 
 __all__ = [  # noqa
-    "Hub",
     "Scope",
     "Client",
     "Transport",
@@ -50,6 +49,3 @@
 
 init_debug_support()
 del init_debug_support
-
-# circular imports
-from sentry_sdk.hub import Hub
diff --git a/sentry_sdk/hub.py b/sentry_sdk/hub.py
deleted file mode 100644
index 1493c53992..0000000000
--- a/sentry_sdk/hub.py
+++ /dev/null
@@ -1,736 +0,0 @@
-import warnings
-
-# Importing sentry_sdk.consts here prevents a circular import, even though it's not used in this file.
-import sentry_sdk.consts  # noqa: F401
-
-from contextlib import contextmanager
-
-from sentry_sdk import (
-    get_client,
-    get_global_scope,
-    get_isolation_scope,
-    get_current_scope,
-)
-from sentry_sdk._compat import with_metaclass
-from sentry_sdk.scope import _ScopeManager
-from sentry_sdk.client import Client
-from sentry_sdk.tracing import (
-    NoOpSpan,
-    Span,
-    Transaction,
-)
-
-from sentry_sdk.utils import (
-    logger,
-    ContextVar,
-)
-
-from sentry_sdk._types import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from typing import Any
-    from typing import Callable
-    from typing import ContextManager
-    from typing import Dict
-    from typing import Generator
-    from typing import List
-    from typing import Optional
-    from typing import overload
-    from typing import Tuple
-    from typing import Type
-    from typing import TypeVar
-    from typing import Union
-
-    from typing_extensions import Unpack
-
-    from sentry_sdk.scope import Scope
-    from sentry_sdk.client import BaseClient
-    from sentry_sdk.integrations import Integration
-    from sentry_sdk._types import (
-        Event,
-        Hint,
-        Breadcrumb,
-        BreadcrumbHint,
-        ExcInfo,
-        LogLevelStr,
-        SamplingContext,
-    )
-    from sentry_sdk.tracing import TransactionKwargs
-
-    T = TypeVar("T")
-
-else:
-
-    def overload(x):
-        # type: (T) -> T
-        return x
-
-
-class SentryHubDeprecationWarning(DeprecationWarning):
-    """
-    A custom deprecation warning to inform users that the Hub is deprecated.
-    """
-
-    _MESSAGE = (
-        "`sentry_sdk.Hub` is deprecated and will be removed in a future major release. "
-        "Please consult our 1.x to 2.x migration guide for details on how to migrate "
-        "`Hub` usage to the new API: "
-        "https://docs.sentry.io/platforms/python/migration/1.x-to-2.x"
-    )
-
-    def __init__(self, *_):
-        # type: (*object) -> None
-        super().__init__(self._MESSAGE)
-
-
-@contextmanager
-def _suppress_hub_deprecation_warning():
-    # type: () -> Generator[None, None, None]
-    """Utility function to suppress deprecation warnings for the Hub."""
-    with warnings.catch_warnings():
-        warnings.filterwarnings("ignore", category=SentryHubDeprecationWarning)
-        yield
-
-
-_local = ContextVar("sentry_current_hub")
-
-
-class HubMeta(type):
-    @property
-    def current(cls):
-        # type: () -> Hub
-        """Returns the current instance of the hub."""
-        warnings.warn(SentryHubDeprecationWarning(), stacklevel=2)
-        rv = _local.get(None)
-        if rv is None:
-            with _suppress_hub_deprecation_warning():
-                # This will raise a deprecation warning; supress it since we already warned above.
-                rv = Hub(GLOBAL_HUB)
-            _local.set(rv)
-        return rv
-
-    @property
-    def main(cls):
-        # type: () -> Hub
-        """Returns the main instance of the hub."""
-        warnings.warn(SentryHubDeprecationWarning(), stacklevel=2)
-        return GLOBAL_HUB
-
-
-class Hub(with_metaclass(HubMeta)):  # type: ignore
-    """
-    .. deprecated:: 2.0.0
-        The Hub is deprecated. Its functionality will be merged into :py:class:`sentry_sdk.scope.Scope`.
-
-    The hub wraps the concurrency management of the SDK.  Each thread has
-    its own hub but the hub might transfer with the flow of execution if
-    context vars are available.
-
-    If the hub is used with a with statement it's temporarily activated.
-    """
-
-    _stack = None  # type: List[Tuple[Optional[Client], Scope]]
-    _scope = None  # type: Optional[Scope]
-
-    # Mypy doesn't pick up on the metaclass.
-
-    if TYPE_CHECKING:
-        current = None  # type: Hub
-        main = None  # type: Hub
-
-    def __init__(
-        self,
-        client_or_hub=None,  # type: Optional[Union[Hub, Client]]
-        scope=None,  # type: Optional[Any]
-    ):
-        # type: (...) -> None
-        warnings.warn(SentryHubDeprecationWarning(), stacklevel=2)
-
-        current_scope = None
-
-        if isinstance(client_or_hub, Hub):
-            client = get_client()
-            if scope is None:
-                # hub cloning is going on, we use a fork of the current/isolation scope for context manager
-                scope = get_isolation_scope().fork()
-                current_scope = get_current_scope().fork()
-        else:
-            client = client_or_hub  # type: ignore
-            get_global_scope().set_client(client)
-
-        if scope is None:  # so there is no Hub cloning going on
-            # just the current isolation scope is used for context manager
-            scope = get_isolation_scope()
-            current_scope = get_current_scope()
-
-        if current_scope is None:
-            # just the current current scope is used for context manager
-            current_scope = get_current_scope()
-
-        self._stack = [(client, scope)]  # type: ignore
-        self._last_event_id = None  # type: Optional[str]
-        self._old_hubs = []  # type: List[Hub]
-
-        self._old_current_scopes = []  # type: List[Scope]
-        self._old_isolation_scopes = []  # type: List[Scope]
-        self._current_scope = current_scope  # type: Scope
-        self._scope = scope  # type: Scope
-
-    def __enter__(self):
-        # type: () -> Hub
-        self._old_hubs.append(Hub.current)
-        _local.set(self)
-
-        current_scope = get_current_scope()
-        self._old_current_scopes.append(current_scope)
-        scope._current_scope.set(self._current_scope)
-
-        isolation_scope = get_isolation_scope()
-        self._old_isolation_scopes.append(isolation_scope)
-        scope._isolation_scope.set(self._scope)
-
-        return self
-
-    def __exit__(
-        self,
-        exc_type,  # type: Optional[type]
-        exc_value,  # type: Optional[BaseException]
-        tb,  # type: Optional[Any]
-    ):
-        # type: (...) -> None
-        old = self._old_hubs.pop()
-        _local.set(old)
-
-        old_current_scope = self._old_current_scopes.pop()
-        scope._current_scope.set(old_current_scope)
-
-        old_isolation_scope = self._old_isolation_scopes.pop()
-        scope._isolation_scope.set(old_isolation_scope)
-
-    def run(
-        self, callback  # type: Callable[[], T]
-    ):
-        # type: (...) -> T
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-
-        Runs a callback in the context of the hub.  Alternatively the
-        with statement can be used on the hub directly.
-        """
-        with self:
-            return callback()
-
-    def get_integration(
-        self, name_or_class  # type: Union[str, Type[Integration]]
-    ):
-        # type: (...) -> Any
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.client._Client.get_integration` instead.
-
-        Returns the integration for this hub by name or class.  If there
-        is no client bound or the client does not have that integration
-        then `None` is returned.
-
-        If the return value is not `None` the hub is guaranteed to have a
-        client attached.
-        """
-        return get_client().get_integration(name_or_class)
-
-    @property
-    def client(self):
-        # type: () -> Optional[BaseClient]
-        """
-        .. deprecated:: 2.0.0
-            This property is deprecated and will be removed in a future release.
-            Please use :py:func:`sentry_sdk.api.get_client` instead.
-
-        Returns the current client on the hub.
-        """
-        client = get_client()
-
-        if not client.is_active():
-            return None
-
-        return client
-
-    @property
-    def scope(self):
-        # type: () -> Scope
-        """
-        .. deprecated:: 2.0.0
-            This property is deprecated and will be removed in a future release.
-            Returns the current scope on the hub.
-        """
-        return get_isolation_scope()
-
-    def last_event_id(self):
-        # type: () -> Optional[str]
-        """
-        Returns the last event ID.
-
-        .. deprecated:: 1.40.5
-            This function is deprecated and will be removed in a future release. The functions `capture_event`, `capture_message`, and `capture_exception` return the event ID directly.
-        """
-        logger.warning(
-            "Deprecated: last_event_id is deprecated. This will be removed in the future. The functions `capture_event`, `capture_message`, and `capture_exception` return the event ID directly."
-        )
-        return self._last_event_id
-
-    def bind_client(
-        self, new  # type: Optional[BaseClient]
-    ):
-        # type: (...) -> None
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.set_client` instead.
-
-        Binds a new client to the hub.
-        """
-        get_global_scope().set_client(new)
-
-    def capture_event(self, event, hint=None, scope=None, **scope_kwargs):
-        # type: (Event, Optional[Hint], Optional[Scope], Any) -> Optional[str]
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.capture_event` instead.
-
-        Captures an event.
-
-        Alias of :py:meth:`sentry_sdk.Scope.capture_event`.
-
-        :param event: A ready-made event that can be directly sent to Sentry.
-
-        :param hint: Contains metadata about the event that can be read from `before_send`, such as the original exception object or a HTTP request object.
-
-        :param scope: An optional :py:class:`sentry_sdk.Scope` to apply to events.
-            The `scope` and `scope_kwargs` parameters are mutually exclusive.
-
-        :param scope_kwargs: Optional data to apply to event.
-            For supported `**scope_kwargs` see :py:meth:`sentry_sdk.Scope.update_from_kwargs`.
-            The `scope` and `scope_kwargs` parameters are mutually exclusive.
-        """
-        last_event_id = get_current_scope().capture_event(
-            event, hint, scope=scope, **scope_kwargs
-        )
-
-        is_transaction = event.get("type") == "transaction"
-        if last_event_id is not None and not is_transaction:
-            self._last_event_id = last_event_id
-
-        return last_event_id
-
-    def capture_message(self, message, level=None, scope=None, **scope_kwargs):
-        # type: (str, Optional[LogLevelStr], Optional[Scope], Any) -> Optional[str]
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.capture_message` instead.
-
-        Captures a message.
-
-        Alias of :py:meth:`sentry_sdk.Scope.capture_message`.
-
-        :param message: The string to send as the message to Sentry.
-
-        :param level: If no level is provided, the default level is `info`.
-
-        :param scope: An optional :py:class:`sentry_sdk.Scope` to apply to events.
-            The `scope` and `scope_kwargs` parameters are mutually exclusive.
-
-        :param scope_kwargs: Optional data to apply to event.
-            For supported `**scope_kwargs` see :py:meth:`sentry_sdk.Scope.update_from_kwargs`.
-            The `scope` and `scope_kwargs` parameters are mutually exclusive.
-
-        :returns: An `event_id` if the SDK decided to send the event (see :py:meth:`sentry_sdk.client._Client.capture_event`).
-        """
-        last_event_id = get_current_scope().capture_message(
-            message, level=level, scope=scope, **scope_kwargs
-        )
-
-        if last_event_id is not None:
-            self._last_event_id = last_event_id
-
-        return last_event_id
-
-    def capture_exception(self, error=None, scope=None, **scope_kwargs):
-        # type: (Optional[Union[BaseException, ExcInfo]], Optional[Scope], Any) -> Optional[str]
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.capture_exception` instead.
-
-        Captures an exception.
-
-        Alias of :py:meth:`sentry_sdk.Scope.capture_exception`.
-
-        :param error: An exception to capture. If `None`, `sys.exc_info()` will be used.
-
-        :param scope: An optional :py:class:`sentry_sdk.Scope` to apply to events.
-            The `scope` and `scope_kwargs` parameters are mutually exclusive.
-
-        :param scope_kwargs: Optional data to apply to event.
-            For supported `**scope_kwargs` see :py:meth:`sentry_sdk.Scope.update_from_kwargs`.
-            The `scope` and `scope_kwargs` parameters are mutually exclusive.
-
-        :returns: An `event_id` if the SDK decided to send the event (see :py:meth:`sentry_sdk.client._Client.capture_event`).
-        """
-        last_event_id = get_current_scope().capture_exception(
-            error, scope=scope, **scope_kwargs
-        )
-
-        if last_event_id is not None:
-            self._last_event_id = last_event_id
-
-        return last_event_id
-
-    def add_breadcrumb(self, crumb=None, hint=None, **kwargs):
-        # type: (Optional[Breadcrumb], Optional[BreadcrumbHint], Any) -> None
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.add_breadcrumb` instead.
-
-        Adds a breadcrumb.
-
-        :param crumb: Dictionary with the data as the sentry v7/v8 protocol expects.
-
-        :param hint: An optional value that can be used by `before_breadcrumb`
-            to customize the breadcrumbs that are emitted.
-        """
-        get_isolation_scope().add_breadcrumb(crumb, hint, **kwargs)
-
-    def start_span(self, **kwargs):
-        # type: (Any) -> Span
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.start_span` instead.
-
-        Start a span whose parent is the currently active span or transaction, if any.
-
-        The return value is a :py:class:`sentry_sdk.tracing.Span` instance,
-        typically used as a context manager to start and stop timing in a `with`
-        block.
-
-        Only spans contained in a transaction are sent to Sentry. Most
-        integrations start a transaction at the appropriate time, for example
-        for every incoming HTTP request. Use
-        :py:meth:`sentry_sdk.start_transaction` to start a new transaction when
-        one is not already in progress.
-
-        For supported `**kwargs` see :py:class:`sentry_sdk.tracing.Span`.
-        """
-        scope = get_current_scope()
-        return scope.start_span(**kwargs)
-
-    def start_transaction(
-        self, transaction=None, custom_sampling_context=None, **kwargs
-    ):
-        # type: (Optional[Transaction], Optional[SamplingContext], Unpack[TransactionKwargs]) -> Union[Transaction, NoOpSpan]
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.start_transaction` instead.
-
-        Start and return a transaction.
-
-        Start an existing transaction if given, otherwise create and start a new
-        transaction with kwargs.
-
-        This is the entry point to manual tracing instrumentation.
-
-        A tree structure can be built by adding child spans to the transaction,
-        and child spans to other spans. To start a new child span within the
-        transaction or any span, call the respective `.start_child()` method.
-
-        Every child span must be finished before the transaction is finished,
-        otherwise the unfinished spans are discarded.
-
-        When used as context managers, spans and transactions are automatically
-        finished at the end of the `with` block. If not using context managers,
-        call the `.finish()` method.
-
-        When the transaction is finished, it will be sent to Sentry with all its
-        finished child spans.
-
-        For supported `**kwargs` see :py:class:`sentry_sdk.tracing.Transaction`.
-        """
-        scope = get_current_scope()
-
-        # For backwards compatibility, we allow passing the scope as the hub.
-        # We need a major release to make this nice. (if someone searches the code: deprecated)
-        # Type checking disabled for this line because deprecated keys are not allowed in the type signature.
-        kwargs["hub"] = scope  # type: ignore
-
-        return scope.start_transaction(transaction, custom_sampling_context, **kwargs)
-
-    def continue_trace(self, environ_or_headers, op=None, name=None, source=None):
-        # type: (Dict[str, Any], Optional[str], Optional[str], Optional[str]) -> Transaction
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.continue_trace` instead.
-
-        Sets the propagation context from environment or headers and returns a transaction.
-        """
-        return get_isolation_scope().continue_trace(
-            environ_or_headers=environ_or_headers, op=op, name=name, source=source
-        )
-
-    @overload
-    def push_scope(
-        self, callback=None  # type: Optional[None]
-    ):
-        # type: (...) -> ContextManager[Scope]
-        pass
-
-    @overload
-    def push_scope(  # noqa: F811
-        self, callback  # type: Callable[[Scope], None]
-    ):
-        # type: (...) -> None
-        pass
-
-    def push_scope(  # noqa
-        self,
-        callback=None,  # type: Optional[Callable[[Scope], None]]
-        continue_trace=True,  # type: bool
-    ):
-        # type: (...) -> Optional[ContextManager[Scope]]
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-
-        Pushes a new layer on the scope stack.
-
-        :param callback: If provided, this method pushes a scope, calls
-            `callback`, and pops the scope again.
-
-        :returns: If no `callback` is provided, a context manager that should
-            be used to pop the scope again.
-        """
-        if callback is not None:
-            with self.push_scope() as scope:
-                callback(scope)
-            return None
-
-        return _ScopeManager(self)
-
-    def pop_scope_unsafe(self):
-        # type: () -> Tuple[Optional[Client], Scope]
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-
-        Pops a scope layer from the stack.
-
-        Try to use the context manager :py:meth:`push_scope` instead.
-        """
-        rv = self._stack.pop()
-        assert self._stack, "stack must have at least one layer"
-        return rv
-
-    @overload
-    def configure_scope(
-        self, callback=None  # type: Optional[None]
-    ):
-        # type: (...) -> ContextManager[Scope]
-        pass
-
-    @overload
-    def configure_scope(  # noqa: F811
-        self, callback  # type: Callable[[Scope], None]
-    ):
-        # type: (...) -> None
-        pass
-
-    def configure_scope(  # noqa
-        self,
-        callback=None,  # type: Optional[Callable[[Scope], None]]
-        continue_trace=True,  # type: bool
-    ):
-        # type: (...) -> Optional[ContextManager[Scope]]
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-
-        Reconfigures the scope.
-
-        :param callback: If provided, call the callback with the current scope.
-
-        :returns: If no callback is provided, returns a context manager that returns the scope.
-        """
-        scope = get_isolation_scope()
-
-        if continue_trace:
-            scope.generate_propagation_context()
-
-        if callback is not None:
-            # TODO: used to return None when client is None. Check if this changes behavior.
-            callback(scope)
-
-            return None
-
-        @contextmanager
-        def inner():
-            # type: () -> Generator[Scope, None, None]
-            yield scope
-
-        return inner()
-
-    def start_session(
-        self, session_mode="application"  # type: str
-    ):
-        # type: (...) -> None
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.start_session` instead.
-
-        Starts a new session.
-        """
-        get_isolation_scope().start_session(
-            session_mode=session_mode,
-        )
-
-    def end_session(self):
-        # type: (...) -> None
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.end_session` instead.
-
-        Ends the current session if there is one.
-        """
-        get_isolation_scope().end_session()
-
-    def stop_auto_session_tracking(self):
-        # type: (...) -> None
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.stop_auto_session_tracking` instead.
-
-        Stops automatic session tracking.
-
-        This temporarily session tracking for the current scope when called.
-        To resume session tracking call `resume_auto_session_tracking`.
-        """
-        get_isolation_scope().stop_auto_session_tracking()
-
-    def resume_auto_session_tracking(self):
-        # type: (...) -> None
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.resume_auto_session_tracking` instead.
-
-        Resumes automatic session tracking for the current scope if
-        disabled earlier.  This requires that generally automatic session
-        tracking is enabled.
-        """
-        get_isolation_scope().resume_auto_session_tracking()
-
-    def flush(
-        self,
-        timeout=None,  # type: Optional[float]
-        callback=None,  # type: Optional[Callable[[int, float], None]]
-    ):
-        # type: (...) -> None
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.client._Client.flush` instead.
-
-        Alias for :py:meth:`sentry_sdk.client._Client.flush`
-        """
-        return get_client().flush(timeout=timeout, callback=callback)
-
-    def get_traceparent(self):
-        # type: () -> Optional[str]
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.get_traceparent` instead.
-
-        Returns the traceparent either from the active span or from the scope.
-        """
-        current_scope = get_current_scope()
-        traceparent = current_scope.get_traceparent()
-
-        if traceparent is None:
-            isolation_scope = get_isolation_scope()
-            traceparent = isolation_scope.get_traceparent()
-
-        return traceparent
-
-    def get_baggage(self):
-        # type: () -> Optional[str]
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.get_baggage` instead.
-
-        Returns Baggage either from the active span or from the scope.
-        """
-        current_scope = get_current_scope()
-        baggage = current_scope.get_baggage()
-
-        if baggage is None:
-            isolation_scope = get_isolation_scope()
-            baggage = isolation_scope.get_baggage()
-
-        if baggage is not None:
-            return baggage.serialize()
-
-        return None
-
-    def iter_trace_propagation_headers(self, span=None):
-        # type: (Optional[Span]) -> Generator[Tuple[str, str], None, None]
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.iter_trace_propagation_headers` instead.
-
-        Return HTTP headers which allow propagation of trace data. Data taken
-        from the span representing the request, if available, or the current
-        span on the scope if not.
-        """
-        return get_current_scope().iter_trace_propagation_headers(
-            span=span,
-        )
-
-    def trace_propagation_meta(self, span=None):
-        # type: (Optional[Span]) -> str
-        """
-        .. deprecated:: 2.0.0
-            This function is deprecated and will be removed in a future release.
-            Please use :py:meth:`sentry_sdk.Scope.trace_propagation_meta` instead.
-
-        Return meta tags which should be injected into HTML templates
-        to allow propagation of trace information.
-        """
-        if span is not None:
-            logger.warning(
-                "The parameter `span` in trace_propagation_meta() is deprecated and will be removed in the future."
-            )
-
-        return get_current_scope().trace_propagation_meta(
-            span=span,
-        )
-
-
-with _suppress_hub_deprecation_warning():
-    # Suppress deprecation warning for the Hub here, since we still always
-    # import this module.
-    GLOBAL_HUB = Hub()
-_local.set(GLOBAL_HUB)
-
-
-# Circular imports
-from sentry_sdk import scope
diff --git a/sentry_sdk/integrations/sanic.py b/sentry_sdk/integrations/sanic.py
index 36e3b4c892..ee299215c9 100644
--- a/sentry_sdk/integrations/sanic.py
+++ b/sentry_sdk/integrations/sanic.py
@@ -218,7 +218,7 @@ async def _context_exit(request, response=None):
         response_status = None if response is None else response.status
 
         # This capture_internal_exceptions block has been intentionally nested here, so that in case an exception
-        # happens while trying to end the transaction, we still attempt to exit the hub.
+        # happens while trying to end the transaction, we still attempt to exit the scope.
         with capture_internal_exceptions():
             request.ctx._sentry_transaction.set_http_status(response_status)
             request.ctx._sentry_transaction.sampled &= (
diff --git a/sentry_sdk/profiler/transaction_profiler.py b/sentry_sdk/profiler/transaction_profiler.py
index 6ed983fb59..4ccad4f298 100644
--- a/sentry_sdk/profiler/transaction_profiler.py
+++ b/sentry_sdk/profiler/transaction_profiler.py
@@ -33,7 +33,6 @@
 import threading
 import time
 import uuid
-import warnings
 from abc import ABC, abstractmethod
 from collections import deque
 
@@ -209,7 +208,6 @@ def __init__(
         self,
         sampled,  # type: Optional[bool]
         start_ns,  # type: int
-        hub=None,  # type: Optional[sentry_sdk.Hub]
         scheduler=None,  # type: Optional[Scheduler]
     ):
         # type: (...) -> None
@@ -240,16 +238,6 @@ def __init__(
 
         self.unique_samples = 0
 
-        # Backwards compatibility with the old hub property
-        self._hub = None  # type: Optional[sentry_sdk.Hub]
-        if hub is not None:
-            self._hub = hub
-            warnings.warn(
-                "The `hub` parameter is deprecated. Please do not use it.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
     def update_active_thread_id(self):
         # type: () -> None
         self.active_thread_id = get_current_thread_meta()[0]
@@ -516,26 +504,6 @@ def valid(self):
 
         return True
 
-    @property
-    def hub(self):
-        # type: () -> Optional[sentry_sdk.Hub]
-        warnings.warn(
-            "The `hub` attribute is deprecated. Please do not access it.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self._hub
-
-    @hub.setter
-    def hub(self, value):
-        # type: (Optional[sentry_sdk.Hub]) -> None
-        warnings.warn(
-            "The `hub` attribute is deprecated. Please do not set it.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self._hub = value
-
 
 class Scheduler(ABC):
     mode = "unknown"  # type: ProfilerMode
diff --git a/sentry_sdk/scope.py b/sentry_sdk/scope.py
index 0c475d22b7..111c28dc7f 100644
--- a/sentry_sdk/scope.py
+++ b/sentry_sdk/scope.py
@@ -105,28 +105,6 @@ class ScopeType(Enum):
     MERGED = "merged"
 
 
-class _ScopeManager:
-    def __init__(self, hub=None):
-        # type: (Optional[Any]) -> None
-        self._old_scopes = []  # type: List[Scope]
-
-    def __enter__(self):
-        # type: () -> Scope
-        isolation_scope = Scope.get_isolation_scope()
-
-        self._old_scopes.append(isolation_scope)
-
-        forked_scope = isolation_scope.fork()
-        _isolation_scope.set(forked_scope)
-
-        return forked_scope
-
-    def __exit__(self, exc_type, exc_value, tb):
-        # type: (Any, Any, Any) -> None
-        old_scope = self._old_scopes.pop()
-        _isolation_scope.set(old_scope)
-
-
 def add_global_event_processor(processor):
     # type: (EventProcessor) -> None
     global_event_processors.append(processor)
diff --git a/sentry_sdk/sessions.py b/sentry_sdk/sessions.py
index 66bbdfd5ec..77e9051550 100644
--- a/sentry_sdk/sessions.py
+++ b/sentry_sdk/sessions.py
@@ -1,6 +1,5 @@
 import os
 import time
-import warnings
 from threading import Thread, Lock
 from contextlib import contextmanager
 
@@ -17,75 +16,6 @@
     from typing import Generator
     from typing import List
     from typing import Optional
-    from typing import Union
-
-
-def is_auto_session_tracking_enabled(hub=None):
-    # type: (Optional[sentry_sdk.Hub]) -> Union[Any, bool, None]
-    """DEPRECATED: Utility function to find out if session tracking is enabled."""
-
-    # Internal callers should use private _is_auto_session_tracking_enabled, instead.
-    warnings.warn(
-        "This function is deprecated and will be removed in the next major release. "
-        "There is no public API replacement.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-
-    if hub is None:
-        hub = sentry_sdk.Hub.current
-
-    should_track = hub.scope._force_auto_session_tracking
-
-    if should_track is None:
-        client_options = hub.client.options if hub.client else {}
-        should_track = client_options.get("auto_session_tracking", False)
-
-    return should_track
-
-
-@contextmanager
-def auto_session_tracking(hub=None, session_mode="application"):
-    # type: (Optional[sentry_sdk.Hub], str) -> Generator[None, None, None]
-    """DEPRECATED: Use track_session instead
-    Starts and stops a session automatically around a block.
-    """
-    warnings.warn(
-        "This function is deprecated and will be removed in the next major release. "
-        "Use track_session instead.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-
-    if hub is None:
-        hub = sentry_sdk.Hub.current
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", DeprecationWarning)
-        should_track = is_auto_session_tracking_enabled(hub)
-    if should_track:
-        hub.start_session(session_mode=session_mode)
-    try:
-        yield
-    finally:
-        if should_track:
-            hub.end_session()
-
-
-def is_auto_session_tracking_enabled_scope(scope):
-    # type: (sentry_sdk.Scope) -> bool
-    """
-    DEPRECATED: Utility function to find out if session tracking is enabled.
-    """
-
-    warnings.warn(
-        "This function is deprecated and will be removed in the next major release. "
-        "There is no public API replacement.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-
-    # Internal callers should use private _is_auto_session_tracking_enabled, instead.
-    return _is_auto_session_tracking_enabled(scope)
 
 
 def _is_auto_session_tracking_enabled(scope):
@@ -102,23 +32,6 @@ def _is_auto_session_tracking_enabled(scope):
     return should_track
 
 
-@contextmanager
-def auto_session_tracking_scope(scope, session_mode="application"):
-    # type: (sentry_sdk.Scope, str) -> Generator[None, None, None]
-    """DEPRECATED: This function is a deprecated alias for track_session.
-    Starts and stops a session automatically around a block.
-    """
-
-    warnings.warn(
-        "This function is a deprecated alias for track_session and will be removed in the next major release.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-
-    with track_session(scope, session_mode=session_mode):
-        yield
-
-
 @contextmanager
 def track_session(scope, session_mode="application"):
     # type: (sentry_sdk.Scope, str) -> Generator[None, None, None]
diff --git a/sentry_sdk/tracing.py b/sentry_sdk/tracing.py
index 484320ccbd..88ea7f55ff 100644
--- a/sentry_sdk/tracing.py
+++ b/sentry_sdk/tracing.py
@@ -1,6 +1,5 @@
 import uuid
 import random
-import warnings
 from datetime import datetime, timedelta, timezone
 
 import sentry_sdk
@@ -71,9 +70,6 @@ class SpanKwargs(TypedDict, total=False):
         description: str
         """A description of what operation is being performed within the span."""
 
-        hub: Optional["sentry_sdk.Hub"]
-        """The hub to use for this span. This argument is DEPRECATED. Please use the `scope` parameter, instead."""
-
         status: str
         """The span's status. Possible values are listed at https://develop.sentry.dev/sdk/event-payloads/span/"""
 
@@ -226,10 +222,6 @@ class Span:
     :param op: The span's operation. A list of recommended values is available here:
         https://develop.sentry.dev/sdk/performance/span-operations/
     :param description: A description of what operation is being performed within the span.
-    :param hub: The hub to use for this span.
-
-        .. deprecated:: 2.0.0
-            Please use the `scope` parameter, instead.
     :param status: The span's status. Possible values are listed at
         https://develop.sentry.dev/sdk/event-payloads/span/
     :param containing_transaction: The transaction that this span belongs to.
@@ -254,7 +246,6 @@ class Span:
         "_tags",
         "_data",
         "_span_recorder",
-        "hub",
         "_context_manager_state",
         "_containing_transaction",
         "_local_aggregator",
@@ -271,7 +262,6 @@ def __init__(
         sampled=None,  # type: Optional[bool]
         op=None,  # type: Optional[str]
         description=None,  # type: Optional[str]
-        hub=None,  # type: Optional[sentry_sdk.Hub]  # deprecated
         status=None,  # type: Optional[str]
         containing_transaction=None,  # type: Optional[Transaction]
         start_timestamp=None,  # type: Optional[Union[datetime, float]]
@@ -287,7 +277,6 @@ def __init__(
         self.op = op
         self.description = description
         self.status = status
-        self.hub = hub  # backwards compatibility
         self.scope = scope
         self.origin = origin
         self._measurements = {}  # type: Dict[str, MeasurementValue]
@@ -295,15 +284,6 @@ def __init__(
         self._data = {}  # type: Dict[str, Any]
         self._containing_transaction = containing_transaction
 
-        if hub is not None:
-            warnings.warn(
-                "The `hub` parameter is deprecated. Please use `scope` instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
-            self.scope = self.scope or hub.scope
-
         if start_timestamp is None:
             start_timestamp = datetime.now(timezone.utc)
         elif isinstance(start_timestamp, float):
@@ -831,45 +811,10 @@ def containing_transaction(self):
         # reference.
         return self
 
-    def _get_scope_from_finish_args(
-        self,
-        scope_arg,  # type: Optional[Union[sentry_sdk.Scope, sentry_sdk.Hub]]
-        hub_arg,  # type: Optional[Union[sentry_sdk.Scope, sentry_sdk.Hub]]
-    ):
-        # type: (...) -> Optional[sentry_sdk.Scope]
-        """
-        Logic to get the scope from the arguments passed to finish. This
-        function exists for backwards compatibility with the old finish.
-
-        TODO: Remove this function in the next major version.
-        """
-        scope_or_hub = scope_arg
-        if hub_arg is not None:
-            warnings.warn(
-                "The `hub` parameter is deprecated. Please use the `scope` parameter, instead.",
-                DeprecationWarning,
-                stacklevel=3,
-            )
-
-            scope_or_hub = hub_arg
-
-        if isinstance(scope_or_hub, sentry_sdk.Hub):
-            warnings.warn(
-                "Passing a Hub to finish is deprecated. Please pass a Scope, instead.",
-                DeprecationWarning,
-                stacklevel=3,
-            )
-
-            return scope_or_hub.scope
-
-        return scope_or_hub
-
     def finish(
         self,
         scope=None,  # type: Optional[sentry_sdk.Scope]
         end_timestamp=None,  # type: Optional[Union[float, datetime]]
-        *,
-        hub=None,  # type: Optional[sentry_sdk.Hub]
     ):
         # type: (...) -> Optional[str]
         """Finishes the transaction and sends it to Sentry.
@@ -879,9 +824,6 @@ def finish(
             If not provided, the current Scope will be used.
         :param end_timestamp: Optional timestamp that should
             be used as timestamp instead of the current time.
-        :param hub: The hub to use for this transaction.
-            This argument is DEPRECATED. Please use the `scope`
-            parameter, instead.
 
         :return: The event ID if the transaction was sent to Sentry,
             otherwise None.
@@ -890,12 +832,6 @@ def finish(
             # This transaction is already finished, ignore.
             return None
 
-        # For backwards compatibility, we must handle the case where `scope`
-        # or `hub` could both either be a `Scope` or a `Hub`.
-        scope = self._get_scope_from_finish_args(
-            scope, hub
-        )  # type: Optional[sentry_sdk.Scope]
-
         scope = scope or self.scope or sentry_sdk.get_current_scope()
         client = sentry_sdk.get_client()
 
@@ -1215,13 +1151,8 @@ def finish(
         self,
         scope=None,  # type: Optional[sentry_sdk.Scope]
         end_timestamp=None,  # type: Optional[Union[float, datetime]]
-        *,
-        hub=None,  # type: Optional[sentry_sdk.Hub]
     ):
         # type: (...) -> Optional[str]
-        """
-        The `hub` parameter is deprecated. Please use the `scope` parameter, instead.
-        """
         pass
 
     def set_measurement(self, name, value, unit=""):
diff --git a/sentry_sdk/utils.py b/sentry_sdk/utils.py
index d731fa2254..106b03cdce 100644
--- a/sentry_sdk/utils.py
+++ b/sentry_sdk/utils.py
@@ -52,7 +52,7 @@
         Union,
     )
 
-    from gevent.hub import Hub
+    from gevent.hub import Hub as GeventHub
 
     from sentry_sdk._types import Event, ExcInfo
 
@@ -1814,9 +1814,9 @@ def now():
 except ImportError:
 
     # it's not great that the signatures are different, get_hub can't return None
-    # consider adding an if TYPE_CHECKING to change the signature to Optional[Hub]
+    # consider adding an if TYPE_CHECKING to change the signature to Optional[GeventHub]
     def get_gevent_hub():  # type: ignore[misc]
-        # type: () -> Optional[Hub]
+        # type: () -> Optional[GeventHub]
         return None
 
     def is_module_patched(mod_name):
diff --git a/tests/integrations/conftest.py b/tests/integrations/conftest.py
index 560155e2b5..2dd25bab6f 100644
--- a/tests/integrations/conftest.py
+++ b/tests/integrations/conftest.py
@@ -6,19 +6,8 @@
 def capture_exceptions(monkeypatch):
     def inner():
         errors = set()
-        old_capture_event_hub = sentry_sdk.Hub.capture_event
         old_capture_event_scope = sentry_sdk.Scope.capture_event
 
-        def capture_event_hub(self, event, hint=None, scope=None):
-            """
-            Can be removed when we remove push_scope and the Hub from the SDK.
-            """
-            if hint:
-                if "exc_info" in hint:
-                    error = hint["exc_info"][1]
-                    errors.add(error)
-            return old_capture_event_hub(self, event, hint=hint, scope=scope)
-
         def capture_event_scope(self, event, hint=None, scope=None):
             if hint:
                 if "exc_info" in hint:
@@ -26,7 +15,6 @@ def capture_event_scope(self, event, hint=None, scope=None):
                     errors.add(error)
             return old_capture_event_scope(self, event, hint=hint, scope=scope)
 
-        monkeypatch.setattr(sentry_sdk.Hub, "capture_event", capture_event_hub)
         monkeypatch.setattr(sentry_sdk.Scope, "capture_event", capture_event_scope)
 
         return errors
diff --git a/tests/new_scopes_compat/__init__.py b/tests/new_scopes_compat/__init__.py
deleted file mode 100644
index 45391bd9ad..0000000000
--- a/tests/new_scopes_compat/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-"""
-Separate module for tests that check backwards compatibility of the Hub API with 1.x.
-These tests should be removed once we remove the Hub API, likely in the next major.
-
-All tests in this module are run with hub isolation, provided by `isolate_hub` autouse
-fixture, defined in `conftest.py`.
-"""
diff --git a/tests/new_scopes_compat/conftest.py b/tests/new_scopes_compat/conftest.py
deleted file mode 100644
index 9f16898dea..0000000000
--- a/tests/new_scopes_compat/conftest.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import pytest
-import sentry_sdk
-
-
-@pytest.fixture(autouse=True)
-def isolate_hub(suppress_deprecation_warnings):
-    with sentry_sdk.Hub(None):
-        yield
diff --git a/tests/new_scopes_compat/test_new_scopes_compat.py b/tests/new_scopes_compat/test_new_scopes_compat.py
deleted file mode 100644
index 1e109ec036..0000000000
--- a/tests/new_scopes_compat/test_new_scopes_compat.py
+++ /dev/null
@@ -1,217 +0,0 @@
-import sentry_sdk
-from sentry_sdk.hub import Hub
-
-"""
-Those tests are meant to check the compatibility of the new scopes in SDK 2.0 with the old Hub/Scope system in SDK 1.x.
-
-Those tests have been run with the latest SDK 1.x versiona and the data used in the `assert` statements represents
-the behvaior of the SDK 1.x.
-
-This makes sure that we are backwards compatible. (on a best effort basis, there will probably be some edge cases that are not covered here)
-"""
-
-
-def test_with_hub_sdk1(sentry_init, capture_events):
-    """
-    Mutate data in a `with Hub:` block
-
-    Checks the results of SDK 2.x against the results the same code returned in SDK 1.x.
-    """
-    sentry_init()
-
-    events = capture_events()
-
-    sentry_sdk.set_tag("A", 1)
-    sentry_sdk.capture_message("Event A")
-
-    with Hub.current as hub:  # with hub
-        sentry_sdk.set_tag("B1", 1)
-        hub.scope.set_tag("B2", 1)
-        sentry_sdk.capture_message("Event B")
-
-    sentry_sdk.set_tag("Z", 1)
-    sentry_sdk.capture_message("Event Z")
-
-    (event_a, event_b, event_z) = events
-
-    # Check against the results the same code returned in SDK 1.x
-    assert event_a["tags"] == {"A": 1}
-    assert event_b["tags"] == {"A": 1, "B1": 1, "B2": 1}
-    assert event_z["tags"] == {"A": 1, "B1": 1, "B2": 1, "Z": 1}
-
-
-def test_with_hub_configure_scope_sdk1(sentry_init, capture_events):
-    """
-    Mutate data in a `with Hub:` containing a `with configure_scope` block
-
-    Checks the results of SDK 2.x against the results the same code returned in SDK 1.x.
-    """
-    sentry_init()
-
-    events = capture_events()
-
-    sentry_sdk.set_tag("A", 1)
-    sentry_sdk.capture_message("Event A")
-
-    with Hub.current as hub:  # with hub
-        sentry_sdk.set_tag("B1", 1)
-        with hub.configure_scope() as scope:  # configure scope
-            sentry_sdk.set_tag("B2", 1)
-            hub.scope.set_tag("B3", 1)
-            scope.set_tag("B4", 1)
-            sentry_sdk.capture_message("Event B")
-        sentry_sdk.set_tag("B5", 1)
-        sentry_sdk.capture_message("Event C")
-
-    sentry_sdk.set_tag("Z", 1)
-    sentry_sdk.capture_message("Event Z")
-
-    (event_a, event_b, event_c, event_z) = events
-
-    # Check against the results the same code returned in SDK 1.x
-    assert event_a["tags"] == {"A": 1}
-    assert event_b["tags"] == {"A": 1, "B1": 1, "B2": 1, "B3": 1, "B4": 1}
-    assert event_c["tags"] == {"A": 1, "B1": 1, "B2": 1, "B3": 1, "B4": 1, "B5": 1}
-    assert event_z["tags"] == {
-        "A": 1,
-        "B1": 1,
-        "B2": 1,
-        "B3": 1,
-        "B4": 1,
-        "B5": 1,
-        "Z": 1,
-    }
-
-
-def test_with_hub_push_scope_sdk1(sentry_init, capture_events):
-    """
-    Mutate data in a `with Hub:` containing a `with push_scope` block
-
-    Checks the results of SDK 2.x against the results the same code returned in SDK 1.x.
-    """
-    sentry_init()
-
-    events = capture_events()
-
-    sentry_sdk.set_tag("A", 1)
-    sentry_sdk.capture_message("Event A")
-
-    with Hub.current as hub:  # with hub
-        sentry_sdk.set_tag("B1", 1)
-        with hub.push_scope() as scope:  # push scope
-            sentry_sdk.set_tag("B2", 1)
-            hub.scope.set_tag("B3", 1)
-            scope.set_tag("B4", 1)
-            sentry_sdk.capture_message("Event B")
-        sentry_sdk.set_tag("B5", 1)
-        sentry_sdk.capture_message("Event C")
-
-    sentry_sdk.set_tag("Z", 1)
-    sentry_sdk.capture_message("Event Z")
-
-    (event_a, event_b, event_c, event_z) = events
-
-    # Check against the results the same code returned in SDK 1.x
-    assert event_a["tags"] == {"A": 1}
-    assert event_b["tags"] == {"A": 1, "B1": 1, "B2": 1, "B3": 1, "B4": 1}
-    assert event_c["tags"] == {"A": 1, "B1": 1, "B5": 1}
-    assert event_z["tags"] == {"A": 1, "B1": 1, "B5": 1, "Z": 1}
-
-
-def test_with_cloned_hub_sdk1(sentry_init, capture_events):
-    """
-    Mutate data in a `with cloned Hub:` block
-
-    Checks the results of SDK 2.x against the results the same code returned in SDK 1.x.
-    """
-    sentry_init()
-
-    events = capture_events()
-
-    sentry_sdk.set_tag("A", 1)
-    sentry_sdk.capture_message("Event A")
-
-    with Hub(Hub.current) as hub:  # clone hub
-        sentry_sdk.set_tag("B1", 1)
-        hub.scope.set_tag("B2", 1)
-        sentry_sdk.capture_message("Event B")
-
-    sentry_sdk.set_tag("Z", 1)
-    sentry_sdk.capture_message("Event Z")
-
-    (event_a, event_b, event_z) = events
-
-    # Check against the results the same code returned in SDK 1.x
-    assert event_a["tags"] == {"A": 1}
-    assert event_b["tags"] == {"A": 1, "B1": 1, "B2": 1}
-    assert event_z["tags"] == {"A": 1, "Z": 1}
-
-
-def test_with_cloned_hub_configure_scope_sdk1(sentry_init, capture_events):
-    """
-    Mutate data in a `with cloned Hub:` containing a `with configure_scope` block
-
-    Checks the results of SDK 2.x against the results the same code returned in SDK 1.x.
-    """
-    sentry_init()
-
-    events = capture_events()
-
-    sentry_sdk.set_tag("A", 1)
-    sentry_sdk.capture_message("Event A")
-
-    with Hub(Hub.current) as hub:  # clone hub
-        sentry_sdk.set_tag("B1", 1)
-        with hub.configure_scope() as scope:  # configure scope
-            sentry_sdk.set_tag("B2", 1)
-            hub.scope.set_tag("B3", 1)
-            scope.set_tag("B4", 1)
-            sentry_sdk.capture_message("Event B")
-        sentry_sdk.set_tag("B5", 1)
-        sentry_sdk.capture_message("Event C")
-
-    sentry_sdk.set_tag("Z", 1)
-    sentry_sdk.capture_message("Event Z")
-
-    (event_a, event_b, event_c, event_z) = events
-
-    # Check against the results the same code returned in SDK 1.x
-    assert event_a["tags"] == {"A": 1}
-    assert event_b["tags"] == {"A": 1, "B1": 1, "B2": 1, "B3": 1, "B4": 1}
-    assert event_c["tags"] == {"A": 1, "B1": 1, "B2": 1, "B3": 1, "B4": 1, "B5": 1}
-    assert event_z["tags"] == {"A": 1, "Z": 1}
-
-
-def test_with_cloned_hub_push_scope_sdk1(sentry_init, capture_events):
-    """
-    Mutate data in a `with cloned Hub:` containing a `with push_scope` block
-
-    Checks the results of SDK 2.x against the results the same code returned in SDK 1.x.
-    """
-    sentry_init()
-
-    events = capture_events()
-
-    sentry_sdk.set_tag("A", 1)
-    sentry_sdk.capture_message("Event A")
-
-    with Hub(Hub.current) as hub:  # clone hub
-        sentry_sdk.set_tag("B1", 1)
-        with hub.push_scope() as scope:  # push scope
-            sentry_sdk.set_tag("B2", 1)
-            hub.scope.set_tag("B3", 1)
-            scope.set_tag("B4", 1)
-            sentry_sdk.capture_message("Event B")
-        sentry_sdk.set_tag("B5", 1)
-        sentry_sdk.capture_message("Event C")
-
-    sentry_sdk.set_tag("Z", 1)
-    sentry_sdk.capture_message("Event Z")
-
-    (event_a, event_b, event_c, event_z) = events
-
-    # Check against the results the same code returned in SDK 1.x
-    assert event_a["tags"] == {"A": 1}
-    assert event_b["tags"] == {"A": 1, "B1": 1, "B2": 1, "B3": 1, "B4": 1}
-    assert event_c["tags"] == {"A": 1, "B1": 1, "B5": 1}
-    assert event_z["tags"] == {"A": 1, "Z": 1}
diff --git a/tests/profiler/test_transaction_profiler.py b/tests/profiler/test_transaction_profiler.py
index 142fd7d78c..a77942e788 100644
--- a/tests/profiler/test_transaction_profiler.py
+++ b/tests/profiler/test_transaction_profiler.py
@@ -1,6 +1,5 @@
 import inspect
 import os
-import sentry_sdk
 import sys
 import threading
 import time
@@ -817,24 +816,6 @@ def test_profile_processing(
             assert processed["samples"] == expected["samples"]
 
 
-def test_hub_backwards_compatibility(suppress_deprecation_warnings):
-    hub = sentry_sdk.Hub()
-
-    with pytest.warns(DeprecationWarning):
-        profile = Profile(True, 0, hub=hub)
-
-    with pytest.warns(DeprecationWarning):
-        assert profile.hub is hub
-
-    new_hub = sentry_sdk.Hub()
-
-    with pytest.warns(DeprecationWarning):
-        profile.hub = new_hub
-
-    with pytest.warns(DeprecationWarning):
-        assert profile.hub is new_hub
-
-
 def test_no_warning_without_hub():
     with warnings.catch_warnings():
         warnings.simplefilter("error")
diff --git a/tests/test_basics.py b/tests/test_basics.py
index a98d00a774..9a24827d42 100644
--- a/tests/test_basics.py
+++ b/tests/test_basics.py
@@ -21,7 +21,6 @@
     add_breadcrumb,
     isolation_scope,
     new_scope,
-    Hub,
 )
 from sentry_sdk.integrations import (
     _AUTO_ENABLING_INTEGRATIONS,
@@ -800,21 +799,3 @@ def test_last_event_id_scope(sentry_init):
     # Should not crash
     with isolation_scope() as scope:
         assert scope.last_event_id() is None
-
-
-def test_hub_constructor_deprecation_warning():
-    with pytest.warns(sentry_sdk.hub.SentryHubDeprecationWarning):
-        Hub()
-
-
-def test_hub_current_deprecation_warning():
-    with pytest.warns(sentry_sdk.hub.SentryHubDeprecationWarning) as warning_records:
-        Hub.current
-
-    # Make sure we only issue one deprecation warning
-    assert len(warning_records) == 1
-
-
-def test_hub_main_deprecation_warnings():
-    with pytest.warns(sentry_sdk.hub.SentryHubDeprecationWarning):
-        Hub.main
diff --git a/tests/test_sessions.py b/tests/test_sessions.py
index 11f0314dda..bc9c598a83 100644
--- a/tests/test_sessions.py
+++ b/tests/test_sessions.py
@@ -1,7 +1,7 @@
 from unittest import mock
 
 import sentry_sdk
-from sentry_sdk.sessions import auto_session_tracking, track_session
+from sentry_sdk.sessions import track_session
 
 
 def sorted_aggregates(item):
@@ -83,52 +83,13 @@ def test_aggregates(sentry_init, capture_envelopes):
     assert aggregates[0]["errored"] == 1
 
 
-def test_aggregates_deprecated(
-    sentry_init, capture_envelopes, suppress_deprecation_warnings
-):
-    sentry_init(
-        release="fun-release",
-        environment="not-fun-env",
-    )
-    envelopes = capture_envelopes()
-
-    with auto_session_tracking(session_mode="request"):
-        with sentry_sdk.new_scope() as scope:
-            try:
-                scope.set_user({"id": "42"})
-                raise Exception("all is wrong")
-            except Exception:
-                sentry_sdk.capture_exception()
-
-    with auto_session_tracking(session_mode="request"):
-        pass
-
-    sentry_sdk.get_isolation_scope().start_session(session_mode="request")
-    sentry_sdk.get_isolation_scope().end_session()
-    sentry_sdk.flush()
-
-    assert len(envelopes) == 2
-    assert envelopes[0].get_event() is not None
-
-    sess = envelopes[1]
-    assert len(sess.items) == 1
-    sess_event = sess.items[0].payload.json
-    assert sess_event["attrs"] == {
-        "release": "fun-release",
-        "environment": "not-fun-env",
-    }
-
-    aggregates = sorted_aggregates(sess_event)
-    assert len(aggregates) == 1
-    assert aggregates[0]["exited"] == 2
-    assert aggregates[0]["errored"] == 1
-
-
 def test_aggregates_explicitly_disabled_session_tracking_request_mode(
     sentry_init, capture_envelopes
 ):
     sentry_init(
-        release="fun-release", environment="not-fun-env", auto_session_tracking=False
+        release="fun-release",
+        environment="not-fun-env",
+        auto_session_tracking=False,
     )
     envelopes = capture_envelopes()
 
@@ -157,38 +118,6 @@ def test_aggregates_explicitly_disabled_session_tracking_request_mode(
     assert "errored" not in aggregates[0]
 
 
-def test_aggregates_explicitly_disabled_session_tracking_request_mode_deprecated(
-    sentry_init, capture_envelopes, suppress_deprecation_warnings
-):
-    sentry_init(
-        release="fun-release", environment="not-fun-env", auto_session_tracking=False
-    )
-    envelopes = capture_envelopes()
-
-    with auto_session_tracking(session_mode="request"):
-        with sentry_sdk.new_scope():
-            try:
-                raise Exception("all is wrong")
-            except Exception:
-                sentry_sdk.capture_exception()
-
-    with auto_session_tracking(session_mode="request"):
-        pass
-
-    sentry_sdk.get_isolation_scope().start_session(session_mode="request")
-    sentry_sdk.get_isolation_scope().end_session()
-    sentry_sdk.flush()
-
-    sess = envelopes[1]
-    assert len(sess.items) == 1
-    sess_event = sess.items[0].payload.json
-
-    aggregates = sorted_aggregates(sess_event)
-    assert len(aggregates) == 1
-    assert aggregates[0]["exited"] == 1
-    assert "errored" not in aggregates[0]
-
-
 def test_no_thread_on_shutdown_no_errors(sentry_init):
     sentry_init(
         release="fun-release",
@@ -214,31 +143,3 @@ def test_no_thread_on_shutdown_no_errors(sentry_init):
         sentry_sdk.get_isolation_scope().start_session(session_mode="request")
         sentry_sdk.get_isolation_scope().end_session()
         sentry_sdk.flush()
-
-
-def test_no_thread_on_shutdown_no_errors_deprecated(
-    sentry_init, suppress_deprecation_warnings
-):
-    sentry_init(
-        release="fun-release",
-        environment="not-fun-env",
-    )
-
-    # make it seem like the interpreter is shutting down
-    with mock.patch(
-        "threading.Thread.start",
-        side_effect=RuntimeError("can't create new thread at interpreter shutdown"),
-    ):
-        with auto_session_tracking(session_mode="request"):
-            with sentry_sdk.new_scope():
-                try:
-                    raise Exception("all is wrong")
-                except Exception:
-                    sentry_sdk.capture_exception()
-
-        with auto_session_tracking(session_mode="request"):
-            pass
-
-        sentry_sdk.get_isolation_scope().start_session(session_mode="request")
-        sentry_sdk.get_isolation_scope().end_session()
-        sentry_sdk.flush()
diff --git a/tests/tracing/test_decorator.py b/tests/tracing/test_decorator.py
index 584268fbdd..c018d610a5 100644
--- a/tests/tracing/test_decorator.py
+++ b/tests/tracing/test_decorator.py
@@ -31,6 +31,7 @@ def test_trace_decorator():
         assert result2 == "return_of_sync_function"
 
 
+@pytest.mark.forked
 def test_trace_decorator_no_trx():
     with patch_start_tracing_child(fake_transaction_is_none=True):
         with mock.patch.object(logger, "debug", mock.Mock()) as fake_debug:
diff --git a/tests/tracing/test_deprecated.py b/tests/tracing/test_deprecated.py
deleted file mode 100644
index fb58e43ebf..0000000000
--- a/tests/tracing/test_deprecated.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import warnings
-
-import pytest
-
-import sentry_sdk
-import sentry_sdk.tracing
-from sentry_sdk import start_span
-
-from sentry_sdk.tracing import Span
-
-
-@pytest.mark.skip(reason="This deprecated feature has been removed in SDK 2.0.")
-def test_start_span_to_start_transaction(sentry_init, capture_events):
-    # XXX: this only exists for backwards compatibility with code before
-    # Transaction / start_transaction were introduced.
-    sentry_init(traces_sample_rate=1.0)
-    events = capture_events()
-
-    with start_span(transaction="/1/"):
-        pass
-
-    with start_span(Span(transaction="/2/")):
-        pass
-
-    assert len(events) == 2
-    assert events[0]["transaction"] == "/1/"
-    assert events[1]["transaction"] == "/2/"
-
-
-@pytest.mark.parametrize(
-    "parameter_value_getter",
-    # Use lambda to avoid Hub deprecation warning here (will suppress it in the test)
-    (lambda: sentry_sdk.Hub(), lambda: sentry_sdk.Scope()),
-)
-def test_passing_hub_parameter_to_transaction_finish(
-    suppress_deprecation_warnings, parameter_value_getter
-):
-    parameter_value = parameter_value_getter()
-    transaction = sentry_sdk.tracing.Transaction()
-    with pytest.warns(DeprecationWarning):
-        transaction.finish(hub=parameter_value)
-
-
-def test_passing_hub_object_to_scope_transaction_finish(suppress_deprecation_warnings):
-    transaction = sentry_sdk.tracing.Transaction()
-
-    # Do not move the following line under the `with` statement. Otherwise, the Hub.__init__ deprecation
-    # warning will be confused with the transaction.finish deprecation warning that we are testing.
-    hub = sentry_sdk.Hub()
-
-    with pytest.warns(DeprecationWarning):
-        transaction.finish(hub)
-
-
-def test_no_warnings_scope_to_transaction_finish():
-    transaction = sentry_sdk.tracing.Transaction()
-    with warnings.catch_warnings():
-        warnings.simplefilter("error")
-        transaction.finish(sentry_sdk.Scope())