diff --git a/client.py b/client.py
index 7b04b0eec..ad9874d80 100644
--- a/client.py
+++ b/client.py
@@ -18,14 +18,6 @@
 
 def main(playwright: Playwright) -> None:
     browser = playwright.chromium.launch(headless=False)
-    page = browser.new_page(viewport=0)
-    page.set_content(
-        "<button id=button onclick=\"window.open('http://webkit.org', '_blank')\">Click me</input>"
-    )
-
-    with page.expect_popup() as popup_info:
-        page.click("#button")
-    print(popup_info.value)
 
     print("Contexts in browser: %d" % len(browser.contexts))
     print("Creating context...")
diff --git a/playwright/_impl/_driver.py b/playwright/_impl/_driver.py
index 398ac058a..d11906e60 100644
--- a/playwright/_impl/_driver.py
+++ b/playwright/_impl/_driver.py
@@ -18,6 +18,7 @@
 from pathlib import Path
 
 import playwright
+from playwright._impl._logger import init_logger
 
 
 def compute_driver_executable() -> Path:
@@ -37,3 +38,5 @@ def compute_driver_executable() -> Path:
         # RuntimeError: Cannot add child handler, the child watcher does not have a loop attached
         asyncio.get_event_loop()
         asyncio.get_child_watcher()
+
+init_logger()
diff --git a/playwright/_impl/_logger.py b/playwright/_impl/_logger.py
new file mode 100644
index 000000000..b1e6e6ca9
--- /dev/null
+++ b/playwright/_impl/_logger.py
@@ -0,0 +1,32 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import sys
+
+debug_enabled = os.environ.get("PWDEBUG") or (
+    "DEBUG" in os.environ and "pw:api" in os.environ["DEBUG"]
+)
+
+
+def init_logger() -> None:
+    if os.environ.get("PWDEBUG"):
+        os.environ["DEBUG"] = (
+            os.environ["DEBUG"] + ",pw:api" if "DEBUG" in os.environ else "pw:api"
+        )
+
+
+def log_api(text: str) -> None:
+    if debug_enabled:
+        print(f"  \033[1m\033[96mpw:api\033[0m {text}", file=sys.stderr)
diff --git a/playwright/async_api/_generated.py b/playwright/async_api/_generated.py
index 640f27966..174f34dc8 100644
--- a/playwright/async_api/_generated.py
+++ b/playwright/async_api/_generated.py
@@ -51,6 +51,7 @@
 from playwright._impl._input import Mouse as MouseImpl
 from playwright._impl._input import Touchscreen as TouchscreenImpl
 from playwright._impl._js_handle import JSHandle as JSHandleImpl
+from playwright._impl._logger import log_api
 from playwright._impl._network import Request as RequestImpl
 from playwright._impl._network import Response as ResponseImpl
 from playwright._impl._network import Route as RouteImpl
@@ -247,7 +248,15 @@ async def response(self) -> typing.Union["Response", NoneType]:
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(await self._impl_obj.response())
+
+        try:
+            log_api("=> request.response started")
+            result = mapping.from_impl_nullable(await self._impl_obj.response())
+            log_api("<= request.response succeded")
+            return result
+        except Exception as e:
+            log_api("<= request.response failed")
+            raise e
 
 
 mapping.register(RequestImpl, Request)
@@ -350,7 +359,15 @@ async def finished(self) -> typing.Union[str, NoneType]:
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(await self._impl_obj.finished())
+
+        try:
+            log_api("=> response.finished started")
+            result = mapping.from_maybe_impl(await self._impl_obj.finished())
+            log_api("<= response.finished succeded")
+            return result
+        except Exception as e:
+            log_api("<= response.finished failed")
+            raise e
 
     async def body(self) -> bytes:
         """Response.body
@@ -361,7 +378,15 @@ async def body(self) -> bytes:
         -------
         bytes
         """
-        return mapping.from_maybe_impl(await self._impl_obj.body())
+
+        try:
+            log_api("=> response.body started")
+            result = mapping.from_maybe_impl(await self._impl_obj.body())
+            log_api("<= response.body succeded")
+            return result
+        except Exception as e:
+            log_api("<= response.body failed")
+            raise e
 
     async def text(self) -> str:
         """Response.text
@@ -372,7 +397,15 @@ async def text(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(await self._impl_obj.text())
+
+        try:
+            log_api("=> response.text started")
+            result = mapping.from_maybe_impl(await self._impl_obj.text())
+            log_api("<= response.text succeded")
+            return result
+        except Exception as e:
+            log_api("<= response.text failed")
+            raise e
 
     async def json(self) -> typing.Union[typing.Dict, typing.List]:
         """Response.json
@@ -384,7 +417,15 @@ async def json(self) -> typing.Union[typing.Dict, typing.List]:
         -------
         Union[Dict, List]
         """
-        return mapping.from_maybe_impl(await self._impl_obj.json())
+
+        try:
+            log_api("=> response.json started")
+            result = mapping.from_maybe_impl(await self._impl_obj.json())
+            log_api("<= response.json succeded")
+            return result
+        except Exception as e:
+            log_api("<= response.json failed")
+            raise e
 
 
 mapping.register(ResponseImpl, Response)
@@ -430,7 +471,17 @@ async def abort(self, error_code: str = None) -> NoneType:
              - `'timedout'` - An operation timed out.
              - `'failed'` - A generic failure occurred.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.abort(errorCode=error_code))
+
+        try:
+            log_api("=> route.abort started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.abort(errorCode=error_code)
+            )
+            log_api("<= route.abort succeded")
+            return result
+        except Exception as e:
+            log_api("<= route.abort failed")
+            raise e
 
     async def fulfill(
         self,
@@ -459,15 +510,23 @@ async def fulfill(
         content_type : Optional[str]
             If set, equals to setting `Content-Type` response header.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.fulfill(
-                status=status,
-                headers=mapping.to_impl(headers),
-                body=body,
-                path=path,
-                contentType=content_type,
+
+        try:
+            log_api("=> route.fulfill started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.fulfill(
+                    status=status,
+                    headers=mapping.to_impl(headers),
+                    body=body,
+                    path=path,
+                    contentType=content_type,
+                )
             )
-        )
+            log_api("<= route.fulfill succeded")
+            return result
+        except Exception as e:
+            log_api("<= route.fulfill failed")
+            raise e
 
     async def continue_(
         self,
@@ -491,14 +550,22 @@ async def continue_(
         post_data : Union[str, bytes, NoneType]
             If set changes the post data of request
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.continue_(
-                url=url,
-                method=method,
-                headers=mapping.to_impl(headers),
-                postData=post_data,
+
+        try:
+            log_api("=> route.continue_ started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.continue_(
+                    url=url,
+                    method=method,
+                    headers=mapping.to_impl(headers),
+                    postData=post_data,
+                )
             )
-        )
+            log_api("<= route.continue_ succeded")
+            return result
+        except Exception as e:
+            log_api("<= route.continue_ failed")
+            raise e
 
 
 mapping.register(RouteImpl, Route)
@@ -541,11 +608,21 @@ async def wait_for_event(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.waitForEvent(
-                event=event, predicate=self._wrap_handler(predicate), timeout=timeout
+
+        try:
+            log_api("=> web_socket.wait_for_event started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.waitForEvent(
+                    event=event,
+                    predicate=self._wrap_handler(predicate),
+                    timeout=timeout,
+                )
             )
-        )
+            log_api("<= web_socket.wait_for_event succeded")
+            return result
+        except Exception as e:
+            log_api("<= web_socket.wait_for_event failed")
+            raise e
 
     def expect_event(
         self,
@@ -585,7 +662,15 @@ def is_closed(self) -> bool:
         -------
         bool
         """
-        return mapping.from_maybe_impl(self._impl_obj.isClosed())
+
+        try:
+            log_api("=> web_socket.is_closed started")
+            result = mapping.from_maybe_impl(self._impl_obj.isClosed())
+            log_api("<= web_socket.is_closed succeded")
+            return result
+        except Exception as e:
+            log_api("<= web_socket.is_closed failed")
+            raise e
 
 
 mapping.register(WebSocketImpl, WebSocket)
@@ -621,7 +706,15 @@ async def down(self, key: str) -> NoneType:
         key : str
             Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.down(key=key))
+
+        try:
+            log_api("=> keyboard.down started")
+            result = mapping.from_maybe_impl(await self._impl_obj.down(key=key))
+            log_api("<= keyboard.down succeded")
+            return result
+        except Exception as e:
+            log_api("<= keyboard.down failed")
+            raise e
 
     async def up(self, key: str) -> NoneType:
         """Keyboard.up
@@ -633,7 +726,15 @@ async def up(self, key: str) -> NoneType:
         key : str
             Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.up(key=key))
+
+        try:
+            log_api("=> keyboard.up started")
+            result = mapping.from_maybe_impl(await self._impl_obj.up(key=key))
+            log_api("<= keyboard.up succeded")
+            return result
+        except Exception as e:
+            log_api("<= keyboard.up failed")
+            raise e
 
     async def insert_text(self, text: str) -> NoneType:
         """Keyboard.insert_text
@@ -647,7 +748,15 @@ async def insert_text(self, text: str) -> NoneType:
         text : str
             Sets input to the specified text value.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.insertText(text=text))
+
+        try:
+            log_api("=> keyboard.insert_text started")
+            result = mapping.from_maybe_impl(await self._impl_obj.insertText(text=text))
+            log_api("<= keyboard.insert_text succeded")
+            return result
+        except Exception as e:
+            log_api("<= keyboard.insert_text failed")
+            raise e
 
     async def type(self, text: str, delay: int = None) -> NoneType:
         """Keyboard.type
@@ -664,9 +773,17 @@ async def type(self, text: str, delay: int = None) -> NoneType:
         delay : Optional[int]
             Time to wait between key presses in milliseconds. Defaults to 0.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.type(text=text, delay=delay)
-        )
+
+        try:
+            log_api("=> keyboard.type started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.type(text=text, delay=delay)
+            )
+            log_api("<= keyboard.type succeded")
+            return result
+        except Exception as e:
+            log_api("<= keyboard.type failed")
+            raise e
 
     async def press(self, key: str, delay: int = None) -> NoneType:
         """Keyboard.press
@@ -691,7 +808,17 @@ async def press(self, key: str, delay: int = None) -> NoneType:
         delay : Optional[int]
             Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.press(key=key, delay=delay))
+
+        try:
+            log_api("=> keyboard.press started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.press(key=key, delay=delay)
+            )
+            log_api("<= keyboard.press succeded")
+            return result
+        except Exception as e:
+            log_api("<= keyboard.press failed")
+            raise e
 
 
 mapping.register(KeyboardImpl, Keyboard)
@@ -713,7 +840,17 @@ async def move(self, x: float, y: float, steps: int = None) -> NoneType:
         steps : Optional[int]
             defaults to 1. Sends intermediate `mousemove` events.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.move(x=x, y=y, steps=steps))
