Exemplo n.º 1
0
        public override void ConsumeBuffered(WorkloadEvent evnt)
        {
            if (evnt is MessageWorkloadEvent)
            {
                MessageWorkloadEvent msgEvent = evnt as MessageWorkloadEvent;
                if (msgEvent.MsgType == MessageWorkloadEvent.MessageType.TotalEvents)
                {
                    try
                    {
                        totalEventCount = (long)msgEvent.Value;
                    }
                    catch (Exception e)
                    {
                        logger.Error($"Unable to set the total number of events: {e.Message}");
                    }
                }
            }

            if (!(evnt is ExecutionWorkloadEvent))
            {
                return;
            }

            if (evnt.Type != WorkloadEvent.EventType.RPCCompleted && evnt.Type != WorkloadEvent.EventType.BatchCompleted)
            {
                return;
            }

            eventCount++;
            if ((eventCount > 0) && (eventCount % WorkerStatsCommandCount == 0))
            {
                string percentInfo = (totalEventCount > 0) ? "( " + ((eventCount * 100) / totalEventCount).ToString() + "% )" : "";
                logger.Info($"{eventCount} events queued for replay {percentInfo}");
            }

            if (startTime == DateTime.MinValue)
            {
                startTime = DateTime.Now;
            }

            ExecutionWorkloadEvent evt = (ExecutionWorkloadEvent)evnt;

            ReplayCommand command = new ReplayCommand()
            {
                CommandText     = evt.Text,
                Database        = evt.DatabaseName,
                ApplicationName = evt.ApplicationName,
                ReplayOffset    = evt.ReplayOffset,
                EventSequence   = evt.EventSequence
            };

            int session_id = -1;

            session_id = (int)evt.SPID;

            ReplayWorker rw = null;

            if (ReplayWorkers.TryGetValue(session_id, out rw))
            {
                // Ensure that the buffer does not get too big
                while (rw.QueueLength >= (BufferSize * .9))
                {
                    spin.SpinOnce();
                }
                rw.AppendCommand(command);
            }
            else
            {
                rw = new ReplayWorker()
                {
                    ConnectionInfo        = this.ConnectionInfo,
                    ReplayIntervalSeconds = 0,
                    StopOnError           = false,
                    Name = session_id.ToString(),
                    DisplayWorkerStats      = this.DisplayWorkerStats,
                    ConsumeResults          = this.ConsumeResults,
                    QueryTimeoutSeconds     = this.QueryTimeoutSeconds,
                    WorkerStatsCommandCount = this.WorkerStatsCommandCount,
                    MimicApplicationName    = this.MimicApplicationName,
                    DatabaseMap             = this.DatabaseMap,
                    StartTime         = startTime,
                    FailRetryCount    = this.FailRetryCount,
                    TimeoutRetryCount = this.TimeoutRetryCount
                };
                ReplayWorkers.TryAdd(session_id, rw);
                rw.AppendCommand(command);

                logger.Info($"Worker [{session_id}] - Starting");
            }

            if (runner == null)
            {
                runner = new Thread(new ThreadStart(
                                        delegate
                {
                    try
                    {
                        RunWorkers();
                    }
                    catch (Exception e)
                    {
                        try { logger.Error(e, "Unhandled exception in ReplayConsumer.RunWorkers"); }
                        catch { Console.WriteLine(e.Message); }
                    }
                }
                                        ));
                runner.IsBackground = true;
                runner.Start();
            }


            if (sweeper == null)
            {
                sweeper = new Thread(new ThreadStart(
                                         delegate
                {
                    try
                    {
                        RunSweeper();
                    }
                    catch (Exception e)
                    {
                        try { logger.Error(e, "Unhandled exception in TraceManager.RunSweeper"); }
                        catch { Console.WriteLine(e.Message); }
                    }
                }
                                         ));
                sweeper.IsBackground = true;
                sweeper.Start();
            }
        }
        public override void Initialize()
        {
            connectionString = "Data Source=" + Source + ";Version=3;Read Only=True;Journal Mode=Off;Synchronous=Off;";

            totalEvents = ValidateFile();
            if (totalEvents < 0)
            {
                throw new FormatException($"The input file \"{Source}\" is not a valid workload file");
            }

            totalEventsMessage = new MessageWorkloadEvent()
            {
                MsgType = MessageWorkloadEvent.MessageType.TotalEvents,
                Value   = totalEvents
            };

            // Push Down EventFilters
            string filters = String.Empty;

            string appFilter   = Filter.ApplicationFilter.PushDown();
            string dbFilter    = Filter.DatabaseFilter.PushDown();
            string hostFilter  = Filter.HostFilter.PushDown();
            string loginFilter = Filter.LoginFilter.PushDown();

            if (appFilter != String.Empty)
            {
                filters += ((filters == String.Empty) ? String.Empty : " AND ") + appFilter;
            }
            if (dbFilter != String.Empty)
            {
                filters += ((filters == String.Empty) ? String.Empty : " AND ") + dbFilter;
            }
            if (hostFilter != String.Empty)
            {
                filters += ((filters == String.Empty) ? String.Empty : " AND ") + hostFilter;
            }
            if (loginFilter != String.Empty)
            {
                filters += ((filters == String.Empty) ? String.Empty : " AND ") + loginFilter;
            }

            if (filters != String.Empty)
            {
                filters = "WHERE (" + filters + ") ";

                // these events should not be filtered out
                // 4 - PerformanceCounter
                // 5 - Timeout
                // 6 - WaitStats
                // 7 - Error
                filters += "OR event_type IN (4,5,6,7)";
            }



            try
            {
                string sql = "SELECT * FROM Events " + filters;
                conn = new SQLiteConnection(connectionString);
                conn.Open();
                SQLiteCommand command = new SQLiteCommand(sql, conn);
                reader = command.ExecuteReader();
            }
            catch (Exception e)
            {
                logger.Error(e);
                throw;
            }
        }