add logs for sttd

Change-Id: I212c369ce9b8941d63e66468dd9b8d02f058a8a4
Signed-off-by: Wonnam Jang <wn.jang@samsung.com>
(cherry picked from commit f0a11dcb2a0fbdc450f61c1365f067f9c44268fd)

diff --git a/common/stt_engine.c b/common/stt_engine.c
index 9dfd996115e4fb00c14ef9144a9e71ea4766a100..14e6276d9db3a2b82611054a5229cc1f2ea65820 100644 (file)
--- a/common/stt_engine.c
+++ b/common/stt_engine.c
@@ -149,6 +149,8 @@ int stt_engine_initialize(bool is_from_lib)
                return STTE_ERROR_OPERATION_FAILED;
        }
 
+       SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to initialize");
+
        ret = g_engine->callback->initialize();
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to initialize : %s", __stt_get_engine_error_code(ret));
@@ -174,6 +176,8 @@ int stt_engine_deinitialize()
                return STTE_ERROR_OPERATION_FAILED;
        }
 
+       SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to deinitialize");
+
        int ret;
        ret = g_engine->callback->deinitialize();
        if (0 != ret) {
@@ -391,6 +395,8 @@ int stt_engine_support_silence(bool* support)
                return STTE_ERROR_OPERATION_FAILED;
        }
 
+       SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to support silence");
+
        if (NULL == g_engine->callback->support_silence) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
                return STTE_ERROR_OPERATION_FAILED;
@@ -420,6 +426,8 @@ int stt_engine_need_app_credential(bool* need)
                return STTE_ERROR_OPERATION_FAILED;
        }
 
+       SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to need app credential");
+
        if (NULL == g_engine->callback->need_app_credential) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid engine");
                return STTE_ERROR_OPERATION_FAILED;
@@ -454,6 +462,8 @@ int stt_engine_support_recognition_type(const char* type, bool* support)
                return STTE_ERROR_OPERATION_FAILED;
        }
 
+       SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to support recognition type, type(%s)", type);
+
        int ret = STTE_ERROR_NONE;
        ret = g_engine->callback->support_recognition_type(type, support);
        if (0 != ret) {
@@ -484,6 +494,8 @@ int stt_engine_get_audio_type(stte_audio_type_e* types, int* rate, int* channels
                return STTE_ERROR_OPERATION_FAILED;
        }
 
+       SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to get audio format");
+
        int ret;
        ret = g_engine->callback->get_audio_format(types, rate, channels);
        if (0 != ret) {
@@ -511,6 +523,8 @@ int stt_engine_set_silence_detection(bool value)
                return STTE_ERROR_OPERATION_FAILED;
        }
 
+       SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to set silence detection(%d)", value);
+
        int ret = g_engine->callback->set_silence_detection(value);
        if (STTE_ERROR_NOT_SUPPORTED_FEATURE == ret) {
                SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Not support silence detection");
@@ -543,6 +557,8 @@ int stt_engine_check_app_agreed(const char* appid, bool* is_agreed)
                return 0;
        }
 
+       SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to app agreed, appid(%s), is_agreed(%d)", appid, is_agreed);
+
        int ret = g_engine->callback->check_app_agreed(appid, is_agreed);
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get app agreement : %s", __stt_get_engine_error_code(ret));
@@ -575,6 +591,8 @@ int stt_engine_recognize_start(const char* lang, const char* recognition_type, c
                return STTE_ERROR_OPERATION_FAILED;
        }
 
+       SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to start, lang(%s), recognition_type(%s), credential(%s)", lang, recognition_type, credential);
+
        int ret = g_engine->callback->start(lang, recognition_type, appid, credential, user_param);
 
        if (0 != ret) {
@@ -632,6 +650,8 @@ int stt_engine_recognize_stop()
                return STTE_ERROR_OPERATION_FAILED;
        }
 
+       SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to stop");
+
        int ret = g_engine->callback->stop();
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to stop : %s", __stt_get_engine_error_code(ret));
@@ -657,6 +677,8 @@ int stt_engine_recognize_cancel()
                return STTE_ERROR_OPERATION_FAILED;
        }
 
