/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@ 
**********************************************************************/
/* -*-C++-*-
 *****************************************************************************
 *
 * File:         logmxevent.cpp
 * Description:  Eventlogging functions for SQL
 *
 * Created:      02/05/96
 * Language:     C++
 *
 *
 *
 *
 ****************************************************************************/

#include "NLSConversion.h"
#include "logmxevent.h"
#include "str.h"
#include <stdlib.h>
#include <pthread.h>
#include <rosetta/tal.h>
#include "rosetta/rosgen.h"
#include <limits.h>
#include <stdarg.h>
#include <execinfo.h>
#ifdef _MSC_VER
#undef _MSC_VER
#endif
#include "common/sql.error_event.pb.h"
#include "common/sql.info_event.pb.h"
//#include "wrapper/amqpwrapper.h"
#include "sq_sql_eventids.h"
#include "common/evl_sqlog_eventnum.h"

// #include "sqevlog/evl_sqlog_writer.h"
#include "seabed/fs.h"

// forward declaration
static void check_assert_bug_catcher();
Lng32  sqlToSLSeverity(const char *severity, NABoolean isWarning);

#if 0 /* No longer needed with sqlTextBuf moved to CmpContext */
THREAD_P NAWString* sqlTextBuf = 0;
#endif

NABoolean SQLMXLoggingArea::establishedAMQPConnection_ = FALSE;
pthread_mutex_t SQLMXLoggingArea::loggingMutex_;
bool SQLMXLoggingArea::loggingMutexInitialized_ = false;

void SQLMXLoggingArea::init()
{
  char buffer[80];
  int rc;
  establishedAMQPConnection_= FALSE;
  if (!loggingMutexInitialized_)
  {
    rc = pthread_mutex_init(&loggingMutex_, NULL);
    if (rc == 0)
      loggingMutexInitialized_ = true;
    else
    {
      sprintf(buffer, "SQLMXLoggingArea::init() pthread_mutex_init() rc=%d", rc);
      logSQLMXDebugEvent(buffer, (short)rc);
    }
  }
}

bool SQLMXLoggingArea::lockMutex()
{
  char buffer[80];
  int rc = 0;
  if (loggingMutexInitialized_)
  {
    rc = pthread_mutex_trylock(&loggingMutex_);
    if (rc)
    {
      sprintf(buffer, "SQLMXLoggingArea::lockMutex() pthread_mutex_trylock() rc=%d", rc);
      logSQLMXDebugEvent(buffer, (short)rc, false);
    }
  }
  return rc ? false : true;
}

void SQLMXLoggingArea::unlockMutex()
{
  char buffer[80];
  int rc = 0;
  if (loggingMutexInitialized_)
    rc = pthread_mutex_unlock(&loggingMutex_);
  if (rc)
  {
    sprintf(buffer, "SQLMXLoggingArea::unlockMutex() pthread_mutex_unlock() rc=%d", rc);
    logSQLMXDebugEvent(buffer, (short)rc, false);
  }
}


#if 0 /* No longer needed with sqlTextBuf moved to CmpContext */
// Set the SQL text for later use. If the buffer is not empty, this
// call does nothing.
//
void SQLMXLoggingArea::setSqlText(const NAWString& x)
{
   if ( sqlTextBuf == 0 )
      sqlTextBuf = new NAWString(x);
}
#endif

 SQLMXLoggingArea::~SQLMXLoggingArea() 
{
#ifndef SP_DIS
  closeAMQPConnection();
#endif
  establishedAMQPConnection_ = FALSE;
};

