/*

* PROGRAM: SQL Trace plugin

* MODULE: TracePluginImpl.cpp

* DESCRIPTION: Plugin implementation

*

* The contents of this file are subject to the Initial

* Developer's Public License Version 1.0 (the "License");

* you may not use this file except in compliance with the

* License. You may obtain a copy of the License at

* http://www.ibphoenix.com/main.nfs?a=ibphoenix&page=ibp_idpl.

*

* Software distributed under the License is distributed AS IS,

* WITHOUT WARRANTY OF ANY KIND, either express or implied.

* See the License for the specific language governing rights

* and limitations under the License.

*

* The Original Code was created by Nickolay Samofatov

* for the Firebird Open Source RDBMS project.

*

* Copyright (c) 2004 Nickolay Samofatov <[email protected]>

* and all contributors signed below.

*

* All Rights Reserved.

* Contributor(s): ______________________________________.

*

* 2008 Khorsun Vladyslav

*/

#include <time.h>

#include <math.h>

#include "TracePluginImpl.h"

#include "PluginLogWriter.h"

#include "os/platform.h"

#include "consts_pub.h"

#include "codetext.h"

#include "../../common/isc_f_proto.h"

#include "../../common/dsc.h"

#include "../../common/utils_proto.h"

#include "../../common/UtilSvc.h"

#include "../../jrd/svc_undoc.h"

#include "../../jrd/constants.h"

#include "../../common/os/path_utils.h"

#include "../../jrd/inf_pub.h"

#include "../../dsql/sqlda_pub.h"

#include "../../common/classes/ImplementHelper.h"

#include "../../common/SimpleStatusVector.h"

#include "../../jrd/status.h"

using namespace Firebird;

using namespace Jrd;

static const char* const DEFAULT_LOG_NAME = "default_trace.log";

#ifdef WIN_NT

#define NEWLINE "\r\n"

#else

#define NEWLINE "\n"

#endif

/// TracePluginImpl

const char* TracePluginImpl::marshal_exception(const Firebird::Exception& ex)

{

Firebird::StaticStatusVector st;

ex.stuffException(st);

const ISC_STATUS* status = st.begin();

char buff[1024];

char* p = buff;

char* const end = buff + sizeof(buff) - 1;

const ISC_STATUS* s = status;

while (end > p && fb_interpret(p, end - p, &s))

{

p += strlen(p);

if (p < end)

*p++ = '\n';

}

*p = 0;

set_error_string(buff);

return get_error_string();

}

TracePluginImpl::TracePluginImpl(IPluginBase* plugin,

const TracePluginConfig& configuration,

ITraceInitInfo* initInfo) :

factory(plugin),

operational(false),

session_id(initInfo->getTraceSessionID()),

session_name(*getDefaultMemoryPool()),

logWriter(initInfo->getLogWriter()),

config(configuration),

record(*getDefaultMemoryPool()),

connections(getDefaultMemoryPool()),

transactions(getDefaultMemoryPool()),

statements(getDefaultMemoryPool()),

services(getDefaultMemoryPool()),

unicodeCollation(*getDefaultMemoryPool()),

include_codes(*getDefaultMemoryPool()),

exclude_codes(*getDefaultMemoryPool())

{

const char* ses_name = initInfo->getTraceSessionName();

session_name = ses_name && *ses_name ? ses_name : " ";

if (!logWriter)

{

PathName logname(configuration.log_filename);

if (logname.empty()) {

logname = DEFAULT_LOG_NAME;

}

if (PathUtils::isRelative(logname))

{

PathName root(initInfo->getFirebirdRootDirectory());

PathUtils::ensureSeparator(root);

logname.insert(0, root);

}

logWriter = FB_NEW PluginLogWriter(logname.c_str(), config.max_log_size * 1024 * 1024);

logWriter->addRef();

}

Jrd::TextType* textType = unicodeCollation.getTextType();

// Compile filtering regular expressions

const char* str = NULL;

try

{

if (config.include_filter.hasData())

{

str = config.include_filter.c_str();

string filter(config.include_filter);

ISC_systemToUtf8(filter);

include_matcher = FB_NEW TraceSimilarToMatcher(

*getDefaultMemoryPool(), textType, (const UCHAR*) filter.c_str(),

filter.length(), '\\', true);

}

if (config.exclude_filter.hasData())

{

str = config.exclude_filter.c_str();

string filter(config.exclude_filter);

ISC_systemToUtf8(filter);

exclude_matcher = FB_NEW TraceSimilarToMatcher(

*getDefaultMemoryPool(), textType, (const UCHAR*) filter.c_str(),

filter.length(), '\\', true);

}

}

catch (const Exception&)

{

if (config.db_filename.empty())

{

fatal_exception::raiseFmt(

"error while compiling regular expression \"%s\"", str);

}

else

{

fatal_exception::raiseFmt(

"error while compiling regular expression \"%s\" for database \"%s\"",

str, config.db_filename.c_str());

}

}

// parse filters for gds error codes

if (!config.include_gds_codes.isEmpty())

str2Array(config.include_gds_codes, include_codes);

if (!config.exclude_gds_codes.isEmpty())

str2Array(config.exclude_gds_codes, exclude_codes);

operational = true;

log_init();

}