+       SLOG(LOG_INFO, stt_tag(), "[Engine Info] request to cancel");
+
        int ret = g_engine->callback->cancel();
        if (0 != ret) {
                SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to cancel : %s", __stt_get_engine_error_code(ret));

diff --git a/server/sttd_engine_agent.c b/server/sttd_engine_agent.c
index 4573cf4682ae08b3e1a6516daaea56a9aca3a5c0..62866b2c34fb971eea61bd5b307ead2bef27cf1c 100644 (file)
--- a/server/sttd_engine_agent.c
+++ b/server/sttd_engine_agent.c
@@ -316,9 +316,9 @@ int sttd_engine_agent_load_current_engine(stte_request_callback_s *callback)
        }
 
        if (false == is_default_engine) {
-               SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Current engine is not Default engine");
+               SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Current engine is not Default engine");
        } else {
-               SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Current engine is Default engine");
+               SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Current engine is Default engine");
        }
 
        /* Load engine */
@@ -375,7 +375,7 @@ int sttd_engine_agent_load_current_engine(stte_request_callback_s *callback)
 #endif
 
        g_engine_info->is_loaded = true;
-       SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent SUCCESS] The %s has been loaded !!!", g_engine_info->engine_name);
+       SECURE_SLOG(LOG_INFO, TAG_STTD, "[Engine Agent SUCCESS] The %s has been loaded !!!", g_engine_info->engine_name);
 
        return 0;
 }
@@ -751,7 +751,7 @@ int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const ch
                return STTD_ERROR_OPERATION_FAILED;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "g_default_language %s", g_default_language);
+       SLOG(LOG_INFO, TAG_STTD, "g_default_language %s", g_default_language);
 
        int ret;
        char* temp = NULL;
@@ -774,7 +774,7 @@ int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const ch
                temp = strdup(lang);
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start engine");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Start engine");
 
        ret = stt_engine_recognize_start(temp, recognition_type, appid, credential, user_param);
        if (NULL != temp)       free(temp);
@@ -795,7 +795,7 @@ int sttd_engine_agent_recognize_start_engine(int uid, const char* lang, const ch
                return ret;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Create recorder");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Create recorder");
 
        ret = sttd_recorder_create(atype, channels, rate);
        if (0 != ret) {
@@ -830,7 +830,7 @@ int sttd_engine_agent_recognize_start_recorder(int uid)
                return STTD_ERROR_OPERATION_FAILED;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Start recorder");
 
        int ret;
        ret = sttd_recorder_start(uid);
@@ -856,7 +856,7 @@ int sttd_engine_agent_recognize_start_file(int uid, const char* filepath)
                return STTD_ERROR_OPERATION_FAILED;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Start recorder");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Start recorder");
 
        int ret;
        ret = sttd_recorder_start_file(uid, filepath);
@@ -917,7 +917,7 @@ int sttd_engine_agent_recognize_stop_file()
                return STTD_ERROR_OPERATION_FAILED;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop recorder");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop recorder");
        int ret;
        ret = sttd_recorder_stop_file();
        if (0 != ret) {
@@ -926,12 +926,12 @@ int sttd_engine_agent_recognize_stop_file()
        }
 
 #ifdef AUDIO_CREATE_ON_START
-       SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
+       SECURE_SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Destroy recorder");
        if (0 != sttd_recorder_destroy())
                SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
 #endif
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Stop recorder");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Stop recorder");
        return 0;
 }
 
@@ -952,7 +952,7 @@ int sttd_engine_agent_recognize_stop_recorder()
                return STTD_ERROR_OPERATION_FAILED;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop recorder");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop recorder");
        int ret;
        ret = sttd_recorder_stop();
        if (0 != ret) {
@@ -966,7 +966,7 @@ int sttd_engine_agent_recognize_stop_recorder()
                SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
 #endif
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Stop recorder");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Stop recorder");
        return 0;
 }
 
@@ -987,7 +987,7 @@ int sttd_engine_agent_recognize_stop_engine()
                return STTD_ERROR_OPERATION_FAILED;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop engine");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop engine");
 
        int ret;
        ret = stt_engine_recognize_stop();
@@ -996,7 +996,7 @@ int sttd_engine_agent_recognize_stop_engine()
                return ret;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Stop engine");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Stop engine");
 
        return 0;
 }
@@ -1018,7 +1018,7 @@ int sttd_engine_agent_recognize_cancel()
                return STTD_ERROR_OPERATION_FAILED;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Cancel engine");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Cancel engine");
 
        int ret;
        ret = stt_engine_recognize_cancel();
@@ -1027,7 +1027,7 @@ int sttd_engine_agent_recognize_cancel()
                return ret;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Stop recorder");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Stop recorder");
 
        ret = sttd_recorder_stop();
        if (0 != ret) {
@@ -1036,12 +1036,12 @@ int sttd_engine_agent_recognize_cancel()
        }
 
 #ifdef AUDIO_CREATE_ON_START
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Destroy recorder");
        if (0 != sttd_recorder_destroy())
                SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
 #endif
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent Success] Cancel recognition");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent Success] Cancel recognition");
 
        return 0;
 }