#if 0 /* No longer needed with sqlTextBuf moved to CmpContext */
//
// clear up the SQL text so that next setSqlText() call can have effect.
//
void SQLMXLoggingArea::resetSqlText()
{
   delete sqlTextBuf;
   sqlTextBuf = 0;
}
#endif


 Int32 SQLMXLoggingArea::logSQLMXEventForError( ULng32 sqlcode, 
                                        const char* experienceLevel,
                                        const char* severityLevel,
                                        const char* eventTarget,
					const char *msgTxt,
					const char* sqlId,
					const Lng32 Int0,
					const Lng32 Int1,
					const Lng32 Int2,
					const Lng32 Int3,
					const Lng32 Int4,
				        const char *String0,
					const char * String1,
					const char * String2,
					const char * String3,
					const char * String4,
					const char * serverName,
					const char * connectionName,
					const char * constraintCatalog,
					const char * constraintSchema,
					const char * constraintName,
					const char * triggerCatalog,
					const char * triggerSchema,
					const char *triggerName,
					const char *catalogName,
					const char *schemaName,
					const char *tableName,
					const char *columnName,
					const Int64 currTransid,
					const Lng32 rowNumber,
					const Lng32 platformCode,
					NABoolean isWarning	
					)
{
  Int32 rc = 0;
  // sealog logging of sql error events
  // declare a event stack variable and populate
#ifndef SP_DIS
  bool lockedMutex = lockMutex();

  sql::error_event sql_error_event;
  Int32 qpidNodePort = atoi(getenv("QPID_NODE_PORT"));

  common::event_header * eventHeader = sql_error_event.mutable_header();
  common::info_header * infoHeader = eventHeader->mutable_header();  


  if (!SQLMXLoggingArea::establishedAMQPConnection())
    {
      rc = createAMQPConnection(NULL,-1);
      if (rc)
      {
        if (lockedMutex)
          unlockMutex();
	return rc;
      }
      establishedAMQPConnection_ = TRUE;
    }
 

  char eventidStr[10]="        ";
  Lng32 eventidLen = 0;
  str_sprintf(eventidStr,"10%d%06d",SQEVL_SQL,sqlcode);
  str_strip_blanks(eventidStr,eventidLen);
  Lng32 eventIdVal = (Lng32)str_atoi(eventidStr,eventidLen);
 
  sql_error_event.mutable_header()->set_event_id(eventIdVal);
  sql_error_event.mutable_header()->set_event_severity(sqlToSLSeverity(severityLevel, isWarning));

 
  sql_error_event.set_sqlcode(sqlcode);
  if (sqlId)
    sql_error_event.set_sqlid(sqlId);
  else
    {
      SB_Phandle_Type myphandle;
      XPROCESSHANDLE_GETMINE_(&myphandle);
      char charProcHandle[200];
      char myprocname[30];
      Int32 mycpu,mypin,mynodenumber=0;
      short myproclength = 0;
      XPROCESSHANDLE_DECOMPOSE_(&myphandle, &mycpu, &mypin, &mynodenumber,NULL,100, NULL, myprocname,100, &myproclength); 
      myprocname[myproclength] = '\0';
      str_sprintf(charProcHandle,"%d,%d,%d,%s",mycpu,mypin,mynodenumber,myprocname);
      sql_error_event.set_sqlid(charProcHandle);
    }
  sql_error_event.set_message_text(msgTxt);
  sql_error_event.set_err_experience_level(experienceLevel);
  sql_error_event.set_err_target(eventTarget);
  sql_error_event.set_int0(Int0);
  sql_error_event.set_int1(Int1);
  sql_error_event.set_int2(Int2);
  sql_error_event.set_int3(Int3);
  sql_error_event.set_int4(Int4);

  if (String0)
    sql_error_event.set_string0(String0);
  if (String1)
    sql_error_event.set_string1(String1);
  if (String2)
    sql_error_event.set_string2(String2);
  if (String3)
    sql_error_event.set_string3(String3);
  if (String4)
    sql_error_event.set_string4(String4);
  if (serverName)
    sql_error_event.set_server_name(serverName);
  if (connectionName)
    sql_error_event.set_connection_name(connectionName);
  if (constraintCatalog)
    sql_error_event.set_constraint_catalog(constraintCatalog);
  if (constraintSchema)
    sql_error_event.set_constraint_schema(constraintSchema);
  if (constraintName)
    sql_error_event.set_constraint_name(constraintName);
  if (triggerCatalog)
    sql_error_event.set_trigger_catalog(triggerCatalog);
  if (triggerSchema)
    sql_error_event.set_trigger_schema(triggerSchema);
  if (triggerName)
    sql_error_event.set_trigger_name(triggerName);
  
  if (catalogName)
    sql_error_event.set_catalog_name(catalogName);
  if (schemaName)
    sql_error_event.set_schema_name(schemaName);
  if (tableName)
    sql_error_event.set_table_name(tableName);
  if (columnName)
    sql_error_event.set_column_name(columnName);
  
  sql_error_event.set_current_transid(currTransid);
  sql_error_event.set_row_number(rowNumber);  
  sql_error_event.set_platform_error_code(platformCode);

  rc =  initAMQPInfoHeader(infoHeader, SQEVL_SQL);
  if (rc)
    {
      closeAMQPConnection();
      establishedAMQPConnection_ = FALSE;
      if (lockedMutex)
        unlockMutex();
      return rc;
    }
 
  AMQPRoutingKey routingKey(SP_EVENT, SP_SQLPACKAGE,  SP_INSTANCE, 
                              SP_PUBLIC,  SP_GPBPROTOCOL,  "error_event"); 
  try { 
    rc = sendAMQPMessage(true, sql_error_event.SerializeAsString(), 
                         SP_CONTENT_TYPE_APP, routingKey);
    if (rc) throw 1;
  } catch (...) {
    closeAMQPConnection(); 
    establishedAMQPConnection_ = FALSE;
    if (!rc) rc = SP_SEND_FAILED;
    if (lockedMutex)
       unlockMutex();
    return rc;
  }

  if (lockedMutex)
    unlockMutex();
#else
  rc = 0;
#endif

  return rc;

}


