Esempio n. 1
0
        public IDictionary <string, ExtendedEventsPosition> GetCurrentLogPositions(
            ExtendedEventsLogBase xEventsLog)
        {
            var cmdGetLastLogFileInfo = _connection.CreateCommand();

            cmdGetLastLogFileInfo.CommandText = Resources.Query_GetActualPositions;
            cmdGetLastLogFileInfo.AddParameterToCommand("ExtendedEventsLog", DbType.AnsiString, xEventsLog.Name);

            IDictionary <string, ExtendedEventsPosition> output = new Dictionary <string, ExtendedEventsPosition>();

            using (var cmdReader = cmdGetLastLogFileInfo.ExecuteReader())
            {
                while (cmdReader.Read())
                {
                    string fileName       = cmdReader.GetString(2).Replace("\\\\", "\\");
                    bool   finishReadFile = cmdReader.GetBoolean(9);
                    output.Add(fileName, new ExtendedEventsPosition(
                                   cmdReader.GetInt64(6),
                                   fileName,
                                   cmdReader.GetString(7),
                                   cmdReader.GetDateTime(8),
                                   finishReadFile,
                                   cmdReader.GetDateTime(10),
                                   cmdReader.GetDateTime(11)
                                   ));
                }
            }

            return(output);
        }
Esempio n. 2
0
        private void GetRowsDataMaxPeriodAndId(
            ExtendedEventsLogBase xEventsLog,
            string fileName, DateTime fromPeriod,
            out DateTime maxPeriod, out long maxId)
        {
            DateTime outputMaxPeriod = DateTime.MinValue;
            long     outputMaxId     = 0;

            using (var command = _connection.CreateCommand())
            {
                command.CommandText =
                    @"SELECT
                        MAX(Period) AS MaxPeriod,
                        MAX(EventNumber) AS MaxId
                    FROM XEventData AS RD
                    WHERE ExtendedEventsLog = {xEventLog:String}
                        AND FileName = {fileName:String}
                        AND Period >= {fromPeriod:DateTime}";
                command.AddParameterToCommand("xEventLog", xEventsLog.Name);
                command.AddParameterToCommand("fileName", fileName);
                command.AddParameterToCommand("fromPeriod", fromPeriod);
                using (var cmdReader = command.ExecuteReader())
                {
                    if (cmdReader.Read())
                    {
                        outputMaxPeriod = cmdReader.GetDateTime(0);
                        outputMaxId     = cmdReader.GetInt64(1);
                    }
                }
            }

            maxPeriod = outputMaxPeriod;
            maxId     = outputMaxId;
        }
Esempio n. 3
0
 public async Task SaveLogPosition(ExtendedEventsLogBase xEventsLog, ExtendedEventsPosition position)
 {
     await SaveLogPositions(xEventsLog, new List <ExtendedEventsPosition>()
     {
         position
     });
 }
Esempio n. 4
0
        public async Task <DateTime> GetRowsDataMaxPeriod(ExtendedEventsLogBase xEventsLog, string FileName)
        {
            DateTime output = DateTime.MinValue;

            using (var command = _connection.CreateCommand())
            {
                command.CommandText =
                    @"SELECT
                        MAX(Period) AS MaxPeriod
                    FROM XEventData AS RD
                    WHERE ExtendedEventsLog = {ExtendedEventsLog:String}
                        AND FileName = {FileName:String} ";
                command.Parameters.Add(new ClickHouseDbParameter
                {
                    ParameterName = "ExtendedEventsLog",
                    Value         = xEventsLog.Name
                });
                command.Parameters.Add(new ClickHouseDbParameter
                {
                    ParameterName = "FileName",
                    Value         = FileName
                });
                using (var cmdReader = await command.ExecuteReaderAsync())
                {
                    if (await cmdReader.ReadAsync())
                    {
                        output = cmdReader.GetDateTime(0);
                    }
                }
            }

            return(output);
        }