+
+        try:
+            log_api("=> mouse.move started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.move(x=x, y=y, steps=steps)
+            )
+            log_api("<= mouse.move succeded")
+            return result
+        except Exception as e:
+            log_api("<= mouse.move failed")
+            raise e
 
     async def down(
         self, button: Literal["left", "middle", "right"] = None, click_count: int = None
@@ -729,9 +866,17 @@ async def down(
         click_count : Optional[int]
             defaults to 1. See UIEvent.detail.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.down(button=button, clickCount=click_count)
-        )
+
+        try:
+            log_api("=> mouse.down started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.down(button=button, clickCount=click_count)
+            )
+            log_api("<= mouse.down succeded")
+            return result
+        except Exception as e:
+            log_api("<= mouse.down failed")
+            raise e
 
     async def up(
         self, button: Literal["left", "middle", "right"] = None, click_count: int = None
@@ -747,9 +892,17 @@ async def up(
         click_count : Optional[int]
             defaults to 1. See UIEvent.detail.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.up(button=button, clickCount=click_count)
-        )
+
+        try:
+            log_api("=> mouse.up started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.up(button=button, clickCount=click_count)
+            )
+            log_api("<= mouse.up succeded")
+            return result
+        except Exception as e:
+            log_api("<= mouse.up failed")
+            raise e
 
     async def click(
         self,
@@ -774,11 +927,19 @@ async def click(
         click_count : Optional[int]
             defaults to 1. See UIEvent.detail.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.click(
-                x=x, y=y, delay=delay, button=button, clickCount=click_count
+
+        try:
+            log_api("=> mouse.click started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.click(
+                    x=x, y=y, delay=delay, button=button, clickCount=click_count
+                )
             )
-        )
+            log_api("<= mouse.click succeded")
+            return result
+        except Exception as e:
+            log_api("<= mouse.click failed")
+            raise e
 
     async def dblclick(
         self,
@@ -800,9 +961,17 @@ async def dblclick(
         button : Optional[Literal['left', 'middle', 'right']]
             Defaults to `left`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.dblclick(x=x, y=y, delay=delay, button=button)
-        )
+
+        try:
+            log_api("=> mouse.dblclick started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.dblclick(x=x, y=y, delay=delay, button=button)
+            )
+            log_api("<= mouse.dblclick succeded")
+            return result
+        except Exception as e:
+            log_api("<= mouse.dblclick failed")
+            raise e
 
 
 mapping.register(MouseImpl, Mouse)
@@ -822,7 +991,15 @@ async def tap(self, x: float, y: float) -> NoneType:
         x : float
         y : float
         """
-        return mapping.from_maybe_impl(await self._impl_obj.tap(x=x, y=y))
+
+        try:
+            log_api("=> touchscreen.tap started")
+            result = mapping.from_maybe_impl(await self._impl_obj.tap(x=x, y=y))
+            log_api("<= touchscreen.tap succeded")
+            return result
+        except Exception as e:
+            log_api("<= touchscreen.tap failed")
+            raise e
 
 
 mapping.register(TouchscreenImpl, Touchscreen)
@@ -856,11 +1033,21 @@ async def evaluate(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.evaluate(
-                expression=expression, arg=mapping.to_impl(arg), force_expr=force_expr
+
+        try:
+            log_api("=> js_handle.evaluate started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.evaluate(
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                )
             )
-        )
+            log_api("<= js_handle.evaluate succeded")
+            return result
+        except Exception as e:
+            log_api("<= js_handle.evaluate failed")
+            raise e
 
     async def evaluate_handle(
         self, expression: str, arg: typing.Any = None, force_expr: bool = None
@@ -888,11 +1075,21 @@ async def evaluate_handle(
         -------
         JSHandle
         """
-        return mapping.from_impl(
-            await self._impl_obj.evaluateHandle(
-                expression=expression, arg=mapping.to_impl(arg), force_expr=force_expr
+
+        try:
+            log_api("=> js_handle.evaluate_handle started")
+            result = mapping.from_impl(
+                await self._impl_obj.evaluateHandle(
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                )
             )
-        )
+            log_api("<= js_handle.evaluate_handle succeded")
+            return result
+        except Exception as e:
+            log_api("<= js_handle.evaluate_handle failed")
+            raise e
 
     async def get_property(self, property_name: str) -> "JSHandle":
         """JSHandle.get_property
@@ -908,9 +1105,17 @@ async def get_property(self, property_name: str) -> "JSHandle":
         -------
         JSHandle
         """
-        return mapping.from_impl(
-            await self._impl_obj.getProperty(propertyName=property_name)
-        )
+
+        try:
+            log_api("=> js_handle.get_property started")
+            result = mapping.from_impl(
+                await self._impl_obj.getProperty(propertyName=property_name)
+            )
+            log_api("<= js_handle.get_property succeded")
+            return result
+        except Exception as e:
+            log_api("<= js_handle.get_property failed")
+            raise e
 
     async def get_properties(self) -> typing.Dict[str, "JSHandle"]:
         """JSHandle.get_properties
@@ -921,7 +1126,15 @@ async def get_properties(self) -> typing.Dict[str, "JSHandle"]:
         -------
         Dict[str, JSHandle]
         """
-        return mapping.from_impl_dict(await self._impl_obj.getProperties())
+
+        try:
+            log_api("=> js_handle.get_properties started")
+            result = mapping.from_impl_dict(await self._impl_obj.getProperties())
+            log_api("<= js_handle.get_properties succeded")
+            return result
+        except Exception as e:
+            log_api("<= js_handle.get_properties failed")
+            raise e
 
     def as_element(self) -> typing.Union["ElementHandle", NoneType]:
         """JSHandle.as_element
@@ -932,14 +1145,30 @@ def as_element(self) -> typing.Union["ElementHandle", NoneType]:
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(self._impl_obj.asElement())
+
+        try:
+            log_api("=> js_handle.as_element started")
+            result = mapping.from_impl_nullable(self._impl_obj.asElement())
+            log_api("<= js_handle.as_element succeded")
+            return result
+        except Exception as e:
+            log_api("<= js_handle.as_element failed")
+            raise e
 
     async def dispose(self) -> NoneType:
         """JSHandle.dispose
 
         The `jsHandle.dispose` method stops referencing the element handle.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.dispose())
+
+        try:
+            log_api("=> js_handle.dispose started")
+            result = mapping.from_maybe_impl(await self._impl_obj.dispose())
+            log_api("<= js_handle.dispose succeded")
+            return result
+        except Exception as e:
+            log_api("<= js_handle.dispose failed")
+            raise e
 
     async def json_value(self) -> typing.Any:
         """JSHandle.json_value
@@ -955,7 +1184,15 @@ async def json_value(self) -> typing.Any:
         -------
         Any
         """
-        return mapping.from_maybe_impl(await self._impl_obj.jsonValue())
+
+        try:
+            log_api("=> js_handle.json_value started")
+            result = mapping.from_maybe_impl(await self._impl_obj.jsonValue())
+            log_api("<= js_handle.json_value succeded")
+            return result
+        except Exception as e:
+            log_api("<= js_handle.json_value failed")
+            raise e
 
 
 mapping.register(JSHandleImpl, JSHandle)
@@ -972,7 +1209,15 @@ def to_string(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(self._impl_obj.toString())
+
+        try:
+            log_api("=> element_handle.to_string started")
+            result = mapping.from_maybe_impl(self._impl_obj.toString())
+            log_api("<= element_handle.to_string succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.to_string failed")
+            raise e
 
     def as_element(self) -> typing.Union["ElementHandle", NoneType]:
         """ElementHandle.as_element
@@ -983,7 +1228,15 @@ def as_element(self) -> typing.Union["ElementHandle", NoneType]:
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(self._impl_obj.asElement())
+
+        try:
+            log_api("=> element_handle.as_element started")
+            result = mapping.from_impl_nullable(self._impl_obj.asElement())
+            log_api("<= element_handle.as_element succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.as_element failed")
+            raise e
 
     async def owner_frame(self) -> typing.Union["Frame", NoneType]:
         """ElementHandle.owner_frame
@@ -994,7 +1247,15 @@ async def owner_frame(self) -> typing.Union["Frame", NoneType]:
         -------
         Optional[Frame]
         """
-        return mapping.from_impl_nullable(await self._impl_obj.ownerFrame())
+
+        try:
+            log_api("=> element_handle.owner_frame started")
+            result = mapping.from_impl_nullable(await self._impl_obj.ownerFrame())
+            log_api("<= element_handle.owner_frame succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.owner_frame failed")
+            raise e
 
     async def content_frame(self) -> typing.Union["Frame", NoneType]:
         """ElementHandle.content_frame
@@ -1005,7 +1266,15 @@ async def content_frame(self) -> typing.Union["Frame", NoneType]:
         -------
         Optional[Frame]
         """
-        return mapping.from_impl_nullable(await self._impl_obj.contentFrame())
+
+        try:
+            log_api("=> element_handle.content_frame started")
+            result = mapping.from_impl_nullable(await self._impl_obj.contentFrame())
+            log_api("<= element_handle.content_frame succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.content_frame failed")
+            raise e
 
     async def get_attribute(self, name: str) -> typing.Union[str, NoneType]:
         """ElementHandle.get_attribute
@@ -1021,7 +1290,17 @@ async def get_attribute(self, name: str) -> typing.Union[str, NoneType]:
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(await self._impl_obj.getAttribute(name=name))
+
+        try:
+            log_api("=> element_handle.get_attribute started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.getAttribute(name=name)
+            )
+            log_api("<= element_handle.get_attribute succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.get_attribute failed")
+            raise e
 
     async def text_content(self) -> typing.Union[str, NoneType]:
         """ElementHandle.text_content
@@ -1032,7 +1311,15 @@ async def text_content(self) -> typing.Union[str, NoneType]:
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(await self._impl_obj.textContent())
+
+        try:
+            log_api("=> element_handle.text_content started")
+            result = mapping.from_maybe_impl(await self._impl_obj.textContent())
+            log_api("<= element_handle.text_content succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.text_content failed")
+            raise e
 
     async def inner_text(self) -> str:
         """ElementHandle.inner_text
@@ -1043,7 +1330,15 @@ async def inner_text(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(await self._impl_obj.innerText())
+
+        try:
+            log_api("=> element_handle.inner_text started")
+            result = mapping.from_maybe_impl(await self._impl_obj.innerText())
+            log_api("<= element_handle.inner_text succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.inner_text failed")
+            raise e
 
     async def inner_html(self) -> str:
         """ElementHandle.inner_html
@@ -1054,7 +1349,15 @@ async def inner_html(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(await self._impl_obj.innerHTML())
+
+        try:
+            log_api("=> element_handle.inner_html started")
+            result = mapping.from_maybe_impl(await self._impl_obj.innerHTML())
+            log_api("<= element_handle.inner_html succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.inner_html failed")
+            raise e
 
     async def dispatch_event(
         self, type: str, event_init: typing.Dict = None
@@ -1085,11 +1388,19 @@ async def dispatch_event(
         event_init : Optional[Dict]
             Optional event-specific initialization properties.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.dispatchEvent(
-                type=type, eventInit=mapping.to_impl(event_init)
+
+        try:
+            log_api("=> element_handle.dispatch_event started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.dispatchEvent(
+                    type=type, eventInit=mapping.to_impl(event_init)
+                )
             )
-        )
+            log_api("<= element_handle.dispatch_event succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.dispatch_event failed")
+            raise e
 
     async def scroll_into_view_if_needed(self, timeout: int = None) -> NoneType:
         """ElementHandle.scroll_into_view_if_needed
@@ -1105,9 +1416,17 @@ async def scroll_into_view_if_needed(self, timeout: int = None) -> NoneType:
         timeout : Optional[int]
             Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.scrollIntoViewIfNeeded(timeout=timeout)
-        )
+
+        try:
+            log_api("=> element_handle.scroll_into_view_if_needed started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.scrollIntoViewIfNeeded(timeout=timeout)
+            )
+            log_api("<= element_handle.scroll_into_view_if_needed succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.scroll_into_view_if_needed failed")
+            raise e
 
     async def hover(
         self,
@@ -1142,11 +1461,19 @@ async def hover(
         force : Optional[bool]
             Whether to bypass the actionability checks. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.hover(
-                modifiers=modifiers, position=position, timeout=timeout, force=force
+
+        try:
+            log_api("=> element_handle.hover started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.hover(
+                    modifiers=modifiers, position=position, timeout=timeout, force=force
+                )
             )
-        )
+            log_api("<= element_handle.hover succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.hover failed")
+            raise e
 
     async def click(
         self,
@@ -1193,18 +1520,26 @@ async def click(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.click(
-                modifiers=modifiers,
-                position=position,
-                delay=delay,
-                button=button,
-                clickCount=click_count,
-                timeout=timeout,
-                force=force,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> element_handle.click started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.click(
+                    modifiers=modifiers,
+                    position=position,
+                    delay=delay,
+                    button=button,
+                    clickCount=click_count,
+                    timeout=timeout,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= element_handle.click succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.click failed")
+            raise e
 
     async def dblclick(
         self,
@@ -1250,17 +1585,25 @@ async def dblclick(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.dblclick(
-                modifiers=modifiers,
-                position=position,
-                delay=delay,
-                button=button,
-                timeout=timeout,
-                force=force,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> element_handle.dblclick started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.dblclick(
+                    modifiers=modifiers,
+                    position=position,
+                    delay=delay,
+                    button=button,
+                    timeout=timeout,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= element_handle.dblclick succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.dblclick failed")
+            raise e
 
     async def select_option(
         self,
@@ -1288,16 +1631,24 @@ async def select_option(
         -------
         List[str]
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.selectOption(
-                value=value,
-                index=index,
-                label=label,
-                element=mapping.to_impl(element),
-                timeout=timeout,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> element_handle.select_option started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.selectOption(
+                    value=value,
+                    index=index,
+                    label=label,
+                    element=mapping.to_impl(element),
+                    timeout=timeout,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= element_handle.select_option succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.select_option failed")
+            raise e
 
     async def tap(
         self,
@@ -1337,15 +1688,23 @@ async def tap(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.tap(
-                modifiers=modifiers,
-                position=position,
-                timeout=timeout,
-                force=force,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> element_handle.tap started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.tap(
+                    modifiers=modifiers,
+                    position=position,
+                    timeout=timeout,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= element_handle.tap succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.tap failed")
+            raise e
 
     async def fill(
         self, value: str, timeout: int = None, no_wait_after: bool = None
@@ -1365,11 +1724,19 @@ async def fill(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.fill(
-                value=value, timeout=timeout, noWaitAfter=no_wait_after
+
+        try:
+            log_api("=> element_handle.fill started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.fill(
+                    value=value, timeout=timeout, noWaitAfter=no_wait_after
+                )
             )
-        )
+            log_api("<= element_handle.fill succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.fill failed")
+            raise e
 
     async def select_text(self, timeout: int = None) -> NoneType:
         """ElementHandle.select_text
@@ -1382,7 +1749,17 @@ async def select_text(self, timeout: int = None) -> NoneType:
         timeout : Optional[int]
             Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.selectText(timeout=timeout))
+
+        try:
+            log_api("=> element_handle.select_text started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.selectText(timeout=timeout)
+            )
+            log_api("<= element_handle.select_text succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.select_text failed")
+            raise e
 
     async def set_input_files(
         self,
@@ -1413,18 +1790,34 @@ async def set_input_files(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.setInputFiles(
-                files=files, timeout=timeout, noWaitAfter=no_wait_after
+
+        try:
+            log_api("=> element_handle.set_input_files started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.setInputFiles(
+                    files=files, timeout=timeout, noWaitAfter=no_wait_after
+                )
             )
-        )
+            log_api("<= element_handle.set_input_files succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.set_input_files failed")
+            raise e
 
     async def focus(self) -> NoneType:
         """ElementHandle.focus
 
         Calls focus on the element.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.focus())
+
+        try:
+            log_api("=> element_handle.focus started")
+            result = mapping.from_maybe_impl(await self._impl_obj.focus())
+            log_api("<= element_handle.focus succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.focus failed")
+            raise e
 
     async def type(
         self,
@@ -1450,11 +1843,19 @@ async def type(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.type(
-                text=text, delay=delay, timeout=timeout, noWaitAfter=no_wait_after
+
+        try:
+            log_api("=> element_handle.type started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.type(
+                    text=text, delay=delay, timeout=timeout, noWaitAfter=no_wait_after
+                )
             )
-        )
+            log_api("<= element_handle.type succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.type failed")
+            raise e
 
     async def press(
         self,
@@ -1489,11 +1890,19 @@ async def press(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.press(
-                key=key, delay=delay, timeout=timeout, noWaitAfter=no_wait_after
+
+        try:
+            log_api("=> element_handle.press started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.press(
+                    key=key, delay=delay, timeout=timeout, noWaitAfter=no_wait_after
+                )
             )
-        )
+            log_api("<= element_handle.press succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.press failed")
+            raise e
 
     async def check(
         self, timeout: int = None, force: bool = None, no_wait_after: bool = None
@@ -1522,11 +1931,19 @@ async def check(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.check(
-                timeout=timeout, force=force, noWaitAfter=no_wait_after
+
+        try:
+            log_api("=> element_handle.check started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.check(
+                    timeout=timeout, force=force, noWaitAfter=no_wait_after
+                )
             )
-        )
+            log_api("<= element_handle.check succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.check failed")
+            raise e
 
     async def uncheck(
         self, timeout: int = None, force: bool = None, no_wait_after: bool = None
@@ -1555,11 +1972,19 @@ async def uncheck(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.uncheck(
-                timeout=timeout, force=force, noWaitAfter=no_wait_after
+
+        try:
+            log_api("=> element_handle.uncheck started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.uncheck(
+                    timeout=timeout, force=force, noWaitAfter=no_wait_after
+                )
             )
-        )
+            log_api("<= element_handle.uncheck succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.uncheck failed")
+            raise e
 
     async def bounding_box(self) -> typing.Union["FloatRect", NoneType]:
         """ElementHandle.bounding_box
@@ -1578,7 +2003,15 @@ async def bounding_box(self) -> typing.Union["FloatRect", NoneType]:
         -------
         Optional[{"x": float, "y": float, "width": float, "height": float}]
         """
-        return mapping.from_impl_nullable(await self._impl_obj.boundingBox())
+
+        try:
+            log_api("=> element_handle.bounding_box started")
+            result = mapping.from_impl_nullable(await self._impl_obj.boundingBox())
+            log_api("<= element_handle.bounding_box succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.bounding_box failed")
+            raise e
 
     async def screenshot(
         self,
@@ -1611,15 +2044,23 @@ async def screenshot(
         -------
         bytes
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.screenshot(
-                timeout=timeout,
-                type=type,
-                path=path,
-                quality=quality,
-                omitBackground=omit_background,
+
+        try:
+            log_api("=> element_handle.screenshot started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.screenshot(
+                    timeout=timeout,
+                    type=type,
+                    path=path,
+                    quality=quality,
+                    omitBackground=omit_background,
+                )
             )
-        )
+            log_api("<= element_handle.screenshot succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.screenshot failed")
+            raise e
 
     async def query_selector(
         self, selector: str
@@ -1639,9 +2080,17 @@ async def query_selector(
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(
-            await self._impl_obj.querySelector(selector=selector)
-        )
+
+        try:
+            log_api("=> element_handle.query_selector started")
+            result = mapping.from_impl_nullable(
+                await self._impl_obj.querySelector(selector=selector)
+            )
+            log_api("<= element_handle.query_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.query_selector failed")
+            raise e
 
     async def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
         """ElementHandle.query_selector_all
@@ -1659,9 +2108,17 @@ async def query_selector_all(self, selector: str) -> typing.List["ElementHandle"
         -------
         List[ElementHandle]
         """
-        return mapping.from_impl_list(
-            await self._impl_obj.querySelectorAll(selector=selector)
-        )
+
+        try:
+            log_api("=> element_handle.query_selector_all started")
+            result = mapping.from_impl_list(
+                await self._impl_obj.querySelectorAll(selector=selector)
+            )
+            log_api("<= element_handle.query_selector_all succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.query_selector_all failed")
+            raise e
 
     async def eval_on_selector(
         self,
@@ -1694,14 +2151,22 @@ async def eval_on_selector(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.evalOnSelector(
-                selector=selector,
-                expression=expression,
-                arg=mapping.to_impl(arg),
-                force_expr=force_expr,
+
+        try:
+            log_api("=> element_handle.eval_on_selector started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.evalOnSelector(
+                    selector=selector,
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                )
             )
-        )
+            log_api("<= element_handle.eval_on_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.eval_on_selector failed")
+            raise e
 
     async def eval_on_selector_all(
         self,
@@ -1740,14 +2205,22 @@ async def eval_on_selector_all(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.evalOnSelectorAll(
-                selector=selector,
-                expression=expression,
-                arg=mapping.to_impl(arg),
-                force_expr=force_expr,
+
+        try:
+            log_api("=> element_handle.eval_on_selector_all started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.evalOnSelectorAll(
+                    selector=selector,
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                )
             )
-        )
+            log_api("<= element_handle.eval_on_selector_all succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.eval_on_selector_all failed")
+            raise e
 
     async def wait_for_element_state(
         self,
@@ -1775,9 +2248,17 @@ async def wait_for_element_state(
         timeout : Optional[int]
             Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.waitForElementState(state=state, timeout=timeout)
-        )
+
+        try:
+            log_api("=> element_handle.wait_for_element_state started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.waitForElementState(state=state, timeout=timeout)
+            )
+            log_api("<= element_handle.wait_for_element_state succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.wait_for_element_state failed")
+            raise e
 
     async def wait_for_selector(
         self,
@@ -1813,11 +2294,19 @@ async def wait_for_selector(
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(
-            await self._impl_obj.waitForSelector(
-                selector=selector, state=state, timeout=timeout
+
+        try:
+            log_api("=> element_handle.wait_for_selector started")
+            result = mapping.from_impl_nullable(
+                await self._impl_obj.waitForSelector(
+                    selector=selector, state=state, timeout=timeout
+                )
             )
-        )
+            log_api("<= element_handle.wait_for_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.wait_for_selector failed")
+            raise e
 
 
 mapping.register(ElementHandleImpl, ElementHandle)
@@ -1852,11 +2341,19 @@ async def snapshot(
         -------
         Optional[Dict]
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.snapshot(
-                interestingOnly=interesting_only, root=mapping.to_impl(root)
+
+        try:
+            log_api("=> accessibility.snapshot started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.snapshot(
+                    interestingOnly=interesting_only, root=mapping.to_impl(root)
+                )
             )
-        )
+            log_api("<= accessibility.snapshot succeded")
+            return result
+        except Exception as e:
+            log_api("<= accessibility.snapshot failed")
+            raise e
 
 
 mapping.register(AccessibilityImpl, Accessibility)
@@ -1924,11 +2421,19 @@ async def set_files(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.setFiles(
-                files=files, timeout=timeout, noWaitAfter=no_wait_after
+
+        try:
+            log_api("=> file_chooser.set_files started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.setFiles(
+                    files=files, timeout=timeout, noWaitAfter=no_wait_after
+                )
             )
-        )
+            log_api("<= file_chooser.set_files succeded")
+            return result
+        except Exception as e:
+            log_api("<= file_chooser.set_files failed")
+            raise e
 
 
 mapping.register(FileChooserImpl, FileChooser)
@@ -2046,11 +2551,19 @@ async def goto(
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(
-            await self._impl_obj.goto(
-                url=url, timeout=timeout, waitUntil=wait_until, referer=referer
+
+        try:
+            log_api("=> frame.goto started")
+            result = mapping.from_impl_nullable(
+                await self._impl_obj.goto(
+                    url=url, timeout=timeout, waitUntil=wait_until, referer=referer
+                )
             )
-        )
+            log_api("<= frame.goto succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.goto failed")
+            raise e
 
     async def wait_for_navigation(
         self,
@@ -2084,11 +2597,19 @@ async def wait_for_navigation(
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(
-            await self._impl_obj.waitForNavigation(
-                url=self._wrap_handler(url), waitUntil=wait_until, timeout=timeout
+
+        try:
+            log_api("=> frame.wait_for_navigation started")
+            result = mapping.from_impl_nullable(
+                await self._impl_obj.waitForNavigation(
+                    url=self._wrap_handler(url), waitUntil=wait_until, timeout=timeout
+                )
             )
-        )
+            log_api("<= frame.wait_for_navigation succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.wait_for_navigation failed")
+            raise e
 
     async def wait_for_load_state(
         self,
@@ -2111,9 +2632,17 @@ async def wait_for_load_state(
         timeout : Optional[int]
             Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.waitForLoadState(state=state, timeout=timeout)
-        )
+
+        try:
+            log_api("=> frame.wait_for_load_state started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.waitForLoadState(state=state, timeout=timeout)
+            )
+            log_api("<= frame.wait_for_load_state succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.wait_for_load_state failed")
+            raise e
 
     async def frame_element(self) -> "ElementHandle":
         """Frame.frame_element
@@ -2126,7 +2655,15 @@ async def frame_element(self) -> "ElementHandle":
         -------
         ElementHandle
         """
-        return mapping.from_impl(await self._impl_obj.frameElement())
+
+        try:
+            log_api("=> frame.frame_element started")
+            result = mapping.from_impl(await self._impl_obj.frameElement())
+            log_api("<= frame.frame_element succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.frame_element failed")
+            raise e
 
     async def evaluate(
         self, expression: str, arg: typing.Any = None, force_expr: bool = None
@@ -2155,11 +2692,21 @@ async def evaluate(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.evaluate(
-                expression=expression, arg=mapping.to_impl(arg), force_expr=force_expr
+
+        try:
+            log_api("=> frame.evaluate started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.evaluate(
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                )
             )
-        )
+            log_api("<= frame.evaluate succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.evaluate failed")
+            raise e
 
     async def evaluate_handle(
         self, expression: str, arg: typing.Any = None, force_expr: bool = None
@@ -2187,11 +2734,21 @@ async def evaluate_handle(
         -------
         JSHandle
         """
-        return mapping.from_impl(
-            await self._impl_obj.evaluateHandle(
-                expression=expression, arg=mapping.to_impl(arg), force_expr=force_expr
+
+        try:
+            log_api("=> frame.evaluate_handle started")
+            result = mapping.from_impl(
+                await self._impl_obj.evaluateHandle(
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                )
             )
-        )
+            log_api("<= frame.evaluate_handle succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.evaluate_handle failed")
+            raise e
 
     async def query_selector(
         self, selector: str
@@ -2212,9 +2769,17 @@ async def query_selector(
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(
-            await self._impl_obj.querySelector(selector=selector)
-        )
+
+        try:
+            log_api("=> frame.query_selector started")
+            result = mapping.from_impl_nullable(
+                await self._impl_obj.querySelector(selector=selector)
+            )
+            log_api("<= frame.query_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.query_selector failed")
+            raise e
 
     async def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
         """Frame.query_selector_all
@@ -2233,9 +2798,17 @@ async def query_selector_all(self, selector: str) -> typing.List["ElementHandle"
         -------
         List[ElementHandle]
         """
-        return mapping.from_impl_list(
-            await self._impl_obj.querySelectorAll(selector=selector)
-        )
+
+        try:
+            log_api("=> frame.query_selector_all started")
+            result = mapping.from_impl_list(
+                await self._impl_obj.querySelectorAll(selector=selector)
+            )
+            log_api("<= frame.query_selector_all succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.query_selector_all failed")
+            raise e
 
     async def wait_for_selector(
         self,
@@ -2269,11 +2842,19 @@ async def wait_for_selector(
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(
-            await self._impl_obj.waitForSelector(
-                selector=selector, timeout=timeout, state=state
+
+        try:
+            log_api("=> frame.wait_for_selector started")
+            result = mapping.from_impl_nullable(
+                await self._impl_obj.waitForSelector(
+                    selector=selector, timeout=timeout, state=state
+                )
             )
-        )
+            log_api("<= frame.wait_for_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.wait_for_selector failed")
+            raise e
 
     async def dispatch_event(
         self,
@@ -2312,14 +2893,22 @@ async def dispatch_event(
         timeout : Optional[int]
             Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.dispatchEvent(
-                selector=selector,
-                type=type,
-                eventInit=mapping.to_impl(event_init),
-                timeout=timeout,
+
+        try:
+            log_api("=> frame.dispatch_event started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.dispatchEvent(
+                    selector=selector,
+                    type=type,
+                    eventInit=mapping.to_impl(event_init),
+                    timeout=timeout,
+                )
             )
-        )
+            log_api("<= frame.dispatch_event succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.dispatch_event failed")
+            raise e
 
     async def eval_on_selector(
         self,
@@ -2352,14 +2941,22 @@ async def eval_on_selector(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.evalOnSelector(
-                selector=selector,
-                expression=expression,
-                arg=mapping.to_impl(arg),
-                force_expr=force_expr,
+
+        try:
+            log_api("=> frame.eval_on_selector started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.evalOnSelector(
+                    selector=selector,
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                )
             )
-        )
+            log_api("<= frame.eval_on_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.eval_on_selector failed")
+            raise e
 
     async def eval_on_selector_all(
         self,
@@ -2391,14 +2988,22 @@ async def eval_on_selector_all(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.evalOnSelectorAll(
-                selector=selector,
-                expression=expression,
-                arg=mapping.to_impl(arg),
-                force_expr=force_expr,
+
+        try:
+            log_api("=> frame.eval_on_selector_all started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.evalOnSelectorAll(
+                    selector=selector,
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                )
             )
-        )
+            log_api("<= frame.eval_on_selector_all succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.eval_on_selector_all failed")
+            raise e
 
     async def content(self) -> str:
         """Frame.content
@@ -2409,7 +3014,15 @@ async def content(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(await self._impl_obj.content())
+
+        try:
+            log_api("=> frame.content started")
+            result = mapping.from_maybe_impl(await self._impl_obj.content())
+            log_api("<= frame.content succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.content failed")
+            raise e
 
     async def set_content(
         self,
@@ -2431,11 +3044,19 @@ async def set_content(
              - `'load'` - consider operation to be finished when the `load` event is fired.
              - `'networkidle'` - consider operation to be finished when there are no network connections for at least `500` ms.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.setContent(
-                html=html, timeout=timeout, waitUntil=wait_until
+
+        try:
+            log_api("=> frame.set_content started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.setContent(
+                    html=html, timeout=timeout, waitUntil=wait_until
+                )
             )
-        )
+            log_api("<= frame.set_content succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.set_content failed")
+            raise e
 
     def is_detached(self) -> bool:
         """Frame.is_detached
@@ -2446,7 +3067,15 @@ def is_detached(self) -> bool:
         -------
         bool
         """
-        return mapping.from_maybe_impl(self._impl_obj.isDetached())
+
+        try:
+            log_api("=> frame.is_detached started")
+            result = mapping.from_maybe_impl(self._impl_obj.isDetached())
+            log_api("<= frame.is_detached succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.is_detached failed")
+            raise e
 
     async def add_script_tag(
         self,
@@ -2475,11 +3104,19 @@ async def add_script_tag(
         -------
         ElementHandle
         """
-        return mapping.from_impl(
-            await self._impl_obj.addScriptTag(
-                url=url, path=path, content=content, type=type
+
+        try:
+            log_api("=> frame.add_script_tag started")
+            result = mapping.from_impl(
+                await self._impl_obj.addScriptTag(
+                    url=url, path=path, content=content, type=type
+                )
             )
-        )
+            log_api("<= frame.add_script_tag succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.add_script_tag failed")
+            raise e
 
     async def add_style_tag(
         self,
@@ -2506,9 +3143,17 @@ async def add_style_tag(
         -------
         ElementHandle
         """
-        return mapping.from_impl(
-            await self._impl_obj.addStyleTag(url=url, path=path, content=content)
-        )
+
+        try:
+            log_api("=> frame.add_style_tag started")
+            result = mapping.from_impl(
+                await self._impl_obj.addStyleTag(url=url, path=path, content=content)
+            )
+            log_api("<= frame.add_style_tag succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.add_style_tag failed")
+            raise e
 
     async def click(
         self,
@@ -2558,19 +3203,27 @@ async def click(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.click(
-                selector=selector,
-                modifiers=modifiers,
-                position=position,
-                delay=delay,
-                button=button,
-                clickCount=click_count,
-                timeout=timeout,
-                force=force,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.click started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.click(
+                    selector=selector,
+                    modifiers=modifiers,
+                    position=position,
+                    delay=delay,
+                    button=button,
+                    clickCount=click_count,
+                    timeout=timeout,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= frame.click succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.click failed")
+            raise e
 
     async def dblclick(
         self,
@@ -2619,18 +3272,26 @@ async def dblclick(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.dblclick(
-                selector=selector,
-                modifiers=modifiers,
-                position=position,
-                delay=delay,
-                button=button,
-                timeout=timeout,
-                force=force,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.dblclick started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.dblclick(
+                    selector=selector,
+                    modifiers=modifiers,
+                    position=position,
+                    delay=delay,
+                    button=button,
+                    timeout=timeout,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= frame.dblclick succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.dblclick failed")
+            raise e
 
     async def tap(
         self,
@@ -2673,16 +3334,24 @@ async def tap(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.tap(
-                selector=selector,
-                modifiers=modifiers,
-                position=position,
-                timeout=timeout,
-                force=force,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.tap started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.tap(
+                    selector=selector,
+                    modifiers=modifiers,
+                    position=position,
+                    timeout=timeout,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= frame.tap succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.tap failed")
+            raise e
 
     async def fill(
         self, selector: str, value: str, timeout: int = None, no_wait_after: bool = None
@@ -2706,14 +3375,22 @@ async def fill(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.fill(
-                selector=selector,
-                value=value,
-                timeout=timeout,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.fill started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.fill(
+                    selector=selector,
+                    value=value,
+                    timeout=timeout,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= frame.fill succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.fill failed")
+            raise e
 
     async def focus(self, selector: str, timeout: int = None) -> NoneType:
         """Frame.focus
@@ -2728,9 +3405,17 @@ async def focus(self, selector: str, timeout: int = None) -> NoneType:
         timeout : Optional[int]
             Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.focus(selector=selector, timeout=timeout)
-        )
+
+        try:
+            log_api("=> frame.focus started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.focus(selector=selector, timeout=timeout)
+            )
+            log_api("<= frame.focus succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.focus failed")
+            raise e
 
     async def text_content(
         self, selector: str, timeout: int = None
@@ -2750,9 +3435,17 @@ async def text_content(
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.textContent(selector=selector, timeout=timeout)
-        )
+
+        try:
+            log_api("=> frame.text_content started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.textContent(selector=selector, timeout=timeout)
+            )
+            log_api("<= frame.text_content succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.text_content failed")
+            raise e
 
     async def inner_text(self, selector: str, timeout: int = None) -> str:
         """Frame.inner_text
@@ -2770,9 +3463,17 @@ async def inner_text(self, selector: str, timeout: int = None) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.innerText(selector=selector, timeout=timeout)
-        )
+
+        try:
+            log_api("=> frame.inner_text started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.innerText(selector=selector, timeout=timeout)
+            )
+            log_api("<= frame.inner_text succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.inner_text failed")
+            raise e
 
     async def inner_html(self, selector: str, timeout: int = None) -> str:
         """Frame.inner_html
@@ -2790,9 +3491,17 @@ async def inner_html(self, selector: str, timeout: int = None) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.innerHTML(selector=selector, timeout=timeout)
-        )
+
+        try:
+            log_api("=> frame.inner_html started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.innerHTML(selector=selector, timeout=timeout)
+            )
+            log_api("<= frame.inner_html succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.inner_html failed")
+            raise e
 
     async def get_attribute(
         self, selector: str, name: str, timeout: int = None
@@ -2814,11 +3523,19 @@ async def get_attribute(
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.getAttribute(
-                selector=selector, name=name, timeout=timeout
+
+        try:
+            log_api("=> frame.get_attribute started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.getAttribute(
+                    selector=selector, name=name, timeout=timeout
+                )
             )
-        )
+            log_api("<= frame.get_attribute succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.get_attribute failed")
+            raise e
 
     async def hover(
         self,
@@ -2856,15 +3573,23 @@ async def hover(
         force : Optional[bool]
             Whether to bypass the actionability checks. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.hover(
-                selector=selector,
-                modifiers=modifiers,
-                position=position,
-                timeout=timeout,
-                force=force,
+
+        try:
+            log_api("=> frame.hover started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.hover(
+                    selector=selector,
+                    modifiers=modifiers,
+                    position=position,
+                    timeout=timeout,
+                    force=force,
+                )
             )
-        )
+            log_api("<= frame.hover succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.hover failed")
+            raise e
 
     async def select_option(
         self,
@@ -2895,17 +3620,25 @@ async def select_option(
         -------
         List[str]
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.selectOption(
-                selector=selector,
-                value=value,
-                index=index,
-                label=label,
-                element=mapping.to_impl(element),
-                timeout=timeout,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.select_option started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.selectOption(
+                    selector=selector,
+                    value=value,
+                    index=index,
+                    label=label,
+                    element=mapping.to_impl(element),
+                    timeout=timeout,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= frame.select_option succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.select_option failed")
+            raise e
 
     async def set_input_files(
         self,
@@ -2939,14 +3672,22 @@ async def set_input_files(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.setInputFiles(
-                selector=selector,
-                files=files,
-                timeout=timeout,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.set_input_files started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.setInputFiles(
+                    selector=selector,
+                    files=files,
+                    timeout=timeout,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= frame.set_input_files succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.set_input_files failed")
+            raise e
 
     async def type(
         self,
@@ -2975,15 +3716,23 @@ async def type(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.type(
-                selector=selector,
-                text=text,
-                delay=delay,
-                timeout=timeout,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.type started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.type(
+                    selector=selector,
+                    text=text,
+                    delay=delay,
+                    timeout=timeout,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= frame.type succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.type failed")
+            raise e
 
     async def press(
         self,
@@ -3020,15 +3769,23 @@ async def press(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.press(
-                selector=selector,
-                key=key,
-                delay=delay,
-                timeout=timeout,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.press started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.press(
+                    selector=selector,
+                    key=key,
+                    delay=delay,
+                    timeout=timeout,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= frame.press succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.press failed")
+            raise e
 
     async def check(
         self,
@@ -3063,14 +3820,22 @@ async def check(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.check(
-                selector=selector,
-                timeout=timeout,
-                force=force,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.check started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.check(
+                    selector=selector,
+                    timeout=timeout,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= frame.check succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.check failed")
+            raise e
 
     async def uncheck(
         self,
@@ -3105,14 +3870,22 @@ async def uncheck(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.uncheck(
-                selector=selector,
-                timeout=timeout,
-                force=force,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.uncheck started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.uncheck(
+                    selector=selector,
+                    timeout=timeout,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= frame.uncheck succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.uncheck failed")
+            raise e
 
     async def wait_for_timeout(self, timeout: int) -> NoneType:
         """Frame.wait_for_timeout
@@ -3126,9 +3899,17 @@ async def wait_for_timeout(self, timeout: int) -> NoneType:
         timeout : int
             A timeout to wait for
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.waitForTimeout(timeout=timeout)
-        )
+
+        try:
+            log_api("=> frame.wait_for_timeout started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.waitForTimeout(timeout=timeout)
+            )
+            log_api("<= frame.wait_for_timeout succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.wait_for_timeout failed")
+            raise e
 
     async def wait_for_function(
         self,
@@ -3162,15 +3943,23 @@ async def wait_for_function(
         -------
         JSHandle
         """
-        return mapping.from_impl(
-            await self._impl_obj.waitForFunction(
-                expression=expression,
-                arg=mapping.to_impl(arg),
-                force_expr=force_expr,
-                timeout=timeout,
-                polling=polling,
+
+        try:
+            log_api("=> frame.wait_for_function started")
+            result = mapping.from_impl(
+                await self._impl_obj.waitForFunction(
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                    timeout=timeout,
+                    polling=polling,
+                )
             )
-        )
+            log_api("<= frame.wait_for_function succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.wait_for_function failed")
+            raise e
 
     async def title(self) -> str:
         """Frame.title
@@ -3181,7 +3970,15 @@ async def title(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(await self._impl_obj.title())
+
+        try:
+            log_api("=> frame.title started")
+            result = mapping.from_maybe_impl(await self._impl_obj.title())
+            log_api("<= frame.title succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.title failed")
+            raise e
 
     def expect_load_state(
         self,
@@ -3281,11 +4078,21 @@ async def evaluate(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.evaluate(
-                expression=expression, arg=mapping.to_impl(arg), force_expr=force_expr
+
+        try:
+            log_api("=> worker.evaluate started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.evaluate(
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                )
             )
-        )
+            log_api("<= worker.evaluate succeded")
+            return result
+        except Exception as e:
+            log_api("<= worker.evaluate failed")
+            raise e
 
     async def evaluate_handle(
         self, expression: str, arg: typing.Any = None, force_expr: bool = None
@@ -3311,11 +4118,21 @@ async def evaluate_handle(
         -------
         JSHandle
         """
-        return mapping.from_impl(
-            await self._impl_obj.evaluateHandle(
-                expression=expression, arg=mapping.to_impl(arg), force_expr=force_expr
+
+        try:
+            log_api("=> worker.evaluate_handle started")
+            result = mapping.from_impl(
+                await self._impl_obj.evaluateHandle(
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                )
             )
-        )
+            log_api("<= worker.evaluate_handle succeded")
+            return result
+        except Exception as e:
+            log_api("<= worker.evaluate_handle failed")
+            raise e
 
 
 mapping.register(WorkerImpl, Worker)
@@ -3345,11 +4162,19 @@ async def register(
         content_script : Optional[bool]
             Whether to run this selector engine in isolated JavaScript environment. This environment has access to the same DOM, but not any JavaScript objects from the frame's scripts. Defaults to `false`. Note that running as a content script is not guaranteed when this engine is used together with other registered engines.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.register(
-                name=name, source=source, path=path, contentScript=content_script
+
+        try:
+            log_api("=> selectors.register started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.register(
+                    name=name, source=source, path=path, contentScript=content_script
+                )
             )
-        )
+            log_api("<= selectors.register succeded")
+            return result
+        except Exception as e:
+            log_api("<= selectors.register failed")
+            raise e
 
 
 mapping.register(SelectorsImpl, Selectors)
@@ -3457,16 +4282,32 @@ async def accept(self, prompt_text: str = None) -> NoneType:
         prompt_text : Optional[str]
             A text to enter in prompt. Does not cause any effects if the dialog's `type` is not prompt. Optional.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.accept(promptText=prompt_text)
-        )
+
+        try:
+            log_api("=> dialog.accept started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.accept(promptText=prompt_text)
+            )
+            log_api("<= dialog.accept succeded")
+            return result
+        except Exception as e:
+            log_api("<= dialog.accept failed")
+            raise e
 
     async def dismiss(self) -> NoneType:
         """Dialog.dismiss
 
         Returns when the dialog has been dismissed.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.dismiss())
+
+        try:
+            log_api("=> dialog.dismiss started")
+            result = mapping.from_maybe_impl(await self._impl_obj.dismiss())
+            log_api("<= dialog.dismiss succeded")
+            return result
+        except Exception as e:
+            log_api("<= dialog.dismiss failed")
+            raise e
 
 
 mapping.register(DialogImpl, Dialog)
@@ -3508,7 +4349,15 @@ async def delete(self) -> NoneType:
 
         Deletes the downloaded file.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.delete())
+
+        try:
+            log_api("=> download.delete started")
+            result = mapping.from_maybe_impl(await self._impl_obj.delete())
+            log_api("<= download.delete succeded")
+            return result
+        except Exception as e:
+            log_api("<= download.delete failed")
+            raise e
 
     async def failure(self) -> typing.Union[str, NoneType]:
         """Download.failure
@@ -3519,7 +4368,15 @@ async def failure(self) -> typing.Union[str, NoneType]:
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(await self._impl_obj.failure())
+
+        try:
+            log_api("=> download.failure started")
+            result = mapping.from_maybe_impl(await self._impl_obj.failure())
+            log_api("<= download.failure succeded")
+            return result
+        except Exception as e:
+            log_api("<= download.failure failed")
+            raise e
 
     async def path(self) -> typing.Union[str, NoneType]:
         """Download.path
@@ -3530,7 +4387,15 @@ async def path(self) -> typing.Union[str, NoneType]:
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(await self._impl_obj.path())
+
+        try:
+            log_api("=> download.path started")
+            result = mapping.from_maybe_impl(await self._impl_obj.path())
+            log_api("<= download.path succeded")
+            return result
+        except Exception as e:
+            log_api("<= download.path failed")
+            raise e
 
     async def save_as(self, path: typing.Union[str, pathlib.Path]) -> NoneType:
         """Download.save_as
@@ -3542,7 +4407,15 @@ async def save_as(self, path: typing.Union[str, pathlib.Path]) -> NoneType:
         path : Union[str, pathlib.Path]
             Path where the download should be saved.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.saveAs(path=path))
+
+        try:
+            log_api("=> download.save_as started")
+            result = mapping.from_maybe_impl(await self._impl_obj.saveAs(path=path))
+            log_api("<= download.save_as succeded")
+            return result
+        except Exception as e:
+            log_api("<= download.save_as failed")
+            raise e
 
 
 mapping.register(DownloadImpl, Download)
@@ -3562,7 +4435,15 @@ async def path(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(await self._impl_obj.path())
+
+        try:
+            log_api("=> video.path started")
+            result = mapping.from_maybe_impl(await self._impl_obj.path())
+            log_api("<= video.path succeded")
+            return result
+        except Exception as e:
+            log_api("<= video.path failed")
+            raise e
 
 
 mapping.register(VideoImpl, Video)
@@ -3573,9 +4454,17 @@ def __init__(self, obj: BindingCallImpl):
         super().__init__(obj)
 
     async def call(self, func: typing.Callable) -> NoneType:
-        return mapping.from_maybe_impl(
-            await self._impl_obj.call(func=self._wrap_handler(func))
-        )
+
+        try:
+            log_api("=> binding_call.call started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.call(func=self._wrap_handler(func))
+            )
+            log_api("<= binding_call.call succeded")
+            return result
+        except Exception as e:
+            log_api("<= binding_call.call failed")
+            raise e
 
 
 mapping.register(BindingCallImpl, BindingCall)
@@ -3710,7 +4599,15 @@ async def opener(self) -> typing.Union["Page", NoneType]:
         -------
         Optional[Page]
         """
-        return mapping.from_impl_nullable(await self._impl_obj.opener())
+
+        try:
+            log_api("=> page.opener started")
+            result = mapping.from_impl_nullable(await self._impl_obj.opener())
+            log_api("<= page.opener succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.opener failed")
+            raise e
 
     def frame(
         self,
@@ -3732,9 +4629,17 @@ def frame(
         -------
         Optional[Frame]
         """
-        return mapping.from_impl_nullable(
-            self._impl_obj.frame(name=name, url=self._wrap_handler(url))
-        )
+
+        try:
+            log_api("=> page.frame started")
+            result = mapping.from_impl_nullable(
+                self._impl_obj.frame(name=name, url=self._wrap_handler(url))
+            )
+            log_api("<= page.frame succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.frame failed")
+            raise e
 
     def set_default_navigation_timeout(self, timeout: int) -> NoneType:
         """Page.set_default_navigation_timeout
@@ -3756,9 +4661,17 @@ def set_default_navigation_timeout(self, timeout: int) -> NoneType:
         timeout : int
             Maximum navigation time in milliseconds
         """
-        return mapping.from_maybe_impl(
-            self._impl_obj.setDefaultNavigationTimeout(timeout=timeout)
-        )
+
+        try:
+            log_api("=> page.set_default_navigation_timeout started")
+            result = mapping.from_maybe_impl(
+                self._impl_obj.setDefaultNavigationTimeout(timeout=timeout)
+            )
+            log_api("<= page.set_default_navigation_timeout succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.set_default_navigation_timeout failed")
+            raise e
 
     def set_default_timeout(self, timeout: int) -> NoneType:
         """Page.set_default_timeout
@@ -3772,9 +4685,17 @@ def set_default_timeout(self, timeout: int) -> NoneType:
         timeout : int
             Maximum time in milliseconds
         """
-        return mapping.from_maybe_impl(
-            self._impl_obj.setDefaultTimeout(timeout=timeout)
-        )
+
+        try:
+            log_api("=> page.set_default_timeout started")
+            result = mapping.from_maybe_impl(
+                self._impl_obj.setDefaultTimeout(timeout=timeout)
+            )
+            log_api("<= page.set_default_timeout succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.set_default_timeout failed")
+            raise e
 
     async def query_selector(
         self, selector: str
@@ -3794,9 +4715,17 @@ async def query_selector(
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(
-            await self._impl_obj.querySelector(selector=selector)
-        )
+
+        try:
+            log_api("=> page.query_selector started")
+            result = mapping.from_impl_nullable(
+                await self._impl_obj.querySelector(selector=selector)
+            )
+            log_api("<= page.query_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.query_selector failed")
+            raise e
 
     async def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
         """Page.query_selector_all
@@ -3814,9 +4743,17 @@ async def query_selector_all(self, selector: str) -> typing.List["ElementHandle"
         -------
         List[ElementHandle]
         """
-        return mapping.from_impl_list(
-            await self._impl_obj.querySelectorAll(selector=selector)
-        )
+
+        try:
+            log_api("=> page.query_selector_all started")
+            result = mapping.from_impl_list(
+                await self._impl_obj.querySelectorAll(selector=selector)
+            )
+            log_api("<= page.query_selector_all succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.query_selector_all failed")
+            raise e
 
     async def wait_for_selector(
         self,
@@ -3850,11 +4787,19 @@ async def wait_for_selector(
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(
-            await self._impl_obj.waitForSelector(
-                selector=selector, timeout=timeout, state=state
+
+        try:
+            log_api("=> page.wait_for_selector started")
+            result = mapping.from_impl_nullable(
+                await self._impl_obj.waitForSelector(
+                    selector=selector, timeout=timeout, state=state
+                )
             )
-        )
+            log_api("<= page.wait_for_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_selector failed")
+            raise e
 
     async def dispatch_event(
         self,
@@ -3893,14 +4838,22 @@ async def dispatch_event(
         timeout : Optional[int]
             Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.dispatchEvent(
-                selector=selector,
-                type=type,
-                eventInit=mapping.to_impl(event_init),
-                timeout=timeout,
+
+        try:
+            log_api("=> page.dispatch_event started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.dispatchEvent(
+                    selector=selector,
+                    type=type,
+                    eventInit=mapping.to_impl(event_init),
+                    timeout=timeout,
+                )
             )
-        )
+            log_api("<= page.dispatch_event succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.dispatch_event failed")
+            raise e
 
     async def evaluate(
         self, expression: str, arg: typing.Any = None, force_expr: bool = None
@@ -3931,11 +4884,21 @@ async def evaluate(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.evaluate(
-                expression=expression, arg=mapping.to_impl(arg), force_expr=force_expr
+
+        try:
+            log_api("=> page.evaluate started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.evaluate(
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                )
             )
-        )
+            log_api("<= page.evaluate succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.evaluate failed")
+            raise e
 
     async def evaluate_handle(
         self, expression: str, arg: typing.Any = None, force_expr: bool = None
@@ -3963,11 +4926,21 @@ async def evaluate_handle(
         -------
         JSHandle
         """
-        return mapping.from_impl(
-            await self._impl_obj.evaluateHandle(
-                expression=expression, arg=mapping.to_impl(arg), force_expr=force_expr
+
+        try:
+            log_api("=> page.evaluate_handle started")
+            result = mapping.from_impl(
+                await self._impl_obj.evaluateHandle(
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                )
             )
-        )
+            log_api("<= page.evaluate_handle succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.evaluate_handle failed")
+            raise e
 
     async def eval_on_selector(
         self,
@@ -3999,14 +4972,22 @@ async def eval_on_selector(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.evalOnSelector(
-                selector=selector,
-                expression=expression,
-                arg=mapping.to_impl(arg),
-                force_expr=force_expr,
+
+        try:
+            log_api("=> page.eval_on_selector started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.evalOnSelector(
+                    selector=selector,
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                )
             )
-        )
+            log_api("<= page.eval_on_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.eval_on_selector failed")
+            raise e
 
     async def eval_on_selector_all(
         self,
@@ -4037,14 +5018,22 @@ async def eval_on_selector_all(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.evalOnSelectorAll(
-                selector=selector,
-                expression=expression,
-                arg=mapping.to_impl(arg),
-                force_expr=force_expr,
+
+        try:
+            log_api("=> page.eval_on_selector_all started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.evalOnSelectorAll(
+                    selector=selector,
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                )
             )
-        )
+            log_api("<= page.eval_on_selector_all succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.eval_on_selector_all failed")
+            raise e
 
     async def add_script_tag(
         self,
@@ -4074,11 +5063,19 @@ async def add_script_tag(
         -------
         ElementHandle
         """
-        return mapping.from_impl(
-            await self._impl_obj.addScriptTag(
-                url=url, path=path, content=content, type=type
+
+        try:
+            log_api("=> page.add_script_tag started")
+            result = mapping.from_impl(
+                await self._impl_obj.addScriptTag(
+                    url=url, path=path, content=content, type=type
+                )
             )
-        )
+            log_api("<= page.add_script_tag succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.add_script_tag failed")
+            raise e
 
     async def add_style_tag(
         self,
@@ -4105,9 +5102,17 @@ async def add_style_tag(
         -------
         ElementHandle
         """
-        return mapping.from_impl(
-            await self._impl_obj.addStyleTag(url=url, path=path, content=content)
-        )
+
+        try:
+            log_api("=> page.add_style_tag started")
+            result = mapping.from_impl(
+                await self._impl_obj.addStyleTag(url=url, path=path, content=content)
+            )
+            log_api("<= page.add_style_tag succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.add_style_tag failed")
+            raise e
 
     async def expose_function(self, name: str, binding: typing.Callable) -> NoneType:
         """Page.expose_function
@@ -4131,11 +5136,19 @@ async def expose_function(self, name: str, binding: typing.Callable) -> NoneType
         binding : Callable
             Callback function which will be called in Playwright's context.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.exposeFunction(
-                name=name, binding=self._wrap_handler(binding)
+
+        try:
+            log_api("=> page.expose_function started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.exposeFunction(
+                    name=name, binding=self._wrap_handler(binding)
+                )
             )
-        )
+            log_api("<= page.expose_function succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.expose_function failed")
+            raise e
 
     async def expose_binding(
         self, name: str, binding: typing.Callable, handle: bool = None
@@ -4163,11 +5176,19 @@ async def expose_binding(
         handle : Optional[bool]
             Whether to pass the argument as a handle, instead of passing by value. When passing a handle, only one argument is supported. When passing by value, multiple arguments are supported.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.exposeBinding(
-                name=name, binding=self._wrap_handler(binding), handle=handle
+
+        try:
+            log_api("=> page.expose_binding started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.exposeBinding(
+                    name=name, binding=self._wrap_handler(binding), handle=handle
+                )
             )
-        )
+            log_api("<= page.expose_binding succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.expose_binding failed")
+            raise e
 
     async def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> NoneType:
         """Page.set_extra_http_headers
@@ -4181,9 +5202,19 @@ async def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> NoneTy
         headers : Dict[str, str]
             An object containing additional HTTP headers to be sent with every request. All header values must be strings.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.setExtraHTTPHeaders(headers=mapping.to_impl(headers))
-        )
+
+        try:
+            log_api("=> page.set_extra_http_headers started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.setExtraHTTPHeaders(
+                    headers=mapping.to_impl(headers)
+                )
+            )
+            log_api("<= page.set_extra_http_headers succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.set_extra_http_headers failed")
+            raise e
 
     async def content(self) -> str:
         """Page.content
@@ -4194,7 +5225,15 @@ async def content(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(await self._impl_obj.content())
+
+        try:
+            log_api("=> page.content started")
+            result = mapping.from_maybe_impl(await self._impl_obj.content())
+            log_api("<= page.content succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.content failed")
+            raise e
 
     async def set_content(
         self,
@@ -4216,11 +5255,19 @@ async def set_content(
              - `'load'` - consider operation to be finished when the `load` event is fired.
              - `'networkidle'` - consider operation to be finished when there are no network connections for at least `500` ms.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.setContent(
-                html=html, timeout=timeout, waitUntil=wait_until
+
+        try:
+            log_api("=> page.set_content started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.setContent(
+                    html=html, timeout=timeout, waitUntil=wait_until
+                )
             )
-        )
+            log_api("<= page.set_content succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.set_content failed")
+            raise e
 
     async def goto(
         self,
@@ -4270,11 +5317,19 @@ async def goto(
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(
-            await self._impl_obj.goto(
-                url=url, timeout=timeout, waitUntil=wait_until, referer=referer
+
+        try:
+            log_api("=> page.goto started")
+            result = mapping.from_impl_nullable(
+                await self._impl_obj.goto(
+                    url=url, timeout=timeout, waitUntil=wait_until, referer=referer
+                )
             )
-        )
+            log_api("<= page.goto succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.goto failed")
+            raise e
 
     async def reload(
         self,
@@ -4300,9 +5355,17 @@ async def reload(
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(
-            await self._impl_obj.reload(timeout=timeout, waitUntil=wait_until)
-        )
+
+        try:
+            log_api("=> page.reload started")
+            result = mapping.from_impl_nullable(
+                await self._impl_obj.reload(timeout=timeout, waitUntil=wait_until)
+            )
+            log_api("<= page.reload succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.reload failed")
+            raise e
 
     async def wait_for_load_state(
         self,
@@ -4326,9 +5389,17 @@ async def wait_for_load_state(
         timeout : Optional[int]
             Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.waitForLoadState(state=state, timeout=timeout)
-        )
+
+        try:
+            log_api("=> page.wait_for_load_state started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.waitForLoadState(state=state, timeout=timeout)
+            )
+            log_api("<= page.wait_for_load_state succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_load_state failed")
+            raise e
 
     async def wait_for_navigation(
         self,
@@ -4364,11 +5435,19 @@ async def wait_for_navigation(
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(
-            await self._impl_obj.waitForNavigation(
-                url=self._wrap_handler(url), waitUntil=wait_until, timeout=timeout
+
+        try:
+            log_api("=> page.wait_for_navigation started")
+            result = mapping.from_impl_nullable(
+                await self._impl_obj.waitForNavigation(
+                    url=self._wrap_handler(url), waitUntil=wait_until, timeout=timeout
+                )
             )
-        )
+            log_api("<= page.wait_for_navigation succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_navigation failed")
+            raise e
 
     async def wait_for_request(
         self,
@@ -4391,13 +5470,21 @@ async def wait_for_request(
         -------
         Request
         """
-        return mapping.from_impl(
-            await self._impl_obj.waitForRequest(
-                url=self._wrap_handler(url),
-                predicate=self._wrap_handler(predicate),
-                timeout=timeout,
+
+        try:
+            log_api("=> page.wait_for_request started")
+            result = mapping.from_impl(
+                await self._impl_obj.waitForRequest(
+                    url=self._wrap_handler(url),
+                    predicate=self._wrap_handler(predicate),
+                    timeout=timeout,
+                )
             )
-        )
+            log_api("<= page.wait_for_request succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_request failed")
+            raise e
 
     async def wait_for_response(
         self,
@@ -4420,13 +5507,21 @@ async def wait_for_response(
         -------
         Response
         """
-        return mapping.from_impl(
-            await self._impl_obj.waitForResponse(
-                url=self._wrap_handler(url),
-                predicate=self._wrap_handler(predicate),
-                timeout=timeout,
+
+        try:
+            log_api("=> page.wait_for_response started")
+            result = mapping.from_impl(
+                await self._impl_obj.waitForResponse(
+                    url=self._wrap_handler(url),
+                    predicate=self._wrap_handler(predicate),
+                    timeout=timeout,
+                )
             )
-        )
+            log_api("<= page.wait_for_response succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_response failed")
+            raise e
 
     async def wait_for_event(
         self,
@@ -4449,11 +5544,21 @@ async def wait_for_event(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.waitForEvent(
-                event=event, predicate=self._wrap_handler(predicate), timeout=timeout
+
+        try:
+            log_api("=> page.wait_for_event started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.waitForEvent(
+                    event=event,
+                    predicate=self._wrap_handler(predicate),
+                    timeout=timeout,
+                )
             )
-        )
+            log_api("<= page.wait_for_event succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_event failed")
+            raise e
 
     async def go_back(
         self,
@@ -4480,9 +5585,17 @@ async def go_back(
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(
-            await self._impl_obj.goBack(timeout=timeout, waitUntil=wait_until)
-        )
+
+        try:
+            log_api("=> page.go_back started")
+            result = mapping.from_impl_nullable(
+                await self._impl_obj.goBack(timeout=timeout, waitUntil=wait_until)
+            )
+            log_api("<= page.go_back succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.go_back failed")
+            raise e
 
     async def go_forward(
         self,
@@ -4509,9 +5622,17 @@ async def go_forward(
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(
-            await self._impl_obj.goForward(timeout=timeout, waitUntil=wait_until)
-        )
+
+        try:
+            log_api("=> page.go_forward started")
+            result = mapping.from_impl_nullable(
+                await self._impl_obj.goForward(timeout=timeout, waitUntil=wait_until)
+            )
+            log_api("<= page.go_forward succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.go_forward failed")
+            raise e
 
     async def emulate_media(
         self,
@@ -4528,9 +5649,17 @@ async def emulate_media(
         color_scheme : Optional[Literal['dark', 'light', 'no-preference']]
             Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. Passing `null` disables color scheme emulation. Omitting `colorScheme` or passing `undefined` does not change the emulated value.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.emulateMedia(media=media, colorScheme=color_scheme)
-        )
+
+        try:
+            log_api("=> page.emulate_media started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.emulateMedia(media=media, colorScheme=color_scheme)
+            )
+            log_api("<= page.emulate_media succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.emulate_media failed")
+            raise e
 
     async def set_viewport_size(self, width: int, height: int) -> NoneType:
         """Page.set_viewport_size
@@ -4547,9 +5676,17 @@ async def set_viewport_size(self, width: int, height: int) -> NoneType:
         height : int
             page height in pixels. **required**
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.setViewportSize(width=width, height=height)
-        )
+
+        try:
+            log_api("=> page.set_viewport_size started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.setViewportSize(width=width, height=height)
+            )
+            log_api("<= page.set_viewport_size succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.set_viewport_size failed")
+            raise e
 
     def viewport_size(self) -> typing.Union[typing.Tuple[int, int], NoneType]:
         """Page.viewport_size
@@ -4558,14 +5695,30 @@ def viewport_size(self) -> typing.Union[typing.Tuple[int, int], NoneType]:
         -------
         Optional[typing.Tuple[int, int]]
         """
-        return mapping.from_maybe_impl(self._impl_obj.viewportSize())
+
+        try:
+            log_api("=> page.viewport_size started")
+            result = mapping.from_maybe_impl(self._impl_obj.viewportSize())
+            log_api("<= page.viewport_size succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.viewport_size failed")
+            raise e
 
     async def bring_to_front(self) -> NoneType:
         """Page.bring_to_front
 
         Brings page to front (activates tab).
         """
-        return mapping.from_maybe_impl(await self._impl_obj.bringToFront())
+
+        try:
+            log_api("=> page.bring_to_front started")
+            result = mapping.from_maybe_impl(await self._impl_obj.bringToFront())
+            log_api("<= page.bring_to_front succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.bring_to_front failed")
+            raise e
 
     async def add_init_script(
         self, source: str = None, path: typing.Union[str, pathlib.Path] = None
@@ -4589,9 +5742,17 @@ async def add_init_script(
         source : Optional[str]
             Script to be evaluated in the page.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.addInitScript(source=source, path=path)
-        )
+
+        try:
+            log_api("=> page.add_init_script started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.addInitScript(source=source, path=path)
+            )
+            log_api("<= page.add_init_script succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.add_init_script failed")
+            raise e
 
     async def route(
         self,
@@ -4622,11 +5783,19 @@ async def route(
         handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any]]
             handler function to route the request.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.route(
-                url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+
+        try:
+            log_api("=> page.route started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.route(
+                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+                )
             )
-        )
+            log_api("<= page.route succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.route failed")
+            raise e
 
     async def unroute(
         self,
@@ -4647,11 +5816,19 @@ async def unroute(
         handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any], NoneType]
             Optional handler function to route the request.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.unroute(
-                url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+
+        try:
+            log_api("=> page.unroute started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.unroute(
+                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+                )
             )
-        )
+            log_api("<= page.unroute succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.unroute failed")
+            raise e
 
     async def screenshot(
         self,
@@ -4691,17 +5868,25 @@ async def screenshot(
         -------
         bytes
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.screenshot(
-                timeout=timeout,
-                type=type,
-                path=path,
-                quality=quality,
-                omitBackground=omit_background,
-                fullPage=full_page,
-                clip=clip,
+
+        try:
+            log_api("=> page.screenshot started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.screenshot(
+                    timeout=timeout,
+                    type=type,
+                    path=path,
+                    quality=quality,
+                    omitBackground=omit_background,
+                    fullPage=full_page,
+                    clip=clip,
+                )
             )
-        )
+            log_api("<= page.screenshot succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.screenshot failed")
+            raise e
 
     async def title(self) -> str:
         """Page.title
@@ -4712,7 +5897,15 @@ async def title(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(await self._impl_obj.title())
+
+        try:
+            log_api("=> page.title started")
+            result = mapping.from_maybe_impl(await self._impl_obj.title())
+            log_api("<= page.title succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.title failed")
+            raise e
 
     async def close(self, run_before_unload: bool = None) -> NoneType:
         """Page.close
@@ -4729,9 +5922,17 @@ async def close(self, run_before_unload: bool = None) -> NoneType:
         run_before_unload : Optional[bool]
             Defaults to `false`. Whether to run the before unload page handlers.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.close(runBeforeUnload=run_before_unload)
-        )
+
+        try:
+            log_api("=> page.close started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.close(runBeforeUnload=run_before_unload)
+            )
+            log_api("<= page.close succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.close failed")
+            raise e
 
     def is_closed(self) -> bool:
         """Page.is_closed
@@ -4742,7 +5943,15 @@ def is_closed(self) -> bool:
         -------
         bool
         """
-        return mapping.from_maybe_impl(self._impl_obj.isClosed())
+
+        try:
+            log_api("=> page.is_closed started")
+            result = mapping.from_maybe_impl(self._impl_obj.isClosed())
+            log_api("<= page.is_closed succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.is_closed failed")
+            raise e
 
     async def click(
         self,
@@ -4793,19 +6002,27 @@ async def click(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.click(
-                selector=selector,
-                modifiers=modifiers,
-                position=position,
-                delay=delay,
-                button=button,
-                clickCount=click_count,
-                timeout=timeout,
-                force=force,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.click started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.click(
+                    selector=selector,
+                    modifiers=modifiers,
+                    position=position,
+                    delay=delay,
+                    button=button,
+                    clickCount=click_count,
+                    timeout=timeout,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= page.click succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.click failed")
+            raise e
 
     async def dblclick(
         self,
@@ -4856,18 +6073,26 @@ async def dblclick(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.dblclick(
-                selector=selector,
-                modifiers=modifiers,
-                position=position,
-                delay=delay,
-                button=button,
-                timeout=timeout,
-                force=force,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.dblclick started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.dblclick(
+                    selector=selector,
+                    modifiers=modifiers,
+                    position=position,
+                    delay=delay,
+                    button=button,
+                    timeout=timeout,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= page.dblclick succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.dblclick failed")
+            raise e
 
     async def tap(
         self,
@@ -4912,16 +6137,24 @@ async def tap(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.tap(
-                selector=selector,
-                modifiers=modifiers,
-                position=position,
-                timeout=timeout,
-                force=force,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.tap started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.tap(
+                    selector=selector,
+                    modifiers=modifiers,
+                    position=position,
+                    timeout=timeout,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= page.tap succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.tap failed")
+            raise e
 
     async def fill(
         self, selector: str, value: str, timeout: int = None, no_wait_after: bool = None
@@ -4946,14 +6179,22 @@ async def fill(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.fill(
-                selector=selector,
-                value=value,
-                timeout=timeout,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.fill started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.fill(
+                    selector=selector,
+                    value=value,
+                    timeout=timeout,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= page.fill succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.fill failed")
+            raise e
 
     async def focus(self, selector: str, timeout: int = None) -> NoneType:
         """Page.focus
@@ -4969,9 +6210,17 @@ async def focus(self, selector: str, timeout: int = None) -> NoneType:
         timeout : Optional[int]
             Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.focus(selector=selector, timeout=timeout)
-        )
+
+        try:
+            log_api("=> page.focus started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.focus(selector=selector, timeout=timeout)
+            )
+            log_api("<= page.focus succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.focus failed")
+            raise e
 
     async def text_content(
         self, selector: str, timeout: int = None
@@ -4991,9 +6240,17 @@ async def text_content(
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.textContent(selector=selector, timeout=timeout)
-        )
+
+        try:
+            log_api("=> page.text_content started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.textContent(selector=selector, timeout=timeout)
+            )
+            log_api("<= page.text_content succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.text_content failed")
+            raise e
 
     async def inner_text(self, selector: str, timeout: int = None) -> str:
         """Page.inner_text
@@ -5011,9 +6268,17 @@ async def inner_text(self, selector: str, timeout: int = None) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.innerText(selector=selector, timeout=timeout)
-        )
+
+        try:
+            log_api("=> page.inner_text started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.innerText(selector=selector, timeout=timeout)
+            )
+            log_api("<= page.inner_text succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.inner_text failed")
+            raise e
 
     async def inner_html(self, selector: str, timeout: int = None) -> str:
         """Page.inner_html
@@ -5031,9 +6296,17 @@ async def inner_html(self, selector: str, timeout: int = None) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.innerHTML(selector=selector, timeout=timeout)
-        )
+
+        try:
+            log_api("=> page.inner_html started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.innerHTML(selector=selector, timeout=timeout)
+            )
+            log_api("<= page.inner_html succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.inner_html failed")
+            raise e
 
     async def get_attribute(
         self, selector: str, name: str, timeout: int = None
@@ -5055,11 +6328,19 @@ async def get_attribute(
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.getAttribute(
-                selector=selector, name=name, timeout=timeout
+
+        try:
+            log_api("=> page.get_attribute started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.getAttribute(
+                    selector=selector, name=name, timeout=timeout
+                )
             )
-        )
+            log_api("<= page.get_attribute succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.get_attribute failed")
+            raise e
 
     async def hover(
         self,
@@ -5098,15 +6379,23 @@ async def hover(
         force : Optional[bool]
             Whether to bypass the actionability checks. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.hover(
-                selector=selector,
-                modifiers=modifiers,
-                position=position,
-                timeout=timeout,
-                force=force,
+
+        try:
+            log_api("=> page.hover started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.hover(
+                    selector=selector,
+                    modifiers=modifiers,
+                    position=position,
+                    timeout=timeout,
+                    force=force,
+                )
             )
-        )
+            log_api("<= page.hover succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.hover failed")
+            raise e
 
     async def select_option(
         self,
@@ -5139,17 +6428,25 @@ async def select_option(
         -------
         List[str]
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.selectOption(
-                selector=selector,
-                value=value,
-                index=index,
-                label=label,
-                element=mapping.to_impl(element),
-                timeout=timeout,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.select_option started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.selectOption(
+                    selector=selector,
+                    value=value,
+                    index=index,
+                    label=label,
+                    element=mapping.to_impl(element),
+                    timeout=timeout,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= page.select_option succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.select_option failed")
+            raise e
 
     async def set_input_files(
         self,
@@ -5178,14 +6475,22 @@ async def set_input_files(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.setInputFiles(
-                selector=selector,
-                files=files,
-                timeout=timeout,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.set_input_files started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.setInputFiles(
+                    selector=selector,
+                    files=files,
+                    timeout=timeout,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= page.set_input_files succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.set_input_files failed")
+            raise e
 
     async def type(
         self,
@@ -5215,15 +6520,23 @@ async def type(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.type(
-                selector=selector,
-                text=text,
-                delay=delay,
-                timeout=timeout,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.type started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.type(
+                    selector=selector,
+                    text=text,
+                    delay=delay,
+                    timeout=timeout,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= page.type succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.type failed")
+            raise e
 
     async def press(
         self,
@@ -5261,15 +6574,23 @@ async def press(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.press(
-                selector=selector,
-                key=key,
-                delay=delay,
-                timeout=timeout,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.press started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.press(
+                    selector=selector,
+                    key=key,
+                    delay=delay,
+                    timeout=timeout,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= page.press succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.press failed")
+            raise e
 
     async def check(
         self,
@@ -5305,14 +6626,22 @@ async def check(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.check(
-                selector=selector,
-                timeout=timeout,
-                force=force,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.check started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.check(
+                    selector=selector,
+                    timeout=timeout,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= page.check succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.check failed")
+            raise e
 
     async def uncheck(
         self,
@@ -5348,14 +6677,22 @@ async def uncheck(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.uncheck(
-                selector=selector,
-                timeout=timeout,
-                force=force,
-                noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.uncheck started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.uncheck(
+                    selector=selector,
+                    timeout=timeout,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                )
             )
-        )
+            log_api("<= page.uncheck succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.uncheck failed")
+            raise e
 
     async def wait_for_timeout(self, timeout: int) -> NoneType:
         """Page.wait_for_timeout
@@ -5370,9 +6707,17 @@ async def wait_for_timeout(self, timeout: int) -> NoneType:
         timeout : int
             A timeout to wait for
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.waitForTimeout(timeout=timeout)
-        )
+
+        try:
+            log_api("=> page.wait_for_timeout started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.waitForTimeout(timeout=timeout)
+            )
+            log_api("<= page.wait_for_timeout succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_timeout failed")
+            raise e
 
     async def wait_for_function(
         self,
@@ -5407,15 +6752,23 @@ async def wait_for_function(
         -------
         JSHandle
         """
-        return mapping.from_impl(
-            await self._impl_obj.waitForFunction(
-                expression=expression,
-                arg=mapping.to_impl(arg),
-                force_expr=force_expr,
-                timeout=timeout,
-                polling=polling,
+
+        try:
+            log_api("=> page.wait_for_function started")
+            result = mapping.from_impl(
+                await self._impl_obj.waitForFunction(
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    force_expr=force_expr,
+                    timeout=timeout,
+                    polling=polling,
+                )
             )
-        )
+            log_api("<= page.wait_for_function succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_function failed")
+            raise e
 
     async def pdf(
         self,
@@ -5517,23 +6870,31 @@ async def pdf(
         -------
         bytes
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.pdf(
-                scale=scale,
-                displayHeaderFooter=display_header_footer,
-                headerTemplate=header_template,
-                footerTemplate=footer_template,
-                printBackground=print_background,
-                landscape=landscape,
-                pageRanges=page_ranges,
-                format=format,
-                width=width,
-                height=height,
-                preferCSSPageSize=prefer_css_page_size,
-                margin=margin,
-                path=path,
+
+        try:
+            log_api("=> page.pdf started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.pdf(
+                    scale=scale,
+                    displayHeaderFooter=display_header_footer,
+                    headerTemplate=header_template,
+                    footerTemplate=footer_template,
+                    printBackground=print_background,
+                    landscape=landscape,
+                    pageRanges=page_ranges,
+                    format=format,
+                    width=width,
+                    height=height,
+                    preferCSSPageSize=prefer_css_page_size,
+                    margin=margin,
+                    path=path,
+                )
             )
-        )
+            log_api("<= page.pdf succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.pdf failed")
+            raise e
 
     def expect_event(
         self,
@@ -5904,9 +7265,17 @@ def set_default_navigation_timeout(self, timeout: int) -> NoneType:
         timeout : int
             Maximum navigation time in milliseconds
         """
-        return mapping.from_maybe_impl(
-            self._impl_obj.setDefaultNavigationTimeout(timeout=timeout)
-        )
+
+        try:
+            log_api("=> browser_context.set_default_navigation_timeout started")
+            result = mapping.from_maybe_impl(
+                self._impl_obj.setDefaultNavigationTimeout(timeout=timeout)
+            )
+            log_api("<= browser_context.set_default_navigation_timeout succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.set_default_navigation_timeout failed")
+            raise e
 
     def set_default_timeout(self, timeout: int) -> NoneType:
         """BrowserContext.set_default_timeout
@@ -5921,9 +7290,17 @@ def set_default_timeout(self, timeout: int) -> NoneType:
         timeout : int
             Maximum time in milliseconds
         """
-        return mapping.from_maybe_impl(
-            self._impl_obj.setDefaultTimeout(timeout=timeout)
-        )
+
+        try:
+            log_api("=> browser_context.set_default_timeout started")
+            result = mapping.from_maybe_impl(
+                self._impl_obj.setDefaultTimeout(timeout=timeout)
+            )
+            log_api("<= browser_context.set_default_timeout succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.set_default_timeout failed")
+            raise e
 
     async def new_page(self) -> "Page":
         """BrowserContext.new_page
@@ -5934,7 +7311,15 @@ async def new_page(self) -> "Page":
         -------
         Page
         """
-        return mapping.from_impl(await self._impl_obj.newPage())
+
+        try:
+            log_api("=> browser_context.new_page started")
+            result = mapping.from_impl(await self._impl_obj.newPage())
+            log_api("<= browser_context.new_page succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.new_page failed")
+            raise e
 
     async def cookies(
         self, urls: typing.Union[str, typing.List[str]] = None
@@ -5953,7 +7338,15 @@ async def cookies(
         -------
         List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]
         """
-        return mapping.from_impl_list(await self._impl_obj.cookies(urls=urls))
+
+        try:
+            log_api("=> browser_context.cookies started")
+            result = mapping.from_impl_list(await self._impl_obj.cookies(urls=urls))
+            log_api("<= browser_context.cookies succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.cookies failed")
+            raise e
 
     async def add_cookies(self, cookies: typing.List["Cookie"]) -> NoneType:
         """BrowserContext.add_cookies
@@ -5965,14 +7358,32 @@ async def add_cookies(self, cookies: typing.List["Cookie"]) -> NoneType:
         ----------
         cookies : List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]
         """
-        return mapping.from_maybe_impl(await self._impl_obj.addCookies(cookies=cookies))
+
+        try:
+            log_api("=> browser_context.add_cookies started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.addCookies(cookies=cookies)
+            )
+            log_api("<= browser_context.add_cookies succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.add_cookies failed")
+            raise e
 
     async def clear_cookies(self) -> NoneType:
         """BrowserContext.clear_cookies
 
         Clears context cookies.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.clearCookies())
+
+        try:
+            log_api("=> browser_context.clear_cookies started")
+            result = mapping.from_maybe_impl(await self._impl_obj.clearCookies())
+            log_api("<= browser_context.clear_cookies succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.clear_cookies failed")
+            raise e
 
     async def grant_permissions(
         self, permissions: typing.List[str], origin: str = None
@@ -6005,18 +7416,34 @@ async def grant_permissions(
         origin : Optional[str]
             The origin to grant permissions to, e.g. "https://example.com".
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.grantPermissions(
-                permissions=permissions, origin=origin
+
+        try:
+            log_api("=> browser_context.grant_permissions started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.grantPermissions(
+                    permissions=permissions, origin=origin
+                )
             )
-        )
+            log_api("<= browser_context.grant_permissions succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.grant_permissions failed")
+            raise e
 
     async def clear_permissions(self) -> NoneType:
         """BrowserContext.clear_permissions
 
         Clears all permission overrides for the browser context.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.clearPermissions())
+
+        try:
+            log_api("=> browser_context.clear_permissions started")
+            result = mapping.from_maybe_impl(await self._impl_obj.clearPermissions())
+            log_api("<= browser_context.clear_permissions succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.clear_permissions failed")
+            raise e
 
     async def set_geolocation(
         self, latitude: float, longitude: float, accuracy: float = None
@@ -6037,14 +7464,30 @@ async def set_geolocation(
         accuracy : Optional[float]
             Non-negative accuracy value. Defaults to `0`.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.setGeolocation(
-                latitude=latitude, longitude=longitude, accuracy=accuracy
+
+        try:
+            log_api("=> browser_context.set_geolocation started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.setGeolocation(
+                    latitude=latitude, longitude=longitude, accuracy=accuracy
+                )
             )
-        )
+            log_api("<= browser_context.set_geolocation succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.set_geolocation failed")
+            raise e
 
     async def reset_geolocation(self) -> NoneType:
-        return mapping.from_maybe_impl(await self._impl_obj.resetGeolocation())
+
+        try:
+            log_api("=> browser_context.reset_geolocation started")
+            result = mapping.from_maybe_impl(await self._impl_obj.resetGeolocation())
+            log_api("<= browser_context.reset_geolocation succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.reset_geolocation failed")
+            raise e
 
     async def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> NoneType:
         """BrowserContext.set_extra_http_headers
@@ -6060,9 +7503,19 @@ async def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> NoneTy
         headers : Dict[str, str]
             An object containing additional HTTP headers to be sent with every request. All header values must be strings.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.setExtraHTTPHeaders(headers=mapping.to_impl(headers))
-        )
+
+        try:
+            log_api("=> browser_context.set_extra_http_headers started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.setExtraHTTPHeaders(
+                    headers=mapping.to_impl(headers)
+                )
+            )
+            log_api("<= browser_context.set_extra_http_headers succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.set_extra_http_headers failed")
+            raise e
 
     async def set_offline(self, offline: bool) -> NoneType:
         """BrowserContext.set_offline
@@ -6072,7 +7525,17 @@ async def set_offline(self, offline: bool) -> NoneType:
         offline : bool
             Whether to emulate network being offline for the browser context.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.setOffline(offline=offline))
+
+        try:
+            log_api("=> browser_context.set_offline started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.setOffline(offline=offline)
+            )
+            log_api("<= browser_context.set_offline succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.set_offline failed")
+            raise e
 
     async def add_init_script(
         self, source: str = None, path: typing.Union[str, pathlib.Path] = None
@@ -6096,9 +7559,17 @@ async def add_init_script(
         source : Optional[str]
             Script to be evaluated in all pages in the browser context.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.addInitScript(source=source, path=path)
-        )
+
+        try:
+            log_api("=> browser_context.add_init_script started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.addInitScript(source=source, path=path)
+            )
+            log_api("<= browser_context.add_init_script succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.add_init_script failed")
+            raise e
 
     async def expose_binding(
         self, name: str, binding: typing.Callable, handle: bool = None
@@ -6123,11 +7594,19 @@ async def expose_binding(
         handle : Optional[bool]
             Whether to pass the argument as a handle, instead of passing by value. When passing a handle, only one argument is supported. When passing by value, multiple arguments are supported.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.exposeBinding(
-                name=name, binding=self._wrap_handler(binding), handle=handle
+
+        try:
+            log_api("=> browser_context.expose_binding started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.exposeBinding(
+                    name=name, binding=self._wrap_handler(binding), handle=handle
+                )
             )
-        )
+            log_api("<= browser_context.expose_binding succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.expose_binding failed")
+            raise e
 
     async def expose_function(self, name: str, binding: typing.Callable) -> NoneType:
         """BrowserContext.expose_function
@@ -6146,11 +7625,19 @@ async def expose_function(self, name: str, binding: typing.Callable) -> NoneType
         binding : Callable
             Callback function that will be called in the Playwright's context.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.exposeFunction(
-                name=name, binding=self._wrap_handler(binding)
+
+        try:
+            log_api("=> browser_context.expose_function started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.exposeFunction(
+                    name=name, binding=self._wrap_handler(binding)
+                )
             )
-        )
+            log_api("<= browser_context.expose_function succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.expose_function failed")
+            raise e
 
     async def route(
         self,
@@ -6178,11 +7665,19 @@ async def route(
         handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any]]
             handler function to route the request.
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.route(
-                url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+
+        try:
+            log_api("=> browser_context.route started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.route(
+                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+                )
             )
-        )
+            log_api("<= browser_context.route succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.route failed")
+            raise e
 
     async def unroute(
         self,
@@ -6204,11 +7699,19 @@ async def unroute(
         handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any], NoneType]
             Optional handler function used to register a routing with browser_context.route(url, handler).
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.unroute(
-                url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+
+        try:
+            log_api("=> browser_context.unroute started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.unroute(
+                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+                )
             )
-        )
+            log_api("<= browser_context.unroute succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.unroute failed")
+            raise e
 
     async def wait_for_event(
         self,
@@ -6230,11 +7733,21 @@ async def wait_for_event(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.waitForEvent(
-                event=event, predicate=self._wrap_handler(predicate), timeout=timeout
+
+        try:
+            log_api("=> browser_context.wait_for_event started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.waitForEvent(
+                    event=event,
+                    predicate=self._wrap_handler(predicate),
+                    timeout=timeout,
+                )
             )
-        )
+            log_api("<= browser_context.wait_for_event succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.wait_for_event failed")
+            raise e
 
     async def close(self) -> NoneType:
         """BrowserContext.close
@@ -6243,7 +7756,15 @@ async def close(self) -> NoneType:
 
         **NOTE** the default browser context cannot be closed.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.close())
+
+        try:
+            log_api("=> browser_context.close started")
+            result = mapping.from_maybe_impl(await self._impl_obj.close())
+            log_api("<= browser_context.close succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.close failed")
+            raise e
 
     async def storage_state(
         self, path: typing.Union[str, pathlib.Path] = None
@@ -6261,7 +7782,15 @@ async def storage_state(
         -------
         {"cookies": Optional[List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]], "origins": Optional[List[Dict]]}
         """
-        return mapping.from_impl(await self._impl_obj.storageState(path=path))
+
+        try:
+            log_api("=> browser_context.storage_state started")
+            result = mapping.from_impl(await self._impl_obj.storageState(path=path))
+            log_api("<= browser_context.storage_state succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.storage_state failed")
+            raise e
 
     def expect_event(
         self,
@@ -6343,9 +7872,17 @@ async def send(self, method: str, params: typing.Dict = None) -> typing.Dict:
         -------
         Dict
         """
-        return mapping.from_maybe_impl(
-            await self._impl_obj.send(method=method, params=mapping.to_impl(params))
-        )
+
+        try:
+            log_api("=> cdp_session.send started")
+            result = mapping.from_maybe_impl(
+                await self._impl_obj.send(method=method, params=mapping.to_impl(params))
+            )
+            log_api("<= cdp_session.send succeded")
+            return result
+        except Exception as e:
+            log_api("<= cdp_session.send failed")
+            raise e
 
     async def detach(self) -> NoneType:
         """CDPSession.detach
@@ -6353,7 +7890,15 @@ async def detach(self) -> NoneType:
         Detaches the CDPSession from the target. Once detached, the CDPSession object won't emit any events and can't be used to
         send messages.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.detach())
+
+        try:
+            log_api("=> cdp_session.detach started")
+            result = mapping.from_maybe_impl(await self._impl_obj.detach())
+            log_api("<= cdp_session.detach succeded")
+            return result
+        except Exception as e:
+            log_api("<= cdp_session.detach failed")
+            raise e
 
 
 mapping.register(CDPSessionImpl, CDPSession)
@@ -6372,7 +7917,15 @@ def background_pages(self) -> typing.List["Page"]:
         -------
         List[Page]
         """
-        return mapping.from_impl_list(self._impl_obj.backgroundPages())
+
+        try:
+            log_api("=> chromium_browser_context.background_pages started")
+            result = mapping.from_impl_list(self._impl_obj.backgroundPages())
+            log_api("<= chromium_browser_context.background_pages succeded")
+            return result
+        except Exception as e:
+            log_api("<= chromium_browser_context.background_pages failed")
+            raise e
 
     def service_workers(self) -> typing.List["Worker"]:
         """ChromiumBrowserContext.service_workers
@@ -6383,7 +7936,15 @@ def service_workers(self) -> typing.List["Worker"]:
         -------
         List[Worker]
         """
-        return mapping.from_impl_list(self._impl_obj.serviceWorkers())
+
+        try:
+            log_api("=> chromium_browser_context.service_workers started")
+            result = mapping.from_impl_list(self._impl_obj.serviceWorkers())
+            log_api("<= chromium_browser_context.service_workers succeded")
+            return result
+        except Exception as e:
+            log_api("<= chromium_browser_context.service_workers failed")
+            raise e
 
     async def new_cdp_session(self, page: "Page") -> "CDPSession":
         """ChromiumBrowserContext.new_cdp_session
@@ -6399,9 +7960,17 @@ async def new_cdp_session(self, page: "Page") -> "CDPSession":
         -------
         CDPSession
         """
-        return mapping.from_impl(
-            await self._impl_obj.newCDPSession(page=page._impl_obj)
-        )
+
+        try:
+            log_api("=> chromium_browser_context.new_cdp_session started")
+            result = mapping.from_impl(
+                await self._impl_obj.newCDPSession(page=page._impl_obj)
+            )
+            log_api("<= chromium_browser_context.new_cdp_session succeded")
+            return result
+        except Exception as e:
+            log_api("<= chromium_browser_context.new_cdp_session failed")
+            raise e
 
 
 mapping.register(ChromiumBrowserContextImpl, ChromiumBrowserContext)
@@ -6444,7 +8013,15 @@ def is_connected(self) -> bool:
         -------
         bool
         """
-        return mapping.from_maybe_impl(self._impl_obj.isConnected())
+
+        try:
+            log_api("=> browser.is_connected started")
+            result = mapping.from_maybe_impl(self._impl_obj.isConnected())
+            log_api("<= browser.is_connected succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser.is_connected failed")
+            raise e
 
     async def new_context(
         self,
@@ -6529,34 +8106,42 @@ async def new_context(
         -------
         BrowserContext
         """
-        return mapping.from_impl(
-            await self._impl_obj.newContext(
-                viewport=viewport,
-                ignoreHTTPSErrors=ignore_https_errors,
-                javaScriptEnabled=java_script_enabled,
-                bypassCSP=bypass_csp,
-                userAgent=user_agent,
-                locale=locale,
-                timezoneId=timezone_id,
-                geolocation=geolocation,
-                permissions=permissions,
-                extraHTTPHeaders=mapping.to_impl(extra_http_headers),
-                offline=offline,
-                httpCredentials=http_credentials,
-                deviceScaleFactor=device_scale_factor,
-                isMobile=is_mobile,
-                hasTouch=has_touch,
-                colorScheme=color_scheme,
-                acceptDownloads=accept_downloads,
-                defaultBrowserType=default_browser_type,
-                proxy=proxy,
-                recordHarPath=record_har_path,
-                recordHarOmitContent=record_har_omit_content,
-                recordVideoDir=record_video_dir,
-                recordVideoSize=record_video_size,
-                storageState=storage_state,
+
+        try:
+            log_api("=> browser.new_context started")
+            result = mapping.from_impl(
+                await self._impl_obj.newContext(
+                    viewport=viewport,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    javaScriptEnabled=java_script_enabled,
+                    bypassCSP=bypass_csp,
+                    userAgent=user_agent,
+                    locale=locale,
+                    timezoneId=timezone_id,
+                    geolocation=geolocation,
+                    permissions=permissions,
+                    extraHTTPHeaders=mapping.to_impl(extra_http_headers),
+                    offline=offline,
+                    httpCredentials=http_credentials,
+                    deviceScaleFactor=device_scale_factor,
+                    isMobile=is_mobile,
+                    hasTouch=has_touch,
+                    colorScheme=color_scheme,
+                    acceptDownloads=accept_downloads,
+                    defaultBrowserType=default_browser_type,
+                    proxy=proxy,
+                    recordHarPath=record_har_path,
+                    recordHarOmitContent=record_har_omit_content,
+                    recordVideoDir=record_video_dir,
+                    recordVideoSize=record_video_size,
+                    storageState=storage_state,
+                )
             )
-        )
+            log_api("<= browser.new_context succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser.new_context failed")
+            raise e
 
     async def new_page(
         self,
@@ -6644,34 +8229,42 @@ async def new_page(
         -------
         Page
         """
-        return mapping.from_impl(
-            await self._impl_obj.newPage(
-                viewport=viewport,
-                ignoreHTTPSErrors=ignore_https_errors,
-                javaScriptEnabled=java_script_enabled,
-                bypassCSP=bypass_csp,
-                userAgent=user_agent,
-                locale=locale,
-                timezoneId=timezone_id,
-                geolocation=geolocation,
-                permissions=permissions,
-                extraHTTPHeaders=mapping.to_impl(extra_http_headers),
-                offline=offline,
-                httpCredentials=http_credentials,
-                deviceScaleFactor=device_scale_factor,
-                isMobile=is_mobile,
-                hasTouch=has_touch,
-                colorScheme=color_scheme,
-                acceptDownloads=accept_downloads,
-                defaultBrowserType=default_browser_type,
-                proxy=proxy,
-                recordHarPath=record_har_path,
-                recordHarOmitContent=record_har_omit_content,
-                recordVideoDir=record_video_dir,
-                recordVideoSize=record_video_size,
-                storageState=storage_state,
+
+        try:
+            log_api("=> browser.new_page started")
+            result = mapping.from_impl(
+                await self._impl_obj.newPage(
+                    viewport=viewport,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    javaScriptEnabled=java_script_enabled,
+                    bypassCSP=bypass_csp,
+                    userAgent=user_agent,
+                    locale=locale,
+                    timezoneId=timezone_id,
+                    geolocation=geolocation,
+                    permissions=permissions,
+                    extraHTTPHeaders=mapping.to_impl(extra_http_headers),
+                    offline=offline,
+                    httpCredentials=http_credentials,
+                    deviceScaleFactor=device_scale_factor,
+                    isMobile=is_mobile,
+                    hasTouch=has_touch,
+                    colorScheme=color_scheme,
+                    acceptDownloads=accept_downloads,
+                    defaultBrowserType=default_browser_type,
+                    proxy=proxy,
+                    recordHarPath=record_har_path,
+                    recordHarOmitContent=record_har_omit_content,
+                    recordVideoDir=record_video_dir,
+                    recordVideoSize=record_video_size,
+                    storageState=storage_state,
+                )
             )
-        )
+            log_api("<= browser.new_page succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser.new_page failed")
+            raise e
 
     async def close(self) -> NoneType:
         """Browser.close
@@ -6682,7 +8275,15 @@ async def close(self) -> NoneType:
         and disconnects from the browser server.
         The Browser object itself is considered to be disposed and cannot be used anymore.
         """
-        return mapping.from_maybe_impl(await self._impl_obj.close())
+
+        try:
+            log_api("=> browser.close started")
+            result = mapping.from_maybe_impl(await self._impl_obj.close())
+            log_api("<= browser.close succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser.close failed")
+            raise e
 
 
 mapping.register(BrowserImpl, Browser)
@@ -6789,25 +8390,33 @@ async def launch(
         -------
         Browser
         """
-        return mapping.from_impl(
-            await self._impl_obj.launch(
-                executablePath=executable_path,
-                args=args,
-                ignoreDefaultArgs=ignore_default_args,
-                handleSIGINT=handle_sigint,
-                handleSIGTERM=handle_sigterm,
-                handleSIGHUP=handle_sighup,
-                timeout=timeout,
-                env=mapping.to_impl(env),
-                headless=headless,
-                devtools=devtools,
-                proxy=proxy,
-                downloadsPath=downloads_path,
-                slowMo=slow_mo,
-                chromiumSandbox=chromium_sandbox,
-                firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
+
+        try:
+            log_api("=> browser_type.launch started")
+            result = mapping.from_impl(
+                await self._impl_obj.launch(
+                    executablePath=executable_path,
+                    args=args,
+                    ignoreDefaultArgs=ignore_default_args,
+                    handleSIGINT=handle_sigint,
+                    handleSIGTERM=handle_sigterm,
+                    handleSIGHUP=handle_sighup,
+                    timeout=timeout,
+                    env=mapping.to_impl(env),
+                    headless=headless,
+                    devtools=devtools,
+                    proxy=proxy,
+                    downloadsPath=downloads_path,
+                    slowMo=slow_mo,
+                    chromiumSandbox=chromium_sandbox,
+                    firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
+                )
             )
-        )
+            log_api("<= browser_type.launch succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_type.launch failed")
+            raise e
 
     async def launch_persistent_context(
         self,
@@ -6932,46 +8541,54 @@ async def launch_persistent_context(
         -------
         BrowserContext
         """
-        return mapping.from_impl(
-            await self._impl_obj.launchPersistentContext(
-                userDataDir=user_data_dir,
-                executablePath=executable_path,
-                args=args,
-                ignoreDefaultArgs=ignore_default_args,
-                handleSIGINT=handle_sigint,
-                handleSIGTERM=handle_sigterm,
-                handleSIGHUP=handle_sighup,
-                timeout=timeout,
-                env=mapping.to_impl(env),
-                headless=headless,
-                devtools=devtools,
-                proxy=proxy,
-                downloadsPath=downloads_path,
-                slowMo=slow_mo,
-                viewport=viewport,
-                ignoreHTTPSErrors=ignore_https_errors,
-                javaScriptEnabled=java_script_enabled,
-                bypassCSP=bypass_csp,
-                userAgent=user_agent,
-                locale=locale,
-                timezoneId=timezone_id,
-                geolocation=geolocation,
-                permissions=permissions,
-                extraHTTPHeaders=mapping.to_impl(extra_http_headers),
-                offline=offline,
-                httpCredentials=http_credentials,
-                deviceScaleFactor=device_scale_factor,
-                isMobile=is_mobile,
-                hasTouch=has_touch,
-                colorScheme=color_scheme,
-                acceptDownloads=accept_downloads,
-                chromiumSandbox=chromium_sandbox,
-                recordHarPath=record_har_path,
-                recordHarOmitContent=record_har_omit_content,
-                recordVideoDir=record_video_dir,
-                recordVideoSize=record_video_size,
+
+        try:
+            log_api("=> browser_type.launch_persistent_context started")
+            result = mapping.from_impl(
+                await self._impl_obj.launchPersistentContext(
+                    userDataDir=user_data_dir,
+                    executablePath=executable_path,
+                    args=args,
+                    ignoreDefaultArgs=ignore_default_args,
+                    handleSIGINT=handle_sigint,
+                    handleSIGTERM=handle_sigterm,
+                    handleSIGHUP=handle_sighup,
+                    timeout=timeout,
+                    env=mapping.to_impl(env),
+                    headless=headless,
+                    devtools=devtools,
+                    proxy=proxy,
+                    downloadsPath=downloads_path,
+                    slowMo=slow_mo,
+                    viewport=viewport,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    javaScriptEnabled=java_script_enabled,
+                    bypassCSP=bypass_csp,
+                    userAgent=user_agent,
+                    locale=locale,
+                    timezoneId=timezone_id,
+                    geolocation=geolocation,
+                    permissions=permissions,
+                    extraHTTPHeaders=mapping.to_impl(extra_http_headers),
+                    offline=offline,
+                    httpCredentials=http_credentials,
+                    deviceScaleFactor=device_scale_factor,
+                    isMobile=is_mobile,
+                    hasTouch=has_touch,
+                    colorScheme=color_scheme,
+                    acceptDownloads=accept_downloads,
+                    chromiumSandbox=chromium_sandbox,
+                    recordHarPath=record_har_path,
+                    recordHarOmitContent=record_har_omit_content,
+                    recordVideoDir=record_video_dir,
+                    recordVideoSize=record_video_size,
+                )
             )
-        )
+            log_api("<= browser_type.launch_persistent_context succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_type.launch_persistent_context failed")
+            raise e
 
 
 mapping.register(BrowserTypeImpl, BrowserType)
@@ -7002,7 +8619,15 @@ def devices(self) -> typing.Dict[str, "DeviceDescriptor"]:
         return mapping.from_impl_dict(self._impl_obj.devices)
 
     def stop(self) -> NoneType:
-        return mapping.from_maybe_impl(self._impl_obj.stop())
+
+        try:
+            log_api("=> playwright.stop started")
+            result = mapping.from_maybe_impl(self._impl_obj.stop())
+            log_api("<= playwright.stop succeded")
+            return result
+        except Exception as e:
+            log_api("<= playwright.stop failed")
+            raise e
 
 
 mapping.register(PlaywrightImpl, Playwright)
diff --git a/playwright/sync_api/_generated.py b/playwright/sync_api/_generated.py
index 03edbb905..25865819a 100644
--- a/playwright/sync_api/_generated.py
+++ b/playwright/sync_api/_generated.py
@@ -50,6 +50,7 @@
 from playwright._impl._input import Mouse as MouseImpl
 from playwright._impl._input import Touchscreen as TouchscreenImpl
 from playwright._impl._js_handle import JSHandle as JSHandleImpl
+from playwright._impl._logger import log_api
 from playwright._impl._network import Request as RequestImpl
 from playwright._impl._network import Response as ResponseImpl
 from playwright._impl._network import Route as RouteImpl
@@ -247,7 +248,15 @@ def response(self) -> typing.Union["Response", NoneType]:
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(self._sync(self._impl_obj.response()))
+
+        try:
+            log_api("=> request.response started")
+            result = mapping.from_impl_nullable(self._sync(self._impl_obj.response()))
+            log_api("<= request.response succeded")
+            return result
+        except Exception as e:
+            log_api("<= request.response failed")
+            raise e
 
 
 mapping.register(RequestImpl, Request)
@@ -350,7 +359,15 @@ def finished(self) -> typing.Union[str, NoneType]:
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.finished()))
+
+        try:
+            log_api("=> response.finished started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.finished()))
+            log_api("<= response.finished succeded")
+            return result
+        except Exception as e:
+            log_api("<= response.finished failed")
+            raise e
 
     def body(self) -> bytes:
         """Response.body
@@ -361,7 +378,15 @@ def body(self) -> bytes:
         -------
         bytes
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.body()))
+
+        try:
+            log_api("=> response.body started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.body()))
+            log_api("<= response.body succeded")
+            return result
+        except Exception as e:
+            log_api("<= response.body failed")
+            raise e
 
     def text(self) -> str:
         """Response.text
@@ -372,7 +397,15 @@ def text(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.text()))
+
+        try:
+            log_api("=> response.text started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.text()))
+            log_api("<= response.text succeded")
+            return result
+        except Exception as e:
+            log_api("<= response.text failed")
+            raise e
 
     def json(self) -> typing.Union[typing.Dict, typing.List]:
         """Response.json
@@ -384,7 +417,15 @@ def json(self) -> typing.Union[typing.Dict, typing.List]:
         -------
         Union[Dict, List]
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.json()))
+
+        try:
+            log_api("=> response.json started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.json()))
+            log_api("<= response.json succeded")
+            return result
+        except Exception as e:
+            log_api("<= response.json failed")
+            raise e
 
 
 mapping.register(ResponseImpl, Response)
@@ -430,9 +471,17 @@ def abort(self, error_code: str = None) -> NoneType:
              - `'timedout'` - An operation timed out.
              - `'failed'` - A generic failure occurred.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.abort(errorCode=error_code))
-        )
+
+        try:
+            log_api("=> route.abort started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.abort(errorCode=error_code))
+            )
+            log_api("<= route.abort succeded")
+            return result
+        except Exception as e:
+            log_api("<= route.abort failed")
+            raise e
 
     def fulfill(
         self,
@@ -461,17 +510,25 @@ def fulfill(
         content_type : Optional[str]
             If set, equals to setting `Content-Type` response header.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.fulfill(
-                    status=status,
-                    headers=mapping.to_impl(headers),
-                    body=body,
-                    path=path,
-                    contentType=content_type,
+
+        try:
+            log_api("=> route.fulfill started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.fulfill(
+                        status=status,
+                        headers=mapping.to_impl(headers),
+                        body=body,
+                        path=path,
+                        contentType=content_type,
+                    )
                 )
             )
-        )
+            log_api("<= route.fulfill succeded")
+            return result
+        except Exception as e:
+            log_api("<= route.fulfill failed")
+            raise e
 
     def continue_(
         self,
@@ -495,16 +552,24 @@ def continue_(
         post_data : Union[str, bytes, NoneType]
             If set changes the post data of request
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.continue_(
-                    url=url,
-                    method=method,
-                    headers=mapping.to_impl(headers),
-                    postData=post_data,
+
+        try:
+            log_api("=> route.continue_ started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.continue_(
+                        url=url,
+                        method=method,
+                        headers=mapping.to_impl(headers),
+                        postData=post_data,
+                    )
                 )
             )
-        )
+            log_api("<= route.continue_ succeded")
+            return result
+        except Exception as e:
+            log_api("<= route.continue_ failed")
+            raise e
 
 
 mapping.register(RouteImpl, Route)
@@ -547,15 +612,23 @@ def wait_for_event(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.waitForEvent(
-                    event=event,
-                    predicate=self._wrap_handler(predicate),
-                    timeout=timeout,
+
+        try:
+            log_api("=> web_socket.wait_for_event started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.waitForEvent(
+                        event=event,
+                        predicate=self._wrap_handler(predicate),
+                        timeout=timeout,
+                    )
                 )
             )
-        )
+            log_api("<= web_socket.wait_for_event succeded")
+            return result
+        except Exception as e:
+            log_api("<= web_socket.wait_for_event failed")
+            raise e
 
     def expect_event(
         self,
@@ -595,7 +668,15 @@ def is_closed(self) -> bool:
         -------
         bool
         """
-        return mapping.from_maybe_impl(self._impl_obj.isClosed())
+
+        try:
+            log_api("=> web_socket.is_closed started")
+            result = mapping.from_maybe_impl(self._impl_obj.isClosed())
+            log_api("<= web_socket.is_closed succeded")
+            return result
+        except Exception as e:
+            log_api("<= web_socket.is_closed failed")
+            raise e
 
 
 mapping.register(WebSocketImpl, WebSocket)
@@ -631,7 +712,15 @@ def down(self, key: str) -> NoneType:
         key : str
             Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.down(key=key)))
+
+        try:
+            log_api("=> keyboard.down started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.down(key=key)))
+            log_api("<= keyboard.down succeded")
+            return result
+        except Exception as e:
+            log_api("<= keyboard.down failed")
+            raise e
 
     def up(self, key: str) -> NoneType:
         """Keyboard.up
@@ -643,7 +732,15 @@ def up(self, key: str) -> NoneType:
         key : str
             Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.up(key=key)))
+
+        try:
+            log_api("=> keyboard.up started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.up(key=key)))
+            log_api("<= keyboard.up succeded")
+            return result
+        except Exception as e:
+            log_api("<= keyboard.up failed")
+            raise e
 
     def insert_text(self, text: str) -> NoneType:
         """Keyboard.insert_text
@@ -657,7 +754,17 @@ def insert_text(self, text: str) -> NoneType:
         text : str
             Sets input to the specified text value.
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.insertText(text=text)))
+
+        try:
+            log_api("=> keyboard.insert_text started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.insertText(text=text))
+            )
+            log_api("<= keyboard.insert_text succeded")
+            return result
+        except Exception as e:
+            log_api("<= keyboard.insert_text failed")
+            raise e
 
     def type(self, text: str, delay: int = None) -> NoneType:
         """Keyboard.type
@@ -674,9 +781,17 @@ def type(self, text: str, delay: int = None) -> NoneType:
         delay : Optional[int]
             Time to wait between key presses in milliseconds. Defaults to 0.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.type(text=text, delay=delay))
-        )
+
+        try:
+            log_api("=> keyboard.type started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.type(text=text, delay=delay))
+            )
+            log_api("<= keyboard.type succeded")
+            return result
+        except Exception as e:
+            log_api("<= keyboard.type failed")
+            raise e
 
     def press(self, key: str, delay: int = None) -> NoneType:
         """Keyboard.press
@@ -701,9 +816,17 @@ def press(self, key: str, delay: int = None) -> NoneType:
         delay : Optional[int]
             Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.press(key=key, delay=delay))
-        )
+
+        try:
+            log_api("=> keyboard.press started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.press(key=key, delay=delay))
+            )
+            log_api("<= keyboard.press succeded")
+            return result
+        except Exception as e:
+            log_api("<= keyboard.press failed")
+            raise e
 
 
 mapping.register(KeyboardImpl, Keyboard)
@@ -725,9 +848,17 @@ def move(self, x: float, y: float, steps: int = None) -> NoneType:
         steps : Optional[int]
             defaults to 1. Sends intermediate `mousemove` events.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.move(x=x, y=y, steps=steps))
-        )
+
+        try:
+            log_api("=> mouse.move started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.move(x=x, y=y, steps=steps))
+            )
+            log_api("<= mouse.move succeded")
+            return result
+        except Exception as e:
+            log_api("<= mouse.move failed")
+            raise e
 
     def down(
         self, button: Literal["left", "middle", "right"] = None, click_count: int = None
@@ -743,9 +874,17 @@ def down(
         click_count : Optional[int]
             defaults to 1. See UIEvent.detail.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.down(button=button, clickCount=click_count))
-        )
+
+        try:
+            log_api("=> mouse.down started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.down(button=button, clickCount=click_count))
+            )
+            log_api("<= mouse.down succeded")
+            return result
+        except Exception as e:
+            log_api("<= mouse.down failed")
+            raise e
 
     def up(
         self, button: Literal["left", "middle", "right"] = None, click_count: int = None
@@ -761,9 +900,17 @@ def up(
         click_count : Optional[int]
             defaults to 1. See UIEvent.detail.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.up(button=button, clickCount=click_count))
-        )
+
+        try:
+            log_api("=> mouse.up started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.up(button=button, clickCount=click_count))
+            )
+            log_api("<= mouse.up succeded")
+            return result
+        except Exception as e:
+            log_api("<= mouse.up failed")
+            raise e
 
     def click(
         self,
@@ -788,13 +935,21 @@ def click(
         click_count : Optional[int]
             defaults to 1. See UIEvent.detail.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.click(
-                    x=x, y=y, delay=delay, button=button, clickCount=click_count
+
+        try:
+            log_api("=> mouse.click started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.click(
+                        x=x, y=y, delay=delay, button=button, clickCount=click_count
+                    )
                 )
             )
-        )
+            log_api("<= mouse.click succeded")
+            return result
+        except Exception as e:
+            log_api("<= mouse.click failed")
+            raise e
 
     def dblclick(
         self,
@@ -816,9 +971,19 @@ def dblclick(
         button : Optional[Literal['left', 'middle', 'right']]
             Defaults to `left`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.dblclick(x=x, y=y, delay=delay, button=button))
-        )
+
+        try:
+            log_api("=> mouse.dblclick started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.dblclick(x=x, y=y, delay=delay, button=button)
+                )
+            )
+            log_api("<= mouse.dblclick succeded")
+            return result
+        except Exception as e:
+            log_api("<= mouse.dblclick failed")
+            raise e
 
 
 mapping.register(MouseImpl, Mouse)
@@ -838,7 +1003,15 @@ def tap(self, x: float, y: float) -> NoneType:
         x : float
         y : float
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.tap(x=x, y=y)))
+
+        try:
+            log_api("=> touchscreen.tap started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.tap(x=x, y=y)))
+            log_api("<= touchscreen.tap succeded")
+            return result
+        except Exception as e:
+            log_api("<= touchscreen.tap failed")
+            raise e
 
 
 mapping.register(TouchscreenImpl, Touchscreen)
@@ -872,15 +1045,23 @@ def evaluate(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.evaluate(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
+
+        try:
+            log_api("=> js_handle.evaluate started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.evaluate(
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                    )
                 )
             )
-        )
+            log_api("<= js_handle.evaluate succeded")
+            return result
+        except Exception as e:
+            log_api("<= js_handle.evaluate failed")
+            raise e
 
     def evaluate_handle(
         self, expression: str, arg: typing.Any = None, force_expr: bool = None
@@ -908,15 +1089,23 @@ def evaluate_handle(
         -------
         JSHandle
         """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.evaluateHandle(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
+
+        try:
+            log_api("=> js_handle.evaluate_handle started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.evaluateHandle(
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                    )
                 )
             )
-        )
+            log_api("<= js_handle.evaluate_handle succeded")
+            return result
+        except Exception as e:
+            log_api("<= js_handle.evaluate_handle failed")
+            raise e
 
     def get_property(self, property_name: str) -> "JSHandle":
         """JSHandle.get_property
@@ -932,9 +1121,17 @@ def get_property(self, property_name: str) -> "JSHandle":
         -------
         JSHandle
         """
-        return mapping.from_impl(
-            self._sync(self._impl_obj.getProperty(propertyName=property_name))
-        )
+
+        try:
+            log_api("=> js_handle.get_property started")
+            result = mapping.from_impl(
+                self._sync(self._impl_obj.getProperty(propertyName=property_name))
+            )
+            log_api("<= js_handle.get_property succeded")
+            return result
+        except Exception as e:
+            log_api("<= js_handle.get_property failed")
+            raise e
 
     def get_properties(self) -> typing.Dict[str, "JSHandle"]:
         """JSHandle.get_properties
@@ -945,7 +1142,15 @@ def get_properties(self) -> typing.Dict[str, "JSHandle"]:
         -------
         Dict[str, JSHandle]
         """
-        return mapping.from_impl_dict(self._sync(self._impl_obj.getProperties()))
+
+        try:
+            log_api("=> js_handle.get_properties started")
+            result = mapping.from_impl_dict(self._sync(self._impl_obj.getProperties()))
+            log_api("<= js_handle.get_properties succeded")
+            return result
+        except Exception as e:
+            log_api("<= js_handle.get_properties failed")
+            raise e
 
     def as_element(self) -> typing.Union["ElementHandle", NoneType]:
         """JSHandle.as_element
@@ -956,14 +1161,30 @@ def as_element(self) -> typing.Union["ElementHandle", NoneType]:
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(self._impl_obj.asElement())
+
+        try:
+            log_api("=> js_handle.as_element started")
+            result = mapping.from_impl_nullable(self._impl_obj.asElement())
+            log_api("<= js_handle.as_element succeded")
+            return result
+        except Exception as e:
+            log_api("<= js_handle.as_element failed")
+            raise e
 
     def dispose(self) -> NoneType:
         """JSHandle.dispose
 
         The `jsHandle.dispose` method stops referencing the element handle.
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.dispose()))
+
+        try:
+            log_api("=> js_handle.dispose started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.dispose()))
+            log_api("<= js_handle.dispose succeded")
+            return result
+        except Exception as e:
+            log_api("<= js_handle.dispose failed")
+            raise e
 
     def json_value(self) -> typing.Any:
         """JSHandle.json_value
@@ -979,7 +1200,15 @@ def json_value(self) -> typing.Any:
         -------
         Any
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.jsonValue()))
+
+        try:
+            log_api("=> js_handle.json_value started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.jsonValue()))
+            log_api("<= js_handle.json_value succeded")
+            return result
+        except Exception as e:
+            log_api("<= js_handle.json_value failed")
+            raise e
 
 
 mapping.register(JSHandleImpl, JSHandle)
@@ -996,7 +1225,15 @@ def to_string(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(self._impl_obj.toString())
+
+        try:
+            log_api("=> element_handle.to_string started")
+            result = mapping.from_maybe_impl(self._impl_obj.toString())
+            log_api("<= element_handle.to_string succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.to_string failed")
+            raise e
 
     def as_element(self) -> typing.Union["ElementHandle", NoneType]:
         """ElementHandle.as_element
@@ -1007,7 +1244,15 @@ def as_element(self) -> typing.Union["ElementHandle", NoneType]:
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(self._impl_obj.asElement())
+
+        try:
+            log_api("=> element_handle.as_element started")
+            result = mapping.from_impl_nullable(self._impl_obj.asElement())
+            log_api("<= element_handle.as_element succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.as_element failed")
+            raise e
 
     def owner_frame(self) -> typing.Union["Frame", NoneType]:
         """ElementHandle.owner_frame
@@ -1018,7 +1263,15 @@ def owner_frame(self) -> typing.Union["Frame", NoneType]:
         -------
         Optional[Frame]
         """
-        return mapping.from_impl_nullable(self._sync(self._impl_obj.ownerFrame()))
+
+        try:
+            log_api("=> element_handle.owner_frame started")
+            result = mapping.from_impl_nullable(self._sync(self._impl_obj.ownerFrame()))
+            log_api("<= element_handle.owner_frame succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.owner_frame failed")
+            raise e
 
     def content_frame(self) -> typing.Union["Frame", NoneType]:
         """ElementHandle.content_frame
@@ -1029,7 +1282,17 @@ def content_frame(self) -> typing.Union["Frame", NoneType]:
         -------
         Optional[Frame]
         """
-        return mapping.from_impl_nullable(self._sync(self._impl_obj.contentFrame()))
+
+        try:
+            log_api("=> element_handle.content_frame started")
+            result = mapping.from_impl_nullable(
+                self._sync(self._impl_obj.contentFrame())
+            )
+            log_api("<= element_handle.content_frame succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.content_frame failed")
+            raise e
 
     def get_attribute(self, name: str) -> typing.Union[str, NoneType]:
         """ElementHandle.get_attribute
@@ -1045,9 +1308,17 @@ def get_attribute(self, name: str) -> typing.Union[str, NoneType]:
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.getAttribute(name=name))
-        )
+
+        try:
+            log_api("=> element_handle.get_attribute started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.getAttribute(name=name))
+            )
+            log_api("<= element_handle.get_attribute succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.get_attribute failed")
+            raise e
 
     def text_content(self) -> typing.Union[str, NoneType]:
         """ElementHandle.text_content
@@ -1058,7 +1329,15 @@ def text_content(self) -> typing.Union[str, NoneType]:
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.textContent()))
+
+        try:
+            log_api("=> element_handle.text_content started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.textContent()))
+            log_api("<= element_handle.text_content succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.text_content failed")
+            raise e
 
     def inner_text(self) -> str:
         """ElementHandle.inner_text
@@ -1069,7 +1348,15 @@ def inner_text(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.innerText()))
+
+        try:
+            log_api("=> element_handle.inner_text started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.innerText()))
+            log_api("<= element_handle.inner_text succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.inner_text failed")
+            raise e
 
     def inner_html(self) -> str:
         """ElementHandle.inner_html
@@ -1080,7 +1367,15 @@ def inner_html(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.innerHTML()))
+
+        try:
+            log_api("=> element_handle.inner_html started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.innerHTML()))
+            log_api("<= element_handle.inner_html succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.inner_html failed")
+            raise e
 
     def dispatch_event(self, type: str, event_init: typing.Dict = None) -> NoneType:
         """ElementHandle.dispatch_event
@@ -1109,13 +1404,21 @@ def dispatch_event(self, type: str, event_init: typing.Dict = None) -> NoneType:
         event_init : Optional[Dict]
             Optional event-specific initialization properties.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.dispatchEvent(
-                    type=type, eventInit=mapping.to_impl(event_init)
+
+        try:
+            log_api("=> element_handle.dispatch_event started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.dispatchEvent(
+                        type=type, eventInit=mapping.to_impl(event_init)
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.dispatch_event succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.dispatch_event failed")
+            raise e
 
     def scroll_into_view_if_needed(self, timeout: int = None) -> NoneType:
         """ElementHandle.scroll_into_view_if_needed
@@ -1131,9 +1434,17 @@ def scroll_into_view_if_needed(self, timeout: int = None) -> NoneType:
         timeout : Optional[int]
             Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.scrollIntoViewIfNeeded(timeout=timeout))
-        )
+
+        try:
+            log_api("=> element_handle.scroll_into_view_if_needed started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.scrollIntoViewIfNeeded(timeout=timeout))
+            )
+            log_api("<= element_handle.scroll_into_view_if_needed succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.scroll_into_view_if_needed failed")
+            raise e
 
     def hover(
         self,
@@ -1168,13 +1479,24 @@ def hover(
         force : Optional[bool]
             Whether to bypass the actionability checks. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.hover(
-                    modifiers=modifiers, position=position, timeout=timeout, force=force
+
+        try:
+            log_api("=> element_handle.hover started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.hover(
+                        modifiers=modifiers,
+                        position=position,
+                        timeout=timeout,
+                        force=force,
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.hover succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.hover failed")
+            raise e
 
     def click(
         self,
@@ -1221,20 +1543,28 @@ def click(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.click(
-                    modifiers=modifiers,
-                    position=position,
-                    delay=delay,
-                    button=button,
-                    clickCount=click_count,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> element_handle.click started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.click(
+                        modifiers=modifiers,
+                        position=position,
+                        delay=delay,
+                        button=button,
+                        clickCount=click_count,
+                        timeout=timeout,
+                        force=force,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.click succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.click failed")
+            raise e
 
     def dblclick(
         self,
@@ -1280,19 +1610,27 @@ def dblclick(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.dblclick(
-                    modifiers=modifiers,
-                    position=position,
-                    delay=delay,
-                    button=button,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> element_handle.dblclick started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.dblclick(
+                        modifiers=modifiers,
+                        position=position,
+                        delay=delay,
+                        button=button,
+                        timeout=timeout,
+                        force=force,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.dblclick succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.dblclick failed")
+            raise e
 
     def select_option(
         self,
@@ -1320,18 +1658,26 @@ def select_option(
         -------
         List[str]
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.selectOption(
-                    value=value,
-                    index=index,
-                    label=label,
-                    element=mapping.to_impl(element),
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> element_handle.select_option started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.selectOption(
+                        value=value,
+                        index=index,
+                        label=label,
+                        element=mapping.to_impl(element),
+                        timeout=timeout,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.select_option succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.select_option failed")
+            raise e
 
     def tap(
         self,
@@ -1371,17 +1717,25 @@ def tap(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.tap(
-                    modifiers=modifiers,
-                    position=position,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> element_handle.tap started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.tap(
+                        modifiers=modifiers,
+                        position=position,
+                        timeout=timeout,
+                        force=force,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.tap succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.tap failed")
+            raise e
 
     def fill(
         self, value: str, timeout: int = None, no_wait_after: bool = None
@@ -1401,13 +1755,21 @@ def fill(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.fill(
-                    value=value, timeout=timeout, noWaitAfter=no_wait_after
+
+        try:
+            log_api("=> element_handle.fill started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.fill(
+                        value=value, timeout=timeout, noWaitAfter=no_wait_after
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.fill succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.fill failed")
+            raise e
 
     def select_text(self, timeout: int = None) -> NoneType:
         """ElementHandle.select_text
@@ -1420,9 +1782,17 @@ def select_text(self, timeout: int = None) -> NoneType:
         timeout : Optional[int]
             Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.selectText(timeout=timeout))
-        )
+
+        try:
+            log_api("=> element_handle.select_text started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.selectText(timeout=timeout))
+            )
+            log_api("<= element_handle.select_text succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.select_text failed")
+            raise e
 
     def set_input_files(
         self,
@@ -1453,20 +1823,36 @@ def set_input_files(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.setInputFiles(
-                    files=files, timeout=timeout, noWaitAfter=no_wait_after
+
+        try:
+            log_api("=> element_handle.set_input_files started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.setInputFiles(
+                        files=files, timeout=timeout, noWaitAfter=no_wait_after
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.set_input_files succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.set_input_files failed")
+            raise e
 
     def focus(self) -> NoneType:
         """ElementHandle.focus
 
         Calls focus on the element.
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.focus()))
+
+        try:
+            log_api("=> element_handle.focus started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.focus()))
+            log_api("<= element_handle.focus succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.focus failed")
+            raise e
 
     def type(
         self,
@@ -1492,13 +1878,24 @@ def type(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.type(
-                    text=text, delay=delay, timeout=timeout, noWaitAfter=no_wait_after
+
+        try:
+            log_api("=> element_handle.type started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.type(
+                        text=text,
+                        delay=delay,
+                        timeout=timeout,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.type succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.type failed")
+            raise e
 
     def press(
         self,
@@ -1533,13 +1930,21 @@ def press(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.press(
-                    key=key, delay=delay, timeout=timeout, noWaitAfter=no_wait_after
+
+        try:
+            log_api("=> element_handle.press started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.press(
+                        key=key, delay=delay, timeout=timeout, noWaitAfter=no_wait_after
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.press succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.press failed")
+            raise e
 
     def check(
         self, timeout: int = None, force: bool = None, no_wait_after: bool = None
@@ -1568,13 +1973,21 @@ def check(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.check(
-                    timeout=timeout, force=force, noWaitAfter=no_wait_after
+
+        try:
+            log_api("=> element_handle.check started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.check(
+                        timeout=timeout, force=force, noWaitAfter=no_wait_after
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.check succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.check failed")
+            raise e
 
     def uncheck(
         self, timeout: int = None, force: bool = None, no_wait_after: bool = None
@@ -1603,13 +2016,21 @@ def uncheck(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.uncheck(
-                    timeout=timeout, force=force, noWaitAfter=no_wait_after
+
+        try:
+            log_api("=> element_handle.uncheck started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.uncheck(
+                        timeout=timeout, force=force, noWaitAfter=no_wait_after
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.uncheck succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.uncheck failed")
+            raise e
 
     def bounding_box(self) -> typing.Union["FloatRect", NoneType]:
         """ElementHandle.bounding_box
@@ -1628,7 +2049,17 @@ def bounding_box(self) -> typing.Union["FloatRect", NoneType]:
         -------
         Optional[{"x": float, "y": float, "width": float, "height": float}]
         """
-        return mapping.from_impl_nullable(self._sync(self._impl_obj.boundingBox()))
+
+        try:
+            log_api("=> element_handle.bounding_box started")
+            result = mapping.from_impl_nullable(
+                self._sync(self._impl_obj.boundingBox())
+            )
+            log_api("<= element_handle.bounding_box succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.bounding_box failed")
+            raise e
 
     def screenshot(
         self,
@@ -1661,17 +2092,25 @@ def screenshot(
         -------
         bytes
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.screenshot(
-                    timeout=timeout,
-                    type=type,
-                    path=path,
-                    quality=quality,
-                    omitBackground=omit_background,
+
+        try:
+            log_api("=> element_handle.screenshot started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.screenshot(
+                        timeout=timeout,
+                        type=type,
+                        path=path,
+                        quality=quality,
+                        omitBackground=omit_background,
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.screenshot succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.screenshot failed")
+            raise e
 
     def query_selector(self, selector: str) -> typing.Union["ElementHandle", NoneType]:
         """ElementHandle.query_selector
@@ -1689,9 +2128,17 @@ def query_selector(self, selector: str) -> typing.Union["ElementHandle", NoneTyp
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(
-            self._sync(self._impl_obj.querySelector(selector=selector))
-        )
+
+        try:
+            log_api("=> element_handle.query_selector started")
+            result = mapping.from_impl_nullable(
+                self._sync(self._impl_obj.querySelector(selector=selector))
+            )
+            log_api("<= element_handle.query_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.query_selector failed")
+            raise e
 
     def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
         """ElementHandle.query_selector_all
@@ -1709,9 +2156,17 @@ def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
         -------
         List[ElementHandle]
         """
-        return mapping.from_impl_list(
-            self._sync(self._impl_obj.querySelectorAll(selector=selector))
-        )
+
+        try:
+            log_api("=> element_handle.query_selector_all started")
+            result = mapping.from_impl_list(
+                self._sync(self._impl_obj.querySelectorAll(selector=selector))
+            )
+            log_api("<= element_handle.query_selector_all succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.query_selector_all failed")
+            raise e
 
     def eval_on_selector(
         self,
@@ -1744,16 +2199,24 @@ def eval_on_selector(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.evalOnSelector(
-                    selector=selector,
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
+
+        try:
+            log_api("=> element_handle.eval_on_selector started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.evalOnSelector(
+                        selector=selector,
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.eval_on_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.eval_on_selector failed")
+            raise e
 
     def eval_on_selector_all(
         self,
@@ -1792,16 +2255,24 @@ def eval_on_selector_all(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.evalOnSelectorAll(
-                    selector=selector,
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
+
+        try:
+            log_api("=> element_handle.eval_on_selector_all started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.evalOnSelectorAll(
+                        selector=selector,
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.eval_on_selector_all succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.eval_on_selector_all failed")
+            raise e
 
     def wait_for_element_state(
         self,
@@ -1829,9 +2300,19 @@ def wait_for_element_state(
         timeout : Optional[int]
             Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.waitForElementState(state=state, timeout=timeout))
-        )
+
+        try:
+            log_api("=> element_handle.wait_for_element_state started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.waitForElementState(state=state, timeout=timeout)
+                )
+            )
+            log_api("<= element_handle.wait_for_element_state succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.wait_for_element_state failed")
+            raise e
 
     def wait_for_selector(
         self,
@@ -1867,13 +2348,21 @@ def wait_for_selector(
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(
-            self._sync(
-                self._impl_obj.waitForSelector(
-                    selector=selector, state=state, timeout=timeout
+
+        try:
+            log_api("=> element_handle.wait_for_selector started")
+            result = mapping.from_impl_nullable(
+                self._sync(
+                    self._impl_obj.waitForSelector(
+                        selector=selector, state=state, timeout=timeout
+                    )
                 )
             )
-        )
+            log_api("<= element_handle.wait_for_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= element_handle.wait_for_selector failed")
+            raise e
 
 
 mapping.register(ElementHandleImpl, ElementHandle)
@@ -1908,13 +2397,21 @@ def snapshot(
         -------
         Optional[Dict]
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.snapshot(
-                    interestingOnly=interesting_only, root=mapping.to_impl(root)
+
+        try:
+            log_api("=> accessibility.snapshot started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.snapshot(
+                        interestingOnly=interesting_only, root=mapping.to_impl(root)
+                    )
                 )
             )
-        )
+            log_api("<= accessibility.snapshot succeded")
+            return result
+        except Exception as e:
+            log_api("<= accessibility.snapshot failed")
+            raise e
 
 
 mapping.register(AccessibilityImpl, Accessibility)
@@ -1982,13 +2479,21 @@ def set_files(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.setFiles(
-                    files=files, timeout=timeout, noWaitAfter=no_wait_after
+
+        try:
+            log_api("=> file_chooser.set_files started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.setFiles(
+                        files=files, timeout=timeout, noWaitAfter=no_wait_after
+                    )
                 )
             )
-        )
+            log_api("<= file_chooser.set_files succeded")
+            return result
+        except Exception as e:
+            log_api("<= file_chooser.set_files failed")
+            raise e
 
 
 mapping.register(FileChooserImpl, FileChooser)
@@ -2106,13 +2611,21 @@ def goto(
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(
-            self._sync(
-                self._impl_obj.goto(
-                    url=url, timeout=timeout, waitUntil=wait_until, referer=referer
+
+        try:
+            log_api("=> frame.goto started")
+            result = mapping.from_impl_nullable(
+                self._sync(
+                    self._impl_obj.goto(
+                        url=url, timeout=timeout, waitUntil=wait_until, referer=referer
+                    )
                 )
             )
-        )
+            log_api("<= frame.goto succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.goto failed")
+            raise e
 
     def wait_for_navigation(
         self,
@@ -2146,13 +2659,23 @@ def wait_for_navigation(
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(
-            self._sync(
-                self._impl_obj.waitForNavigation(
-                    url=self._wrap_handler(url), waitUntil=wait_until, timeout=timeout
+
+        try:
+            log_api("=> frame.wait_for_navigation started")
+            result = mapping.from_impl_nullable(
+                self._sync(
+                    self._impl_obj.waitForNavigation(
+                        url=self._wrap_handler(url),
+                        waitUntil=wait_until,
+                        timeout=timeout,
+                    )
                 )
             )
-        )
+            log_api("<= frame.wait_for_navigation succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.wait_for_navigation failed")
+            raise e
 
     def wait_for_load_state(
         self,
@@ -2175,9 +2698,19 @@ def wait_for_load_state(
         timeout : Optional[int]
             Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.waitForLoadState(state=state, timeout=timeout))
-        )
+
+        try:
+            log_api("=> frame.wait_for_load_state started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.waitForLoadState(state=state, timeout=timeout)
+                )
+            )
+            log_api("<= frame.wait_for_load_state succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.wait_for_load_state failed")
+            raise e
 
     def frame_element(self) -> "ElementHandle":
         """Frame.frame_element
@@ -2190,7 +2723,15 @@ def frame_element(self) -> "ElementHandle":
         -------
         ElementHandle
         """
-        return mapping.from_impl(self._sync(self._impl_obj.frameElement()))
+
+        try:
+            log_api("=> frame.frame_element started")
+            result = mapping.from_impl(self._sync(self._impl_obj.frameElement()))
+            log_api("<= frame.frame_element succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.frame_element failed")
+            raise e
 
     def evaluate(
         self, expression: str, arg: typing.Any = None, force_expr: bool = None
@@ -2219,15 +2760,23 @@ def evaluate(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.evaluate(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
+
+        try:
+            log_api("=> frame.evaluate started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.evaluate(
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                    )
                 )
             )
-        )
+            log_api("<= frame.evaluate succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.evaluate failed")
+            raise e
 
     def evaluate_handle(
         self, expression: str, arg: typing.Any = None, force_expr: bool = None
@@ -2255,15 +2804,23 @@ def evaluate_handle(
         -------
         JSHandle
         """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.evaluateHandle(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
+
+        try:
+            log_api("=> frame.evaluate_handle started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.evaluateHandle(
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                    )
                 )
             )
-        )
+            log_api("<= frame.evaluate_handle succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.evaluate_handle failed")
+            raise e
 
     def query_selector(self, selector: str) -> typing.Union["ElementHandle", NoneType]:
         """Frame.query_selector
@@ -2282,9 +2839,17 @@ def query_selector(self, selector: str) -> typing.Union["ElementHandle", NoneTyp
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(
-            self._sync(self._impl_obj.querySelector(selector=selector))
-        )
+
+        try:
+            log_api("=> frame.query_selector started")
+            result = mapping.from_impl_nullable(
+                self._sync(self._impl_obj.querySelector(selector=selector))
+            )
+            log_api("<= frame.query_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.query_selector failed")
+            raise e
 
     def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
         """Frame.query_selector_all
@@ -2303,9 +2868,17 @@ def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
         -------
         List[ElementHandle]
         """
-        return mapping.from_impl_list(
-            self._sync(self._impl_obj.querySelectorAll(selector=selector))
-        )
+
+        try:
+            log_api("=> frame.query_selector_all started")
+            result = mapping.from_impl_list(
+                self._sync(self._impl_obj.querySelectorAll(selector=selector))
+            )
+            log_api("<= frame.query_selector_all succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.query_selector_all failed")
+            raise e
 
     def wait_for_selector(
         self,
@@ -2339,13 +2912,21 @@ def wait_for_selector(
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(
-            self._sync(
-                self._impl_obj.waitForSelector(
-                    selector=selector, timeout=timeout, state=state
+
+        try:
+            log_api("=> frame.wait_for_selector started")
+            result = mapping.from_impl_nullable(
+                self._sync(
+                    self._impl_obj.waitForSelector(
+                        selector=selector, timeout=timeout, state=state
+                    )
                 )
             )
-        )
+            log_api("<= frame.wait_for_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.wait_for_selector failed")
+            raise e
 
     def dispatch_event(
         self,
@@ -2384,16 +2965,24 @@ def dispatch_event(
         timeout : Optional[int]
             Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.dispatchEvent(
-                    selector=selector,
-                    type=type,
-                    eventInit=mapping.to_impl(event_init),
-                    timeout=timeout,
+
+        try:
+            log_api("=> frame.dispatch_event started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.dispatchEvent(
+                        selector=selector,
+                        type=type,
+                        eventInit=mapping.to_impl(event_init),
+                        timeout=timeout,
+                    )
                 )
             )
-        )
+            log_api("<= frame.dispatch_event succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.dispatch_event failed")
+            raise e
 
     def eval_on_selector(
         self,
@@ -2426,16 +3015,24 @@ def eval_on_selector(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.evalOnSelector(
-                    selector=selector,
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
+
+        try:
+            log_api("=> frame.eval_on_selector started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.evalOnSelector(
+                        selector=selector,
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                    )
                 )
             )
-        )
+            log_api("<= frame.eval_on_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.eval_on_selector failed")
+            raise e
 
     def eval_on_selector_all(
         self,
@@ -2467,16 +3064,24 @@ def eval_on_selector_all(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.evalOnSelectorAll(
-                    selector=selector,
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
+
+        try:
+            log_api("=> frame.eval_on_selector_all started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.evalOnSelectorAll(
+                        selector=selector,
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                    )
                 )
             )
-        )
+            log_api("<= frame.eval_on_selector_all succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.eval_on_selector_all failed")
+            raise e
 
     def content(self) -> str:
         """Frame.content
@@ -2487,7 +3092,15 @@ def content(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.content()))
+
+        try:
+            log_api("=> frame.content started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.content()))
+            log_api("<= frame.content succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.content failed")
+            raise e
 
     def set_content(
         self,
@@ -2509,13 +3122,21 @@ def set_content(
              - `'load'` - consider operation to be finished when the `load` event is fired.
              - `'networkidle'` - consider operation to be finished when there are no network connections for at least `500` ms.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.setContent(
-                    html=html, timeout=timeout, waitUntil=wait_until
+
+        try:
+            log_api("=> frame.set_content started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.setContent(
+                        html=html, timeout=timeout, waitUntil=wait_until
+                    )
                 )
             )
-        )
+            log_api("<= frame.set_content succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.set_content failed")
+            raise e
 
     def is_detached(self) -> bool:
         """Frame.is_detached
@@ -2526,7 +3147,15 @@ def is_detached(self) -> bool:
         -------
         bool
         """
-        return mapping.from_maybe_impl(self._impl_obj.isDetached())
+
+        try:
+            log_api("=> frame.is_detached started")
+            result = mapping.from_maybe_impl(self._impl_obj.isDetached())
+            log_api("<= frame.is_detached succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.is_detached failed")
+            raise e
 
     def add_script_tag(
         self,
@@ -2555,13 +3184,21 @@ def add_script_tag(
         -------
         ElementHandle
         """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.addScriptTag(
-                    url=url, path=path, content=content, type=type
+
+        try:
+            log_api("=> frame.add_script_tag started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.addScriptTag(
+                        url=url, path=path, content=content, type=type
+                    )
                 )
             )
-        )
+            log_api("<= frame.add_script_tag succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.add_script_tag failed")
+            raise e
 
     def add_style_tag(
         self,
@@ -2588,9 +3225,19 @@ def add_style_tag(
         -------
         ElementHandle
         """
-        return mapping.from_impl(
-            self._sync(self._impl_obj.addStyleTag(url=url, path=path, content=content))
-        )
+
+        try:
+            log_api("=> frame.add_style_tag started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.addStyleTag(url=url, path=path, content=content)
+                )
+            )
+            log_api("<= frame.add_style_tag succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.add_style_tag failed")
+            raise e
 
     def click(
         self,
@@ -2640,21 +3287,29 @@ def click(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.click(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    delay=delay,
-                    button=button,
-                    clickCount=click_count,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.click started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.click(
+                        selector=selector,
+                        modifiers=modifiers,
+                        position=position,
+                        delay=delay,
+                        button=button,
+                        clickCount=click_count,
+                        timeout=timeout,
+                        force=force,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= frame.click succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.click failed")
+            raise e
 
     def dblclick(
         self,
@@ -2703,20 +3358,28 @@ def dblclick(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.dblclick(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    delay=delay,
-                    button=button,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.dblclick started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.dblclick(
+                        selector=selector,
+                        modifiers=modifiers,
+                        position=position,
+                        delay=delay,
+                        button=button,
+                        timeout=timeout,
+                        force=force,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= frame.dblclick succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.dblclick failed")
+            raise e
 
     def tap(
         self,
@@ -2759,18 +3422,26 @@ def tap(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.tap(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.tap started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.tap(
+                        selector=selector,
+                        modifiers=modifiers,
+                        position=position,
+                        timeout=timeout,
+                        force=force,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= frame.tap succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.tap failed")
+            raise e
 
     def fill(
         self, selector: str, value: str, timeout: int = None, no_wait_after: bool = None
@@ -2794,16 +3465,24 @@ def fill(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.fill(
-                    selector=selector,
-                    value=value,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.fill started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.fill(
+                        selector=selector,
+                        value=value,
+                        timeout=timeout,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= frame.fill succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.fill failed")
+            raise e
 
     def focus(self, selector: str, timeout: int = None) -> NoneType:
         """Frame.focus
@@ -2818,9 +3497,17 @@ def focus(self, selector: str, timeout: int = None) -> NoneType:
         timeout : Optional[int]
             Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.focus(selector=selector, timeout=timeout))
-        )
+
+        try:
+            log_api("=> frame.focus started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.focus(selector=selector, timeout=timeout))
+            )
+            log_api("<= frame.focus succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.focus failed")
+            raise e
 
     def text_content(
         self, selector: str, timeout: int = None
@@ -2840,9 +3527,19 @@ def text_content(
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.textContent(selector=selector, timeout=timeout))
-        )
+
+        try:
+            log_api("=> frame.text_content started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.textContent(selector=selector, timeout=timeout)
+                )
+            )
+            log_api("<= frame.text_content succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.text_content failed")
+            raise e
 
     def inner_text(self, selector: str, timeout: int = None) -> str:
         """Frame.inner_text
@@ -2860,9 +3557,17 @@ def inner_text(self, selector: str, timeout: int = None) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.innerText(selector=selector, timeout=timeout))
-        )
+
+        try:
+            log_api("=> frame.inner_text started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.innerText(selector=selector, timeout=timeout))
+            )
+            log_api("<= frame.inner_text succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.inner_text failed")
+            raise e
 
     def inner_html(self, selector: str, timeout: int = None) -> str:
         """Frame.inner_html
@@ -2880,9 +3585,17 @@ def inner_html(self, selector: str, timeout: int = None) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.innerHTML(selector=selector, timeout=timeout))
-        )
+
+        try:
+            log_api("=> frame.inner_html started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.innerHTML(selector=selector, timeout=timeout))
+            )
+            log_api("<= frame.inner_html succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.inner_html failed")
+            raise e
 
     def get_attribute(
         self, selector: str, name: str, timeout: int = None
@@ -2904,13 +3617,21 @@ def get_attribute(
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.getAttribute(
-                    selector=selector, name=name, timeout=timeout
+
+        try:
+            log_api("=> frame.get_attribute started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.getAttribute(
+                        selector=selector, name=name, timeout=timeout
+                    )
                 )
             )
-        )
+            log_api("<= frame.get_attribute succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.get_attribute failed")
+            raise e
 
     def hover(
         self,
@@ -2948,17 +3669,25 @@ def hover(
         force : Optional[bool]
             Whether to bypass the actionability checks. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.hover(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    timeout=timeout,
-                    force=force,
+
+        try:
+            log_api("=> frame.hover started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.hover(
+                        selector=selector,
+                        modifiers=modifiers,
+                        position=position,
+                        timeout=timeout,
+                        force=force,
+                    )
                 )
             )
-        )
+            log_api("<= frame.hover succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.hover failed")
+            raise e
 
     def select_option(
         self,
@@ -2989,19 +3718,27 @@ def select_option(
         -------
         List[str]
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.selectOption(
-                    selector=selector,
-                    value=value,
-                    index=index,
-                    label=label,
-                    element=mapping.to_impl(element),
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.select_option started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.selectOption(
+                        selector=selector,
+                        value=value,
+                        index=index,
+                        label=label,
+                        element=mapping.to_impl(element),
+                        timeout=timeout,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= frame.select_option succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.select_option failed")
+            raise e
 
     def set_input_files(
         self,
@@ -3035,16 +3772,24 @@ def set_input_files(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.setInputFiles(
-                    selector=selector,
-                    files=files,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.set_input_files started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.setInputFiles(
+                        selector=selector,
+                        files=files,
+                        timeout=timeout,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= frame.set_input_files succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.set_input_files failed")
+            raise e
 
     def type(
         self,
@@ -3073,17 +3818,25 @@ def type(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.type(
-                    selector=selector,
-                    text=text,
-                    delay=delay,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.type started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.type(
+                        selector=selector,
+                        text=text,
+                        delay=delay,
+                        timeout=timeout,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= frame.type succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.type failed")
+            raise e
 
     def press(
         self,
@@ -3120,17 +3873,25 @@ def press(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.press(
-                    selector=selector,
-                    key=key,
-                    delay=delay,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.press started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.press(
+                        selector=selector,
+                        key=key,
+                        delay=delay,
+                        timeout=timeout,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= frame.press succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.press failed")
+            raise e
 
     def check(
         self,
@@ -3165,16 +3926,24 @@ def check(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.check(
-                    selector=selector,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.check started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.check(
+                        selector=selector,
+                        timeout=timeout,
+                        force=force,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= frame.check succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.check failed")
+            raise e
 
     def uncheck(
         self,
@@ -3209,16 +3978,24 @@ def uncheck(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.uncheck(
-                    selector=selector,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> frame.uncheck started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.uncheck(
+                        selector=selector,
+                        timeout=timeout,
+                        force=force,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= frame.uncheck succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.uncheck failed")
+            raise e
 
     def wait_for_timeout(self, timeout: int) -> NoneType:
         """Frame.wait_for_timeout
@@ -3232,9 +4009,17 @@ def wait_for_timeout(self, timeout: int) -> NoneType:
         timeout : int
             A timeout to wait for
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.waitForTimeout(timeout=timeout))
-        )
+
+        try:
+            log_api("=> frame.wait_for_timeout started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.waitForTimeout(timeout=timeout))
+            )
+            log_api("<= frame.wait_for_timeout succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.wait_for_timeout failed")
+            raise e
 
     def wait_for_function(
         self,
@@ -3268,17 +4053,25 @@ def wait_for_function(
         -------
         JSHandle
         """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.waitForFunction(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                    timeout=timeout,
-                    polling=polling,
+
+        try:
+            log_api("=> frame.wait_for_function started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.waitForFunction(
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                        timeout=timeout,
+                        polling=polling,
+                    )
                 )
             )
-        )
+            log_api("<= frame.wait_for_function succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.wait_for_function failed")
+            raise e
 
     def title(self) -> str:
         """Frame.title
@@ -3289,7 +4082,15 @@ def title(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.title()))
+
+        try:
+            log_api("=> frame.title started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.title()))
+            log_api("<= frame.title succeded")
+            return result
+        except Exception as e:
+            log_api("<= frame.title failed")
+            raise e
 
     def expect_load_state(
         self,
@@ -3391,15 +4192,23 @@ def evaluate(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.evaluate(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
+
+        try:
+            log_api("=> worker.evaluate started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.evaluate(
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                    )
                 )
             )
-        )
+            log_api("<= worker.evaluate succeded")
+            return result
+        except Exception as e:
+            log_api("<= worker.evaluate failed")
+            raise e
 
     def evaluate_handle(
         self, expression: str, arg: typing.Any = None, force_expr: bool = None
@@ -3425,15 +4234,23 @@ def evaluate_handle(
         -------
         JSHandle
         """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.evaluateHandle(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
+
+        try:
+            log_api("=> worker.evaluate_handle started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.evaluateHandle(
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                    )
                 )
             )
-        )
+            log_api("<= worker.evaluate_handle succeded")
+            return result
+        except Exception as e:
+            log_api("<= worker.evaluate_handle failed")
+            raise e
 
 
 mapping.register(WorkerImpl, Worker)
@@ -3463,13 +4280,24 @@ def register(
         content_script : Optional[bool]
             Whether to run this selector engine in isolated JavaScript environment. This environment has access to the same DOM, but not any JavaScript objects from the frame's scripts. Defaults to `false`. Note that running as a content script is not guaranteed when this engine is used together with other registered engines.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.register(
-                    name=name, source=source, path=path, contentScript=content_script
+
+        try:
+            log_api("=> selectors.register started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.register(
+                        name=name,
+                        source=source,
+                        path=path,
+                        contentScript=content_script,
+                    )
                 )
             )
-        )
+            log_api("<= selectors.register succeded")
+            return result
+        except Exception as e:
+            log_api("<= selectors.register failed")
+            raise e
 
 
 mapping.register(SelectorsImpl, Selectors)
@@ -3577,16 +4405,32 @@ def accept(self, prompt_text: str = None) -> NoneType:
         prompt_text : Optional[str]
             A text to enter in prompt. Does not cause any effects if the dialog's `type` is not prompt. Optional.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.accept(promptText=prompt_text))
-        )
+
+        try:
+            log_api("=> dialog.accept started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.accept(promptText=prompt_text))
+            )
+            log_api("<= dialog.accept succeded")
+            return result
+        except Exception as e:
+            log_api("<= dialog.accept failed")
+            raise e
 
     def dismiss(self) -> NoneType:
         """Dialog.dismiss
 
         Returns when the dialog has been dismissed.
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.dismiss()))
+
+        try:
+            log_api("=> dialog.dismiss started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.dismiss()))
+            log_api("<= dialog.dismiss succeded")
+            return result
+        except Exception as e:
+            log_api("<= dialog.dismiss failed")
+            raise e
 
 
 mapping.register(DialogImpl, Dialog)
@@ -3628,7 +4472,15 @@ def delete(self) -> NoneType:
 
         Deletes the downloaded file.
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.delete()))
+
+        try:
+            log_api("=> download.delete started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.delete()))
+            log_api("<= download.delete succeded")
+            return result
+        except Exception as e:
+            log_api("<= download.delete failed")
+            raise e
 
     def failure(self) -> typing.Union[str, NoneType]:
         """Download.failure
@@ -3639,7 +4491,15 @@ def failure(self) -> typing.Union[str, NoneType]:
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.failure()))
+
+        try:
+            log_api("=> download.failure started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.failure()))
+            log_api("<= download.failure succeded")
+            return result
+        except Exception as e:
+            log_api("<= download.failure failed")
+            raise e
 
     def path(self) -> typing.Union[str, NoneType]:
         """Download.path
@@ -3650,7 +4510,15 @@ def path(self) -> typing.Union[str, NoneType]:
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.path()))
+
+        try:
+            log_api("=> download.path started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.path()))
+            log_api("<= download.path succeded")
+            return result
+        except Exception as e:
+            log_api("<= download.path failed")
+            raise e
 
     def save_as(self, path: typing.Union[str, pathlib.Path]) -> NoneType:
         """Download.save_as
@@ -3662,7 +4530,17 @@ def save_as(self, path: typing.Union[str, pathlib.Path]) -> NoneType:
         path : Union[str, pathlib.Path]
             Path where the download should be saved.
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.saveAs(path=path)))
+
+        try:
+            log_api("=> download.save_as started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.saveAs(path=path))
+            )
+            log_api("<= download.save_as succeded")
+            return result
+        except Exception as e:
+            log_api("<= download.save_as failed")
+            raise e
 
 
 mapping.register(DownloadImpl, Download)
@@ -3682,7 +4560,15 @@ def path(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.path()))
+
+        try:
+            log_api("=> video.path started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.path()))
+            log_api("<= video.path succeded")
+            return result
+        except Exception as e:
+            log_api("<= video.path failed")
+            raise e
 
 
 mapping.register(VideoImpl, Video)
@@ -3693,9 +4579,17 @@ def __init__(self, obj: BindingCallImpl):
         super().__init__(obj)
 
     def call(self, func: typing.Callable) -> NoneType:
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.call(func=self._wrap_handler(func)))
-        )
+
+        try:
+            log_api("=> binding_call.call started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.call(func=self._wrap_handler(func)))
+            )
+            log_api("<= binding_call.call succeded")
+            return result
+        except Exception as e:
+            log_api("<= binding_call.call failed")
+            raise e
 
 
 mapping.register(BindingCallImpl, BindingCall)
@@ -3830,7 +4724,15 @@ def opener(self) -> typing.Union["Page", NoneType]:
         -------
         Optional[Page]
         """
-        return mapping.from_impl_nullable(self._sync(self._impl_obj.opener()))
+
+        try:
+            log_api("=> page.opener started")
+            result = mapping.from_impl_nullable(self._sync(self._impl_obj.opener()))
+            log_api("<= page.opener succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.opener failed")
+            raise e
 
     def frame(
         self,
@@ -3852,9 +4754,17 @@ def frame(
         -------
         Optional[Frame]
         """
-        return mapping.from_impl_nullable(
-            self._impl_obj.frame(name=name, url=self._wrap_handler(url))
-        )
+
+        try:
+            log_api("=> page.frame started")
+            result = mapping.from_impl_nullable(
+                self._impl_obj.frame(name=name, url=self._wrap_handler(url))
+            )
+            log_api("<= page.frame succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.frame failed")
+            raise e
 
     def set_default_navigation_timeout(self, timeout: int) -> NoneType:
         """Page.set_default_navigation_timeout
@@ -3876,9 +4786,17 @@ def set_default_navigation_timeout(self, timeout: int) -> NoneType:
         timeout : int
             Maximum navigation time in milliseconds
         """
-        return mapping.from_maybe_impl(
-            self._impl_obj.setDefaultNavigationTimeout(timeout=timeout)
-        )
+
+        try:
+            log_api("=> page.set_default_navigation_timeout started")
+            result = mapping.from_maybe_impl(
+                self._impl_obj.setDefaultNavigationTimeout(timeout=timeout)
+            )
+            log_api("<= page.set_default_navigation_timeout succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.set_default_navigation_timeout failed")
+            raise e
 
     def set_default_timeout(self, timeout: int) -> NoneType:
         """Page.set_default_timeout
@@ -3892,9 +4810,17 @@ def set_default_timeout(self, timeout: int) -> NoneType:
         timeout : int
             Maximum time in milliseconds
         """
-        return mapping.from_maybe_impl(
-            self._impl_obj.setDefaultTimeout(timeout=timeout)
-        )
+
+        try:
+            log_api("=> page.set_default_timeout started")
+            result = mapping.from_maybe_impl(
+                self._impl_obj.setDefaultTimeout(timeout=timeout)
+            )
+            log_api("<= page.set_default_timeout succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.set_default_timeout failed")
+            raise e
 
     def query_selector(self, selector: str) -> typing.Union["ElementHandle", NoneType]:
         """Page.query_selector
@@ -3912,9 +4838,17 @@ def query_selector(self, selector: str) -> typing.Union["ElementHandle", NoneTyp
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(
-            self._sync(self._impl_obj.querySelector(selector=selector))
-        )
+
+        try:
+            log_api("=> page.query_selector started")
+            result = mapping.from_impl_nullable(
+                self._sync(self._impl_obj.querySelector(selector=selector))
+            )
+            log_api("<= page.query_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.query_selector failed")
+            raise e
 
     def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
         """Page.query_selector_all
@@ -3932,9 +4866,17 @@ def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
         -------
         List[ElementHandle]
         """
-        return mapping.from_impl_list(
-            self._sync(self._impl_obj.querySelectorAll(selector=selector))
-        )
+
+        try:
+            log_api("=> page.query_selector_all started")
+            result = mapping.from_impl_list(
+                self._sync(self._impl_obj.querySelectorAll(selector=selector))
+            )
+            log_api("<= page.query_selector_all succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.query_selector_all failed")
+            raise e
 
     def wait_for_selector(
         self,
@@ -3968,13 +4910,21 @@ def wait_for_selector(
         -------
         Optional[ElementHandle]
         """
-        return mapping.from_impl_nullable(
-            self._sync(
-                self._impl_obj.waitForSelector(
-                    selector=selector, timeout=timeout, state=state
+
+        try:
+            log_api("=> page.wait_for_selector started")
+            result = mapping.from_impl_nullable(
+                self._sync(
+                    self._impl_obj.waitForSelector(
+                        selector=selector, timeout=timeout, state=state
+                    )
                 )
             )
-        )
+            log_api("<= page.wait_for_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_selector failed")
+            raise e
 
     def dispatch_event(
         self,
@@ -4013,16 +4963,24 @@ def dispatch_event(
         timeout : Optional[int]
             Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.dispatchEvent(
-                    selector=selector,
-                    type=type,
-                    eventInit=mapping.to_impl(event_init),
-                    timeout=timeout,
+
+        try:
+            log_api("=> page.dispatch_event started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.dispatchEvent(
+                        selector=selector,
+                        type=type,
+                        eventInit=mapping.to_impl(event_init),
+                        timeout=timeout,
+                    )
                 )
             )
-        )
+            log_api("<= page.dispatch_event succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.dispatch_event failed")
+            raise e
 
     def evaluate(
         self, expression: str, arg: typing.Any = None, force_expr: bool = None
@@ -4053,15 +5011,23 @@ def evaluate(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.evaluate(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
+
+        try:
+            log_api("=> page.evaluate started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.evaluate(
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                    )
                 )
             )
-        )
+            log_api("<= page.evaluate succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.evaluate failed")
+            raise e
 
     def evaluate_handle(
         self, expression: str, arg: typing.Any = None, force_expr: bool = None
@@ -4089,15 +5055,23 @@ def evaluate_handle(
         -------
         JSHandle
         """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.evaluateHandle(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
+
+        try:
+            log_api("=> page.evaluate_handle started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.evaluateHandle(
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                    )
                 )
             )
-        )
+            log_api("<= page.evaluate_handle succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.evaluate_handle failed")
+            raise e
 
     def eval_on_selector(
         self,
@@ -4129,16 +5103,24 @@ def eval_on_selector(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.evalOnSelector(
-                    selector=selector,
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
+
+        try:
+            log_api("=> page.eval_on_selector started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.evalOnSelector(
+                        selector=selector,
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                    )
                 )
             )
-        )
+            log_api("<= page.eval_on_selector succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.eval_on_selector failed")
+            raise e
 
     def eval_on_selector_all(
         self,
@@ -4169,16 +5151,24 @@ def eval_on_selector_all(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.evalOnSelectorAll(
-                    selector=selector,
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
+
+        try:
+            log_api("=> page.eval_on_selector_all started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.evalOnSelectorAll(
+                        selector=selector,
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                    )
                 )
             )
-        )
+            log_api("<= page.eval_on_selector_all succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.eval_on_selector_all failed")
+            raise e
 
     def add_script_tag(
         self,
@@ -4208,13 +5198,21 @@ def add_script_tag(
         -------
         ElementHandle
         """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.addScriptTag(
-                    url=url, path=path, content=content, type=type
+
+        try:
+            log_api("=> page.add_script_tag started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.addScriptTag(
+                        url=url, path=path, content=content, type=type
+                    )
                 )
             )
-        )
+            log_api("<= page.add_script_tag succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.add_script_tag failed")
+            raise e
 
     def add_style_tag(
         self,
@@ -4241,9 +5239,19 @@ def add_style_tag(
         -------
         ElementHandle
         """
-        return mapping.from_impl(
-            self._sync(self._impl_obj.addStyleTag(url=url, path=path, content=content))
-        )
+
+        try:
+            log_api("=> page.add_style_tag started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.addStyleTag(url=url, path=path, content=content)
+                )
+            )
+            log_api("<= page.add_style_tag succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.add_style_tag failed")
+            raise e
 
     def expose_function(self, name: str, binding: typing.Callable) -> NoneType:
         """Page.expose_function
@@ -4267,13 +5275,21 @@ def expose_function(self, name: str, binding: typing.Callable) -> NoneType:
         binding : Callable
             Callback function which will be called in Playwright's context.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.exposeFunction(
-                    name=name, binding=self._wrap_handler(binding)
+
+        try:
+            log_api("=> page.expose_function started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.exposeFunction(
+                        name=name, binding=self._wrap_handler(binding)
+                    )
                 )
             )
-        )
+            log_api("<= page.expose_function succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.expose_function failed")
+            raise e
 
     def expose_binding(
         self, name: str, binding: typing.Callable, handle: bool = None
@@ -4301,13 +5317,21 @@ def expose_binding(
         handle : Optional[bool]
             Whether to pass the argument as a handle, instead of passing by value. When passing a handle, only one argument is supported. When passing by value, multiple arguments are supported.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.exposeBinding(
-                    name=name, binding=self._wrap_handler(binding), handle=handle
+
+        try:
+            log_api("=> page.expose_binding started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.exposeBinding(
+                        name=name, binding=self._wrap_handler(binding), handle=handle
+                    )
                 )
             )
-        )
+            log_api("<= page.expose_binding succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.expose_binding failed")
+            raise e
 
     def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> NoneType:
         """Page.set_extra_http_headers
@@ -4321,11 +5345,19 @@ def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> NoneType:
         headers : Dict[str, str]
             An object containing additional HTTP headers to be sent with every request. All header values must be strings.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.setExtraHTTPHeaders(headers=mapping.to_impl(headers))
+
+        try:
+            log_api("=> page.set_extra_http_headers started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.setExtraHTTPHeaders(headers=mapping.to_impl(headers))
+                )
             )
-        )
+            log_api("<= page.set_extra_http_headers succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.set_extra_http_headers failed")
+            raise e
 
     def content(self) -> str:
         """Page.content
@@ -4336,7 +5368,15 @@ def content(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.content()))
+
+        try:
+            log_api("=> page.content started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.content()))
+            log_api("<= page.content succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.content failed")
+            raise e
 
     def set_content(
         self,
@@ -4358,13 +5398,21 @@ def set_content(
              - `'load'` - consider operation to be finished when the `load` event is fired.
              - `'networkidle'` - consider operation to be finished when there are no network connections for at least `500` ms.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.setContent(
-                    html=html, timeout=timeout, waitUntil=wait_until
+
+        try:
+            log_api("=> page.set_content started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.setContent(
+                        html=html, timeout=timeout, waitUntil=wait_until
+                    )
                 )
             )
-        )
+            log_api("<= page.set_content succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.set_content failed")
+            raise e
 
     def goto(
         self,
@@ -4414,13 +5462,21 @@ def goto(
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(
-            self._sync(
-                self._impl_obj.goto(
-                    url=url, timeout=timeout, waitUntil=wait_until, referer=referer
+
+        try:
+            log_api("=> page.goto started")
+            result = mapping.from_impl_nullable(
+                self._sync(
+                    self._impl_obj.goto(
+                        url=url, timeout=timeout, waitUntil=wait_until, referer=referer
+                    )
                 )
             )
-        )
+            log_api("<= page.goto succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.goto failed")
+            raise e
 
     def reload(
         self,
@@ -4446,9 +5502,17 @@ def reload(
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(
-            self._sync(self._impl_obj.reload(timeout=timeout, waitUntil=wait_until))
-        )
+
+        try:
+            log_api("=> page.reload started")
+            result = mapping.from_impl_nullable(
+                self._sync(self._impl_obj.reload(timeout=timeout, waitUntil=wait_until))
+            )
+            log_api("<= page.reload succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.reload failed")
+            raise e
 
     def wait_for_load_state(
         self,
@@ -4472,9 +5536,19 @@ def wait_for_load_state(
         timeout : Optional[int]
             Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.waitForLoadState(state=state, timeout=timeout))
-        )
+
+        try:
+            log_api("=> page.wait_for_load_state started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.waitForLoadState(state=state, timeout=timeout)
+                )
+            )
+            log_api("<= page.wait_for_load_state succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_load_state failed")
+            raise e
 
     def wait_for_navigation(
         self,
@@ -4510,13 +5584,23 @@ def wait_for_navigation(
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(
-            self._sync(
-                self._impl_obj.waitForNavigation(
-                    url=self._wrap_handler(url), waitUntil=wait_until, timeout=timeout
+
+        try:
+            log_api("=> page.wait_for_navigation started")
+            result = mapping.from_impl_nullable(
+                self._sync(
+                    self._impl_obj.waitForNavigation(
+                        url=self._wrap_handler(url),
+                        waitUntil=wait_until,
+                        timeout=timeout,
+                    )
                 )
             )
-        )
+            log_api("<= page.wait_for_navigation succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_navigation failed")
+            raise e
 
     def wait_for_request(
         self,
@@ -4539,15 +5623,23 @@ def wait_for_request(
         -------
         Request
         """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.waitForRequest(
-                    url=self._wrap_handler(url),
-                    predicate=self._wrap_handler(predicate),
-                    timeout=timeout,
+
+        try:
+            log_api("=> page.wait_for_request started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.waitForRequest(
+                        url=self._wrap_handler(url),
+                        predicate=self._wrap_handler(predicate),
+                        timeout=timeout,
+                    )
                 )
             )
-        )
+            log_api("<= page.wait_for_request succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_request failed")
+            raise e
 
     def wait_for_response(
         self,
@@ -4570,15 +5662,23 @@ def wait_for_response(
         -------
         Response
         """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.waitForResponse(
-                    url=self._wrap_handler(url),
-                    predicate=self._wrap_handler(predicate),
-                    timeout=timeout,
+
+        try:
+            log_api("=> page.wait_for_response started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.waitForResponse(
+                        url=self._wrap_handler(url),
+                        predicate=self._wrap_handler(predicate),
+                        timeout=timeout,
+                    )
                 )
             )
-        )
+            log_api("<= page.wait_for_response succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_response failed")
+            raise e
 
     def wait_for_event(
         self,
@@ -4601,15 +5701,23 @@ def wait_for_event(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.waitForEvent(
-                    event=event,
-                    predicate=self._wrap_handler(predicate),
-                    timeout=timeout,
+
+        try:
+            log_api("=> page.wait_for_event started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.waitForEvent(
+                        event=event,
+                        predicate=self._wrap_handler(predicate),
+                        timeout=timeout,
+                    )
                 )
             )
-        )
+            log_api("<= page.wait_for_event succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_event failed")
+            raise e
 
     def go_back(
         self,
@@ -4636,9 +5744,17 @@ def go_back(
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(
-            self._sync(self._impl_obj.goBack(timeout=timeout, waitUntil=wait_until))
-        )
+
+        try:
+            log_api("=> page.go_back started")
+            result = mapping.from_impl_nullable(
+                self._sync(self._impl_obj.goBack(timeout=timeout, waitUntil=wait_until))
+            )
+            log_api("<= page.go_back succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.go_back failed")
+            raise e
 
     def go_forward(
         self,
@@ -4665,9 +5781,19 @@ def go_forward(
         -------
         Optional[Response]
         """
-        return mapping.from_impl_nullable(
-            self._sync(self._impl_obj.goForward(timeout=timeout, waitUntil=wait_until))
-        )
+
+        try:
+            log_api("=> page.go_forward started")
+            result = mapping.from_impl_nullable(
+                self._sync(
+                    self._impl_obj.goForward(timeout=timeout, waitUntil=wait_until)
+                )
+            )
+            log_api("<= page.go_forward succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.go_forward failed")
+            raise e
 
     def emulate_media(
         self,
@@ -4684,11 +5810,19 @@ def emulate_media(
         color_scheme : Optional[Literal['dark', 'light', 'no-preference']]
             Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. Passing `null` disables color scheme emulation. Omitting `colorScheme` or passing `undefined` does not change the emulated value.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.emulateMedia(media=media, colorScheme=color_scheme)
+
+        try:
+            log_api("=> page.emulate_media started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.emulateMedia(media=media, colorScheme=color_scheme)
+                )
             )
-        )
+            log_api("<= page.emulate_media succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.emulate_media failed")
+            raise e
 
     def set_viewport_size(self, width: int, height: int) -> NoneType:
         """Page.set_viewport_size
@@ -4705,9 +5839,17 @@ def set_viewport_size(self, width: int, height: int) -> NoneType:
         height : int
             page height in pixels. **required**
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.setViewportSize(width=width, height=height))
-        )
+
+        try:
+            log_api("=> page.set_viewport_size started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.setViewportSize(width=width, height=height))
+            )
+            log_api("<= page.set_viewport_size succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.set_viewport_size failed")
+            raise e
 
     def viewport_size(self) -> typing.Union[typing.Tuple[int, int], NoneType]:
         """Page.viewport_size
@@ -4716,14 +5858,30 @@ def viewport_size(self) -> typing.Union[typing.Tuple[int, int], NoneType]:
         -------
         Optional[typing.Tuple[int, int]]
         """
-        return mapping.from_maybe_impl(self._impl_obj.viewportSize())
+
+        try:
+            log_api("=> page.viewport_size started")
+            result = mapping.from_maybe_impl(self._impl_obj.viewportSize())
+            log_api("<= page.viewport_size succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.viewport_size failed")
+            raise e
 
     def bring_to_front(self) -> NoneType:
         """Page.bring_to_front
 
         Brings page to front (activates tab).
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.bringToFront()))
+
+        try:
+            log_api("=> page.bring_to_front started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.bringToFront()))
+            log_api("<= page.bring_to_front succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.bring_to_front failed")
+            raise e
 
     def add_init_script(
         self, source: str = None, path: typing.Union[str, pathlib.Path] = None
@@ -4747,9 +5905,17 @@ def add_init_script(
         source : Optional[str]
             Script to be evaluated in the page.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.addInitScript(source=source, path=path))
-        )
+
+        try:
+            log_api("=> page.add_init_script started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.addInitScript(source=source, path=path))
+            )
+            log_api("<= page.add_init_script succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.add_init_script failed")
+            raise e
 
     def route(
         self,
@@ -4780,13 +5946,21 @@ def route(
         handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any]]
             handler function to route the request.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.route(
-                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+
+        try:
+            log_api("=> page.route started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.route(
+                        url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+                    )
                 )
             )
-        )
+            log_api("<= page.route succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.route failed")
+            raise e
 
     def unroute(
         self,
@@ -4807,13 +5981,21 @@ def unroute(
         handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any], NoneType]
             Optional handler function to route the request.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.unroute(
-                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+
+        try:
+            log_api("=> page.unroute started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.unroute(
+                        url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+                    )
                 )
             )
-        )
+            log_api("<= page.unroute succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.unroute failed")
+            raise e
 
     def screenshot(
         self,
@@ -4853,19 +6035,27 @@ def screenshot(
         -------
         bytes
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.screenshot(
-                    timeout=timeout,
-                    type=type,
-                    path=path,
-                    quality=quality,
-                    omitBackground=omit_background,
-                    fullPage=full_page,
-                    clip=clip,
+
+        try:
+            log_api("=> page.screenshot started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.screenshot(
+                        timeout=timeout,
+                        type=type,
+                        path=path,
+                        quality=quality,
+                        omitBackground=omit_background,
+                        fullPage=full_page,
+                        clip=clip,
+                    )
                 )
             )
-        )
+            log_api("<= page.screenshot succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.screenshot failed")
+            raise e
 
     def title(self) -> str:
         """Page.title
@@ -4876,7 +6066,15 @@ def title(self) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.title()))
+
+        try:
+            log_api("=> page.title started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.title()))
+            log_api("<= page.title succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.title failed")
+            raise e
 
     def close(self, run_before_unload: bool = None) -> NoneType:
         """Page.close
@@ -4893,9 +6091,17 @@ def close(self, run_before_unload: bool = None) -> NoneType:
         run_before_unload : Optional[bool]
             Defaults to `false`. Whether to run the before unload page handlers.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.close(runBeforeUnload=run_before_unload))
-        )
+
+        try:
+            log_api("=> page.close started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.close(runBeforeUnload=run_before_unload))
+            )
+            log_api("<= page.close succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.close failed")
+            raise e
 
     def is_closed(self) -> bool:
         """Page.is_closed
@@ -4906,7 +6112,15 @@ def is_closed(self) -> bool:
         -------
         bool
         """
-        return mapping.from_maybe_impl(self._impl_obj.isClosed())
+
+        try:
+            log_api("=> page.is_closed started")
+            result = mapping.from_maybe_impl(self._impl_obj.isClosed())
+            log_api("<= page.is_closed succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.is_closed failed")
+            raise e
 
     def click(
         self,
@@ -4957,21 +6171,29 @@ def click(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.click(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    delay=delay,
-                    button=button,
-                    clickCount=click_count,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.click started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.click(
+                        selector=selector,
+                        modifiers=modifiers,
+                        position=position,
+                        delay=delay,
+                        button=button,
+                        clickCount=click_count,
+                        timeout=timeout,
+                        force=force,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= page.click succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.click failed")
+            raise e
 
     def dblclick(
         self,
@@ -5022,20 +6244,28 @@ def dblclick(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.dblclick(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    delay=delay,
-                    button=button,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.dblclick started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.dblclick(
+                        selector=selector,
+                        modifiers=modifiers,
+                        position=position,
+                        delay=delay,
+                        button=button,
+                        timeout=timeout,
+                        force=force,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= page.dblclick succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.dblclick failed")
+            raise e
 
     def tap(
         self,
@@ -5080,18 +6310,26 @@ def tap(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.tap(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.tap started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.tap(
+                        selector=selector,
+                        modifiers=modifiers,
+                        position=position,
+                        timeout=timeout,
+                        force=force,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= page.tap succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.tap failed")
+            raise e
 
     def fill(
         self, selector: str, value: str, timeout: int = None, no_wait_after: bool = None
@@ -5116,16 +6354,24 @@ def fill(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.fill(
-                    selector=selector,
-                    value=value,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.fill started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.fill(
+                        selector=selector,
+                        value=value,
+                        timeout=timeout,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= page.fill succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.fill failed")
+            raise e
 
     def focus(self, selector: str, timeout: int = None) -> NoneType:
         """Page.focus
@@ -5141,9 +6387,17 @@ def focus(self, selector: str, timeout: int = None) -> NoneType:
         timeout : Optional[int]
             Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.focus(selector=selector, timeout=timeout))
-        )
+
+        try:
+            log_api("=> page.focus started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.focus(selector=selector, timeout=timeout))
+            )
+            log_api("<= page.focus succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.focus failed")
+            raise e
 
     def text_content(
         self, selector: str, timeout: int = None
@@ -5163,9 +6417,19 @@ def text_content(
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.textContent(selector=selector, timeout=timeout))
-        )
+
+        try:
+            log_api("=> page.text_content started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.textContent(selector=selector, timeout=timeout)
+                )
+            )
+            log_api("<= page.text_content succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.text_content failed")
+            raise e
 
     def inner_text(self, selector: str, timeout: int = None) -> str:
         """Page.inner_text
@@ -5183,9 +6447,17 @@ def inner_text(self, selector: str, timeout: int = None) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.innerText(selector=selector, timeout=timeout))
-        )
+
+        try:
+            log_api("=> page.inner_text started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.innerText(selector=selector, timeout=timeout))
+            )
+            log_api("<= page.inner_text succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.inner_text failed")
+            raise e
 
     def inner_html(self, selector: str, timeout: int = None) -> str:
         """Page.inner_html
@@ -5203,9 +6475,17 @@ def inner_html(self, selector: str, timeout: int = None) -> str:
         -------
         str
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.innerHTML(selector=selector, timeout=timeout))
-        )
+
+        try:
+            log_api("=> page.inner_html started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.innerHTML(selector=selector, timeout=timeout))
+            )
+            log_api("<= page.inner_html succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.inner_html failed")
+            raise e
 
     def get_attribute(
         self, selector: str, name: str, timeout: int = None
@@ -5227,13 +6507,21 @@ def get_attribute(
         -------
         Optional[str]
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.getAttribute(
-                    selector=selector, name=name, timeout=timeout
+
+        try:
+            log_api("=> page.get_attribute started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.getAttribute(
+                        selector=selector, name=name, timeout=timeout
+                    )
                 )
             )
-        )
+            log_api("<= page.get_attribute succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.get_attribute failed")
+            raise e
 
     def hover(
         self,
@@ -5272,17 +6560,25 @@ def hover(
         force : Optional[bool]
             Whether to bypass the actionability checks. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.hover(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    timeout=timeout,
-                    force=force,
+
+        try:
+            log_api("=> page.hover started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.hover(
+                        selector=selector,
+                        modifiers=modifiers,
+                        position=position,
+                        timeout=timeout,
+                        force=force,
+                    )
                 )
             )
-        )
+            log_api("<= page.hover succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.hover failed")
+            raise e
 
     def select_option(
         self,
@@ -5315,19 +6611,27 @@ def select_option(
         -------
         List[str]
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.selectOption(
-                    selector=selector,
-                    value=value,
-                    index=index,
-                    label=label,
-                    element=mapping.to_impl(element),
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.select_option started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.selectOption(
+                        selector=selector,
+                        value=value,
+                        index=index,
+                        label=label,
+                        element=mapping.to_impl(element),
+                        timeout=timeout,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= page.select_option succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.select_option failed")
+            raise e
 
     def set_input_files(
         self,
@@ -5356,16 +6660,24 @@ def set_input_files(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.setInputFiles(
-                    selector=selector,
-                    files=files,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.set_input_files started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.setInputFiles(
+                        selector=selector,
+                        files=files,
+                        timeout=timeout,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= page.set_input_files succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.set_input_files failed")
+            raise e
 
     def type(
         self,
@@ -5395,17 +6707,25 @@ def type(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.type(
-                    selector=selector,
-                    text=text,
-                    delay=delay,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.type started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.type(
+                        selector=selector,
+                        text=text,
+                        delay=delay,
+                        timeout=timeout,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= page.type succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.type failed")
+            raise e
 
     def press(
         self,
@@ -5443,17 +6763,25 @@ def press(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.press(
-                    selector=selector,
-                    key=key,
-                    delay=delay,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.press started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.press(
+                        selector=selector,
+                        key=key,
+                        delay=delay,
+                        timeout=timeout,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= page.press succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.press failed")
+            raise e
 
     def check(
         self,
@@ -5489,16 +6817,24 @@ def check(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.check(
-                    selector=selector,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.check started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.check(
+                        selector=selector,
+                        timeout=timeout,
+                        force=force,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= page.check succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.check failed")
+            raise e
 
     def uncheck(
         self,
@@ -5534,16 +6870,24 @@ def uncheck(
         no_wait_after : Optional[bool]
             Actions that initiate navigations are waiting for these navigations to happen and for pages to start loading. You can opt out of waiting via setting this flag. You would only need this option in the exceptional cases such as navigating to inaccessible pages. Defaults to `false`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.uncheck(
-                    selector=selector,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
+
+        try:
+            log_api("=> page.uncheck started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.uncheck(
+                        selector=selector,
+                        timeout=timeout,
+                        force=force,
+                        noWaitAfter=no_wait_after,
+                    )
                 )
             )
-        )
+            log_api("<= page.uncheck succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.uncheck failed")
+            raise e
 
     def wait_for_timeout(self, timeout: int) -> NoneType:
         """Page.wait_for_timeout
@@ -5558,9 +6902,17 @@ def wait_for_timeout(self, timeout: int) -> NoneType:
         timeout : int
             A timeout to wait for
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.waitForTimeout(timeout=timeout))
-        )
+
+        try:
+            log_api("=> page.wait_for_timeout started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.waitForTimeout(timeout=timeout))
+            )
+            log_api("<= page.wait_for_timeout succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_timeout failed")
+            raise e
 
     def wait_for_function(
         self,
@@ -5595,17 +6947,25 @@ def wait_for_function(
         -------
         JSHandle
         """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.waitForFunction(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                    timeout=timeout,
-                    polling=polling,
+
+        try:
+            log_api("=> page.wait_for_function started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.waitForFunction(
+                        expression=expression,
+                        arg=mapping.to_impl(arg),
+                        force_expr=force_expr,
+                        timeout=timeout,
+                        polling=polling,
+                    )
                 )
             )
-        )
+            log_api("<= page.wait_for_function succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.wait_for_function failed")
+            raise e
 
     def pdf(
         self,
@@ -5707,25 +7067,33 @@ def pdf(
         -------
         bytes
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.pdf(
-                    scale=scale,
-                    displayHeaderFooter=display_header_footer,
-                    headerTemplate=header_template,
-                    footerTemplate=footer_template,
-                    printBackground=print_background,
-                    landscape=landscape,
-                    pageRanges=page_ranges,
-                    format=format,
-                    width=width,
-                    height=height,
-                    preferCSSPageSize=prefer_css_page_size,
-                    margin=margin,
-                    path=path,
+
+        try:
+            log_api("=> page.pdf started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.pdf(
+                        scale=scale,
+                        displayHeaderFooter=display_header_footer,
+                        headerTemplate=header_template,
+                        footerTemplate=footer_template,
+                        printBackground=print_background,
+                        landscape=landscape,
+                        pageRanges=page_ranges,
+                        format=format,
+                        width=width,
+                        height=height,
+                        preferCSSPageSize=prefer_css_page_size,
+                        margin=margin,
+                        path=path,
+                    )
                 )
             )
-        )
+            log_api("<= page.pdf succeded")
+            return result
+        except Exception as e:
+            log_api("<= page.pdf failed")
+            raise e
 
     def expect_event(
         self,
@@ -6069,9 +7437,17 @@ def set_default_navigation_timeout(self, timeout: int) -> NoneType:
         timeout : int
             Maximum navigation time in milliseconds
         """
-        return mapping.from_maybe_impl(
-            self._impl_obj.setDefaultNavigationTimeout(timeout=timeout)
-        )
+
+        try:
+            log_api("=> browser_context.set_default_navigation_timeout started")
+            result = mapping.from_maybe_impl(
+                self._impl_obj.setDefaultNavigationTimeout(timeout=timeout)
+            )
+            log_api("<= browser_context.set_default_navigation_timeout succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.set_default_navigation_timeout failed")
+            raise e
 
     def set_default_timeout(self, timeout: int) -> NoneType:
         """BrowserContext.set_default_timeout
@@ -6086,9 +7462,17 @@ def set_default_timeout(self, timeout: int) -> NoneType:
         timeout : int
             Maximum time in milliseconds
         """
-        return mapping.from_maybe_impl(
-            self._impl_obj.setDefaultTimeout(timeout=timeout)
-        )
+
+        try:
+            log_api("=> browser_context.set_default_timeout started")
+            result = mapping.from_maybe_impl(
+                self._impl_obj.setDefaultTimeout(timeout=timeout)
+            )
+            log_api("<= browser_context.set_default_timeout succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.set_default_timeout failed")
+            raise e
 
     def new_page(self) -> "Page":
         """BrowserContext.new_page
@@ -6099,7 +7483,15 @@ def new_page(self) -> "Page":
         -------
         Page
         """
-        return mapping.from_impl(self._sync(self._impl_obj.newPage()))
+
+        try:
+            log_api("=> browser_context.new_page started")
+            result = mapping.from_impl(self._sync(self._impl_obj.newPage()))
+            log_api("<= browser_context.new_page succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.new_page failed")
+            raise e
 
     def cookies(
         self, urls: typing.Union[str, typing.List[str]] = None
@@ -6118,7 +7510,17 @@ def cookies(
         -------
         List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]
         """
-        return mapping.from_impl_list(self._sync(self._impl_obj.cookies(urls=urls)))
+
+        try:
+            log_api("=> browser_context.cookies started")
+            result = mapping.from_impl_list(
+                self._sync(self._impl_obj.cookies(urls=urls))
+            )
+            log_api("<= browser_context.cookies succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.cookies failed")
+            raise e
 
     def add_cookies(self, cookies: typing.List["Cookie"]) -> NoneType:
         """BrowserContext.add_cookies
@@ -6130,16 +7532,32 @@ def add_cookies(self, cookies: typing.List["Cookie"]) -> NoneType:
         ----------
         cookies : List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.addCookies(cookies=cookies))
-        )
+
+        try:
+            log_api("=> browser_context.add_cookies started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.addCookies(cookies=cookies))
+            )
+            log_api("<= browser_context.add_cookies succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.add_cookies failed")
+            raise e
 
     def clear_cookies(self) -> NoneType:
         """BrowserContext.clear_cookies
 
         Clears context cookies.
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.clearCookies()))
+
+        try:
+            log_api("=> browser_context.clear_cookies started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.clearCookies()))
+            log_api("<= browser_context.clear_cookies succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.clear_cookies failed")
+            raise e
 
     def grant_permissions(
         self, permissions: typing.List[str], origin: str = None
@@ -6172,18 +7590,38 @@ def grant_permissions(
         origin : Optional[str]
             The origin to grant permissions to, e.g. "https://example.com".
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.grantPermissions(permissions=permissions, origin=origin)
+
+        try:
+            log_api("=> browser_context.grant_permissions started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.grantPermissions(
+                        permissions=permissions, origin=origin
+                    )
+                )
             )
-        )
+            log_api("<= browser_context.grant_permissions succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.grant_permissions failed")
+            raise e
 
     def clear_permissions(self) -> NoneType:
         """BrowserContext.clear_permissions
 
         Clears all permission overrides for the browser context.
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.clearPermissions()))
+
+        try:
+            log_api("=> browser_context.clear_permissions started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.clearPermissions())
+            )
+            log_api("<= browser_context.clear_permissions succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.clear_permissions failed")
+            raise e
 
     def set_geolocation(
         self, latitude: float, longitude: float, accuracy: float = None
@@ -6204,16 +7642,34 @@ def set_geolocation(
         accuracy : Optional[float]
             Non-negative accuracy value. Defaults to `0`.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.setGeolocation(
-                    latitude=latitude, longitude=longitude, accuracy=accuracy
+
+        try:
+            log_api("=> browser_context.set_geolocation started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.setGeolocation(
+                        latitude=latitude, longitude=longitude, accuracy=accuracy
+                    )
                 )
             )
-        )
+            log_api("<= browser_context.set_geolocation succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.set_geolocation failed")
+            raise e
 
     def reset_geolocation(self) -> NoneType:
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.resetGeolocation()))
+
+        try:
+            log_api("=> browser_context.reset_geolocation started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.resetGeolocation())
+            )
+            log_api("<= browser_context.reset_geolocation succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.reset_geolocation failed")
+            raise e
 
     def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> NoneType:
         """BrowserContext.set_extra_http_headers
@@ -6229,11 +7685,19 @@ def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> NoneType:
         headers : Dict[str, str]
             An object containing additional HTTP headers to be sent with every request. All header values must be strings.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.setExtraHTTPHeaders(headers=mapping.to_impl(headers))
+
+        try:
+            log_api("=> browser_context.set_extra_http_headers started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.setExtraHTTPHeaders(headers=mapping.to_impl(headers))
+                )
             )
-        )
+            log_api("<= browser_context.set_extra_http_headers succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.set_extra_http_headers failed")
+            raise e
 
     def set_offline(self, offline: bool) -> NoneType:
         """BrowserContext.set_offline
@@ -6243,9 +7707,17 @@ def set_offline(self, offline: bool) -> NoneType:
         offline : bool
             Whether to emulate network being offline for the browser context.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.setOffline(offline=offline))
-        )
+
+        try:
+            log_api("=> browser_context.set_offline started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.setOffline(offline=offline))
+            )
+            log_api("<= browser_context.set_offline succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.set_offline failed")
+            raise e
 
     def add_init_script(
         self, source: str = None, path: typing.Union[str, pathlib.Path] = None
@@ -6269,9 +7741,17 @@ def add_init_script(
         source : Optional[str]
             Script to be evaluated in all pages in the browser context.
         """
-        return mapping.from_maybe_impl(
-            self._sync(self._impl_obj.addInitScript(source=source, path=path))
-        )
+
+        try:
+            log_api("=> browser_context.add_init_script started")
+            result = mapping.from_maybe_impl(
+                self._sync(self._impl_obj.addInitScript(source=source, path=path))
+            )
+            log_api("<= browser_context.add_init_script succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.add_init_script failed")
+            raise e
 
     def expose_binding(
         self, name: str, binding: typing.Callable, handle: bool = None
@@ -6296,13 +7776,21 @@ def expose_binding(
         handle : Optional[bool]
             Whether to pass the argument as a handle, instead of passing by value. When passing a handle, only one argument is supported. When passing by value, multiple arguments are supported.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.exposeBinding(
-                    name=name, binding=self._wrap_handler(binding), handle=handle
+
+        try:
+            log_api("=> browser_context.expose_binding started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.exposeBinding(
+                        name=name, binding=self._wrap_handler(binding), handle=handle
+                    )
                 )
             )
-        )
+            log_api("<= browser_context.expose_binding succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.expose_binding failed")
+            raise e
 
     def expose_function(self, name: str, binding: typing.Callable) -> NoneType:
         """BrowserContext.expose_function
@@ -6321,13 +7809,21 @@ def expose_function(self, name: str, binding: typing.Callable) -> NoneType:
         binding : Callable
             Callback function that will be called in the Playwright's context.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.exposeFunction(
-                    name=name, binding=self._wrap_handler(binding)
+
+        try:
+            log_api("=> browser_context.expose_function started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.exposeFunction(
+                        name=name, binding=self._wrap_handler(binding)
+                    )
                 )
             )
-        )
+            log_api("<= browser_context.expose_function succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.expose_function failed")
+            raise e
 
     def route(
         self,
@@ -6355,13 +7851,21 @@ def route(
         handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any]]
             handler function to route the request.
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.route(
-                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+
+        try:
+            log_api("=> browser_context.route started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.route(
+                        url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+                    )
                 )
             )
-        )
+            log_api("<= browser_context.route succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.route failed")
+            raise e
 
     def unroute(
         self,
@@ -6383,13 +7887,21 @@ def unroute(
         handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any], NoneType]
             Optional handler function used to register a routing with browser_context.route(url, handler).
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.unroute(
-                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+
+        try:
+            log_api("=> browser_context.unroute started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.unroute(
+                        url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+                    )
                 )
             )
-        )
+            log_api("<= browser_context.unroute succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.unroute failed")
+            raise e
 
     def wait_for_event(
         self,
@@ -6411,15 +7923,23 @@ def wait_for_event(
         -------
         Any
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.waitForEvent(
-                    event=event,
-                    predicate=self._wrap_handler(predicate),
-                    timeout=timeout,
+
+        try:
+            log_api("=> browser_context.wait_for_event started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.waitForEvent(
+                        event=event,
+                        predicate=self._wrap_handler(predicate),
+                        timeout=timeout,
+                    )
                 )
             )
-        )
+            log_api("<= browser_context.wait_for_event succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.wait_for_event failed")
+            raise e
 
     def close(self) -> NoneType:
         """BrowserContext.close
@@ -6428,7 +7948,15 @@ def close(self) -> NoneType:
 
         **NOTE** the default browser context cannot be closed.
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.close()))
+
+        try:
+            log_api("=> browser_context.close started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.close()))
+            log_api("<= browser_context.close succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.close failed")
+            raise e
 
     def storage_state(
         self, path: typing.Union[str, pathlib.Path] = None
@@ -6446,7 +7974,17 @@ def storage_state(
         -------
         {"cookies": Optional[List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]], "origins": Optional[List[Dict]]}
         """
-        return mapping.from_impl(self._sync(self._impl_obj.storageState(path=path)))
+
+        try:
+            log_api("=> browser_context.storage_state started")
+            result = mapping.from_impl(
+                self._sync(self._impl_obj.storageState(path=path))
+            )
+            log_api("<= browser_context.storage_state succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_context.storage_state failed")
+            raise e
 
     def expect_event(
         self,
@@ -6528,11 +8066,19 @@ def send(self, method: str, params: typing.Dict = None) -> typing.Dict:
         -------
         Dict
         """
-        return mapping.from_maybe_impl(
-            self._sync(
-                self._impl_obj.send(method=method, params=mapping.to_impl(params))
+
+        try:
+            log_api("=> cdp_session.send started")
+            result = mapping.from_maybe_impl(
+                self._sync(
+                    self._impl_obj.send(method=method, params=mapping.to_impl(params))
+                )
             )
-        )
+            log_api("<= cdp_session.send succeded")
+            return result
+        except Exception as e:
+            log_api("<= cdp_session.send failed")
+            raise e
 
     def detach(self) -> NoneType:
         """CDPSession.detach
@@ -6540,7 +8086,15 @@ def detach(self) -> NoneType:
         Detaches the CDPSession from the target. Once detached, the CDPSession object won't emit any events and can't be used to
         send messages.
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.detach()))
+
+        try:
+            log_api("=> cdp_session.detach started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.detach()))
+            log_api("<= cdp_session.detach succeded")
+            return result
+        except Exception as e:
+            log_api("<= cdp_session.detach failed")
+            raise e
 
 
 mapping.register(CDPSessionImpl, CDPSession)
@@ -6559,7 +8113,15 @@ def background_pages(self) -> typing.List["Page"]:
         -------
         List[Page]
         """
-        return mapping.from_impl_list(self._impl_obj.backgroundPages())
+
+        try:
+            log_api("=> chromium_browser_context.background_pages started")
+            result = mapping.from_impl_list(self._impl_obj.backgroundPages())
+            log_api("<= chromium_browser_context.background_pages succeded")
+            return result
+        except Exception as e:
+            log_api("<= chromium_browser_context.background_pages failed")
+            raise e
 
     def service_workers(self) -> typing.List["Worker"]:
         """ChromiumBrowserContext.service_workers
@@ -6570,7 +8132,15 @@ def service_workers(self) -> typing.List["Worker"]:
         -------
         List[Worker]
         """
-        return mapping.from_impl_list(self._impl_obj.serviceWorkers())
+
+        try:
+            log_api("=> chromium_browser_context.service_workers started")
+            result = mapping.from_impl_list(self._impl_obj.serviceWorkers())
+            log_api("<= chromium_browser_context.service_workers succeded")
+            return result
+        except Exception as e:
+            log_api("<= chromium_browser_context.service_workers failed")
+            raise e
 
     def new_cdp_session(self, page: "Page") -> "CDPSession":
         """ChromiumBrowserContext.new_cdp_session
@@ -6586,9 +8156,17 @@ def new_cdp_session(self, page: "Page") -> "CDPSession":
         -------
         CDPSession
         """
-        return mapping.from_impl(
-            self._sync(self._impl_obj.newCDPSession(page=page._impl_obj))
-        )
+
+        try:
+            log_api("=> chromium_browser_context.new_cdp_session started")
+            result = mapping.from_impl(
+                self._sync(self._impl_obj.newCDPSession(page=page._impl_obj))
+            )
+            log_api("<= chromium_browser_context.new_cdp_session succeded")
+            return result
+        except Exception as e:
+            log_api("<= chromium_browser_context.new_cdp_session failed")
+            raise e
 
 
 mapping.register(ChromiumBrowserContextImpl, ChromiumBrowserContext)
@@ -6631,7 +8209,15 @@ def is_connected(self) -> bool:
         -------
         bool
         """
-        return mapping.from_maybe_impl(self._impl_obj.isConnected())
+
+        try:
+            log_api("=> browser.is_connected started")
+            result = mapping.from_maybe_impl(self._impl_obj.isConnected())
+            log_api("<= browser.is_connected succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser.is_connected failed")
+            raise e
 
     def new_context(
         self,
@@ -6716,36 +8302,44 @@ def new_context(
         -------
         BrowserContext
         """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.newContext(
-                    viewport=viewport,
-                    ignoreHTTPSErrors=ignore_https_errors,
-                    javaScriptEnabled=java_script_enabled,
-                    bypassCSP=bypass_csp,
-                    userAgent=user_agent,
-                    locale=locale,
-                    timezoneId=timezone_id,
-                    geolocation=geolocation,
-                    permissions=permissions,
-                    extraHTTPHeaders=mapping.to_impl(extra_http_headers),
-                    offline=offline,
-                    httpCredentials=http_credentials,
-                    deviceScaleFactor=device_scale_factor,
-                    isMobile=is_mobile,
-                    hasTouch=has_touch,
-                    colorScheme=color_scheme,
-                    acceptDownloads=accept_downloads,
-                    defaultBrowserType=default_browser_type,
-                    proxy=proxy,
-                    recordHarPath=record_har_path,
-                    recordHarOmitContent=record_har_omit_content,
-                    recordVideoDir=record_video_dir,
-                    recordVideoSize=record_video_size,
-                    storageState=storage_state,
+
+        try:
+            log_api("=> browser.new_context started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.newContext(
+                        viewport=viewport,
+                        ignoreHTTPSErrors=ignore_https_errors,
+                        javaScriptEnabled=java_script_enabled,
+                        bypassCSP=bypass_csp,
+                        userAgent=user_agent,
+                        locale=locale,
+                        timezoneId=timezone_id,
+                        geolocation=geolocation,
+                        permissions=permissions,
+                        extraHTTPHeaders=mapping.to_impl(extra_http_headers),
+                        offline=offline,
+                        httpCredentials=http_credentials,
+                        deviceScaleFactor=device_scale_factor,
+                        isMobile=is_mobile,
+                        hasTouch=has_touch,
+                        colorScheme=color_scheme,
+                        acceptDownloads=accept_downloads,
+                        defaultBrowserType=default_browser_type,
+                        proxy=proxy,
+                        recordHarPath=record_har_path,
+                        recordHarOmitContent=record_har_omit_content,
+                        recordVideoDir=record_video_dir,
+                        recordVideoSize=record_video_size,
+                        storageState=storage_state,
+                    )
                 )
             )
-        )
+            log_api("<= browser.new_context succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser.new_context failed")
+            raise e
 
     def new_page(
         self,
@@ -6833,36 +8427,44 @@ def new_page(
         -------
         Page
         """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.newPage(
-                    viewport=viewport,
-                    ignoreHTTPSErrors=ignore_https_errors,
-                    javaScriptEnabled=java_script_enabled,
-                    bypassCSP=bypass_csp,
-                    userAgent=user_agent,
-                    locale=locale,
-                    timezoneId=timezone_id,
-                    geolocation=geolocation,
-                    permissions=permissions,
-                    extraHTTPHeaders=mapping.to_impl(extra_http_headers),
-                    offline=offline,
-                    httpCredentials=http_credentials,
-                    deviceScaleFactor=device_scale_factor,
-                    isMobile=is_mobile,
-                    hasTouch=has_touch,
-                    colorScheme=color_scheme,
-                    acceptDownloads=accept_downloads,
-                    defaultBrowserType=default_browser_type,
-                    proxy=proxy,
-                    recordHarPath=record_har_path,
-                    recordHarOmitContent=record_har_omit_content,
-                    recordVideoDir=record_video_dir,
-                    recordVideoSize=record_video_size,
-                    storageState=storage_state,
+
+        try:
+            log_api("=> browser.new_page started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.newPage(
+                        viewport=viewport,
+                        ignoreHTTPSErrors=ignore_https_errors,
+                        javaScriptEnabled=java_script_enabled,
+                        bypassCSP=bypass_csp,
+                        userAgent=user_agent,
+                        locale=locale,
+                        timezoneId=timezone_id,
+                        geolocation=geolocation,
+                        permissions=permissions,
+                        extraHTTPHeaders=mapping.to_impl(extra_http_headers),
+                        offline=offline,
+                        httpCredentials=http_credentials,
+                        deviceScaleFactor=device_scale_factor,
+                        isMobile=is_mobile,
+                        hasTouch=has_touch,
+                        colorScheme=color_scheme,
+                        acceptDownloads=accept_downloads,
+                        defaultBrowserType=default_browser_type,
+                        proxy=proxy,
+                        recordHarPath=record_har_path,
+                        recordHarOmitContent=record_har_omit_content,
+                        recordVideoDir=record_video_dir,
+                        recordVideoSize=record_video_size,
+                        storageState=storage_state,
+                    )
                 )
             )
-        )
+            log_api("<= browser.new_page succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser.new_page failed")
+            raise e
 
     def close(self) -> NoneType:
         """Browser.close
@@ -6873,7 +8475,15 @@ def close(self) -> NoneType:
         and disconnects from the browser server.
         The Browser object itself is considered to be disposed and cannot be used anymore.
         """
-        return mapping.from_maybe_impl(self._sync(self._impl_obj.close()))
+
+        try:
+            log_api("=> browser.close started")
+            result = mapping.from_maybe_impl(self._sync(self._impl_obj.close()))
+            log_api("<= browser.close succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser.close failed")
+            raise e
 
 
 mapping.register(BrowserImpl, Browser)
@@ -6980,27 +8590,35 @@ def launch(
         -------
         Browser
         """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.launch(
-                    executablePath=executable_path,
-                    args=args,
-                    ignoreDefaultArgs=ignore_default_args,
-                    handleSIGINT=handle_sigint,
-                    handleSIGTERM=handle_sigterm,
-                    handleSIGHUP=handle_sighup,
-                    timeout=timeout,
-                    env=mapping.to_impl(env),
-                    headless=headless,
-                    devtools=devtools,
-                    proxy=proxy,
-                    downloadsPath=downloads_path,
-                    slowMo=slow_mo,
-                    chromiumSandbox=chromium_sandbox,
-                    firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
+
+        try:
+            log_api("=> browser_type.launch started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.launch(
+                        executablePath=executable_path,
+                        args=args,
+                        ignoreDefaultArgs=ignore_default_args,
+                        handleSIGINT=handle_sigint,
+                        handleSIGTERM=handle_sigterm,
+                        handleSIGHUP=handle_sighup,
+                        timeout=timeout,
+                        env=mapping.to_impl(env),
+                        headless=headless,
+                        devtools=devtools,
+                        proxy=proxy,
+                        downloadsPath=downloads_path,
+                        slowMo=slow_mo,
+                        chromiumSandbox=chromium_sandbox,
+                        firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
+                    )
                 )
             )
-        )
+            log_api("<= browser_type.launch succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_type.launch failed")
+            raise e
 
     def launch_persistent_context(
         self,
@@ -7125,48 +8743,56 @@ def launch_persistent_context(
         -------
         BrowserContext
         """
-        return mapping.from_impl(
-            self._sync(
-                self._impl_obj.launchPersistentContext(
-                    userDataDir=user_data_dir,
-                    executablePath=executable_path,
-                    args=args,
-                    ignoreDefaultArgs=ignore_default_args,
-                    handleSIGINT=handle_sigint,
-                    handleSIGTERM=handle_sigterm,
-                    handleSIGHUP=handle_sighup,
-                    timeout=timeout,
-                    env=mapping.to_impl(env),
-                    headless=headless,
-                    devtools=devtools,
-                    proxy=proxy,
-                    downloadsPath=downloads_path,
-                    slowMo=slow_mo,
-                    viewport=viewport,
-                    ignoreHTTPSErrors=ignore_https_errors,
-                    javaScriptEnabled=java_script_enabled,
-                    bypassCSP=bypass_csp,
-                    userAgent=user_agent,
-                    locale=locale,
-                    timezoneId=timezone_id,
-                    geolocation=geolocation,
-                    permissions=permissions,
-                    extraHTTPHeaders=mapping.to_impl(extra_http_headers),
-                    offline=offline,
-                    httpCredentials=http_credentials,
-                    deviceScaleFactor=device_scale_factor,
-                    isMobile=is_mobile,
-                    hasTouch=has_touch,
-                    colorScheme=color_scheme,
-                    acceptDownloads=accept_downloads,
-                    chromiumSandbox=chromium_sandbox,
-                    recordHarPath=record_har_path,
-                    recordHarOmitContent=record_har_omit_content,
-                    recordVideoDir=record_video_dir,
-                    recordVideoSize=record_video_size,
+
+        try:
+            log_api("=> browser_type.launch_persistent_context started")
+            result = mapping.from_impl(
+                self._sync(
+                    self._impl_obj.launchPersistentContext(
+                        userDataDir=user_data_dir,
+                        executablePath=executable_path,
+                        args=args,
+                        ignoreDefaultArgs=ignore_default_args,
+                        handleSIGINT=handle_sigint,
+                        handleSIGTERM=handle_sigterm,
+                        handleSIGHUP=handle_sighup,
+                        timeout=timeout,
+                        env=mapping.to_impl(env),
+                        headless=headless,
+                        devtools=devtools,
+                        proxy=proxy,
+                        downloadsPath=downloads_path,
+                        slowMo=slow_mo,
+                        viewport=viewport,
+                        ignoreHTTPSErrors=ignore_https_errors,
+                        javaScriptEnabled=java_script_enabled,
+                        bypassCSP=bypass_csp,
+                        userAgent=user_agent,
+                        locale=locale,
+                        timezoneId=timezone_id,
+                        geolocation=geolocation,
+                        permissions=permissions,
+                        extraHTTPHeaders=mapping.to_impl(extra_http_headers),
+                        offline=offline,
+                        httpCredentials=http_credentials,
+                        deviceScaleFactor=device_scale_factor,
+                        isMobile=is_mobile,
+                        hasTouch=has_touch,
+                        colorScheme=color_scheme,
+                        acceptDownloads=accept_downloads,
+                        chromiumSandbox=chromium_sandbox,
+                        recordHarPath=record_har_path,
+                        recordHarOmitContent=record_har_omit_content,
+                        recordVideoDir=record_video_dir,
+                        recordVideoSize=record_video_size,
+                    )
                 )
             )
-        )
+            log_api("<= browser_type.launch_persistent_context succeded")
+            return result
+        except Exception as e:
+            log_api("<= browser_type.launch_persistent_context failed")
+            raise e
 
 
 mapping.register(BrowserTypeImpl, BrowserType)
@@ -7197,7 +8823,15 @@ def devices(self) -> typing.Dict[str, "DeviceDescriptor"]:
         return mapping.from_impl_dict(self._impl_obj.devices)
 
     def stop(self) -> NoneType:
-        return mapping.from_maybe_impl(self._impl_obj.stop())
+
+        try:
+            log_api("=> playwright.stop started")
+            result = mapping.from_maybe_impl(self._impl_obj.stop())
+            log_api("<= playwright.stop succeded")
+            return result
+        except Exception as e:
+            log_api("<= playwright.stop failed")
+            raise e
 
 
 mapping.register(PlaywrightImpl, Playwright)
diff --git a/scripts/generate_api.py b/scripts/generate_api.py
index fd1747454..a5b2a2e8f 100644
--- a/scripts/generate_api.py
+++ b/scripts/generate_api.py
@@ -183,6 +183,7 @@ def return_value(value: Any) -> List[str]:
 from playwright._impl._playwright import Playwright as PlaywrightImpl
 from playwright._impl._selectors import Selectors as SelectorsImpl
 from playwright._impl._video import Video as VideoImpl
+from playwright._impl._logger import log_api
 
 """
 
diff --git a/scripts/generate_async_api.py b/scripts/generate_async_api.py
index e4827419d..db8c63f51 100755
--- a/scripts/generate_async_api.py
+++ b/scripts/generate_async_api.py
@@ -81,33 +81,32 @@ def generate(t: Any) -> None:
             and "expect_" not in name
             and "remove_listener" != name
         ):
+            is_async = inspect.iscoroutinefunction(value)
             print("")
-            if inspect.iscoroutinefunction(value):
-                print(
-                    f"    async def {to_snake_case(name)}({signature(value, len(name) + 9)}) -> {return_type(value)}:"
-                )
-                documentation_provider.print_entry(
-                    class_name, name, get_type_hints(value, api_globals)
-                )
-                [prefix, suffix] = return_value(
-                    get_type_hints(value, api_globals)["return"]
-                )
-                prefix = "        return " + prefix + f"await self._impl_obj.{name}("
-                suffix = ")" + suffix
-                print(f"{prefix}{arguments(value, len(prefix))}{suffix}")
-            else:
-                print(
-                    f"    def {to_snake_case(name)}({signature(value, len(name) + 9)}) -> {return_type(value)}:"
-                )
-                documentation_provider.print_entry(
-                    class_name, name, get_type_hints(value, api_globals)
-                )
-                [prefix, suffix] = return_value(
-                    get_type_hints(value, api_globals)["return"]
-                )
-                prefix = "        return " + prefix + f"self._impl_obj.{name}("
-                suffix = ")" + suffix
-                print(f"{prefix}{arguments(value, len(prefix))}{suffix}")
+            async_prefix = "async " if is_async else ""
+            await_prefix = "await " if is_async else ""
+            print(
+                f"    {async_prefix}def {to_snake_case(name)}({signature(value, len(name) + 9)}) -> {return_type(value)}:"
+            )
+            documentation_provider.print_entry(
+                class_name, name, get_type_hints(value, api_globals)
+            )
+            [prefix, suffix] = return_value(
+                get_type_hints(value, api_globals)["return"]
+            )
+            prefix = prefix + f"{await_prefix}self._impl_obj.{name}("
+            suffix = ")" + suffix
+            print(
+                f"""
+        try:
+            log_api("=> {to_snake_case(class_name)}.{to_snake_case(name)} started")
+            result = {prefix}{arguments(value, len(prefix))}{suffix}
+            log_api("<= {to_snake_case(class_name)}.{to_snake_case(name)} succeded")
+            return result
+        except Exception as e:
+            log_api("<= {to_snake_case(class_name)}.{to_snake_case(name)} failed")
+            raise e"""
+            )
         if "expect_" in name:
             print("")
             return_type_value = return_type(value)
diff --git a/scripts/generate_sync_api.py b/scripts/generate_sync_api.py
index a17656d70..3385bfe6c 100755
--- a/scripts/generate_sync_api.py
+++ b/scripts/generate_sync_api.py
@@ -83,6 +83,7 @@ def generate(t: Any) -> None:
             and "expect_" not in name
             and "remove_listener" != name
         ):
+            is_async = inspect.iscoroutinefunction(value)
             print("")
             print(
                 f"    def {to_snake_case(name)}({signature(value, len(name) + 9)}) -> {return_type(value)}:"
@@ -93,15 +94,24 @@ def generate(t: Any) -> None:
             [prefix, suffix] = return_value(
                 get_type_hints(value, api_globals)["return"]
             )
-            if inspect.iscoroutinefunction(value):
-                prefix = (
-                    "        return " + prefix + f"self._sync(self._impl_obj.{name}("
-                )
+            if is_async:
+                prefix = prefix + f"self._sync(self._impl_obj.{name}("
                 suffix = "))" + suffix
             else:
-                prefix = "        return " + prefix + f"self._impl_obj.{name}("
+                prefix = prefix + f"self._impl_obj.{name}("
                 suffix = ")" + suffix
-            print(f"{prefix}{arguments(value, len(prefix))}{suffix}")
+
+            print(
+                f"""
+        try:
+            log_api("=> {to_snake_case(class_name)}.{to_snake_case(name)} started")
+            result = {prefix}{arguments(value, len(prefix))}{suffix}
+            log_api("<= {to_snake_case(class_name)}.{to_snake_case(name)} succeded")
+            return result
+        except Exception as e:
+            log_api("<= {to_snake_case(class_name)}.{to_snake_case(name)} failed")
+            raise e"""
+            )
         if "expect_" in name:
             print("")
             return_type_value = return_type(value)