fix: fixed issue with filtering not functioning for start_time

Author: robbert229

internal/sql/manual.go

@@ -127,3 +127,22 @@ WHERE spans.start_time < sqlc.arg(prune_before)::TIMESTAMP;
 -- name: GetSpansDiskSize :one
 
 SELECT pg_total_relation_size('spans');
+
+-- name: GetSpansCount :one
+
+SELECT COUNT(*) FROM spans;
+
+-- name: FindTraceIDs :many
+
+SELECT DISTINCT spans.trace_id as trace_id
+FROM spans
+    INNER JOIN operations ON (operations.id = spans.operation_id)
+    INNER JOIN services ON (services.id = spans.service_id)
+WHERE
+    (services.name = sqlc.arg(service_name)::VARCHAR OR sqlc.arg(service_name_enable_filter)::BOOLEAN = FALSE) AND
+    (operations.name = sqlc.arg(operation_name)::VARCHAR OR sqlc.arg(operation_name_enable_filter)::BOOLEAN = FALSE) AND
+    (start_time >= sqlc.arg(start_time_minimum)::TIMESTAMP OR sqlc.arg(start_time_minimum_enable_filter)::BOOLEAN = FALSE) AND
+    (start_time <= sqlc.arg(start_time_maximum)::TIMESTAMP OR sqlc.arg(start_time_maximum_enable_filter)::BOOLEAN = FALSE) AND
+    (duration >= sqlc.arg(duration_minimum)::INTERVAL OR sqlc.arg(duration_minimum_enable_filter)::BOOLEAN = FALSE) AND
+    (duration <= sqlc.arg(duration_maximum)::INTERVAL OR sqlc.arg(duration_maximum_enable_filter)::BOOLEAN = FALSE)
+LIMIT sqlc.arg(num_traces);

internal/sql/query.sql

@@ -17,6 +17,8 @@ func TestGetOperations(t *testing.T) {
 	conn, cleanup := sqltest.Harness(t)
 	q := sql.New(conn)
 
+	defer conn.Close(context.Background())
+
 	t.Run("should return nothing when no operations exist", func(t *testing.T) {
 		require.Nil(t, cleanup())
 
@@ -79,6 +81,8 @@ func TestGetServices(t *testing.T) {
 	conn, cleanup := sqltest.Harness(t)
 	q := sql.New(conn)
 
+	defer conn.Close(context.Background())
+
 	t.Run("should return nothing when no services exist", func(t *testing.T) {
 		require.Nil(t, cleanup())
 
@@ -111,6 +115,8 @@ func TestSpans(t *testing.T) {
 	conn, cleanup := sqltest.Harness(t)
 	q := sql.New(conn)
 
+	defer conn.Close(context.Background())
+
 	t.Run("should be able to write a span", func(t *testing.T) {
 		require.Nil(t, cleanup())
 
@@ -186,4 +192,79 @@ func TestSpans(t *testing.T) {
 		_ = queried
 
 	})
+
+	t.Run("should be able to write a span", func(t *testing.T) {
+		require.Nil(t, cleanup())
+
+		err := q.UpsertService(ctx, "service-1")
+		require.Nil(t, err)
+
+		serviceID, err := q.GetServiceID(ctx, "service-1")
+		require.Nil(t, err)
+
+		err = q.UpsertOperation(ctx, sql.UpsertOperationParams{Name: "operation-1", ServiceID: serviceID, Kind: sql.SpankindClient})
+		require.Nil(t, err)
+
+		operationID, err := q.GetOperationID(ctx, sql.GetOperationIDParams{Name: "operation-1", ServiceID: serviceID, Kind: sql.SpankindClient})
+		require.Nil(t, err)
+
+		_, err = q.InsertSpan(ctx, sql.InsertSpanParams{
+			SpanID:      []byte{0, 0, 0, 1},
+			TraceID:     []byte{0, 0, 0, 0},
+			OperationID: operationID,
+			Flags:       0,
+			StartTime:   pgtype.Timestamp{Time: time.Now(), Valid: true},
+			Duration:    pgtype.Interval{Microseconds: 1000, Valid: true},
+			Tags:        []byte("[]"),
+			ServiceID:   serviceID,
+			ProcessID:   "",
+			ProcessTags: []byte("[]"),
+			Warnings:    []string{},
+			Kind:        sql.SpankindClient,
+			Logs:        []byte("null"),
+			Refs:        []byte("[]"),
+		})
+		require.Nil(t, err)
+
+		_, err = q.InsertSpan(ctx, sql.InsertSpanParams{
+			SpanID:      []byte{0, 0, 0, 0},
+			TraceID:     []byte{0, 0, 0, 1},
+			OperationID: operationID,
+			Flags:       0,
+			StartTime:   pgtype.Timestamp{Time: time.Now(), Valid: true},
+			Duration:    pgtype.Interval{Microseconds: 1000, Valid: true},
+			Tags:        []byte("[]"),
+			ServiceID:   serviceID,
+			ProcessID:   "",
+			ProcessTags: []byte("null"),
+			Warnings:    []string{},
+			Kind:        sql.SpankindClient,
+			Logs:        []byte("null"),
+			Refs:        []byte("[]"),
+		})
+		require.Nil(t, err)
+
+		_, err = q.InsertSpan(ctx, sql.InsertSpanParams{
+			SpanID:      []byte{0, 0, 0, 0},
+			TraceID:     []byte{0, 0, 0, 2},
+			OperationID: operationID,
+			Flags:       0,
+			StartTime:   pgtype.Timestamp{Time: time.Now(), Valid: true},
+			Duration:    pgtype.Interval{Microseconds: 1000, Valid: true},
+			Tags:        []byte("[]"),
+			ServiceID:   serviceID,
+			ProcessID:   "",
+			ProcessTags: []byte("[]"),
+			Warnings:    []string{},
+			Kind:        sql.SpankindClient,
+			Logs:        []byte("null"),
+			Refs:        []byte("[]"),
+		})
+		require.Nil(t, err)
+
+		queried, err := q.FindTraceIDs(ctx, sql.FindTraceIDsParams{NumTraces: 1})
+		require.Nil(t, err)
+
+		require.Len(t, queried, 1)
+	})
 }

internal/sql/query.sql.go

@@ -38,7 +38,7 @@ func getDatabaseURL() string {
 		return url
 	}
 
-	return "postgres://postgres:password@localhost:5432/jaeger"
+	return "postgres://postgres:password@localhost:5432/jaegertest"
 }
 
 // Harness provides a test harness

internal/sql/query_test.go

@@ -20,6 +20,8 @@ func TestJaegerStorageIntegration(t *testing.T) {
 	conn, cleanup := sqltest.Harness(t)
 	require.Nil(t, cleanup())
 
+	defer conn.Close(context.Background())
+
 	q := sql.New(conn)
 
 	logger := slog.Default()
@@ -34,6 +36,7 @@ func TestJaegerStorageIntegration(t *testing.T) {
 		Refresh:                      func() error { return nil },
 		SkipList:                     []string{},
 	}
+
 	// Runs all storage integration tests.
 	si.IntegrationTestAll(t)
 }
@@ -43,6 +46,9 @@ func TestSpans(t *testing.T) {
 	require.Nil(t, cleanup())
 
 	ctx := context.Background()
+
+	defer conn.Close(ctx)
+
 	q := sql.New(conn)
 
 	require.Nil(t, cleanup())