fix:bug

src/core/callcenter/agent.py

@@ -2,12 +2,15 @@
 # encoding:utf-8
 
 import threading
+import time
+import traceback
 from collections import defaultdict
 from concurrent.futures import ThreadPoolExecutor
 from typing import List
 
 from sqlalchemy import or_
 
+from src.core.callcenter import registry
 import src.core.callcenter.esl.utils.esl_event_util as EslEventUtil
 from src.core import with_app_context
 from src.core.callcenter.api import AgentActionRequest, AgentQueryRequest, AgentRequest, AgentEventData, \
@@ -84,81 +87,87 @@ class AgentEventService:
         called = device_info.called if device_info else None
         is_agent = (device_info and DeviceType.AGENT.code == device_info.device_type) if device_info else False
 
-        self.logger.info('agent_event_channel, event_name=%s, call_id=%s, device_id=%s, is_agent=%s', event_name, call_id, device_id, is_agent)
-        agent = self.data_handle_server.get_agent(saas_id, agent_num)
-        if not agent:
-            # self.logger.warn("event service channel agent is null %s %s %s %s %s", saas_id, event_name, caller, called, json.loads(event.serialize('json')))
-            return
-        agent_monitor = self.data_handle_server.get_agent_monitor(saas_id, agent_num)
-        if not agent_monitor:
-            # self.logger.warn("event service channel agentMonitor is null %s %s %s %s %s", saas_id, event_name, caller, called, json.loads(event.serialize('json')))
-            return
-
-        # 信道发起事件，触发完成发起（或桥）&& 坐席侧
-        if CHANNEL_ORIGINATE == event_name and is_agent:
-            self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_RINGING,phone=call_info.caller)
-
-        # 进度事件，外呼时对方提醒。或者入呼时提醒 && 坐席侧
-        if CHANNEL_PROGRESS == event_name and is_agent:
-            self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.MANUAL, AgentServiceState.DIALING)
-            self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_CALLING)
-
-        # 媒体进度事件，外呼时对方提醒。或者入呼时提醒 && 用户侧
-        if CHANNEL_PROGRESS_MEDIA == event_name and not is_agent:
-            self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_CALLING_RINGING)
-
-        #应答
-        if CHANNEL_ANSWER == event_name:
-            if call_id:
-                if self.cache.get_call_is_end(call_id):
-                    # self.logger.warn("event service channel call is end {} {} {} {} {} {}", saas_id, event_name, caller, called, call_id, json.dumps(event.serialize('json')))
-                    return
-
-            self.agent_state_service.busy(saas_id, agent.agent_num, agent.phone_num)
-            self.data_handle_server.update_record(call_id, status=1)
-            if is_agent:
-                # 坐席接起
-                self.cache.set_call_is_answer(saas_id, flow_id)
-                self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.ANSWER_COMPENSATE)
-                self.push_handler.push_answer_call(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, ServiceDirect.MANUAL_CALL.service_direct, WorkStatus.AGENT_HANG_REPROCESSING)
-
-                self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.CALLING, AgentLogState.CHANNEL_TURN_ON)
-            else:
-                # 用户侧接起
-                self.agent_monitor_service.update_calling(agent_monitor)
-                self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_ANSWER_OUTGOING)
-                self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.MANUAL, AgentServiceState.CALLING)
-
-        #挂断
-        if CHANNEL_HANGUP == event_name:
-            # 坐席侧挂断
-            if is_agent:
-                if call_id:
-                    self.cache.set_call_is_end(call_id)
-            self.agent_monitor_service.update_processing(agent_monitor)
-            self.reprocessing_idle(AgentDelayStateData(saas_id, flow_id, agent_num, AgentServiceState.REPROCESSING, AgentScene.MANUAL))
-            self.push_handler.push_on_call_end(saas_id, flow_id, agent_num, AgentScene.MANUAL, ServiceDirect.MANUAL_CALL.service_direct, '0')
-            self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_HANG_REPROCESSING)
-            self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.MANUAL, AgentServiceState.REPROCESSING)
-
-            self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.REPROCESSING, AgentLogState.CHANNEL_HANG_UP)
-
-            self.data_handle_server.update_record(call_id, time_end=datetime.now())
-            # 同步处理后处理置闲
-            # reprocessingIdle(statusDto);
-            # agentProducer.pushDelayedStatus(statusDto, reprocessingTimeout);
+        start_time = time.time()
+        try:
+            self.logger.info('agent_event_channel, event_name=%s, call_id=%s, device_id=%s, is_agent=%s', event_name, call_id, device_id, is_agent)
+            agent = self.data_handle_server.get_agent(saas_id, agent_num)
+            if not agent:
+                # self.logger.warn("event service channel agent is null %s %s %s %s %s", saas_id, event_name, caller, called, json.loads(event.serialize('json')))
+                return
+            agent_monitor = self.data_handle_server.get_agent_monitor(saas_id, agent_num)
+            if not agent_monitor:
+                # self.logger.warn("event service channel agentMonitor is null %s %s %s %s %s", saas_id, event_name, caller, called, json.loads(event.serialize('json')))
+                return
 