TracePluginImpl::~TracePluginImpl()

{

// All objects must have been free already, but in case something remained

// deallocate tracking objects now.

if (operational)

{

if (connections.getFirst())

{

do {

connections.current().deallocate_references();

} while (connections.getNext());

}

if (transactions.getFirst())

{

do {

transactions.current().deallocate_references();

} while (transactions.getNext());

}

if (statements.getFirst())

{

do {

delete statements.current().description;

} while (statements.getNext());

}

if (services.getFirst())

{

do {

services.current().deallocate_references();

} while (services.getNext());

}

log_finalize();

}

}

void TracePluginImpl::logRecord(const char* action)

{

// We use atomic file appends for logging. Do not try to break logging

// to multiple separate file operations

const Firebird::TimeStamp stamp(Firebird::TimeStamp::getCurrentTimeStamp());

struct tm times;

stamp.decode(&times);

char buffer[100];

SNPRINTF(buffer, sizeof(buffer), "%04d-%02d-%02dT%02d:%02d:%02d.%04d (%d:%p) %s" NEWLINE,

times.tm_year + 1900, times.tm_mon + 1, times.tm_mday, times.tm_hour,

times.tm_min, times.tm_sec, (int) (stamp.value().timestamp_time % ISC_TIME_SECONDS_PRECISION),

get_process_id(), this, action);

record.insert(0, buffer);

record.append(NEWLINE);

// TODO: implement adjusting of line breaks

// line.adjustLineBreaks();

LocalStatus ls;

CheckStatusWrapper status(&ls);

logWriter->write_s(&status, record.c_str(), record.length());

if (ls.getState() & IStatus::STATE_ERRORS && ls.getErrors()[1] == isc_interface_version_too_old)

logWriter->write(record.c_str(), record.length());

else

check(&status);

record = "";

}

void TracePluginImpl::logRecordConn(const char* action, ITraceDatabaseConnection* connection)

{

// Lookup connection description

const AttNumber conn_id = connection->getConnectionID();

bool reg = false;

while (true)

{

{

ReadLockGuard lock(connectionsLock, FB_FUNCTION);

ConnectionsTree::Accessor accessor(&connections);

if (accessor.locate(conn_id))

{

record.insert(0, *accessor.current().description);

break;

}

}

if (reg)

{

string temp;

temp.printf("\t%s (ATT_%" SQUADFORMAT", <unknown, bug?>)" NEWLINE,

config.db_filename.c_str(), conn_id);

record.insert(0, temp);

break;

}

register_connection(connection);

reg = true;

}

// don't keep failed connection

if (!conn_id)

{

WriteLockGuard lock(connectionsLock, FB_FUNCTION);

ConnectionsTree::Accessor accessor(&connections);

if (accessor.locate(conn_id))

{

accessor.current().deallocate_references();

accessor.fastRemove();

}

}

logRecord(action);

}

void TracePluginImpl::logRecordTrans(const char* action, ITraceDatabaseConnection* connection,

ITraceTransaction* transaction)

