agno 2.3.7__py3-none-any.whl → 2.3.8__py3-none-any.whl

agno/db/mongo/async_mongo.py

@@ -2265,14 +2265,6 @@ class AsyncMongoDb(AsyncBaseDb):
                 if trace.workflow_id is not None:
                     update_values["workflow_id"] = trace.workflow_id
 
-                log_debug(
-                    f"  Updating trace with context: run_id={update_values.get('run_id', 'unchanged')}, "
-                    f"session_id={update_values.get('session_id', 'unchanged')}, "
-                    f"user_id={update_values.get('user_id', 'unchanged')}, "
-                    f"agent_id={update_values.get('agent_id', 'unchanged')}, "
-                    f"team_id={update_values.get('team_id', 'unchanged')}, "
-                )
-
                 await collection.update_one({"trace_id": trace.trace_id}, {"$set": update_values})
             else:
                 trace_dict = trace.to_dict()
@@ -2380,11 +2372,6 @@ class AsyncMongoDb(AsyncBaseDb):
         try:
             from agno.tracing.schemas import Trace as TraceSchema
 
-            log_debug(
-                f"get_traces called with filters: run_id={run_id}, session_id={session_id}, "
-                f"user_id={user_id}, agent_id={agent_id}, page={page}, limit={limit}"
-            )
-
             collection = await self._get_collection(table_type="traces")
             if collection is None:
                 log_debug("Traces collection not found")
@@ -2398,7 +2385,6 @@ class AsyncMongoDb(AsyncBaseDb):
             if run_id:
                 query["run_id"] = run_id
             if session_id:
-                log_debug(f"Filtering by session_id={session_id}")
                 query["session_id"] = session_id
             if user_id:
                 query["user_id"] = user_id
@@ -2420,14 +2406,12 @@ class AsyncMongoDb(AsyncBaseDb):
 
             # Get total count
             total_count = await collection.count_documents(query)
-            log_debug(f"Total matching traces: {total_count}")
 
             # Apply pagination
             skip = ((page or 1) - 1) * (limit or 20)
             cursor = collection.find(query).sort("start_time", -1).skip(skip).limit(limit or 20)
 
             results = await cursor.to_list(length=None)
-            log_debug(f"Returning page {page} with {len(results)} traces")
 
             traces = []
             for row in results:
@@ -2481,12 +2465,6 @@ class AsyncMongoDb(AsyncBaseDb):
                 workflow_id, first_trace_at, last_trace_at.
         """
         try:
-            log_debug(
-                f"get_trace_stats called with filters: user_id={user_id}, agent_id={agent_id}, "
-                f"workflow_id={workflow_id}, team_id={team_id}, "
-                f"start_time={start_time}, end_time={end_time}, page={page}, limit={limit}"
-            )
-
             collection = await self._get_collection(table_type="traces")
             if collection is None:
                 log_debug("Traces collection not found")
@@ -2532,7 +2510,6 @@ class AsyncMongoDb(AsyncBaseDb):
             count_pipeline = pipeline + [{"$count": "total"}]
             count_result = await collection.aggregate(count_pipeline).to_list(length=1)
             total_count = count_result[0]["total"] if count_result else 0
-            log_debug(f"Total matching sessions: {total_count}")
 
             # Apply pagination
             skip = ((page or 1) - 1) * (limit or 20)
@@ -2540,7 +2517,6 @@ class AsyncMongoDb(AsyncBaseDb):
             pipeline.append({"$limit": limit or 20})
 
             results = await collection.aggregate(pipeline).to_list(length=None)
-            log_debug(f"Returning page {page} with {len(results)} session stats")
 
             # Convert to list of dicts with datetime objects
             stats_list = []

agno/db/mongo/mongo.py

@@ -2217,11 +2217,6 @@ class MongoDb(BaseDb):
         try:
             from agno.tracing.schemas import Trace as TraceSchema
 
-            log_debug(
-                f"get_traces called with filters: run_id={run_id}, session_id={session_id}, "
-                f"user_id={user_id}, agent_id={agent_id}, page={page}, limit={limit}"
-            )
-
             collection = self._get_collection(table_type="traces")
             if collection is None:
                 log_debug("Traces collection not found")
@@ -2235,7 +2230,6 @@ class MongoDb(BaseDb):
             if run_id:
                 query["run_id"] = run_id
             if session_id:
-                log_debug(f"Filtering by session_id={session_id}")
                 query["session_id"] = session_id
             if user_id:
                 query["user_id"] = user_id
@@ -2257,14 +2251,12 @@ class MongoDb(BaseDb):
 
             # Get total count
             total_count = collection.count_documents(query)
-            log_debug(f"Total matching traces: {total_count}")
 
             # Apply pagination
             skip = ((page or 1) - 1) * (limit or 20)
             cursor = collection.find(query).sort("start_time", -1).skip(skip).limit(limit or 20)
 
             results = list(cursor)
-            log_debug(f"Returning page {page} with {len(results)} traces")
 
             traces = []
             for row in results:
@@ -2318,12 +2310,6 @@ class MongoDb(BaseDb):
                 workflow_id, first_trace_at, last_trace_at.
         """
         try:
