builder_apm 0.2.0

data/app/views/builder_apm/js/_data_fetcher.html.erb

@@ -0,0 +1,254 @@
+<%= render 'builder_apm/js/lzma' %>
+<%= render 'builder_apm/js/compress' %>
+
+<script>
+var allData = null;
+var isAsc = true;
+var current_sort_field = 'start_time';
+
+function fetchDataAndUpdateStorage(onSuccess) {
+  // Get the last request time
+  var cursor = localStorage.getItem('builder_apm_cursor') || "-inf";
+  var limit = 50;
+  
+  // Make an AJAX request to fetch latest data
+  $.get('/builder_apm/request_data?cursor=' + cursor + '&limit=' + limit, function(newData) {
+    
+    newData = newData.map(request => calcDurations(request));
+
+    if(allData != null){
+      processData(allData, null, newData, onSuccess);
+    } else {
+      // Retrieve the stored data from local storage
+      var storedData = localStorage.getItem('builder_apm_requests');
+      if (storedData) {
+        var dataCompressed = decompress(storedData, function(result, error) {
+            processData(JSON.parse(result), error, newData, onSuccess);
+        });
+      } else {
+        processData([], null, newData, onSuccess);
+      }
+    }
+  });
+}
+
+function loadLocalData(onSuccess) {
+  if(allData) {
+    onSuccess(allData);
+  } else {
+    var storedData = localStorage.getItem('builder_apm_requests');
+    if (storedData) {
+      var dataCompressed = decompress(storedData, function(result, error) {
+          processData(JSON.parse(result), error, [], onSuccess);
+      });
+    } else {
+      fetchDataAndUpdateStorage(onSuccess);
+    }
+  }
+}
+
+function processData(storedData, error, newData, onSuccess) {
+
+    // Append the new data to the stored data
+    allData = storedData.concat(newData);
+    try {
+      // Store the updated data back to local storage
+      compress(JSON.stringify(allData), function(result, error) {
+        if(result != null) {
+          localStorage.setItem('builder_apm_requests', result);
+        }
+      });
+
+      // Update the cursor
+      if (newData.length > 0) {
+        var lastRequest = newData[newData.length - 1];
+        cursor = lastRequest.end_time+0.001;
+        localStorage.setItem('builder_apm_cursor', cursor.toString());
+      }
+    } catch(e) {
+        console.error("Error storing data to local storage. Might be out of storage space.", e);
+        alert('not enough local storage')
+    }
+    // Callback function after data fetched and stored
+    console.log(allData);
+    onSuccess(allData);
+}
+
+function loadRequest(request_id) {
+    var requestData = allData.find(function(item) {
+      return item['request_id'] == request_id;
+    });
+
+    return requestData;
+}
+
+function processStack(stack, processSqlEvent) {
+    if(stack == null) {
+      stack = {}
+    }
+    let sqlEvents = stack.sql_events || [];
+    let sqlQueries = sqlEvents.map((event, index) => ({
+        sql: event.sql,
+        triggeringLine: event.triggering_line,
+        index: index
+    }));
+
+    let queriesCount = {};
+    sqlQueries.forEach(queryData => {
+        let table = queryData.sql.match(/FROM ['`"]*([^ '`"]+)['`"]*/i)
+        if (table) {
+            let tableAndLine = `${table[1]}|${queryData.triggeringLine}`;
+            queriesCount[tableAndLine] = queriesCount[tableAndLine] || {count: 0, indices: []};
+            queriesCount[tableAndLine].count += 1;
+            queriesCount[tableAndLine].indices.push(queryData.index);
+        }
+    });
+
+    processSqlEvent(sqlEvents, queriesCount);
+
+    (stack.children || []).forEach(child => processStack(child, processSqlEvent));
+}
+
+function tagQueriesWithNPlusOne(requestInput) {
+    // If requestInput is not an array, convert it into an array
+    const requestArray = Array.isArray(requestInput) ? requestInput : [requestInput];
+
+    requestArray.forEach(requestObject => {
+        // Assume no N+1 issues are found initially
+        requestObject.has_n_plus_one = false;
+
+        processStack(requestObject.stack[0], function(sqlEvents, queriesCount) {
+            // By default, add 'possibleNPlusOne: false' tag to all SQL events
+            sqlEvents.forEach(event => {
+                event.possibleNPlusOne = false;
+            });
+
+            for (let tableAndLine in queriesCount) {
+                if (queriesCount[tableAndLine].count > 1) {
+                    // If any N+1 issue is found, set 'has_n_plus_one' to true
+                    requestObject.has_n_plus_one = true;
+
+                    queriesCount[tableAndLine].indices.forEach(index => {
+                        sqlEvents[index].possibleNPlusOne = true; // Update the tag to true for N+1 issues
+                    });
+                }
+            }
+        });
+    });
+}
+
+function addSortingClick() {
+  // Assuming your table headers have a class name "sortable"
+  $('.sortable').click(function() {
+    current_sort_field = $(this).data('field');  // Assuming data-field attribute contains the name of the field to sort
+    isAsc = !isAsc;
+
+    renderTable(allData);
+    });
+}
+
+function sortDataBy(field, data) {
+    data.sort(function(a, b) {
+    if (a[field] < b[field]) {
+      return isAsc ? -1 : 1;
+    }
+    if (a[field] > b[field]) {
+      return isAsc ? 1 : -1;
+    }
+    return 0;  // equal
+  });
+
+  return data;
+}
+
+function getNPlusOneRequests(requestArray) {
+    let requestsWithIssues = [];
+
+    requestArray.forEach(requestObject => {
+        let hasNPlusOne = false;
+
+        processStack(requestObject.stack[0], function(sqlEvents) {
+            if (sqlEvents.some(event => event.possibleNPlusOne)) {
+                hasNPlusOne = true;
+            }
+        });
+
+        if (hasNPlusOne) {
+            requestsWithIssues.push(requestObject);
+        }
+    });
+
+    return requestsWithIssues;
+}
+function aggregateRequests(requestArray) {
+    let aggregates = {};
+    requestArray.forEach(request => {
+        let key = `${request.controller}#${request.method}|${request.path}`;
+        if (!aggregates[key]) {
+            aggregates[key] = {
+                count: 0,
+                totalDuration: 0,
+                totalDbRuntime: 0,
+                totalViewRuntime: 0,
+                slowestDuration: 0,
+                slowestDbRuntime: 0,
+                slowestViewRuntime: 0
+            };
+        }
+        aggregates[key].count++;
+        aggregates[key].totalDuration += request.duration;
+        aggregates[key].totalDbRuntime += request.db_runtime || 0;
+        aggregates[key].totalViewRuntime += request.view_runtime || 0;
+        aggregates[key].slowestDuration = Math.max(aggregates[key].slowestDuration, request.duration);
+        aggregates[key].slowestDbRuntime = Math.max(aggregates[key].slowestDbRuntime, request.db_runtime || 0);
+        aggregates[key].slowestViewRuntime = Math.max(aggregates[key].slowestViewRuntime, request.view_runtime || 0);
+    });
+
+    let results = [];
+    for (let key in aggregates) {
+        let [controller, path] = key.split('|');
+        results.push({
+            controller,
+            path,
+            count: aggregates[key].count,
+            averageDuration: aggregates[key].totalDuration / aggregates[key].count,
+            averageDbRuntime: aggregates[key].totalDbRuntime / aggregates[key].count,
+            averageViewRuntime: aggregates[key].totalViewRuntime / aggregates[key].count,
+            slowestDuration: aggregates[key].slowestDuration,
+            slowestDbRuntime: aggregates[key].slowestDbRuntime,
+            slowestViewRuntime: aggregates[key].slowestViewRuntime,
+        });
+    }
+    return results;
+}
+
+
+function calcDurations(requestObj) {
+    function iterateStack(stack) {
+        for (let item of stack) {
+            item.calc_duration = item.duration;
+            item.calc_db_runtime = 0;
+            for (let event of item.sql_events) {
+                item.calc_db_runtime += event.duration;
+            }
+            if (item.children.length > 0) {
+                let childrenTotals = iterateStack(item.children);
+                item.calc_duration += childrenTotals.duration;
+                item.calc_db_runtime += childrenTotals.dbRuntime;
+            }
+        }
+        let totalDuration = stack.reduce((acc, curr) => acc + curr.calc_duration, 0);
+        let totalDbRuntime = stack.reduce((acc, curr) => acc + curr.calc_db_runtime, 0);
+        return {duration: totalDuration, dbRuntime: totalDbRuntime};
+    }
+    if(requestObj.stack == null) {
+      requestObj.stack = [];
+    }
+    let totals = iterateStack(requestObj.stack);
+    requestObj.calc_duration = totals.duration;
+    requestObj.calc_db_runtime = totals.dbRuntime;
+    return requestObj;
+}
+
+
+</script>

data/app/views/builder_apm/js/_error_requests.html.erb

@@ -0,0 +1,65 @@
+<script>
+$(document).ready(function() {
+
+    fetchDataAndUpdateStorage(function(updatedData) {
+      renderTable(updatedData);
+    });
+
+    setInterval(function() {
+      var autoUpdate = $('#autoUpdate').is(':checked');
+      if (autoUpdate) {
+        fetchDataAndUpdateStorage(function(updatedData) {
+          renderTable(updatedData);
+        });
+      }
+    }, 5000);
+    
+    addSortingClick();
+  });
+  
+  function renderTable(data, target = null) {
+    data = data.filter(item => item.status === 500);
+    data = sortDataBy(current_sort_field, data);
+
+    // Get a reference to the table body
+    var tableBody = target || $('table tbody');
+  
+    // Clear the table body
+    tableBody.empty();
+  
+    // Create new table rows for each data item
+    data.forEach(function(item) {
+      var row = $('<tr>');
+  
+      $('<td>').text(new Date(item['start_time']).toLocaleString()).appendTo(row);
+      $('<td>').text(item['controller'] + '#' + item['action']).appendTo(row);
+      $('<td>').text(item['status']).appendTo(row);
+      $('<td>').append(item['exception_class']).appendTo(row);
+      $('<td>').append(item['exception_message']).appendTo(row);
+
+      trace_cell = $('<td>');
+      if( item['exception_backtrace']) {
+        for(let i = 0; i < item['exception_backtrace'].length && i < 3; i++) {
+            var lineElement = $('<p>').text(item['exception_backtrace'][i]);
+            trace_cell.append(lineElement);
+        }
+      }
+      trace_cell.appendTo(row);
+
+      // Action column
+      var actionTd = $('<td>');
+      var actionButton = $('<button>').text('Details');
+      actionButton.on('click', function() {
+        // Replace 'your-details-url' with the actual URL where the details are to be fetched.
+        // It's assumed the ID is required as a URL parameter, modify as per your requirements.
+        window.location.href = '<%= request_details_path %>?request_id=' + item['request_id'];
+      });
+      actionButton.appendTo(actionTd);
+      actionTd.appendTo(row);
+
+      // Append the row to the table body
+      tableBody.append(row);
+    });
+  }
+
+  </script>