Merge branch 'main' into database/sql_instrumentation

Author: RonFed

CHANGELOG.md

@@ -8,9 +8,20 @@ OpenTelemetry Go Automatic Instrumentation adheres to [Semantic Versioning](http
 
 ## [Unreleased]
 
+### Changed
+
+- The function signature of `"go.opentelemetry.io/auto/offsets-tracker/downloader".DownloadBinary` has changed.
+  It now has an additional flag indicating whether it'll build a dummy app for Go stdlib packages or not. ([#256]https://github.com/open-telemetry/opentelemetry-go-instrumentation/pull/256)
+- The function signature of `"go.opentelemetry.io/auto/offsets-tracker/target".New` has changed.
+  It now accepts a flag to determine if the returned `Data` is from the Go stdlib or not. ([#256]https://github.com/open-telemetry/opentelemetry-go-instrumentation/pull/256)
+- Use UPROBE_RETURN to declare the common uprobe return logic (finding the corresponding context, setting up end time, and sending the event via perf buffer) ([#257]https://github.com/open-telemetry/opentelemetry-go-instrumentation/pull/257)
+- BASE_SPAN_PROPERTIES as common fields (start time, end time, SpanContext and ParentSpanContext) for all instrumentations events (consistent between C and Go structs). ([#257]https://github.com/open-telemetry/opentelemetry-go-instrumentation/pull/257)
+- Header guards in eBPF code. ([#257]https://github.com/open-telemetry/opentelemetry-go-instrumentation/pull/257)
+
 ### Fixed
 
 - Fix context propagation across different goroutines. ([#118](https://github.com/open-telemetry/opentelemetry-go-instrumentation/pull/118))
+- The offset tracker can once again build binaries for the Go stdlib. ([#256]https://github.com/open-telemetry/opentelemetry-go-instrumentation/pull/256)
 
 ## [v0.2.2-alpha] - 2023-07-12
 

Makefile

@@ -87,7 +87,7 @@ offsets:
 
 .PHONY: docker-offsets
 docker-offsets:
-	docker run --rm -v $(shell pwd):/app golang:1.20 /bin/sh -c "cd ../app && make offsets"
+	docker run --rm -v $(shell pwd):/app golang:1.21 /bin/sh -c "cd ../app && make offsets"
 
 .PHONY: update-licenses
 update-licenses: generate $(GOLICENSES)

include/alloc.h

@@ -12,6 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#ifndef _ALLOC_H_
+#define _ALLOC_H_
+
 #include "bpf_helpers.h"
 
 #define MAX_ENTRIES 50
@@ -119,3 +122,5 @@ static __always_inline void *write_target_data(void *data, s32 size)
         return NULL;
     }
 }
+
+#endif

include/arguments.h

@@ -12,6 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#ifndef _ARGUMENTS_H_
+#define _ARGUMENTS_H_
+
 #include "common.h"
 #include "bpf_tracing.h"
 #include "bpf_helpers.h"
@@ -80,4 +83,6 @@ static __always_inline void *get_consistent_key(struct pt_regs *ctx, void *conte
     void *ctx_ptr = 0;
     bpf_probe_read(&ctx_ptr, sizeof(ctx_ptr), contextContext);
     return ctx_ptr;
-}
+}
+
+#endif

include/go_context.h

@@ -12,6 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#ifndef _GO_CONTEXT_H_
+#define _GO_CONTEXT_H_
+
 #include "bpf_helpers.h"
 
 #define MAX_DISTANCE 10
@@ -83,4 +86,6 @@ static __always_inline void stop_tracking_span(struct span_context *sc) {
 
     bpf_map_delete_elem(&tracked_spans, &ctx);
     bpf_map_delete_elem(&tracked_spans_by_sc, sc);
-}
+}
+
+#endif

include/go_types.h

@@ -12,6 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#ifndef _GO_TYPES_H
+#define _GO_TYPES_H
+
 #include "alloc.h"
 #include "bpf_helpers.h"
 
@@ -121,4 +124,6 @@ static __always_inline void append_item_to_slice(struct go_slice *slice, void *n
     // Update len
     slice->len++;
     long success = bpf_probe_write_user(slice_user_ptr->len, &slice->len, sizeof(slice->len));
-}
+}
+
+#endif

include/span_context.h

@@ -12,6 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#ifndef _SPAN_CONTEXT_H_
+#define _SPAN_CONTEXT_H_
+
 #include "utils.h"
 
 #define SPAN_CONTEXT_STRING_SIZE 55
@@ -63,3 +66,5 @@ static __always_inline void w3c_string_to_span_context(char *str, struct span_co
     hex_string_to_bytes(str + trace_id_start_pos, TRACE_ID_STRING_SIZE, ctx->TraceID);
     hex_string_to_bytes(str + span_id_start_pod, SPAN_ID_STRING_SIZE, ctx->SpanID);
 }
+
+#endif

include/uprobe.h

@@ -0,0 +1,50 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef _UPROBE_H_
+#define _UPROBE_H_
+
+#include "common.h"
+#include "span_context.h"
+#include "go_context.h"
+
+#define BASE_SPAN_PROPERTIES \
+    u64 start_time;          \
+    u64 end_time;            \
+    struct span_context sc;  \
+    struct span_context psc; 
+
+// Common flow for uprobe return:
+// 1. Find consistend key for the current uprobe context
+// 2. Use the key to lookup for the uprobe context in the uprobe_context_map
+// 3. Update the end time of the found span
+// 4. Submit the constructed event to the agent code using perf buffer events_map
+// 5. Delete the span from the uprobe_context_map
+// 6. Delete the span from the global active spans map
+#define UPROBE_RETURN(name, event_type, ctx_struct_pos, ctx_struct_offset, uprobe_context_map, events_map) \
+SEC("uprobe/##name##")                                                                                     \
+int uprobe_##name##_Returns(struct pt_regs *ctx) {                                                         \
+    void *req_ptr = get_argument(ctx, ctx_struct_pos);                                                     \
+    void *key = get_consistent_key(ctx, (void *)(req_ptr + ctx_struct_offset));                            \
+    void *req_ptr_map = bpf_map_lookup_elem(&uprobe_context_map, &key);                                    \
+    event_type tmpReq = {};                                                                                \
+    bpf_probe_read(&tmpReq, sizeof(tmpReq), req_ptr_map);                                                  \
+    tmpReq.end_time = bpf_ktime_get_ns();                                                                  \
+    bpf_perf_event_output(ctx, &events_map, BPF_F_CURRENT_CPU, &tmpReq, sizeof(tmpReq));                   \
+    bpf_map_delete_elem(&uprobe_context_map, &key);                                                        \
+    stop_tracking_span(&tmpReq.sc);                                                                        \
+    return 0;                                                                                              \
+}
+
+#endif

offsets-tracker/README.md

@@ -57,18 +57,24 @@ For example, here is the tracking of `method` field inside `transport.Stream` st
 
 ## Versions Discovery
 
-By default, offsets-tracker finds availble versions by executing `go list -versions <target-name>`.
+By default, offsets-tracker finds available versions by executing `go list -versions <target-name>`.
 
 Unfortunately, Go standard library versions are not discoverable via `go list`. 
-In order to discover Go versions, offsets-tracker can fetch the versions published at `https://go.dev/dl`.
+In order to discover Go versions, the offsets-tracker fetch the versions published at `https://go.dev/dl`.
 Fetching `go.dev` for discovering versions can be enabled by setting`.FindVersionsBy(target.GoDevFileVersionsStrategy)` when registering a new target.
 
 ## Download Strategy
 
 offsets-tracker wraps every Go module version as a Go application that depends on that module.
 Those applications are the result of [generating template files](./downloader/wrapper) with the appropriate version.
 
-In the case of the Go standard library, offsets-tracker downloads the published binary for the specified version. 
+In the case of the Go standard library, the offsets-tracker creates a dummy application that depends on the specific library. For example
+
+```go
+import (
+  _ "net/http"
+)
+```
 
 ## Version Constraints
 

offsets-tracker/downloader/go_wrapper.go

@@ -18,7 +18,7 @@ import (
 	_ "embed"
 	"fmt"
 	"io/fs"
-	"io/ioutil"
+	"os"
 	"path"
 
 	"go.opentelemetry.io/auto/offsets-tracker/utils"
@@ -30,25 +30,35 @@ var (
 	//go:embed wrapper/go.mod.txt
 	goMod string
 
+	//go:embed wrapper/go.modstd.txt
+	goModStdLib string
+
 	//go:embed wrapper/main.go.txt
 	goMain string
 )
 
 // DownloadBinary downloads the module with modName at version.
-func DownloadBinary(modName string, version string) (string, string, error) {
-	dir, err := ioutil.TempDir("", appName)
+// revive:disable-next-line:flag-parameter
+func DownloadBinary(modName string, version string, isGoStandartLib bool) (string, string, error) {
+	dir, err := os.MkdirTemp("", appName)
 	if err != nil {
 		return "", "", err
 	}
 
-	goModContent := fmt.Sprintf(goMod, modName, version)
-	err = ioutil.WriteFile(path.Join(dir, "go.mod"), []byte(goModContent), fs.ModePerm)
+	var goModContent string
+	if isGoStandartLib {
+		goModContent = fmt.Sprintf(goModStdLib, version)
+	} else {
+		goModContent = fmt.Sprintf(goMod, modName, version)
+	}
+
+	err = os.WriteFile(path.Join(dir, "go.mod"), []byte(goModContent), fs.ModePerm)
 	if err != nil {
 		return "", "", err
 	}
 
 	goMainContent := fmt.Sprintf(goMain, modName)
-	err = ioutil.WriteFile(path.Join(dir, "main.go"), []byte(goMainContent), fs.ModePerm)
+	err = os.WriteFile(path.Join(dir, "main.go"), []byte(goMainContent), fs.ModePerm)
 	if err != nil {
 		return "", "", err
 	}
@@ -58,7 +68,7 @@ func DownloadBinary(modName string, version string) (string, string, error) {
 		return "", "", err
 	}
 
-	_, _, err = utils.RunCommand("GOOS=linux GOARCH=amd64 go build", dir)
+	_, _, err = utils.RunCommand(fmt.Sprintf("GOOS=linux GOARCH=amd64 go build -o %s", appName), dir)
 	if err != nil {
 		return "", "", err
 	}