{

TraNumber tra_id = transaction->getPreviousID();

if (!tra_id)

tra_id = transaction->getTransactionID();

bool reg = false;

while (true)

{

// Lookup transaction description

{

ReadLockGuard lock(transactionsLock, FB_FUNCTION);

TransactionsTree::Accessor accessor(&transactions);

if (accessor.locate(tra_id))

{

record.insert(0, *accessor.current().description);

break;

}

}

if (reg)

{

string temp;

temp.printf("\t\t(TRA_%" SQUADFORMAT", <unknown, bug?>)" NEWLINE, tra_id);

record.insert(0, temp);

break;

}

register_transaction(transaction);

reg = true;

}

logRecordConn(action, connection);

}

void TracePluginImpl::logRecordProcFunc(const char* action, ITraceDatabaseConnection* connection,

ITraceTransaction* transaction, const char* obj_type, const char* obj_name)

{

string temp;

temp.printf(NEWLINE "%s %s:" NEWLINE, obj_type, obj_name);

record.insert(0, temp);

if (!transaction) {

logRecordConn(action, connection);

}

else {

logRecordTrans(action, connection, transaction);

}

}

void TracePluginImpl::logRecordStmt(const char* action, ITraceDatabaseConnection* connection,

ITraceTransaction* transaction, ITraceStatement* statement, bool isSQL)

{

const StmtNumber stmt_id = statement->getStmtID();

bool reg = false;

bool log = true;

while (true)

{

// Lookup description for statement

{

ReadLockGuard lock(statementsLock, FB_FUNCTION);

StatementsTree::Accessor accessor(&statements);

if (accessor.locate(stmt_id))

{

const string* description = accessor.current().description;

log = (description != NULL);

// Do not say anything about statements which do not fall under filter criteria

if (log) {

record.insert(0, *description);

}

break;

}

}

if (reg)

{

string temp;

temp.printf(NEWLINE "Statement %" SQUADFORMAT", <unknown, bug?>:" NEWLINE, stmt_id);

record.insert(0, temp);

break;

}

if (isSQL) {

register_sql_statement((ITraceSQLStatement*) statement);

}

else {

register_blr_statement((ITraceBLRStatement*) statement);

}

reg = true;

}

// don't need to keep failed statement

if (!stmt_id)

{

WriteLockGuard lock(statementsLock, FB_FUNCTION);

StatementsTree::Accessor accessor(&statements);

if (accessor.locate(stmt_id))

{

delete accessor.current().description;

accessor.fastRemove();

}

}

if (!log)

{

record = "";

return;

}

if (!transaction) {

logRecordConn(action, connection);

}

else {

logRecordTrans(action, connection, transaction);

}

}

void TracePluginImpl::logRecordServ(const char* action, ITraceServiceConnection* service)

{

ServiceId svc_id = service->getServiceID();

bool reg = false;

while (true)

{

// Lookup service description

{

ReadLockGuard lock(servicesLock, FB_FUNCTION);

ServicesTree::Accessor accessor(&services);

if (accessor.locate(svc_id))

{

record.insert(0, *accessor.current().description);

break;

}

}

if (reg)

{

string temp;

temp.printf("\tService %p, <unknown, bug?>" NEWLINE, svc_id);

record.insert(0, temp);

break;

}

register_service(service);

reg = true;

}

logRecord(action);

}

void TracePluginImpl::logRecordError(const char* action, ITraceConnection* connection,

ITraceStatusVector* status)

{

const char* err = status->getText();

record.insert(0, err);

if (connection)

{

switch (connection->getKind())

{

case ITraceConnection::KIND_DATABASE:

logRecordConn(action, (ITraceDatabaseConnection*) connection);

break;

case ITraceConnection::KIND_SERVICE:

logRecordServ(action, (ITraceServiceConnection*) connection);

break;

default:

break;

}

}

else

logRecord(action);

}

void TracePluginImpl::appendGlobalCounts(const PerformanceInfo* info)

{

string temp;

temp.printf("%7" QUADFORMAT"d ms", info->pin_time);

record.append(temp);

ntrace_counter_t cnt;

if ((cnt = info->pin_counters[PerformanceInfo::READS]) != 0)

{

temp.printf(", %" QUADFORMAT"d read(s)", cnt);

record.append(temp);

}

if ((cnt = info->pin_counters[PerformanceInfo::WRITES]) != 0)

{

temp.printf(", %" QUADFORMAT"d write(s)", cnt);

record.append(temp);

}

if ((cnt = info->pin_counters[PerformanceInfo::FETCHES]) != 0)

{

temp.printf(", %" QUADFORMAT"d fetch(es)", cnt);

record.append(temp);

}

if ((cnt = info->pin_counters[PerformanceInfo::MARKS]) != 0)

{

temp.printf(", %" QUADFORMAT"d mark(s)", cnt);

record.append(temp);

}

record.append(NEWLINE);

}