@@ -1070,7 +1070,7 @@ int sttd_engine_agent_set_default_engine(const char* engine_uuid)
                return STTD_ERROR_ENGINE_NOT_FOUND;
        }
 
-       SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Default engine uuid(%s)", g_engine_info->engine_uuid);
+       SECURE_SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Default engine uuid(%s)", g_engine_info->engine_uuid);
 
        return 0;
 }
@@ -1132,13 +1132,13 @@ int sttd_engine_agent_check_app_agreed(const char* appid, bool* result)
        }
 
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Get engine right : %s", *result ? "true" : "false");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Get engine right : %s", *result ? "true" : "false");
        return 0;
 }
 
 static void __recorder_destroy_by_error_result(void *data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "[Engine Agent] Destroy recorder");
+       SLOG(LOG_INFO, TAG_STTD, "[Engine Agent] Destroy recorder");
        if (0 != sttd_recorder_destroy())
                SECURE_SLOG(LOG_WARN, TAG_STTD, "[Engine Agent] Fail to destroy recorder");
 
@@ -1155,7 +1155,7 @@ int sttd_engine_agent_send_result(stte_result_event_e event, const char* type, c
                return STTD_ERROR_OPERATION_FAILED;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] === Result time callback ===");
+       SLOG(LOG_INFO, TAG_STTD, "[Server] === Result time callback ===");
 
        if (NULL != time_info) {
                /* Get the time info */
@@ -1166,7 +1166,7 @@ int sttd_engine_agent_send_result(stte_result_event_e event, const char* type, c
                }
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] ============================");
+       SLOG(LOG_INFO, TAG_STTD, "[Server] ============================");
 
        ret = g_result_cb(event, type, result, result_count, msg, user_data);
 

diff --git a/server/sttd_server.c b/server/sttd_server.c
index c31d6a61a64349ab0bc3507ad27ba8ae2d929838..f1bda74ac21f7f6bf22a0437a8b0c2a636c85df8 100644 (file)
--- a/server/sttd_server.c
+++ b/server/sttd_server.c
@@ -52,7 +52,7 @@ static GList *g_proc_list = NULL;
 */
 void __stop_by_silence(void *data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Stop by silence detection");
+       SLOG(LOG_INFO, TAG_STTD, "===== Stop by silence detection");
 
        int uid = 0;
 
@@ -79,7 +79,7 @@ void __stop_by_silence(void *data)
                SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] uid is NOT valid");
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "=====");
+       SLOG(LOG_INFO, TAG_STTD, "=====");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
 
        return;