Lng32  sqlToSLSeverity(const char *severity,NABoolean isWarning)
{
  if (isWarning)
    return SQ_LOG_WARNING; 
  if (str_cmp(severity,"CRTCL",str_len(severity)) == 0)
    return SQ_LOG_CRIT;
  else if (str_cmp(severity,"MAJOR",str_len(severity)) == 0)
    return SQ_LOG_ERR;
  else if (str_cmp(severity,"MINOR",str_len(severity)) == 0)
    return SQ_LOG_ERR;
  else if (str_cmp(severity,"INFRM",str_len(severity)) == 0 )
    return SQ_LOG_INFO;
  else
    return -1;
}
void SQLMXLoggingArea::logCompNQCretryEvent(char *stmt)
{
  const char m[]="Statement was compiled as if query plan caching were off: ";
  Int32 mLen = sizeof(m);
  Int32 sLen = str_len(stmt);
  char msg[8192];
  str_cpy_all(msg, m, mLen);
  str_cpy_all(msg+mLen, stmt, MINOF(sLen, 8192-mLen));
  logSQLMXEventForError(SQEV_CMP_NQC_RETRY_OCCURED, "ADVANCED", "INFRM", 
                        "LOGONLY", msg); 
}
void SQLMXLoggingArea::logExecRtInfo(const char *fileName,
                                     ULng32 lineNo,
                                     const char *msg, Lng32 explainSeqNum)
{
  bool lockedMutex = lockMutex();
  short rc = 0;
  SqlSealogEvent sevent;
  // Open a  new connection 
  sevent.openConnection();
  // set the required parameters
  sevent.setFileName((char *)fileName);
  sevent.setLineNumber(lineNo);
  sevent.setMessageText((char *)msg);
  sevent.setExplainSeqNum(explainSeqNum);
  // set the event ifd and severity and send the event
  sevent.sendEvent(SQEV_SQL_EXEC_RT_INFO, SQ_LOG_INFO);
  // close the connection.
  sevent.closeConnection();
  if (lockedMutex)
    unlockMutex();
}
static void writeStackTrace(char *s, int bufLen)
{
  const int safetyMargin = 256;
  int len = sprintf(s, "Process Stack Trace:\n");

  // This is a quick and dirty implementation for Linux. It is easy to
  // get the program counters for the stack trace, but is difficult to
  // look up the function name, line, and file number based off of the
  // program counter. For simplicity, this code just calls addr2line to
  // look up the information. This could be changed in the future if an
  // easy to use API becomes available.
  void *bt[20];
  size_t size = backtrace(bt, 20);

  pid_t myPID = getpid();

  // Write each level of the stack except for the top frame and the
  // bottom two frames, which aren't important here.
  Int32 i = 1;
  while (i < size - 2)
  {
    char buffer[128];  // Used for command-line + addr2line output.
    char addrBuf[sizeof(void *)*2 + 4];

    sprintf(buffer, "/usr/bin/addr2line -e /proc/%d/exe -f -C ", myPID);

    Int32 j;

    // Run addr2line on 5 addresses at a time.
    for (j = i; j < i+5 && j < size-2; j++)
    {
      sprintf(addrBuf, " %p", bt[j]);
      strcat(buffer, addrBuf);
    }

    FILE *cmdFP = popen(buffer, "r");
    if (cmdFP == NULL)
    {
      if (len+safetyMargin < bufLen)
        len += sprintf(s, "Error %d while popen() of %s\n", errno, buffer);
      break;
    }
    else
    {
      for (j = i; j < i+5 && j < size-2; j++)
      {
        // Read from the addr2line output
        fgets(buffer, sizeof(buffer), cmdFP);

        // Replace newline with null character
        size_t len = strlen(buffer);
        if (buffer[len-1] == '\n')
          buffer[len-1] = '\0';

        if (len+safetyMargin < bufLen)
          len += sprintf(s, "%p: %s()\n", bt[j], buffer); 
        fgets(buffer, sizeof(buffer), cmdFP);
        if (len+safetyMargin < bufLen)
          len += sprintf(s, "            %s", buffer); 
      }
      fclose(cmdFP);
    }
    i = j;
  }
  sprintf(s, "\n");
}
void SQLMXLoggingArea::logErr97Event(int rc)
{
#if 0
// to be completed, need event id 516 and proper template in sqf/seapilot/
// source/event_templates/sql.info_event.template.
  const int LEN=8192;
  if (rc == 97) {
    char msg[LEN];
    writeStackTrace(msg, LEN);
    logSQLMXEventForError(SQLMX_ERR97_OCCURED, "ADVANCED", "INFRM", 
			  "LOGONLY", msg);
  }
#endif
}
void SQLMXLoggingArea::logSQLMXPredefinedEvent(
  ULng32 eventId,
  SQLMXLoggingArea::Category category)
{
 
  bool lockedMutex = lockMutex();
  SqlSealogEvent sevent;
  // Open a  new connection 
  sevent.openConnection();
  // set the required parameters 
  // set the event id and severity and send the event
  sevent.sendEvent(eventId, SQ_LOG_INFO);
  // close the connection.
  // sevent.closeConnection(); 
  if (lockedMutex)
    unlockMutex();
 
}
void SQLMXLoggingArea::logSQLMXDebugEvent( const char *msg, short errorcode, bool lock)
{
  
  bool lockedMutex = lock ? lockMutex() : false;
  SqlSealogEvent sevent;
  // Open a  new connection 
  sevent.openConnection();
  // set the required parameters

  sevent.setMessageText((char *)msg);
  sevent.setError1((Lng32)errorcode);
  // set the event id and severity and send the event
  sevent.sendEvent(SQEV_SQL_DEBUG_EVENT, SQ_LOG_DEBUG);
  // close the connection.
  sevent.closeConnection(); 
  if (lockedMutex)
    unlockMutex();
}