-        if (CHANNEL_BRIDGE == event_name or PLAYBACK_START == event_name) and is_agent:
-            self.push_handler.push_on_ring_start(saas_id, flow_id, agent_num, AgentScene.MANUAL, call_id)
-            # self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_ANSWER_OUTGOING)
-            # self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.MANUAL, AgentServiceState.CALLING)
+            # 信道发起事件，触发完成发起（或桥）&& 坐席侧
+            if CHANNEL_ORIGINATE == event_name and is_agent:
+                self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_RINGING,phone=call_info.caller)
 
-        if DETECTED_TONE == event_name and not is_agent:
-            self.push_handler.push_on_detected_tone(saas_id, flow_id, call_id, AgentScene.MANUAL, call_id)
+            # 进度事件，外呼时对方提醒。或者入呼时提醒 && 坐席侧
+            if CHANNEL_PROGRESS == event_name and is_agent:
+                self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.MANUAL, AgentServiceState.DIALING)
+                self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_CALLING)
 
-        if (CHANNEL_UNBRIDGE == event_name or PLAYBACK_STOP == event_name) and is_agent:
-            self.push_handler.push_on_ring_end(saas_id, flow_id, call_id, AgentScene.MANUAL, call_id)
+            # 媒体进度事件，外呼时对方提醒。或者入呼时提醒 && 用户侧
+            if CHANNEL_PROGRESS_MEDIA == event_name and not is_agent:
+                self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_CALLING_RINGING)
 
+            #应答
+            if CHANNEL_ANSWER == event_name:
+                if call_id:
+                    if self.cache.get_call_is_end(call_id):
+                        # self.logger.warn("event service channel call is end {} {} {} {} {} {}", saas_id, event_name, caller, called, call_id, json.dumps(event.serialize('json')))
+                        return
+
+                self.agent_state_service.busy(saas_id, agent.agent_num, agent.phone_num)
+                self.data_handle_server.update_record(call_id, status=1)
+                if is_agent:
+                    # 坐席接起
+                    self.cache.set_call_is_answer(saas_id, flow_id)
+                    self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.ANSWER_COMPENSATE)
+                    self.push_handler.push_answer_call(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, ServiceDirect.MANUAL_CALL.service_direct, WorkStatus.AGENT_HANG_REPROCESSING)
+
+                    self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.CALLING, AgentLogState.CHANNEL_TURN_ON)
+                else:
+                    # 用户侧接起
+                    self.agent_monitor_service.update_calling(agent_monitor)
+                    self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_ANSWER_OUTGOING)
+                    self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.MANUAL, AgentServiceState.CALLING)
+
+            #挂断
+            if CHANNEL_HANGUP == event_name:
+                # 坐席侧挂断
+                if is_agent:
+                    if call_id:
+                        self.cache.set_call_is_end(call_id)
+                self.agent_monitor_service.update_processing(agent_monitor)
+                self.reprocessing_idle(AgentDelayStateData(saas_id, flow_id, agent_num, AgentServiceState.REPROCESSING, AgentScene.MANUAL))
+                self.push_handler.push_on_call_end(saas_id, flow_id, agent_num, AgentScene.MANUAL, ServiceDirect.MANUAL_CALL.service_direct, '0')
+                self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_HANG_REPROCESSING)
+                self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.MANUAL, AgentServiceState.REPROCESSING)
+
+                self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.REPROCESSING, AgentLogState.CHANNEL_HANG_UP)
+
+                self.data_handle_server.update_record(call_id, time_end=datetime.now())
+                # 同步处理后处理置闲
+                # reprocessingIdle(statusDto);
+                # agentProducer.pushDelayedStatus(statusDto, reprocessingTimeout);
+
+            if (CHANNEL_BRIDGE == event_name or PLAYBACK_START == event_name) and is_agent:
+                self.push_handler.push_on_ring_start(saas_id, flow_id, agent_num, AgentScene.MANUAL, call_id)
+                # self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.MANUAL, WorkStatus.AGENT_ANSWER_OUTGOING)
+                # self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.MANUAL, AgentServiceState.CALLING)
+
+            if DETECTED_TONE == event_name and not is_agent:
+                self.push_handler.push_on_detected_tone(saas_id, flow_id, call_id, AgentScene.MANUAL, call_id)
+
+            if (CHANNEL_UNBRIDGE == event_name or PLAYBACK_STOP == event_name) and is_agent:
+                self.push_handler.push_on_ring_end(saas_id, flow_id, call_id, AgentScene.MANUAL, call_id)
+        except:
+            traceback.print_exc()
+        finally:
+            latency = (time.time() - start_time)
+            registry.ESL_EVENT_CALLBACK_LATENCY.labels(event_name, "agent").observe(latency)
 
     def bot_event_channel(self, event, call_info, device_info):
         event_name = EslEventUtil.getEventName(event)