-            log_debug(
-                f"get_trace_stats called with filters: user_id={user_id}, agent_id={agent_id}, "
-                f"workflow_id={workflow_id}, team_id={team_id}, "
-                f"start_time={start_time}, end_time={end_time}, page={page}, limit={limit}"
-            )
-
             collection = self._get_collection(table_type="traces")
             if collection is None:
                 log_debug("Traces collection not found")
@@ -2369,7 +2355,6 @@ class MongoDb(BaseDb):
             count_pipeline = pipeline + [{"$count": "total"}]
             count_result = list(collection.aggregate(count_pipeline))
             total_count = count_result[0]["total"] if count_result else 0
-            log_debug(f"Total matching sessions: {total_count}")
 
             # Apply pagination
             skip = ((page or 1) - 1) * (limit or 20)
@@ -2377,7 +2362,6 @@ class MongoDb(BaseDb):
             pipeline.append({"$limit": limit or 20})
 
             results = list(collection.aggregate(pipeline))
-            log_debug(f"Returning page {page} with {len(results)} session stats")
 
             # Convert to list of dicts with datetime objects
             stats_list = []

agno/db/mysql/mysql.py

@@ -2514,14 +2514,6 @@ class MySQLDb(BaseDb):
                     if trace.workflow_id is not None:
                         update_values["workflow_id"] = trace.workflow_id
 
-                    log_debug(
-                        f"  Updating trace with context: run_id={update_values.get('run_id', 'unchanged')}, "
-                        f"session_id={update_values.get('session_id', 'unchanged')}, "
-                        f"user_id={update_values.get('user_id', 'unchanged')}, "
-                        f"agent_id={update_values.get('agent_id', 'unchanged')}, "
-                        f"team_id={update_values.get('team_id', 'unchanged')}, "
-                    )
-
                     stmt = update(table).where(table.c.trace_id == trace.trace_id).values(**update_values)
                     sess.execute(stmt)
                 else:
@@ -2642,7 +2634,6 @@ class MySQLDb(BaseDb):
                 if run_id:
                     base_stmt = base_stmt.where(table.c.run_id == run_id)
                 if session_id:
-                    log_debug(f"Filtering by session_id={session_id}")
                     base_stmt = base_stmt.where(table.c.session_id == session_id)
                 if user_id:
                     base_stmt = base_stmt.where(table.c.user_id == user_id)
@@ -2664,14 +2655,12 @@ class MySQLDb(BaseDb):
                 # Get total count
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = sess.execute(count_stmt).scalar() or 0
-                log_debug(f"Total matching traces: {total_count}")
 
                 # Apply pagination
                 offset = (page - 1) * limit if page and limit else 0
                 paginated_stmt = base_stmt.order_by(table.c.start_time.desc()).limit(limit).offset(offset)
 
                 results = sess.execute(paginated_stmt).fetchall()
-                log_debug(f"Returning page {page} with {len(results)} traces")
 
                 traces = [Trace.from_dict(dict(row._mapping)) for row in results]
                 return traces, total_count
