private static boolean shouldLog(Logger logger, LoggerLevel level) { if (level == LoggerLevel.TRACE && !logger.isTraceEnabled()) { return false; } return level != LoggerLevel.DEBUG || logger.isDebugEnabled(); }
/** * Logs a DEBUG message which is only to be constructed if the logging level * is such that the message will actually be logged. * <p> * DEBUG messages must * be valuable for diagnosing production problems. They must not be used for development debugging. * @param msgSupplier A function, which when called, produces the desired log message * @since 6.3 */ default void debug(Supplier<String> msgSupplier) { if (isDebugEnabled()) { debug(msgSupplier.get()); } }
private static void logPostJobs(Collection<PostJobWrapper> postJobs) { if (LOG.isDebugEnabled()) { LOG.debug(() -> "Post-jobs : " + postJobs.stream().map(Object::toString).collect(Collectors.joining(" -> "))); } } }
private void removeGroups(DbSession dbSession, UserDto userDto, Collection<String> groupsToRemove, Map<String, GroupDto> groupsByName) { Optional<GroupDto> defaultGroup = getDefaultGroup(dbSession); groupsToRemove.stream().map(groupsByName::get) .filter(Objects::nonNull) // user should be member of default group only when organizations are disabled, as the IdentityProvider API doesn't handle yet // organizations .filter(group -> !defaultGroup.isPresent() || !group.getId().equals(defaultGroup.get().getId())) .forEach(groupDto -> { LOGGER.debug("Removing group '{}' from user '{}'", groupDto.getName(), userDto.getLogin()); dbClient.userGroupDao().delete(dbSession, groupDto.getId(), userDto.getId()); }); }
private Optional<Period> resolveVersion(DbSession dbSession, List<EventDto> versions, String propertyValue) { LOG.debug("Resolving new code period by version: {}", propertyValue); Optional<EventDto> version = versions.stream().filter(t -> propertyValue.equals(t.getName())).findFirst(); checkPeriodProperty(version.isPresent(), propertyValue, "version is none of the existing ones: %s", supplierToString(() -> toVersions(versions))); return newPeriod(dbSession, LEAK_PERIOD_MODE_VERSION, version.get()); }
private void printSensors(Collection<ModuleSensorWrapper> moduleSensors, Collection<ModuleSensorWrapper> globalSensors) { String sensors = Stream .concat(moduleSensors.stream(), globalSensors.stream()) .map(Object::toString) .collect(Collectors.joining(" -> ")); LOG.debug("Sensors : {}", sensors); }
private void addGroups(DbSession dbSession, UserDto userDto, Collection<String> groupsToAdd, Map<String, GroupDto> groupsByName) { groupsToAdd.stream().map(groupsByName::get).filter(Objects::nonNull).forEach( groupDto -> { LOGGER.debug("Adding group '{}' to user '{}'", groupDto.getName(), userDto.getLogin()); dbClient.userGroupDao().insert(dbSession, new UserGroupDto().setGroupId(groupDto.getId()).setUserId(userDto.getId())); }); }
public void execute() { List<ProjectSensorWrapper> sensors = selector.selectSensors(); LOG.debug("Sensors : {}", sensors.stream() .map(Object::toString) .collect(Collectors.joining(" -> "))); for (ProjectSensorWrapper sensor : sensors) { String sensorName = getSensorName(sensor); profiler.startInfo("Sensor " + sensorName); sensor.analyse(); profiler.stopInfo(); } }
@Override public void execute(Context context) throws SQLException { List<String> tables = asList("measure_filters", "measure_filter_favourites"); Loggers.get(getClass()).info("Removing tables {}", tables); context.execute(tables .stream() .flatMap(table -> new DropTableBuilder(getDialect(), table).build().stream()) .collect(toList())); } }
private static void log(WebhookDelivery delivery) { Optional<String> error = delivery.getErrorMessage(); if (error.isPresent()) { LOGGER.debug("Failed to send webhook '{}' | url={} | message={}", delivery.getWebhook().getName(), delivery.getWebhook().getUrl(), error.get()); } else { LOGGER.debug("Sent webhook '{}' | url={} | time={}ms | status={}", delivery.getWebhook().getName(), delivery.getWebhook().getUrl(), delivery.getDurationInMs().orElse(-1), delivery.getHttpStatus().orElse(-1)); } }
@Override public void execute(SensorContext context) { Set<String> reportPaths = loadReportPaths(); for (String reportPath : reportPaths) { File reportFile = context.fileSystem().resolvePath(reportPath); LOG.info("Parsing {}", reportFile); GenericCoverageReportParser parser = new GenericCoverageReportParser(); parser.parse(reportFile, context); LOG.info("Imported coverage data for {} files", parser.numberOfMatchedFiles()); int numberOfUnknownFiles = parser.numberOfUnknownFiles(); if (numberOfUnknownFiles > 0) { LOG.info("Coverage data ignored for " + numberOfUnknownFiles + " unknown files, including:\n" + parser.firstUnknownFiles().stream().collect(Collectors.joining("\n"))); } } }
private void insertPermissionForAdministrators(DbSession dbSession, PermissionTemplateDto template) { Optional<GroupDto> admins = dbClient.groupDao().selectByName(dbSession, template.getOrganizationUuid(), DefaultGroups.ADMINISTRATORS); if (admins.isPresent()) { insertGroupPermission(dbSession, template, UserRole.ADMIN, admins.get()); insertGroupPermission(dbSession, template, UserRole.ISSUE_ADMIN, admins.get()); insertGroupPermission(dbSession, template, UserRole.SECURITYHOTSPOT_ADMIN, admins.get()); insertGroupPermission(dbSession, template, OrganizationPermission.APPLICATION_CREATOR.getKey(), admins.get()); insertGroupPermission(dbSession, template, OrganizationPermission.PORTFOLIO_CREATOR.getKey(), admins.get()); } else { LOG.error("Cannot setup default permission for group: " + DefaultGroups.ADMINISTRATORS); } }
private Optional<FileBlocks> toFileBlocks(String componentKey, Collection<Block> fileBlocks) { DefaultInputFile component = (DefaultInputFile) componentStore.getByKey(componentKey); if (component == null) { LOG.error("Resource not found in component store: {}. Skipping CPD computation for it", componentKey); return Optional.empty(); } return Optional.of(new FileBlocks(component, fileBlocks)); }
private static void startLevel4(ComponentContainer level4) { level4.getComponentByType(CECoreExtensionsInstaller.class) .install(level4, hasPlatformLevel4OrNone(), noAdditionalSideFilter()); level4.getComponentByType(ServerExtensionInstaller.class) .installExtensions(level4); level4.startComponents(); PlatformEditionProvider editionProvider = level4.getComponentByType(PlatformEditionProvider.class); Loggers.get(ComputeEngineContainerImpl.class) .info("Running {} edition", editionProvider.get().map(EditionProvider.Edition::getLabel).orElse("")); }
private void logProfiling(long start, Configuration config) { if (config.getBoolean(CoreProperties.PROFILING_LOG_PROPERTY).orElse(false)) { long duration = System.currentTimeMillis() - start; LOG.info("\n -------- Profiling for purge: " + TimeUtils.formatDuration(duration) + " --------\n"); profiler.dump(duration, LOG); LOG.info("\n -------- End of profiling for purge --------\n"); } } }
private Optional<Period> resolveByDate(DbSession dbSession, String projectUuid, Instant date, String propertyValue) { Instant now = Instant.ofEpochMilli(system2.now()); checkPeriodProperty(date.compareTo(now) <= 0, propertyValue, "date is in the future (now: '%s')", supplierToString(() -> logDate(now))); LOG.debug("Resolving new code period by date: {}", supplierToString(() -> logDate(date))); Optional<Period> period = findFirstSnapshot(dbSession, createCommonQuery(projectUuid).setCreatedAfter(date.toEpochMilli()).setSort(BY_DATE, ASC)) .map(dto -> newPeriod(LEAK_PERIOD_MODE_DATE, DateUtils.formatDate(date), dto)); checkPeriodProperty(period.isPresent(), propertyValue, "No analysis found created after date '%s'", supplierToString(() -> logDate(date))); return period; }
public GlobalServerSettings provide(SettingsLoader loader) { if (singleton == null) { Map<String, String> serverSideSettings = loader.loadGlobalSettings(); singleton = new GlobalServerSettings(serverSideSettings); Optional.ofNullable(serverSideSettings.get(CoreProperties.SERVER_ID)).ifPresent(v -> LOG.info("Server id: {}", v)); } return singleton; } }