// log an ABORT event
void
SQLMXLoggingArea::logSQLMXAbortEvent(const char* file, Int32 line, const char* msg)
{
  bool lockedMutex = lockMutex();
  SqlSealogEvent sevent;
  // Open a  new connection 
  sevent.openConnection();
  // set the required parameters
  sevent.setFileName((char *)file);
  sevent.setLineNumber(line);
  sevent.setMessageText((char *)msg);
 
  // set the event id and severity and send the event
  sevent.sendEvent(SQEV_SQL_ABORT, SQ_LOG_ERR);
  // close the connection.
  sevent.closeConnection(); 
  if (lockedMutex)
    unlockMutex();
 
}

// log an ASSERTION FAILURE event
void
SQLMXLoggingArea::logSQLMXAssertionFailureEvent(const char* file, Int32 line, const char* msg, const char* condition, const Lng32* tid)
{
  bool lockedMutex = lockMutex();
  SqlSealogEvent sevent;
  // Open a  new connection 
  sevent.openConnection();
  // set the required parameters
  sevent.setFileName((char *)file);
  sevent.setLineNumber(line);
  sevent.setMessageText((char *)msg);
  if (tid)
    sevent.setInt0(*tid);
  if (condition)
    sevent.setString0((char *)condition);
 
  // set the event id and severity and send the event
  sevent.sendEvent(SQEV_SQL_ASSERTION_FAILURE, SQ_LOG_ERR);
  // close the connection.
  sevent.closeConnection(); 
  if (lockedMutex)
    unlockMutex();
  // logSQLMXEvent(SQLMX_ASSERTION_FAILURE, file, line, msg);
}