@@ -171,49 +180,53 @@ class AgentEventService:
         called = (device_info.caller if is_agent else device_info.called) if device_info else None
         human_service_id = '00000000000000000'
 
-        if CHANNEL_ORIGINATE == event_name:
-            self.logger.info('bot_event_channel, event_name=%s, call_id=%s, is_agent=%s, agent_num=%s, call_info=%s', event_name, call_id, is_agent, agent_num, call_info)
-
-        agent = self.data_handle_server.get_agent(saas_id, agent_num)
-        if not agent:
-            # self.logger.warn("bot event service channel agent is null %s %s %s %s %s", saas_id, event_name, caller, called,
-            #                  json.dumps(event.serialize('json')))
-            return
-        agent_monitor = self.data_handle_server.get_agent_monitor(saas_id, agent_num)
-        if not agent_monitor:
-            # self.logger.warn("bot event service channel agentMonitor is null %s %s %s %s %s", saas_id, event_name, caller,
-            #                  called, json.dumps(event.serialize('json')))
-            return
-
-        # 信道发起事件，触发完成发起（或桥）&& 坐席侧
-        if CHANNEL_ORIGINATE == event_name and is_agent:
-            self.push_handler.push_on_call_ring(saas_id, flow_id, agent_num, AgentScene.ROBOT, call_id, ServiceDirect.ROBOT_CALL.service_direct, called, caller, human_service_id)
-            self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, WorkStatus.AGENT_RINGING,phone=call_info.caller)
-
-
-        if CHANNEL_ANSWER == event_name:
-            self.agent_state_service.busy(saas_id, agent.agent_num, agent.phone_num)
-            if is_agent:
-                self.agent_monitor_service.update_calling(agent_monitor)
-                self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, WorkStatus.AGENT_ANSWER_INCOMING, "座席接通呼入电话! internal")
-                self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.ROBOT, AgentServiceState.CALLING)
-                self.push_handler.push_answer_call(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, ServiceDirect.ROBOT_CALL.service_direct, WorkStatus.AGENT_HANG_REPROCESSING)
-
-                self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.CALLING, AgentLogState.CHANNEL_TURN_ON, service_id=human_service_id)
-            else:
-                self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, WorkStatus.AGENT_ANSWER_INCOMING, "座席接通呼入电话! external")
-
-        if CHANNEL_HANGUP == event_name and is_agent:
-            self.agent_monitor_service.update_processing(agent_monitor)
-            self.reprocessing_idle(AgentDelayStateData(saas_id, flow_id, agent_num, AgentServiceState.REPROCESSING, AgentScene.ROBOT))
-            self.push_handler.push_on_call_end(saas_id, flow_id, agent_num, AgentScene.ROBOT, ServiceDirect.ROBOT_CALL.service_direct, "0")
-            self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, WorkStatus.AGENT_HANG_REPROCESSING)
-            self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.ROBOT, AgentServiceState.REPROCESSING)
-
-            self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.REPROCESSING,
-                                                  AgentLogState.CHANNEL_HANG_UP, service_id=human_service_id)
-            self.data_handle_server.update_record(call_id, time_end=datetime.now())
+        start_time = time.time()
+        try:
+            self.logger.info('bot_event_channel, event_name=%s, call_id=%s, is_agent=%s, agent_num=%s', event_name, call_id, is_agent, agent_num)
+            agent = self.data_handle_server.get_agent(saas_id, agent_num)
+            if not agent:
+                # self.logger.warn("bot event service channel agent is null %s %s %s %s %s", saas_id, event_name, caller, called,
+                #                  json.dumps(event.serialize('json')))
+                return
+            agent_monitor = self.data_handle_server.get_agent_monitor(saas_id, agent_num)
+            if not agent_monitor:
+                # self.logger.warn("bot event service channel agentMonitor is null %s %s %s %s %s", saas_id, event_name, caller,
+                #                  called, json.dumps(event.serialize('json')))
+                return
 
