bingyi/gf
1
0
Fork 0
mirror of https://gitee.com/johng/gf synced 2026-06-06 16:21:40 +08:00
Code Issues Packages Projects Releases Wiki Activity

move tracing examples to new repo.

Browse Source
This commit is contained in:
jianchenma
2021-01-26 20:07:40 +08:00
parent 24e2c7926e
commit 6bad31f1be
14 changed files with 0 additions and 2066 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
.example/net/gtrace/1.http/client/main.go
View File

@ -1,51 +0,0 @@
package main
import (
"context"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/net/ghttp"
"github.com/gogf/gf/net/gtrace"
"go.opentelemetry.io/otel/baggage"
"go.opentelemetry.io/otel/exporters/trace/jaeger"
"go.opentelemetry.io/otel/label"
sdkTrace "go.opentelemetry.io/otel/sdk/trace"
)
const (
JaegerEndpoint = "http://localhost:14268/api/traces"
ServiceName = "tracing-http-client"
)
// initTracer creates a new trace provider instance and registers it as global trace provider.
func initTracer() func() {
// Create and install Jaeger export pipeline.
flush, err := jaeger.InstallNewPipeline(
jaeger.WithCollectorEndpoint(JaegerEndpoint),
jaeger.WithProcess(jaeger.Process{
ServiceName: ServiceName,
}),
jaeger.WithSDK(&sdkTrace.Config{DefaultSampler: sdkTrace.AlwaysSample()}),
)
if err != nil {
g.Log().Fatal(err)
}
return flush
}
func StartRequests() {
ctx, span := gtrace.Tracer().Start(context.Background(), "StartRequests")
defer span.End()
ctx = baggage.ContextWithValues(ctx, label.String("name", "john"))
client := g.Client().Use(ghttp.MiddlewareClientTracing)
content := client.Ctx(ctx).GetContent("http://127.0.0.1:8199/hello")
g.Log().Ctx(ctx).Print(content)
}
func main() {
flush := initTracer()
defer flush()
StartRequests()
}

52
.example/net/gtrace/1.http/server/main.go
View File

@ -1,52 +0,0 @@
package main
import (
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/net/ghttp"
"github.com/gogf/gf/net/gtrace"
"go.opentelemetry.io/otel/baggage"
"go.opentelemetry.io/otel/exporters/trace/jaeger"
sdkTrace "go.opentelemetry.io/otel/sdk/trace"
)
const (
JaegerEndpoint = "http://localhost:14268/api/traces"
ServiceName = "tracing-http-server"
)
// initTracer creates a new trace provider instance and registers it as global trace provider.
func initTracer() func() {
// Create and install Jaeger export pipeline.
flush, err := jaeger.InstallNewPipeline(
jaeger.WithCollectorEndpoint(JaegerEndpoint),
jaeger.WithProcess(jaeger.Process{
ServiceName: ServiceName,
}),
jaeger.WithSDK(&sdkTrace.Config{DefaultSampler: sdkTrace.AlwaysSample()}),
)
if err != nil {
g.Log().Fatal(err)
}
return flush
}
func main() {
flush := initTracer()
defer flush()
s := g.Server()
s.Group("/", func(group *ghttp.RouterGroup) {
group.Middleware(ghttp.MiddlewareServerTracing)
group.GET("/hello", helloHandler)
})
s.SetPort(8199)
s.Run()
}
func helloHandler(r *ghttp.Request) {
ctx, span := gtrace.Tracer().Start(r.Context(), "helloHandler")
defer span.End()
value := baggage.Value(ctx, "name")
r.Response.Write("hello:", value.AsString())
}

19
.example/net/gtrace/2.http+db/config.toml
View File

@ -1,19 +0,0 @@
# MySQL.
[database]
[database.logger]
level = "all"
stdout = true
[database.default]
link = "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
debug = true
# Redis.
[redis]
default = "127.0.0.1:6379,0"
cache = "127.0.0.1:6379,1"

64
.example/net/gtrace/2.http+db/main.go
View File