@@ -105,6 +105,7 @@ static void __cancel_recognition_internal()
        }
 
        if (0 != uid && (APP_STATE_PROCESSING == state || APP_STATE_RECORDING == state)) {
+               SLOG(LOG_INFO, TAG_STTD, "===== cancel by internal");
                /* cancel engine recognition */
                ret = sttd_server_cancel(uid);
                if (0 != ret) {
@@ -117,7 +118,7 @@ static void __cancel_recognition_internal()
 
 static void __cancel_by_error(void *data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by error");
+       SLOG(LOG_INFO, TAG_STTD, "===== Cancel by error");
 
        __cancel_recognition_internal();
 
@@ -164,7 +165,7 @@ int __server_audio_recorder_callback(const void* data, const unsigned int length
 
 void __server_audio_interrupt_callback()
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by sound interrupt");
+       SLOG(LOG_INFO, TAG_STTD, "===== Cancel by sound interrupt");
 
        __cancel_recognition_internal();
 
@@ -174,7 +175,7 @@ void __server_audio_interrupt_callback()
 
 void __cancel_by_no_record(void *data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by no record");
+       SLOG(LOG_INFO, TAG_STTD, "===== Cancel by no record");
 
        __cancel_recognition_internal();
 
@@ -190,7 +191,7 @@ int __server_recognition_result_callback(stte_result_event_e event, const char*
        // critical section
        pthread_mutex_lock(&stte_result_mutex);
 
-       SLOG(LOG_DEBUG, TAG_STTD, "===== RESULT event[%d] type[%s] data[%p] data_count[%d]", event, type, data, data_count);
+       SLOG(LOG_INFO, TAG_STTD, "===== RESULT event[%d] type[%s] data[%p] data_count[%d]", event, type, data, data_count);
 
        /* check uid */
        int uid = stt_client_get_current_recognition();
@@ -204,14 +205,14 @@ int __server_recognition_result_callback(stte_result_event_e event, const char*
                return STTD_ERROR_OPERATION_FAILED;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid (%d), event(%d)", uid, event);
+       SLOG(LOG_INFO, TAG_STTD, "[Server] uid (%d), event(%d)", uid, event);
 
        /* send result to client */
        if (STTE_RESULT_EVENT_FINAL_RESULT == event) {
                if (APP_STATE_PROCESSING != state) {
                        SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current state is NOT 'Processing'.");
                }
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server] the size of result from engine is '%d'", data_count);
+               SLOG(LOG_INFO, TAG_STTD, "[Server] the size of result from engine is '%d'", data_count);
 
                /* Delete timer for processing time out */
                if (NULL != g_processing_timer) {
@@ -252,7 +253,7 @@ int __server_recognition_result_callback(stte_result_event_e event, const char*
 //             stt_client_unset_current_recognition();
 
        } else if (STTE_RESULT_EVENT_PARTIAL_RESULT == event) {
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server] The partial result from engine is event[%d] data_count[%d]", event,  data_count);
+               SLOG(LOG_INFO, TAG_STTD, "[Server] The partial result from engine is event[%d] data_count[%d]", event,  data_count);
 
                sttd_config_time_save();
                sttd_config_time_reset();
@@ -304,7 +305,7 @@ int __server_recognition_result_callback(stte_result_event_e event, const char*
                /* nothing */
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "=====");
+       SLOG(LOG_INFO, TAG_STTD, "=====");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
        pthread_mutex_unlock(&stte_result_mutex);
 
@@ -315,7 +316,7 @@ bool __server_result_time_callback(int index, stte_result_time_event_e event, co
 {
        pthread_mutex_lock(&stte_result_time_mutex);
 
-       SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Server] index(%d) event(%d) text(%s) start(%ld) end(%ld)",
+       SECURE_SLOG(LOG_INFO, TAG_STTD, "[Server] index(%d) event(%d) text(%s) start(%ld) end(%ld)",
                index, event, text, start_time, end_time);
 
        int ret;
@@ -333,7 +334,7 @@ bool __server_result_time_callback(int index, stte_result_time_event_e event, co
 
 int __server_speech_status_callback(stte_speech_status_e status, void *user_param)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Speech status detected Callback");
+       SLOG(LOG_INFO, TAG_STTD, "===== Speech status detected Callback");
 
        int uid = stt_client_get_current_recognition();
        if (0 != uid) {
@@ -359,7 +360,7 @@ int __server_speech_status_callback(stte_speech_status_e status, void *user_para
                SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current recognition uid is not valid ");
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "=====");
+       SLOG(LOG_INFO, TAG_STTD, "=====");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
 
        return STTD_ERROR_NONE;
@@ -367,7 +368,7 @@ int __server_speech_status_callback(stte_speech_status_e status, void *user_para
 
 int __server_error_callback(stte_error_e error, const char* msg)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] Error Callback is called");
+       SLOG(LOG_INFO, TAG_STTD, "[Server] Error Callback is called");
        ecore_main_loop_thread_safe_call_async(__cancel_by_error, NULL);
 
        return STTD_ERROR_NONE;
@@ -379,7 +380,7 @@ void __sttd_server_engine_changed_cb(const char* engine_id, const char* language
                SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Engine id is NULL");
                return;
        } else {
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server] New default engine : %s", engine_id);
+               SLOG(LOG_INFO, TAG_STTD, "[Server] New default engine : %s", engine_id);
        }
 
 #if 0
@@ -421,7 +422,7 @@ void __sttd_server_language_changed_cb(const char* language, void* user_data)
                SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] language is NULL");
                return;
        } else {
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server] Get language changed : %s", language);
+               SLOG(LOG_INFO, TAG_STTD, "[Server] Get language changed : %s", language);
        }
 
        int ret = sttd_engine_agent_set_default_language(language);
@@ -433,7 +434,7 @@ void __sttd_server_language_changed_cb(const char* language, void* user_data)
 
 void __sttd_server_silence_changed_cb(bool value, void* user_data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] Get silence detection changed : %s", value ? "on" : "off");
+       SLOG(LOG_INFO, TAG_STTD, "[Server] Get silence detection changed : %s", value ? "on" : "off");
 
        int ret = 0;
        ret = sttd_engine_agent_set_silence_detection(value);
@@ -489,7 +490,7 @@ int sttd_initialize(stte_request_callback_s *callback)
                SLOG(LOG_WARN, TAG_STTD, "[Main Warning] Fail to create timer of client check");
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] initialize");
+       SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] initialize");
 
        return 0;
 }
@@ -526,6 +527,8 @@ int sttd_finalize()
                SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete ecore timer handle");
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] finalize");
+
        return STTD_ERROR_NONE;
 }
 
@@ -578,7 +581,7 @@ Eina_Bool sttd_cleanup_client(void *data)
        }
 
        if (NULL != client_list) {
-               SLOG(LOG_DEBUG, TAG_STTD, "===== Clean up client ");
+               SLOG(LOG_INFO, TAG_STTD, "===== Clean up client ");
 
                __read_proc();
 
@@ -618,7 +621,7 @@ Eina_Bool sttd_cleanup_client(void *data)
 #endif
                }
 
-               SLOG(LOG_DEBUG, TAG_STTD, "=====");
+               SLOG(LOG_INFO, TAG_STTD, "=====");
                SLOG(LOG_DEBUG, TAG_STTD, "  ");
 
                free(client_list);
@@ -635,6 +638,8 @@ int sttd_server_initialize(int pid, int uid, bool* silence, bool* credential)
 {
        int ret = STTD_ERROR_NONE;
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server] server initialize");
+
        /* check if uid is valid */
        app_state_e state;
        if (0 == sttd_client_get_state(uid, &state)) {
@@ -661,19 +666,21 @@ int sttd_server_initialize(int pid, int uid, bool* silence, bool* credential)
                return ret;
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server Success] server initialize");
+
        return STTD_ERROR_NONE;
 }
 
 static Eina_Bool __quit_ecore_loop(void *data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] Quit");