void SQLMXLoggingArea::logPOSInfoEvent(const char *msg)
{
  bool lockedMutex = lockMutex();
  SqlSealogEvent sevent;
  // Open a  new connection 
  sevent.openConnection();
  // set the required parameters
  sevent.setMessageText((char *)msg);
 
  // set the event id and severity and send the event
  sevent.sendEvent(SQEV_SQL_POS_INFO, SQ_LOG_INFO);
  // close the connection.
  sevent.closeConnection(); 
  if (lockedMutex)
    unlockMutex();
       
}
void SQLMXLoggingArea::logPOSErrorEvent(const Lng32 errorCode,
                                        const char *msg1,
                                        const char *msg2,
                                        const char *msg3)
{
  bool lockedMutex = lockMutex();
  SqlSealogEvent sevent;
  // Open a  new connection 
  sevent.openConnection();
  // set the required parameters
  sevent.setError1(errorCode);
  sevent.setString0((char *)msg1);
  sevent.setString1((char *)msg2);
  sevent.setString2((char *)msg3);
 
  // set the event id and severity and send the event
  if (errorCode == 1150)
    sevent.sendEvent(SQEV_SQL_POS_ERROR, SQ_LOG_ERR);
  else if (errorCode ==1154)
    sevent.sendEvent(SQEV_SQL_POS_CREATE_ERROR,SQ_LOG_ERR);
  // close the connection.
  sevent.closeConnection(); 
  if (lockedMutex)
    unlockMutex();
	
}


// events that correspond to informational messages from CommonLogger or one of
// its subclasses
void SQLMXLoggingArea::logCommonLoggerInfoEvent(ULng32 eventId,
                                                const char *msg)
{ 
  SqlSealogEvent sevent;
  sevent.openConnection();
  sevent.setExperienceLevel("ADVANCED");
  sevent.setTarget("LOGONLY");
  sevent.setMessageText((char*)msg);
  sevent.sendEvent(eventId, SQ_LOG_INFO);
  sevent.closeConnection(); 
}   
    
// events that correspond to error messages from CommonLogger or one of its
// subclasses
void SQLMXLoggingArea::logCommonLoggerErrorEvent(ULng32 eventId,
                                                 const char *msg)
{ 
  SqlSealogEvent sevent;
  sevent.openConnection();
  sevent.setExperienceLevel("ADVANCED");
  sevent.setTarget("DBADMIN");
  sevent.setMessageText((char*)msg);
  sevent.sendEvent(eventId, SQ_LOG_ERR);
  sevent.closeConnection(); 
}

// events that correspond to fatal error messages from CommonLogger or one of
// its subclasses
void SQLMXLoggingArea::logCommonLoggerFailureEvent(ULng32 eventId,
                                                   const char *msg)
{
  SqlSealogEvent sevent;
  sevent.openConnection();
  sevent.setExperienceLevel("ADVANCED");
  sevent.setTarget("DBADMIN");
  sevent.setMessageText((char*)msg);
  sevent.sendEvent(eventId, SQ_LOG_ERR);
  sevent.closeConnection(); 
}

void SQLMXLoggingArea::logMVQRInfoEvent(const char *msg)
{ 
  logSQLMXEventForError(SQLMX_MVQR_INFO, "ADVANCED", "INFRM", "LOGONLY", msg);
}   
    
// events that correspond to error messages in an MVQR process (qms, qmm, qmp)
void SQLMXLoggingArea::logMVQRErrorEvent(const char *msg)
{ 
  logSQLMXEventForError(SQLMX_MVQR_ERROR, "ADVANCED", "MAJOR", "DBADMIN", msg);
} 

// events that correspond to fatal error messages in an MVQR process (qms, qmm, qmp)
void SQLMXLoggingArea::logMVQRFailureEvent(const char *msg)
{
  logSQLMXEventForError(SQLMX_MVQR_FAILURE, "ADVANCED", "MAJOR", "DBADMIN", msg);
}

void SQLMXLoggingArea::logMVRefreshInfoEvent(const char *msg)
{
  bool lockedMutex = lockMutex();
  SqlSealogEvent sevent;
  // Open a  new connection 
  sevent.openConnection();
  // set the required parameters
  
  sevent.setMessageText((char *)msg);
 
  // set the event id and severity and send the event
  sevent.sendEvent(SQEV_MVREFRESH_INFO, SQ_LOG_INFO);
  // close the connection.
  sevent.closeConnection(); 
  if (lockedMutex)
    unlockMutex();
  	
}

