Url-Shortener – Redirect-Statistiken – Teil 2

package com.svenruppert.urlshortener.ui.vaadin.views.statistics;

/**
* Statistics overview view showing all shortcodes with their redirect counts.
* Uses SearchBar for filtering and StatisticsToolbar for date range/granularity.
*/

@PageTitle("Statistics")
@Route(value = StatisticsView.PATH, layout = MainLayout.class)
@CssImport("./styles/statistics-view.css")
public class StatisticsView
    extends VerticalLayout
    implements HasLogger, I18nSupport {
  public static final String PATH = "statistics";
  private static final String C_ROOT = "statistics-view";
  private static final String C_GRID = "statistics-view__grid";
  private static final String C_URL_ANCHOR = "statistics-view__url";
  private static final String C_SHORTCODE = "statistics-view__shortcode";
  private static final String C_COUNT = "statistics-view__count";
  private static final String C_PAGING_BAR = "statistics-view__pagingbar";
  // i18n keys
  private static final String K_TITLE = "statistics.title";
  private static final String K_COL_SHORTCODE = "statistics.grid.column.shortcode";
  private static final String K_COL_URL = "statistics.grid.column.url";
  private static final String K_COL_COUNT = "statistics.grid.column.count";
  private static final String K_COL_ACTIONS = "statistics.grid.column.actions";
  private static final String K_PAGING_PREV = "statistics.paging.prev";
  private static final String K_PAGING_NEXT = "statistics.paging.next";
  private static final String K_DETAILS_TOOLTIP = "statistics.details.tooltip";
  private final URLShortenerClient urlShortenerClient = UrlShortenerClientFactory.newInstance();
  private final StatisticsClient statisticsClient = StatisticsClientFactory.newInstance();
  private final SearchBar searchBar = new SearchBar();
  private final StatisticsToolbar statisticsToolbar = new StatisticsToolbar();
  private final Grid<ShortUrlMappingWithCount> grid = new Grid<>();
  private final Button prevBtn = new Button();
  private final Button nextBtn = new Button();
  private final Text pageInfo = new Text("");
  private int currentPage = 1;
  private int totalCount = 0;
  public StatisticsView() {
    addClassName(C_ROOT);
    setSizeFull();
    setPadding(true);
    setSpacing(true);
    add(new H2(tr(K_TITLE, "Statistics")));
    configureSearchBar();
    configureStatisticsToolbar();
    configureGrid();
    configurePagingBar();
    applyI18n();
    add(searchBar, statisticsToolbar, grid, buildPagingBar());
    // Initial data load
    loadData();
  }
  // ...
}

package com.svenruppert.urlshortener.ui.vaadin.tools;
public class StatisticsClientFactory {
  private StatisticsClientFactory() {
  }
  public static StatisticsClient newInstance() {
    return new StatisticsClient();
  }
}

private void configureSearchBar() {
  // Configure callbacks
  searchBar.setOnFilterChange(_ -> {
    currentPage = 1;
    loadData();
  });
  searchBar.setOnPageSizeChange(_ -> {
    currentPage = 1;
    loadData();
  });
  searchBar.setOnReset(_ -> {
    currentPage = 1;
    statisticsToolbar.resetToDefaults();
    loadData();
  });
  // Set default page size
  searchBar.setPageSize(25);
}

package com.svenruppert.urlshortener.ui.vaadin.views.statistics;

