diff --git a/.github/workflows/test-integrations-web-frameworks-2.yml b/.github/workflows/test-integrations-web-frameworks-2.yml
index 37d00f8fbf..c56451b751 100644
--- a/.github/workflows/test-integrations-web-frameworks-2.yml
+++ b/.github/workflows/test-integrations-web-frameworks-2.yml
@@ -59,6 +59,10 @@ jobs:
         run: |
           set -x # print commands that are executed
           ./scripts/runtox.sh "py${{ matrix.python-version }}-falcon-latest"
+      - name: Test litestar latest
+        run: |
+          set -x # print commands that are executed
+          ./scripts/runtox.sh "py${{ matrix.python-version }}-litestar-latest"
       - name: Test pyramid latest
         run: |
           set -x # print commands that are executed
@@ -137,6 +141,10 @@ jobs:
         run: |
           set -x # print commands that are executed
           ./scripts/runtox.sh --exclude-latest "py${{ matrix.python-version }}-falcon"
+      - name: Test litestar pinned
+        run: |
+          set -x # print commands that are executed
+          ./scripts/runtox.sh --exclude-latest "py${{ matrix.python-version }}-litestar"
       - name: Test pyramid pinned
         run: |
           set -x # print commands that are executed
diff --git a/scripts/split-tox-gh-actions/split-tox-gh-actions.py b/scripts/split-tox-gh-actions/split-tox-gh-actions.py
index d27ab1d45a..b9f978d850 100755
--- a/scripts/split-tox-gh-actions/split-tox-gh-actions.py
+++ b/scripts/split-tox-gh-actions/split-tox-gh-actions.py
@@ -115,6 +115,7 @@
         "asgi",
         "bottle",
         "falcon",
+        "litestar",
         "pyramid",
         "quart",
         "sanic",
diff --git a/sentry_sdk/consts.py b/sentry_sdk/consts.py
index 9e4484c398..d81b361461 100644
--- a/sentry_sdk/consts.py
+++ b/sentry_sdk/consts.py
@@ -432,6 +432,9 @@ class OP:
     HTTP_CLIENT_STREAM = "http.client.stream"
     HTTP_SERVER = "http.server"
     MIDDLEWARE_DJANGO = "middleware.django"
+    MIDDLEWARE_LITESTAR = "middleware.litestar"
+    MIDDLEWARE_LITESTAR_RECEIVE = "middleware.litestar.receive"
+    MIDDLEWARE_LITESTAR_SEND = "middleware.litestar.send"
     MIDDLEWARE_STARLETTE = "middleware.starlette"
     MIDDLEWARE_STARLETTE_RECEIVE = "middleware.starlette.receive"
     MIDDLEWARE_STARLETTE_SEND = "middleware.starlette.send"