void SQLMXLoggingArea::logMVRefreshErrorEvent(const char *msg)
{
  bool lockedMutex = lockMutex();
  SqlSealogEvent sevent;
  // Open a  new connection 
  sevent.openConnection();
  // set the required parameters

  sevent.setMessageText((char *)msg);
 
  // set the event id and severity and send the event
  sevent.sendEvent(SQEV_MVREFRESH_ERROR, SQ_LOG_ERR);
  // close the connection.
  sevent.closeConnection(); 
  if (lockedMutex)
    unlockMutex();
       
}


void SQLMXLoggingArea::logCliReclaimSpaceEvent(Lng32 freeSize, Lng32 totalSize,
					       Lng32 totalContexts, Lng32 totalStatements)
{

  bool lockedMutex = lockMutex();
  SqlSealogEvent sevent;
  // Open a  new connection 
  sevent.openConnection();
  // set the required parameters
  sevent.setInt0(freeSize);
  sevent.setInt1(totalSize);
  sevent.setInt2(totalContexts);
  sevent.setInt3(totalStatements);
 
  // set the event id and severity and send the event
  sevent.sendEvent(SQEV_SQL_CLI_RECLAIM_OCCURED, SQ_LOG_INFO);
  // close the connection.
  sevent.closeConnection(); 
  if (lockedMutex)
    unlockMutex();
 
}

Int16 SqlSealogEvent::openConnection()
{
#ifdef SP_DIS
  return 0;
#else
  if (SQLMXLoggingArea::establishedAMQPConnection())
    return 0;
  Int32 qpidNodePort = atoi(getenv("QPID_NODE_PORT"));

  common::event_header * eventHeader = sqlInfoEvent_.mutable_header();
  common::info_header * infoHeader = eventHeader->mutable_header();  

  Int32 rc = createAMQPConnection("127.0.0.1",qpidNodePort);
  if (rc)
    //add trace log 
    return rc;
  SQLMXLoggingArea::establishedAMQPConnection_ = TRUE;
  return rc;
#endif
 
}

//set methods
void SqlSealogEvent::setQueryId(char *queryId)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_query_id(queryId ? queryId:"(not available)");
#endif
}

void SqlSealogEvent::setMessageText(char *messageText)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_message_text(messageText ? messageText: "(not available)");
#endif
}

void SqlSealogEvent::setExperienceLevel(const char *el)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_experience_level(el?el:"ADVANCED");
#endif
}
void SqlSealogEvent::setTarget(const char *target)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_target(target?target:"LOGONLY");
#endif
}
void SqlSealogEvent::setFileName(char *fn)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_file_name(fn?fn:"(not available)");
#endif
}
void SqlSealogEvent::setLineNumber(Lng32 ln)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_line_number((ln>0)?ln:0);
#endif
}
void SqlSealogEvent::setExplainSeqNum(Lng32 esn)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_explain_seq_num(esn);
#endif
}
void SqlSealogEvent::setError1(Lng32 e1)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_error1(e1);
#endif
}
void SqlSealogEvent::setError2(Lng32 e2)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_error2(e2);
#endif
}
void SqlSealogEvent::setError3(Lng32 e3)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_error3(e3);
#endif
}
void SqlSealogEvent::setInt0(Lng32 i0)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_int0(i0);
#endif
}
void SqlSealogEvent::setInt1(Lng32 i1)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_int1(i1);
#endif
}
void SqlSealogEvent::setInt2(Lng32 i2)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_int2(i2);
#endif
}
void SqlSealogEvent::setInt3(Lng32 i3)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_int3(i3);
#endif
}
void SqlSealogEvent::setInt4(Lng32 i4)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_int4(i4);
#endif
}
void SqlSealogEvent::setString0(char *string0)
{ 
#ifndef SP_DIS
  sqlInfoEvent_.set_string0(string0 ? string0 : "");
#endif
}
void SqlSealogEvent::setString1(char *string1)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_string1(string1?string1:"");
#endif
}
void SqlSealogEvent::setString2(char *string2)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_string2(string2 ? string2 : "");
#endif
}
void SqlSealogEvent::setString3(char *string3)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_string3(string3 ? string3 : "");
#endif
}
void SqlSealogEvent::setString4(char *string4)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_string4(string4 ? string4 : "");
#endif
}
void SqlSealogEvent::setInt64_0(Int64 i64_0)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_int64_0(i64_0);
#endif
}
void SqlSealogEvent::setInt64_1(Int64 i64_1)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_int64_1(i64_1);
#endif
}
void SqlSealogEvent::setInt64_2(Int64 i64_2)
{
#ifndef SP_DIS
  sqlInfoEvent_.set_int64_2(i64_2);
#endif
}
  