/**
* Toolbar for statistics-specific controls: date range and aggregation granularity.
* Designed to be used below the SearchBar in statistics views.
*/
@CssImport("./styles/statistics-toolbar.css")
public class StatisticsToolbar
    extends Composite<HorizontalLayout>
    implements HasLogger, I18nSupport {
  private static final String C_ROOT = "statistics-toolbar";
  private static final String C_DATE_RANGE = "statistics-toolbar__date-range";
  private static final String C_GRANULARITY = "statistics-toolbar__granularity";
  private static final int DEFAULT_HOT_WINDOW_DAYS = 7;
  // i18n keys
  private static final String K_FROM_LABEL = "statistics.toolbar.from.label";
  private static final String K_TO_LABEL = "statistics.toolbar.to.label";
  private static final String K_GRANULARITY_LABEL = "statistics.toolbar.granularity.label";
  private static final String K_GRANULARITY_HOUR = "statistics.toolbar.granularity.hour";
  private static final String K_GRANULARITY_DAY = "statistics.toolbar.granularity.day";
  private static final String K_GRANULARITY_WEEK = "statistics.toolbar.granularity.week";
  private static final String K_GRANULARITY_MONTH = "statistics.toolbar.granularity.month";
  private final DatePicker fromDate = new DatePicker();
  private final DatePicker toDate = new DatePicker();
  private final Select<AggregationGranularity> granularity = new Select<>();
  private int hotWindowDays = DEFAULT_HOT_WINDOW_DAYS;
  private Consumer<Void> onFilterChange;
  public StatisticsToolbar() {
    container().addClassName(C_ROOT);
    container().setWidthFull();
    container().setSpacing(true);
    container().setAlignItems(FlexComponent.Alignment.END);
    buildComponents();
    applyI18n();
    addListeners();
    setDefaultValues();
  }
  private HorizontalLayout container() {
    return getContent();
  }
  private void buildComponents() {
    fromDate.addClassName(C_DATE_RANGE);
    fromDate.setClearButtonVisible(true);
    toDate.addClassName(C_DATE_RANGE);
    toDate.setClearButtonVisible(true);
    granularity.addClassName(C_GRANULARITY);
    granularity.setItems(AggregationGranularity.values());
    granularity.setItemLabelGenerator(this::translateGranularity);
    granularity.setEmptySelectionAllowed(false);
    container().add(fromDate, toDate, granularity);
  }
  // ...
}

private void updateHourlyAvailability() {
  LocalDate from = fromDate.getValue();
  LocalDate to = toDate.getValue();
  LocalDate hotWindowStart = LocalDate.now().minusDays(hotWindowDays);
  // Hour granularity is only available if the entire range is within the hot window
  final boolean hourlyAvailable =
      (from == null || !from.isBefore(hotWindowStart))
          && (to == null || !to.isBefore(hotWindowStart));
  // If hourly is currently selected but not available, switch to day
  if (!hourlyAvailable && granularity.getValue() == AggregationGranularity.HOUR) {
    granularity.setValue(AggregationGranularity.DAY);
  }
  granularity.setItemEnabledProvider(
      g -> g != AggregationGranularity.HOUR || hourlyAvailable
  );
}

package com.svenruppert.urlshortener.ui.vaadin.tools;
public interface I18nSupport {
  default String tr(String key) {
    return ((Component) this).getTranslation(key);
  }
  default String tr(String key, String fallback) {
    final String translated = ((Component) this).getTranslation(key);
    if (translated == null || translated.isBlank() || translated.equals(key)) {
      return fallback;
    }
    return translated;
  }
  default String tr(String key, String fallback, Object... params) {
    final String translated = ((Component) this).getTranslation(key, params);
    if (translated == null || translated.isBlank() || translated.equals(key)) {
      // fallback uses the same placeholder style as Vaadin (MessageFormat)
      return java.text.MessageFormat.format(fallback, params);
    }
    return translated;
  }
}

# Statistics Toolbar
statistics.toolbar.from.label=Von
statistics.toolbar.to.label=Bis
statistics.toolbar.granularity.label=Granularität
statistics.toolbar.granularity.hour=Stunde
statistics.toolbar.granularity.day=Tag
statistics.toolbar.granularity.week=Woche
statistics.toolbar.granularity.month=Monat

private void applyI18n() {
  fromDate.setLabel(tr(K_FROM_LABEL, "From"));
  toDate.setLabel(tr(K_TO_LABEL, "To"));
  granularity.setLabel(tr(K_GRANULARITY_LABEL, "Granularity"));
}
private String translateGranularity(AggregationGranularity g) {
  return switch (g) {
    case HOUR -> tr(K_GRANULARITY_HOUR, "Hour");
    case DAY -> tr(K_GRANULARITY_DAY, "Day");
    case WEEK -> tr(K_GRANULARITY_WEEK, "Week");
    case MONTH -> tr(K_GRANULARITY_MONTH, "Month");
  };
}

package com.svenruppert.urlshortener.ui.vaadin.views.statistics;
/**
* Defines the granularity for statistics aggregation.
*/
public enum AggregationGranularity {
  HOUR("hour"),
  DAY("day"),
  WEEK("week"),
  MONTH("month");
  private final String key;
  AggregationGranularity(String key) {
    this.key = key;
  }
  public String getKey() {
    return key;
  }
}

