diff --git a/hash_query.c b/hash_query.c index 97c4f44..d59164a 100644 --- a/hash_query.c +++ b/hash_query.c @@ -19,14 +19,14 @@ #include "pg_stat_monitor.h" static pgsmLocalState pgsmStateLocal; -static PGSM_HASH_TABLE_HANDLE pgsm_create_bucket_hash(pgssSharedState *pgss, dsa_area *dsa); +static PGSM_HASH_TABLE_HANDLE pgsm_create_bucket_hash(pgsmSharedState *pgsm, dsa_area *dsa); static Size pgsm_get_shared_area_size(void); #if USE_DYNAMIC_HASH /* parameter for the shared hash */ static dshash_parameters dsh_params = { - sizeof(pgssHashKey), - sizeof(pgssEntry), + sizeof(pgsmHashKey), + sizeof(pgsmEntry), dshash_memcmp, dshash_memhash }; @@ -54,12 +54,12 @@ pgsm_query_area_size(void) Size pgsm_ShmemSize(void) { - Size sz = MAXALIGN(sizeof(pgssSharedState)); + Size sz = MAXALIGN(sizeof(pgsmSharedState)); sz = add_size(sz, MAX_QUERY_BUF); #if USE_DYNAMIC_HASH sz = add_size(sz, MAX_BUCKETS_MEM); #else - sz = add_size(sz, hash_estimate_size(MAX_BUCKET_ENTRIES, sizeof(pgssEntry))); + sz = add_size(sz, hash_estimate_size(MAX_BUCKET_ENTRIES, sizeof(pgsmEntry))); #endif return MAXALIGN(sz); } @@ -77,47 +77,47 @@ pgsm_get_shared_area_size(void) #if USE_DYNAMIC_HASH sz = pgsm_ShmemSize(); #else - sz = MAXALIGN(sizeof(pgssSharedState)); + sz = MAXALIGN(sizeof(pgsmSharedState)); sz = add_size(sz, pgsm_query_area_size()); #endif return sz; } void -pgss_startup(void) +pgsm_startup(void) { bool found = false; - pgssSharedState *pgss; + pgsmSharedState *pgsm; /* reset in case this is a restart within the postmaster */ pgsmStateLocal.dsa = NULL; pgsmStateLocal.shared_hash = NULL; - pgsmStateLocal.shared_pgssState = NULL; + pgsmStateLocal.shared_pgsmState = NULL; /* * Create or attach to the shared memory state, including hash table */ LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); - pgss = ShmemInitStruct("pg_stat_monitor", pgsm_get_shared_area_size(), &found); + pgsm = ShmemInitStruct("pg_stat_monitor", pgsm_get_shared_area_size(), &found); if (!found) { /* First time through ... */ dsa_area *dsa; - char *p = (char *) pgss; + char *p = (char *) pgsm; - pgss->lock = &(GetNamedLWLockTranche("pg_stat_monitor"))->lock; - SpinLockInit(&pgss->mutex); - ResetSharedState(pgss); - /* the allocation of pgssSharedState itself */ - p += MAXALIGN(sizeof(pgssSharedState)); - pgss->raw_dsa_area = p; - dsa = dsa_create_in_place(pgss->raw_dsa_area, + pgsm->lock = &(GetNamedLWLockTranche("pg_stat_monitor"))->lock; + SpinLockInit(&pgsm->mutex); + ResetSharedState(pgsm); + /* the allocation of pgsmSharedState itself */ + p += MAXALIGN(sizeof(pgsmSharedState)); + pgsm->raw_dsa_area = p; + dsa = dsa_create_in_place(pgsm->raw_dsa_area, pgsm_query_area_size(), LWLockNewTrancheId(), 0); dsa_pin(dsa); dsa_set_size_limit(dsa, pgsm_query_area_size()); - pgss->hash_handle = pgsm_create_bucket_hash(pgss,dsa); + pgsm->hash_handle = pgsm_create_bucket_hash(pgsm,dsa); /* If overflow is enabled, set the DSA size to unlimited, * and allow the DSA to grow beyond the shared memory space @@ -125,7 +125,7 @@ pgss_startup(void) if (PGSM_OVERFLOW_TARGET == OVERFLOW_TARGET_DISK) dsa_set_size_limit(dsa, -1); - pgsmStateLocal.shared_pgssState = pgss; + pgsmStateLocal.shared_pgsmState = pgsm; /* * Postmaster will never access the dsa again, thus free it's local * references. @@ -143,29 +143,29 @@ pgss_startup(void) * If we're in the postmaster (or a standalone backend...), set up a shmem * exit hook to dump the statistics to disk. */ - on_shmem_exit(pgss_shmem_shutdown, (Datum) 0); + on_shmem_exit(pgsm_shmem_shutdown, (Datum) 0); } /* * Create the classic or dshahs hash table for storing the query statistics. */ static PGSM_HASH_TABLE_HANDLE -pgsm_create_bucket_hash(pgssSharedState *pgss, dsa_area *dsa) +pgsm_create_bucket_hash(pgsmSharedState *pgsm, dsa_area *dsa) { PGSM_HASH_TABLE_HANDLE bucket_hash; #if USE_DYNAMIC_HASH dshash_table *dsh; - pgss->hash_tranche_id = LWLockNewTrancheId(); - dsh_params.tranche_id = pgss->hash_tranche_id; + pgsm->hash_tranche_id = LWLockNewTrancheId(); + dsh_params.tranche_id = pgsm->hash_tranche_id; dsh = dshash_create(dsa, &dsh_params, 0); bucket_hash = dshash_get_hash_table_handle(dsh); dshash_detach(dsh); #else HASHCTL info; memset(&info, 0, sizeof(info)); - info.keysize = sizeof(pgssHashKey); - info.entrysize = sizeof(pgssEntry); + info.keysize = sizeof(pgsmHashKey); + info.entrysize = sizeof(pgsmEntry); bucket_hash = ShmemInitHash("pg_stat_monitor: bucket hashtable", MAX_BUCKET_ENTRIES, MAX_BUCKET_ENTRIES, &info, HASH_ELEM | HASH_BLOBS); #endif return bucket_hash; @@ -193,7 +193,7 @@ pgsm_attach_shmem(void) */ oldcontext = MemoryContextSwitchTo(TopMemoryContext); - pgsmStateLocal.dsa = dsa_attach_in_place(pgsmStateLocal.shared_pgssState->raw_dsa_area, + pgsmStateLocal.dsa = dsa_attach_in_place(pgsmStateLocal.shared_pgsmState->raw_dsa_area, NULL); /* pin the attached area to keep the area attached until end of * session or explicit detach. @@ -201,11 +201,11 @@ pgsm_attach_shmem(void) dsa_pin_mapping(pgsmStateLocal.dsa); #if USE_DYNAMIC_HASH - dsh_params.tranche_id = pgsmStateLocal.shared_pgssState->hash_tranche_id; + dsh_params.tranche_id = pgsmStateLocal.shared_pgsmState->hash_tranche_id; pgsmStateLocal.shared_hash = dshash_attach(pgsmStateLocal.dsa, &dsh_params, - pgsmStateLocal.shared_pgssState->hash_handle, 0); + pgsmStateLocal.shared_pgsmState->hash_handle, 0); #else - pgsmStateLocal.shared_hash = pgsmStateLocal.shared_pgssState->hash_handle; + pgsmStateLocal.shared_hash = pgsmStateLocal.shared_pgsmState->hash_handle; #endif MemoryContextSwitchTo(oldcontext); @@ -219,17 +219,17 @@ get_dsa_area_for_query_text(void) } PGSM_HASH_TABLE* -get_pgssHash(void) +get_pgsmHash(void) { pgsm_attach_shmem(); return pgsmStateLocal.shared_hash; } -pgssSharedState * +pgsmSharedState * pgsm_get_ss(void) { pgsm_attach_shmem(); - return pgsmStateLocal.shared_pgssState; + return pgsmStateLocal.shared_pgsmState; } @@ -240,31 +240,32 @@ pgsm_get_ss(void) * other processes running when this is called. */ void -pgss_shmem_shutdown(int code, Datum arg) +pgsm_shmem_shutdown(int code, Datum arg) { /* Don't try to dump during a crash. */ - elog(LOG,"pgss_shmem_shutdown"); + elog(LOG,"[pg_stat_monitor] pgsm_shmem_shutdown: Shutdown initiated."); + if (code) return; - pgsmStateLocal.shared_pgssState = NULL; + pgsmStateLocal.shared_pgsmState = NULL; /* Safety check ... shouldn't get here unless shmem is set up. */ if (!IsHashInitialize()) return; } -pgssEntry * -hash_entry_alloc(pgssSharedState *pgss, pgssHashKey *key, int encoding) +pgsmEntry * +hash_entry_alloc(pgsmSharedState *pgsm, pgsmHashKey *key, int encoding) { - pgssEntry *entry = NULL; + pgsmEntry *entry = NULL; bool found = false; /* Find or create an entry with desired hash code */ - entry = (pgssEntry*) pgsm_hash_find_or_insert(pgsmStateLocal.shared_hash, key, &found); + entry = (pgsmEntry*) pgsm_hash_find_or_insert(pgsmStateLocal.shared_hash, key, &found); if (entry == NULL) - elog(DEBUG1, "hash_entry_alloc: OUT OF MEMORY"); + elog(DEBUG1, "[pg_stat_monitor] hash_entry_alloc: OUT OF MEMORY."); else if (!found) { - pgss->bucket_entry[pg_atomic_read_u64(&pgss->current_wbucket)]++; + pgsm->bucket_entry[pg_atomic_read_u64(&pgsm->current_wbucket)]++; /* New entry, initialize it */ /* reset the statistics */ memset(&entry->counters, 0, sizeof(Counters)); @@ -295,13 +296,13 @@ hash_entry_alloc(pgssSharedState *pgss, pgssHashKey *key, int encoding) * previous query buffer (query_buffer[old_bucket_id]) to the new one * (query_buffer[new_bucket_id]). * - * Caller must hold an exclusive lock on pgss->lock. + * Caller must hold an exclusive lock on pgsm->lock. */ void hash_entry_dealloc(int new_bucket_id, int old_bucket_id, unsigned char *query_buffer) { PGSM_HASH_SEQ_STATUS hstat; - pgssEntry *entry = NULL; + pgsmEntry *entry = NULL; /* Store pending query ids from the previous bucket. */ if (!pgsmStateLocal.shared_hash) @@ -340,7 +341,7 @@ hash_entry_dealloc(int new_bucket_id, int old_bucket_id, unsigned char *query_bu bool IsHashInitialize(void) { - return (pgsmStateLocal.shared_pgssState != NULL); + return (pgsmStateLocal.shared_pgsmState != NULL); } /* @@ -349,7 +350,7 @@ IsHashInitialize(void) */ void * -pgsm_hash_find_or_insert(PGSM_HASH_TABLE *shared_hash, pgssHashKey *key, bool* found) +pgsm_hash_find_or_insert(PGSM_HASH_TABLE *shared_hash, pgsmHashKey *key, bool* found) { #if USE_DYNAMIC_HASH void *entry; @@ -361,7 +362,7 @@ pgsm_hash_find_or_insert(PGSM_HASH_TABLE *shared_hash, pgssHashKey *key, bool* f } void * -pgsm_hash_find(PGSM_HASH_TABLE *shared_hash, pgssHashKey *key, bool* found) +pgsm_hash_find(PGSM_HASH_TABLE *shared_hash, pgsmHashKey *key, bool* found) { #if USE_DYNAMIC_HASH return dshash_find(shared_hash, key, false); diff --git a/pg_stat_monitor.c b/pg_stat_monitor.c index 1718ef8..ce2c4a5 100644 --- a/pg_stat_monitor.c +++ b/pg_stat_monitor.c @@ -101,7 +101,7 @@ static struct rusage rusage_end; /* Query buffer, store queries' text. */ -static char *pgss_explain(QueryDesc *queryDesc); +static char *pgsm_explain(QueryDesc *queryDesc); static void extract_query_comments(const char *query, char *comments, size_t max_len); static void histogram_bucket_timings(int index, int64 *b_start, int64 *b_end); @@ -114,7 +114,7 @@ static void request_additional_shared_resources(void); /* Saved hook values in case of unload */ #if PG_VERSION_NUM >= 150000 -static void pgss_shmem_request(void); +static void pgsm_shmem_request(void); static shmem_request_hook_type prev_shmem_request_hook = NULL; #endif #if PG_VERSION_NUM >= 130000 @@ -151,15 +151,15 @@ DECLARE_HOOK(void pgsm_post_parse_analyze, ParseState *pstate, Query *query); DECLARE_HOOK(void pgsm_post_parse_analyze, ParseState *pstate, Query *query, JumbleState *jstate); #endif -DECLARE_HOOK(void pgss_ExecutorStart, QueryDesc *queryDesc, int eflags); -DECLARE_HOOK(void pgss_ExecutorRun, QueryDesc *queryDesc, ScanDirection direction, uint64 count, bool execute_once); -DECLARE_HOOK(void pgss_ExecutorFinish, QueryDesc *queryDesc); +DECLARE_HOOK(void pgsm_ExecutorStart, QueryDesc *queryDesc, int eflags); +DECLARE_HOOK(void pgsm_ExecutorRun, QueryDesc *queryDesc, ScanDirection direction, uint64 count, bool execute_once); +DECLARE_HOOK(void pgsm_ExecutorFinish, QueryDesc *queryDesc); DECLARE_HOOK(void pgsm_ExecutorEnd, QueryDesc *queryDesc); -DECLARE_HOOK(bool pgss_ExecutorCheckPerms, List *rt, bool abort); +DECLARE_HOOK(bool pgsm_ExecutorCheckPerms, List *rt, bool abort); #if PG_VERSION_NUM >= 140000 DECLARE_HOOK(PlannedStmt *pgsm_planner_hook, Query *parse, const char *query_string, int cursorOptions, ParamListInfo boundParams); -DECLARE_HOOK(void pgss_ProcessUtility, PlannedStmt *pstmt, const char *queryString, +DECLARE_HOOK(void pgsm_ProcessUtility, PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, @@ -167,7 +167,7 @@ DECLARE_HOOK(void pgss_ProcessUtility, PlannedStmt *pstmt, const char *queryStri QueryCompletion *qc); #elif PG_VERSION_NUM >= 130000 DECLARE_HOOK(PlannedStmt *pgsm_planner_hook, Query *parse, const char *query_string, int cursorOptions, ParamListInfo boundParams); -DECLARE_HOOK(void pgss_ProcessUtility, PlannedStmt *pstmt, const char *queryString, +DECLARE_HOOK(void pgsm_ProcessUtility, PlannedStmt *pstmt, const char *queryString, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, @@ -175,13 +175,13 @@ DECLARE_HOOK(void pgss_ProcessUtility, PlannedStmt *pstmt, const char *queryStri #else static void BufferUsageAccumDiff(BufferUsage *bufusage, BufferUsage *pgBufferUsage, BufferUsage *bufusage_start); -DECLARE_HOOK(void pgss_ProcessUtility, PlannedStmt *pstmt, const char *queryString, +DECLARE_HOOK(void pgsm_ProcessUtility, PlannedStmt *pstmt, const char *queryString, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, char *completionTag); #endif -static uint64 pgss_hash_string(const char *str, int len); +static uint64 pgsm_hash_string(const char *str, int len); char *unpack_sql_state(int sql_state); #define PGSM_HANDLED_UTILITY(n) (!IsA(n, ExecuteStmt) && \ @@ -189,13 +189,13 @@ char *unpack_sql_state(int sql_state); !IsA(n, DeallocateStmt)) -static pgssEntry *pgsm_create_hash_entry(MemoryContext context, uint64 bucket_id, uint64 queryid, PlanInfo *plan_info); -static void pgsm_add_to_list(pgssEntry *entry, char *query_text, int query_len, bool should_dup); -static pgssEntry* pgsm_get_entry_for_query(uint64 queryid, PlanInfo *plan_info, const char* query_text, int query_len, bool create); +static pgsmEntry *pgsm_create_hash_entry(MemoryContext context, uint64 bucket_id, uint64 queryid, PlanInfo *plan_info); +static void pgsm_add_to_list(pgsmEntry *entry, char *query_text, int query_len, bool should_dup); +static pgsmEntry* pgsm_get_entry_for_query(uint64 queryid, PlanInfo *plan_info, const char* query_text, int query_len, bool create); static void pgsm_cleanup_callback(void *arg); static void pgsm_store_error(const char *query, ErrorData *edata); -static void pgsm_update_entry(pgssEntry *entry, +static void pgsm_update_entry(pgsmEntry *entry, const char *query, PlanInfo * plan_info, SysInfo * sys_info, @@ -208,7 +208,7 @@ static void pgsm_update_entry(pgssEntry *entry, const struct JitInstrumentation *jitusage, bool reset, pgsmStoreKind kind); -static void pgsm_store(pgssEntry *entry); +static void pgsm_store(pgsmEntry *entry); static void pg_stat_monitor_internal(FunctionCallInfo fcinfo, pgsmVersion api_version, @@ -234,7 +234,7 @@ static char *generate_normalized_query(JumbleState *jstate, const char *query, static void fill_in_constant_lengths(JumbleState *jstate, const char *query, int query_loc); static int comp_location(const void *a, const void *b); -static uint64 get_next_wbucket(pgssSharedState *pgss); +static uint64 get_next_wbucket(pgsmSharedState *pgsm); #if PG_VERSION_NUM < 140000 static uint64 get_query_id(JumbleState *jstate, Query *query); @@ -249,7 +249,7 @@ _PG_init(void) { int rc; - elog(DEBUG2, "pg_stat_monitor: %s()", __FUNCTION__); + elog(DEBUG2, "[pg_stat_monitor] pg_stat_monitor: %s().", __FUNCTION__); /* * In order to create our shared memory area, we have to be loaded via @@ -326,7 +326,7 @@ _PG_init(void) rc = regcomp(&preg_query_comments, "/\\*([^*]|[\r\n]|(\\*+([^*/]|[\r\n])))*\\*+/", REG_EXTENDED); if (rc != 0) { - elog(ERROR, "pg_stat_monitor: query comments regcomp() failed, return code=(%d)\n", rc); + elog(ERROR, "[pg_stat_monitor] _PG_init: query comments regcomp() failed, return code=(%d).", rc); } /* @@ -334,24 +334,24 @@ _PG_init(void) */ #if PG_VERSION_NUM >= 150000 prev_shmem_request_hook = shmem_request_hook; - shmem_request_hook = pgss_shmem_request; + shmem_request_hook = pgsm_shmem_request; #else request_additional_shared_resources(); #endif prev_shmem_startup_hook = shmem_startup_hook; - shmem_startup_hook = pgss_shmem_startup; + shmem_startup_hook = pgsm_shmem_startup; prev_post_parse_analyze_hook = post_parse_analyze_hook; post_parse_analyze_hook = HOOK(pgsm_post_parse_analyze); prev_ExecutorStart = ExecutorStart_hook; - ExecutorStart_hook = HOOK(pgss_ExecutorStart); + ExecutorStart_hook = HOOK(pgsm_ExecutorStart); prev_ExecutorRun = ExecutorRun_hook; - ExecutorRun_hook = HOOK(pgss_ExecutorRun); + ExecutorRun_hook = HOOK(pgsm_ExecutorRun); prev_ExecutorFinish = ExecutorFinish_hook; - ExecutorFinish_hook = HOOK(pgss_ExecutorFinish); + ExecutorFinish_hook = HOOK(pgsm_ExecutorFinish); prev_ExecutorEnd = ExecutorEnd_hook; ExecutorEnd_hook = HOOK(pgsm_ExecutorEnd); prev_ProcessUtility = ProcessUtility_hook; - ProcessUtility_hook = HOOK(pgss_ProcessUtility); + ProcessUtility_hook = HOOK(pgsm_ProcessUtility); #if PG_VERSION_NUM >= 130000 planner_hook_next = planner_hook; planner_hook = HOOK(pgsm_planner_hook); @@ -359,7 +359,7 @@ _PG_init(void) prev_emit_log_hook = emit_log_hook; emit_log_hook = HOOK(pgsm_emit_log_hook); prev_ExecutorCheckPerms_hook = ExecutorCheckPerms_hook; - ExecutorCheckPerms_hook = HOOK(pgss_ExecutorCheckPerms); + ExecutorCheckPerms_hook = HOOK(pgsm_ExecutorCheckPerms); nested_queryids = (uint64 *) malloc(sizeof(uint64) * max_stack_depth); nested_query_txts = (char **) malloc(sizeof(char*) * max_stack_depth); @@ -374,12 +374,12 @@ _PG_init(void) * (even if empty) while the module is enabled. */ void -pgss_shmem_startup(void) +pgsm_shmem_startup(void) { if (prev_shmem_startup_hook) prev_shmem_startup_hook(); - pgss_startup(); + pgsm_startup(); } static void @@ -388,7 +388,7 @@ request_additional_shared_resources(void) /* * Request additional shared resources. (These are no-ops if we're not in * the postmaster process.) We'll allocate or attach to the shared - * resources in pgss_shmem_startup(). + * resources in pgsm_shmem_startup(). */ RequestAddinShmemSpace(pgsm_ShmemSize() + HOOK_STATS_SIZE); RequestNamedLWLockTranche("pg_stat_monitor", 1); @@ -405,10 +405,10 @@ pg_stat_monitor_version(PG_FUNCTION_ARGS) #if PG_VERSION_NUM >= 150000 /* * shmem_request hook: request additional shared resources. We'll allocate or - * attach to the shared resources in pgss_shmem_startup(). + * attach to the shared resources in pgsm_shmem_startup(). */ static void -pgss_shmem_request(void) +pgsm_shmem_request(void) { if (prev_shmem_request_hook) prev_shmem_request_hook(); @@ -419,7 +419,7 @@ pgss_shmem_request(void) static void pgsm_post_parse_analyze_internal(ParseState *pstate, Query *query, JumbleState *jstate) { - pgssEntry *entry; + pgsmEntry *entry; const char *query_text; char *norm_query = NULL; int norm_query_len; @@ -514,7 +514,7 @@ pgsm_post_parse_analyze_internal(ParseState *pstate, Query *query, JumbleState * entry = pgsm_create_hash_entry(MessageContext, 0, query->queryId, NULL); /* Update other member that are not counters, so that we don't have to worry about these. */ - entry->pgsm_query_id = pgss_hash_string(norm_query ? norm_query : query_text, norm_query_len); + entry->pgsm_query_id = pgsm_hash_string(norm_query ? norm_query : query_text, norm_query_len); entry->counters.info.cmd_type = query->commandType; /* @@ -573,10 +573,10 @@ pgsm_post_parse_analyze(ParseState *pstate, Query *query) * ExecutorStart hook: start up tracking if needed */ static void -pgss_ExecutorStart(QueryDesc *queryDesc, int eflags) +pgsm_ExecutorStart(QueryDesc *queryDesc, int eflags) { if (getrusage(RUSAGE_SELF, &rusage_start) != 0) - elog(DEBUG1, "pgss_ExecutorStart: failed to execute getrusage"); + elog(DEBUG1, "[pg_stat_monitor] pgsm_ExecutorStart: failed to execute getrusage."); if (prev_ExecutorStart) prev_ExecutorStart(queryDesc, eflags); @@ -616,7 +616,7 @@ pgss_ExecutorStart(QueryDesc *queryDesc, int eflags) * ExecutorRun hook: all we need do is track nesting depth */ static void -pgss_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count, +pgsm_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count, bool execute_once) { if (exec_nested_level >= 0 && exec_nested_level < max_stack_depth) @@ -660,7 +660,7 @@ pgss_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count, * ExecutorFinish hook: all we need do is track nesting depth */ static void -pgss_ExecutorFinish(QueryDesc *queryDesc) +pgsm_ExecutorFinish(QueryDesc *queryDesc) { exec_nested_level++; @@ -682,7 +682,7 @@ pgss_ExecutorFinish(QueryDesc *queryDesc) } static char * -pgss_explain(QueryDesc *queryDesc) +pgsm_explain(QueryDesc *queryDesc) { ExplainState *es = NewExplainState(); @@ -711,13 +711,13 @@ pgsm_ExecutorEnd(QueryDesc *queryDesc) SysInfo sys_info; PlanInfo plan_info; PlanInfo *plan_ptr = NULL; - pgssEntry *entry = NULL; + pgsmEntry *entry = NULL; /* Extract the plan information in case of SELECT statement */ if (queryDesc->operation == CMD_SELECT && PGSM_QUERY_PLAN) { - plan_info.plan_len = snprintf(plan_info.plan_text, PLAN_TEXT_LEN, "%s", pgss_explain(queryDesc)); - plan_info.planid = pgss_hash_string(plan_info.plan_text, plan_info.plan_len); + plan_info.plan_len = snprintf(plan_info.plan_text, PLAN_TEXT_LEN, "%s", pgsm_explain(queryDesc)); + plan_info.planid = pgsm_hash_string(plan_info.plan_text, plan_info.plan_len); plan_ptr = &plan_info; } @@ -726,7 +726,7 @@ pgsm_ExecutorEnd(QueryDesc *queryDesc) entry = pgsm_get_entry_for_query(queryId, plan_ptr, (char *)queryDesc->sourceText, strlen(queryDesc->sourceText), true); if(!entry) { - elog(NOTICE,"Failed to find entry for [%lu] %s",queryId, queryDesc->sourceText); + elog(NOTICE,"[pg_stat_monitor] pgsm_ExecutorEnd: Failed to find entry for [%lu] %s.",queryId, queryDesc->sourceText); return; } @@ -743,7 +743,7 @@ pgsm_ExecutorEnd(QueryDesc *queryDesc) sys_info.stime = 0; if (getrusage(RUSAGE_SELF, &rusage_end) != 0) - elog(DEBUG1, "pg_stat_monitor: failed to execute getrusage"); + elog(DEBUG1, "[pg_stat_monitor] pgsm_ExecutorEnd: Failed to execute getrusage."); else { sys_info.utime = time_diff(rusage_end.ru_utime, rusage_start.ru_utime); @@ -784,7 +784,7 @@ pgsm_ExecutorEnd(QueryDesc *queryDesc) } static bool -pgss_ExecutorCheckPerms(List *rt, bool abort) +pgsm_ExecutorCheckPerms(List *rt, bool abort) { ListCell *lr = NULL; int i = 0; @@ -838,7 +838,7 @@ static PlannedStmt * pgsm_planner_hook(Query *parse, const char *query_string, int cursorOptions, ParamListInfo boundParams) { PlannedStmt *result; - pgssEntry *entry = NULL; + pgsmEntry *entry = NULL; /* @@ -952,7 +952,7 @@ pgsm_planner_hook(Query *parse, const char *query_string, int cursorOptions, Par */ #if PG_VERSION_NUM >= 140000 static void -pgss_ProcessUtility(PlannedStmt *pstmt, const char *queryString, +pgsm_ProcessUtility(PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, @@ -961,7 +961,7 @@ pgss_ProcessUtility(PlannedStmt *pstmt, const char *queryString, #elif PG_VERSION_NUM >= 130000 static void -pgss_ProcessUtility(PlannedStmt *pstmt, const char *queryString, +pgsm_ProcessUtility(PlannedStmt *pstmt, const char *queryString, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, @@ -969,7 +969,7 @@ pgss_ProcessUtility(PlannedStmt *pstmt, const char *queryString, #else static void -pgss_ProcessUtility(PlannedStmt *pstmt, const char *queryString, +pgsm_ProcessUtility(PlannedStmt *pstmt, const char *queryString, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, @@ -982,7 +982,7 @@ pgss_ProcessUtility(PlannedStmt *pstmt, const char *queryString, #if PG_VERSION_NUM < 140000 int len = strlen(queryString); - queryId = pgss_hash_string(queryString, len); + queryId = pgsm_hash_string(queryString, len); #else queryId = pstmt->queryId; @@ -1016,7 +1016,7 @@ pgss_ProcessUtility(PlannedStmt *pstmt, const char *queryString, if (PGSM_TRACK_UTILITY && pgsm_enabled(exec_nested_level) && PGSM_HANDLED_UTILITY(parsetree)) { - pgssEntry *entry; + pgsmEntry *entry; char *query_text; int location; int query_len; @@ -1032,7 +1032,7 @@ pgss_ProcessUtility(PlannedStmt *pstmt, const char *queryString, #endif if (getrusage(RUSAGE_SELF, &rusage_start) != 0) - elog(DEBUG1, "pg_stat_monitor: failed to execute getrusage"); + elog(DEBUG1, "[pg_stat_monitor] pgsm_ProcessUtility: Failed to execute getrusage."); INSTR_TIME_SET_CURRENT(start); exec_nested_level++; @@ -1089,7 +1089,7 @@ pgss_ProcessUtility(PlannedStmt *pstmt, const char *queryString, PG_END_TRY(); if (getrusage(RUSAGE_SELF, &rusage_end) != 0) - elog(DEBUG1, "pg_stat_monitor: failed to execute getrusage"); + elog(DEBUG1, "[pg_stat_monitor] pgsm_ProcessUtility: Failed to execute getrusage."); else { sys_info.utime = time_diff(rusage_end.ru_utime, rusage_start.ru_utime); @@ -1132,7 +1132,7 @@ pgss_ProcessUtility(PlannedStmt *pstmt, const char *queryString, query_len = pstmt->stmt_len; query_text = (char *)CleanQuerytext(queryString, &location, &query_len); - entry->pgsm_query_id = pgss_hash_string(query_text, query_len); + entry->pgsm_query_id = pgsm_hash_string(query_text, query_len); entry->counters.info.cmd_type = 0; pgsm_add_to_list(entry, query_text, query_len, true); @@ -1230,7 +1230,7 @@ BufferUsageAccumDiff(BufferUsage *bufusage, BufferUsage *pgBufferUsage, BufferUs * utility statements. */ static uint64 -pgss_hash_string(const char *str, int len) +pgsm_hash_string(const char *str, int len) { return DatumGetUInt64(hash_any_extended((const unsigned char *) str, len, 0)); @@ -1314,7 +1314,7 @@ pg_get_client_addr(bool *ok) } static void -pgsm_update_entry(pgssEntry *entry, +pgsm_update_entry(pgsmEntry *entry, const char *query, PlanInfo * plan_info, SysInfo * sys_info, @@ -1342,7 +1342,7 @@ pgsm_update_entry(pgssEntry *entry, /* volatile block */ { - volatile pgssEntry *e = (volatile pgssEntry *)entry; + volatile pgsmEntry *e = (volatile pgsmEntry *)entry; if (kind == PGSM_STORE) SpinLockAcquire(&e->mutex); @@ -1557,7 +1557,7 @@ pgsm_update_entry(pgssEntry *entry, static void pgsm_store_error(const char *query, ErrorData *edata) { - pgssEntry *entry; + pgsmEntry *entry; uint64 queryid = 0; int len = strlen(query); @@ -1566,7 +1566,7 @@ pgsm_store_error(const char *query, ErrorData *edata) len = strlen(query); - queryid = pgss_hash_string(query, len); + queryid = pgsm_hash_string(query, len); entry = pgsm_create_hash_entry(ErrorContext, 0, queryid, NULL); entry->query_text.query_pointer = pnstrdup(query, len); @@ -1579,7 +1579,7 @@ pgsm_store_error(const char *query, ErrorData *edata) } static void -pgsm_add_to_list(pgssEntry *entry, char *query_text, int query_len, bool should_dup) +pgsm_add_to_list(pgsmEntry *entry, char *query_text, int query_len, bool should_dup) { MemoryContext oldctx; @@ -1596,10 +1596,10 @@ pgsm_add_to_list(pgssEntry *entry, char *query_text, int query_len, bool should_ MemoryContextSwitchTo(oldctx); } -static pgssEntry* +static pgsmEntry* pgsm_get_entry_for_query(uint64 queryid, PlanInfo *plan_info, const char* query_text, int query_len, bool create) { - pgssEntry *entry = NULL; + pgsmEntry *entry = NULL; ListCell *lc = NULL; /* First bet is on the last entry */ @@ -1608,7 +1608,7 @@ pgsm_get_entry_for_query(uint64 queryid, PlanInfo *plan_info, const char* query_ if (lentries) { - entry = (pgssEntry *)llast(lentries); + entry = (pgsmEntry *)llast(lentries); if(entry->key.queryid == queryid) return entry; @@ -1630,7 +1630,7 @@ pgsm_get_entry_for_query(uint64 queryid, PlanInfo *plan_info, const char* query_ entry = pgsm_create_hash_entry(MessageContext, 0, queryid, plan_info); /* Update other member that are not counters, so that we don't have to worry about these. */ - entry->pgsm_query_id = pgss_hash_string(query_text, query_len); + entry->pgsm_query_id = pgsm_hash_string(query_text, query_len); pgsm_add_to_list(entry, (char *)query_text, query_len, true); } @@ -1647,10 +1647,10 @@ pgsm_cleanup_callback(void *arg) * Function encapsulating some external calls for filling up the hash key data structure. * The bucket_id may not be known at this stage. So pass any value that you may wish. */ -static pgssEntry * +static pgsmEntry * pgsm_create_hash_entry(MemoryContext context, uint64 bucket_id, uint64 queryid, PlanInfo *plan_info) { - pgssEntry *entry; + pgsmEntry *entry; int sec_ctx; bool found_client_addr = false; char app_name[APPLICATIONNAME_LEN] = ""; @@ -1660,7 +1660,7 @@ pgsm_create_hash_entry(MemoryContext context, uint64 bucket_id, uint64 queryid, /* Create an entry in the TopMemoryContext */ oldctx = MemoryContextSwitchTo(context); - entry = palloc0(sizeof(pgssEntry)); + entry = palloc0(sizeof(pgsmEntry)); MemoryContextSwitchTo(oldctx); /* @@ -1671,7 +1671,7 @@ pgsm_create_hash_entry(MemoryContext context, uint64 bucket_id, uint64 queryid, /* Get the application name and set appid */ app_name_len = pg_get_application_name(app_name, APPLICATIONNAME_LEN); - entry->key.appid = pgss_hash_string((const char *)app_name_ptr, app_name_len); + entry->key.appid = pgsm_hash_string((const char *)app_name_ptr, app_name_len); /* client address */ entry->key.ip = pg_get_client_addr(&found_client_addr); @@ -1705,10 +1705,10 @@ pgsm_create_hash_entry(MemoryContext context, uint64 bucket_id, uint64 queryid, * query string. total_time, rows, bufusage are ignored in this case. */ static void -pgsm_store(pgssEntry *entry) +pgsm_store(pgsmEntry *entry) { - pgssEntry *shared_hash_entry; - pgssSharedState *pgss; + pgsmEntry *shared_hash_entry; + pgsmSharedState *pgsm; bool found; uint64 bucketid; uint64 prev_bucket_id; @@ -1723,11 +1723,11 @@ pgsm_store(pgssEntry *entry) if (!IsSystemInitialized()) return; - pgss = pgsm_get_ss(); + pgsm = pgsm_get_ss(); /* We should lock the hash table here what if the bucket is removed; e.g. reset is called - HAMID */ - prev_bucket_id = pg_atomic_read_u64(&pgss->current_wbucket); - bucketid = get_next_wbucket(pgss); + prev_bucket_id = pg_atomic_read_u64(&pgsm->current_wbucket); + bucketid = get_next_wbucket(pgsm); if (bucketid != prev_bucket_id) reset = true; @@ -1740,8 +1740,8 @@ pgsm_store(pgssEntry *entry) * Acquire a share lock to start with. We'd have to acquire exclusive * if we need ot create the entry. */ - LWLockAcquire(pgss->lock, LW_SHARED); - shared_hash_entry = (pgssEntry *) pgsm_hash_find(get_pgssHash(), &entry->key, &found); + LWLockAcquire(pgsm->lock, LW_SHARED); + shared_hash_entry = (pgsmEntry *) pgsm_hash_find(get_pgsmHash(), &entry->key, &found); if (!shared_hash_entry) { @@ -1758,7 +1758,7 @@ pgsm_store(pgssEntry *entry) dsa_query_pointer = dsa_allocate_extended(query_dsa_area, query_len+1, DSA_ALLOC_NO_OOM | DSA_ALLOC_ZERO); if (!DsaPointerIsValid(dsa_query_pointer)) { - LWLockRelease(pgss->lock); + LWLockRelease(pgsm->lock); return; } @@ -1766,19 +1766,19 @@ pgsm_store(pgssEntry *entry) query_buff = dsa_get_address(query_dsa_area, dsa_query_pointer); memcpy(query_buff, query, query_len); - LWLockRelease(pgss->lock); - LWLockAcquire(pgss->lock, LW_EXCLUSIVE); + LWLockRelease(pgsm->lock); + LWLockAcquire(pgsm->lock, LW_EXCLUSIVE); /* OK to create a new hashtable entry */ PGSM_DISABLE_ERROR_CAPUTRE(); { PG_TRY(); { - shared_hash_entry = hash_entry_alloc(pgss, &entry->key, GetDatabaseEncoding()); + shared_hash_entry = hash_entry_alloc(pgsm, &entry->key, GetDatabaseEncoding()); } PG_CATCH(); { - LWLockRelease(pgss->lock); + LWLockRelease(pgsm->lock); if (DsaPointerIsValid(dsa_query_pointer)) dsa_free(query_dsa_area, dsa_query_pointer); @@ -1789,7 +1789,7 @@ pgsm_store(pgssEntry *entry) if (shared_hash_entry == NULL) { - LWLockRelease(pgss->lock); + LWLockRelease(pgsm->lock); if (DsaPointerIsValid(dsa_query_pointer)) dsa_free(query_dsa_area, dsa_query_pointer); @@ -1857,7 +1857,7 @@ pgsm_store(pgssEntry *entry) PGSM_STORE); memset(&entry->counters, 0, sizeof(entry->counters)); - LWLockRelease(pgss->lock); + LWLockRelease(pgsm->lock); } /* @@ -1866,7 +1866,7 @@ pgsm_store(pgssEntry *entry) Datum pg_stat_monitor_reset(PG_FUNCTION_ARGS) { - pgssSharedState *pgss; + pgsmSharedState *pgsm; /* Safety check... */ if (!IsSystemInitialized()) @@ -1874,11 +1874,11 @@ pg_stat_monitor_reset(PG_FUNCTION_ARGS) (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("pg_stat_monitor: must be loaded via shared_preload_libraries"))); - pgss = pgsm_get_ss(); - LWLockAcquire(pgss->lock, LW_EXCLUSIVE); + pgsm = pgsm_get_ss(); + LWLockAcquire(pgsm->lock, LW_EXCLUSIVE); hash_entry_dealloc(-1, -1, NULL); - LWLockRelease(pgss->lock); + LWLockRelease(pgsm->lock); PG_RETURN_VOID(); } @@ -1912,9 +1912,9 @@ IsBucketValid(uint64 bucketid) long secs; int microsecs; TimestampTz current_tz = GetCurrentTimestamp(); - pgssSharedState *pgss = pgsm_get_ss(); + pgsmSharedState *pgsm = pgsm_get_ss(); - TimestampDifference(pgss->bucket_start_time[bucketid], current_tz,&secs, µsecs); + TimestampDifference(pgsm->bucket_start_time[bucketid], current_tz,&secs, µsecs); if (secs > (PGSM_BUCKET_TIME * PGSM_MAX_BUCKETS)) return false; @@ -1933,8 +1933,8 @@ pg_stat_monitor_internal(FunctionCallInfo fcinfo, MemoryContext per_query_ctx; MemoryContext oldcontext; PGSM_HASH_SEQ_STATUS hstat; - pgssEntry *entry; - pgssSharedState *pgss; + pgsmEntry *entry; + pgsmSharedState *pgsm; char *query_txt = NULL; char *parent_query_txt = NULL; int expected_columns = (api_version >= PGSM_V2_0)?PG_STAT_MONITOR_COLS_V2_0:PG_STAT_MONITOR_COLS_V1_0; @@ -1943,26 +1943,26 @@ pg_stat_monitor_internal(FunctionCallInfo fcinfo, if (api_version < PGSM_V2_0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("pg_stat_monitor: API version not supported"), - errhint("upgrade pg_stat_monitor extension"))); + errmsg("[pg_stat_monitor] pg_stat_monitor_internal: API version not supported."), + errhint("Upgrade pg_stat_monitor extension"))); /* Safety check... */ if (!IsSystemInitialized()) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), - errmsg("pg_stat_monitor: must be loaded via shared_preload_libraries"))); + errmsg("[pg_stat_monitor] pg_stat_monitor_internal: Must be loaded via shared_preload_libraries."))); /* check to see if caller supports us returning a tuplestore */ if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("pg_stat_monitor: set-valued function called in context that cannot accept a set"))); + errmsg("[pg_stat_monitor] pg_stat_monitor_internal: Set-valued function called in context that cannot accept a set."))); if (!(rsinfo->allowedModes & SFRM_Materialize)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("pg_stat_monitor: materialize mode required, but it is not " \ - "allowed in this context"))); + errmsg("[pg_stat_monitor] pg_stat_monitor_internal: Materialize mode required, but it is not " \ + "allowed in this context."))); - pgss = pgsm_get_ss(); + pgsm = pgsm_get_ss(); /* Switch into long-lived context to construct returned data structures */ per_query_ctx = rsinfo->econtext->ecxt_per_query_memory; @@ -1970,10 +1970,10 @@ pg_stat_monitor_internal(FunctionCallInfo fcinfo, /* Build a tuple descriptor for our result type */ if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) - elog(ERROR, "pg_stat_monitor: return type must be a row type"); + elog(ERROR, "[pg_stat_monitor] pg_stat_monitor_internal: Return type must be a row type."); if (tupdesc->natts != expected_columns) - elog(ERROR, "pg_stat_monitor: incorrect number of output arguments, required %d", tupdesc->natts); + elog(ERROR, "[pg_stat_monitor] pg_stat_monitor_internal: Incorrect number of output arguments, received %d, required %d.", tupdesc->natts, expected_columns); tupstore = tuplestore_begin_heap(true, false, work_mem); rsinfo->returnMode = SFRM_Materialize; @@ -1982,9 +1982,9 @@ pg_stat_monitor_internal(FunctionCallInfo fcinfo, MemoryContextSwitchTo(oldcontext); - LWLockAcquire(pgss->lock, LW_SHARED); + LWLockAcquire(pgsm->lock, LW_SHARED); - pgsm_hash_seq_init(&hstat, get_pgssHash(), false); + pgsm_hash_seq_init(&hstat, get_pgsmHash(), false); while ((entry = pgsm_hash_seq_next(&hstat)) != NULL) { @@ -2020,7 +2020,7 @@ pg_stat_monitor_internal(FunctionCallInfo fcinfo, /* copy counters to a local variable to keep locking time short */ { - volatile pgssEntry *e = (volatile pgssEntry *) entry; + volatile pgsmEntry *e = (volatile pgsmEntry *) entry; SpinLockAcquire(&e->mutex); tmp = e->counters; @@ -2184,7 +2184,7 @@ pg_stat_monitor_internal(FunctionCallInfo fcinfo, values[i++] = CStringGetTextDatum(tmp.error.message); /* bucket_start_time at column number 15 */ - values[i++] = TimestampTzGetDatum(pgss->bucket_start_time[entry->key.bucket_id]); + values[i++] = TimestampTzGetDatum(pgsm->bucket_start_time[entry->key.bucket_id]); if (tmp.calls.calls == 0) { @@ -2307,14 +2307,14 @@ pg_stat_monitor_internal(FunctionCallInfo fcinfo, values[i++] = Float8GetDatumFast(tmp.jitinfo.jit_emission_time); } values[i++] = BoolGetDatum(toplevel); - values[i++] = BoolGetDatum(pg_atomic_read_u64(&pgss->current_wbucket) != bucketid); + values[i++] = BoolGetDatum(pg_atomic_read_u64(&pgsm->current_wbucket) != bucketid); /* clean up and return the tuplestore */ tuplestore_putvalues(tupstore, tupdesc, values, nulls); } /* clean up and return the tuplestore */ pgsm_hash_seq_term(&hstat); - LWLockRelease(pgss->lock); + LWLockRelease(pgsm->lock); if(query_txt) pfree(query_txt); @@ -2325,7 +2325,7 @@ pg_stat_monitor_internal(FunctionCallInfo fcinfo, } static uint64 -get_next_wbucket(pgssSharedState *pgss) +get_next_wbucket(pgsmSharedState *pgsm) { struct timeval tv; uint64 current_bucket_sec; @@ -2335,7 +2335,7 @@ get_next_wbucket(pgssSharedState *pgss) bool update_bucket = false; gettimeofday(&tv, NULL); - current_bucket_sec = pg_atomic_read_u64(&pgss->prev_bucket_sec); + current_bucket_sec = pg_atomic_read_u64(&pgsm->prev_bucket_sec); /* * If current bucket expired we loop attempting to update prev_bucket_sec. @@ -2354,13 +2354,13 @@ get_next_wbucket(pgssSharedState *pgss) */ while ((tv.tv_sec - (uint)current_bucket_sec) >= ((uint)PGSM_BUCKET_TIME)) { - if (pg_atomic_compare_exchange_u64(&pgss->prev_bucket_sec, ¤t_bucket_sec, (uint64)tv.tv_sec)) + if (pg_atomic_compare_exchange_u64(&pgsm->prev_bucket_sec, ¤t_bucket_sec, (uint64)tv.tv_sec)) { update_bucket = true; break; } - current_bucket_sec = pg_atomic_read_u64(&pgss->prev_bucket_sec); + current_bucket_sec = pg_atomic_read_u64(&pgsm->prev_bucket_sec); } if (update_bucket) @@ -2369,25 +2369,25 @@ get_next_wbucket(pgssSharedState *pgss) new_bucket_id = (tv.tv_sec / PGSM_BUCKET_TIME) % PGSM_MAX_BUCKETS; /* Update bucket id and retrieve the previous one. */ - prev_bucket_id = pg_atomic_exchange_u64(&pgss->current_wbucket, new_bucket_id); + prev_bucket_id = pg_atomic_exchange_u64(&pgsm->current_wbucket, new_bucket_id); - LWLockAcquire(pgss->lock, LW_EXCLUSIVE); + LWLockAcquire(pgsm->lock, LW_EXCLUSIVE); hash_entry_dealloc(new_bucket_id, prev_bucket_id, NULL); - LWLockRelease(pgss->lock); + LWLockRelease(pgsm->lock); /* Allign the value in prev_bucket_sec to the bucket start time */ tv.tv_sec = (tv.tv_sec) - (tv.tv_sec % PGSM_BUCKET_TIME); - pg_atomic_exchange_u64(&pgss->prev_bucket_sec, (uint64)tv.tv_sec); + pg_atomic_exchange_u64(&pgsm->prev_bucket_sec, (uint64)tv.tv_sec); - pgss->bucket_start_time[new_bucket_id] = (TimestampTz) tv.tv_sec - + pgsm->bucket_start_time[new_bucket_id] = (TimestampTz) tv.tv_sec - ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY); - pgss->bucket_start_time[new_bucket_id] = pgss->bucket_start_time[new_bucket_id] * USECS_PER_SEC; + pgsm->bucket_start_time[new_bucket_id] = pgsm->bucket_start_time[new_bucket_id] * USECS_PER_SEC; return new_bucket_id; } - return pg_atomic_read_u64(&pgss->current_wbucket); + return pg_atomic_read_u64(&pgsm->current_wbucket); } #if PG_VERSION_NUM < 140000 @@ -2414,7 +2414,7 @@ AppendJumble(JumbleState *jstate, const unsigned char *item, Size size) { uint64 start_hash; - start_hash = pgss_hash_string((char *)jumble, JUMBLE_SIZE); + start_hash = pgsm_hash_string((char *)jumble, JUMBLE_SIZE); memcpy(jumble, &start_hash, sizeof(start_hash)); jumble_len = sizeof(start_hash); } @@ -2522,7 +2522,7 @@ JumbleRangeTable(JumbleState *jstate, List *rtable, CmdType cmd_type) APP_JUMB_STRING(rte->enrname); break; default: - elog(ERROR, "unrecognized RTE kind: %d", (int) rte->rtekind); + elog(ERROR, "[pg_stat_monitor] JumbleRangeTable: unrecognized RTE kind: %d.", (int) rte->rtekind); break; } } @@ -3023,7 +3023,7 @@ JumbleExpr(JumbleState *jstate, Node *node) break; default: /* Only a warning, since we can stumble along anyway */ - elog(INFO, "unrecognized node type: %d", + elog(INFO, "[pg_stat_monitor] JumbleExpr: unrecognized node type: %d.", (int) nodeTag(node)); break; } @@ -3595,7 +3595,7 @@ get_query_id(JumbleState *jstate, Query *query) /* Compute query ID and mark the Query node with it */ JumbleQuery(jstate, query); - queryid = pgss_hash_string((const char *)jstate->jumble, jstate->jumble_len); + queryid = pgsm_hash_string((const char *)jstate->jumble, jstate->jumble_len); return queryid; } #endif diff --git a/pg_stat_monitor.h b/pg_stat_monitor.h index 3c84ae8..921132f 100644 --- a/pg_stat_monitor.h +++ b/pg_stat_monitor.h @@ -91,8 +91,8 @@ #define MAX_QUERY_BUF (PGSM_QUERY_SHARED_BUFFER * 1024 * 1024) #define MAX_BUCKETS_MEM (PGSM_MAX * 1024 * 1024) -#define BUCKETS_MEM_OVERFLOW() ((hash_get_num_entries(pgss_hash) * sizeof(pgssEntry)) >= MAX_BUCKETS_MEM) -#define MAX_BUCKET_ENTRIES (MAX_BUCKETS_MEM / sizeof(pgssEntry)) +#define BUCKETS_MEM_OVERFLOW() ((hash_get_num_entries(pgsm_hash) * sizeof(pgsmEntry)) >= MAX_BUCKETS_MEM) +#define MAX_BUCKET_ENTRIES (MAX_BUCKETS_MEM / sizeof(pgsmEntry)) #define QUERY_BUFFER_OVERFLOW(x,y) ((x + y + sizeof(uint64) + sizeof(uint64)) > MAX_QUERY_BUF) #define QUERY_MARGIN 100 #define MIN_QUERY_LEN 10 @@ -212,7 +212,7 @@ typedef enum pgsmStoreKind PGSM_STORE, PGSM_ERROR, - PGSS_NUMKIND /* Must be last value of this enum */ + PGSM_NUMKIND /* Must be last value of this enum */ } pgsmStoreKind; /* the assumption of query max nested level */ @@ -248,7 +248,7 @@ typedef struct PlanInfo size_t plan_len; /* strlen(plan_text) */ } PlanInfo; -typedef struct pgssHashKey +typedef struct pgsmHashKey { uint64 bucket_id; /* bucket number */ uint64 queryid; /* query identifier */ @@ -258,7 +258,7 @@ typedef struct pgssHashKey Oid dbid; /* database OID */ uint32 ip; /* client ip address */ bool toplevel; /* query executed at top level */ -} pgssHashKey; +} pgsmHashKey; typedef struct QueryInfo { @@ -380,9 +380,9 @@ typedef struct Counters /* * Statistics per statement */ -typedef struct pgssEntry +typedef struct pgsmEntry { - pgssHashKey key; /* hash key of entry - MUST BE FIRST */ + pgsmHashKey key; /* hash key of entry - MUST BE FIRST */ uint64 pgsm_query_id; /* pgsm generate normalized query hash */ Counters counters; /* the statistics for this query */ int encoding; /* query text encoding */ @@ -392,12 +392,12 @@ typedef struct pgssEntry dsa_pointer query_pos; /* query location within query buffer */ char* query_pointer; }query_text; -} pgssEntry; +} pgsmEntry; /* * Global shared state */ -typedef struct pgssSharedState +typedef struct pgsmSharedState { LWLock *lock; /* protects hashtable search/modification */ double cur_median_usage; /* current median usage in hashtable */ @@ -415,11 +415,11 @@ typedef struct pgssSharedState * classic shared memory hash or dshash * (if we are using USE_DYNAMIC_HASH) */ -} pgssSharedState; +} pgsmSharedState; typedef struct pgsmLocalState { - pgssSharedState *shared_pgssState; + pgsmSharedState *shared_pgsmState; dsa_area *dsa; /* local dsa area for backend attached to the * dsa area created by postmaster at startup. */ @@ -478,23 +478,23 @@ GucVariable *get_conf(int i); /* hash_create.c */ dsa_area *get_dsa_area_for_query_text(void); -PGSM_HASH_TABLE *get_pgssHash(void); +PGSM_HASH_TABLE *get_pgsmHash(void); void pgsm_attach_shmem(void); bool IsHashInitialize(void); -void pgss_shmem_startup(void); -void pgss_shmem_shutdown(int code, Datum arg); +void pgsm_shmem_startup(void); +void pgsm_shmem_shutdown(int code, Datum arg); int pgsm_get_bucket_size(void); -pgssSharedState *pgsm_get_ss(void); +pgsmSharedState *pgsm_get_ss(void); void hash_query_entries(); void hash_query_entry_dealloc(int new_bucket_id, int old_bucket_id, unsigned char *query_buffer[]); void hash_entry_dealloc(int new_bucket_id, int old_bucket_id, unsigned char *query_buffer); -pgssEntry *hash_entry_alloc(pgssSharedState *pgss, pgssHashKey *key, int encoding); +pgsmEntry *hash_entry_alloc(pgsmSharedState *pgsm, pgsmHashKey *key, int encoding); Size pgsm_ShmemSize(void); -void pgss_startup(void); +void pgsm_startup(void); /* hash_query.c */ -void pgss_startup(void); +void pgsm_startup(void); /*---- GUC variables ----*/ typedef enum @@ -533,8 +533,8 @@ static const struct config_enum_entry track_options[] = #define HOOK_STATS_SIZE 0 #endif -void *pgsm_hash_find_or_insert(PGSM_HASH_TABLE *shared_hash, pgssHashKey *key, bool* found); -void *pgsm_hash_find(PGSM_HASH_TABLE *shared_hash, pgssHashKey *key, bool* found); +void *pgsm_hash_find_or_insert(PGSM_HASH_TABLE *shared_hash, pgsmHashKey *key, bool* found); +void *pgsm_hash_find(PGSM_HASH_TABLE *shared_hash, pgsmHashKey *key, bool* found); void pgsm_hash_seq_init(PGSM_HASH_SEQ_STATUS *hstat, PGSM_HASH_TABLE *shared_hash, bool lock); void *pgsm_hash_seq_next(PGSM_HASH_SEQ_STATUS *hstat); void pgsm_hash_seq_term(PGSM_HASH_SEQ_STATUS *hstat);