void TracePluginImpl::appendTableCounts(const PerformanceInfo *info)

{

if (!config.print_perf || info->pin_count == 0)

return;

record.append(NEWLINE

"Table Natural Index Update Insert Delete Backout Purge Expunge" NEWLINE

"***************************************************************************************************************" NEWLINE );

const TraceCounts* trc;

const TraceCounts* trc_end;

string temp;

for (trc = info->pin_tables, trc_end = trc + info->pin_count; trc < trc_end; trc++)

{

record.append(trc->trc_relation_name);

record.append(MAX_SQL_IDENTIFIER_LEN - fb_strlen(trc->trc_relation_name), ' ');

for (int j = 0; j <= TraceCounts::EXPUNGES; j++)

{

if (trc->trc_counters[j] == 0)

{

record.append(10, ' ');

}

else

{

//fb_utils::exactNumericToStr(trc->trc_counters[j], 0, temp);

//record.append(' ', 10 - temp.length());

temp.printf("%10" QUADFORMAT"d", trc->trc_counters[j]);

record.append(temp);

}

}

record.append(NEWLINE);

}

}

void TracePluginImpl::formatStringArgument(string& result, const UCHAR* str, size_t len)

{

if (config.max_arg_length && len > config.max_arg_length)

{

/* CVC: We will wrap with the original code.

len = config.max_arg_length - 3;

if (len < 0)

len = 0;

*/

if (config.max_arg_length < 3)

len = 0;

else

len = config.max_arg_length - 3;

result.printf("%.*s...", len, str);

return;

}

result.printf("%.*s", len, str);

}

bool TracePluginImpl::filterStatus(const ISC_STATUS* status, GdsCodesArray& arr)

{

FB_SIZE_T pos;

while (*status != isc_arg_end)

{

const ISC_STATUS s = *status;

switch (s)

{

case isc_arg_gds:

case isc_arg_warning:

if (arr.find(status[1], pos))

return true;

status += 2;

break;

case isc_arg_cstring:

status += 3;

break;

default:

status += 2;

break;

}

}

return false;

}

namespace {

class GdsName2CodeMap

{

public:

GdsName2CodeMap(MemoryPool& pool) :

m_map(pool)

{

for (int i = 0; codes[i].code_string; i++)

m_map.put(codes[i].code_string, codes[i].code_number);

}

bool find(const char* name, ISC_STATUS& code) const

{

return m_map.get(name, code);

}

private:

class NocaseCmp

{

public:

static bool greaterThan(const char* i1, const char* i2)

{

return fb_utils::stricmp(i1, i2) > 0;

}

};

GenericMap<Pair<NonPooled<const char*, ISC_STATUS> >, NocaseCmp > m_map;

};

}; // namespace

static InitInstance<GdsName2CodeMap> gdsNamesMap;

void TracePluginImpl::str2Array(const Firebird::string& str, GdsCodesArray& arr)

{

// input: string with comma-delimited list of gds codes values and\or gds codes names

// output: sorted array of gds codes values

const char *sep = " ,";

FB_SIZE_T p1 = 0, p2 = 0;

while (p2 < str.length())

{

p2 = str.find_first_of(sep, p1);

if (p2 == string::npos)

p2 = str.length();

string s = str.substr(p1, p2 - p1);

ISC_STATUS code = atol(s.c_str());

if (!code && !gdsNamesMap().find(s.c_str(), code))

fatal_exception::raiseFmt(

"Error parsing error codes filter: \n"

"\t%s\n"

"\tbad item is: %s, at position: %d",

str.c_str(), s.c_str(), p1 + 1);

// avoid duplicates

FB_SIZE_T ins_pos;

if (!arr.find(code, ins_pos))

arr.insert(ins_pos, code);

p1 = str.find_first_not_of(sep, p2);

}

}

void TracePluginImpl::appendParams(ITraceParams* params)

