# Logging

Copy for LLM

The library logs useful debug information to the `apify_client` logger whenever it sends requests to the Apify API. You can configure this logger to print debug information to the standard output by adding a handler:

```
import logging



# Configure the Apify client logger

apify_client_logger = logging.getLogger('apify_client')

apify_client_logger.setLevel(logging.DEBUG)

apify_client_logger.addHandler(logging.StreamHandler())
```

The log records include additional properties, provided via the extra argument, which can be helpful for debugging. Some of these properties are:

* `attempt` - Number of retry attempts for the request.
* `status_code` - HTTP status code of the response. Only present on records about a request's outcome.
* `url` - URL of the API endpoint being called.
* `client_method` - Method name of the client that initiated the request.
* `resource_id` - Identifier of the resource being accessed.

To display these additional properties in the log output, you need to use a custom log formatter. Reference only the properties present on every record, since a `%`-style formatter raises an error for records that lack a referenced property. Here's a basic example:

```
import logging



# Create a custom logging formatter. Reference only the properties present

# on every record. Properties attached to some records only, such as

# `status_code`, would raise an error for the records that lack them.

formatter = logging.Formatter(

    '%(asctime)s - %(name)s - %(levelname)s - %(message)s - '

    '%(client_method)s - %(attempt)s - %(url)s'

)



handler = logging.StreamHandler()

handler.setFormatter(formatter)



# Configure the Apify client logger to use the custom formatter

apify_client_logger = logging.getLogger('apify_client')

apify_client_logger.setLevel(logging.DEBUG)

apify_client_logger.addHandler(handler)
```

For more information on creating and using custom log formatters, refer to the official Python [logging documentation](https://docs.python.org/3/howto/logging.html#formatters).

## Redirecting Actor run logs[](#redirecting-actor-run-logs)

When you start an Actor with [`ActorClient.call`](https://docs.apify.com/api/client/python/reference/class/ActorClient.md#call), the client redirects the run's log to a Python logger while it waits for the run to finish. The same logger also receives the run's status and status message whenever they change. The `logger` argument controls where the lines go:

* `'default'` (the default) - A built-in redirect logger named after the Actor and the run ID.
* A `logging.Logger` - Your own logger receives the lines, so give it a handler and a level that let them through.
* `None` - Redirection is turned off.

- Async client
- Sync client

```
import logging



from apify_client import ApifyClientAsync



TOKEN = 'MY-APIFY-TOKEN'





async def main() -> None:

    apify_client = ApifyClientAsync(TOKEN)

    actor_client = apify_client.actor('username/actor-name')



    # By default, the run's log and status messages go to a built-in redirect logger.

    await actor_client.call()



    # Send the run's log and status messages to your own logger.

    logging.basicConfig(level=logging.INFO)

    my_logger = logging.getLogger('my_actor_run')

    await actor_client.call(logger=my_logger)



    # Turn the redirection off.

    await actor_client.call(logger=None)
```

```
import logging



from apify_client import ApifyClient



TOKEN = 'MY-APIFY-TOKEN'





def main() -> None:

    apify_client = ApifyClient(TOKEN)

    actor_client = apify_client.actor('username/actor-name')



    # By default, the run's log and status messages go to a built-in redirect logger.

    actor_client.call()



    # Send the run's log and status messages to your own logger.

    logging.basicConfig(level=logging.INFO)

    my_logger = logging.getLogger('my_actor_run')

    actor_client.call(logger=my_logger)



    # Turn the redirection off.

    actor_client.call(logger=None)
```

For a run started with [`ActorClient.start`](https://docs.apify.com/api/client/python/reference/class/ActorClient.md#start), or any other run you have a client for, use [`RunClient.get_streamed_log`](https://docs.apify.com/api/client/python/reference/class/RunClient.md#get_streamed_log) to redirect its log and [`RunClient.get_status_message_watcher`](https://docs.apify.com/api/client/python/reference/class/RunClient.md#get_status_message_watcher) to redirect its status messages. Both accept an optional `to_logger` and work as context managers, or you can call `start()` and `stop()` yourself:

* Async client
* Sync client

```
from apify_client import ApifyClientAsync



TOKEN = 'MY-APIFY-TOKEN'





async def main() -> None:

    apify_client = ApifyClientAsync(TOKEN)

    actor_client = apify_client.actor('username/actor-name')



    actor_run = await actor_client.start()

    run_client = apify_client.run(actor_run.id)



    # Use the helpers as context managers to redirect while the run is in progress.

    streamed_log = await run_client.get_streamed_log()

    status_message_watcher = await run_client.get_status_message_watcher()

    async with streamed_log, status_message_watcher:

        await run_client.wait_for_finish()



    # Or start and stop them yourself.

    actor_run = await actor_client.start()

    run_client = apify_client.run(actor_run.id)



    # With `from_start=False`, only log lines written from now on are redirected.

    streamed_log = await run_client.get_streamed_log(from_start=False)

    streamed_log.start()

    # Do other work while the run's log is redirected.

    await streamed_log.stop()
```

```
from apify_client import ApifyClient



TOKEN = 'MY-APIFY-TOKEN'





def main() -> None:

    apify_client = ApifyClient(TOKEN)

    actor_client = apify_client.actor('username/actor-name')



    actor_run = actor_client.start()

    run_client = apify_client.run(actor_run.id)



    # Use the helpers as context managers to redirect while the run is in progress.

    streamed_log = run_client.get_streamed_log()

    status_message_watcher = run_client.get_status_message_watcher()

    with streamed_log, status_message_watcher:

        run_client.wait_for_finish()



    # Or start and stop them yourself.

    actor_run = actor_client.start()

    run_client = apify_client.run(actor_run.id)



    # With `from_start=False`, only log lines written from now on are redirected.

    streamed_log = run_client.get_streamed_log(from_start=False)

    streamed_log.start()

    # Do other work while the run's log is redirected.

    streamed_log.stop()
```