diff --git a/sentry_sdk/integrations/litestar.py b/sentry_sdk/integrations/litestar.py
new file mode 100644
index 0000000000..8eb3b44ca4
--- /dev/null
+++ b/sentry_sdk/integrations/litestar.py
@@ -0,0 +1,284 @@
+import sentry_sdk
+from sentry_sdk._types import TYPE_CHECKING
+from sentry_sdk.consts import OP
+from sentry_sdk.integrations import DidNotEnable, Integration
+from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
+from sentry_sdk.integrations.logging import ignore_logger
+from sentry_sdk.scope import should_send_default_pii
+from sentry_sdk.tracing import SOURCE_FOR_STYLE, TRANSACTION_SOURCE_ROUTE
+from sentry_sdk.utils import (
+    ensure_integration_enabled,
+    event_from_exception,
+    transaction_from_function,
+)
+
+try:
+    from litestar import Request, Litestar  # type: ignore
+    from litestar.handlers.base import BaseRouteHandler  # type: ignore
+    from litestar.middleware import DefineMiddleware  # type: ignore
+    from litestar.routes.http import HTTPRoute  # type: ignore
+    from litestar.data_extractors import ConnectionDataExtractor  # type: ignore
+except ImportError:
+    raise DidNotEnable("Litestar is not installed")
+if TYPE_CHECKING:
+    from typing import Any, Optional, Union
+    from litestar.types.asgi_types import ASGIApp  # type: ignore
+    from litestar.types import (  # type: ignore
+        HTTPReceiveMessage,
+        HTTPScope,
+        Message,
+        Middleware,
+        Receive,
+        Scope as LitestarScope,
+        Send,
+        WebSocketReceiveMessage,
+    )
+    from litestar.middleware import MiddlewareProtocol
+    from sentry_sdk._types import Event, Hint
+
+_DEFAULT_TRANSACTION_NAME = "generic Litestar request"
+
+
+class LitestarIntegration(Integration):
+    identifier = "litestar"
+    origin = f"auto.http.{identifier}"
+
+    @staticmethod
+    def setup_once():
+        # type: () -> None
+        patch_app_init()
+        patch_middlewares()
+        patch_http_route_handle()
+
+        # The following line follows the pattern found in other integrations such as `DjangoIntegration.setup_once`.
+        # The Litestar `ExceptionHandlerMiddleware.__call__` catches exceptions and does the following
+        # (among other things):
+        #   1. Logs them, some at least (such as 500s) as errors
+        #   2. Calls after_exception hooks
+        # The `LitestarIntegration`` provides an after_exception hook (see `patch_app_init` below) to create a Sentry event
+        # from an exception, which ends up being called during step 2 above. However, the Sentry `LoggingIntegration` will
+        # by default create a Sentry event from error logs made in step 1 if we do not prevent it from doing so.
+        ignore_logger("litestar")
+
+
+class SentryLitestarASGIMiddleware(SentryAsgiMiddleware):
+    def __init__(self, app, span_origin=LitestarIntegration.origin):
+        # type: (ASGIApp, str) -> None
+
+        super().__init__(
+            app=app,
+            unsafe_context_data=False,
+            transaction_style="endpoint",
+            mechanism_type="asgi",
+            span_origin=span_origin,
+        )
+
+
+def patch_app_init():
+    # type: () -> None
+    """
+    Replaces the Litestar class's `__init__` function in order to inject `after_exception` handlers and set the
+    `SentryLitestarASGIMiddleware` as the outmost middleware in the stack.
+    See:
+    - https://docs.litestar.dev/2/usage/applications.html#after-exception
+    - https://docs.litestar.dev/2/usage/middleware/using-middleware.html
+    """
+    old__init__ = Litestar.__init__
+
+    @ensure_integration_enabled(LitestarIntegration, old__init__)
+    def injection_wrapper(self, *args, **kwargs):
+        # type: (Litestar, *Any, **Any) -> None
+        kwargs["after_exception"] = [
+            exception_handler,
+            *(kwargs.get("after_exception") or []),
+        ]
+
+        SentryLitestarASGIMiddleware.__call__ = SentryLitestarASGIMiddleware._run_asgi3  # type: ignore
+        middleware = kwargs.get("middleware") or []
+        kwargs["middleware"] = [SentryLitestarASGIMiddleware, *middleware]
+        old__init__(self, *args, **kwargs)
+
+    Litestar.__init__ = injection_wrapper
+
+
+def patch_middlewares():
+    # type: () -> None
+    old_resolve_middleware_stack = BaseRouteHandler.resolve_middleware
+
+    @ensure_integration_enabled(LitestarIntegration, old_resolve_middleware_stack)
+    def resolve_middleware_wrapper(self):
+        # type: (BaseRouteHandler) -> list[Middleware]
+        return [
+            enable_span_for_middleware(middleware)
+            for middleware in old_resolve_middleware_stack(self)
+        ]
+
+    BaseRouteHandler.resolve_middleware = resolve_middleware_wrapper
+
+
+def enable_span_for_middleware(middleware):
+    # type: (Middleware) -> Middleware
+    if (
+        not hasattr(middleware, "__call__")  # noqa: B004
+        or middleware is SentryLitestarASGIMiddleware
+    ):
+        return middleware
+
+    if isinstance(middleware, DefineMiddleware):
+        old_call = middleware.middleware.__call__  # type: ASGIApp
+    else:
+        old_call = middleware.__call__
+
+    async def _create_span_call(self, scope, receive, send):
+        # type: (MiddlewareProtocol, LitestarScope, Receive, Send) -> None
+        if sentry_sdk.get_client().get_integration(LitestarIntegration) is None:
+            return await old_call(self, scope, receive, send)
+
+        middleware_name = self.__class__.__name__
+        with sentry_sdk.start_span(
+            op=OP.MIDDLEWARE_LITESTAR,
+            description=middleware_name,
+            origin=LitestarIntegration.origin,
+        ) as middleware_span:
+            middleware_span.set_tag("litestar.middleware_name", middleware_name)
+
+            # Creating spans for the "receive" callback
+            async def _sentry_receive(*args, **kwargs):
+                # type: (*Any, **Any) -> Union[HTTPReceiveMessage, WebSocketReceiveMessage]
+                if sentry_sdk.get_client().get_integration(LitestarIntegration) is None:
+                    return await receive(*args, **kwargs)
+                with sentry_sdk.start_span(
+                    op=OP.MIDDLEWARE_LITESTAR_RECEIVE,
+                    description=getattr(receive, "__qualname__", str(receive)),
+                    origin=LitestarIntegration.origin,
+                ) as span:
+                    span.set_tag("litestar.middleware_name", middleware_name)
+                    return await receive(*args, **kwargs)
+
+            receive_name = getattr(receive, "__name__", str(receive))
+            receive_patched = receive_name == "_sentry_receive"
+            new_receive = _sentry_receive if not receive_patched else receive
+
+            # Creating spans for the "send" callback
+            async def _sentry_send(message):
+                # type: (Message) -> None
+                if sentry_sdk.get_client().get_integration(LitestarIntegration) is None:
+                    return await send(message)
+                with sentry_sdk.start_span(
+                    op=OP.MIDDLEWARE_LITESTAR_SEND,
+                    description=getattr(send, "__qualname__", str(send)),
+                    origin=LitestarIntegration.origin,
+                ) as span:
+                    span.set_tag("litestar.middleware_name", middleware_name)
+                    return await send(message)
+
+            send_name = getattr(send, "__name__", str(send))
+            send_patched = send_name == "_sentry_send"
+            new_send = _sentry_send if not send_patched else send
+
+            return await old_call(self, scope, new_receive, new_send)
+
+    not_yet_patched = old_call.__name__ not in ["_create_span_call"]
+
+    if not_yet_patched:
+        if isinstance(middleware, DefineMiddleware):
+            middleware.middleware.__call__ = _create_span_call
+        else:
+            middleware.__call__ = _create_span_call
+
+    return middleware
+
+
+def patch_http_route_handle():
+    # type: () -> None
+    old_handle = HTTPRoute.handle
+
+    async def handle_wrapper(self, scope, receive, send):
+        # type: (HTTPRoute, HTTPScope, Receive, Send) -> None
+        if sentry_sdk.get_client().get_integration(LitestarIntegration) is None:
+            return await old_handle(self, scope, receive, send)
+
+        sentry_scope = sentry_sdk.get_isolation_scope()
+        request = scope["app"].request_class(
+            scope=scope, receive=receive, send=send
+        )  # type: Request[Any, Any]
+        extracted_request_data = ConnectionDataExtractor(
+            parse_body=True, parse_query=True
+        )(request)
+        body = extracted_request_data.pop("body")
+
+        request_data = await body
+
+        def event_processor(event, _):
+            # type: (Event, Hint) -> Event
+            route_handler = scope.get("route_handler")
+
+            request_info = event.get("request", {})
+            request_info["content_length"] = len(scope.get("_body", b""))
+            if should_send_default_pii():
+                request_info["cookies"] = extracted_request_data["cookies"]
+            if request_data is not None:
+                request_info["data"] = request_data
+
+            func = None
+            if route_handler.name is not None:
+                tx_name = route_handler.name
+            # Accounts for use of type `Ref` in earlier versions of litestar without the need to reference it as a type
+            elif hasattr(route_handler.fn, "value"):
+                func = route_handler.fn.value
+            else:
+                func = route_handler.fn
+            if func is not None:
+                tx_name = transaction_from_function(func)
+
+            tx_info = {"source": SOURCE_FOR_STYLE["endpoint"]}
+
+            if not tx_name:
+                tx_name = _DEFAULT_TRANSACTION_NAME
+                tx_info = {"source": TRANSACTION_SOURCE_ROUTE}
+
+            event.update(
+                {
+                    "request": request_info,
+                    "transaction": tx_name,
+                    "transaction_info": tx_info,
+                }
+            )
+            return event
+
+        sentry_scope._name = LitestarIntegration.identifier
+        sentry_scope.add_event_processor(event_processor)
+
+        return await old_handle(self, scope, receive, send)
+
+    HTTPRoute.handle = handle_wrapper
+
+
+def retrieve_user_from_scope(scope):
+    # type: (LitestarScope) -> Optional[dict[str, Any]]
+    scope_user = scope.get("user")
+    if isinstance(scope_user, dict):
+        return scope_user
+    if hasattr(scope_user, "asdict"):  # dataclasses
+        return scope_user.asdict()
+
+    return None
+
+
+@ensure_integration_enabled(LitestarIntegration)
+def exception_handler(exc, scope):
+    # type: (Exception, LitestarScope) -> None
+    user_info = None  # type: Optional[dict[str, Any]]
+    if should_send_default_pii():
+        user_info = retrieve_user_from_scope(scope)
+    if user_info and isinstance(user_info, dict):
+        sentry_scope = sentry_sdk.get_isolation_scope()
+        sentry_scope.set_user(user_info)
+
+    event, hint = event_from_exception(
+        exc,
+        client_options=sentry_sdk.get_client().options,
+        mechanism={"type": LitestarIntegration.identifier, "handled": False},
+    )
+
+    sentry_sdk.capture_event(event, hint=hint)
diff --git a/setup.py b/setup.py
index fae4a1d0d8..35908b0068 100644
--- a/setup.py
+++ b/setup.py
@@ -63,6 +63,7 @@ def get_file_text(file_name):
         "huey": ["huey>=2"],
         "huggingface_hub": ["huggingface_hub>=0.22"],
         "langchain": ["langchain>=0.0.210"],
