*: implement span tracing in gitbase nodes

erizocosmico · erizocosmico · commit bcfe069cea43 · 2018-04-12T14:28:49.000+02:00
Signed-off-by: Miguel Molina &lt;miguel@erizocosmi.co&gt;
diff --git a/blobs.go b/blobs.go
@@ -69,14 +69,16 @@ func (r *blobsTable) TransformExpressionsUp(f sql.TransformExprFunc) (sql.Node,
 }
 
 func (r blobsTable) RowIter(ctx *sql.Context) (sql.RowIter, error) {
+	span, ctx := ctx.Span("gitbase.BlobsTable")
 	iter := new(blobIter)
 
 	repoIter, err := NewRowRepoIter(ctx, iter)
 	if err != nil {
+		span.Finish()
 		return nil, err
 	}
 
-	return repoIter, nil
+	return sql.NewSpanIter(span, repoIter), nil
 }
 
 func (blobsTable) Children() []sql.Node {
@@ -91,7 +93,8 @@ func (r *blobsTable) WithProjectAndFilters(
 	ctx *sql.Context,
 	_, filters []sql.Expression,
 ) (sql.RowIter, error) {
-	return rowIterWithSelectors(
+	span, ctx := ctx.Span("gitbase.BlobsTable")
+	iter, err := rowIterWithSelectors(
 		ctx, BlobsSchema, BlobsTableName, filters,
 		[]string{"hash"},
 		func(selectors selectors) (RowRepoIter, error) {
@@ -107,6 +110,13 @@ func (r *blobsTable) WithProjectAndFilters(
 			return &blobsByHashIter{hashes: hashes}, nil
 		},
 	)
+
+	if err != nil {
+		span.Finish()
+		return nil, err
+	}
+
+	return sql.NewSpanIter(span, iter), nil
 }
 
 type blobIter struct {
diff --git a/commits.go b/commits.go
@@ -60,14 +60,16 @@ func (r *commitsTable) TransformExpressionsUp(f sql.TransformExprFunc) (sql.Node
 }
 
 func (r commitsTable) RowIter(ctx *sql.Context) (sql.RowIter, error) {
+	span, ctx := ctx.Span("gitbase.CommitsTable")
 	iter := new(commitIter)
 
 	repoIter, err := NewRowRepoIter(ctx, iter)
 	if err != nil {
+		span.Finish()
 		return nil, err
 	}
 
-	return repoIter, nil
+	return sql.NewSpanIter(span, repoIter), nil
 }
 
 func (commitsTable) Children() []sql.Node {
@@ -82,7 +84,8 @@ func (r *commitsTable) WithProjectAndFilters(
 	ctx *sql.Context,
 	_, filters []sql.Expression,
 ) (sql.RowIter, error) {
-	return rowIterWithSelectors(
+	span, ctx := ctx.Span("gitbase.CommitsTable")
+	iter, err := rowIterWithSelectors(
 		ctx, CommitsSchema, CommitsTableName, filters,
 		[]string{"hash"},
 		func(selectors selectors) (RowRepoIter, error) {
@@ -98,6 +101,13 @@ func (r *commitsTable) WithProjectAndFilters(
 			return &commitsByHashIter{hashes: hashes}, nil
 		},
 	)
+
+	if err != nil {
+		span.Finish()
+		return nil, err
+	}
+
+	return sql.NewSpanIter(span, iter), nil
 }
 
 type commitIter struct {
diff --git a/internal/function/commit_has_tree.go b/internal/function/commit_has_tree.go
@@ -46,6 +46,9 @@ func (CommitHasTree) Type() sql.Type { return sql.Boolean }
 
 // Eval implements the Expression interface.
 func (f *CommitHasTree) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	span, ctx := ctx.Span("gitbase.CommitHasTree")
+	defer span.Finish()
+
 	s, ok := ctx.Session.(*gitbase.Session)
 	if !ok {
 		return nil, gitbase.ErrInvalidGitbaseSession.New(ctx.Session)
diff --git a/internal/function/history_idx.go b/internal/function/history_idx.go
@@ -38,6 +38,9 @@ type historyKey struct {
 
 // Eval implements the Expression interface.
 func (f *HistoryIdx) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	span, ctx := ctx.Span("gitbase.HistoryIdx")
+	defer span.Finish()
+
 	s, ok := ctx.Session.(*gitbase.Session)
 	if !ok {
 		return nil, gitbase.ErrInvalidGitbaseSession.New(ctx.Session)
diff --git a/internal/function/is_remote.go b/internal/function/is_remote.go
@@ -21,6 +21,9 @@ func NewIsRemote(e sql.Expression) sql.Expression {
 
 // Eval implements the expression interface.
 func (f *IsRemote) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	span, ctx := ctx.Span("gitbase.IsRemote")
+	defer span.Finish()
+
 	val, err := f.Child.Eval(ctx, row)
 	if err != nil {
 		return nil, err
diff --git a/internal/function/is_tag.go b/internal/function/is_tag.go
@@ -21,6 +21,9 @@ func NewIsTag(e sql.Expression) sql.Expression {
 
 // Eval implements the expression interface.
 func (f *IsTag) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	span, ctx := ctx.Span("gitbase.IsTag")
+	defer span.Finish()
+
 	val, err := f.Child.Eval(ctx, row)
 	if err != nil {
 		return nil, err
diff --git a/internal/function/language.go b/internal/function/language.go
@@ -72,6 +72,9 @@ func (f *Language) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error)
 
 // Eval implements the Expression interface.
 func (f *Language) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	span, ctx := ctx.Span("gitbase.Language")
+	defer span.Finish()
+
 	left, err := f.Left.Eval(ctx, row)
 	if err != nil {
 		return nil, err
diff --git a/internal/function/language_test.go b/internal/function/language_test.go
@@ -28,6 +28,7 @@ func TestLanguage(t *testing.T) {
 	for _, tt := range testCases {
 		t.Run(tt.name, func(t *testing.T) {
 			require := require.New(t)
+			ctx := sql.NewEmptyContext()
 
 			var args = make([]sql.Expression, len(tt.row))
 			for i := range tt.row {
@@ -37,7 +38,7 @@ func TestLanguage(t *testing.T) {
 			f, err := NewLanguage(args...)
 			if err == nil {
 				var val interface{}
-				val, err = f.Eval(nil, tt.row)
+				val, err = f.Eval(ctx, tt.row)
 				if tt.err == nil {
 					require.NoError(err)
 					require.Equal(tt.expected, val)
diff --git a/internal/function/uast.go b/internal/function/uast.go
@@ -115,6 +115,9 @@ func (f UAST) String() string {
 
 // Eval implements the Expression interface.
 func (f UAST) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	span, ctx := ctx.Span("gitbase.UAST")
+	defer span.Finish()
+
 	session, ok := ctx.Session.(*gitbase.Session)
 	if !ok {
 		return nil, gitbase.ErrInvalidGitbaseSession.New(ctx.Session)
@@ -229,6 +232,9 @@ func (UASTXPath) Type() sql.Type {
 
 // Eval implements the Expression interface.
 func (f *UASTXPath) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	span, ctx := ctx.Span("gitbase.UASTXPath")
+	defer span.Finish()
+
 	left, err := f.Left.Eval(ctx, row)
 	if err != nil {
 		return nil, err
diff --git a/internal/rule/squashjoins.go b/internal/rule/squashjoins.go
@@ -28,6 +28,9 @@ func SquashJoins(
 		return n, nil
 	}
 
+	span, ctx := ctx.Span("gitbase.SquashJoins")
+	defer span.Finish()
+
 	a.Log("squashing joins, node of type %T", n)
 	n, err := n.TransformUp(func(n sql.Node) (sql.Node, error) {
 		join, ok := n.(*plan.InnerJoin)
@@ -606,11 +609,17 @@ func (t *squashedTable) Resolved() bool {
 	return true
 }
 func (t *squashedTable) RowIter(ctx *sql.Context) (sql.RowIter, error) {
+	span, ctx := ctx.Span("gitbase.SquashedTable")
 	iter, err := gitbase.NewRowRepoIter(ctx, gitbase.NewChainableRowRepoIter(ctx, t.iter))
 	if err != nil {
+		span.Finish()
 		return nil, err
 	}
-	return &schemaMapperIter{iter, t.schemaMappings}, nil
+
+	return sql.NewSpanIter(
+		span,
+		&schemaMapperIter{iter, t.schemaMappings},
+	), nil
 }
 func (t *squashedTable) String() string {
 	return fmt.Sprintf("SquashedTable(%s)", strings.Join(t.tables, ", "))
diff --git a/references.go b/references.go
@@ -53,14 +53,16 @@ func (r *referencesTable) TransformExpressionsUp(f sql.TransformExprFunc) (sql.N
 }
 
 func (r referencesTable) RowIter(ctx *sql.Context) (sql.RowIter, error) {
+	span, ctx := ctx.Span("gitbase.ReferencesTable")
 	iter := new(referenceIter)
 
 	repoIter, err := NewRowRepoIter(ctx, iter)
 	if err != nil {
+		span.Finish()
 		return nil, err
 	}
 
-	return repoIter, nil
+	return sql.NewSpanIter(span, repoIter), nil
 }
 
 func (referencesTable) Children() []sql.Node {
@@ -75,7 +77,8 @@ func (r *referencesTable) WithProjectAndFilters(
 	ctx *sql.Context,
 	_, filters []sql.Expression,
 ) (sql.RowIter, error) {
-	return rowIterWithSelectors(
+	span, ctx := ctx.Span("gitbase.ReferencesTable")
+	iter, err := rowIterWithSelectors(
 		ctx, RefsSchema, ReferencesTableName, filters,
 		[]string{"hash", "name"},
 		func(selectors selectors) (RowRepoIter, error) {
@@ -100,6 +103,13 @@ func (r *referencesTable) WithProjectAndFilters(
 			return &filteredReferencesIter{hashes: stringsToHashes(hashes), names: names}, nil
 		},
 	)
+
+	if err != nil {
+		span.Finish()
+		return nil, err
+	}
+
+	return sql.NewSpanIter(span, iter), nil
 }
 
 type referenceIter struct {
diff --git a/remotes.go b/remotes.go
@@ -54,14 +54,16 @@ func (r *remotesTable) TransformExpressionsUp(f sql.TransformExprFunc) (sql.Node
 }
 
 func (r remotesTable) RowIter(ctx *sql.Context) (sql.RowIter, error) {
+	span, ctx := ctx.Span("gitbase.RemotesTable")
 	iter := new(remotesIter)
 
 	rowRepoIter, err := NewRowRepoIter(ctx, iter)
 	if err != nil {
+		span.Finish()
 		return nil, err
 	}
 
-	return rowRepoIter, nil
+	return sql.NewSpanIter(span, rowRepoIter), nil
 }
 
 func (remotesTable) Children() []sql.Node {
@@ -76,13 +78,21 @@ func (r *remotesTable) WithProjectAndFilters(
 	ctx *sql.Context,
 	_, filters []sql.Expression,
 ) (sql.RowIter, error) {
-	return rowIterWithSelectors(
+	span, ctx := ctx.Span("gitbase.RemotesTable")
+	iter, err := rowIterWithSelectors(
 		ctx, RemotesSchema, RemotesTableName, filters, nil,
 		func(selectors) (RowRepoIter, error) {
 			// it's not worth to manually filter with the selectors
 			return new(remotesIter), nil
 		},
 	)
+
+	if err != nil {
+		span.Finish()
+		return nil, err
+	}
+
+	return sql.NewSpanIter(span, iter), nil
 }
 
 type remotesIter struct {
diff --git a/repositories.go b/repositories.go
@@ -48,14 +48,16 @@ func (r *repositoriesTable) TransformExpressionsUp(f sql.TransformExprFunc) (sql
 }
 
 func (r repositoriesTable) RowIter(ctx *sql.Context) (sql.RowIter, error) {
+	span, ctx := ctx.Span("gitbase.RepositoriesTable")
 	iter := &repositoriesIter{}
 
 	rowRepoIter, err := NewRowRepoIter(ctx, iter)
 	if err != nil {
+		span.Finish()
 		return nil, err
 	}
 
-	return rowRepoIter, nil
+	return sql.NewSpanIter(span, rowRepoIter), nil
 }
 
 func (repositoriesTable) Children() []sql.Node {
@@ -70,13 +72,21 @@ func (r *repositoriesTable) WithProjectAndFilters(
 	ctx *sql.Context,
 	_, filters []sql.Expression,
 ) (sql.RowIter, error) {
-	return rowIterWithSelectors(
+	span, ctx := ctx.Span("gitbase.RepositoriesTable")
+	iter, err := rowIterWithSelectors(
 		ctx, RepositoriesSchema, RepositoriesTableName, filters, nil,
 		func(selectors) (RowRepoIter, error) {
 			// it's not worth to manually filter with the selectors
 			return new(repositoriesIter), nil
 		},
 	)
+
+	if err != nil {
+		span.Finish()
+		return nil, err
+	}
+
+	return sql.NewSpanIter(span, iter), nil
 }
 
 type repositoriesIter struct {
diff --git a/tree_entries.go b/tree_entries.go
@@ -51,14 +51,16 @@ func (r *treeEntriesTable) TransformExpressionsUp(f sql.TransformExprFunc) (sql.
 }
 
 func (r treeEntriesTable) RowIter(ctx *sql.Context) (sql.RowIter, error) {
+	span, ctx := ctx.Span("gitbase.TreeEntriesTable")
 	iter := new(treeEntryIter)
 
 	repoIter, err := NewRowRepoIter(ctx, iter)
 	if err != nil {
+		span.Finish()
 		return nil, err
 	}
 
-	return repoIter, nil
+	return sql.NewSpanIter(span, repoIter), nil
 }
 
 func (treeEntriesTable) Children() []sql.Node {
@@ -73,10 +75,11 @@ func (r *treeEntriesTable) WithProjectAndFilters(
 	ctx *sql.Context,
 	_, filters []sql.Expression,
 ) (sql.RowIter, error) {
+	span, ctx := ctx.Span("gitbase.TreeEntriesTable")
 	// TODO: could be optimized even more checking that only tree_hash is
 	// projected. There would be no need to iterate files in this case, and
 	// it would be much faster.
-	return rowIterWithSelectors(
+	iter, err := rowIterWithSelectors(
 		ctx, TreeEntriesSchema, TreeEntriesTableName, filters,
 		[]string{"tree_hash"},
 		func(selectors selectors) (RowRepoIter, error) {
@@ -92,6 +95,13 @@ func (r *treeEntriesTable) WithProjectAndFilters(
 			return &treeEntriesByHashIter{hashes: hashes}, nil
 		},
 	)
+
+	if err != nil {
+		span.Finish()
+		return nil, err
+	}
+
+	return sql.NewSpanIter(span, iter), nil
 }
 
 func (r treeEntriesTable) String() string {