{

const FB_SIZE_T paramcount = params->getCount();

if (!paramcount)

return;

// NS: Please, do not move strings inside the loop. This is performance-sensitive piece of code.

string paramtype;

string paramvalue;

string temp;

for (FB_SIZE_T i = 0; i < paramcount; i++)

{

const struct dsc* parameters = params->getParam(i);

// See if we need to print any more arguments

if (config.max_arg_count && i >= config.max_arg_count)

{

temp.printf("...%d more arguments skipped..." NEWLINE, paramcount - i);

record.append(temp);

break;

}

// Assign type name

switch (parameters->dsc_dtype)

{

case dtype_text:

paramtype.printf("char(%d)", parameters->dsc_length);

break;

case dtype_cstring:

paramtype.printf("cstring(%d)", parameters->dsc_length - 1);

break;

case dtype_varying:

paramtype.printf("varchar(%d)", parameters->dsc_length - 2);

break;

case dtype_blob:

paramtype = "blob";

break;

case dtype_array:

paramtype = "array";

break;

case dtype_quad:

paramtype = "quad";

break;

case dtype_short:

if (parameters->dsc_scale)

paramtype.printf("smallint(*, %d)", parameters->dsc_scale);

else

paramtype = "smallint";

break;

case dtype_long:

if (parameters->dsc_scale)

paramtype.printf("integer(*, %d)", parameters->dsc_scale);

else

paramtype = "integer";

break;

case dtype_double:

if (parameters->dsc_scale)

paramtype.printf("double precision(*, %d)", parameters->dsc_scale);

else

paramtype = "double precision";

break;

case dtype_int64:

if (parameters->dsc_scale)

paramtype.printf("bigint(*, %d)", parameters->dsc_scale);

else

paramtype = "bigint";

break;

case dtype_real:

paramtype = "float";

break;

case dtype_sql_date:

paramtype = "date";

break;

case dtype_sql_time:

paramtype = "time";

break;

case dtype_timestamp:

paramtype = "timestamp";

break;

case dtype_dbkey:

paramtype = "db_key";

break;

case dtype_boolean:

paramtype = "boolean";

break;

default:

paramtype.printf("<type%d>", parameters->dsc_dtype);

break;

}

if (parameters->dsc_flags & DSC_null)

{

paramvalue = "<NULL>";

}

else

{

// Assign value

switch (parameters->dsc_dtype)

{

// Handle potentially long string values

case dtype_text:

{

FbLocalStatus status;

const char* text = params->getTextUTF8(&status, i);

if (status->getState() & IStatus::STATE_ERRORS)

{

formatStringArgument(paramvalue,

parameters->dsc_address, parameters->dsc_length);

}

else

formatStringArgument(paramvalue, (UCHAR*)text, strlen(text));

break;

}

case dtype_cstring:

formatStringArgument(paramvalue,

parameters->dsc_address,

strlen(reinterpret_cast<const char*>(parameters->dsc_address)));

break;

case dtype_varying:

{

FbLocalStatus status;

const char* text = params->getTextUTF8(&status, i);

if (status->getState() & IStatus::STATE_ERRORS)

{

formatStringArgument(paramvalue,

parameters->dsc_address + 2,

*(USHORT*)parameters->dsc_address);

}

else

formatStringArgument(paramvalue, (UCHAR*)text, strlen(text));

break;

}

// Handle quad

case dtype_quad:

case dtype_blob:

case dtype_array:

case dtype_dbkey:

{

ISC_QUAD *quad = (ISC_QUAD*) parameters->dsc_address;

paramvalue.printf("%08X%08X", quad->gds_quad_high, quad->gds_quad_low);

break;

}

case dtype_short:

fb_utils::exactNumericToStr(*(SSHORT*) parameters->dsc_address, parameters->dsc_scale, paramvalue);

break;

case dtype_long:

fb_utils::exactNumericToStr(*(SLONG*) parameters->dsc_address, parameters->dsc_scale, paramvalue);

break;

case dtype_int64:

fb_utils::exactNumericToStr(*(SINT64*) parameters->dsc_address, parameters->dsc_scale, paramvalue);

break;

case dtype_real:

if (!parameters->dsc_scale) {

paramvalue.printf("%.7g", *(float*) parameters->dsc_address);

}

else {

paramvalue.printf("%.7g",

*(float*) parameters->dsc_address * pow(10.0f, -parameters->dsc_scale));

}

break;

case dtype_double:

if (!parameters->dsc_scale) {

paramvalue.printf("%.15g", *(double*) parameters->dsc_address);

}

else {

paramvalue.printf("%.15g",

*(double*) parameters->dsc_address * pow(10.0, -parameters->dsc_scale));

}

break;

case dtype_sql_date:

{

struct tm times;

Firebird::TimeStamp::decode_date(*(ISC_DATE*)parameters->dsc_address, &times);

paramvalue.printf("%04d-%02d-%02d", times.tm_year + 1900, times.tm_mon + 1, times.tm_mday);

break;

}

case dtype_sql_time:

{

int hours, minutes, seconds, fractions;

Firebird::TimeStamp::decode_time(*(ISC_TIME*) parameters->dsc_address,

&hours, &minutes, &seconds, &fractions);

paramvalue.printf("%02d:%02d:%02d.%04d", hours, minutes, seconds, fractions);

break;

}

case dtype_timestamp:

{

Firebird::TimeStamp ts(*(ISC_TIMESTAMP*) parameters->dsc_address);

struct tm times;

ts.decode(&times);

paramvalue.printf("%04d-%02d-%02dT%02d:%02d:%02d.%04d",

times.tm_year + 1900, times.tm_mon + 1, times.tm_mday,

times.tm_hour, times.tm_min, times.tm_sec,

ts.value().timestamp_time % ISC_TIME_SECONDS_PRECISION);

break;

}

case dtype_boolean:

paramvalue = *parameters->dsc_address ? "<true>" : "<false>";

break;

default:

paramvalue = "<unknown>";

}

}

temp.printf("param%d = %s, \"%s\"" NEWLINE, i, paramtype.c_str(), paramvalue.c_str());

record.append(temp);

}

}