+        "litestar": ["litestar>=2.0.0"],
         "loguru": ["loguru>=0.5"],
         "openai": ["openai>=1.0.0", "tiktoken>=0.3.0"],
         "opentelemetry": ["opentelemetry-distro>=0.35b0"],
diff --git a/tests/integrations/litestar/__init__.py b/tests/integrations/litestar/__init__.py
new file mode 100644
index 0000000000..3a4a6235de
--- /dev/null
+++ b/tests/integrations/litestar/__init__.py
@@ -0,0 +1,3 @@
+import pytest
+
+pytest.importorskip("litestar")
diff --git a/tests/integrations/litestar/test_litestar.py b/tests/integrations/litestar/test_litestar.py
new file mode 100644
index 0000000000..90346537a7
--- /dev/null
+++ b/tests/integrations/litestar/test_litestar.py
@@ -0,0 +1,398 @@
+from __future__ import annotations
+import functools
+
+import pytest
+
+from sentry_sdk import capture_message
+from sentry_sdk.integrations.litestar import LitestarIntegration
+
+from typing import Any
+
+from litestar import Litestar, get, Controller
+from litestar.logging.config import LoggingConfig
+from litestar.middleware import AbstractMiddleware
+from litestar.middleware.logging import LoggingMiddlewareConfig
+from litestar.middleware.rate_limit import RateLimitConfig
+from litestar.middleware.session.server_side import ServerSideSessionConfig
+from litestar.testing import TestClient
+
+
+def litestar_app_factory(middleware=None, debug=True, exception_handlers=None):
+    class MyController(Controller):
+        path = "/controller"
+
+        @get("/error")
+        async def controller_error(self) -> None:
+            raise Exception("Whoa")
+
+    @get("/some_url")
+    async def homepage_handler() -> "dict[str, Any]":
+        1 / 0
+        return {"status": "ok"}
+
+    @get("/custom_error", name="custom_name")
+    async def custom_error() -> Any:
+        raise Exception("Too Hot")
+
+    @get("/message")
+    async def message() -> "dict[str, Any]":
+        capture_message("hi")
+        return {"status": "ok"}
+
+    @get("/message/{message_id:str}")
+    async def message_with_id() -> "dict[str, Any]":
+        capture_message("hi")
+        return {"status": "ok"}
+
+    logging_config = LoggingConfig()
+
+    app = Litestar(
+        route_handlers=[
+            homepage_handler,
+            custom_error,
+            message,
+            message_with_id,
+            MyController,
+        ],
+        debug=debug,
+        middleware=middleware,
+        logging_config=logging_config,
+        exception_handlers=exception_handlers,
+    )
+
+    return app
+
+
+@pytest.mark.parametrize(
+    "test_url,expected_error,expected_message,expected_tx_name",
+    [
+        (
+            "/some_url",
+            ZeroDivisionError,
+            "division by zero",
+            "tests.integrations.litestar.test_litestar.litestar_app_factory.<locals>.homepage_handler",
+        ),
+        (
+            "/custom_error",
+            Exception,
+            "Too Hot",
+            "custom_name",
+        ),
+        (
+            "/controller/error",
+            Exception,
+            "Whoa",
+            "tests.integrations.litestar.test_litestar.litestar_app_factory.<locals>.MyController.controller_error",
+        ),
+    ],
+)
+def test_catch_exceptions(
+    sentry_init,
+    capture_exceptions,
+    capture_events,
+    test_url,
+    expected_error,
+    expected_message,
+    expected_tx_name,
+):
+    sentry_init(integrations=[LitestarIntegration()])
+    litestar_app = litestar_app_factory()
+    exceptions = capture_exceptions()
+    events = capture_events()
+
+    client = TestClient(litestar_app)
+    try:
+        client.get(test_url)
+    except Exception:
+        pass
+
+    (exc,) = exceptions
+    assert isinstance(exc, expected_error)
+    assert str(exc) == expected_message
+
+    (event,) = events
+    assert expected_tx_name in event["transaction"]
+    assert event["exception"]["values"][0]["mechanism"]["type"] == "litestar"
+
+
+def test_middleware_spans(sentry_init, capture_events):
+    sentry_init(
+        traces_sample_rate=1.0,
+        integrations=[LitestarIntegration()],
+    )
+
+    logging_config = LoggingMiddlewareConfig()
+    session_config = ServerSideSessionConfig()
+    rate_limit_config = RateLimitConfig(rate_limit=("hour", 5))
+
+    litestar_app = litestar_app_factory(
+        middleware=[
+            session_config.middleware,
+            logging_config.middleware,
+            rate_limit_config.middleware,
+        ]
+    )
+    events = capture_events()
+
+    client = TestClient(
+        litestar_app, raise_server_exceptions=False, base_url="http://testserver.local"
+    )
+    client.get("/message")
+
+    (_, transaction_event) = events
+
+    expected = {"SessionMiddleware", "LoggingMiddleware", "RateLimitMiddleware"}
+    found = set()
+
+    litestar_spans = (
+        span
+        for span in transaction_event["spans"]
+        if span["op"] == "middleware.litestar"
+    )
+
+    for span in litestar_spans:
+        assert span["description"] in expected
+        assert span["description"] not in found
+        found.add(span["description"])
+        assert span["description"] == span["tags"]["litestar.middleware_name"]
+
+
+def test_middleware_callback_spans(sentry_init, capture_events):
+    class SampleMiddleware(AbstractMiddleware):
+        async def __call__(self, scope, receive, send) -> None:
+            async def do_stuff(message):
+                if message["type"] == "http.response.start":
+                    # do something here.
+                    pass
+                await send(message)
+
+            await self.app(scope, receive, do_stuff)
+
+    sentry_init(
+        traces_sample_rate=1.0,
+        integrations=[LitestarIntegration()],
+    )
+    litestar_app = litestar_app_factory(middleware=[SampleMiddleware])
+    events = capture_events()
+
+    client = TestClient(litestar_app, raise_server_exceptions=False)
+    client.get("/message")
+
+    (_, transaction_events) = events
+
+    expected_litestar_spans = [
+        {
+            "op": "middleware.litestar",
+            "description": "SampleMiddleware",
+            "tags": {"litestar.middleware_name": "SampleMiddleware"},
+        },
+        {
+            "op": "middleware.litestar.send",
+            "description": "SentryAsgiMiddleware._run_app.<locals>._sentry_wrapped_send",
+            "tags": {"litestar.middleware_name": "SampleMiddleware"},
+        },
+        {
+            "op": "middleware.litestar.send",
+            "description": "SentryAsgiMiddleware._run_app.<locals>._sentry_wrapped_send",
+            "tags": {"litestar.middleware_name": "SampleMiddleware"},
+        },
+    ]
+
+    def is_matching_span(expected_span, actual_span):
+        return (
+            expected_span["op"] == actual_span["op"]
+            and expected_span["description"] == actual_span["description"]
+            and expected_span["tags"] == actual_span["tags"]
+        )
+
+    actual_litestar_spans = list(
+        span
+        for span in transaction_events["spans"]
+        if "middleware.litestar" in span["op"]
+    )
+    assert len(actual_litestar_spans) == 3
+
+    for expected_span in expected_litestar_spans:
+        assert any(
+            is_matching_span(expected_span, actual_span)
+            for actual_span in actual_litestar_spans
+        )
+
+
+def test_middleware_receive_send(sentry_init, capture_events):
+    class SampleReceiveSendMiddleware(AbstractMiddleware):
+        async def __call__(self, scope, receive, send):
+            message = await receive()
+            assert message
+            assert message["type"] == "http.request"
+
+            send_output = await send({"type": "something-unimportant"})
+            assert send_output is None
+
+            await self.app(scope, receive, send)
+
+    sentry_init(
+        traces_sample_rate=1.0,
+        integrations=[LitestarIntegration()],
+    )
+    litestar_app = litestar_app_factory(middleware=[SampleReceiveSendMiddleware])
+
+    client = TestClient(litestar_app, raise_server_exceptions=False)
+    # See SampleReceiveSendMiddleware.__call__ above for assertions of correct behavior
+    client.get("/message")
+
+
+def test_middleware_partial_receive_send(sentry_init, capture_events):
+    class SamplePartialReceiveSendMiddleware(AbstractMiddleware):
+        async def __call__(self, scope, receive, send):
+            message = await receive()
+            assert message
+            assert message["type"] == "http.request"
+
+            send_output = await send({"type": "something-unimportant"})
+            assert send_output is None
+
+            async def my_receive(*args, **kwargs):
+                pass
+
+            async def my_send(*args, **kwargs):
+                pass
+
+            partial_receive = functools.partial(my_receive)
+            partial_send = functools.partial(my_send)
+
+            await self.app(scope, partial_receive, partial_send)
+
+    sentry_init(
+        traces_sample_rate=1.0,
+        integrations=[LitestarIntegration()],
+    )
+    litestar_app = litestar_app_factory(middleware=[SamplePartialReceiveSendMiddleware])
+    events = capture_events()
+
+    client = TestClient(litestar_app, raise_server_exceptions=False)
+    # See SamplePartialReceiveSendMiddleware.__call__ above for assertions of correct behavior
+    client.get("/message")
+
+    (_, transaction_events) = events
+
+    expected_litestar_spans = [
+        {
+            "op": "middleware.litestar",
+            "description": "SamplePartialReceiveSendMiddleware",
+            "tags": {"litestar.middleware_name": "SamplePartialReceiveSendMiddleware"},
+        },
+        {
+            "op": "middleware.litestar.receive",
+            "description": "TestClientTransport.create_receive.<locals>.receive",
+            "tags": {"litestar.middleware_name": "SamplePartialReceiveSendMiddleware"},
+        },
+        {
+            "op": "middleware.litestar.send",
+            "description": "SentryAsgiMiddleware._run_app.<locals>._sentry_wrapped_send",
+            "tags": {"litestar.middleware_name": "SamplePartialReceiveSendMiddleware"},
+        },
+    ]
+
+    def is_matching_span(expected_span, actual_span):
+        return (
+            expected_span["op"] == actual_span["op"]
+            and actual_span["description"].startswith(expected_span["description"])
+            and expected_span["tags"] == actual_span["tags"]
+        )
+
+    actual_litestar_spans = list(
+        span
+        for span in transaction_events["spans"]
+        if "middleware.litestar" in span["op"]
+    )
+    assert len(actual_litestar_spans) == 3
+
+    for expected_span in expected_litestar_spans:
+        assert any(
+            is_matching_span(expected_span, actual_span)
+            for actual_span in actual_litestar_spans
+        )
+
+
+def test_span_origin(sentry_init, capture_events):
+    sentry_init(
+        integrations=[LitestarIntegration()],
+        traces_sample_rate=1.0,
+    )
+
+    logging_config = LoggingMiddlewareConfig()
+    session_config = ServerSideSessionConfig()
+    rate_limit_config = RateLimitConfig(rate_limit=("hour", 5))
+
+    litestar_app = litestar_app_factory(
+        middleware=[
+            session_config.middleware,
+            logging_config.middleware,
+            rate_limit_config.middleware,
+        ]
+    )
+    events = capture_events()
+
+    client = TestClient(
+        litestar_app, raise_server_exceptions=False, base_url="http://testserver.local"
+    )
+    client.get("/message")
+
+    (_, event) = events
+
+    assert event["contexts"]["trace"]["origin"] == "auto.http.litestar"
+    for span in event["spans"]:
+        assert span["origin"] == "auto.http.litestar"
+
+
+@pytest.mark.parametrize(
+    "is_send_default_pii",
+    [
+        True,
+        False,
+    ],
+    ids=[
+        "send_default_pii=True",
+        "send_default_pii=False",
+    ],
+)
+def test_litestar_scope_user_on_exception_event(
+    sentry_init, capture_exceptions, capture_events, is_send_default_pii
+):
+    class TestUserMiddleware(AbstractMiddleware):
+        async def __call__(self, scope, receive, send):
+            scope["user"] = {
+                "email": "lennon@thebeatles.com",
+                "username": "john",
+                "id": "1",
+            }
+            await self.app(scope, receive, send)
+
+    sentry_init(
+        integrations=[LitestarIntegration()], send_default_pii=is_send_default_pii
+    )
+    litestar_app = litestar_app_factory(middleware=[TestUserMiddleware])
+    exceptions = capture_exceptions()
+    events = capture_events()
+
+    # This request intentionally raises an exception
+    client = TestClient(litestar_app)
+    try:
+        client.get("/some_url")
+    except Exception:
+        pass
+
+    assert len(exceptions) == 1
+    assert len(events) == 1
+    (event,) = events
+
+    if is_send_default_pii:
+        assert "user" in event
+        assert event["user"] == {
+            "email": "lennon@thebeatles.com",
+            "username": "john",
+            "id": "1",
+        }
+    else:
+        assert "user" not in event
diff --git a/tox.ini b/tox.ini
index 2b5ef6d8d2..f23a77465b 100644
--- a/tox.ini
+++ b/tox.ini
@@ -159,6 +159,14 @@ envlist =
     {py3.9,py3.11,py3.12}-langchain-latest
     {py3.9,py3.11,py3.12}-langchain-notiktoken
 
