WebSVN - OpenConcerto - Rev 174 - /trunk/OpenConcerto/src/org/openconcerto/sql/model/SQLRequestLog.java

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
 * 
 * The contents of this file are subject to the terms of the GNU General Public License Version 3
 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each file.
 */
 
 package org.openconcerto.sql.model;

import org.openconcerto.sql.Log;
import org.openconcerto.ui.FontUtils;
import org.openconcerto.utils.ExceptionUtils;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.io.PrintStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Vector;
import java.util.logging.Level;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextArea;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.event.ChangeListener;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableModel;
import javax.swing.table.TableRowSorter;

import net.jcip.annotations.GuardedBy;

public class SQLRequestLog {

    private static final Color BG_PINK = new Color(254, 240, 240);
    private static final String ACTIVER_LA_CAPTURE = "Enable monitoring";
    private static final String DESACTIVER_LA_CAPTURE = "Disable monitoring";
    private static Vector<SQLRequestLog> list = new Vector<SQLRequestLog>(500);
    @GuardedBy("this")
    private static boolean enabled;

    public static synchronized void setEnabled(boolean enable) {
        enabled = enable;
    }

    public static synchronized boolean toggleEnabled() {
        final boolean newVal = !isEnabled();
        setEnabled(newVal);
        return newVal;
    }

    public static synchronized boolean isEnabled() {
        return enabled;
    }

    private String query;
    private String comment;
    private long startAsMs;
    private final long startTime, afterCache, afterQueryInfo, afterExecute, afterHandle, endTime;
    private String stack;
    private boolean inSwing;
    private int connectionId;
    private boolean forShare;
    private String threadId;
    private static List<ChangeListener> listeners = new ArrayList<ChangeListener>(2);
    @GuardedBy("EDT")
    private static JLabel textInfo;
    @GuardedBy("EDT")
    private static final DateFormat sdt = new SimpleDateFormat("HH:mm:ss.SS");
    private static final DecimalFormat dformat = new DecimalFormat("##0.00");

    private boolean isHighlighted = false;
    private int rs_count;

    private static final String format(final Object nano) {
        final long l = ((Number) nano).longValue();
        return l == 0 ? "" : dformat.format(l / 1000000D) + " ms";
    }

    public SQLRequestLog(String query, String comment, int connectionId, long starAtMs, String ex, boolean inSwing, long startTime, long afterCache, long afterQueryInfo, long afterExecute,
            long afterHandle, long endTime, int count) {
        this.query = query;
        this.comment = comment;
        this.connectionId = connectionId;
        this.startAsMs = starAtMs;
        this.startTime = startTime;
        this.afterCache = afterCache;
        this.afterQueryInfo = afterQueryInfo;
        this.afterExecute = afterExecute;
        this.afterHandle = afterHandle;
        this.endTime = endTime;
        this.rs_count = count;
        this.stack = ex;
        this.inSwing = inSwing;
        this.forShare = query.contains("FOR SHARE");
        if (this.forShare) {
            this.comment = "Use FOR SHARE. " + comment;
        }
        this.threadId = "[" + Thread.currentThread().getId() + "] " + Thread.currentThread().getName();
    }

    static long total_count = 0;

    public static void log(String query, String comment, int connectionId, long starAtMs, long startTime, long afterCache, long afterQueryInfo, long afterExecute, long afterHandle, long endTime,
            int count) {

        if (isEnabled()) {
            if (list.size() < 50000) {
                final String ex = ExceptionUtils.getStackTrace(new Exception());

                list.add(new SQLRequestLog(query, comment, connectionId, starAtMs, ex, SwingUtilities.isEventDispatchThread(), startTime, afterCache, afterQueryInfo, afterExecute, afterHandle,
                        endTime, count));
                fireEvent();
            }

        }
        count++;
    }

    public static void log(String query, String comment, long starAtMs, long startTime) {
        log(query, comment, 0, starAtMs, startTime, startTime, startTime, startTime, startTime, startTime, 0);
    }