Esempio n. 5
0
        public async Task SaveRowsData(ExtendedEventsLogBase xEventsLog, List <XEventData> xEventsData)
        {
            IDictionary <string, List <XEventData> > xEventsDataToInsert = xEventsData
                                                                           .GroupBy(g => g.FileName)
                                                                           .ToDictionary(k => k.Key, v => v.ToList());

            await SaveRowsData(xEventsLog, xEventsDataToInsert);
        }
Esempio n. 6
0
        public async Task <ExtendedEventsPosition> GetLogFilePosition(ExtendedEventsLogBase xEventsLog, string fileName)
        {
            var cmdGetLastLogFileInfo = _connection.CreateCommand();

            cmdGetLastLogFileInfo.CommandText =
                @"SELECT	                
                    FileName,
	                LastEventNumber,
	                LastEventUUID,
	                LastEventPeriod,
                    FinishReadFile,
                    FileCreateDate,
                    FileModificationDate
                FROM LogFiles AS LF
                WHERE ExtendedEventsLog = {ExtendedEventsLog:String}
                    AND FileName = {FileName:String}
                    AND Id IN (
                        SELECT
                            MAX(Id) LastId
                        FROM LogFiles AS LF_LAST
                        WHERE LF_LAST.ExtendedEventsLog = {ExtendedEventsLog:String}
                            AND LF_LAST.FileName = {FileName:String}
                    )";
            cmdGetLastLogFileInfo.AddParameterToCommand("ExtendedEventsLog", DbType.AnsiString, xEventsLog.Name);
            cmdGetLastLogFileInfo.AddParameterToCommand("FileName", DbType.AnsiString, fileName);

            ExtendedEventsPosition output = null;

            await using (var cmdReader = await cmdGetLastLogFileInfo.ExecuteReaderAsync())
            {
                if (await cmdReader.ReadAsync())
                {
                    bool finishReadFile = cmdReader.GetBoolean(4);
                    output = new ExtendedEventsPosition(
                        cmdReader.GetInt64(1),
                        cmdReader.GetString(0),
                        cmdReader.GetString(2),
                        cmdReader.GetDateTime(3),
                        finishReadFile,
                        cmdReader.GetDateTime(5),
                        cmdReader.GetDateTime(6));
                }
            }

            return(output);
        }
Esempio n. 7
0
        public async Task SaveLogPositions(ExtendedEventsLogBase xEventsLog, List <ExtendedEventsPosition> positions)
        {
            List <object[]> positionsForInsert = new List <object[]>();

            foreach (var positionItem in positions)
            {
                FileInfo logFileInfo = new FileInfo(positionItem.CurrentFileData);
                long     itemNumber  = positions.IndexOf(positionItem) + 1;

                positionsForInsert.Add(new object[]
                {
                    xEventsLog.Name,
                    DateTime.UtcNow.Ticks + itemNumber,
                    logFileInfo.Name,
                    DateTime.UtcNow,
                    logFileInfo.CreationTimeUtc,
                    logFileInfo.LastWriteTimeUtc,
                    positionItem.EventNumber,
                    positionItem.EventUUID,
                    positionItem.EventPeriod,
                    positionItem.CurrentFileData.Replace("\\", "\\\\"),
                });
            }

            if (positionsForInsert.Count > 0)
            {
                using (ClickHouseBulkCopy bulkCopyInterface = new ClickHouseBulkCopy(_connection)
                {
                    DestinationTableName = "LogFiles",
                    BatchSize = 100000
                })
                {
                    await bulkCopyInterface.WriteToServerAsync(positionsForInsert);
                }
            }
        }
 public void SetLogInformation(ExtendedEventsLogBase xEventsLog)
 {
     _xEventsLog = xEventsLog;
 }