private void configureGrid() {
  grid.addClassName(C_GRID);
  grid.addThemeVariants(GridVariant.LUMO_ROW_STRIPES);
  grid.setSelectionMode(Grid.SelectionMode.NONE);
  // Shortcode column
  grid.addComponentColumn(item -> {
    Span code = new Span(item.mapping().shortCode());
    code.addClassName(C_SHORTCODE);
    return code;
  }).setKey("shortcode").setAutoWidth(true).setFlexGrow(0).setSortable(true);
  // URL column
  grid.addComponentColumn(item -> {
    Anchor a = new Anchor(item.mapping().originalUrl(), item.mapping().originalUrl());
    a.addClassName(C_URL_ANCHOR);
    a.setTarget("_blank");
    a.getElement().setProperty("title", item.mapping().originalUrl());
    return a;
  }).setKey("url").setFlexGrow(1);
  // Count column
  grid.addComponentColumn(item -> {
    Span count = new Span(String.valueOf(item.count()));
    count.addClassName(C_COUNT);
    return count;
  }).setKey("count").setAutoWidth(true).setFlexGrow(0).setSortable(true);
  // Actions column (detail link)
  grid.addComponentColumn(item -> {
    Button detailBtn = new Button(new Icon(VaadinIcon.CHART));
    detailBtn.addThemeVariants(ButtonVariant.LUMO_TERTIARY_INLINE);
    detailBtn.getElement().setProperty("title", tr(K_DETAILS_TOOLTIP, "View details"));
    detailBtn.addClickListener(_ ->
                                   detailBtn.getUI()
                                       .ifPresent(ui ->
                                                      ui.navigate(StatisticsDetailView.class,
                                                                 item.mapping().shortCode())
                                       )
    );
    return detailBtn;
  }).setKey("actions").setAutoWidth(true).setFlexGrow(0);
}

private List<ShortUrlMappingWithCount> enrichWithCounts(List<ShortUrlMapping> mappings) {
  LocalDate from = statisticsToolbar.getFromDate();
  LocalDate to = statisticsToolbar.getToDate();
  return mappings.stream()
      .map(mapping -> {
        long count = 0;
        try {
          if (from != null && to != null) {
            StatisticsCountResponse response = statisticsClient.getCountForDateRange(
                mapping.shortCode(), from, to
            );
            count = response != null ? response.count() : 0;
          } else {
            StatisticsCountResponse response = statisticsClient.getTotalCount(mapping.shortCode());
            count = response != null ? response.count() : 0;
          }
        } catch (IOException ex) {
          logger().warn("Failed to get count for {}: {}", mapping.shortCode(), ex.getMessage());
        }
        return new ShortUrlMappingWithCount(mapping, count);
      })
      .toList();
}
/**
* Record combining a ShortUrlMapping with its redirect count.
*/
public record ShortUrlMappingWithCount(ShortUrlMapping mapping, long count) {
}

package com.svenruppert.urlshortener.ui.vaadin.views.statistics;
/**
* Detail view showing statistics for a specific shortcode.
* Uses StatisticsToolbar for date range and granularity controls.
*/
@PageTitle("Statistics Detail")
@Route(value = StatisticsDetailView.PATH, layout = MainLayout.class)
@CssImport("./styles/statistics-detail-view.css")
public class StatisticsDetailView
    extends VerticalLayout
    implements HasUrlParameter<String>, HasLogger, I18nSupport {
  public static final String PATH = "statisticDetails";
  // ...
  @Override
  public void setParameter(BeforeEvent event, @OptionalParameter String parameter) {
    if (parameter == null || parameter.isBlank()) {
      Notifications.errorKey(K_NOT_FOUND, "No shortcode specified");
      event.forwardTo(StatisticsView.class);
      return;
    }
    this.shortCode = parameter;
    loadMappingInfo();
    loadData();
  }
  // ...
}