    public static void log(PreparedStatement pStmt, String comment, long timeMs, long startTime, long afterCache, long afterQueryInfo, long afterExecute, long afterHandle, long endTime) {
        // only call potentially expensive and/or exceptions throwing methods if necessary
        if (isEnabled()) {
            try {
                log(pStmt.toString(), comment, pStmt.getConnection(), timeMs, startTime, afterCache, afterQueryInfo, afterExecute, afterHandle, endTime, 0);
            } catch (Exception e) {
                // never propagate exceptions
                Log.get().log(Level.WARNING, "Couldn't log " + pStmt, e);
            }
        }
    }

    public static void log(String query, String comment, Connection conn, long timeMs, long startTime, long afterCache, long afterQueryInfo, long afterExecute, long afterHandle, long endTime,
            int count) {
        log(query, comment, System.identityHashCode(conn), timeMs, startTime, afterCache, afterQueryInfo, afterExecute, afterHandle, endTime, count);
    }

    private static void fireEvent() {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                int stop = listeners.size();
                for (int i = 0; i < stop; i++) {
                    listeners.get(i).stateChanged(null);
                }
                if (textInfo != null) {
                    final long totalMs = getTotalMs();
                    final long totalSQLMs = getTotalSQLMs();
                    textInfo.setText("Total: " + totalMs + " ms,  Swing: " + getTotalSwing() + " ms, SQL: " + totalSQLMs + " ms, processing: " + (totalMs - totalSQLMs) + " ms , " + getNbConnections()
                            + " conn., " + getNbThread() + " threads. Total: " + list.size() + " / " + total_count);
                }
            }
        });
    }

    protected static int getNbConnections() {
        final Set<Integer> s = new HashSet<Integer>();
        final int stop = list.size();

        for (int i = 0; i < stop; i++) {
            final SQLRequestLog l = list.get(i);
            if (l.getConnectionId() > 0) {
                s.add(l.getConnectionId());
            }

        }
        return s.size();
    }

    protected static int getNbThread() {
        final Set<String> s = new HashSet<String>();
        final int stop = list.size();
        for (int i = 0; i < stop; i++) {
            final SQLRequestLog l = list.get(i);
            s.add(l.getThreadId());
        }
        return s.size();
    }

    protected static long getTotalMs() {
        final int stop = list.size();
        long t = 0;
        for (int i = 0; i < stop; i++) {
            t += (list.get(i).getDurationTotalNano() / 1000);
        }
        return t / 1000;
    }

    protected static long getTotalSQLMs() {
        final int stop = list.size();
        long t = 0;
        for (int i = 0; i < stop; i++) {
            t += (list.get(i).getDurationSQLNano() / 1000);
        }
        return t / 1000;
    }

    protected static long getTotalSwing() {
        final int stop = list.size();
        long t = 0;
        for (int i = 0; i < stop; i++) {

            final SQLRequestLog requestLog = list.get(i);
            if (requestLog.isInSwing()) {
                t += (requestLog.getDurationTotalNano() / 1000);
            }
        }
        return t / 1000;
    }

    public boolean isInSwing() {
        return this.inSwing;
    }

    public static void addChangeListener(ChangeListener l) {
        listeners.add(l);
    }

    public static void showFrame() {
        if (textInfo != null)
            return;

        JFrame f = new JFrame("SQL monitoring");
        final SQLRequestLogModel model = new SQLRequestLogModel();
        final JTable table = new JTable(model);
        table.setRowHeight(FontUtils.getPreferredRowHeight(table));
        final TableRowSorter<TableModel> sorter = new TableRowSorter<>(table.getModel());
        table.setRowSorter(sorter);

        table.getTableHeader().setReorderingAllowed(false);

        table.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                if (e.getClickCount() >= 2) {
                    showStack(model, sorter, table.getSelectedRow());
                }
                highLight(model, sorter, table.getSelectedRow());

            }
        });

        // Column Date
        final TableColumn timeCol = table.getColumnModel().getColumn(0);
        timeCol.setCellRenderer(new DefaultTableCellRenderer() {
            @Override
            protected void setValue(Object value) {
                super.setValue(sdt.format(value));
            }

            public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
                final Component tableCellRendererComponent = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
                final SQLRequestLog rowAt = model.getRowAt(sorter.convertRowIndexToModel(row));
                if (rowAt.isHighlighted) {
                    tableCellRendererComponent.setBackground(Color.black);
                    tableCellRendererComponent.setForeground(Color.white);
                } else {
                    tableCellRendererComponent.setBackground(Color.white);
                    tableCellRendererComponent.setForeground(Color.black);
                }
                return tableCellRendererComponent;
            }
        });
        timeCol.setMaxWidth(80);
        timeCol.setMinWidth(80);

        // SQL
        final DefaultTableCellRenderer cellRendererDurationSQL = new DefaultTableCellRenderer() {
            @Override
            public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
                final Component tableCellRendererComponent = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
                if (!isSelected) {
                    final SQLRequestLog rowAt = model.getRowAt(sorter.convertRowIndexToModel(row));
                    float ratio = 1;
                    // Ignore processing >2ms
                    if (rowAt.getDurationTotalNano() > 0 && (rowAt.getDurationTotalNano() - rowAt.getDurationSQLNano()) > 2000000) {
                        ratio = rowAt.getDurationSQLNano() / (float) rowAt.getDurationTotalNano();
                    }
                    int b = Math.round(255f * (ratio * ratio));
                    if (b < 0)
                        b = 0;
                    if (b > 255)
                        b = 255;
                    tableCellRendererComponent.setBackground(new Color(255, 255, b));
                    tableCellRendererComponent.setForeground(Color.BLACK);
                }
                return tableCellRendererComponent;
            }

            @Override
            protected void setValue(Object value) {
                super.setValue(format(value));
            }
        };
        cellRendererDurationSQL.setHorizontalAlignment(SwingConstants.RIGHT);
        final TableColumn execCol = table.getColumnModel().getColumn(1);
        execCol.setCellRenderer(cellRendererDurationSQL);
        execCol.setMaxWidth(80);
        execCol.setMinWidth(80);

        // Traitement
        final DefaultTableCellRenderer cellRendererTraitement = new DefaultTableCellRenderer() {
            @Override
            public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
                final JLabel tableCellRendererComponent = (JLabel) super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
                if (!isSelected) {
                    final long l = ((Number) value).longValue();
                    if (l > 100 * 1000000) {
                        tableCellRendererComponent.setBackground(new Color(254, 254, 0));
                    } else {
                        tableCellRendererComponent.setBackground(Color.WHITE);
                    }
                    tableCellRendererComponent.setForeground(Color.BLACK);
                }
                return tableCellRendererComponent;
            }

            @Override
            protected void setValue(Object value) {
                super.setValue(format(value));
            }
        };
        cellRendererTraitement.setHorizontalAlignment(SwingConstants.RIGHT);
        final TableColumn processingCol = table.getColumnModel().getColumn(2);
        processingCol.setCellRenderer(cellRendererTraitement);
        processingCol.setMaxWidth(80);
        processingCol.setMinWidth(80);

        // Clean Up
        final DefaultTableCellRenderer nanoRenderer = new DefaultTableCellRenderer() {

            {
                this.setHorizontalAlignment(SwingConstants.RIGHT);
            }

            @Override
            protected void setValue(Object value) {
                super.setValue(format(value));
            }
        };
        final TableColumn cleanupCol = table.getColumnModel().getColumn(3);
        cleanupCol.setCellRenderer(nanoRenderer);
        cleanupCol.setMaxWidth(80);
        cleanupCol.setMinWidth(80);

        // Column Total SQL
        final TableColumn totalCol = table.getColumnModel().getColumn(4);

        totalCol.setCellRenderer(nanoRenderer);
        totalCol.setMaxWidth(80);
        totalCol.setMinWidth(80);

        // Request
        final TableColumn reqCol = table.getColumnModel().getColumn(5);
        final DefaultTableCellRenderer cellRendererQuery = new DefaultTableCellRenderer() {
            @Override
            public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
                final JLabel tableCellRendererComponent = (JLabel) super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
                if (!isSelected) {
                    final SQLRequestLog rowAt = model.getRowAt(sorter.convertRowIndexToModel(row));
                    if (rowAt.isInSwing() && !rowAt.getComment().contains("cache")) {
                        tableCellRendererComponent.setBackground(BG_PINK);
                    } else {
                        tableCellRendererComponent.setBackground(Color.WHITE);
                    }
                    tableCellRendererComponent.setForeground(Color.BLACK);
                }
                return tableCellRendererComponent;
            }
        };
        reqCol.setCellRenderer(cellRendererQuery);
        reqCol.setMinWidth(400);

        // Column Info
        final DefaultTableCellRenderer cellRendererInfo = new DefaultTableCellRenderer() {
            @Override
            public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
                final JLabel tableCellRendererComponent = (JLabel) super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
                if (!isSelected) {
                    if (model.getRowAt(sorter.convertRowIndexToModel(row)).isForShare()) {
                        tableCellRendererComponent.setBackground(new Color(254, 254, 150));
                    } else {
                        tableCellRendererComponent.setBackground(Color.WHITE);
                    }
                    tableCellRendererComponent.setForeground(Color.BLACK);
                }
                return tableCellRendererComponent;
            }
        };
        table.getColumnModel().getColumn(6).setCellRenderer(cellRendererInfo);
        table.getColumnModel().getColumn(6).setMaxWidth(200);
        table.getColumnModel().getColumn(6).setMinWidth(80);
        // Column Connexion

        table.getColumnModel().getColumn(7).setMaxWidth(80);
        table.getColumnModel().getColumn(7).setMinWidth(80);
        // Column Thread
        final DefaultTableCellRenderer cellRendererThread = new DefaultTableCellRenderer() {
            @Override
            public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
                final JLabel tableCellRendererComponent = (JLabel) super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
                if (!isSelected) {
                    if (model.getRowAt(sorter.convertRowIndexToModel(row)).isInSwing()) {
                        tableCellRendererComponent.setBackground(BG_PINK);
                    } else {
                        tableCellRendererComponent.setBackground(Color.WHITE);
                    }
                    tableCellRendererComponent.setForeground(Color.BLACK);
                }
                return tableCellRendererComponent;
            }
        };

        table.getColumnModel().getColumn(8).setCellRenderer(cellRendererThread);
        table.getColumnModel().getColumn(8).setMinWidth(150);
        JPanel p = new JPanel(new BorderLayout());

        JPanel bar = new JPanel(new FlowLayout());

        final JButton b0 = new JButton();
        if (isEnabled()) {
            b0.setText(DESACTIVER_LA_CAPTURE);
        } else {
            b0.setText(ACTIVER_LA_CAPTURE);
        }
        b0.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {                
                if (!toggleEnabled()) {
                    b0.setText(ACTIVER_LA_CAPTURE);
                } else {
                    b0.setText(DESACTIVER_LA_CAPTURE);
                }

            }
        });
        bar.add(b0);
        final JButton b1 = new JButton("Clear");
        b1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                clear();

            }
        });
        bar.add(b1);
        final JButton b2 = new JButton("Show stacktrace");
        b2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                int s = table.getSelectedRow();
                showStack(model, sorter, s);
            }
        });
        bar.add(b2);

        p.add(bar, BorderLayout.NORTH);
        table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
        table.getTableHeader().setReorderingAllowed(true);
        JScrollPane sc = new JScrollPane(table);

        p.add(sc, BorderLayout.CENTER);

        textInfo = new JLabel("Total: ");
        p.add(textInfo, BorderLayout.SOUTH);
        f.setContentPane(p);
        f.setSize(960, 480);
        f.setVisible(true);
        f.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
        f.setVisible(true);
    }

    public static synchronized void clear() {
        list.clear();
        fireEvent();
        total_count = 0;
    }

    public static long getCount() {
        return total_count;
    }

    public static synchronized int getSize() {
        return list.size();
    }

    public static synchronized SQLRequestLog get(int rowIndex) {
        return list.get(rowIndex);
    }

    public String getQuery() {
        return this.query;
    }

    public String getComment() {
        return this.comment;
    }

    public long getStartAsMs() {
        return this.startAsMs;
    }

    public long getDurationTotalNano() {
        return this.getEndTime() - this.getStartTime();
    }

    public long getDurationSQLNano() {
        return this.getAfterExecute() - this.getAfterQueryInfo();
    }

    public long getDurationHandleNano() {
        return this.getAfterHandle() - this.getAfterExecute();
    }

    // close + cache
    public long getDurationCleanupNano() {
        return this.getEndTime() - this.getAfterHandle();
    }

    public final long getStartTime() {
        return this.startTime;
    }

    public final long getAfterCache() {
        return this.afterCache;
    }

    public final long getAfterQueryInfo() {
        return this.afterQueryInfo;
    }

    public final long getAfterExecute() {
        return this.afterExecute;
    }

    public final long getAfterHandle() {
        return this.afterHandle;
    }

    public final long getEndTime() {
        return this.endTime;
    }

    public String getStack() {
        return this.stack;
    }

    public boolean isForShare() {
        return this.forShare;
    }

    public int getResultCount() {
        return rs_count;
    }

    public void printStack() {
        System.err.println("Stacktrace of : " + this.query);
        System.err.println(this.stack);
    }

    public int getConnectionId() {
        return this.connectionId;
    }

    public String getThreadId() {
        return this.threadId;
    }

    private static void showStack(final SQLRequestLogModel model, TableRowSorter<TableModel> sorter, int s) {
        assert SwingUtilities.isEventDispatchThread();
        if (s >= 0 && s < model.getRowCount()) {
            final SQLRequestLog rowAt = model.getRowAt(sorter.convertRowIndexToModel(s));
            rowAt.printStack();
            String text = "Thread: " + rowAt.getThreadId();
            if (rowAt.isInSwing()) {
                text += " (Swing)";
            }
            text += "\nStart: " + sdt.format(rowAt.getStartAsMs()) + "\n";

            text += "Total duration: " + dformat.format(rowAt.getDurationTotalNano() / 1000000D) + " ms, " + dformat.format(rowAt.getDurationSQLNano() / 1000000D) + " ms SQL\n";
            text += rowAt.getQuery() + "\n" + rowAt.getStack();
            JTextArea area = new JTextArea(text);

            area.setFont(area.getFont().deriveFont(12f));
            area.setLineWrap(true);
            JFrame fStack = new JFrame("Stacktrace");
            fStack.setContentPane(new JScrollPane(area));
            fStack.pack();
            fStack.setSize(800, 600);
            fStack.setLocationRelativeTo(null);
            fStack.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
            fStack.setVisible(true);
        }
    }

    protected synchronized static void highLight(SQLRequestLogModel model, TableRowSorter<TableModel> sorter, int s) {
        if (s >= 0 && s < model.getRowCount()) {
            final SQLRequestLog rowAt = model.getRowAt(sorter.convertRowIndexToModel(s));
            String req = rowAt.getQuery();
            for (SQLRequestLog l : list) {
                l.isHighlighted = l.getQuery().equals(req);
            }
            model.fireTableRowsUpdated(0, model.getRowCount() - 1);
        }
    }

    public static void dump(PrintStream out) {
        final DecimalFormat dformat = new DecimalFormat("##0.00");
        for (SQLRequestLog log : list) {
            out.print(dformat.format(log.getDurationTotalNano() / 1000000D) + " ms ");
            out.print("\t");
            out.print(log.getQuery());
            out.println();
        }

    }
}
Dépôt officiel du code source de l'ERP OpenConcerto

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/sql/model/SQLRequestLog.java - Rev 174
