@cryptotaxi247 / netdata-1 / commits / 39a34f785

work on agent-events crashes (#19741)

* strict sdbus handling * make sure out-of-memory is added to the exit reasons * more detailed startup steps * status file version to 7 * cleanup old shutdown watcher steps

Costa Tsaousis committed Mar 2, 2025 at 11:13 UTC 39a34f785b6597988c4a9bd96b316541ca7621dd
13 files changed +138 -89
src/daemon/daemon-shutdown-watcher.c
-6
@@ -85,9 +85,7 @@ void *watcher_main(void *arg)
85
86 usec_t shutdown_start_time = now_monotonic_usec();
87
88 - watcher_wait_for_step(WATCHER_STEP_ID_CREATE_SHUTDOWN_FILE, shutdown_start_time);
88 watcher_wait_for_step(WATCHER_STEP_ID_DESTROY_MAIN_SPAWN_SERVER, shutdown_start_time);
90 - watcher_wait_for_step(WATCHER_STEP_ID_DBENGINE_EXIT_MODE, shutdown_start_time);
89 watcher_wait_for_step(WATCHER_STEP_ID_CLOSE_WEBRTC_CONNECTIONS, shutdown_start_time);
90 watcher_wait_for_step(WATCHER_STEP_ID_DISABLE_MAINTENANCE_NEW_QUERIES_NEW_WEB_REQUESTS_NEW_STREAMING_CONNECTIONS_AND_ACLK, shutdown_start_time);
91 watcher_wait_for_step(WATCHER_STEP_ID_STOP_MAINTENANCE_THREAD, shutdown_start_time);
@@ -122,12 +120,8 @@ void *watcher_main(void *arg)
120 void watcher_thread_start() {
121 watcher_steps = callocz(WATCHER_STEP_ID_MAX, sizeof(watcher_step_t));
122
125 - watcher_steps[WATCHER_STEP_ID_CREATE_SHUTDOWN_FILE].msg =
126 - "create shutdown file";
123 watcher_steps[WATCHER_STEP_ID_DESTROY_MAIN_SPAWN_SERVER].msg =
124 "destroy main spawn server";
129 - watcher_steps[WATCHER_STEP_ID_DBENGINE_EXIT_MODE].msg =
130 - "dbengine exit mode";
125 watcher_steps[WATCHER_STEP_ID_CLOSE_WEBRTC_CONNECTIONS].msg =
126 "close webrtc connections";
127 watcher_steps[WATCHER_STEP_ID_DISABLE_MAINTENANCE_NEW_QUERIES_NEW_WEB_REQUESTS_NEW_STREAMING_CONNECTIONS_AND_ACLK].msg =
src/daemon/daemon-shutdown-watcher.h
-2
@@ -6,9 +6,7 @@
6 #include "libnetdata/libnetdata.h"
7
8 typedef enum {
9 - WATCHER_STEP_ID_CREATE_SHUTDOWN_FILE = 0,
9 WATCHER_STEP_ID_DESTROY_MAIN_SPAWN_SERVER,
11 - WATCHER_STEP_ID_DBENGINE_EXIT_MODE,
10 WATCHER_STEP_ID_CLOSE_WEBRTC_CONNECTIONS,
11 WATCHER_STEP_ID_DISABLE_MAINTENANCE_NEW_QUERIES_NEW_WEB_REQUESTS_NEW_STREAMING_CONNECTIONS_AND_ACLK,
12 WATCHER_STEP_ID_STOP_MAINTENANCE_THREAD,
src/daemon/daemon-shutdown.c
+2 -6
@@ -196,21 +196,17 @@ void netdata_cleanup_and_exit(EXIT_REASON reason, const char *action, const char
196 statistic = (analytics_statistic_t) {"EXIT", ret?"ERROR":"OK","-"};
197 analytics_statistic_send(&statistic);
198
199 - watcher_step_complete(WATCHER_STEP_ID_CREATE_SHUTDOWN_FILE);
200 -
199 netdata_main_spawn_server_cleanup();
200 watcher_step_complete(WATCHER_STEP_ID_DESTROY_MAIN_SPAWN_SERVER);
201
204 - watcher_step_complete(WATCHER_STEP_ID_DBENGINE_EXIT_MODE);
205 -
202 webrtc_close_all_connections();
203 watcher_step_complete(WATCHER_STEP_ID_CLOSE_WEBRTC_CONNECTIONS);
204
205 service_signal_exit(SERVICE_MAINTENANCE | ABILITY_DATA_QUERIES | ABILITY_WEB_REQUESTS |
210 - ABILITY_STREAMING_CONNECTIONS | SERVICE_ACLK);
206 + ABILITY_STREAMING_CONNECTIONS | SERVICE_ACLK | SERVICE_SYSTEMD);
207 watcher_step_complete(WATCHER_STEP_ID_DISABLE_MAINTENANCE_NEW_QUERIES_NEW_WEB_REQUESTS_NEW_STREAMING_CONNECTIONS_AND_ACLK);
208
213 - service_wait_exit(SERVICE_MAINTENANCE, 3 * USEC_PER_SEC);
209 + service_wait_exit(SERVICE_MAINTENANCE | SERVICE_SYSTEMD, 3 * USEC_PER_SEC);
210 watcher_step_complete(WATCHER_STEP_ID_STOP_MAINTENANCE_THREAD);
211
212 service_wait_exit(SERVICE_EXPORTERS | SERVICE_HEALTH | SERVICE_WEB_SERVER | SERVICE_HTTPD, 3 * USEC_PER_SEC);
src/daemon/daemon-status-file.c
+4 -3
@@ -9,7 +9,7 @@
9 #include <openssl/pem.h>
10 #include <openssl/err.h>
11
12 -#define STATUS_FILE_VERSION 6
12 +#define STATUS_FILE_VERSION 7
13
14 #define STATUS_FILENAME "status-netdata.json"
15
@@ -591,8 +591,9 @@ void daemon_status_file_update_status(DAEMON_STATUS status) {
591 }
592
593 void daemon_status_file_exit_reason_save(EXIT_REASON reason) {
594 + exit_initiated_add(reason);
595 spinlock_lock(&dsf_spinlock);
595 - session_status.exit_reason |= reason;
596 + session_status.exit_reason = exit_initiated;
597 spinlock_unlock(&dsf_spinlock);
598 daemon_status_file_save(&session_status);
599 }
@@ -986,7 +987,7 @@ void daemon_status_file_register_fatal(const char *filename, const char *functio
987 return;
988 }
989
989 - exit_initiated |= EXIT_REASON_FATAL;
990 + exit_initiated_add(EXIT_REASON_FATAL);
991 strncpyz(session_status.fatal.thread, nd_thread_tag(), sizeof(session_status.fatal.thread) - 1);
992
993 session_status.fatal.filename = filename;
src/daemon/daemon-systemd-watcher.c
+3 -3
@@ -108,7 +108,7 @@ static void listen_for_systemd_dbus_events(void) {
108 }
109
110 // Process incoming D-Bus messages.
111 - while (service_running(SERVICE_SYSTEMD)) {
111 + while (service_running(SERVICE_SYSTEMD) && bus != NULL) {
112 // Process any pending messages.
113 r = sd_bus_process(bus, NULL);
114 if (r < 0) {
@@ -121,9 +121,9 @@ static void listen_for_systemd_dbus_events(void) {
121 continue;
122
123 // Wait for the next signal.
124 - r = 0;
125 - while(r == 0 && service_running(SERVICE_SYSTEMD))
124 + do {
125 r = sd_bus_wait(bus, USEC_PER_SEC);
126 + } while((r == 0 || r == -EINTR) && service_running(SERVICE_SYSTEMD));
127
128 if (r < 0) {
129 nd_log(NDLS_DAEMON, NDLP_ERR, "SYSTEMD DBUS: Failed to wait on bus: %s", strerror(-r));
src/daemon/main.c
+94 -48
@@ -762,8 +762,8 @@ int netdata_main(int argc, char **argv) {
762
763 // initialize the log files
764 nd_log_initialize();
765 - nd_log_register_event_cb(daemon_status_file_register_fatal);
766 - nd_log_register_fatal_cb(fatal_status_file_save);
765 + nd_log_register_fatal_data_cb(daemon_status_file_register_fatal);
766 + nd_log_register_fatal_final_cb(fatal_status_file_save);
767
768 netdata_conf_section_global(); // get hostname, host prefix, profile, etc
769 registry_init(); // for machine_guid, must be after netdata_conf_section_global()
@@ -794,36 +794,52 @@ int netdata_main(int argc, char **argv) {
794
795 nd_profile_setup();
796
797 - // start a temporary spawn server
798 - netdata_main_spawn_server_init("init", argc, (const char **)argv);
799 -
797 // status and crash/update/exit detection
798 exit_initiated_reset();
799 daemon_status_file_check_crash();
800
801 // ----------------------------------------------------------------------------------------------------------------
805 - delta_startup_time("initialize environment");
802 + delta_startup_time("signals");
803 +
804 + nd_initialize_signals();
805 +
806 + // ----------------------------------------------------------------------------------------------------------------
807 + delta_startup_time("temporary spawn server");
808 +
809 + netdata_main_spawn_server_init("init", argc, (const char **)argv);
810 +
811 + // ----------------------------------------------------------------------------------------------------------------
812 + delta_startup_time("ssl");
813
814 netdata_conf_ssl();
815
816 + // ----------------------------------------------------------------------------------------------------------------
817 + delta_startup_time("execution path");
818 +
819 // Get the execution path before switching user to avoid permission issues
820 get_netdata_execution_path();
821
822 + // ----------------------------------------------------------------------------------------------------------------
823 + delta_startup_time("environment for plugins");
824 +
825 // prepare configuration environment variables for the plugins
826 set_environment_for_plugins_and_scripts();
827
828 + // ----------------------------------------------------------------------------------------------------------------
829 + delta_startup_time("cd to user config dir");
830 +
831 // cd into config_dir to allow the plugins refer to their config files using relative filenames
832 if(chdir(netdata_configured_user_config_dir) == -1)
833 fatal("Cannot cd to '%s'", netdata_configured_user_config_dir);
834
835 // ----------------------------------------------------------------------------------------------------------------
820 - delta_startup_time("initialize analytics");
836 + delta_startup_time("analytics");
837
838 analytics_reset();
839 get_system_timezone();
840
841 // ----------------------------------------------------------------------------------------------------------------
826 - delta_startup_time("initialize pulse");
842 + delta_startup_time("pulse");
843
844 #ifdef NETDATA_INTERNAL_CHECKS
845 pulse_enabled = true;
@@ -838,24 +854,23 @@ int netdata_main(int argc, char **argv) {
854 workers_utilization_enable();
855
856 // ----------------------------------------------------------------------------------------------------------------
841 - delta_startup_time("initialize streaming and replication");
857 + delta_startup_time("replication");
858
859 replication_initialize();
844 - rrd_functions_inflight_init();
860
861 // ----------------------------------------------------------------------------------------------------------------
847 - delta_startup_time("initialize silencers");
862 + delta_startup_time("inflight functions");
863
849 - health_set_silencers_filename();
850 - health_initialize_global_silencers();
864 + rrd_functions_inflight_init();
865
866 // ----------------------------------------------------------------------------------------------------------------
853 - delta_startup_time("initialize signals");
867 + delta_startup_time("silencers");
868
855 - nd_initialize_signals();
869 + health_set_silencers_filename();
870 + health_initialize_global_silencers();
871
872 // ----------------------------------------------------------------------------------------------------------------
858 - delta_startup_time("initialize static threads");
873 + delta_startup_time("static threads");
874
875 for (i = 0; static_threads[i].name != NULL ; i++) {
876 struct netdata_static_thread *st = &static_threads[i];
@@ -877,34 +892,34 @@ int netdata_main(int argc, char **argv) {
892 }
893
894 // ----------------------------------------------------------------------------------------------------------------
880 - delta_startup_time("initialize web server api");
895 + delta_startup_time("web server api");
896
897 // get the certificate and start security
898 netdata_conf_web_security_init();
899 nd_web_api_init();
900 web_server_threading_selection();
901
887 - delta_startup_time("initialize web server sockets");
902 + delta_startup_time("web server sockets");
903 if(web_server_mode != WEB_SERVER_MODE_NONE) {
904 if (!api_listen_sockets_setup()) {
890 - netdata_log_error("Cannot setup listen port(s). Is Netdata already running?");
905 + fatal("Cannot setup listen port(s). Is Netdata already running?");
906 exit(1);
907 }
908 }
909
910 // ----------------------------------------------------------------------------------------------------------------
896 - delta_startup_time("initialize sqlite");
911 + delta_startup_time("sqlite");
912
913 if (sqlite_library_init())
914 fatal("Failed to initialize sqlite library");
915
916 // ----------------------------------------------------------------------------------------------------------------
902 - delta_startup_time("initialize ML");
917 + delta_startup_time("ML");
918
919 ml_init();
920
921 // ----------------------------------------------------------------------------------------------------------------
907 - delta_startup_time("set resource limits");
922 + delta_startup_time("resource limits");
923
924 #ifdef NETDATA_INTERNAL_CHECKS
925 if(debug_flags != 0) {
@@ -920,12 +935,16 @@ int netdata_main(int argc, char **argv) {
935 set_nofile_limit(&rlimit_nofile);
936
937 // ----------------------------------------------------------------------------------------------------------------
923 - delta_startup_time("become daemon");
938 + delta_startup_time("stop temporary spawn server");
939
940 // stop the old server and later start a new one under the new permissions
941 netdata_main_spawn_server_cleanup();
942
943 +// ----------------------------------------------------------------------------------------------------------------
944 +
945 #if defined(OS_LINUX) || defined(OS_MACOS) || defined(OS_FREEBSD)
946 + delta_startup_time("become daemon");
947 +
948 // fork, switch user, create the pid file, set process priority
949 if(become_daemon(dont_fork, user) == -1)
950 fatal("Cannot daemonize myself.");
@@ -933,17 +952,20 @@ int netdata_main(int argc, char **argv) {
952 (void)dont_fork;
953 #endif
954
955 + // ----------------------------------------------------------------------------------------------------------------
956 + delta_startup_time("plugins spawn server");
957 +
958 netdata_main_spawn_server_init("plugins", argc, (const char **)argv);
959
960 #ifdef ENABLE_SENTRY
961 // ----------------------------------------------------------------------------------------------------------------
940 - delta_startup_time("initialize sentry");
962 + delta_startup_time("sentry");
963
964 nd_sentry_init();
965 #endif
966
967 // ----------------------------------------------------------------------------------------------------------------
946 - delta_startup_time("initialize home");
968 + delta_startup_time("home");
969
970 // The "HOME" env var points to the root's home dir because Netdata starts as root. Can't use "HOME".
971 struct passwd *pw = getpwuid(getuid());
@@ -956,17 +978,17 @@ int netdata_main(int argc, char **argv) {
978 nd_setenv("HOME", netdata_configured_home_dir, 1);
979
980 // ----------------------------------------------------------------------------------------------------------------
959 - delta_startup_time("initialize dyncfg");
981 + delta_startup_time("dyncfg");
982
983 dyncfg_init(true);
984
985 // ----------------------------------------------------------------------------------------------------------------
964 - delta_startup_time("initialize threads after fork");
986 + delta_startup_time("threads after fork");
987
988 netdata_threads_init_after_fork((size_t)inicfg_get_size_bytes(&netdata_config, CONFIG_SECTION_GLOBAL, "pthread stack size", default_stacksize));
989
990 // ----------------------------------------------------------------------------------------------------------------
969 - delta_startup_time("initialize registry");
991 + delta_startup_time("registry");
992
993 registry_load();
994 cloud_conf_init_after_registry();
@@ -980,15 +1002,18 @@ int netdata_main(int argc, char **argv) {
1002 #endif
1003
1004 // ----------------------------------------------------------------------------------------------------------------
983 - delta_startup_time("collecting system info");
1005 + delta_startup_time("system info");
1006
1007 struct rrdhost_system_info *system_info = rrdhost_system_info_create();
1008 rrdhost_system_info_detect(system_info);
1009
1010 + // ----------------------------------------------------------------------------------------------------------------
1011 + delta_startup_time("install type");
1012 +
1013 get_install_type(system_info);
1014
1015 // ----------------------------------------------------------------------------------------------------------------
991 - delta_startup_time("initialize RRD structures");
1016 + delta_startup_time("RRD structures");
1017
1018 abort_on_fatal_disable();
1019 if(rrd_init(netdata_configured_hostname, system_info, false)) {
@@ -996,16 +1021,24 @@ int netdata_main(int argc, char **argv) {
1021 fatal("Cannot initialize localhost instance with name '%s'.", netdata_configured_hostname);
1022 }
1023 abort_on_fatal_enable();
1024 +
1025 + // ----------------------------------------------------------------------------------------------------------------
1026 + delta_startup_time("localhost labels");
1027 +
1028 reload_host_labels();
1029
1030 // ----------------------------------------------------------------------------------------------------------------
1002 - delta_startup_time("collect claiming info");
1031 + delta_startup_time("saved bearer tokens");
1032
1033 bearer_tokens_init();
1034 +
1035 + // ----------------------------------------------------------------------------------------------------------------
1036 + delta_startup_time("claiming info");
1037 +
1038 load_claiming_state();
1039
1040 // ----------------------------------------------------------------------------------------------------------------
1008 - delta_startup_time("start the static threads");
1041 + delta_startup_time("static threads");
1042
1043 nd_log_limits_reset();
1044 get_agent_event_time_median_init();
@@ -1026,36 +1059,41 @@ int netdata_main(int argc, char **argv) {
1059 ml_start_threads();
1060
1061 // ----------------------------------------------------------------------------------------------------------------
1029 - delta_startup_time("initialize commands API");
1062 + delta_startup_time("commands API");
1063
1064 commands_init();
1065
1066 // ----------------------------------------------------------------------------------------------------------------
1034 - delta_startup_time("ready");
1067 + delta_startup_time("agent start timings");
1068
1069 usec_t ready_ut = now_monotonic_usec();
1070 add_agent_event(EVENT_AGENT_START_TIME, (int64_t ) (ready_ut - started_ut));
1071 usec_t median_start_time = get_agent_event_time_median(EVENT_AGENT_START_TIME);
1072 netdata_log_info(
1040 - "NETDATA STARTUP: completed in %llu ms (median start up time is %llu ms). Enjoy real-time performance monitoring!",
1073 + "NETDATA STARTUP: completed in %llu ms (median start up time is %llu ms). "
1074 + "Enjoy X-Ray Vision for your infrastructure!",
1075 (ready_ut - started_ut) / USEC_PER_MS, median_start_time / USEC_PER_MS);
1076
1077 cleanup_agent_event_log();
1078 netdata_ready = true;
1079
1046 - analytics_statistic_t start_statistic = { "START", "-", "-" };
1047 - analytics_statistic_send(&start_statistic);
1048 - if (daemon_status_file_has_last_crashed()) {
1049 - analytics_statistic_t crash_statistic = { "CRASH", "-", "-" };
1050 - analytics_statistic_send(&crash_statistic);
1051 - }
1052 - if (daemon_status_file_was_incomplete_shutdown()) {
1053 - analytics_statistic_t incomplete_shutdown_statistic = { "INCOMPLETE_SHUTDOWN", "-", "-" };
1054 - analytics_statistic_send(&incomplete_shutdown_statistic);
1055 - }
1080 + // ----------------------------------------------------------------------------------------------------------------
1081 +
1082 + if(analytics_check_enabled()) {
1083 + delta_startup_time("anonymous analytics");
1084 +
1085 + analytics_statistic_t start_statistic = {"START", "-", "-"};
1086 + analytics_statistic_send(&start_statistic);
1087 + if (daemon_status_file_has_last_crashed()) {
1088 + analytics_statistic_t crash_statistic = {"CRASH", "-", "-"};
1089 + analytics_statistic_send(&crash_statistic);
1090 + }
1091 + if (daemon_status_file_was_incomplete_shutdown()) {
1092 + analytics_statistic_t incomplete_shutdown_statistic = {"INCOMPLETE_SHUTDOWN", "-", "-"};
1093 + analytics_statistic_send(&incomplete_shutdown_statistic);
1094 + }
1095
1057 - // check if ANALYTICS needs to start
1058 - if (netdata_anonymous_statistics_enabled) {
1096 + // check if ANALYTICS needs to start
1097 for (i = 0; static_threads[i].name != NULL; i++) {
1098 if (!strncmp(static_threads[i].name, "ANALYTICS", 9)) {
1099 struct netdata_static_thread *st = &static_threads[i];
@@ -1066,9 +1104,17 @@ int netdata_main(int argc, char **argv) {
1104 }
1105 }
1106
1107 + // ----------------------------------------------------------------------------------------------------------------
1108 +
1109 +#ifdef HAVE_LIBDATACHANNEL
1110 + delta_startup_time("webrtc");
1111 webrtc_initialize();
1112 +#endif
1113 +
1114 + // ----------------------------------------------------------------------------------------------------------------
1115 + delta_startup_time("done");
1116
1071 - nd_log_register_fatal_cb(fatal_cleanup_and_exit_cb);
1117 + nd_log_register_fatal_final_cb(fatal_cleanup_and_exit_cb);
1118 daemon_status_file_startup_step(NULL);
1119 daemon_status_file_update_status(DAEMON_STATUS_RUNNING);
1120 return 10;
src/libnetdata/exit/exit_initiated.c
+18 -7
@@ -5,20 +5,26 @@
5 volatile EXIT_REASON exit_initiated = EXIT_REASON_NONE;
6
7 ENUM_STR_MAP_DEFINE(EXIT_REASON) = {
8 - { EXIT_REASON_SIGINT, "signal-interrupt"},
9 - { EXIT_REASON_SIGQUIT, "signal-quit"},
10 - { EXIT_REASON_SIGTERM, "signal-terminate"},
8 { EXIT_REASON_SIGBUS, "signal-bus-error"},
9 { EXIT_REASON_SIGSEGV, "signal-segmentation-fault"},
10 { EXIT_REASON_SIGFPE, "signal-floating-point-exception"},
11 { EXIT_REASON_SIGILL, "signal-illegal-instruction"},
12 + { EXIT_REASON_OUT_OF_MEMORY, "out-of-memory"},
13 +
14 + { EXIT_REASON_FATAL, "fatal"},
15 +
16 { EXIT_REASON_API_QUIT, "api-quit"},
17 { EXIT_REASON_CMD_EXIT, "cmd-exit"},
17 - { EXIT_REASON_FATAL, "fatal"},
18 - { EXIT_REASON_SYSTEM_SHUTDOWN, "system-shutdown"},
18 +
19 + { EXIT_REASON_SIGQUIT, "signal-quit"},
20 + { EXIT_REASON_SIGTERM, "signal-terminate"},
21 + { EXIT_REASON_SIGINT, "signal-interrupt"},
22 +
23 { EXIT_REASON_SERVICE_STOP, "service-stop"},
24 +
25 + { EXIT_REASON_SYSTEM_SHUTDOWN, "system-shutdown"},
26 +
27 { EXIT_REASON_UPDATE, "update"},
21 - { EXIT_REASON_OUT_OF_MEMORY, "out-of-memory"},
28
29 // terminator
30 {0, NULL},
@@ -96,6 +102,10 @@ void exit_initiated_reset(void) {
102 self = os_get_file_metadata(self_path);
103 }
104
105 +void exit_initiated_add(EXIT_REASON reason) {
106 + exit_initiated |= reason;
107 +}
108 +
109 void exit_initiated_set(EXIT_REASON reason) {
110 if(exit_initiated == EXIT_REASON_NONE && !(reason & EXIT_REASON_SYSTEM_SHUTDOWN) && is_system_shutdown())
111 reason |= EXIT_REASON_SYSTEM_SHUTDOWN;
@@ -109,5 +119,6 @@ void exit_initiated_set(EXIT_REASON reason) {
119 // we combine all of them together
120 // so that if this is called multiple times,
121 // we will have all of them
112 - exit_initiated |= reason;
122 + exit_initiated_add(reason);
123 }
124 +
src/libnetdata/exit/exit_initiated.h
+1
@@ -51,5 +51,6 @@ extern volatile EXIT_REASON exit_initiated;
51
52 void exit_initiated_reset(void);
53 void exit_initiated_set(EXIT_REASON reason);
54 +void exit_initiated_add(EXIT_REASON reason);
55
56 #endif //NETDATA_EXIT_INITIATED_H
src/libnetdata/log/nd_log-init.c
+2 -2
@@ -281,8 +281,8 @@ int nd_log_systemd_journal_fd(void) {
281
282 void nd_log_reopen_log_files_for_spawn_server(const char *name) {
283 nd_log_forked = true;
284 - nd_log.log_event_cb = NULL;
285 - nd_log.fatal_event_cb = NULL;
284 + nd_log.fatal_data_cb = NULL;
285 + nd_log.fatal_final_cb = NULL;
286
287 gettid_uncached();
288
src/libnetdata/log/nd_log-internals.h
+2 -2
@@ -125,8 +125,8 @@ struct nd_log {
125 nd_uuid_t invocation_id;
126
127 ND_LOG_SOURCES overwrite_process_source;
128 - log_event_t log_event_cb;
129 - fatal_event_t fatal_event_cb;
128 + log_event_t fatal_data_cb;
129 + fatal_event_t fatal_final_cb;
130
131 struct nd_log_source sources[_NDLS_MAX];
132
src/libnetdata/log/nd_log.c
+8 -8
@@ -118,7 +118,7 @@ static void nd_log_event(struct log_field *fields, size_t fields_max __maybe_unu
118
119 nd_log_event_this = false;
120
121 - if(!nd_log.log_event_cb)
121 + if(!nd_log.fatal_data_cb)
122 return;
123
124 const char *filename = log_field_strdupz(&fields[NDF_FILE]);
@@ -128,17 +128,17 @@ static void nd_log_event(struct log_field *fields, size_t fields_max __maybe_unu
128 const char *errno_str = log_field_strdupz(&fields[NDF_ERRNO]);
129 long line = log_field_to_int64(&fields[NDF_LINE]);
130
131 - nd_log.log_event_cb(filename, function, message, errno_str, stack_trace, line);
131 + nd_log.fatal_data_cb(filename, function, message, errno_str, stack_trace, line);
132 }
133
134 -void nd_log_register_event_cb(log_event_t cb) {
135 - nd_log.log_event_cb = cb;
134 +void nd_log_register_fatal_data_cb(log_event_t cb) {
135 + nd_log.fatal_data_cb = cb;
136 }
137
138 // --------------------------------------------------------------------------------------------------------------------
139
140 -void nd_log_register_fatal_cb(fatal_event_t cb) {
141 - nd_log.fatal_event_cb = cb;
140 +void nd_log_register_fatal_final_cb(fatal_event_t cb) {
141 + nd_log.fatal_final_cb = cb;
142 }
143
144 // --------------------------------------------------------------------------------------------------------------------
@@ -521,8 +521,8 @@ void netdata_logger_fatal(const char *file, const char *function, const unsigned
521 // abort();
522 #endif
523
524 - if(nd_log.fatal_event_cb)
525 - nd_log.fatal_event_cb();
524 + if(nd_log.fatal_final_cb)
525 + nd_log.fatal_final_cb();
526
527 exit(1);
528 }
src/libnetdata/log/nd_log.h
+2 -2
@@ -35,10 +35,10 @@ ND_UUID nd_log_get_invocation_id(void);
35 void capture_stack_trace(BUFFER *wb);
36
37 typedef void (*log_event_t)(const char *filename, const char *function, const char *message, const char *errno_str, const char *stack_trace, long line);
38 -void nd_log_register_event_cb(log_event_t cb);
38 +void nd_log_register_fatal_data_cb(log_event_t cb);
39
40 typedef void (*fatal_event_t)(void);
41 -void nd_log_register_fatal_cb(fatal_event_t cb);
41 +void nd_log_register_fatal_final_cb(fatal_event_t cb);
42
43 int nd_log_health_fd(void);
44 int nd_log_collectors_fd(void);
src/libnetdata/memory/nd-mallocz.c
+2
@@ -9,6 +9,8 @@ void mallocz_register_out_of_memory_cb(out_of_memory_cb cb) {
9
10 ALWAYS_INLINE NORETURN
11 static void out_of_memory(const char *call, size_t size) {
12 + exit_initiated_add(EXIT_REASON_OUT_OF_MEMORY);
13 +
14 if(out_of_memory_callback)
15 out_of_memory_callback();
16