void TracePluginImpl::appendServiceQueryParams(size_t send_item_length,

const ntrace_byte_t* send_items, size_t recv_item_length,

const ntrace_byte_t* recv_items)

{

string send_query;

string recv_query;

USHORT l;

UCHAR item;

//USHORT timeout = 0; // Unused

const UCHAR* items = send_items;

const UCHAR* const end_items = items + send_item_length;

while (items < end_items && *items != isc_info_end)

{

switch ((item = *items++))

{

case isc_info_end:

break;

default:

if (items + 2 <= end_items)

{

l = (USHORT) gds__vax_integer(items, 2);

items += 2;

if (items + l <= end_items)

{

switch (item)

{

case isc_info_svc_line:

send_query.printf(NEWLINE "\t\t send line: %.*s", l, items);

break;

case isc_info_svc_message:

send_query.printf(NEWLINE "\t\t send message: %.*s", l + 3, items - 3);

break;

case isc_info_svc_timeout:

send_query.printf(NEWLINE "\t\t set timeout: %d",

(USHORT) gds__vax_integer(items, l));

break;

case isc_info_svc_version:

send_query.printf(NEWLINE "\t\t set version: %d",

(USHORT) gds__vax_integer(items, l));

break;

}

}

items += l;

}

else

items += 2;

break;

}

}

if (send_query.hasData())

{

record.append("\t Send portion of the query:");

record.append(send_query);

}

items = recv_items;

const UCHAR* const end_items2 = items + recv_item_length;

if (*items == isc_info_length) {

items++;

}

while (items < end_items2 && *items != isc_info_end)

{

switch ((item = *items++))

{

case isc_info_end:

break;

case isc_info_svc_svr_db_info:

recv_query.printf(NEWLINE "\t\t retrieve number of attachments and databases");

break;

case isc_info_svc_svr_online:

recv_query.printf(NEWLINE "\t\t set service online");

break;

case isc_info_svc_svr_offline:

recv_query.printf(NEWLINE "\t\t set service offline");

break;

case isc_info_svc_get_env:

recv_query.printf(NEWLINE "\t\t retrieve the setting of $FIREBIRD");

break;

case isc_info_svc_get_env_lock:

recv_query.printf(NEWLINE "\t\t retrieve the setting of $FIREBIRD_LOCK");

break;

case isc_info_svc_get_env_msg:

recv_query.printf(NEWLINE "\t\t retrieve the setting of $FIREBIRD_MSG");

break;

case isc_info_svc_dump_pool_info:

recv_query.printf(NEWLINE "\t\t print memory counters");

break;