private void HandleMethodColumn(string columnContent, LogSubRequest logRow)
{
if (columnContent.StartsWith(SQL_METHOD))
{
logRow.ContainsSQL = true;
//schema
int schemaStart = columnContent.IndexOf(BEFORE_SCHEMA_STRING);
if (schemaStart == -1)
{
return;
}
else
{
schemaStart += BEFORE_SCHEMA_STRING.Length;
}
int schemaEnd = columnContent.IndexOf(' ', schemaStart + 1);
logRow.DbSchema = columnContent.Substring(schemaStart, schemaEnd - schemaStart);
}
else
{
//concat method to class
logRow.Method += '.' + columnContent;
}
}
protected override void HandleColumn(int columnIndex, string columnContent, LogSubRequest logRow)
{
switch (columnIndex)
{
case 0:
HandleDateTimeColumn(columnContent, logRow);
break;
case 1:
HandleThreadColumn(columnContent, logRow);
break;
case 2:
HandleTypeColumn(columnContent, logRow);
break;
case 3:
HandleClassColumn(columnContent, logRow);
break;
case 4:
HandleMethodColumn(columnContent, logRow);
break;
case 5:
HandleMessageColumn(columnContent, logRow);
break;
default:
throw new ApplicationException("Wrong number of columns");
}
}
public static void HandleMethodColumn(string columnContent, LogSubRequest logRow)
{
//method
int methodStart = columnContent.IndexOf('C');
if (methodStart == -1)
{
methodStart = 0;
}
int methodEnd = columnContent.IndexOf(' ', methodStart + 1);
if (methodEnd == -1)
{
methodEnd = columnContent.Length;
}
logRow.Method = columnContent.Substring(methodStart, methodEnd - methodStart);
//schema
int schemaStart = columnContent.IndexOf(BEFORE_SCHEMA_STRING, methodStart);
if (schemaStart == -1)
{
return;
}
else
{
schemaStart += BEFORE_SCHEMA_STRING.Length;//add length of '
}
logRow.ContainsSQL = true;
int schemaEnd = columnContent.IndexOf(' ', schemaStart + 1);
logRow.DbSchema = columnContent.Substring(schemaStart, schemaEnd - schemaStart);
}
protected void HandleThreadColumn(string columnContent, LogSubRequest logRow)
{
//thread name
int threadNameLength = columnContent.IndexOf(' ');
if (threadNameLength == -1)
{
threadNameLength = columnContent.Length;
}
logRow.Thread = columnContent.Substring(0, threadNameLength);
//other parts
int start;
int end = threadNameLength;
string subContent;
while (true)
{
start = columnContent.IndexOf('[', end);
if (start == -1)
{
break;
}
else
{
start++;//add length of '['
}
end = columnContent.IndexOf(']', start);
if (end == -1)
{
end = columnContent.Length - 1;
}
subContent = columnContent.Substring(start, end - start);
if (subContent.StartsWith(STR_CALL_ID))
{
logRow.CallId = subContent.Substring(STR_CALL_ID.Length);
}
else if (subContent.StartsWith(STR_CONNECT_ID))
{
logRow.ConnectId = subContent.Substring(STR_CONNECT_ID.Length);
}
else if (subContent.StartsWith(STR_LOGIN_ID))
{
logRow.LoginId = subContent.Substring(STR_LOGIN_ID.Length);
}
else if (subContent.StartsWith(STR_USER_NAME))
{
logRow.User = subContent.Substring(STR_USER_NAME.Length);
}
else
{
logRow.Request = subContent;
}
}
}
protected override void HandleColumn(int columnIndex, string columnContent, LogSubRequest logRow)
{
if (columnIndex >= ColumnCount)
{
throw new ApplicationException("Wrong number of columns");
}
HandleColumn(GetColumnIndexType(columnIndex), columnContent, logRow);
}
private void HandleClassColumn(string columnContent, LogSubRequest logRow)
{
int start = columnContent.IndexOf('C');
if (start == -1)
{
start = 0;
}
logRow.Method = columnContent.Substring(start);
}
protected void HandleMessageColumn(string columnContent, LogSubRequest logRow)
{
logRow.Message = columnContent;
if (logRow.ContainsSQL)
{
logRow.Message = logRow.Message.Replace(SQL_ROW_START, string.Empty);
}
logRow.IsRequestLastRow = logRow.Message.StartsWith(REQUEST_END);
}
private void TryCompleteRequestIfMissing(LogSubRequest newRow)
{
if (!string.IsNullOrEmpty(newRow.Request))
{
return;
}
if (newRow.Message.StartsWith(REQUEST_START))
{
newRow.IsRequestFirstRow = true;
newRow.Request = newRow.Message.Substring(REQUEST_START.Length);
}
else if (newRow.Thread.StartsWith(THREAD_START1) || newRow.Thread.StartsWith(THREAD_START2))
{
newRow.Request = newRow.Thread;
}
}
private void UpdateText()
{
LogSubRequest logRow = m_filterGridControl.FocusedObject <LogSubRequest>();
if (logRow != null)
{
if (Text != logRow.Message)
{
Text = logRow.Message;
SetMessageColors(logRow);
}
}
else
{
Text = string.Empty;
}
}
private void SetMessageColors(LogSubRequest logRow)
{
if (logRow == null)
{
Text = string.Empty;
return;
}
bool isFailed = logRow.IsErrType;
SetTextRegularProperties(m_options.MessageForeColor, m_options.MessageBackColor, m_options.MessageFont);
SetTextFailedProperties(m_options.MessageErrorForeColor);
UnselectAll();
//unselect all
SelectionStart = 0;
SelectionLength = TextLength;
if (TextLength < 2)
{
return;
}
if (logRow.ContainsSQL)
{
//select sql words
SetTextSelectionProperties(m_options.SqlForeColor, m_options.SqlBackColor, m_options.SqlFont);
SelectStrings(Utilities.SqlReservedWords, true);
}
//select custom words
SetTextSelectionProperties(m_options.CustomForeColor, m_options.CustomBackColor, m_options.CustomFont);
SelectStrings(m_options.CustomSelectedWords, false);
//select filter words
string[] emptyPropertyValues = m_filterGridControl.FilterConfig.MainFilter.GetValues(FilterConfig.EMPTY_PROPERTY);
SelectStrings(emptyPropertyValues, false);
//set focus on zero
SelectionStart = 0;
SelectionLength = 0;
}
protected override void HandleColumn(int columnIndex, string columnContent, LogSubRequest logRow)
{
switch (columnIndex)
{
case 0:
HandleDBDateTimeColumn(columnContent, logRow);
break;
case 1:
HandleDateTimeColumn(columnContent, logRow);
break;
case 2:
HandleThreadColumn(columnContent, logRow);
break;
case 3:
HandleRequestTypeColumn(columnContent, logRow);
break;
case 4:
HandleLoginColumn(columnContent, logRow);
break;
case 5:
HandleIpColumn(columnContent, logRow);
break;
case 6:
HandleTypeColumn(columnContent, logRow);
break;
case 7:
HandleMethodColumn(columnContent, logRow);
break;
case 8:
HandleMessageColumn(columnContent, logRow);
break;
}
}
protected override void HandleColumn(int columnIndex, string columnContent, LogSubRequest logRow)
{
switch (columnIndex)
{
case 0:
case 1:
case 2:
case 3:
case 4:
case 6:
base.HandleColumn(columnIndex, columnContent, logRow);
break;
case 5:
Parser0920.HandleMethodColumn(columnContent, logRow);
break;
default:
throw new ApplicationException("Wrong number of columns");
}
}
protected void HandleMethodColumn(string columnContent, LogSubRequest logRow)
{
//method
int methodLength = columnContent.IndexOf(')') + 1;
logRow.Method = columnContent.Substring(0, methodLength);
//schema
int schemaStart = columnContent.IndexOf('\'', methodLength);
if (schemaStart == -1)
{
return;
}
else
{
schemaStart++;//add length of '
}
int schemaEnd = columnContent.IndexOf('\'', schemaStart + 1);
logRow.DbSchema = columnContent.Substring(schemaStart, schemaEnd - schemaStart);
logRow.ContainsSQL = true;
}
private void HandleColumn(COLUMN_INDEXES columnType, string columnContent, LogSubRequest logRow)
{
switch (columnType)
{
case COLUMN_INDEXES.DATETIME:
HandleDateTimeColumn(columnContent, logRow);
break;
case COLUMN_INDEXES.DB_DATETIME:
HandleDBDateTimeColumn(columnContent, logRow);
break;
case COLUMN_INDEXES.IP:
HandleIpColumn(columnContent, logRow);
break;
case COLUMN_INDEXES.LOGIN:
HandleLoginColumn(columnContent, logRow);
break;
case COLUMN_INDEXES.MESSAGE:
HandleMessageColumn(columnContent, logRow);
break;
case COLUMN_INDEXES.METHOD:
HandleMethodColumn(columnContent, logRow);
break;
case COLUMN_INDEXES.THREAD:
HandleThreadColumn(columnContent, logRow);
break;
case COLUMN_INDEXES.TYPE:
HandleTypeColumn(columnContent, logRow);
break;
}
}
protected override void HandleColumn(int columnIndex, string columnContent, LogSubRequest logRow)
{
switch (columnIndex)
{
case 0:
base.HandleColumn((int)COLUMN_INDEXES.DATETIME, columnContent, logRow);
break;
case 1:
base.HandleColumn((int)COLUMN_INDEXES.THREAD, columnContent, logRow);
break;
case 2:
base.HandleColumn((int)COLUMN_INDEXES.LOGIN, columnContent, logRow);
break;
case 3:
base.HandleColumn((int)COLUMN_INDEXES.IP, columnContent, logRow);
break;
case 4:
base.HandleColumn((int)COLUMN_INDEXES.TYPE, columnContent, logRow);
break;
case 5:
base.HandleColumn((int)COLUMN_INDEXES.METHOD, columnContent, logRow);
break;
case 6:
base.HandleColumn((int)COLUMN_INDEXES.MESSAGE, columnContent, logRow);
break;
default:
throw new ApplicationException("Wrong number of columns");
}
}
/// <summary>
/// Return true if row should be added and false if row shouldn't be added to collection
/// </summary>
/// <param name="logs"></param>
/// <param name="newRow"></param>
/// <returns></returns>
protected virtual bool OnBeforeAdd(List <LogSubRequest> logs, LogSubRequest newRow)
{
return(true);
}
protected abstract void HandleColumn(int columnIndex, string columnContent, LogSubRequest logRow);
public static void HandleTypeColumn(string columnContent, LogSubRequest logRow)
{
logRow.Type = columnContent;
}
protected void HandleDBDateTimeColumn(string columnContent, LogSubRequest logRow)
{
logRow.DbStartDate = DateTime.ParseExact(columnContent, TIME_PATTERN, EN_CULTURE_INFO);
}
/// <summary>
/// Definition : double rows contains EXECUTION TIME and its FIRST ROW
/// Return true if row should be added and
/// false row should be omitted , because : sibling row was found and was updated so we don't need this row
/// </summary>
/// <param name="m_logs"></param>
/// <param name="doubleRow"></param>
/// <returns></returns>
private bool HandleDoubleRow(List <LogSubRequest> logs, LogSubRequest suspectRow)
{
if (!suspectRow.Message.StartsWith(SQL_DOUBLE_ROW_START))
{
return(true);
}
int execTimeStrEnd = suspectRow.Message.IndexOf(MILLISECONDS, SQL_DOUBLE_ROW_START.Length);
string execTimeStr = suspectRow.Message.Substring(SQL_DOUBLE_ROW_START.Length, execTimeStrEnd - SQL_DOUBLE_ROW_START.Length);
int execTime = 0;
try
{
execTime = int.Parse(execTimeStr);
}
catch (OverflowException)
{
execTime = int.MaxValue;
}
DateTime firstRowStartTime = suspectRow.StartDate.AddMilliseconds(-execTime);
firstRowStartTime = firstRowStartTime.AddMilliseconds(-100);//flexibility for 100 ms
LogSubRequest tempLog;
for (int i = logs.Count - 1; i >= 0; i--)
{
tempLog = logs[i];
if (tempLog.StartDate < firstRowStartTime)
{
return(true);
}
if (tempLog.Thread == suspectRow.Thread &&
tempLog.CallId == suspectRow.CallId &&
tempLog.ConnectId == suspectRow.ConnectId &&
tempLog.LoginId == suspectRow.LoginId &&
tempLog.Method == suspectRow.Method &&
tempLog.Request == suspectRow.Request &&
suspectRow.Message.Contains(tempLog.Message)
)
{
tempLog.DbTime = execTime;
//row affected : [1 rows affected]
int rowAffectedStart = suspectRow.Message.IndexOf('[', execTimeStrEnd, 10);
if (rowAffectedStart > 0)
{
rowAffectedStart++;//add length of [
int rowAffectedEnd = suspectRow.Message.IndexOf(' ', rowAffectedStart, 10);
tempLog.RowAffected = suspectRow.Message.Substring(rowAffectedStart, rowAffectedEnd - rowAffectedStart);;
}
return(false);
}
}
return(true);
}
protected override bool OnBeforeAdd(List <LogSubRequest> logs, LogSubRequest newRow)
{
return(HandleDoubleRow(logs, newRow));
}
public static void HandleThreadColumn(string columnContent, LogSubRequest logRow)
{
//thread name
int start = 0;
int end = 0;
if (columnContent.StartsWith(EXECUTE_THREAD))
{
start = columnContent.IndexOf('\'') + 1;
end = columnContent.IndexOf('\'', start + 1);
}
else
{
//try find end by ' ' or by '['
end = columnContent.IndexOf(' ');
if (end == -1)
{
end = columnContent.IndexOf('[');
}
if (end == -1)
{
end = columnContent.Length;
}
}
logRow.Thread = columnContent.Substring(start, end - start);
//other parts
string subContent;
while (true)
{
start = columnContent.IndexOf('[', end);
if (start == -1)
{
break;
}
else
{
start++;//add length of '['
}
end = columnContent.IndexOf(']', start);
subContent = columnContent.Substring(start, end - start);
if (subContent.StartsWith(STR_CALL_ID))
{
logRow.CallId = subContent.Substring(STR_CALL_ID.Length);
}
else if (subContent.StartsWith(STR_CONNECT_ID))
{
logRow.ConnectId = subContent.Substring(STR_CONNECT_ID.Length);
}
else if (subContent.StartsWith(STR_LOGIN_ID))
{
logRow.LoginId = subContent.Substring(STR_LOGIN_ID.Length);
}
else if (subContent.StartsWith(STR_USER_NAME))
{
logRow.User = subContent.Substring(STR_USER_NAME.Length);
}
else if (subContent.StartsWith(STR_JOB))
{
logRow.Request = subContent.Substring(STR_JOB.Length);
}
else if (subContent.StartsWith(STR_DB_MESSENGER))
{
continue;
}
else
{
logRow.Request = subContent;
}
}
}
protected void HandleIpColumn(string columnContent, LogSubRequest logRow)
{
logRow.IP = columnContent;
}
protected void HandleLoginColumn(string columnContent, LogSubRequest logRow)
{
logRow.User = columnContent;
}
public static void HandleDateTimeColumn(string columnContent, LogSubRequest logRow)
{
logRow.StartDate = DateTime.ParseExact(columnContent, TIME_PATTERN, EN_CULTURE_INFO);
}
private void HandleThreadColumn(string columnContent, LogSubRequest logRow)
{
//thread name
int threadStart, threadEnd;
threadStart = columnContent.IndexOf('\'');
if (threadStart == -1)
{
threadStart = 0;
//try find end by ' ' or by '['
threadEnd = columnContent.IndexOf(' ');
if (threadEnd == -1)
{
threadEnd = columnContent.IndexOf('[');
}
if (threadEnd == -1)
{
threadEnd = columnContent.Length;
}
}
else //case : thread is surronded with ' xxxx '
{
threadStart++;//add lenth of '
threadEnd = columnContent.IndexOf('\'', threadStart + 1);
}
logRow.Thread = columnContent.Substring(threadStart, threadEnd - threadStart);
//other parts
int start;
int end = threadEnd;
string subContent;
while (true)
{
start = columnContent.IndexOf('[', end);
if (start == -1)
{
break;
}
else
{
start++;//add length of '['
}
end = columnContent.IndexOf(']', start);
subContent = columnContent.Substring(start, end - start);
if (subContent.StartsWith(STR_CALL_ID))
{
logRow.CallId = subContent.Substring(STR_CALL_ID.Length);
}
else if (subContent.StartsWith(STR_CONNECT_ID))
{
logRow.ConnectId = subContent.Substring(STR_CONNECT_ID.Length);
}
else if (subContent.StartsWith(STR_LOGIN_ID))
{
logRow.LoginId = subContent.Substring(STR_LOGIN_ID.Length);
}
else if (subContent.StartsWith(STR_USER_NAME))
{
logRow.User = subContent.Substring(STR_USER_NAME.Length);
}
else if (subContent.StartsWith(STR_FUNCTION_NAME))
{
logRow.Request = subContent.Substring(STR_FUNCTION_NAME.Length);
}
else if (subContent.StartsWith(STR_JOB))
{
logRow.Request = subContent.Substring(STR_JOB.Length);
}
else if (subContent.StartsWith(STR_REMOTE_CALL_ID))
{
logRow.CallId = subContent.Substring(STR_REMOTE_CALL_ID.Length);
}
else if (subContent.StartsWith(STR_FUNC))
{
logRow.Request = subContent.Substring(STR_FUNC.Length);
}
else if (subContent.StartsWith(STR_DB_MESSENGER))
{
continue;
}
else if (subContent.StartsWith(STR_REMOTE_PROXY) || subContent.StartsWith(STR_REMOTE_DISPATCHER))
{
continue;
}
else//
{
Debug.Fail(string.Format("Unrecognizable content '{0}' in Thread column", subContent));
}
}
}
public List <LogSubRequest> Parse(string sourceFile, IList <string> lines)
{
int firstRow = FirstRow(lines);
int lastRow = LastRow(lines);
m_cancel = false;
m_lastPercentEvented = -MINIMAL_GAPE_PERCENT_FOR_EVENT;
List <LogSubRequest> logs = new List <LogSubRequest>();
LogSubRequest logRow;
int columnIndex, columnStart, columnEnd;
string columnContent;
int currentPercent;
bool needEvent;
for (int i = firstRow; i <= lastRow && !m_cancel; i++)
{
if (lines[i] == string.Empty || !lines[i].StartsWith(ROW_START))
{
continue;
}
//if line is divided to several rows - join that rows
if (!lines[i].EndsWith(END_ROW1))
{
HandleBrokenLine(lines, i);
}
//read columns
logRow = new LogSubRequest();
columnIndex = 0;
columnStart = columnEnd = 0;
while (!m_cancel)//read columns
{
columnStart = lines[i].IndexOf(COLUMN_START, columnEnd);
if (columnStart == -1)
{
break;
}
else
{
columnStart += COLUMN_START.Length;
}
//find end of column
if (columnIndex + 1 == ColumnCount)//if it last column, it can be computed rather simply by decreasing 10
{
columnEnd = lines[i].Length - 10;
}
else
{
columnEnd = lines[i].IndexOf(COLUMN_END, columnStart);
if (columnEnd == -1)
{
columnEnd = lines[i].Length - 1;
}
}
columnContent = lines[i].Substring(columnStart, columnEnd - columnStart);
HandleColumn(columnIndex, columnContent, logRow);
columnIndex++;
}
//if date isn't recognized - continue
if (logRow.StartDate.Ticks == 0)
{
continue;
}
//try complete request field
TryCompleteRequestIfMissing(logRow);
//add to collection
if (!OnBeforeAdd(logs, logRow))
{
continue;
}
logRow.CompareIndex = logs.Count;
logRow.Source = sourceFile;
logs.Add(logRow);
//parse event
if (ParseProgress != null)
{
currentPercent = i * 100 / lines.Count;
needEvent = (currentPercent - m_lastPercentEvented > MINIMAL_GAPE_PERCENT_FOR_EVENT);
if (needEvent)
{
ParseProgress(this, new ParsePercentageEventArgs(currentPercent));
m_lastPercentEvented = currentPercent;
}
}
}
return(logs);
}
protected void HandleTypeColumn(string columnContent, LogSubRequest logRow)
{
logRow.Type = columnContent;
}
