modAL 1.3.6.dev7__tar.gz → 1.3.6.dev9__tar.gz

{modal-1.3.6.dev7 → modal-1.3.6.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.3.6.dev7
+Version: 1.3.6.dev9
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0
@@ -36,7 +36,6 @@ Dynamic: license-file
 
 [![PyPI Version](https://img.shields.io/pypi/v/modal.svg)](https://pypi.org/project/modal/)
 [![License](https://img.shields.io/badge/license-apache_2.0-darkviolet.svg)](https://github.com/modal-labs/modal-client/blob/master/LICENSE)
-[![Tests](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml)
 [![Slack](https://img.shields.io/badge/slack-join-blue.svg?logo=slack)](https://modal.com/slack)
 
 The [Modal](https://modal.com/) Python SDK provides convenient, on-demand

{modal-1.3.6.dev7 → modal-1.3.6.dev9}/README.md

@@ -2,7 +2,6 @@
 
 [![PyPI Version](https://img.shields.io/pypi/v/modal.svg)](https://pypi.org/project/modal/)
 [![License](https://img.shields.io/badge/license-apache_2.0-darkviolet.svg)](https://github.com/modal-labs/modal-client/blob/master/LICENSE)
-[![Tests](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml)
 [![Slack](https://img.shields.io/badge/slack-join-blue.svg?logo=slack)](https://modal.com/slack)
 
 The [Modal](https://modal.com/) Python SDK provides convenient, on-demand

modal-1.3.6.dev9/modal/_logs.py

@@ -0,0 +1,498 @@
+# Copyright Modal Labs 2026
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+from collections.abc import AsyncGenerator
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING, Optional
+
+from google.protobuf.timestamp_pb2 import Timestamp
+
+from modal._utils.async_utils import TaskContext
+from modal.exception import LogsFetchError
+from modal_proto import api_pb2
+
+if TYPE_CHECKING:
+    from modal.client import _Client
+
+
+@dataclasses.dataclass(frozen=True)
+class LogsFilters:
+    source: "api_pb2.FileDescriptor.ValueType" = api_pb2.FILE_DESCRIPTOR_UNSPECIFIED
+    function_id: str = ""
+    function_call_id: str = ""
+    task_id: str = ""
+    sandbox_id: str = ""
+    search_text: str = ""
+
+
+# Maximum number of logs to request per fetch RPC call. This is a safety cap
+# to avoid silently dropping logs from dense intervals, not a target size.
+# Derived from a ~4 MiB target response size at ~200 bytes per log entry.
+_FETCH_LIMIT = 20_000
+
+# Minimum number of logs to accumulate per interval before splitting into
+# a new one. Buckets are merged until this threshold is reached. Intervals
+# with a single bucket exceeding this value are emitted as-is.
+_INTERVAL_LOG_THRESHOLD = 2_000
+
+# Maximum number of fetch RPCs per fetch_logs call. Together with _FETCH_LIMIT,
+# this bounds total retrievable entries to _MAX_FETCHES * _FETCH_LIMIT = 10M.
+_MAX_FETCHES = 500
+
+# Maximum allowed range between `since` and `until`, enforced server-side.
+_MAX_FETCH_RANGE = timedelta(days=35)
+
+# Lookback windows for tailing logs, tried in order from shortest to longest.
+_TAIL_LOOKBACKS = [
+    timedelta(hours=1),
+    timedelta(days=1),
+    timedelta(days=7),
+    timedelta(days=30),
+]
+
+# Maximum number of concurrent AppFetchLogs requests.
+_MAX_CONCURRENT_FETCHES = 10
+
+# Maximum number of concurrent AppCountLogs requests (responses are small).
+_MAX_CONCURRENT_COUNTS = 20
+
+# Maximum number of refinement iterations (each fires a parallel batch of AppCountLogs RPCs).
+_MAX_REFINE_ITERATIONS = 3
+
+# Number of buckets for the initial count
+_APPROX_INITIAL_BUCKETS = 100
+
+# Predefined bucket sizes (in seconds)
+# We pick the smallest size such that the total number of buckets stays <= _APPROX_INITIAL_BUCKETS.
+_BUCKET_SIZES_SECS = [
+    2,
+    4,
+    6,
+    12,
+    20,
+    30,
+    60,
+    120,
+    180,
+    240,
+    300,
+    360,
+    600,
+    720,
+    900,
+    1200,
+    1800,
+    3600,
+    7200,
+    10800,
+    14400,
+    28800,
+    43200,
+    86400,
+]
+
+
+def _datetime_to_timestamp(dt: datetime) -> Timestamp:
+    ts = Timestamp()
+    ts.FromDatetime(dt)
+    return ts
+
+
+def _timestamp_to_seconds(ts: Timestamp) -> float:
+    return ts.seconds + ts.nanos / 1e9
+
+
+def _seconds_to_timestamp(secs: float) -> Timestamp:
+    ts = Timestamp()
+    ts.seconds = int(secs)
+    ts.nanos = int((secs - int(secs)) * 1e9)
+    return ts
+
+
+def _pick_bucket_secs(since: datetime, until: datetime) -> int:
+    """Pick the smallest bucket size that yields _APPROX_INITIAL_BUCKETS."""
+    duration_secs = (until - since).total_seconds()
+    for bucket_secs in _BUCKET_SIZES_SECS:
+        if duration_secs / bucket_secs <= _APPROX_INITIAL_BUCKETS:
+            return bucket_secs
+    return _BUCKET_SIZES_SECS[-1]
+
+
+def _bucket_count(bucket: api_pb2.AppCountLogsResponse.LogBucket) -> int:
+    return bucket.stdout_logs + bucket.stderr_logs + bucket.system_logs
+
+
+def _buckets_to_ranges(
+    buckets: list[api_pb2.AppCountLogsResponse.LogBucket],
+    bucket_secs: int,
+) -> list[tuple[float, float, int]]:
+    """Convert proto buckets to (start, end, count) tuples."""
+    return [
+        (
+            _timestamp_to_seconds(b.bucket_start_at),
+            _timestamp_to_seconds(b.bucket_start_at) + bucket_secs,
+            _bucket_count(b),
+        )
+        for b in buckets
+    ]
+
+
+def _build_fetch_intervals(
+    ranges: list[tuple[float, float, int]],
+) -> list[tuple[float, float]]:
+    """Build time intervals for parallel fetching from (start, end, count) ranges.
+
+    Merges adjacent non-empty ranges into intervals, splitting when the
+    accumulated log count reaches _INTERVAL_LOG_THRESHOLD or when adding the
+    next range would push the interval over _FETCH_LIMIT.
+    """
+    intervals: list[tuple[float, float]] = []
+    current_start: Optional[float] = None
+    current_end: float = 0.0
+    current_count = 0
+
+    for range_start, range_end, total in ranges:
+        if total == 0:
+            if current_start is not None:
+                intervals.append((current_start, current_end))
+                current_start = None
+                current_count = 0
+            continue
+
+        if current_start is not None and current_count + total > _FETCH_LIMIT:
+            intervals.append((current_start, current_end))
+            current_start = None
+            current_count = 0
+
+        if current_start is None:
+            current_start = range_start
+            current_count = total
+        else:
+            current_count += total
+        current_end = range_end
+
+        if current_count >= _INTERVAL_LOG_THRESHOLD:
+            intervals.append((current_start, current_end))
+            current_start = None
+            current_count = 0
+
+    # Flush remaining interval
+    if current_start is not None:
+        intervals.append((current_start, current_end))
+
+    return intervals
+
+
+def _next_smaller_bucket_secs(current_bucket_secs: int) -> Optional[int]:
+    """Return the next smaller bucket size, or None if already at the smallest."""
+    for size in reversed(_BUCKET_SIZES_SECS):
+        if size < current_bucket_secs:
+            return size
+    return None
+
+
+async def _refine_dense_ranges(
+    client: _Client,
+    app_id: str,
+    ranges: list[tuple[float, float, int]],
+    filters: LogsFilters,
+    max_ranges: int,
+    max_iterations: int,
+) -> list[tuple[float, float, int]]:
+    """Refine ranges exceeding _FETCH_LIMIT by subdividing with smaller buckets.
+
+    Uses breadth-first refinement: each iteration splits ALL over-limit ranges
+    one level, ensuring fair treatment across dense regions. Stops when all
+    ranges fit within _FETCH_LIMIT, no further subdivision is possible,
+    the total range count would exceed max_ranges, or the iteration budget
+    is exhausted.
+    """
+    refined = list(ranges)
+    iterations = 0
+
+    while iterations < max_iterations:
+        # Identify dense ranges that can be subdivided
+        to_refine: list[tuple[int, int]] = []  # (index, smaller_secs)
+        for i, (start, end, count) in enumerate(refined):
+            if count <= _FETCH_LIMIT:
+                continue
+            duration = end - start
+            smaller_secs = _next_smaller_bucket_secs(int(duration))
+            if smaller_secs is not None and smaller_secs < duration:
+                to_refine.append((i, smaller_secs))
+
+        if not to_refine:
+            break
+
+        # Estimate new range count: each refined range of duration D
+        # with bucket size S produces ceil(D/S) sub-ranges, replacing 1.
+        estimated_new = len(refined)
+        for i, smaller_secs in to_refine:
+            start, end, _ = refined[i]
+            duration = end - start
+            sub_count = -(-int(duration) // smaller_secs)  # ceil division
+            estimated_new += sub_count - 1  # replacing 1 range with sub_count
+        if estimated_new > max_ranges:
+            break
+
+        # Fire off all re-count RPCs in parallel with bounded concurrency
+        semaphore = asyncio.Semaphore(_MAX_CONCURRENT_COUNTS)
+
+        async def _recount(start: float, end: float, smaller_secs: int) -> list[tuple[float, float, int]]:
+            async with semaphore:
+                sub_req = api_pb2.AppCountLogsRequest(
+                    app_id=app_id,
+                    since=_seconds_to_timestamp(start),
+                    until=_seconds_to_timestamp(end),
+                    bucket_secs=smaller_secs,
+                    source=filters.source,
+                    function_id=filters.function_id,
+                    function_call_id=filters.function_call_id,
+                    task_id=filters.task_id,
+                    sandbox_id=filters.sandbox_id,
+                    search_text=filters.search_text,
+                )
+                sub_resp = await client.stub.AppCountLogs(sub_req)
+                sub_ranges = _buckets_to_ranges(list(sub_resp.buckets), smaller_secs)
+                # Clamp the last sub-range to the parent's end. When bucket_secs
+                # doesn't evenly divide the parent duration, the last bucket
+                # boundary overshoots (e.g. parent (0,30) with 20s buckets
+                # produces (20,40)), causing overlaps with sibling ranges.
+                if sub_ranges:
+                    s, _, c = sub_ranges[-1]
+                    sub_ranges[-1] = (s, min(s + smaller_secs, end), c)
+                return sub_ranges
+
+        refine_set = {i for i, _ in to_refine}
+        tasks = [_recount(refined[i][0], refined[i][1], s) for i, s in to_refine]
+        iterations += 1
+        sub_results = await TaskContext.gather(*tasks)
+
+        # Rebuild the list, splicing in sub-ranges for refined entries
+        result_iter = iter(sub_results)
+        new_refined: list[tuple[float, float, int]] = []
+        for i, r in enumerate(refined):
+            if i in refine_set:
+                new_refined.extend(next(result_iter))
+            else:
+                new_refined.append(r)
+
+        refined = new_refined
+
+    return refined
+
+
+async def _fetch_interval(
+    client: _Client,
+    app_id: str,
+    since: float,
+    until: float,
+    limit: int,
+    filters: LogsFilters,
+) -> list[api_pb2.TaskLogsBatch]:
+    """Fetch logs for a single time interval."""
+    req = api_pb2.AppFetchLogsRequest(
+        app_id=app_id,
+        since=_seconds_to_timestamp(since),
+        until=_seconds_to_timestamp(until),
+        limit=limit,
+        source=filters.source,
+        function_id=filters.function_id,
+        function_call_id=filters.function_call_id,
+        task_id=filters.task_id,
+        sandbox_id=filters.sandbox_id,
+        search_text=filters.search_text,
+    )
+    resp: api_pb2.AppFetchLogsResponse = await client.stub.AppFetchLogs(req)
+    return list(resp.batches)
+
+
+async def tail_logs(
+    client: _Client,
+    app_id: str,
+    n: int,
+    *,
+    since: Optional[datetime] = None,
+    until: Optional[datetime] = None,
+    filters: Optional[LogsFilters] = None,
+) -> AsyncGenerator[api_pb2.TaskLogsBatch]:
+    """Fetch up to `n` of the most recent log entries for an app.
+
+    When `since` is provided, it is used as a hard floor (no progressive
+    widening). When omitted, starts with a short lookback window and widens
+    until `n` results are returned or all windows are exhausted. `until`
+    defaults to now.
+
+    `n` must not exceed _FETCH_LIMIT.
+    """
+    if filters is None:
+        filters = LogsFilters()
+    if n > _FETCH_LIMIT:
+        raise LogsFetchError(f"--tail value must not exceed {_FETCH_LIMIT}.")
+
+    now = datetime.now(timezone.utc)
+
+    if since is not None and since.tzinfo is None:
+        raise ValueError("since must be timezone-aware")
+    if until is not None and until.tzinfo is None:
+        raise ValueError("until must be timezone-aware")
+
+    until_ts = _datetime_to_timestamp(until) if until else _datetime_to_timestamp(now)
+
+    if since is not None:
+        # Explicit floor — single fetch, no widening.
+        effective_until = until or now
+        if effective_until - since > _MAX_FETCH_RANGE:
+            raise LogsFetchError(f"Time range cannot exceed {_MAX_FETCH_RANGE.days} days.")
+        req = api_pb2.AppFetchLogsRequest(
+            app_id=app_id,
+            since=_datetime_to_timestamp(since),
+            until=until_ts,
+            limit=n,
+            source=filters.source,
+            function_id=filters.function_id,
+            function_call_id=filters.function_call_id,
+            task_id=filters.task_id,
+            sandbox_id=filters.sandbox_id,
+            search_text=filters.search_text,
+        )
+        resp = await client.stub.AppFetchLogs(req)
+        for batch in resp.batches:
+            yield batch
+        return
+
+    # No explicit since — progressively widen the lookback.
+    anchor = until or now
+    for lookback in _TAIL_LOOKBACKS:
+        lookback_since = anchor - lookback
+        req = api_pb2.AppFetchLogsRequest(
+            app_id=app_id,
+            since=_datetime_to_timestamp(lookback_since),
+            until=until_ts,
+            limit=n,
+            source=filters.source,
+            function_id=filters.function_id,
+            function_call_id=filters.function_call_id,
+            task_id=filters.task_id,
+            sandbox_id=filters.sandbox_id,
+            search_text=filters.search_text,
+        )
+        resp = await client.stub.AppFetchLogs(req)
+
+        total_items = sum(len(b.items) for b in resp.batches)
+        if total_items >= n or lookback == _TAIL_LOOKBACKS[-1]:
+            for batch in resp.batches:
+                yield batch
+            return
+
+
+async def fetch_logs(
+    client: _Client,
+    app_id: str,
+    since: datetime,
+    until: datetime,
+    *,
+    filters: Optional[LogsFilters] = None,
+) -> AsyncGenerator[api_pb2.TaskLogsBatch]:
+    """Fetch logs for an app over a time range using count-then-fetch strategy.
+
+    Yields TaskLogsBatch objects in chronological order.
+    """
+    if filters is None:
+        filters = LogsFilters()
+
+    if since.tzinfo is None:
+        raise ValueError("since must be timezone-aware")
+    if until.tzinfo is None:
+        raise ValueError("until must be timezone-aware")
+
+    if until - since > _MAX_FETCH_RANGE:
+        raise LogsFetchError(f"Time range cannot exceed {_MAX_FETCH_RANGE.days} days.")
+
+    # Phase 1: Count logs per bucket
+    bucket_secs = _pick_bucket_secs(since, until)
+    count_req = api_pb2.AppCountLogsRequest(
+        app_id=app_id,
+        since=_datetime_to_timestamp(since),
+        until=_datetime_to_timestamp(until),
+        bucket_secs=bucket_secs,
+        source=filters.source,
+        function_id=filters.function_id,
+        function_call_id=filters.function_call_id,
+        task_id=filters.task_id,
+        sandbox_id=filters.sandbox_id,
+        search_text=filters.search_text,
+    )
+    count_resp: api_pb2.AppCountLogsResponse = await client.stub.AppCountLogs(count_req)
+
+    ranges = _buckets_to_ranges(list(count_resp.buckets), bucket_secs)
+    total_logs = sum(count for _, _, count in ranges)
+    if total_logs == 0:
+        return
+
+    # Trim leading/trailing empty buckets so they don't consume refinement
+    # budget. Interior zeros are kept to prevent merging across gaps.
+    while ranges and ranges[0][2] == 0:
+        ranges.pop(0)
+    while ranges and ranges[-1][2] == 0:
+        ranges.pop()
+
+    # Phase 1b: Refine any ranges that exceed the per-fetch limit.
+    # Budget: at most _MAX_FETCHES intervals, each fetching up to _FETCH_LIMIT entries.
+    ranges = await _refine_dense_ranges(
+        client,
+        app_id,
+        ranges,
+        filters,
+        max_ranges=_MAX_FETCHES,
+        max_iterations=_MAX_REFINE_ITERATIONS,
+    )
+    fetch_error_message = "Too many logs to fetch in time range. Consider narrowing the range or adding filters."
+    # Check that all ranges fit within the per-fetch limit.
+    over_limit = [r for r in ranges if r[2] > _FETCH_LIMIT]
+    if over_limit:
+        raise LogsFetchError(fetch_error_message)
+
+    # Phase 2: Build intervals from non-empty ranges and fetch in parallel
+    since_secs = since.timestamp()
+    until_secs = until.timestamp()
+    intervals = _build_fetch_intervals(ranges)
+    # Clamp intervals to the requested time range. Bucket boundaries may
+    # extend beyond the user's since/until (e.g. an 86400s bucket could
+    # include up to a full extra day).
+    intervals = [(max(s, since_secs), min(u, until_secs)) for s, u in intervals]
+    intervals = [(s, u) for s, u in intervals if s < u]
+    if not intervals:
+        return
+
+    if len(intervals) > _MAX_FETCHES:
+        raise LogsFetchError(fetch_error_message)
+
+    # Fetch all intervals concurrently (bounded by semaphore), but yield
+    # results in interval order so logs stay chronological. Awaiting each
+    # task in sequence lets us stream batches to the caller as soon as all
+    # preceding intervals have completed.
+    semaphore = asyncio.Semaphore(_MAX_CONCURRENT_FETCHES)
+
+    async def _bounded_fetch(since_s: float, until_s: float) -> list[api_pb2.TaskLogsBatch]:
+        async with semaphore:
+            return await _fetch_interval(
+                client,
+                app_id,
+                since_s,
+                until_s,
+                _FETCH_LIMIT,
+                filters,
+            )
+
+    tasks = [asyncio.create_task(_bounded_fetch(s, u)) for s, u in intervals]
+
+    try:
+        for task in tasks:
+            for batch in await task:
+                yield batch
+    finally:
+        for task in tasks:
+            task.cancel()

{modal-1.3.6.dev7 → modal-1.3.6.dev9}/modal/_output/manager.py

@@ -298,13 +298,31 @@ class OutputManager(ABC):
         ...
 
     @abstractmethod
-    async def put_log_content(self, log: "api_pb2.TaskLogs") -> None:
-        """Process and display log content.
+    async def put_streaming_log(self, log: "api_pb2.TaskLogs", prefix: str = "") -> None:
+        """Process and display log content with immediate output.
+
+        Use this for streaming paths (--follow, image logs) where logs arrive
+        in real time and should be displayed immediately.
 
         Note: In RichOutputManager, log output is always displayed even when quiet mode
         is enabled. This is intentional - quiet mode suppresses progress indicators and
         status messages, but not actual log output from running functions/images.
         In contrast, DisabledOutputManager suppresses all output including logs.
+
+        prefix: optional string to prepend to each log line (e.g. object IDs).
+        """
+        ...
+
+    @abstractmethod
+    async def put_fetched_log(self, log: "api_pb2.TaskLogs", prefix: str = "") -> None:
+        """Process and display log content with batched output.
+
+        Use this for bulk historical log fetching where thousands of entries
+        are processed in a tight loop. Output is buffered internally and
+        flushed periodically to avoid per-line stdout overhead. Call
+        flush_lines() after the loop to drain any remaining buffered output.
+
+        prefix: optional string to prepend to each log line (e.g. object IDs).
         """
         ...
 
@@ -382,7 +400,7 @@ class OutputManager(ABC):
         - All print() output is suppressed, including stderr
         - Progress indicators (spinners, progress bars) are suppressed
         - Warnings (via show_warning) are still displayed
-        - Log output (via put_log_content) is still displayed
+        - Log output (via put_streaming_log) is still displayed
         - Interactive/raw PTY content (via put_pty_content) is still forwarded to stdout
         - Error output (via print_error) is still displayed
 
@@ -516,7 +534,10 @@ class DisabledOutputManager(OutputManager):
     ) -> None:
         pass
 
-    async def put_log_content(self, log: "api_pb2.TaskLogs") -> None:
+    async def put_streaming_log(self, log: "api_pb2.TaskLogs", prefix: str = "") -> None:
+        pass
+
+    async def put_fetched_log(self, log: "api_pb2.TaskLogs", prefix: str = "") -> None:
         pass
 
     def flush_lines(self) -> None:

{modal-1.3.6.dev7 → modal-1.3.6.dev9}/modal/_output/pty.py

@@ -64,6 +64,30 @@ async def stream_pty_shell_input(client: "_Client", exec_id: str, finish_event:
         await finish_event.wait()
 
 
+_PREFIX_FIELD_GETTERS = {
+    "fu": lambda batch, log: batch.function_id,
+    "ta": lambda batch, log: batch.task_id,
+    "fc": lambda batch, log: log.function_call_id,
+}
+
+
+def _build_log_prefix(batch: api_pb2.TaskLogsBatch, log: api_pb2.TaskLogs, prefix_fields: list[str]) -> str:
+    """Build a prefix string from batch/log fields based on requested prefix types.
+
+    The order of prefix_fields controls the order of the output.
+    """
+    if not prefix_fields:
+        return ""
+    parts = []
+    for field in prefix_fields:
+        getter = _PREFIX_FIELD_GETTERS.get(field)
+        if getter:
+            value = getter(batch, log)
+            if value:
+                parts.append(value)
+    return " ".join(parts)
+
+
 async def get_app_logs_loop(
     client: "_Client",
     output_mgr: "OutputManager",
@@ -71,8 +95,15 @@ async def get_app_logs_loop(
     task_id: Optional[str] = None,
     sandbox_id: Optional[str] = None,
     follow: bool = True,
+    last_entry_id: str = "",
+    prefix_fields: Optional[list[str]] = None,
+    file_descriptor: "api_pb2.FileDescriptor.ValueType" = api_pb2.FILE_DESCRIPTOR_UNSPECIFIED,
+    function_id: str = "",
+    function_call_id: str = "",
+    search_text: str = "",
 ):
-    last_log_batch_entry_id = ""
+    last_log_batch_entry_id = last_entry_id
+    _prefixes = prefix_fields or []
 
     pty_shell_finish_event: Optional[asyncio.Event] = None
     pty_shell_task_id: Optional[str] = None
@@ -112,10 +143,15 @@ async def get_app_logs_loop(
             else:  # Ensure forward-compatible with new types.
                 logger.debug(f"Received unrecognized progress type: {log.task_progress.progress_type}")
         elif log.data:
+            # Client-side search filter for Redis streaming (AppGetLogs
+            # doesn't support server-side search)
+            if search_text and search_text not in log.data:
+                return
             if pty_shell_finish_event:
                 await output_mgr.put_pty_content(log)
             else:
-                await output_mgr.put_log_content(log)
+                log_prefix = _build_log_prefix(log_batch, log, _prefixes)
+                await output_mgr.put_streaming_log(log, prefix=log_prefix)
 
     async def _get_logs():
         nonlocal last_log_batch_entry_id
@@ -127,6 +163,9 @@ async def get_app_logs_loop(
             sandbox_id=sandbox_id or "",
             timeout=55 if follow else 0,
             last_entry_id=last_log_batch_entry_id,
+            file_descriptor=file_descriptor,
+            function_id=function_id,
+            function_call_id=function_call_id,
         )
         log_batch: api_pb2.TaskLogsBatch
         async for log_batch in client.stub.AppGetLogs.unary_stream(request):