private void loadData() {
  if (shortCode == null) return;
  LocalDate from = statisticsToolbar.getFromDate();
  LocalDate to = statisticsToolbar.getToDate();
  AggregationGranularity granularity = statisticsToolbar.getGranularity();
  // Load total count for the selected period
  loadTotalCount(from, to);
  // Load aggregated data based on granularity
  List<AggregateRow> rows = switch (granularity) {
    case HOUR -> loadHourlyData(from, to);
    case DAY -> loadDailyData(from, to);
    case WEEK -> loadWeeklyData(from, to);
    case MONTH -> loadMonthlyData(from, to);
  };
  grid.setItems(rows);
}

private List<AggregateRow> loadDailyData(LocalDate from, LocalDate to) {
  List<AggregateRow> rows = new ArrayList<>();
  try {
    StatisticsTimelineResponse timeline = statisticsClient.getTimeline(
        shortCode,
        from != null ? from : LocalDate.now().minusDays(30),
        to != null ? to : LocalDate.now()
    );
    if (timeline != null && timeline.dailyCounts() != null) {
      for (var dailyCount : timeline.dailyCounts()) {
        String label = dailyCount.date().format(DATE_FMT);
        rows.add(new AggregateRow(label, dailyCount.count()));
      }
    }
  } catch (IOException ex) {
    logger().error("Failed to load daily data for {}", shortCode, ex);
  }
  return rows;
}

private List<AggregateRow> loadWeeklyData(LocalDate from, LocalDate to) {
  List<AggregateRow> dailyRows = loadDailyData(from, to);
  Map<String, Long> weeklyAggregates = new LinkedHashMap<>();
  WeekFields weekFields = WeekFields.of(Locale.getDefault());
  for (AggregateRow row : dailyRows) {
    LocalDate date = LocalDate.parse(row.periodLabel(), DATE_FMT);
    int year = date.getYear();
    int week = date.get(weekFields.weekOfWeekBasedYear());
    String weekLabel = year + "-W" + String.format("%02d", week);
    weeklyAggregates.merge(weekLabel, row.count(), Long::sum);
  }
  return weeklyAggregates.entrySet().stream()
      .map(e -> new AggregateRow(e.getKey(), e.getValue()))
      .toList();
}
private List<AggregateRow> loadMonthlyData(LocalDate from, LocalDate to) {
  List<AggregateRow> dailyRows = loadDailyData(from, to);
  Map<String, Long> monthlyAggregates = new LinkedHashMap<>();
  for (AggregateRow row : dailyRows) {
    LocalDate date = LocalDate.parse(row.periodLabel(), DATE_FMT);
    String monthLabel = date.getYear() + "-" + String.format("%02d", date.getMonthValue());
    monthlyAggregates.merge(monthLabel, row.count(), Long::sum);
  }
  return monthlyAggregates.entrySet().stream()
      .map(e -> new AggregateRow(e.getKey(), e.getValue()))
      .toList();
}

private List<AggregateRow> loadHourlyData(LocalDate from, LocalDate to) {
  List<AggregateRow> rows = new ArrayList<>();
  try {
    LocalDate current = from != null ? from : LocalDate.now().minusDays(7);
    LocalDate end = to != null ? to : LocalDate.now();
    while (!current.isAfter(end)) {
      Optional<HourlyStatisticsResponse> hourlyOpt =
          statisticsClient.getHourlyStatistics(shortCode, current);
      if (hourlyOpt.isPresent()) {
        HourlyStatisticsResponse hourly = hourlyOpt.get();
        long[] counts = hourly.hourlyCounts();
        for (int hour = 0; hour < 24; hour++) {
          if (counts[hour] > 0) {
            String label = current.format(DATE_FMT) + " " + String.format("%02d:00", hour);
            rows.add(new AggregateRow(label, counts[hour]));
          }
        }
      }
      current = current.plusDays(1);
    }
  } catch (IOException ex) {
    logger().error("Failed to load hourly data for {}", shortCode, ex);
  }
  return rows;
}

/**
* Record representing a single row in the aggregates table.
*/
public record AggregateRow(String periodLabel, long count) {
}