@ -1,64 +0,0 @@
package main
import (
"github.com/gogf/gf/errors/gerror"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/net/ghttp"
"go.opentelemetry.io/otel/exporters/trace/jaeger"
sdkTrace "go.opentelemetry.io/otel/sdk/trace"
)
type tracingApi struct{}
const (
JaegerEndpoint = "http://localhost:14268/api/traces"
ServiceName = "tracing-demo-db"
)
// initTracer creates a new trace provider instance and registers it as global trace provider.
func initTracer() func() {
// Create and install Jaeger export pipeline.
flush, err := jaeger.InstallNewPipeline(
jaeger.WithCollectorEndpoint(JaegerEndpoint),
jaeger.WithProcess(jaeger.Process{
ServiceName: ServiceName,
}),
jaeger.WithSDK(&sdkTrace.Config{DefaultSampler: sdkTrace.AlwaysSample()}),
)
if err != nil {
g.Log().Fatal(err)
}
return flush
}
func (api *tracingApi) Insert(r *ghttp.Request) {
result, err := g.Table("user").Ctx(r.Context()).Insert(g.Map{
"name": r.GetString("name"),
})
if err != nil {
r.Response.WriteExit(gerror.Current(err))
}
id, _ := result.LastInsertId()
r.Response.Write("id:", id)
}
func (api *tracingApi) Query(r *ghttp.Request) {
one, err := g.Table("user").Ctx(r.Context()).FindOne(r.GetInt("id"))
if err != nil {
r.Response.WriteExit(gerror.Current(err))
}
r.Response.Write("user:", one)
}
func main() {
flush := initTracer()
defer flush()
s := g.Server()
s.Group("/", func(group *ghttp.RouterGroup) {
group.Middleware(ghttp.MiddlewareServerTracing)
group.ALL("/user", new(tracingApi))
})
s.SetPort(8199)
s.Run()
}

10
.example/net/gtrace/3.http+redis/config.toml
View File

@ -1,10 +0,0 @@
# Redis.
[redis]
default = "127.0.0.1:6379,0"
cache = "127.0.0.1:6379,1"

63
.example/net/gtrace/3.http+redis/main.go
View File

@ -1,63 +0,0 @@
package main
import (
"github.com/gogf/gf/errors/gerror"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/net/ghttp"
"go.opentelemetry.io/otel/exporters/trace/jaeger"
sdkTrace "go.opentelemetry.io/otel/sdk/trace"
)
type tracingApi struct{}
const (
JaegerEndpoint = "http://localhost:14268/api/traces"
ServiceName = "tracing-demo-redis"
)
func (api *tracingApi) Set(r *ghttp.Request) {
_, err := g.Redis().Ctx(r.Context()).Do("SET", r.GetString("key"), r.GetString("value"))
if err != nil {
r.Response.WriteExit(gerror.Current(err))
}
r.Response.Write("ok")
}
func (api *tracingApi) Get(r *ghttp.Request) {
value, err := g.Redis().Ctx(r.Context()).DoVar(
"GET", r.GetString("key"),
)
if err != nil {
r.Response.WriteExit(gerror.Current(err))
}
r.Response.Write(value.String())
}
// initTracer creates a new trace provider instance and registers it as global trace provider.
func initTracer() func() {
// Create and install Jaeger export pipeline.
flush, err := jaeger.InstallNewPipeline(
jaeger.WithCollectorEndpoint(JaegerEndpoint),
jaeger.WithProcess(jaeger.Process{
ServiceName: ServiceName,
}),
jaeger.WithSDK(&sdkTrace.Config{DefaultSampler: sdkTrace.AlwaysSample()}),
)
if err != nil {
g.Log().Fatal(err)
}
return flush
}
func main() {
flush := initTracer()
defer flush()
s := g.Server()
s.Group("/", func(group *ghttp.RouterGroup) {
group.Middleware(ghttp.MiddlewareServerTracing)
group.ALL("/redis", new(tracingApi))
})
s.SetPort(8199)
s.Run()
}

74
.example/net/gtrace/4.http+db+redis+log/client/main.go
View File