+       SLOG(LOG_INFO, TAG_STTD, "[Server] Quit");
 
        stt_network_finalize();
        sttd_finalize();
        sttd_dbus_close_connection();
        ecore_main_loop_quit();
 
-       SLOG(LOG_DEBUG, TAG_STTD, "");
+       SLOG(LOG_INFO, TAG_STTD, "");
 
        return EINA_FALSE;
 }
@@ -745,6 +752,8 @@ int sttd_server_get_supported_engines(int uid, GSList** engine_list)
                return STTD_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] get supported egnines");
+
        int ret;
        ret = sttd_engine_agent_get_engine_list(engine_list);
        if (0 != ret) {
@@ -770,6 +779,8 @@ int sttd_server_set_current_engine(int uid, const char* engine_id, bool* silence
                return STTD_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] set current egnines, uid(%d), engine_id(%s)", uid, engine_id);
+
        int ret;
        ret = sttd_engine_agent_load_current_engine(NULL);
        if (0 != ret) {
@@ -806,6 +817,8 @@ int sttd_server_get_current_engine(int uid, char** engine_id)
                return STTD_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] get current egnines, uid(%d)", uid);
+
        int ret;
        ret = sttd_engine_agent_get_current_engine(engine_id);
        if (0 != ret) {
@@ -831,6 +844,8 @@ int sttd_server_check_app_agreed(int uid, const char* appid, bool* available)
                return STTD_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] check app agreed");
+
        /* Ask engine available */
        int ret;
        bool temp = false;
@@ -860,6 +875,8 @@ int sttd_server_get_supported_languages(int uid, GSList** lang_list)
                return STTD_ERROR_INVALID_PARAMETER;
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] get supported languages");
+
        /* get language list from engine */
        int ret = sttd_engine_agent_supported_langs(lang_list);
        if (0 != ret) {
@@ -893,7 +910,7 @@ int sttd_server_get_current_langauage(int uid, char** current_lang)
                return ret;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Get default language");
+       SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Get default language, current_lang(%s)", *current_lang);
 
        return STTD_ERROR_NONE;
 }
@@ -920,7 +937,7 @@ int sttd_server_set_private_data(int uid, const char* key, const char* data)
                return ret;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Set private data");
+       SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Set private data");
 
        return STTD_ERROR_NONE;
 }
@@ -947,7 +964,7 @@ int sttd_server_get_private_data(int uid, const char* key, char** data)
                return ret;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Get private data, key(%s), data(%s)", key, *data);
+       SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Get private data, key(%s), data(%s)", key, *data);
 
        return STTD_ERROR_NONE;
 }