@@ -2709,12 +2698,6 @@ class MySQLDb(BaseDb):
                 workflow_id, first_trace_at, last_trace_at.
         """
         try:
-            log_debug(
-                f"get_trace_stats called with filters: user_id={user_id}, agent_id={agent_id}, "
-                f"workflow_id={workflow_id}, team_id={team_id}, "
-                f"start_time={start_time}, end_time={end_time}, page={page}, limit={limit}"
-            )
-
             table = self._get_table(table_type="traces")
             if table is None:
                 log_debug("Traces table not found")
@@ -2758,14 +2741,12 @@ class MySQLDb(BaseDb):
                 # Get total count of sessions
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = sess.execute(count_stmt).scalar() or 0
-                log_debug(f"Total matching sessions: {total_count}")
 
                 # Apply pagination and ordering
                 offset = (page - 1) * limit if page and limit else 0
                 paginated_stmt = base_stmt.order_by(func.max(table.c.created_at).desc()).limit(limit).offset(offset)
 
                 results = sess.execute(paginated_stmt).fetchall()
-                log_debug(f"Returning page {page} with {len(results)} session stats")
 
                 # Convert to list of dicts with datetime objects
                 stats_list = []

agno/db/postgres/async_postgres.py

@@ -2186,14 +2186,6 @@ class AsyncPostgresDb(AsyncBaseDb):
                     if trace.workflow_id is not None:
                         update_values["workflow_id"] = trace.workflow_id
 
-                    log_debug(
-                        f"  Updating trace with context: run_id={update_values.get('run_id', 'unchanged')}, "
-                        f"session_id={update_values.get('session_id', 'unchanged')}, "
-                        f"user_id={update_values.get('user_id', 'unchanged')}, "
-                        f"agent_id={update_values.get('agent_id', 'unchanged')}, "
-                        f"team_id={update_values.get('team_id', 'unchanged')}, "
-                    )
-
                     stmt = update(table).where(table.c.trace_id == trace.trace_id).values(**update_values)
                     await sess.execute(stmt)
                 else:
@@ -2293,10 +2285,6 @@ class AsyncPostgresDb(AsyncBaseDb):
         try:
             from agno.tracing.schemas import Trace
 
-            log_debug(
-                f"get_traces called with filters: run_id={run_id}, session_id={session_id}, user_id={user_id}, agent_id={agent_id}, page={page}, limit={limit}"
-            )
-
             table = await self._get_table(table_type="traces")
 
             # Get spans table for JOIN
@@ -2310,7 +2298,6 @@ class AsyncPostgresDb(AsyncBaseDb):
                 if run_id:
                     base_stmt = base_stmt.where(table.c.run_id == run_id)
                 if session_id:
-                    log_debug(f"Filtering by session_id={session_id}")
                     base_stmt = base_stmt.where(table.c.session_id == session_id)
                 if user_id:
                     base_stmt = base_stmt.where(table.c.user_id == user_id)
@@ -2378,12 +2365,6 @@ class AsyncPostgresDb(AsyncBaseDb):
                 workflow_id, first_trace_at, last_trace_at.
         """
         try:
-            log_debug(
-                f"get_trace_stats called with filters: user_id={user_id}, agent_id={agent_id}, "
-                f"workflow_id={workflow_id}, team_id={team_id}, "
-                f"start_time={start_time}, end_time={end_time}, page={page}, limit={limit}"
-            )
-
             table = await self._get_table(table_type="traces")
 
             async with self.async_session_factory() as sess:
@@ -2424,7 +2405,6 @@ class AsyncPostgresDb(AsyncBaseDb):
                 # Get total count of sessions
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = await sess.scalar(count_stmt) or 0
-                log_debug(f"Total matching sessions: {total_count}")
 
                 # Apply pagination and ordering
                 offset = (page - 1) * limit if page and limit else 0
@@ -2432,7 +2412,6 @@ class AsyncPostgresDb(AsyncBaseDb):
 
                 result = await sess.execute(paginated_stmt)
                 results = result.fetchall()
-                log_debug(f"Returning page {page} with {len(results)} session stats")
 
                 # Convert to list of dicts with datetime objects
                 stats_list = []

agno/db/postgres/postgres.py

@@ -2466,14 +2466,6 @@ class PostgresDb(BaseDb):
                     if trace.workflow_id is not None:
                         update_values["workflow_id"] = trace.workflow_id
 
-                    log_debug(
-                        f"  Updating trace with context: run_id={update_values.get('run_id', 'unchanged')}, "
-                        f"session_id={update_values.get('session_id', 'unchanged')}, "
-                        f"user_id={update_values.get('user_id', 'unchanged')}, "
-                        f"agent_id={update_values.get('agent_id', 'unchanged')}, "
-                        f"team_id={update_values.get('team_id', 'unchanged')}, "
-                    )
-
                     stmt = update(table).where(table.c.trace_id == trace.trace_id).values(**update_values)
                     sess.execute(stmt)
                 else:
@@ -2574,10 +2566,6 @@ class PostgresDb(BaseDb):
         try:
             from agno.tracing.schemas import Trace
 
-            log_debug(
-                f"get_traces called with filters: run_id={run_id}, session_id={session_id}, user_id={user_id}, agent_id={agent_id}, page={page}, limit={limit}"
-            )
-
             table = self._get_table(table_type="traces")
             if table is None:
                 log_debug("Traces table not found")
@@ -2594,7 +2582,6 @@ class PostgresDb(BaseDb):
                 if run_id:
                     base_stmt = base_stmt.where(table.c.run_id == run_id)
                 if session_id:
-                    log_debug(f"Filtering by session_id={session_id}")
                     base_stmt = base_stmt.where(table.c.session_id == session_id)
                 if user_id:
                     base_stmt = base_stmt.where(table.c.user_id == user_id)
@@ -2616,14 +2603,12 @@ class PostgresDb(BaseDb):
                 # Get total count
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = sess.execute(count_stmt).scalar() or 0
-                log_debug(f"Total matching traces: {total_count}")
 
                 # Apply pagination
                 offset = (page - 1) * limit if page and limit else 0
                 paginated_stmt = base_stmt.order_by(table.c.start_time.desc()).limit(limit).offset(offset)
 
                 results = sess.execute(paginated_stmt).fetchall()
-                log_debug(f"Returning page {page} with {len(results)} traces")
 
                 traces = [Trace.from_dict(dict(row._mapping)) for row in results]
                 return traces, total_count
