public void PollFullTables(ITableauRepoConn connection, ICollection <RepoTable> tables) { if (connection == null) { Log.Error("Missing Tableau Repo connection while polling full tables!"); return; } Log.Info("Polling Tableau repository tables."); tables.Where(t => t.Full) .Select(t => t.Name) .ToList() .ForEach(t => { try { DataTable table = connection.GetTable(t); OutputSerializer.Write(table, true); } catch (InvalidOperationException ioe) { if (ioe.Message.Contains("Connection property has not been initialized")) { // This might also mean that the connection to Tableau is down Log.Warn(ioe, "Temporarily unable to poll full table: '{0}'! Exception: ", t); } else { Log.Error(ioe, "Invalid operation exception while polling full table: '{0}'! Exception: ", t); } } }); }
public void poll(IDictionary <string, ProcessData> processData, bool allProcesses) { var threadInfoTable = ThreadTables.makeThreadInfoTable(); long threadInfoTableCount = 0; ICollection <Process> processList; if (allProcesses) { processList = Process.GetProcesses(); } else { processList = new List <Process>(); foreach (string processName in processData.Keys) { processList.AddRange(Process.GetProcessesByName(processName)); } } pollProcessList(processList, processData, threadInfoTable, ref threadInfoTableCount); if (threadInfoTableCount > 0) { OutputSerializer.Write(threadInfoTable, false); } }
/// <summary> /// Polls the sampler's counters and writes the results to the writer object. /// </summary> /// <param name="stateInfo"></param> private void PollCounters(object stateInfo) { tryStartIndividualPoll(CounterSampler.InProgressLock, PollWaitTimeout, () => { var sampleResults = sampler.SampleAll(); OutputSerializer.Write(sampleResults, false); }); }
/// <summary> /// Helper that writes a serverlogs table to disk as a CSV /// </summary> /// <param name="serverLogsTable"></param> private static void WriteOutServerlogRows(System.Data.DataTable serverLogsTable) { var serverLogsTableCount = serverLogsTable.Rows.Count; if (serverLogsTableCount == 0) { // There is nothing collected. return; } var statusLine = String.Format("{0} server log {1}", serverLogsTableCount, "row".Pluralize(serverLogsTableCount)); Log.Info("Sending off " + statusLine); if (serverLogsTableCount > 0) { OutputSerializer.Write(serverLogsTable, false); } Log.Info("Sent off {0}", statusLine); }
/// <summary> /// Starts up the agent. /// </summary> public void Start() { Log.Info("Initializing PaletteInsightAgent.."); // Assert that runtime options are valid. if (!PaletteInsightAgentOptions.Instance.Valid()) { Log.Fatal("Invalid PaletteInsightAgent options specified!\nAborting.."); return; } // NOTE: License check disabled as this project became open-source //// Check the license every day //var oneDayInMs = 24 * 60 * 60 * 1000; //licenseCheckTimer = new Timer(callback: licenseGuard.PollLicense, state: options.LicenseKey, dueTime: oneDayInMs, period: oneDayInMs); // only start the JMX if we want to if (USE_COUNTERSAMPLES) { ICollection <ICounter> counters; try { counters = CounterConfigLoader.Load(PathToCountersYaml); } catch (ConfigurationErrorsException ex) { Log.Error("Failed to correctly load '{0}': {1}\nAborting..", PathToCountersYaml, ex.Message); return; } // Spin up counter sampler. sampler = new CounterSampler(counters); // Kick off the polling timer. Log.Info("PaletteInsightAgent initialized! Starting performance counter polling.."); counterSampleTimer = new Timer(callback: PollCounters, state: null, dueTime: 0, period: options.PollInterval * 1000); } if (USE_LOGPOLLER) { // Start the log poller agent logPollerAgent.start(); logPollTimer = new Timer(callback: PollLogs, state: null, dueTime: 0, period: options.LogPollInterval * 1000); } if (USE_THREADINFO) { // Kick off the thread polling timer int dueTime = CalculateDueTime(options.ThreadInfoPollInterval); Log.Debug("Due time until the next best timing for thread info poll start: {0} msec", dueTime); threadInfoTimer = new Timer(callback: PollThreadInfo, state: null, dueTime: dueTime, period: options.ThreadInfoPollInterval * 1000); } // send the metadata if there is a tableau repo behind us if (IsConnectionToTableauRepoRequired()) { // On start get the schema of the repository tables var table = tableauRepo.GetSchemaTable(); // Add the metadata of the agent table to the schema table DataTableUtils.AddAgentMetadata(table); // Serialize schema table so that it gets uploaded with all other tables OutputSerializer.Write(table, true); // Do the same for index data table = tableauRepo.GetIndices(); OutputSerializer.Write(table, true); } output = WebserviceOutput.MakeWebservice(options.WebserviceConfig); webserviceTimer = new Timer(callback: UploadData, state: output, dueTime: 0, period: options.UploadInterval * 1000); if (USE_TABLEAU_REPO) { // Poll Tableau repository data as well repoTablesPollTimer = new Timer(callback: PollFullTables, state: output, dueTime: 0, period: options.RepoTablesPollInterval * 1000); } if (USE_STREAMING_TABLES) { streamingTablesPollTimer = new Timer(callback: PollStreamingTables, state: output, dueTime: 0, period: options.StreamingTablesPollInterval * 1000); } }
public void PollStreamingTables(ITableauRepoConn connection, ICollection <RepoTable> tables, IOutput output) { if (connection == null) { Log.Error("Missing Tableau Repo connection while polling streaming tables!"); return; } Log.Info("Polling Tableau Streaming tables."); tables.Where(table => !table.Full) .ToList() .ForEach((table) => { var tableName = table.Name; try { // If we have a pending request for this table, then just skip this iteration if (output.IsInProgress(tableName)) { return; } // Get maxid from remote server var maxId = this.GetMaxId(tableName); // Get data from that max id string newMax; DataTable dataTable = connection.GetStreamingTable(tableName, table, maxId, out newMax); Log.Info("Polled records of streaming table {0} from {1} to {2}", tableName, maxId, newMax); if (dataTable != null) { RepoPollAgent.localMaxId[tableName] = newMax; OutputSerializer.Write(dataTable, false, newMax); } } catch (AggregateException ae) { ae.Handle((x) => { if (x is HttpRequestException || x is TaskCanceledException || x is TemporaryException) { // HttpRequestException is expected on network errors. TaskCanceledException is thrown if the async task (HTTP request) timed out. Log.Warn(x, "Polling streaming table: '{0}' timed out! Exception: ", tableName); return(true); } Log.Error(x, "Async exception caught while polling streaming table: {0}! Exception: ", tableName); return(true); }); } catch (TemporaryException tex) { Log.Warn("Temporarily unable to poll streaming table: {0}! Exception: {1}", tableName, tex); } catch (TaskCanceledException tce) { // This should be only a temporary condition, it is only a problem if it occurs many times in a row. Log.Warn("Polling streaming table: '{0}' timed out! Exception: {1}", tableName, tce); } catch (HttpRequestException hre) { Log.Warn("HTTP request exception while polling streaming table: '{0}'! Exception: {1}", tableName, hre); } catch (Exception e) { if (e is InvalidOperationException && e.Message.Contains("Connection property has not been initialized")) { // This might also mean that the connection to Tableau is down Log.Warn(e, "Temporarily unable to poll streaming table: '{0}'! Exception: ", tableName); return; } Log.Error(e, "Error while polling streaming table: '{0}'! Exception: ", tableName); } }); }