fixed some time related bugs with metrics/stats queries

client/src/api/logs.ts

@@ -1,14 +1,15 @@
-import { sub } from 'date-fns'
-import { formatDate } from './metrics';
+import { sub, getUnixTime } from 'date-fns'
+import { API_HOST } from './util';
 
 
 export const getLogs = async function ({
     start = sub(new Date(), { hours: 12 }),
     end = new Date(),
+    page = 0,
     filter = ""
 } = {}) {
     try {
-        const data = await fetch(`http://localhost:8080/api/v1/metrics/log?filter=${filter}`, {
+        const data = await fetch(API_HOST(`metrics/log?filter=${filter}&start=${getUnixTime(start)}&end=${getUnixTime(end)}&page=${page}`), {
             "method": "GET",
             "headers": { "Accept": "application/json" }
         });

client/src/api/metrics.ts

@@ -1,4 +1,4 @@
-import { sub, format } from 'date-fns';
+import { getUnixTime, sub, format } from 'date-fns';
 import { readable } from "svelte/store";
 import { API_HOST } from './util';
 
@@ -27,9 +27,9 @@ export const fetchMetrics = async function ({
 } = {}) {
     try {
         const response = await fetch(
-            API_HOST(`/metrics/stats?start=${formatDateForSearch(
+            API_HOST(`metrics/stats?start=${getUnixTime(
                 start
-            )}&end=${formatDateForSearch(end)}&key=${key}&interval=${interval}`),
+            )}&end=${getUnixTime(end)}&key=${key}&interval=${interval}`),
             {
                 method: "GET",
                 headers: { Accept: "application/json" }

internal/http_stats.go

@@ -1,7 +1,6 @@
 package internal
 
 import (
-	"fmt"
 	"net/http"
 	"strconv"
 	"time"
@@ -15,24 +14,30 @@ func (a *adminHandler) getStats(r *http.Request) (*RestResponse, error) {
 	intervalSecondsStr := q.Get("interval")
 
 	var err error
-	start := time.Now().UTC().Add(time.Hour * -86400)
-	end := time.Now().UTC()
+	startTime := time.Now().Add(time.Hour * -86400)
+	endTime := time.Now()
 
 	if startFilter != "" {
-		if start, err = time.Parse(ISO8601, startFilter); err != nil {
-			return BasicResponse(false, fmt.Sprintf("start: could not understand value `%v`", err.Error())), nil
+		var startUnixTime int64
+		if startUnixTime, err = strconv.ParseInt(startFilter, 10, strconv.IntSize); err != nil {
+			return BasicResponse(false, "start: must be a valid unix timestamp"), nil
 		}
+
+		startTime = time.Unix(startUnixTime, 0)
 	}
 
 	if endFilter != "" {
-		if end, err = time.Parse(ISO8601, endFilter); err != nil {
-			return BasicResponse(false, fmt.Sprintf("end: could not understand value `%v`", err.Error())), nil
+		var endUnixTime int64
+		if endUnixTime, err = strconv.ParseInt(endFilter, 10, strconv.IntSize); err != nil {
+			return BasicResponse(false, "end: must be a valid unix timestamp"), nil
 		}
+
+		endTime = time.Unix(endUnixTime, 0)
 	}
 
 	lai := LogAggregateInput{
-		Start:  start,
-		End:    end,
+		Start:  startTime,
+		End:    endTime,
 		Column: key,
 	}
 
@@ -64,32 +69,37 @@ func (a *adminHandler) getLog(r *http.Request) (*RestResponse, error) {
 
 	var err error
 	var page int
-	start := time.Now().UTC().Add(time.Hour * -86400)
-	end := time.Now().UTC()
+	startTime := time.Now().Add(time.Hour * -86400)
+	endTime := time.Now()
 
 	if startFilter != "" {
-		if start, err = time.Parse(ISO8601, startFilter); err != nil {
-			return BasicResponse(false, "start: not a valid start time"), nil
+		var startUnixTime int64
+		if startUnixTime, err = strconv.ParseInt(startFilter, 10, strconv.IntSize); err != nil {
+			return BasicResponse(false, "start: must be a valid unix timestamp"), nil
 		}
+
+		startTime = time.Unix(startUnixTime, 0)
 	}
 
 	if endFilter != "" {
-		if end, err = time.Parse(ISO8601, endFilter); err != nil {
-			return BasicResponse(false, "end: not a valid end time"), nil
+		var endUnixTime int64
+		if endUnixTime, err = strconv.ParseInt(endFilter, 10, strconv.IntSize); err != nil {
+			return BasicResponse(false, "end: must be a valid unix timestamp"), nil
 		}
+
+		endTime = time.Unix(endUnixTime, 0)
 	}
 
 	if pageStr != "" {
 		if page, err = strconv.Atoi(pageStr); err != nil {
 			return BasicResponse(false, "page: must be a valid integer"), nil
-
 		}
 	}
 
 	gli := GetLogInput{
 		// Filter: filter,
-		Start: start,
-		End:   end,
+		Start: startTime,
+		End:   endTime,
 		Limit: 250,
 		Page:  page,
 	}

internal/rest_helpers.go

@@ -5,8 +5,6 @@ import (
 	"fmt"
 	"log"
 	"net/http"
-
-	"github.com/go-chi/chi/middleware"
 )
 
 type RestResponse struct {
@@ -66,9 +64,8 @@ type RestHandler func(request *http.Request) (*RestResponse, error)
 
 func (rh RestHandler) ToHF() http.HandlerFunc {
 	return func(rw http.ResponseWriter, r *http.Request) {
-
-		rid := r.Context().Value(middleware.RequestIDKey)
-		rw.Header().Set(middleware.RequestIDHeader, rid.(string))
+		// rid := r.Context().Value(middleware.RequestIDKey)
+		// rw.Header().Set(middleware.RequestIDHeader, rid.(string))
 		rh.ServeHTTP(rw, r)
 	}
 }

internal/sqlite.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"fmt"
 	"io"
+	"log"
 	"net"
 	"strconv"
 	"strings"
@@ -204,7 +205,7 @@ func (ss *Sqlite) GetRules() ([]RuleRow, error) {
 		return nil, err
 	}
 
-	var results []RuleRow
+	results := []RuleRow{}
 	for rows.Next() {
 		var rule RuleRow
 		var createdTime string
@@ -240,40 +241,43 @@ func (ss *Sqlite) GetLog(in GetLogInput) ([]QueryLog, error) {
 	}
 
 	if in.Start.IsZero() {
-		in.Start = time.Now().UTC().Add(time.Hour * -86400)
+		in.Start = time.Now().Add(time.Hour * -86400)
 	}
 
 	if in.End.IsZero() {
-		in.End = time.Now().UTC()
+		in.End = time.Now()
 	}
 
 	sql := `
 		SELECT
-			started, clientIp, protocol, domain, totalTimeMs, error, recurseRoundTripTimeMs, recurseUpstreamIp, status
+			started, clientIp, protocol, domain, totalTimeMs,
+			error, recurseRoundTripTimeMs, recurseUpstreamIp, status
 		FROM
 			log
 		WHERE
-			id > ? AND started > ? AND started < ?
+			id > ?
+			AND strftime('%s', started) > strftime('%s', ?)
+			AND strftime('%s', started) < strftime('%s', ?)
 		ORDER BY started DESC
 			LIMIT ?;
 	`
 
-	rows, err := ss.DB.Query(sql, in.Page*in.Limit, in.Start.Format(ISO8601), in.End.Format(ISO8601), in.Limit)
+	rows, err := ss.DB.Query(sql, in.Page*in.Limit, in.Start.UTC().Format(ISO8601), in.End.UTC().Format(ISO8601), in.Limit)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("issue with GetLog sql query: %w", err)
 	}
 	defer rows.Close()
 
 	if rerr := rows.Err(); rerr != nil {
-		return nil, rerr
+		return nil, fmt.Errorf("issue with rows object: %w", rerr)
 	}
 
-	var ql []QueryLog
+	ql := []QueryLog{}
 	for rows.Next() {
 		var q QueryLog
 		var started string
 
-		rows.Scan(
+		if err := rows.Scan(
 			&started,
 			&q.ClientIP,
 			&q.Protocol,
@@ -283,14 +287,18 @@ func (ss *Sqlite) GetLog(in GetLogInput) ([]QueryLog, error) {
 			&q.RecurseRoundTripTimeMs,
 			&q.RecurseUpstreamIP,
 			&q.Status,
-		)
-
-		if q.Started, err = time.Parse(ISO8601, started); err != nil {
-			return nil, fmt.Errorf("could not parse time '%s': %v", started, err)
+		); err != nil {
+			return nil, fmt.Errorf("issues scanning rows: %w", err)
 		}
 
+		if q.Started, err = time.Parse(ISO8601, started); err != nil {
+			return nil, fmt.Errorf("could not parse time '%s': %w", started, err)
+		}
+
+		log.Printf("%+v", q)
 		ql = append(ql, q)
 	}
+	log.Printf("%+v", ql)
 
 	return ql, nil
 }
@@ -358,6 +366,10 @@ func (ss *Sqlite) GetLogAggregate(la LogAggregateInput) ([]LogAggregateDataPoint
 	}
 	defer rows.Close()
 
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
 	var results []LogAggregateDataPoint
 	for rows.Next() {
 		var ladp LogAggregateDataPoint

makefile

@@ -8,7 +8,7 @@ client/node_modules:
 	cd ./client && npm install
 
 clean:
-	@rm -rf .bin/gopherhole
+	@rm -rf .bin/gopherhole .bin/config.json
 
 clobber:
 	@rm -rf .bin ./client/node_modules