+            # 信道发起事件，触发完成发起（或桥）&& 坐席侧
+            if CHANNEL_ORIGINATE == event_name and is_agent:
+                self.push_handler.push_on_call_ring(saas_id, flow_id, agent_num, AgentScene.ROBOT, call_id, ServiceDirect.ROBOT_CALL.service_direct, called, caller, human_service_id)
+                self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, WorkStatus.AGENT_RINGING,phone=call_info.caller)
+
+
+            if CHANNEL_ANSWER == event_name:
+                self.agent_state_service.busy(saas_id, agent.agent_num, agent.phone_num)
+                if is_agent:
+                    self.agent_monitor_service.update_calling(agent_monitor)
+                    self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, WorkStatus.AGENT_ANSWER_INCOMING, "座席接通呼入电话! internal")
+                    self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.ROBOT, AgentServiceState.CALLING)
+                    self.push_handler.push_answer_call(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, ServiceDirect.ROBOT_CALL.service_direct, WorkStatus.AGENT_HANG_REPROCESSING)
+
+                    self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.CALLING, AgentLogState.CHANNEL_TURN_ON, service_id=human_service_id)
+                else:
+                    self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, WorkStatus.AGENT_ANSWER_INCOMING, "座席接通呼入电话! external")
+
+            if CHANNEL_HANGUP == event_name and is_agent:
+                self.agent_monitor_service.update_processing(agent_monitor)
+                self.reprocessing_idle(AgentDelayStateData(saas_id, flow_id, agent_num, AgentServiceState.REPROCESSING, AgentScene.ROBOT))
+                self.push_handler.push_on_call_end(saas_id, flow_id, agent_num, AgentScene.ROBOT, ServiceDirect.ROBOT_CALL.service_direct, "0")
+                self.push_handler.push_on_agent_work_report(saas_id, flow_id, agent_num, call_id, AgentScene.ROBOT, WorkStatus.AGENT_HANG_REPROCESSING)
+                self.push_handler.push_on_agent_report(saas_id, agent_num, AgentScene.ROBOT, AgentServiceState.REPROCESSING)
+
+                self.agent_actionlog_service.insert_service_state(agent_monitor, AgentServiceState.REPROCESSING,
+                                                      AgentLogState.CHANNEL_HANG_UP, service_id=human_service_id)
+                self.data_handle_server.update_record(call_id, time_end=datetime.now())
+        except:
+            traceback.print_exc()
+        finally:
+            latency = (time.time() - start_time)
+            registry.ESL_EVENT_CALLBACK_LATENCY.labels(event_name, "agent").observe(latency)
 
     def reprocessing_idle(self, state_data: AgentDelayStateData):
         agent = self.data_handle_server.get_agent(state_data.saas_id, state_data.agent_num)

src/core/callcenter/cache.py

@@ -64,7 +64,7 @@ class Cache:
     def add_call_info(self, call: CallInfo):
         for k, v in call.device_info_map.items():
             self.add_device(k, call.call_id)
-        # print('liuwei::debugger::add_call_info call_id:%s, call=%s'% (call.call_id, call))
+        # print('add_call_info call_id:%s, call=%s'% (call.call_id, call))
         self.redis_handler.set(CALL_INFO + call.call_id, call.to_json_string(), self.cacheDay * 24 * 60 * 60)
 
 
