public static void logTable(List<String> columns, List<Object[]> rows, LoggerLevel level, Logger logger) { logTable(columns, rows, level, logger, false); }
public static final String getPassword(String username, String password) { return getPassword(username, password, DEFAULT_OBSCURER); }
public static final void logMsg(String msg, Logger logger, LoggerLevel level) { logMsg(msg, null, logger, level); }
public static String getTable(LogTableContext context) { Assert.notNull(context, "context is null"); Assert.notNull(context.getColumns(), "columns is null"); Assert.notNull(context.getRows(), "rows is null"); int[] padding = getPadding(context.getColumns(), context.getRows()); int cols = context.getColumns().size(); int rows = context.getRows().size(); String header = getHeader(context.getColumns(), padding, context.isLeftAlign()); updateArgsList(context.getRows(), padding, context.isLeftAlign()); Properties properties = getProperties(context.getRows()); String tableString = getTableString(rows, cols); String resolved = HELPER.replacePlaceholders(tableString, properties); return header + "\n" + resolved; }
@Override public void execute() { if (skip) { logger.info("Skipping execution"); return; } Assert.notNull(service, "service is null"); Assert.notNull(context, "context is null"); Assert.notNull(dataSource, "dataSource is null"); logger.info("------------------------------------------------------------------------"); logger.info("JDBC Configuration"); logger.info("------------------------------------------------------------------------"); logger.info("Vendor - {}", context.getVendor()); logger.info("URL - {}", context.getUrl()); logger.info("Schema - {}", context.getSchema()); logger.info("User - {}", LoggerUtils.getUsername(context.getUsername())); logger.info("Password - {}", LoggerUtils.getPassword(context.getUsername(), context.getPassword())); logger.info("DBA URL - {}", context.getDbaUrl()); logger.info("DBA User - {}", LoggerUtils.getUsername(context.getDbaUsername())); logger.info("DBA Password - {}", LoggerUtils.getPassword(context.getDbaUsername(), context.getDbaPassword())); logger.info("Driver - {}", context.getDriver()); logger.info("SQL Encoding - {}", context.getEncoding()); // Establish a connection to the db to extract more detailed info JdbcMetaData metadata = service.getJdbcMetaData(dataSource); logger.info("Product Name - {}", metadata.getDatabaseProductName()); logger.info("Product Version - {}", metadata.getDatabaseProductVersion()); logger.info("Driver Name - {}", metadata.getDriverName()); logger.info("Driver Version - {}", metadata.getDriverVersion()); logger.info("------------------------------------------------------------------------"); }
public static void logTable(LogTableContext context) { String table = getTable(context); Assert.notNull(context.getLogger(), "logger is null"); Assert.notNull(context.getLevel(), "level is null"); String msg = context.getTitle() + "\n\n" + table; logMsg(msg, context.getLogger(), context.getLevel()); }
protected void logCopy() { String path = FileSystemUtils.getRelativePathQuietly(relativeDir, dstDir); Object[] args = { path, org.kuali.common.util.LoggerUtils.getLogMsg(includes, excludes) }; logger.debug("srcDir - [{}]", LocationUtils.getCanonicalPath(srcDir)); logger.info("Copying to - [{}] - {}", args); }
protected static String getTableString(int rows, int cols) { StringBuilder sb = new StringBuilder(); for (int row = 0; row < rows; row++) { for (int col = 0; col < cols; col++) { sb.append("${" + getPropertyKey(row, col) + "}"); } sb.append("\n"); } return sb.toString(); }
public static final String getUsername(String username) { return getNullAsNone(username); }
@Override public void execute() { if (skip) { logger.info("Skipping execution"); return; } Assert.notNull(service, "service is null"); Assert.notNull(context, "context is null"); Assert.notNull(dataSource, "dataSource is null"); logger.info("------------------------------------------------------------------------"); logger.info("JDBC Configuration"); logger.info("------------------------------------------------------------------------"); logger.info("Vendor - {}", context.getVendor()); logger.info("URL - {}", context.getUrl()); logger.info("Schema - {}", context.getSchema()); logger.info("User - {}", LoggerUtils.getUsername(context.getUsername())); logger.info("Password - {}", LoggerUtils.getPassword(context.getUsername(), context.getPassword())); logger.info("Driver - {}", context.getDriver()); logger.info("SQL Encoding - {}", context.getEncoding()); // Establish a connection to the db to extract more detailed info JdbcMetaData metadata = service.getJdbcMetaData(dataSource); logger.info("Product Name - {}", metadata.getDatabaseProductName()); logger.info("Product Version - {}", metadata.getDatabaseProductVersion()); logger.info("Driver Name - {}", metadata.getDriverName()); logger.info("Driver Version - {}", metadata.getDriverVersion()); logger.info("------------------------------------------------------------------------"); }
public static String getLogMsg(StringFilter filter) { Assert.notNull(filter, "filter is null"); return getLogMsg(filter.getIncludes(), filter.getExcludes()); }
protected static Properties getProperties(List<Object[]> rows) { Properties properties = new Properties(); for (int row = 0; row < rows.size(); row++) { Object[] rowData = rows.get(row); for (int col = 0; col < rowData.length; col++) { String key = getPropertyKey(row, col); StringBuilder sb = new StringBuilder(); if (col == 0) { sb.append("|| "); } else { sb.append("| "); } sb.append(rowData[col] + ""); if (col == rowData.length - 1) { sb.append(" ||"); } else { sb.append(" |"); } properties.setProperty(key, sb.toString()); } } return properties; }
protected void log() { if (!StringUtils.equals(org.kuali.common.util.EncryptionMode.NONE.name(), encryptionMode)) { logger.info("Encryption mode - " + StringUtils.trimToEmpty(encryptionMode)); logger.info("Encryption strength - " + StringUtils.trimToEmpty(encryptionStrength)); String displayPassword = org.kuali.common.util.LoggerUtils.getNullAsNone(encryptionPassword); if (encryptionPassword != null) { displayPassword = obscurer.obscure(encryptionPassword); } logger.info("Encryption password - " + displayPassword); } if (!StringUtils.equals(PropertyStyle.NORMAL.name(), style)) { logger.info("Property style - " + StringUtils.trimToEmpty(style)); } if (!StringUtils.isEmpty(prefix)) { logger.info("Property prefix - " + StringUtils.trimToEmpty(prefix)); } if (!StringUtils.equals(Boolean.toString(Constants.DEFAULT_RESOLVE_PLACEHOLDERS), resolvePlaceholders)) { logger.info("Resolve placeholders - " + resolvePlaceholders); } }
public static void logTable(List<String> columns, List<Object[]> rows) { LogTableContext context = new LogTableContext(columns, rows); logTable(context); }
public static void logLines(String s, Logger logger, LoggerLevel level) { if (s == null) { return; } String[] lines = StringUtils.split(s, "\n"); for (String line : lines) { LoggerUtils.logMsg(line, logger, level); } }
@Override public void bucketsCreated(BucketEvent event) { List<SqlBucket> buckets = event.getBuckets(); List<Object[]> argsList = new ArrayList<Object[]>(); for (int i = 0; i < buckets.size(); i++) { SqlBucket bucket = buckets.get(i); List<SqlSupplier> suppliers = bucket.getSuppliers(); String count = FormatUtils.getCount(JdbcUtils.getSqlCount(suppliers)); String srcs = FormatUtils.getCount(suppliers.size()); String size = FormatUtils.getSize(JdbcUtils.getSqlSize(suppliers)); Object[] args = { i + 1, count, srcs, size }; argsList.add(args); } List<String> columns = Arrays.asList("Bucket", "SQL Count", "Sources", "Size"); LoggerUtils.logTable(columns, argsList, level, logger); }
@Override public void beforeExecuteSql(SqlEvent event) { switch (mode) { case BEFORE: case BOTH: String sql = getSql(event.getSql(), flatten); LoggerUtils.logMsg(sql, logger, level); return; case AFTER: return; default: throw new IllegalArgumentException("Mode [" + mode + "] is unknown"); } }
public static void logTable(Schema schema, String title) { Assert.notNull(schema, "schema is null"); List<String> columns = Arrays.asList("type", "name"); List<Object[]> rows = new ArrayList<Object[]>(); for (Table table : CollectionUtils.toEmptyList(schema.getTables())) { rows.add(new Object[] { "table", table.getName() }); } for (Sequence sequence : CollectionUtils.toEmptyList(schema.getSequences())) { rows.add(new Object[] { "sequence", sequence.getName() }); } for (View view : CollectionUtils.toEmptyList(schema.getViews())) { rows.add(new Object[] { "view", view.getName() }); } for (ForeignKey foreignKey : CollectionUtils.toEmptyList(schema.getForeignKeys())) { rows.add(new Object[] { "foreign key", foreignKey.getName() }); } if (!CollectionUtils.isEmpty(rows)) { LogTableContext context = new LogTableContext(title, columns, rows, logger); LoggerUtils.logTable(context); } }
@Override public void afterExecuteSql(SqlEvent event) { switch (mode) { case BEFORE: return; case BOTH: case AFTER: String sql = getSql(event.getSql(), flatten); String elapsed = FormatUtils.getTime(event.getStopTimeMillis() - event.getStartTimeMillis()); Object[] args = { sql, elapsed }; LoggerUtils.logMsg("{} - {}", args, logger, level); return; default: throw new IllegalArgumentException("Mode [" + mode + "] is unknown"); } }
public static void logTable(List<String> columns, List<Object[]> rows, LoggerLevel level, Logger logger, boolean leftAlign) { LogTableContext context = new LogTableContext(); context.setColumns(columns); context.setRows(rows); context.setLevel(level); context.setLogger(logger); context.setLeftAlign(leftAlign); logTable(context); }