// Pass in event id (from sq_sql_eventids.h file
// Pass in severity from sealog header file (foll values) : 
// SQ_LOG_CRIT
// SQ_LOG_ALERT
// SQ_LOG_ERR
// SQ_LOG_INFO
// This method sets the event id and severity and serailizes
// any other event tokens into a string form and sends the buffer
// to sealog

Int16 SqlSealogEvent::sendEvent(Int16 eventId, Lng32 slSeverity)
{
  Int32 rc = 0;
#ifndef SP_DIS
  char eventidStr[10]="        ";
  Lng32 eventidLen = 0;
  str_sprintf(eventidStr,"10%d%06d",SQEVL_SQL,eventId);
  str_strip_blanks(eventidStr,eventidLen);
  Lng32 eventIdVal = (Lng32)str_atoi(eventidStr,eventidLen);
   common::event_header * eventHeader = sqlInfoEvent_.mutable_header();
  common::info_header * infoHeader = eventHeader->mutable_header();  

   rc = initAMQPInfoHeader(infoHeader, SQEVL_SQL);
   if (rc)
     //add trace log
     return rc;
  sqlInfoEvent_.mutable_header()->set_event_id(eventIdVal);
  sqlInfoEvent_.mutable_header()->set_event_severity(slSeverity);
  setExperienceLevel("ADVANCED");
  setTarget("LOGONLY");

  AMQPRoutingKey routingKey(SP_EVENT, SP_SQLPACKAGE,  SP_INSTANCE, 
                              SP_PUBLIC,  SP_GPBPROTOCOL,  "info_event"); 
  try {
    rc = sendAMQPMessage(true, sqlInfoEvent_.SerializeAsString(), SP_CONTENT_TYPE_APP, routingKey);
  } catch(...) {
    rc = -1;
  }
#endif
  return rc;
}

Int16 SqlSealogEvent::closeConnection()
{
#ifdef SP_DIS
  return 0;
#else
 Int32 rc = closeAMQPConnection();
 SQLMXLoggingArea::establishedAMQPConnection_ = FALSE;
  if (rc)
    // add trace log
    return rc;
  return rc;
#endif
}


void SQLMXLoggingArea::logSortDiskInfo(char *diskname, short percentfree, short diskerror)
{
  // 
  //TBD or rewrite needed 
  //** use event id SQEV_SQL_SRT_INFO **
}

static void check_assert_bug_catcher()
{

}