@@ -2661,12 +2646,6 @@ class PostgresDb(BaseDb):
                 first_trace_at, last_trace_at.
         """
         try:
-            log_debug(
-                f"get_trace_stats called with filters: user_id={user_id}, agent_id={agent_id}, "
-                f"workflow_id={workflow_id}, team_id={team_id}, "
-                f"start_time={start_time}, end_time={end_time}, page={page}, limit={limit}"
-            )
-
             table = self._get_table(table_type="traces")
             if table is None:
                 log_debug("Traces table not found")
@@ -2710,14 +2689,12 @@ class PostgresDb(BaseDb):
                 # Get total count of sessions
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = sess.execute(count_stmt).scalar() or 0
-                log_debug(f"Total matching sessions: {total_count}")
 
                 # Apply pagination and ordering
                 offset = (page - 1) * limit if page and limit else 0
                 paginated_stmt = base_stmt.order_by(func.max(table.c.created_at).desc()).limit(limit).offset(offset)
 
                 results = sess.execute(paginated_stmt).fetchall()
-                log_debug(f"Returning page {page} with {len(results)} session stats")
 
                 # Convert to list of dicts with datetime objects
                 stats_list = []

agno/db/redis/redis.py

@@ -1919,14 +1919,12 @@ class RedisDb(BaseDb):
                 filtered_traces.append(trace)
 
             total_count = len(filtered_traces)
-            log_debug(f"Total matching traces: {total_count}")
 
             # Sort by start_time descending
             filtered_traces.sort(key=lambda x: x.get("start_time", ""), reverse=True)
 
             # Apply pagination
             paginated_traces = apply_pagination(records=filtered_traces, limit=limit, page=page)
-            log_debug(f"Returning page {page} with {len(paginated_traces)} traces")
 
             traces = []
             for row in paginated_traces:
@@ -2025,11 +2023,9 @@ class RedisDb(BaseDb):
             stats_list.sort(key=lambda x: x.get("last_trace_at", ""), reverse=True)
 
             total_count = len(stats_list)
-            log_debug(f"Total matching sessions: {total_count}")
 
             # Apply pagination
             paginated_stats = apply_pagination(records=stats_list, limit=limit, page=page)
-            log_debug(f"Returning page {page} with {len(paginated_stats)} session stats")
 
             # Convert ISO strings to datetime objects
             for stat in paginated_stats:

agno/db/singlestore/singlestore.py

@@ -2461,14 +2461,6 @@ class SingleStoreDb(BaseDb):
                     if trace.workflow_id is not None:
                         update_values["workflow_id"] = trace.workflow_id
 
-                    log_debug(
-                        f"  Updating trace with context: run_id={update_values.get('run_id', 'unchanged')}, "
-                        f"session_id={update_values.get('session_id', 'unchanged')}, "
-                        f"user_id={update_values.get('user_id', 'unchanged')}, "
-                        f"agent_id={update_values.get('agent_id', 'unchanged')}, "
-                        f"team_id={update_values.get('team_id', 'unchanged')}, "
-                    )
-
                     update_stmt = update(table).where(table.c.trace_id == trace.trace_id).values(**update_values)
                     sess.execute(update_stmt)
                 else:
@@ -2589,7 +2581,6 @@ class SingleStoreDb(BaseDb):
                 if run_id:
                     base_stmt = base_stmt.where(table.c.run_id == run_id)
                 if session_id:
-                    log_debug(f"Filtering by session_id={session_id}")
                     base_stmt = base_stmt.where(table.c.session_id == session_id)
                 if user_id:
                     base_stmt = base_stmt.where(table.c.user_id == user_id)
@@ -2611,14 +2602,12 @@ class SingleStoreDb(BaseDb):
                 # Get total count
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = sess.execute(count_stmt).scalar() or 0
-                log_debug(f"Total matching traces: {total_count}")
 
                 # Apply pagination
                 offset = (page - 1) * limit if page and limit else 0
                 paginated_stmt = base_stmt.order_by(table.c.start_time.desc()).limit(limit).offset(offset)
 
                 results = sess.execute(paginated_stmt).fetchall()
-                log_debug(f"Returning page {page} with {len(results)} traces")
 
                 traces = [Trace.from_dict(dict(row._mapping)) for row in results]
                 return traces, total_count

agno/db/sqlite/async_sqlite.py

@@ -363,7 +363,6 @@ class AsyncSqliteDb(AsyncBaseDb):
                     return Table(table_name, self.metadata, autoload_with=connection)
 
                 table = await conn.run_sync(load_table)
-                log_debug(f"Loaded existing table {table_name}")
                 return table
 
         except Exception as e:
@@ -2513,14 +2512,6 @@ class AsyncSqliteDb(AsyncBaseDb):
                     if trace.workflow_id is not None:
                         update_values["workflow_id"] = trace.workflow_id
 
-                    log_debug(
-                        f"  Updating trace with context: run_id={update_values.get('run_id', 'unchanged')}, "
-                        f"session_id={update_values.get('session_id', 'unchanged')}, "
-                        f"user_id={update_values.get('user_id', 'unchanged')}, "
-                        f"agent_id={update_values.get('agent_id', 'unchanged')}, "
-                        f"team_id={update_values.get('team_id', 'unchanged')}, "
-                    )
-
                     stmt = update(table).where(table.c.trace_id == trace.trace_id).values(**update_values)
                     await sess.execute(stmt)
                 else:
@@ -2622,10 +2613,6 @@ class AsyncSqliteDb(AsyncBaseDb):
         try:
             from agno.tracing.schemas import Trace
 
-            log_debug(
-                f"get_traces called with filters: run_id={run_id}, session_id={session_id}, user_id={user_id}, agent_id={agent_id}, page={page}, limit={limit}"
-            )
-
             table = await self._get_table(table_type="traces")
             if table is None:
                 log_debug("Traces table not found")
@@ -2642,7 +2629,6 @@ class AsyncSqliteDb(AsyncBaseDb):
                 if run_id:
                     base_stmt = base_stmt.where(table.c.run_id == run_id)
                 if session_id:
-                    log_debug(f"Filtering by session_id={session_id}")
                     base_stmt = base_stmt.where(table.c.session_id == session_id)
                 if user_id:
                     base_stmt = base_stmt.where(table.c.user_id == user_id)
@@ -2664,7 +2650,6 @@ class AsyncSqliteDb(AsyncBaseDb):
                 # Get total count
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = await sess.scalar(count_stmt) or 0
-                log_debug(f"Total matching traces: {total_count}")
 
                 # Apply pagination
                 offset = (page - 1) * limit if page and limit else 0
@@ -2672,7 +2657,6 @@ class AsyncSqliteDb(AsyncBaseDb):
 
                 result = await sess.execute(paginated_stmt)
                 results = result.fetchall()
-                log_debug(f"Returning page {page} with {len(results)} traces")
 
                 traces = [Trace.from_dict(dict(row._mapping)) for row in results]
                 return traces, total_count
@@ -2710,12 +2694,6 @@ class AsyncSqliteDb(AsyncBaseDb):
                 workflow_id, first_trace_at, last_trace_at.
         """
         try:
-            log_debug(
-                f"get_trace_stats called with filters: user_id={user_id}, agent_id={agent_id}, "
-                f"workflow_id={workflow_id}, team_id={team_id}, "
-                f"start_time={start_time}, end_time={end_time}, page={page}, limit={limit}"
-            )
-
             table = await self._get_table(table_type="traces")
             if table is None:
                 log_debug("Traces table not found")
@@ -2759,7 +2737,6 @@ class AsyncSqliteDb(AsyncBaseDb):
                 # Get total count of sessions
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = await sess.scalar(count_stmt) or 0
-                log_debug(f"Total matching sessions: {total_count}")
 
                 # Apply pagination and ordering
                 offset = (page - 1) * limit if page and limit else 0
@@ -2767,7 +2744,6 @@ class AsyncSqliteDb(AsyncBaseDb):
 
                 result = await sess.execute(paginated_stmt)
                 results = result.fetchall()
-                log_debug(f"Returning page {page} with {len(results)} session stats")
 
                 # Convert to list of dicts with datetime objects
                 stats_list = []

agno/db/sqlite/sqlite.py

@@ -362,7 +362,6 @@ class SqliteDb(BaseDb):
 
         try:
             table = Table(table_name, self.metadata, autoload_with=self.db_engine)
-            log_debug(f"Loaded existing table {table_name}")
             return table
 
         except Exception as e:
@@ -2217,14 +2216,6 @@ class SqliteDb(BaseDb):
                     if trace.workflow_id is not None:
                         update_values["workflow_id"] = trace.workflow_id
 
-                    log_debug(
-                        f"  Updating trace with context: run_id={update_values.get('run_id', 'unchanged')}, "
-                        f"session_id={update_values.get('session_id', 'unchanged')}, "
-                        f"user_id={update_values.get('user_id', 'unchanged')}, "
-                        f"agent_id={update_values.get('agent_id', 'unchanged')}, "
-                        f"team_id={update_values.get('team_id', 'unchanged')}, "
-                    )
-
                     stmt = update(table).where(table.c.trace_id == trace.trace_id).values(**update_values)
                     sess.execute(stmt)
                 else:
@@ -2347,7 +2338,6 @@ class SqliteDb(BaseDb):
                 if run_id:
                     base_stmt = base_stmt.where(table.c.run_id == run_id)
                 if session_id:
-                    log_debug(f"Filtering by session_id={session_id}")
                     base_stmt = base_stmt.where(table.c.session_id == session_id)
                 if user_id:
                     base_stmt = base_stmt.where(table.c.user_id == user_id)
@@ -2369,14 +2359,12 @@ class SqliteDb(BaseDb):
                 # Get total count
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = sess.execute(count_stmt).scalar() or 0
-                log_debug(f"Total matching traces: {total_count}")
 
                 # Apply pagination
                 offset = (page - 1) * limit if page and limit else 0
                 paginated_stmt = base_stmt.order_by(table.c.start_time.desc()).limit(limit).offset(offset)
 
                 results = sess.execute(paginated_stmt).fetchall()
-                log_debug(f"Returning page {page} with {len(results)} traces")
 
                 traces = [Trace.from_dict(dict(row._mapping)) for row in results]
                 return traces, total_count
@@ -2414,12 +2402,6 @@ class SqliteDb(BaseDb):
         try:
             from sqlalchemy import func
 
-            log_debug(
-                f"get_trace_stats called with filters: user_id={user_id}, agent_id={agent_id}, "
-                f"workflow_id={workflow_id}, team_id={team_id}, "
-                f"start_time={start_time}, end_time={end_time}, page={page}, limit={limit}"
-            )
-
             table = self._get_table(table_type="traces")
             if table is None:
                 log_debug("Traces table not found")
@@ -2463,14 +2445,12 @@ class SqliteDb(BaseDb):
                 # Get total count of sessions
                 count_stmt = select(func.count()).select_from(base_stmt.alias())
                 total_count = sess.execute(count_stmt).scalar() or 0
-                log_debug(f"Total matching sessions: {total_count}")
 
                 # Apply pagination and ordering
                 offset = (page - 1) * limit if page and limit else 0
                 paginated_stmt = base_stmt.order_by(func.max(table.c.created_at).desc()).limit(limit).offset(offset)
 
                 results = sess.execute(paginated_stmt).fetchall()
-                log_debug(f"Returning page {page} with {len(results)} session stats")
 
                 # Convert to list of dicts with datetime objects
                 from datetime import datetime