@@ -975,7 +992,7 @@ int sttd_server_is_recognition_type_supported(int uid, const char* type, int* su
 
        *support = (int)temp;
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] recognition type supporting is %s", *support ? "true" : "false");
+       SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] recognition type supporting is %s", *support ? "true" : "false");
 
        return STTD_ERROR_NONE;
 }
@@ -1053,7 +1070,7 @@ Eina_Bool __check_recording_state(void *data)
 
 Eina_Bool __stop_by_recording_timeout(void *data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Stop by timeout");
+       SLOG(LOG_INFO, TAG_STTD, "===== Stop by timeout");
 
        if (NULL != g_recording_timer)  {
                ecore_timer_del(g_recording_timer);
@@ -1070,7 +1087,7 @@ Eina_Bool __stop_by_recording_timeout(void *data)
                }
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "=====");
+       SLOG(LOG_INFO, TAG_STTD, "=====");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
 
        return EINA_FALSE;
@@ -1107,12 +1124,12 @@ void __sttd_server_recorder_start(void* data)
 
 void __sttd_start_sound_completed_cb(int id, void *user_data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Start sound completed");
+       SLOG(LOG_INFO, TAG_STTD, "===== Start sound completed");
 
        /* After wav play callback, recorder start */
        ecore_main_loop_thread_safe_call_async(__sttd_server_recorder_start, user_data);
 
-       SLOG(LOG_DEBUG, TAG_STTD, "=====");
+       SLOG(LOG_INFO, TAG_STTD, "=====");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
        return;
 }
@@ -1186,10 +1203,10 @@ int sttd_server_start(int uid, const char* lang, const char* recognition_type, i
        }
 
        /* engine start recognition */
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] start : uid(%d), lang(%s), recog_type(%s)",
+       SLOG(LOG_INFO, TAG_STTD, "[Server] start : uid(%d), lang(%s), recog_type(%s)",
                        uid, lang, recognition_type);
        if (NULL != sound)
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server] start sound : %s", sound);
+               SLOG(LOG_INFO, TAG_STTD, "[Server] start sound : %s", sound);
 
        /* 1. Set audio session */
        ret = sttd_recorder_set_audio_session();
@@ -1248,7 +1265,7 @@ int sttd_server_start(int uid, const char* lang, const char* recognition_type, i
        app_state_e temp_app_state;
 
        if (true == is_sound_done) {
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server] No sound play");
+               SLOG(LOG_INFO, TAG_STTD, "[Server] No sound play");
 
                ret = sttd_engine_agent_recognize_start_recorder(uid);
                if (0 != ret) {
@@ -1275,11 +1292,11 @@ int sttd_server_start(int uid, const char* lang, const char* recognition_type, i
                        sttdc_send_set_state(uid, APP_STATE_RECORDING);
                }
 
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Start recognition");
+               SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Start recognition");
                return STTD_RESULT_STATE_DONE;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] Wait sound finish");
+       SLOG(LOG_INFO, TAG_STTD, "[Server] Wait sound finish");
 
        return STTD_RESULT_STATE_NOT_DONE;
 }
@@ -1354,7 +1371,7 @@ void __sttd_server_engine_stop(void* data)
 
 void __sttd_stop_sound_completed_cb(int id, void *user_data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Stop sound completed");
+       SLOG(LOG_INFO, TAG_STTD, "===== Stop sound completed");
 
        /* After wav play callback, engine stop */
        ecore_main_loop_thread_safe_call_async(__sttd_server_engine_stop, user_data);
@@ -1395,7 +1412,7 @@ int sttd_server_stop(int uid)
                return STTD_ERROR_OPERATION_FAILED;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] stop sound path : %s", sound);
+       SLOG(LOG_INFO, TAG_STTD, "[Server] stop sound path : %s", sound);
 
        int ret;
        /* 1. Stop recorder */
@@ -1434,7 +1451,7 @@ int sttd_server_stop(int uid)
 
                return STTD_RESULT_STATE_NOT_DONE;
        } else {
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server] No sound play");
+               SLOG(LOG_INFO, TAG_STTD, "[Server] No sound play");
 
                /* Unset audio session */
                ret = sttd_recorder_unset_audio_session();
@@ -1457,7 +1474,7 @@ int sttd_server_stop(int uid)
                /* Notify uid state change */
                sttdc_send_set_state(uid, APP_STATE_PROCESSING);
 
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Stop recognition");
+               SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Stop recognition");
 
                g_processing_timer = ecore_timer_add(g_processing_timeout, __time_out_for_processing, NULL);