void SQLMXLoggingArea::logUtilErrorsEvent (const char *utilName,
                                         const Int32 numOfErrors,
                                         const Lng32  errorCode,
                                         const char *msg1,
                                         const char *msg2,
                                         const char *msg3,
                                         const char *msg4,
                                         const char *msg5)
{
/* TBD
  tokenClass operation_tok(
    STRING, 
    TKN_UTIL_NAME,
    (void*)utilName
    );
  
  tokenClass errorCode_tok(
    LONGINT32, 
    TKN_PM_SQLCODE,
    (void*)&errorCode
    );

  // There must be atleast one error message(msg1) to emit.
  tokenClass msg1_tok(STRING, 
		      TKN_PM_ERRTEXT,
		      (void*)msg1
		      );
  tokenClass msg2_tok(STRING, 
		      TKN_PM_ERRTEXT,
		      (void*)msg2
		      );
  
  tokenClass msg3_tok(STRING, 
		      TKN_PM_ERRTEXT,
		      (void*)msg3
		      );

  tokenClass msg4_tok(STRING, 
		      TKN_PM_ERRTEXT,
		      (void*)msg4
		      );

  tokenClass msg5_tok(STRING, 
		      TKN_PM_ERRTEXT,
		      (void*)msg5
		      );
  
  switch (numOfErrors)
    {
    case (1):
      logAnMxEvent(SQLMX_UTIL_OP_ERROR,
		   SQLMXLoggingArea::SoftwareFailure,
		   &operation_tok, 
		   &errorCode_tok,
		   &msg1_tok,
		   0
		   );

      break;
      
    case (2):
      logAnMxEvent(SQLMX_UTIL_OP_ERROR,
		   SQLMXLoggingArea::SoftwareFailure,
		   &operation_tok, 
		   &errorCode_tok,
		   &msg1_tok,
		   &msg2_tok,
		   0
		   );
      break;
      
    case (3):
      logAnMxEvent(SQLMX_UTIL_OP_ERROR,
		   SQLMXLoggingArea::SoftwareFailure,
		   &operation_tok, 
		   &errorCode_tok,
		   &msg1_tok,
		   &msg2_tok,
		   &msg3_tok,
		   0
		   );
      
      break;
      
    case (4):
      logAnMxEvent(SQLMX_UTIL_OP_ERROR,
		   SQLMXLoggingArea::SoftwareFailure,
		   &operation_tok, 
		   &errorCode_tok,
		   &msg1_tok,
		   &msg2_tok,
		   &msg3_tok,
		   &msg4_tok,
		   0
		   );
      
      break;

    case (5):
      logAnMxEvent(SQLMX_UTIL_OP_ERROR,
		   SQLMXLoggingArea::SoftwareFailure,
		   &operation_tok, 
		   &errorCode_tok,
		   &msg1_tok,
		   &msg2_tok,
		   &msg3_tok,
		   &msg4_tok,
		   &msg5_tok,
		   0
		   );
      break;

    default:
      // should not get here.
      break;

    }
end TBD */
}

void SQLMXLoggingArea::logUtilOperationStatusEvent(ULng32 eventId,
                                                   const char *utilName,
						   const char *objType,
						   const char *objAnsiName,
                                                   const char *utilStatus)
{
/* TBD
  tokenClass utilName_tok(
    STRING, 
    TKN_UTIL_NAME,
    (void*)utilName
    );
  
  tokenClass objType_tok(
    STRING, 
    TKN_PM_OBJ_TYPE,
    (void*)objType
    );

  tokenClass objAnsiName_tok(
    STRING, 
    TKN_PM_ANSI_NAME,
    (void*)objAnsiName
    );

  tokenClass utilStatus_tok(
    STRING, 
    TKN_UTIL_STATUS,
    (void*)utilStatus
    );

  logAnMxEvent(eventId,
	       SQLMXLoggingArea::Informational,
	       &utilName_tok, 
               &objType_tok,
	       &objAnsiName_tok, 
               &utilStatus_tok,
	       0
	       );
end TBD */
}

void SQLMXLoggingArea::logPMEvent(ULng32 eventId)
{
// TBD
}

// These aren't currently used
#if 0
void SQLMXLoggingArea::logPMOperationStatusEvent(ULng32 eventId,
						const char *operation, 
						  const char *objType,
						  const char *objAnsiName)
{
   
}
 
void SQLMXLoggingArea::logPMDataCopyStatusEvent(ULng32 eventId, 
						TInt64 elapsedTime,
						TInt64 totalCopyCount,
						const char *unitName)
{

}

void SQLMXLoggingArea::logPMEventWithGuardianName(ULng32 eventId,
						  const char *location)
{

}

void SQLMXLoggingArea::logPMEventWithDumpFileName(ULng32 eventId,
						  const char *location)
{

}

void SQLMXLoggingArea::logPMEventWithInterval(ULng32 eventId,
					      TInt64 interval)
{


}


void SQLMXLoggingArea::logPMErrorsEvent (const char *operation,
					 const Int32 numOfErrors,
					 const Lng32  errorCode,
					 const char *msg1,
					 const char *msg2,
					 const char *msg3,
					 const char *msg4,
					 const char *msg5)
{

}

void SQLMXLoggingArea::logPMAudInitEvent(ULng32 eventId,
					 TInt64 interval)
{
 
}

void SQLMXLoggingArea::logPMAudStartEvent(ULng32 eventId,
					  const short audNum)
{
  
}

void SQLMXLoggingArea::logPMAudDoneEvent(ULng32 eventId,
					 const short audNum,
					 TInt64 interval)
{
  

}
#endif // #if 0