@ -1,74 +0,0 @@
package main
import (
"context"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/net/ghttp"
"github.com/gogf/gf/net/gtrace"
"go.opentelemetry.io/otel/exporters/trace/jaeger"
sdkTrace "go.opentelemetry.io/otel/sdk/trace"
)
const (
JaegerEndpoint = "http://localhost:14268/api/traces"
ServiceName = "tracing-http-client"
)
// initTracer creates a new trace provider instance and registers it as global trace provider.
func initTracer() func() {
// Create and install Jaeger export pipeline.
flush, err := jaeger.InstallNewPipeline(
jaeger.WithCollectorEndpoint(JaegerEndpoint),
jaeger.WithProcess(jaeger.Process{
ServiceName: ServiceName,
}),
jaeger.WithSDK(&sdkTrace.Config{DefaultSampler: sdkTrace.AlwaysSample()}),
)
if err != nil {
g.Log().Fatal(err)
}
return flush
}
func StartRequests() {
ctx, span := gtrace.Tracer().Start(context.Background(), "StartRequests")
defer span.End()
client := g.Client().Use(ghttp.MiddlewareClientTracing)
// Add user info.
idStr := client.Ctx(ctx).PostContent(
"http://127.0.0.1:8199/user/insert",
g.Map{
"name": "john",
},
)
if idStr == "" {
g.Log().Ctx(ctx).Fatal("retrieve empty id string")
}
g.Log().Ctx(ctx).Print("insert:", idStr)
// Query user info.
userJson := client.Ctx(ctx).GetContent(
"http://127.0.0.1:8199/user/query",
g.Map{
"id": idStr,
},
)
g.Log().Ctx(ctx).Print("query:", idStr, userJson)
// Delete user info.
deleteResult := client.Ctx(ctx).PostContent(
"http://127.0.0.1:8199/user/delete",
g.Map{
"id": idStr,
},
)
g.Log().Ctx(ctx).Print("delete:", idStr, deleteResult)
}
func main() {
flush := initTracer()
defer flush()
StartRequests()
}

19
.example/net/gtrace/4.http+db+redis+log/server/config.toml
View File

@ -1,19 +0,0 @@
# MySQL.
[database]
[database.logger]
level = "all"
stdout = true
[database.default]
link = "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
debug = true
# Redis.
[redis]
default = "127.0.0.1:6379,0"
cache = "127.0.0.1:6379,1"

122
.example/net/gtrace/4.http+db+redis+log/server/main.go
View File

@ -1,122 +0,0 @@
package main
import (
"fmt"
"github.com/gogf/gcache-adapter/adapter"
"github.com/gogf/gf/errors/gerror"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/net/ghttp"
"go.opentelemetry.io/otel/exporters/trace/jaeger"
sdkTrace "go.opentelemetry.io/otel/sdk/trace"
"time"
)
type tracingApi struct{}
const (
JaegerEndpoint = "http://localhost:14268/api/traces"
ServiceName = "tracing-http-server"
)
// initTracer creates a new trace provider instance and registers it as global trace provider.
func initTracer() func() {
// Create and install Jaeger export pipeline.
flush, err := jaeger.InstallNewPipeline(
jaeger.WithCollectorEndpoint(JaegerEndpoint),
jaeger.WithProcess(jaeger.Process{
ServiceName: ServiceName,
}),
jaeger.WithSDK(&sdkTrace.Config{DefaultSampler: sdkTrace.AlwaysSample()}),
)
if err != nil {
g.Log().Fatal(err)
}
return flush
}
type userApiInsert struct {
Name string `v:"required#Please input user name."`
}
// Insert is a route handler for inserting user info into dtabase.
func (api *tracingApi) Insert(r *ghttp.Request) {
var (
dataReq *userApiInsert
)
if err := r.Parse(&dataReq); err != nil {
r.Response.WriteExit(gerror.Current(err))
}
result, err := g.Table("user").Ctx(r.Context()).Insert(g.Map{
"name": dataReq.Name,
})
if err != nil {
r.Response.WriteExit(gerror.Current(err))
}
id, _ := result.LastInsertId()
r.Response.Write(id)
}
type userApiQuery struct {
Id int `v:"min:1#User id is required for querying."`
}
// Query is a route handler for querying user info. It firstly retrieves the info from redis,
// if there's nothing in the redis, it then does db select.
func (api *tracingApi) Query(r *ghttp.Request) {
var (
dataReq *userApiQuery
)
if err := r.Parse(&dataReq); err != nil {
r.Response.WriteExit(gerror.Current(err))
}
one, err := g.Table("user").
Ctx(r.Context()).
Cache(5*time.Second, api.userCacheKey(dataReq.Id)).
FindOne(dataReq.Id)
if err != nil {
r.Response.WriteExit(gerror.Current(err))
}
r.Response.WriteJson(one)
}
type userApiDelete struct {
Id int `v:"min:1#User id is required for deleting."`
}
// Delete is a route handler for deleting specified user info.
func (api *tracingApi) Delete(r *ghttp.Request) {
var (
dataReq *userApiDelete
)
if err := r.Parse(&dataReq); err != nil {
r.Response.WriteExit(gerror.Current(err))
}
_, err := g.Table("user").
Ctx(r.Context()).
Cache(-1, api.userCacheKey(dataReq.Id)).
WherePri(dataReq.Id).
Delete()
if err != nil {
r.Response.WriteExit(gerror.Current(err))
}
r.Response.Write("ok")
}
func (api *tracingApi) userCacheKey(id int) string {
return fmt.Sprintf(`userInfo:%d`, id)
}
func main() {
flush := initTracer()
defer flush()
g.DB().GetCache().SetAdapter(adapter.NewRedis(g.Redis()))
s := g.Server()
s.Group("/", func(group *ghttp.RouterGroup) {
group.Middleware(ghttp.MiddlewareServerTracing)
group.ALL("/user", new(tracingApi))
})
s.SetPort(8199)
s.Run()
}

