Add log redirection guide

Author: Pijukatel

docs/03_concepts/10_logging.mdx

@@ -7,6 +7,9 @@ import CodeBlock from '@theme/CodeBlock';
 
 import LogConfigExample from '!!raw-loader!./code/10_log_config.py';
 import LoggerUsageExample from '!!raw-loader!./code/10_logger_usage.py';
+import RedirectLog from '!!raw-loader!./code/10_redirect_log.py';
+import RedirectLogExistingRun from '!!raw-loader!./code/10_redirect_log_existing_run.py';
+
 
 The Apify SDK is logging useful information through the [`logging`](https://docs.python.org/3/library/logging.html) module from Python's standard library, into the logger with the name `apify`.
 
@@ -82,3 +85,25 @@ Result:
 </pre>
 
 <!-- markdownlint-enable no-inline-html -->
+
+## Redirect logs from other actor runs
+In some situations one Actor is going to start one or more other Actors and wait for them to finish and produce some results. In such cases, you might want to redirect the logs and status messages of the started Actors runs back to the parent Actor run, so that you can see the progress of the started Actors in the parent Actor's logs. This guide will show options how to do it.
+
+### Redirecting logs from `Actor.call`
+Typical use case for log redirection is to call another Actor using the [`Actor.call`](../../reference/class/Actor#call) method. This method has an optional `logger` argument, which is by default set to `default` literal. This means that the logs of the called Actor will be automatically redirected to the parent Actor's logs with default formating and filtering. If you set `logger` argument to `None`, then no log redirection happens. Third option is to pass your own `Logger` instance with the possibility to define own formater, filter and handler.
+
+<CodeBlock className="language-python">
+    {RedirectLog}
+</CodeBlock>
+
+Each default redirect logger log entry will have specific format. After timestamp, it will contain cyan colored text that will contain the redirect information - the other actor's name and the run ID. The rest of the log message will be printed in the same manner as the parent Actor's logger is configured.
+
+The log redirection can be deep, meaning that if the other actor also starts another actor and is redirecting logs from it, then in the top level actor you can see it as well. See following example screenshot of Apify console when one actor recursively starts itself (there are 2 levels of recursion in the example).
+
+![Console with redirected logs](/img/guides/redirected_logs_example.png 'Example of console with redirected logs from recursively started actor.')
+
+### Redirecting logs from already running Actor run
+In some cases you might want to connect to an already running Actor run and redirect its logs to your current Actor run. This can be done using the `ApifyClient` from `apify-client-python` directly.
+<CodeBlock className="language-python">
+    {RedirectLogExistingRun}
+</CodeBlock>

docs/03_concepts/code/10_redirect_log.py

@@ -0,0 +1,15 @@
+import logging
+
+from apify import Actor
+
+
+async def main() -> None:
+    async with Actor:
+        # Default redirect logger
+        await Actor.call(actor_id='some_actor_id')
+        # No redirect logger
+        await Actor.call(actor_id='some_actor_id', logger=None)
+        # Custom redirect logger
+        await Actor.call(
+            actor_id='some_actor_id', logger=logging.getLogger('custom_logger')
+        )

docs/03_concepts/code/10_redirect_log_existing_run.py

@@ -0,0 +1,17 @@
+import asyncio
+
+from apify import Actor
+
+
+async def main() -> None:
+    async with Actor:
+        # With context manager
+        async with await Actor.new_client().run('some_actor_id').get_streamed_log():
+            await asyncio.sleep(5)
+            # Logging will stop out of context
+
+        # With direct call (lifecycle of logging has to be manually handled)
+        streamed_log = await Actor.new_client().run('some_id').get_streamed_log()
+        streamed_log.start()
+        await asyncio.sleep(5)
+        await streamed_log.stop()