+    # Litestar
+    # litestar 2.0.0 is the earliest version that supports Python < 3.12
+    {py3.8,py3.11}-litestar-v{2.0}
+    # litestar 2.3.0 is the earliest version that supports Python 3.12
+    {py3.12}-litestar-v{2.3}
+    {py3.8,py3.11,py3.12}-litestar-v{2.5}
+    {py3.8,py3.11,py3.12}-litestar-latest
+
     # Loguru
     {py3.6,py3.11,py3.12}-loguru-v{0.5}
     {py3.6,py3.11,py3.12}-loguru-latest
@@ -489,6 +497,16 @@ deps =
     langchain-notiktoken: langchain-openai
     langchain-notiktoken: openai>=1.6.1
 
+    # Litestar
+    litestar: pytest-asyncio
+    litestar: python-multipart
+    litestar: requests
+    litestar: cryptography
+    litestar-v2.0: litestar~=2.0.0
+    litestar-v2.3: litestar~=2.3.0
+    litestar-v2.5: litestar~=2.5.0
+    litestar-latest: litestar
+
     # Loguru
     loguru-v0.5: loguru~=0.5.0
     loguru-latest: loguru
@@ -677,6 +695,7 @@ setenv =
     huey: TESTPATH=tests/integrations/huey
     huggingface_hub: TESTPATH=tests/integrations/huggingface_hub
     langchain: TESTPATH=tests/integrations/langchain
+    litestar: TESTPATH=tests/integrations/litestar
     loguru: TESTPATH=tests/integrations/loguru
     openai: TESTPATH=tests/integrations/openai
     opentelemetry: TESTPATH=tests/integrations/opentelemetry