# plugin-memory-usage/1.2.9/plugin-memory-usage.js

Plugin Memory Usage, version 1.2.9. 307 lines.

- Page: https://pluginprobe.com/plugins/plugin-memory-usage/1.2.9/code/plugin-memory-usage.js
- Raw: https://pluginprobe.com/plugins/plugin-memory-usage/1.2.9/raw/plugin-memory-usage.js
- Modified: 2026-03-24T21:47:52+00:00

Line numbers below start at 1. Link to a line or a range by appending a fragment to the
page URL, for example `https://pluginprobe.com/plugins/plugin-memory-usage/1.2.9/code/plugin-memory-usage.js#L10-L20`.

```javascript

var pmusage_ajaxurl = pmusageData.pmusage_ajaxurl;
var pmusageNonce = pmusageData.nonce;
var lastMemoryUsage = pmusageData.initialMemoryUsage;


var pluginMemoryUsage = {};

document.addEventListener('DOMContentLoaded', function() {
    var toggleButtons = document.querySelectorAll('.toggle-plugin');
    toggleButtons.forEach(function(button) {
        button.addEventListener('click', function() {
            var plugin = this.dataset.plugin;
            var action = this.dataset.action;
            pmusage_togglePlugin(plugin, action, this);
        });
    });

    document.getElementById('refresh-memory').addEventListener('click', function() {
        pmusage_refreshMemoryUsage(null, null);
    });


    pmusage_displayAllPluginHistory();


});

function pmusage_togglePlugin(plugin, action, button) {
    var xhr = new XMLHttpRequest();
    xhr.open('POST', pmusage_ajaxurl, true);
    xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');

    xhr.onreadystatechange = function() {
        if (xhr.readyState === 4) {
            if (xhr.status === 200) {
                try {
                    var response = JSON.parse(xhr.responseText);
                    if (response.success) {
                        button.textContent = action === 'activate' ? 'Deactivate' : 'Activate';
                        button.dataset.action = action === 'activate' ? 'deactivate' : 'activate';
                        button.closest('li').classList.toggle('plugin-active');
                        button.closest('li').classList.toggle('plugin-inactive');
                        pmusage_refreshMemoryUsage(plugin, action);
						pmusage_updateAverageMemory(plugin); 
                    } else {
                        console.error('Error toggling plugin:', response.data);
                        alert('Error toggling plugin: ' + response.data);
                    }
                } catch (e) {
                    console.error('Error parsing JSON:', e);
                    alert('Error parsing server response');
                }
            } else {
                console.error('AJAX request failed with status:', xhr.status);
                alert('AJAX request failed');
            }
        }
    };

    xhr.send('action=pmusage_toggle_plugin&plugin=' + encodeURIComponent(plugin) + '&toggle_action=' + action + '&nonce=' + pmusageNonce);
}



function pmusage_updateMemoryHistory(plugin, action, memoryDifference) {
    var historyList = document.getElementById('memory-history-list');
    var listItem = document.createElement('li');
    listItem.textContent = pmusage_createMemoryHistoryEntry(plugin, action, memoryDifference);
    historyList.insertBefore(listItem, historyList.firstChild);
}

function pmusage_updatePluginMemoryUsage(plugin, memoryDifference) {
    var absDifference = Math.abs(memoryDifference);
    pluginMemoryUsage[plugin] = (pluginMemoryUsage[plugin] || 0) + absDifference;
    var pluginItem = document.querySelector('.plugin-list li .toggle-plugin[data-plugin="' + plugin + '"]').closest('li');
    var memoryBar = pluginItem.querySelector('.plugin-memory-fill');
    var memoryText = pluginItem.querySelector('.plugin-memory-text');
    var avgMemorySpan = pluginItem.querySelector('.avg-memory');
    var percentage = (absDifference / lastMemoryUsage) * 100;
    percentage = Math.max(0, Math.min(100, percentage)); // Ensure percentage is between 0 and 100
    memoryBar.style.width = percentage + '%';
    memoryText.textContent = pmusage_formatMemoryDifference(absDifference);
    
    // Update average memory
    var avgMemory = pluginMemoryUsage[plugin] / (1024 * 1024); // Convert to MB
    avgMemorySpan.textContent = '(' + avgMemory.toFixed(2) + ' MB)';
}


function pmusage_createMemoryHistoryEntry(pluginName, action, memoryDifference) {
    var timestamp = new Date().toLocaleString();
    if (action === 'increase_memory') {
        return `${timestamp} - Memory limit increased to ${memoryDifference}`;
    } else if (action === 'increase_memory_failed') {
        return `${timestamp} - Failed to increase memory limit: ${memoryDifference}`;
    } else if (action === 'increase_memory_error') {
        return `${timestamp} - Error while trying to increase memory limit: ${memoryDifference}`;
    } else {
        return `${timestamp} - ${pluginName} (${action}): ${pmusage_formatMemoryDifference(memoryDifference)}`;
    }
}

function pmusage_formatMemoryDifference(diffBytes) {
    var absValue = Math.abs(diffBytes);
    var sign = diffBytes >= 0 ? '+' : '-';
    var mbValue = absValue / (1024 * 1024); // Convert to MB
    return `${sign}${mbValue.toFixed(2)} MB`;
}




function pmusage_refreshMemoryUsage(plugin, action) {
    var refreshButton = document.getElementById('refresh-memory');
    refreshButton.textContent = 'Refreshing...';
    refreshButton.disabled = true;

    var xhr = new XMLHttpRequest();
    xhr.open('POST', pmusage_ajaxurl, true);
    xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');

    xhr.onreadystatechange = function() {
        if (xhr.readyState === 4) {
            if (xhr.status === 200) {
                try {
                    var response = JSON.parse(xhr.responseText);
                    if (response.success) {
                        refreshButton.textContent = 'Refresh Memory Usage';
                        refreshButton.disabled = false;

                        document.getElementById('current-memory').textContent = response.data.current_memory;
                        document.getElementById('memory-bar-fill').style.width = response.data.percentage + '%';
                        document.getElementById('memory-percentage').textContent = response.data.percentage + '%';

                        var memoryDifference = response.data.current_memory_bytes - lastMemoryUsage;
                        lastMemoryUsage = response.data.current_memory_bytes;

                        if (plugin && action) {
                            pmusage_updateMemoryHistory(plugin, action, memoryDifference);
                            pmusage_updatePluginMemoryUsage(plugin, memoryDifference);
                            pmusage_fetchAndDisplayPluginHistory(plugin);
							pmusage_updateAverageMemory(plugin);
                        }
						
                    } else {
                        console.error('Error refreshing memory usage:', response.data);
                    }
                } catch (e) {
                    console.error('Error parsing JSON:', e);
                }
            } else {
                console.error('AJAX request failed with status:', xhr.status);
            }
            refreshButton.textContent = 'Refresh Memory Usage';
            refreshButton.disabled = false;
        }
    };

    var data = 'action=pmusage_refresh_memory_usage&nonce=' + pmusageNonce;
    if (plugin && action) {
        data += '&plugin=' + encodeURIComponent(plugin) + '&toggle_action=' + action + '&previous_memory=' + lastMemoryUsage;
    }
    xhr.send(data);
}

function pmusage_fetchAndDisplayPluginHistory(plugin) {
    var xhr = new XMLHttpRequest();
    xhr.open('POST', pmusage_ajaxurl, true);
    xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');

    xhr.onreadystatechange = function() {
        if (xhr.readyState === 4 && xhr.status === 200) {
            var response = JSON.parse(xhr.responseText);
            if (response.success) {
                pmusage_displayPluginHistory(plugin, response.data);
            } else {
                console.error('Error fetching plugin history:', response.data);
            }
        }
    };

    xhr.send('action=pmusage_get_plugin_history&plugin=' + encodeURIComponent(plugin) + '&nonce=' + pmusageNonce);
}



function pmusage_displayPluginHistory(plugin, history) {
    var pluginItem = document.querySelector('.plugin-list li .toggle-plugin[data-plugin="' + plugin + '"]');
    if (!pluginItem) return;
    
    var historyContainer = pluginItem.closest('li').querySelector('.plugin-history-container');

    if (!historyContainer) {
        historyContainer = document.createElement('div');
        historyContainer.className = 'plugin-history-container';
        pluginItem.closest('li').appendChild(historyContainer);
    }

    historyContainer.innerHTML = '';

    history.slice(0, 3).forEach(function(entry, index) {
        var historyBar = document.createElement('div');
        historyBar.className = 'plugin-history-bar';
        var percentage = (Math.abs(entry.memory_change) / lastMemoryUsage) * 100;
        percentage = Math.max(0, Math.min(100, percentage));
        historyBar.style.width = percentage + '%';
        historyBar.style.backgroundColor = pmusage_getHistoryColor(index);
        historyBar.title = pmusage_formatMemoryDifference(entry.memory_change) + ' on ' + entry.timestamp;
        historyContainer.appendChild(historyBar);
    });

    // Ensure the history container is visible
    historyContainer.style.display = 'block';
}





function pmusage_getHistoryColor(index) {
    var colors = ['#4CAF50', '#8BC34A', '#CDDC39'];
    return colors[index] || colors[colors.length - 1];
}


function pmusage_displayAllPluginHistory() {
    var pluginHistory = pmusageData.pluginHistory;
    for (var plugin in pluginHistory) {
        if (pluginHistory.hasOwnProperty(plugin)) {
            pmusage_displayPluginHistory(plugin, pluginHistory[plugin]);
        }
    }
}




function pmusage_updateAverageMemory(plugin) {
    jQuery.ajax({
        url: pmusage_ajaxurl,
        type: 'POST',
        data: {
            action: 'pmusage_update_average_memory',
            plugin_path: plugin,
            nonce: pmusageNonce 
        },
        success: function(response) {
            if (response.success) {
                var avgMemorySpan = jQuery('.plugin-list li .toggle-plugin[data-plugin="' + plugin + '"]')
                    .closest('li')
                    .find('.avg-memory');
                avgMemorySpan.text('(' + response.data.avg_memory + ' MB)');
            } else {
                console.error('Error updating average memory:', response.data);
            }
        },
        error: function(xhr, status, error) {
            console.error('AJAX request failed:', status, error);
        }
    });
}







jQuery(document).ready(function($) {
    $('#increase-memory-limit').on('click', function() {
        $.ajax({
            url: pmusageData.pmusage_ajaxurl,
            type: 'POST',
            data: {
                action: 'pmusage_increase_memory_limit',
                nonce: pmusageData.nonce
            },
            success: function(response) {
                if (response.success) {
                    $('#memory-increase-result').text('Memory limit increased to ' + response.data.new_limit);
                    // Add to memory history
                    pmusage_updateMemoryHistory('System', 'increase_memory', response.data.new_limit);
                    // Refresh the memory usage display
                   
                    // Refresh the page after a short delay
                    setTimeout(function() {
                        location.reload();
                    }, 2500);


                } else {
                    $('#memory-increase-result').text('Failed to increase memory limit: ' + response.data.message);
                    // Add failure to memory history
                    pmusage_updateMemoryHistory('System', 'increase_memory_failed', response.data.message);
                }
            },
            error: function(xhr, status, error) {
                console.error('AJAX request failed:', status, error);
                // Add error to memory history
                pmusage_updateMemoryHistory('System', 'increase_memory_error', 'AJAX request failed');
            }
        });
    });
});


```