builder_apm 0.4.2 → 0.5.1

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

@@ -2,274 +2,267 @@
 <%= render 'builder_apm/js/compress' %>
 
 <script>
-var allData = null;
-var isAsc = false;
-var current_sort_field = 'real_start_time';
-var start_time = Date.now();
-var data_gathered_counter = 0;
-var time_cursor = <%= Time.now.to_f * 1000 %>;
-var limit = 500;
-
-function fetchDataAndUpdateStorage(onSuccess) {
-  start_time = Date.now();
-  var initialCursor = time_cursor || start_time;
-  if(allData == null) {
-      allData = [];
-  }
-    // Start fetching data
-    fetchAndProcessData(initialCursor, onSuccess);
-  
-}
-function fetchAndProcessData(cursor, onSuccess) {
-    var type = typeof fetch_type !== 'undefined' ? fetch_type : 'timestamps';
-
-    // Make an AJAX request to fetch latest data
-    $.get('/builder_apm/request_data?cursor=' + cursor + '&limit=' + limit + '&type=' +type, function(newData) {
-      data_gathered_counter++;
-      newData = newData.map(request => calcDurations(request));
-
-      processData(allData, 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 {
-      allData = [];
-      fetchDataAndUpdateStorage(onSuccess);
+    var allData = null;
+    var isAsc = false;
+    var current_sort_field = 'real_start_time';
+    var start_time = Date.now();
+    var data_gathered_counter = 0;
+    var time_cursor = <%= Time.now.to_f * 1000 %>;
+    var limit = 500;
+
+    function fetchDataAndUpdateStorage(onSuccess) {
+        start_time = Date.now();
+        var initialCursor = time_cursor || start_time;
+        if (allData == null) {
+            allData = [];
+        }
+        // Start fetching data
+        fetchAndProcessData(initialCursor, onSuccess);
+
     }
-  }
-}
-
-function processData(storedData, error, newData, onSuccess) {
-
-    // Append the new data to the stored data
-    allData = storedData.concat(newData);
-    try {
-
-      // Update the cursor
-      if (newData.length > 0) {
-        var lastRequest = newData[newData.length - 1];
-        time_cursor = lastRequest.end_time-0.001;
-      }
-    } catch(e) {
-        console.error("Error storing data to local storage. Might be out of storage space.", e);
-        alert('not enough local storage')
+
+    function fetchAndProcessData(cursor, onSuccess) {
+        var type = typeof fetch_type !== 'undefined' ? fetch_type : 'timestamps';
+
+        // Make an AJAX request to fetch latest data
+        $.get('/builder_apm/request_data?cursor=' + cursor + '&limit=' + limit + '&type=' + type, function (newData) {
+            data_gathered_counter++;
+            newData = newData.map(request => calcDurations(request));
+
+            processData(allData, null, newData, onSuccess);
+
+        });
     }
-    // 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 autoFetchDataAndUpdateStorage(onSuccess) {
-    var autoUpdate = $('#autoUpdate').is(':checked');
-    if (autoUpdate) {
-        fetchDataAndUpdateStorage(function(updatedData) {
-            onSuccess(updatedData);
-            // Schedule the next run
-            setTimeout(function() { 
-                autoFetchDataAndUpdateStorage(onSuccess); 
-            }, 5000);
+
+    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 {
+                allData = [];
+                fetchDataAndUpdateStorage(onSuccess);
+            }
+        }
+    }
+
+    function processData(storedData, error, newData, onSuccess) { // Append the new data to the stored data
+        allData = storedData.concat(newData);
+        try { // Update the cursor
+            if (newData.length > 0) {
+                var lastRequest = newData[newData.length - 1];
+                time_cursor = lastRequest.end_time - 0.001;
+            }
+        } 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;
         });
-    } else {
-        // If auto update is not checked, schedule the next check
-        setTimeout(function() { 
-            autoFetchDataAndUpdateStorage(onSuccess); 
-        }, 5000);
+
+        return requestData;
     }
-}
 
-function processStack(stack, processSqlEvent) {
-    if(stack == null) {
-      stack = {}
+    function autoFetchDataAndUpdateStorage(onSuccess) {
+        var autoUpdate = $('#autoUpdate').is(':checked');
+        if (autoUpdate) {
+            fetchDataAndUpdateStorage(function (updatedData) {
+                onSuccess(updatedData);
+                // Schedule the next run
+                setTimeout(function () {
+                    autoFetchDataAndUpdateStorage(onSuccess);
+                }, 5000);
+            });
+        } else { // If auto update is not checked, schedule the next check
+            setTimeout(function () {
+                autoFetchDataAndUpdateStorage(onSuccess);
+            }, 5000);
+        }
     }
-    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);
+
+    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);
+        processSqlEvent(sqlEvents, queriesCount);
 
-    (stack.children || []).forEach(child => processStack(child, processSqlEvent));
-}
+        (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];
+    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;
+        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;
-            });
+            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;
+                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
-                    });
+                        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() {
-    if (current_sort_field == $(this).data('field')) {
-      isAsc = !isAsc;
-    } else {
-      isAsc = false;
     }
-    current_sort_field = $(this).data('field');  // Assuming data-field attribute contains the name of the field to sort
 
-    renderTable(allData);
-    });
-}
+    function addSortingClick() { // Assuming your table headers have a class name "sortable"
+        $('.sortable').click(function () {
+            if (current_sort_field == $(this).data('field')) {
+                isAsc = ! isAsc;
+            } else {
+                isAsc = false;
+            } current_sort_field = $(this).data('field'); // Assuming data-field attribute contains the name of the field to sort
 
-function sortDataBy(field, data) {
-    data.sort(function(a, b) {
-    if (a[field] < b[field]) {
-      return isAsc ? -1 : 1;
+            renderTable(allData);
+        });
     }
-    if (a[field] > b[field]) {
-      return isAsc ? 1 : -1;
+
+    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;
     }
-    return 0;  // equal
-  });
 
-  return data;
-}
+    function getNPlusOneRequests(requestArray) {
+        let requestsWithIssues = [];
 
-function getNPlusOneRequests(requestArray) {
-    let requestsWithIssues = [];
+        requestArray.forEach(requestObject => {
+            let hasNPlusOne = false;
 
-    requestArray.forEach(requestObject => {
-        let hasNPlusOne = false;
+            processStack(requestObject.stack[0], function (sqlEvents) {
+                if (sqlEvents.some(event => event.possibleNPlusOne)) {
+                    hasNPlusOne = true;
+                }
+            });
 
-        processStack(requestObject.stack[0], function(sqlEvents) {
-            if (sqlEvents.some(event => event.possibleNPlusOne)) {
-                hasNPlusOne = true;
+            if (hasNPlusOne) {
+                requestsWithIssues.push(requestObject);
             }
         });
 
-        if (hasNPlusOne) {
-            requestsWithIssues.push(requestObject);
-        }
-    });
-
-    return requestsWithIssues;
-}
-function aggregateRequests(requestArray) {
-    let aggregates = {};
-    requestArray.forEach(request => {
-        let key = `${request.controller_action}`;
-        if (!aggregates[key]) {
-            aggregates[key] = {
-                count: 0,
-                method: request.method,
-                path: request.path,
-                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 = key;
-        results.push({
-            controller,
-            method: aggregates[key].method,
-            path: aggregates[key].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 requestsWithIssues;
     }
-    return results;
-}
+    function aggregateRequests(requestArray) {
+        let aggregates = {};
+        requestArray.forEach(request => {
+            let key = `${
+                request.controller_action
+            }`;
+            if (! aggregates[key]) {
+                aggregates[key] = {
+                    count: 0,
+                    method: request.method,
+                    path: request.path,
+                    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);
+        });
 
-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 results = [];
+        for (let key in aggregates) {
+            let controller = key;
+            results.push({
+                controller,
+                method: aggregates[key].method,
+                path: aggregates[key].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
+            });
         }
-        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 = [];
+        return results;
     }
-    let totals = iterateStack(requestObj.stack);
-    requestObj.calc_duration = totals.duration;
-    requestObj.calc_db_runtime = totals.dbRuntime;
-    return requestObj;
-}
 
 
-</script>
+    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>