80
.example/net/gtrace/5.grpc+db+redis+log/client/main.go
View File

@ -1,80 +0,0 @@
package main
import (
"context"
"github.com/gogf/gf/.example/net/gtrace/5.grpc+db+redis+log/protobuf/user"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/net/gtrace"
"go.opentelemetry.io/otel/exporters/trace/jaeger"
sdkTrace "go.opentelemetry.io/otel/sdk/trace"
"google.golang.org/grpc"
)
const (
JaegerEndpoint = "http://localhost:14268/api/traces"
ServiceName = "tracing-grpc-client"
)
// initTracer creates a new trace provider instance and registers it as global trace provider.
func initTracer() func() {
// Create and install Jaeger export pipeline.
flush, err := jaeger.InstallNewPipeline(
jaeger.WithCollectorEndpoint(JaegerEndpoint),
jaeger.WithProcess(jaeger.Process{
ServiceName: ServiceName,
}),
jaeger.WithSDK(&sdkTrace.Config{DefaultSampler: sdkTrace.AlwaysSample()}),
)
if err != nil {
g.Log().Fatal(err)
}
return flush
}
func StartRequests() {
ctx, span := gtrace.Tracer().Start(context.Background(), "StartRequests")
defer span.End()
conn, err := grpc.Dial(":8000", grpc.WithInsecure(), grpc.WithBlock())
if err != nil {
g.Log().Fatalf("did not connect: %v", err)
}
defer conn.Close()
client := user.NewUserClient(conn)
// Insert.
insertRes, err := client.Insert(ctx, &user.InsertReq{
Name: "john",
})
if err != nil {
g.Log().Ctx(ctx).Fatalf(`%+v`, err)
}
g.Log().Ctx(ctx).Println("insert:", insertRes.Id)
// Query.
queryRes, err := client.Query(ctx, &user.QueryReq{
Id: insertRes.Id,
})
if err != nil {
g.Log().Ctx(ctx).Fatalf(`%+v`, err)
}
g.Log().Ctx(ctx).Println("query:", queryRes)
// Delete.
_, err = client.Delete(ctx, &user.DeleteReq{
Id: insertRes.Id,
})
if err != nil {
g.Log().Ctx(ctx).Fatalf(`%+v`, err)
}
g.Log().Ctx(ctx).Println("delete:", "ok")
}
func main() {
flush := initTracer()
defer flush()
StartRequests()
}

1336
.example/net/gtrace/5.grpc+db+redis+log/protobuf/user/user.pb.go
View File

File diff suppressed because it is too large Load Diff

39
.example/net/gtrace/5.grpc+db+redis+log/protocol/user/user.proto
View File

@ -1,39 +0,0 @@
// protoc --gofast_out=plugins=grpc:. protocol/*.proto -I/Users/john/Workspace/Go/GOPATH/src
syntax = "proto3";
package demos;
option go_package = "protobuf/user";
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
// User service for tracing demo.
service User {
rpc Insert(InsertReq) returns (InsertRes) {}
rpc Query(QueryReq) returns (QueryRes) {}
rpc Delete(DeleteReq) returns (DeleteRes) {}
}
message InsertReq {
string Name = 1 [(gogoproto.moretags) = 'v:"required#Please input user name."'];
}
message InsertRes {
int32 Id = 1;
}
message QueryReq {
int32 Id = 1 [(gogoproto.moretags) = 'v:"min:1#User id is required for querying."'];
}
message QueryRes {
int32 Id = 1;
string Name = 2;
}
message DeleteReq {
int32 Id = 1 [(gogoproto.moretags) = 'v:"required#User id is required for deleting."'];
}
message DeleteRes {}