@Override
public void handle(HttpExchange exchange)
    throws IOException {
  if (!RequestMethodUtils.requireGet(exchange)) return;
  final String path = exchange.getRequestURI().getPath();
  if (path == null || !path.startsWith(PATH_REDIRECT)) {
    exchange.sendResponseHeaders(400, -1);
    return;
  }
  final String code = path.substring((PATH_REDIRECT).length());
  if (code.isBlank()) {
    exchange.sendResponseHeaders(400, -1);
    return;
  }
  logger().info("Looking for short code {}", code);
  var mappingOpt = store.findByShortCode(code);
  if (mappingOpt.isEmpty()) {
    logger().info("No mapping found for short code {}", code);
    exchange.sendResponseHeaders(404, -1);
    return;
  }
  var mapping = mappingOpt.get();
  if (isExpired(mapping)) {
    logger().info("Short code {} is expired at {}", code, mapping.expiresAt().orElse(null));
    exchange.sendResponseHeaders(410, -1);
    return;
  }
  if (!mapping.active()) {
    logger().info("Short code {} is inactive", code);
    exchange.sendResponseHeaders(404, -1);
    return;
  }
  // Record the redirect event (non-blocking)
  recordRedirectEvent(exchange, code);
  exchange.getResponseHeaders().add("Location", mapping.originalUrl());
  exchange.sendResponseHeaders(302, -1);
}

private void recordRedirectEvent(HttpExchange exchange, String shortCode) {
  if (statisticsWriter == null) {
    return;
  }
  try {
    var event = requestDataExtractor.extractEvent(exchange, shortCode);
    statisticsWriter.recordEvent(event);
    logger().debug("Recorded redirect event for shortCode={}", shortCode);
  } catch (Exception e) {
    logger().warn("Failed to record redirect event for shortCode={}", shortCode, e);
  }
}

package com.svenruppert.urlshortener.api.store.statistics;
/**
* Extracts redirect event data from an HTTP request.
* Centralizs the logic for reading headers and extracting client information.
*/
public final class RequestDataExtractor {
  private static final String HEADER_USER_AGENT = "User-Agent";
  private static final String HEADER_REFERER = "Referer";
  private static final String HEADER_ACCEPT_LANGUAGE = "Accept-Language";
  private static final String HEADER_X_FORWARDED_FOR = "X-Forwarded-For";
  private final Clock clock;
  public RequestDataExtractor(Clock clock) {
    this.clock = clock != null ? clock : Clock.systemUTC();
  }
  public RequestDataExtractor() {
    this(Clock.systemUTC());
  }
  /**
   * Creates a RedirectEvent from an HttpExchange.
   *
   * @param exchange  the HTTP exchange
   * @param shortCode the short code being resolved
   * @return the redirect event
   */
  public RedirectEvent extractEvent(HttpExchange exchange, String shortCode) {
    var headers = exchange.getRequestHeaders();
    return RedirectEventBuilder.forShortCode(shortCode, clock)
        .userAgent(getFirstHeader(headers, HEADER_USER_AGENT))
        .referer(getFirstHeader(headers, HEADER_REFERER))
        .acceptLanguage(getFirstHeader(headers, HEADER_ACCEPT_LANGUAGE))
        .ipAddress(extractClientIp(exchange))
        .build();
  }
  /**
   * Extracts the client IP address, considering proxy headers.
   */
  private String extractClientIp(HttpExchange exchange) {
    var headers = exchange.getRequestHeaders();
    // Check X-Forwarded-For first (common proxy header)
    String forwardedFor = getFirstHeader(headers, HEADER_X_FORWARDED_FOR);
    if (forwardedFor != null && !forwardedFor.isBlank()) {
      // X-Forwarded-For can contain multiple IPs, take the first one
      int commaIndex = forwardedFor.indexOf(',');
      if (commaIndex > 0) {
        return forwardedFor.substring(0, commaIndex).trim();
      }
      return forwardedFor.trim();
    }
    // Fall back to remote address
    var remoteAddress = exchange.getRemoteAddress();
    if (remoteAddress != null && remoteAddress.getAddress() != null) {
      return remoteAddress.getAddress().getHostAddress();
    }
    return null;
  }
  private String getFirstHeader(com.sun.net.httpserver.Headers headers, String name) {
    List<String> values = headers.get(name);
    if (values != null && !values.isEmpty()) {
      return values.getFirst();
    }
    return null;
  }
}

