diff --git a/resolvers/load.py b/resolvers/load.py
index 4186d4b..769bdb8 100644
--- a/resolvers/load.py
+++ b/resolvers/load.py
@@ -65,44 +65,49 @@ async def load_chats(_, info, limit: int = 50, offset: int = 0) -> Dict[str, Uni
     """load :limit chats of current user with :offset"""
     author_id = info.context["author_id"]
     chats = []
-    if author_id:
-        logger.debug("got author", author_id)
-        cids = await redis.execute("SMEMBERS", f"chats_by_author/{author_id}")
-        logger.debug("got cids", cids)
-        members_online = (await redis.execute("SMEMBERS", "authors-online")) or [] # to show online status
-        logger.debug("members online", members_online)
-        if isinstance(cids, set):
-            # TODO: add sort by chat.created_at with in-memory caching chats service
-            cids = list(cids)[offset : (offset + limit)]
-            lock = asyncio.Lock()
-            if len(cids) == 0:
-                logger.debug(f"no chats for user with id={author_id}")
-                r = await create_chat(None, info, members=[2])  # member with id = 2 is discours
-                logger.debug(f"created chat: {r['chat_id']}")
-                cids.append(r["chat"]["id"])
+    try:
+        if author_id:
+            logger.debug("got author", author_id)
+            cids = await redis.execute("SMEMBERS", f"chats_by_author/{author_id}")
+            logger.debug("got cids", cids)
+            members_online = (await redis.execute("SMEMBERS", "authors-online")) or [] # to show online status
+            logger.debug("members online", members_online)
+            if isinstance(cids, set):
+                # TODO: add sort by chat.created_at with in-memory caching chats service
+                cids = list(cids)[offset : (offset + limit)]
+                lock = asyncio.Lock()
+                if len(cids) == 0:
+                    logger.debug(f"no chats for user with id={author_id}")
+                    r = await create_chat(None, info, members=[2])  # member with id = 2 is discours
+                    logger.debug(f"created chat: {r['chat_id']}")
+                    cids.append(r["chat"]["id"])
 
-            logger.debug(f"getting data for {len(cids)} user's chats")
-            for cid in cids:
-                async with lock:
-                    chat_str = await redis.execute("GET", f"chats/{cid}")
-                    if isinstance(chat_str, str):
-                        logger.debug(f"redis GET by {cid}: {chat_str}")
-                        c: ChatPayload = json.loads(chat_str)
-                        c["messages"] = (await load_messages(cid, 5, 0)) or []
-                        c["unread"] = await get_unread_counter(cid, author_id)
-                        member_ids = c["members"].copy()
-                        c["members"] = []
-                        for member_id in member_ids:
-                            a = CacheStorage.authors_by_id.get(member_id)
-                            if a:
-                                a["online"] = a.get("id") in members_online
-                                c["members"].append(a)
-                            else:
-                                logger.error(f"cant find author by id {member_id}")
-                        chats.append(c)
+                logger.debug(f"getting data for {len(cids)} user's chats")
+                for cid in cids:
+                    async with lock:
+                        chat_str = await redis.execute("GET", f"chats/{cid}")
+                        if isinstance(chat_str, str):
+                            logger.debug(f"redis GET by {cid}: {chat_str}")
+                            c: ChatPayload = json.loads(chat_str)
+                            c["messages"] = (await load_messages(cid, 5, 0)) or []
+                            c["unread"] = await get_unread_counter(cid, author_id)
+                            member_ids = c["members"].copy()
+                            c["members"] = []
+                            for member_id in member_ids:
+                                a = CacheStorage.authors_by_id.get(member_id)
+                                if a:
+                                    a["online"] = a.get("id") in members_online
+                                    c["members"].append(a)
+                                else:
+                                    logger.error(f"cant find author by id {member_id}")
+                            chats.append(c)
 
-                    else:
-                        logger.error(f"cant find chat by id {cid}")
+                        else:
+                            logger.error(f"cant find chat by id {cid}")
+    except Exception as error:
+        import traceback
+
+        traceback.print_exc()
     return {"chats": chats, "error": None}
 
 
@@ -111,24 +116,30 @@ async def load_chats(_, info, limit: int = 50, offset: int = 0) -> Dict[str, Uni
 async def load_messages_by(_, info, by, limit: int = 10, offset: int = 0):
     """load :limit messages of :chat_id with :offset"""
     author_id = info.context["author_id"]
-    author_chats = await redis.execute("SMEMBERS", "chats_by_author/" + str(author_id))
-    if isinstance(author_chats, set):
-        author_chats = list(author_chats)
-        messages = []
-        by_chat = by.get("chat")
-        if by_chat in author_chats:
-            chat = await redis.execute("GET", f"chats/{by_chat}")
-            if not chat:
-                return {"messages": [], "error": "chat not exist"}
-            # everyone's messages in filtered chat
-            messages = await load_messages(by_chat, limit, offset)
-            if isinstance(messages, list):
-                sorted_messages = [m for m in messages if m and m.get("created_at")]
-                return {
-                    "messages": sorted(
-                        sorted_messages,
-                        key=lambda m: m.get("created_at"),
-                    ),
-                    "error": None,
-                }
+    author_chats = await redis.execute("SMEMBERS", f"chats_by_author/{author_id}")
+    try:
+        if isinstance(author_chats, set):
+            author_chats = list(author_chats)
+            messages = []
+            by_chat = by.get("chat")
+            if by_chat in author_chats:
+                chat = await redis.execute("GET", f"chats/{by_chat}")
+                if not chat:
+                    return {"messages": [], "error": "chat not exist"}
+                # everyone's messages in filtered chat
+                messages = await load_messages(by_chat, limit, offset)
+                if isinstance(messages, list):
+                    sorted_messages = [m for m in messages if m and m.get("created_at")]
+                    return {
+                        "messages": sorted(
+                            sorted_messages,
+                            key=lambda m: m.get("created_at"),
+                        ),
+                        "error": None,
+                    }
+
+    except Exception as error:
+        import traceback
+
+        traceback.print_exc()
     return {"error": "Cannot get messages of this chat"}