19
.example/net/gtrace/5.grpc+db+redis+log/server/config.toml
View File

@ -1,19 +0,0 @@
# MySQL.
[database]
[database.logger]
level = "all"
stdout = true
[database.default]
link = "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
debug = true
# Redis.
[redis]
default = "127.0.0.1:6379,0"
cache = "127.0.0.1:6379,1"

118
.example/net/gtrace/5.grpc+db+redis+log/server/main.go
View File

@ -1,118 +0,0 @@
package main
import (
"context"
"fmt"
"github.com/gogf/gcache-adapter/adapter"
"github.com/gogf/gf/.example/net/gtrace/5.grpc+db+redis+log/protobuf/user"
"github.com/gogf/gf/errors/gerror"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/util/gvalid"
"go.opentelemetry.io/otel/exporters/trace/jaeger"
sdkTrace "go.opentelemetry.io/otel/sdk/trace"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"net"
"time"
)
type server struct{}
const (
JaegerEndpoint = "http://localhost:14268/s/traces"
ServiceName = "tracing-grpc-server"
)
// initTracer creates a new trace provider instance and registers it as global trace provider.
func initTracer() func() {
// Create and install Jaeger export pipeline.
flush, err := jaeger.InstallNewPipeline(
jaeger.WithCollectorEndpoint(JaegerEndpoint),
jaeger.WithProcess(jaeger.Process{
ServiceName: ServiceName,
}),
jaeger.WithSDK(&sdkTrace.Config{DefaultSampler: sdkTrace.AlwaysSample()}),
)
if err != nil {
g.Log().Fatal(err)
}
return flush
}
// Common validation unary interpreter.
func UnaryValidate(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
// It does nothing if there's no validation tag in the struct definition.
if err := gvalid.CheckStruct(req, nil); err != nil {
return nil, gerror.NewCode(
int(codes.InvalidArgument),
gerror.Current(err).Error(),
)
}
return handler(ctx, req)
}
// Insert is a route handler for inserting user info into dtabase.
func (s *server) Insert(ctx context.Context, req *user.InsertReq) (*user.InsertRes, error) {
res := user.InsertRes{}
result, err := g.Table("user").Ctx(ctx).Insert(g.Map{
"name": req.Name,
})
if err != nil {
return nil, err
}
id, _ := result.LastInsertId()
res.Id = int32(id)
return &res, nil
}
// Query is a route handler for querying user info. It firstly retrieves the info from redis,
// if there's nothing in the redis, it then does db select.
func (s *server) Query(ctx context.Context, req *user.QueryReq) (*user.QueryRes, error) {
res := user.QueryRes{}
err := g.Table("user").
Ctx(ctx).
Cache(5*time.Second, s.userCacheKey(req.Id)).
WherePri(req.Id).
Scan(&res)
if err != nil {
return nil, err
}
return &res, nil
}
// Delete is a route handler for deleting specified user info.
func (s *server) Delete(ctx context.Context, req *user.DeleteReq) (*user.DeleteRes, error) {
res := user.DeleteRes{}
_, err := g.Table("user").
Ctx(ctx).
Cache(-1, s.userCacheKey(req.Id)).
WherePri(req.Id).
Delete()
if err != nil {
return nil, err
}
return &res, nil
}
func (s *server) userCacheKey(id int32) string {
return fmt.Sprintf(`userInfo:%d`, id)
}
func main() {
flush := initTracer()
defer flush()
g.DB().GetCache().SetAdapter(adapter.NewRedis(g.Redis()))
listen, err := net.Listen("tcp", ":8000")
if err != nil {
g.Log().Fatalf("failed to listen: %v", err)
}
s := grpc.NewServer(
grpc.ChainUnaryInterceptor(UnaryValidate),
)
user.RegisterUserServer(s, &server{})
if err := s.Serve(listen); err != nil {
g.Log().Fatalf("failed to serve: %v", err)
}
}