Esempio n. 9
0
        public async Task SaveRowsData(ExtendedEventsLogBase xEventsLog,
                                       IDictionary <string, List <XEventData> > xEventsData,
                                       Dictionary <string, LastRowsInfoByLogFile> maxPeriodByFiles = null)
        {
            if (maxPeriodByFiles == null)
            {
                maxPeriodByFiles = new Dictionary <string, LastRowsInfoByLogFile>();
            }

            List <object[]> rowsForInsert = new List <object[]>();

            foreach (var eventInfo in xEventsData)
            {
                FileInfo logFileInfo = new FileInfo(eventInfo.Key);
                foreach (var eventItem in eventInfo.Value)
                {
                    DateTime periodServer = eventItem.Timestamp.LocalDateTime;
                    DateTime periodUtc    = TimeZoneInfo.ConvertTimeToUtc(periodServer, TimeZoneInfo.Local);
                    DateTime periodLocal  = periodServer;

                    if (!maxPeriodByFiles.TryGetValue(logFileInfo.Name, out LastRowsInfoByLogFile lastInfo))
                    {
                        if (logFileInfo.Directory != null)
                        {
                            GetRowsDataMaxPeriodAndId(
                                xEventsLog,
                                logFileInfo.Name,
                                periodUtc,
                                out var maxPeriod,
                                out var maxId
                                );
                            lastInfo = new LastRowsInfoByLogFile(maxPeriod, maxId);
                            maxPeriodByFiles.Add(logFileInfo.Name, lastInfo);
                        }
                    }

                    bool existByPeriod = lastInfo.MaxPeriod > ClickHouseHelpers.MinDateTimeValue &&
                                         periodUtc.Truncate(TimeSpan.FromSeconds(1)) <= lastInfo.MaxPeriod;
                    bool existById = lastInfo.MaxId > 0 &&
                                     eventItem.Id <= lastInfo.MaxId;
                    if (existByPeriod && existById)
                    {
                        continue;
                    }

                    if (logFileInfo.Directory != null)
                    {
                        rowsForInsert.Add(new object[]
                        {
                            xEventsLog.Name,
                            logFileInfo.Name,
                            eventItem.EventNumber,
                            periodUtc,
                            periodLocal,
                            eventItem.EventName,
                            eventItem.UUID.ToString(),
                            eventItem.Username ?? string.Empty,
                            eventItem.UsernameNT ?? string.Empty,
                            eventItem.UsernameSessionNT ?? string.Empty,
                            eventItem.SessionId ?? 0,
                            eventItem.PlanHandle ?? string.Empty,
                            eventItem.IsSystem == null ? 0 : ((bool)eventItem.IsSystem ? 1 : 0),
                            eventItem.ExecutionPlanGuid?.ToString() ?? string.Empty,
                            eventItem.DatabaseName ?? string.Empty,
                            eventItem.DatabaseId ?? 0,
                            eventItem.NumaNodeId ?? 0,
                            eventItem.CpuId ?? 0,
                            eventItem.ProcessId ?? 0,
                            eventItem.SQLText ?? string.Empty,
                            eventItem.SQLTextHash ?? string.Empty,
                            eventItem.ClientAppName ?? string.Empty,
                            eventItem.ClientHostname ?? string.Empty,
                            eventItem.ClientId ?? 0,
                            eventItem.QueryHash ?? string.Empty,
                            eventItem.ServerInstanceName ?? string.Empty,
                            eventItem.ServerPrincipalName ?? string.Empty,
                            eventItem.ServerPrincipalId ?? 0,
                            eventItem.CpuTime ?? 0,
                            eventItem.Duration ?? 0,
                            eventItem.PhysicalReads ?? 0,
                            eventItem.LogicalReads ?? 0,
                            eventItem.Writes ?? 0,
                            eventItem.RowCount ?? 0,
                            eventItem.GetActionsAsJSON(),
                            eventItem.GetFieldsAsJSON()
                        });
                    }
                }
            }

            if (rowsForInsert.Count == 0)
            {
                return;
            }

            using (ClickHouseBulkCopy bulkCopyInterface = new ClickHouseBulkCopy(_connection)
            {
                DestinationTableName = "XEventData",
                BatchSize = 100000,
                MaxDegreeOfParallelism = 4
            })
            {
                await bulkCopyInterface.WriteToServerAsync(rowsForInsert);

                rowsForInsert.Clear();
            }
        }