@@ -78,7 +78,7 @@ class Cache:
         text = None
         if call_id:
             text = self.redis_handler.get(CALL_INFO + call_id)
-            # print('liuwei::debugger::get_call_info call_id:%s, text:%s'% (call_id, text))
+            # print('get_call_info call_id:%s, text:%s'% (call_id, text))
         if text:
             return CallInfo.from_json(text)
 

src/core/callcenter/callback.py

@@ -28,12 +28,12 @@ class Callback(object):
             call_id = self.cache.get_call_id_by_device_id(device_id)
         call_info = self.cache.get_call_info(call_id)
         if not call_info:
-            # self.logger.info("liuwei::debugger::callback:return::event_name=%s, call_id=%s, device_id=%s", event_name, call_id, device_id)
+            # self.logger.info("callback:return::event_name=%s, call_id=%s, device_id=%s", event_name, call_id, device_id)
             return
 
         call_type = CallType.get_by_code(call_info.call_type) if call_info else None
         device_info = call_info.device_info_map.get(device_id) if call_info and call_info.device_info_map else None
-        # self.logger.info("liuwei::debugger::callback::event_name=%s, call_type=%s, call_id=%s, device_id=%s, call_info=%s", event_name, call_type, call_id, device_id, call_info)
+        # self.logger.info("callback::event_name=%s, call_type=%s, call_id=%s, device_id=%s, call_info=%s", event_name, call_type, call_id, device_id, call_info)
         if CallType.BOT_CALL == call_type:
             threading.Thread(target=self.agent_event_service.bot_event_channel, args=(event, call_info, device_info)).start()
             # self.agent_event_service.bot_event_channel(event, call_info, device_info)

src/core/callcenter/esl/handler/channel_answer_handler.py

@@ -24,23 +24,25 @@ class ChannelAnswerHandler(EslEventHandler):
     def handle(self, address, event, coreUUID):
         call_id = EslEventUtil.getCallId(event)
         call_info = self.cache.get_call_info(call_id)
-        self.logger.info("liuwei::debugger::answer call_id:%s, call_info:%s", call_id, call_info)
+        self.logger.info("answer call_id:%s, call_info:%s", call_id, call_info)
         if not call_info:
             return
 
         device_id = EslEventUtil.getDeviceId(event)
         device_info = call_info.device_info_map.get(device_id)
         if CallType.AGENT_CALL.code == call_info.call_type and device_info.device_type == DeviceType.CUSTOMER.code:
+            self.logger.info("liuwei::debugger::answer, 11111")
             self.record(event, device_id)
 
         if CallType.BOT_CALL.code == call_info.call_type and device_info.device_type == DeviceType.ROBOT.code:
+            self.logger.info("liuwei::debugger::answer, 22222")
             self.record(event, device_id)
             call_info.answer_flag = AnswerFlag.ROBOT_ANSWER.code
             registry.CALL_BOT_ANSWER_REQUESTS.labels(f"{call_info.bucket_type}").inc()
 
         next_command = call_info.next_commands[0] if len(call_info.next_commands) > 0 else None
         device_type = DeviceType.get_by_code(device_info.device_type)
-        self.logger.info("liuwei::debugger::ChannelAnswerHandler call_id:%s, device_id:%s, device_type:%s, next_command:%s"%(call_id, device_id, device_type, next_command))
+        self.logger.info("ChannelAnswerHandler call_id:%s, device_id:%s, device_type:%s, next_command:%s"%(call_id, device_id, device_type, next_command))
         if not next_command:
             return
 
@@ -48,7 +50,7 @@ class ChannelAnswerHandler(EslEventHandler):
         device_info.ring_end_time = EslEventUtil.getEventDateTimestamp(event)
         call_info.answer_count = call_info.answer_count + 1
         call_info.next_commands.remove(next_command)
-        self.logger.info("liuwei::debugger::ChannelAnswerHandler call_info.answer_time::%s,time:%s", call_info.answer_time, EslEventUtil.getEventDateTimestamp(event))
+        self.logger.info("ChannelAnswerHandler call_info.answer_time::%s,time:%s", call_info.answer_time, EslEventUtil.getEventDateTimestamp(event))
 
         if NextType.NEXT_CALL_OTHER.code == next_command.next_type:
             self.call_other(call_info, device_info, event)