/**
* Sets the IP address and hashes it for privacy.
* The original IP is never stored.
*/
public RedirectEventBuilder ipAddress(String ipAddress) {
  this.ipHash = hashIp(ipAddress);
  return this;
}
/**
* Hashes an IP address using SHA-256.
* Returns null if the input is null or empty.
*/
private String hashIp(String ipAddress) {
  if (ipAddress == null || ipAddress.isBlank()) {
    return null;
  }
  try {
    MessageDigest digest = MessageDigest.getInstance(HASH_ALGORITHM);
    byte[] hash = digest.digest(ipAddress.getBytes(StandardCharsets.UTF_8));
    // Return first 16 characters of the hex string for a shorter hash
    return HEX_FORMAT.formatHex(hash).substring(0, 16);
  } catch (NoSuchAlgorithmException e) {
    // SHA-256 should always be available
    throw new IllegalStateException("SHA-256 algorithm not available", e);
  }
}

@Override
public void recordEvent(RedirectEvent event) {
  if (event == null || !config.isStatisticsEnabled()) {
    return;
  }
  String shortCode = event.shortCode();
  LocalDate date = event.timestamp().atZone(ZoneOffset.UTC).toLocalDate();
  int hour = event.timestamp().atZone(ZoneOffset.UTC).getHour();
  // Store event
  events.computeIfAbsent(shortCode, k -> new ConcurrentHashMap<>())
      .computeIfAbsent(date, k -> new CopyOnWriteArrayList<>())
      .add(event);
  // Update hourly aggregate
  hourlyAggregates.computeIfAbsent(shortCode, k -> new ConcurrentHashMap<>())
      .computeIfAbsent(date, k -> new HourlyAggregate(date))
      .increment(hour);
  // Update daily aggregate
  dailyAggregates.computeIfAbsent(shortCode, k -> new ConcurrentHashMap<>())
      .computeIfAbsent(date, k -> new DailyAggregate(date))
      .increment();
  logger().debug("Recorded event for shortCode={} date={} hour={}", shortCode, date, hour);
}

// In StatisticsDetailView.loadDailyData()
StatisticsTimelineResponse timeline = statisticsClient.getTimeline(
    shortCode,
    from != null ? from : LocalDate.now().minusDays(30),
    to != null ? to : LocalDate.now()
);

@Override
public void handle(HttpExchange exchange)
    throws IOException {
  if (!RequestMethodUtils.requireGet(exchange)) return;
  String path = exchange.getRequestURI().getPath();
  logger().info("StatisticsTimelineHandler: GET {}", path);
  String shortCode = extractShortCode(path);
  if (shortCode == null || shortCode.isBlank()) {
    writeJson(exchange, fromCode(400), ERROR_MISSING_SHORT_CODE);
    return;
  }
  var queryParams = QueryUtils.parseQueryParams(exchange.getRequestURI().getRawQuery());
  String fromParam = QueryUtils.first(queryParams, "from");
  String toParam = QueryUtils.first(queryParams, "to");
  if (fromParam == null || toParam == null || fromParam.isBlank() || toParam.isBlank()) {
    writeJson(exchange, fromCode(400), ERROR_MISSING_DATES);
    return;
  }
  try {
    LocalDate from = LocalDate.parse(fromParam);
    LocalDate to = LocalDate.parse(toParam);
    if (from.isAfter(to)) {
      writeJson(exchange, fromCode(400), ERROR_INVALID_RANGE);
      return;
    }
    List<DailyAggregate> aggregates = statisticsReader.getDailyAggregates(shortCode, from, to);
    List<DailyCount> dailyCounts = new ArrayList<>();
    for (DailyAggregate agg : aggregates) {
      dailyCounts.add(new DailyCount(agg.date(), agg.totalCount()));
    }
    StatisticsTimelineResponse response = StatisticsTimelineResponse.create(
        shortCode, from, to, dailyCounts
    );
    writeJson(exchange, fromCode(200), response);
  } catch (DateTimeParseException e) {
    logger().warn("Invalid date format: {}", e.getMessage());
    writeJson(exchange, fromCode(400), ERROR_INVALID_DATE);
  }
}

@Override
public List<DailyAggregate> getDailyAggregates(String shortCode, LocalDate from, LocalDate to) {
  var dailyMap = dailyAggregates.get(shortCode);
  if (dailyMap == null) {
    return Collections.emptyList();
  }
  return dailyMap.values().stream()
      .filter(agg -> !agg.date().isBefore(from) && !agg.date().isAfter(to))
      .sorted(Comparator.comparing(DailyAggregate::date))
      .collect(Collectors.toList());
}