@@ -76,6 +78,7 @@ class ChannelAnswerHandler(EslEventHandler):
         device_id = device.device_id
 
         # 启用录音, 生产时候打开
+        self.logger.info("liuwei::debugger::answer, 33333")
         record_url = self.record(event, device_id)
         device.record = record_url
         device.record_start_time = device.answer_time
@@ -111,6 +114,7 @@ class ChannelAnswerHandler(EslEventHandler):
     def call_bridge(self, call: CallInfo, device: DeviceInfo, next_command: NextCommand, event):
         self.logger.info("开始桥接电话: callId:%s, caller:%s, called:%s, device1:%s, device2:%s"% (call.call_id,
                          call.caller, call.called, next_command.device_id, next_command.next_value))
+        self.logger.info("liuwei::debugger::answer, 33333")
         self.record(event, device_id=device.device_id)
         device1 = call.device_info_map.get(next_command.device_id)
         device2 = call.device_info_map.get(next_command.next_value)
@@ -131,6 +135,7 @@ class ChannelAnswerHandler(EslEventHandler):
         if CallType.BOT_CALL.code == call.call_type:
             registry.CALL_BOT_TRANSFER_REQUESTS.labels(f"{call.bucket_type}").inc()
 
+        self.logger.info("liuwei::debugger::answer, 44444")
         self.record(event, device_id)
         call.next_commands.append(NextCommand(device_id, NextType.NEXT_TRANSFER_SUCCESS.code, call.device_list[1]))
         self.logger.info("转接电话中 callId:%s, from:%s, to:%s "% (call.call_id, from_device_id, device_id))
@@ -147,13 +152,14 @@ class ChannelAnswerHandler(EslEventHandler):
     def record(self, event, device_id):
         call_id = EslEventUtil.getCallId(event)
         call = self.cache.get_call_info(call_id)
+        self.logger.info("answer.record::call_id=%s, device_id=%s, call=%s", call_id, device_id, call)
         if not call:
-            self.logger.info("answer callInfo is null,call_id:%s"%call_id)
+            self.logger.info("answer.record callInfo is null,call_id:%s"%call_id)
             return
 
         device =call.device_info_map.get(device_id)
         if not device:
-            self.logger.info("answer deviceInfo is null,call_id:%s, device_id:%s"%(call_id, device_id))
+            self.logger.info("answer.record deviceInfo is null,call_id:%s, device_id:%s"%(call_id, device_id))
             return
 
         return self.start_recording(device_id, get_record_file_name(call_id, CallStage.ALL), call)

src/core/callcenter/esl/handler/channel_hangup_handler.py

@@ -102,7 +102,7 @@ class ChannelHangupHandler(EslEventHandler):
             # 一般情况下，挂断其他所有设备
             if device_info.cdr_type <= 4 and not call_info.end_time and not skip_hangup_all:
                 call_info.end_time = device_info.end_time
-                self.logger.info("liuwei::debugger::hang_all, call_info:%s, device_info:%s"%(call_info,device_info))
+                self.logger.info("hang_all, call_info:%s, device_info:%s"%(call_info,device_info))
                 self.call_service.hangup_all(call_info, CallCause.HANGUP_EVENT)
                 # self.inbound_client.hangup_call(call_id, device_id, CallCause.HANGUP_EVENT)
 

src/core/callcenter/registry.py

@@ -16,4 +16,5 @@ CALL_BOT_ANSWER_REQUESTS = Counter('call_bot_answer_requests', '机器人接听
 CALL_BOT_TRANSFER_REQUESTS = Counter('call_bot_transfer_requests', '机器转人量', ['bucket'])
 
 # esl时间耗时
-ESL_EVENT_LATENCY = Histogram('esl_event_latency', 'Esl Event latency in milliseconds', ['eventName'])
+ESL_EVENT_LATENCY = Histogram('esl_event_latency', 'Esl Event latency in seconds', ['eventName'])
+ESL_EVENT_CALLBACK_LATENCY = Histogram('esl_event_callback_latency', 'Esl Event callback latency in seconds', ['eventName','callType'])