AI 助理
备案控制台
开发者社区 云原生 云原生可观测 文章 正文

告别传统Log追踪！GOAT如何用HTTP接口重塑代码监控

2025-04-25 160 发布于广东
版权
举报
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
应用实时监控服务-可观测链路OpenTelemetry版，每月50GB免费额度
应用实时监控服务-应用监控，每月50GB免费额度
可观测可视化 Grafana 版，10个用户账号 1个月
简介： 本文介绍了GOAT（Golang Application Tracing）工具的使用方法，通过一个Echo问答服务实例，详细展示了代码埋点与追踪技术的应用。内容涵盖初始化配置、自动埋点、手动调整埋点、数据监控及清理埋点等核心功能。GOAT适用于灰度发布、功能验证、性能分析、Bug排查和代码重构等场景，助力Go项目质量保障与平稳发布。工具以轻量高效的特点，为开发团队提供数据支持，优化决策流程。

GOAT实战指南：用Echo问答服务掌握代码埋点与追踪技术

开场白

在灰度发布的实践中，如何确保新增代码的质量与稳定性？如何精准监控特定功能的执行情况？如何以最小的成本实现代码追踪？

GOAT（Golang Application Tracing） 作为一款专为Go语言设计的灰度追踪工具，为这些问题提供了优雅的解决方案。本教程将通过一个简单却实用的Echo问答服务，带您全面掌握 GOAT 的核心功能。无论您是Go语言开发者、DevOps工程师，还是对灰度发布和代码质量有深度关注的技术管理者，这篇文章都将帮助您将代码追踪技术落地到实际项目中。

场景描述

Echo是一个基于命令行的简易问答服务，它将作为我们体验GOAT工具完整流程的理想载体。通过这个实例，我们将学习如何追踪代码变更、监控代码执行路径，以及如何利用 GOAT 提供的实时数据做出更明智的发布决策。

构建项目

初始化项目

  1. 首先，我们创建一个基础项目结构，初始化git仓库和Go模块：
mkdir echo
cd echo && git init && go mod init echo && touch main.go


        

          
        

        
        

          

          AI 代码解读
  1. 接下来，编写一个简单的命令行问答服务，代码如下：
package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func main() {
   
    fmt.Println("欢迎使用查户口Echo服务!")
    fmt.Println("请回答以下问题，输入'退出'随时结束对话")

    scanner := bufio.NewScanner(os.Stdin)
    stage := 1
    userInfo := make(map[string]string)
    totalSteps := 3
    for {
   
        var prompt string
        var key string
        switch stage {
   
        case 1:
            key = "姓名"
            prompt = "请问您的姓名是?"
        case 2:
            key = "年龄"
            prompt = "请问您的年龄是?"
        default:
            // 总结阶段
            fmt.Println("\n===== 您的个人信息汇总 =====")
            for k, v := range userInfo {
   
                fmt.Printf("%s: %s\n", k, v)
            }
            fmt.Println("==========================")
            fmt.Println("还有什么想告诉我的吗? (输入'重新开始'可以重新填写信息)")
        }

        fmt.Print(prompt + " ")

        if !scanner.Scan() {
   
            break
        }

        input := strings.TrimSpace(scanner.Text())

        // 检查是否要退出
        if input == "退出" {
   
            fmt.Println("谢谢使用，再见!")
            break
        }

        // 回显用户输入
        if stage < totalSteps {
   
            fmt.Printf("您输入的是: %s\n", input)
        }

        // 处理用户输入
        if stage < totalSteps {
   
            userInfo[key] = input
            stage++
        } else {
   
            if input == "重新开始" {
   
                // 清空信息，重新开始
                userInfo = make(map[string]string)
                stage = 1
                fmt.Println("已重置您的信息，请重新开始。")
            } else {
   
                fmt.Printf("记录您的附加信息: %s\n", input)
                fmt.Println("还有其他想说的吗?")
            }
        }
    }

    // 处理可能的扫描错误
    if err := scanner.Err(); err != nil {
   
        fmt.Fprintln(os.Stderr, "读取输入时发生错误:", err)
    }
}


        

          
        

        
        

          

          AI 代码解读
  1. 验证程序是否正常运行：
go build -o echo . && ./echo


        

          
        

        
        

          

          AI 代码解读
  1. 提交初始代码：
git add .
git commit -m "feat: 添加 echo 命令"


        

          
        

        
        

          

          AI 代码解读

迭代项目：模拟功能增强

现在我们将通过新增几个问题来模拟实际开发中的功能迭代。新增的问题包括：

  • "请问您是哪里人"
  • "请问您是做什么工作的"
  • "请问您有什么兴趣爱好"

这些变更将作为我们测试 GOAT 代码追踪能力的基础。

  1. 首先，创建一个新的功能分支：
git checkout -b feature/additional-questions


        

          
        

        
        

          

          AI 代码解读
  1. 修改代码，添加新的问答选项：
package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func main() {
   
    fmt.Println("欢迎使用查户口Echo服务!")
    fmt.Println("请回答以下问题，输入'退出'随时结束对话")

    scanner := bufio.NewScanner(os.Stdin)
    stage := 1
    userInfo := make(map[string]string)
    totalSteps := 6 // 修改了总步骤数
    for {
   
        var prompt string
        var key string
        switch stage {
   
        case 1:
            key = "姓名"
            prompt = "请问您的姓名是?"
        case 2:
            key = "年龄"
            prompt = "请问您的年龄是?"
        // 以下是新增的问答，关于籍贯、职业、兴趣爱好的问题
        case 3:
            key = "籍贯"
            prompt = "请问您是哪里人?"
        case 4:
            key = "职业"
            prompt = "请问您是做什么工作的?"
        case 5:
            key = "兴趣爱好"
            prompt = "请问您的兴趣爱好是?"

        default:
            // 总结阶段
            fmt.Println("\n===== 您的个人信息汇总 =====")
            for k, v := range userInfo {
   
                fmt.Printf("%s: %s\n", k, v)
            }
            fmt.Println("==========================")
            fmt.Println("还有什么想告诉我的吗? (输入'重新开始'可以重新填写信息)")
        }

        fmt.Print(prompt + " ")

        if !scanner.Scan() {
   
            break
        }

        input := strings.TrimSpace(scanner.Text())

        // 检查是否要退出
        if input == "退出" {
   
            fmt.Println("谢谢使用，再见!")
            break
        }

        // 回显用户输入
        if stage < totalSteps {
   
            fmt.Printf("您输入的是: %s\n", input)
        }

        // 处理用户输入
        if stage < totalSteps {
   
            userInfo[key] = input
            stage++
        } else {
   
            if input == "重新开始" {
   
                // 清空信息，重新开始
                userInfo = make(map[string]string)
                stage = 1
                fmt.Println("已重置您的信息，请重新开始。")
            } else {
   
                fmt.Printf("记录您的附加信息: %s\n", input)
                fmt.Println("还有其他想说的吗?")
            }
        }
    }

    // 处理可能的扫描错误
    if err := scanner.Err(); err != nil {
   
        fmt.Fprintln(os.Stderr, "读取输入时发生错误:", err)
    }
}


        

          
        

        
        

          

          AI 代码解读
  1. 验证程序更新是否正常工作：
go build -o echo && ./echo


        

          
        

        
        

          

          AI 代码解读
  1. 提交功能迭代代码：
git add .
git commit -m "feat: 添加额外的用户信息收集功能"


        

          
        

        
        

          

          AI 代码解读

使用GOAT实现代码追踪

初识GOAT工具

首先，让我们了解一下 GOAT 的主要命令。执行以下命令查看 GOAT 的帮助信息：

 go install github.com/monshunter/goat/cmd/goat@latest
 goat help


        

          
        

        
        

          

          AI 代码解读

输出内容：

Goat is a tool for analyzing and instrumenting Go programs

Usage:
  goat [flags]
  goat [command]

Available Commands:
  clean       Clean up instrumentation code in project
  completion  Generate the autocompletion script for the specified shell
  help        Help about any command
  init        Initialize a new project
  patch       Process manual instrumentation markers in the project
  track       Insert instrumentation code for the project
  version     Print the version number of Goat

Flags:
  -h, --help      help for goat


        

          
        

        
        

          

          AI 代码解读

GOAT 的主要工作流程包括：

  • goat init：初始化项目配置
  • goat track：自动识别代码变更并插入追踪代码
  • goat patch：处理手动添加的追踪标记
  • goat clean：清理所有追踪代码

接下来，我们将一步步体验这个完整流程。

步骤1：配置初始化

首先执行初始化命令：

goat init


        

          
        

        
        

          

          AI 代码解读

初始化完成后， GOAT 会输出类似如下信息：

[2025/04/25 15:21:57] INFO: Start to run init command
[2025/04/25 15:21:57] INFO: initializing project
[2025/04/25 15:21:57] INFO: initializing config: /Users/xxxx/Documents/echo/goat.yaml
[2025/04/25 15:21:57] INFO: project initialized successfully
[2025/04/25 15:21:57] INFO: you can edit '/Users/xxxx/Documents/echo/goat.yaml' to customize configurations according to your needs


        

          
        

        
        

          

          AI 代码解读

GOAT 在项目根目录生成了配置文件goat.yaml，该文件包含了项目追踪所需的各项配置。其中几个重要配置项包括：

# Goat configuration goat.yaml
#
# This file is generated by goat.
# Please do modify when you know what you are doing.
# Every time the field is changed, please rerun "goat patch" to update the tracking results.
#
## App name (default: current directory name)
appName: echo

## App version (default: current .newBranch's commit short hash)
## Before running "goat track" or "goat patch",please confirm the appVersion is the correct version.
## Change when it's necessary.
appVersion: 7f6e79f

## Old branch name (for comparison base)
## Valid values are:
## 1. commit hash
## 2. branch name
## 3. tag name
## 4. ""  or "HEAD" means the current branch
## 5. "INIT" means the current repository is a new one, no old branch
## default: "main"
oldBranch: main

## New branch name (for comparison target)
## Valid values are:
## 1. commit hash
## 2. branch name
## 3. tag name
## 4. "" or "HEAD" means the current branch
## default: "HEAD"
## newBranch must be the same as the current HEAD
newBranch: HEAD

## Ignore files and directories
ignores:
  - .git
  - .gitignore
  - .DS_Store
  - .idea
  - .vscode
  - .venv
  - vendor
  - testdata
  - node_modules
  - goat/goat_generated.go

## Goat package name
goatPackageName: goat

## Goat package alias
goatPackageAlias: goat

## Goat package path, where goat package is installed in your project
goatPackagePath: goat

## Granularity ([line, patch, scope, func], default: patch)
## granularity = line: Track changes at the line level when the line is modified
## granularity = patch: Track changes at the patch(diff patch in the same scope) level when the patch is modified
## granularity = scope: Track changes at the scope level when the scope is modified
## granularity = func: Track changes at the function level when the function is modified
granularity: patch

## Diff precision (1~3, default: 1)
## diffPrecision = 1: Uses git blame to get file change history and generates tracking information based on it,
## highest precision, worst performance
## diffPrecision = 2: Uses git diff to get file change history and generates tracking information (tracks file
## renames or moves), medium precision, normal performance (100 times faster than diffPrecision = 1), in this mode,
## some renamed files may be granted as new files
## diffPrecision = 3: Uses git diff to get file change history and generates tracking information (cannot track
## file renames or moves), lowest precision, best performance (1 ~ 10 times faster than diffPrecision = 2),
## in this mode, all renamed files are granted as new files
diffPrecision: 1

## Threads (default: 1)
threads: 1

## Race (default: false)
## race: true, enable race detection, performance worse
## race: false, disable race detection, performance better
race: false

## Main entries to track (default: all)
## Specify relative paths to main packages from project root
## Examples:
##  - "*" (track all main packages)
##  - "cmd/server" (track only the main package in cmd/server)
##  - "cmd/client,cmd/server" (track multiple specific main packages)
mainEntries:
  - "*"

## Gofmt printer config, same as printer.Config
## Printer config mode, list of (none, useSpaces, tabIndent, sourcePos, rawFormat) (default: "useSpaces,tabIndent")
printerConfigMode:
  - "useSpaces"
  - "tabIndent"

## Printer config tabwidth (default: 8)
printerConfigTabwidth: 8

## Printer config indent (default: 0)
printerConfigIndent: 0

## Data type ([truth, count], default: truth)
dataType: truth

## Verbose output (default: false)
verbose: false


        

          
        

        
        

          

          AI 代码解读

这些配置允许您精确控制代码追踪的范围、粒度和性能。

步骤2：自动识别代码变更并添加埋点

现在执行追踪命令，让 GOAT 自动分析代码变更并添加埋点：

goat track


        

          
        

        
        

          

          AI 代码解读

GOAT 会输出详细的处理日志：

[2025/04/25 15:37:27] INFO: Start to run track command
[2025/04/25 15:37:27] INFO: Tracking project
[2025/04/25 15:37:27] INFO: Getting code differences
[2025/04/25 15:37:27] INFO: Getting main package infos
[2025/04/25 15:37:27] INFO: Initializing trackers
[2025/04/25 15:37:27] INFO: Replacing tracks
[2025/04/25 15:37:27] INFO: Replaced 4 tracking points
[2025/04/25 15:37:27] INFO: Saving generated file goat/goat_generated.go
[2025/04/25 15:37:27] INFO: Saving tracking points to 1 files
[2025/04/25 15:37:27] INFO: Applying main entries
[2025/04/25 15:37:27] INFO: Track applied successfully with 4 tracking points
[2025/04/25 15:37:27] INFO: ----------------------------------------------------------
[2025/04/25 15:37:27] INFO: ✅ Track completed successfully!
[2025/04/25 15:37:27] INFO: You can:
[2025/04/25 15:37:27] INFO: - Review the changes using git diff or your preferred diff tool
[2025/04/25 15:37:27] INFO: - Build and test your application to verify instrumentation
[2025/04/25 15:37:27] INFO: - If you manualy add or remove instrumentation, run 'goat patch' to update the instrumentation
[2025/04/25 15:37:27] INFO: - To remove all instrumentation, run 'goat clean'
[2025/04/25 15:37:27] INFO: ----------------------------------------------------------


        

          
        

        
        

          

          AI 代码解读

执行git status查看文件变更情况：

git status


        

          
        

        
        

          

          AI 代码解读

输出信息：

On branch feature/additional-questions
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
    modified:   main.go

Untracked files:
  (use "git add <file>..." to include in what will be committed)
    goat.yaml
    goat/

no changes added to commit (use "git add" and/or "git commit -a")


        

          
        

        
        

          

          AI 代码解读

GOAT 执行后对项目做了两项主要修改：

  1. 生成了goat/goat_generated.go文件，包含埋点相关的代码和HTTP服务
  2. 在main.go中插入了埋点追踪代码

通过git diff main.go，我们可以看到 GOAT 自动在几个关键位置插入了埋点代码：

diff --git a/main.go b/main.go
index 7dd80ee..3984e88 100644
--- a/main.go
+++ b/main.go
@@ -5,15 +5,24 @@ import (
     "fmt"
     "os"
     "strings"
+    goat "echo/goat"
 )

 func main() {
+    // +goat:main
+    // +goat:tips: do not edit the block between the +goat comments
+    goat.ServeHTTP(goat.COMPONENT_0)
+    // +goat:end
     fmt.Println("欢迎使用查户口Echo服务!")
     fmt.Println("请回答以下问题，输入'退出'随时结束对话")

     scanner := bufio.NewScanner(os.Stdin)
     stage := 1
     userInfo := make(map[string]string)
+    // +goat:generate
+    // +goat:tips: do not edit the block between the +goat comments
+    goat.Track(goat.TRACK_ID_1)
+    // +goat:end
     totalSteps := 6 // 修改了总步骤数
     for {
         var prompt string
@@ -27,12 +36,24 @@ func main() {
             prompt = "请问您的年龄是?"
         // 以下是新增的问答，关于籍贯、职业、兴趣爱好的问题
         case 3:
+            // +goat:generate
+            // +goat:tips: do not edit the block between the +goat comments
+            goat.Track(goat.TRACK_ID_2)
+            // +goat:end
             key = "籍贯"
             prompt = "请问您是哪里人?"
         case 4:
+            // +goat:generate
+            // +goat:tips: do not edit the block between the +goat comments
+            goat.Track(goat.TRACK_ID_3)
+            // +goat:end
             key = "职业"
             prompt = "请问您是做什么工作的?"
         case 5:
+            // +goat:generate
+            // +goat:tips: do not edit the block between the +goat comments
+            goat.Track(goat.TRACK_ID_4)
+            // +goat:end
             key = "兴趣爱好"
             prompt = "请问您的兴趣爱好是?"


        

          
        

        
        

          

          AI 代码解读

GOAT 自动完成了两项关键任务：

  1. 在main函数开头添加了goat.ServeHTTP(goat.COMPONENT_0)，启动用于收集埋点数据的HTTP服务
  2. 在新增的代码位置添加了goat.Track(goat.TRACK_ID_*)埋点，用于记录代码执行情况

步骤3：验证埋点效果

编译并运行添加埋点后的程序：

go build -o echo . && ./echo


        

          
        

        
        

          

          AI 代码解读

程序运行后，会输出埋点服务的启动信息：

欢迎使用查户口Echo服务!
请回答以下问题，输入'退出'随时结束对话
请问您的姓名是? 2025/04/25 16:01:49 Goat track service started: http://127.0.0.1:57005
2025/04/25 16:01:49 Goat track all components metrics in prometheus format: http://127.0.0.1:57005/metrics
2025/04/25 16:01:49 Goat track all components details: http://127.0.0.1:57005/track
2025/04/25 16:01:49 Goat track component details: http://127.0.0.1:57005/track?component=COMPONENT_ID
2025/04/25 16:01:49 Goat track components details: http://127.0.0.1:57005/track?component=COMPONENT_ID,COMPONENT_ID2
2025/04/25 16:01:49 Goat track details order by count asc: http://127.0.0.1:57005/track?component=COMPONENT_ID&order=0
2025/04/25 16:01:49 Goat track details order by count desc: http://127.0.0.1:57005/track?component=COMPONENT_ID&order=1
2025/04/25 16:01:49 Goat track details order by id asc: http://127.0.0.1:57005/track?component=COMPONENT_ID&order=2
2025/04/25 16:01:49 Goat track details order by id desc: http://127.0.0.1:57005/track?component=COMPONENT_ID&order=3


        

          
        

        
        

          

          AI 代码解读

让我们通过HTTP接口查看埋点状态：

curl http://127.0.0.1:57005/track


        

          
        

        
        

          

          AI 代码解读

初始状态下的埋点数据：

{
   
  "name": "echo",
  "version": "7f6e79f",
  "results": [
    {
   
      "id": 0,
      "name": ".",
      "metrics": {
   
        "version": "78091c90f1a220db24d82de7dcd49e37",
        "total": 4,
        "covered": 1,
        "coveredRate": 25,
        "items": [
          {
    "id": 2, "name": "TRACK_ID_2", "count": 0 },
          {
    "id": 3, "name": "TRACK_ID_3", "count": 0 },
          {
    "id": 4, "name": "TRACK_ID_4", "count": 0 },
          {
    "id": 1, "name": "TRACK_ID_1", "count": 1 }
        ]
      }
    }
  ]
}


        

          
        

        
        

          

          AI 代码解读

从上面的数据可以看出，程序刚启动时，只有TRACK_ID_1执行了一次，其余埋点尚未触发。总计有4个埋点，覆盖率为25%。

现在，进行一次完整的问答流程：

请问您的姓名是? 张三
您输入的是: 张三
请问您的年龄是? 30
您输入的是: 30
请问您是哪里人? 北京
您输入的是: 北京
请问您是做什么工作的? 软件工程师


        

          
        

        
        

          

          AI 代码解读

再次查询埋点状态：

curl http://127.0.0.1:57005/track


        

          
        

        
        

          

          AI 代码解读

更新后的埋点数据：

{
   
  "name": "echo",
  "version": "7f6e79f",
  "results": [
    {
   
      "id": 0,
      "name": ".",
      "metrics": {
   
        "version": "dfe41b436b9a52b2955e42ccde8dddce",
        "total": 4,
        "covered": 3,
        "coveredRate": 75,
        "items": [
          {
    "id": 4, "name": "TRACK_ID_4", "count": 0 },
          {
    "id": 1, "name": "TRACK_ID_1", "count": 1 },
          {
    "id": 2, "name": "TRACK_ID_2", "count": 1 },
          {
    "id": 3, "name": "TRACK_ID_3", "count": 1 }
        ]
      }
    }
  ]
}


        

          
        

        
        

          

          AI 代码解读

现在，前三个埋点都被触发了，覆盖率提升到了75%。这直观地展示了哪些新增代码被执行到，哪些尚未执行。

步骤4：手动调整埋点位置

GOAT 不仅支持自动埋点，还允许开发者手动调整埋点位置。现在，我们尝试进行两项调整：

  1. 在case 1(姓名问题)中添加一个埋点
  2. 删除case 3(籍贯问题)中的埋点

修改main.go文件，在相应位置添加标记：

package main

import (
    "bufio"
    goat "echo/goat"
    "fmt"
    "os"
    "strings"
)

func main() {
   
    // +goat:main
    // +goat:tips: do not edit the block between the +goat comments
    goat.ServeHTTP(goat.COMPONENT_0)
    // +goat:end
    fmt.Println("欢迎使用查户口Echo服务!")
    fmt.Println("请回答以下问题，输入'退出'随时结束对话")

    scanner := bufio.NewScanner(os.Stdin)
    stage := 1
    userInfo := make(map[string]string)
    // +goat:generate
    // +goat:tips: do not edit the block between the +goat comments
    goat.Track(goat.TRACK_ID_1)
    // +goat:end
    totalSteps := 6 // 修改了总步骤数
    for {
   
        var prompt string
        var key string
        switch stage {
   
        case 1:
            // +goat:insert // 插入跟踪点
            key = "姓名"
            prompt = "请问您的姓名是?"
        case 2:
            key = "年龄"
            prompt = "请问您的年龄是?"
        // 以下是新增的问答，关于籍贯、职业、兴趣爱好的问题
        case 3:
            // +goat:delete // 删除跟踪点
            // +goat:tips: do not edit the block between the +goat comments
            goat.Track(goat.TRACK_ID_2)
            // +goat:end
            key = "籍贯"
            prompt = "请问您是哪里人?"
        case 4:
            // +goat:generate
            // +goat:tips: do not edit the block between the +goat comments
            goat.Track(goat.TRACK_ID_3)
            // +goat:end
            key = "职业"
            prompt = "请问您是做什么工作的?"
        case 5:
            // +goat:generate
            // +goat:tips: do not edit the block between the +goat comments
            goat.Track(goat.TRACK_ID_4)
            // +goat:end
            key = "兴趣爱好"
            prompt = "请问您的兴趣爱好是?"

        default:
            // 总结阶段
            fmt.Println("\n===== 您的个人信息汇总 =====")
            for k, v := range userInfo {
   
                fmt.Printf("%s: %s\n", k, v)
            }
            fmt.Println("==========================")
            fmt.Println("还有什么想告诉我的吗? (输入'重新开始'可以重新填写信息)")
        }

        fmt.Print(prompt + " ")

        if !scanner.Scan() {
   
            break
        }

        input := strings.TrimSpace(scanner.Text())

        // 检查是否要退出
        if input == "退出" {
   
            fmt.Println("谢谢使用，再见!")
            break
        }

        // 回显用户输入
        if stage < totalSteps {
   
            fmt.Printf("您输入的是: %s\n", input)
        }

        // 处理用户输入
        if stage < totalSteps {
   
            userInfo[key] = input
            stage++
        } else {
   
            if input == "重新开始" {
   
                // 清空信息，重新开始
                userInfo = make(map[string]string)
                stage = 1
                fmt.Println("已重置您的信息，请重新开始。")
            } else {
   
                fmt.Printf("记录您的附加信息: %s\n", input)
                fmt.Println("还有其他想说的吗?")
            }
        }
    }

    // 处理可能的扫描错误
    if err := scanner.Err(); err != nil {
   
        fmt.Fprintln(os.Stderr, "读取输入时发生错误:", err)
    }
}


        

          
        

        
        

          

          AI 代码解读

现在执行goat patch命令，处理这些手动标记：

goat patch


        

          
        

        
        

          

          AI 代码解读

输出结果：

[2025/04/25 16:30:14] INFO: Start to run patch command
[2025/04/25 16:30:14] INFO: Patching project
[2025/04/25 16:30:14] INFO: Getting main package infos
[2025/04/25 16:30:14] INFO: Preparing files
[2025/04/25 16:30:14] INFO: Applying patch
[2025/04/25 16:30:14] INFO: Total replaced tracks: 4
[2025/04/25 16:30:14] INFO: Patch applied
[2025/04/25 16:30:14] INFO: ----------------------------------------------------------
[2025/04/25 16:30:14] INFO: ✅ Patch applied successfully!
[2025/04/25 16:30:14] INFO: Manual markers have been processed (// +goat:delete, // +goat:insert)
[2025/04/25 16:30:14] INFO: You can:
[2025/04/25 16:30:14] INFO: - Review the changes using git diff or your preferred diff tool
[2025/04/25 16:30:14] INFO: - Build and test your application to verify the changes
[2025/04/25 16:30:14] INFO: - Add more manual markers and run 'goat fix' again if needed
[2025/04/25 16:30:14] INFO: - If you want to remove all instrumentation, run 'goat clean'
[2025/04/25 16:30:14] INFO: ----------------------------------------------------------


        

          
        

        
        

          

          AI 代码解读

查看更新后的main.go文件，可以发现：

// Omit the existing code ...
for {
   
        var prompt string
        var key string
        switch stage {
   
        case 1:
            // +goat:generate
            // +goat:tips: do not edit the block between the +goat comments
            goat.Track(goat.TRACK_ID_2)
            // +goat:end
            key = "姓名"
            prompt = "请问您的姓名是?"
        case 2:
            key = "年龄"
            prompt = "请问您的年龄是?"
        // 以下是新增的问答，关于籍贯、职业、兴趣爱好的问题
        case 3:
            key = "籍贯"
            prompt = "请问您是哪里人?"
        case 4:
            // +goat:generate
            // +goat:tips: do not edit the block between the +goat comments
            goat.Track(goat.TRACK_ID_3)
            // +goat:end
            key = "职业"
            prompt = "请问您是做什么工作的?"
        case 5:
            // +goat:generate
            // +goat:tips: do not edit the block between the +goat comments
            goat.Track(goat.TRACK_ID_4)
            // +goat:end
            key = "兴趣爱好"
            prompt = "请问您的兴趣爱好是?"

        default:
            // 总结阶段
            fmt.Println("\n===== 您的个人信息汇总 =====")
            for k, v := range userInfo {
   
                fmt.Printf("%s: %s\n", k, v)
            }
            fmt.Println("==========================")
            fmt.Println("还有什么想告诉我的吗? (输入'重新开始'可以重新填写信息)")
        }

        fmt.Print(prompt + " ")

        if !scanner.Scan() {
   
            break
        }

        input := strings.TrimSpace(scanner.Text())

        // 检查是否要退出
        if input == "退出" {
   
            fmt.Println("谢谢使用，再见!")
            break
        }

        // 回显用户输入
        if stage < totalSteps {
   
            fmt.Printf("您输入的是: %s\n", input)
        }

        // 处理用户输入
        if stage < totalSteps {
   
            userInfo[key] = input
            stage++
        } else {
   
            if input == "重新开始" {
   
                // 清空信息，重新开始
                userInfo = make(map[string]string)
                stage = 1
                fmt.Println("已重置您的信息，请重新开始。")
            } else {
   
                fmt.Printf("记录您的附加信息: %s\n", input)
                fmt.Println("还有其他想说的吗?")
            }
        }
    }
    // Omit the existing code ...


        

          
        

        
        

          

          AI 代码解读
  • 在case 1中添加了新的埋点代码
  • 删除了case 3中的埋点代码

这展示了 GOAT 对手动精细调整埋点位置的灵活支持。

步骤5：清理埋点代码

在完成测试或发布后，您可能希望清理所有埋点代码。 GOAT 提供了简单的清理命令：

goat clean


        

          
        

        
        

          

          AI 代码解读

执行结果：

[2025/04/25 16:38:07] INFO: Start to run clean command
[2025/04/25 16:38:07] INFO: Cleaning project
[2025/04/25 16:38:07] INFO: Preparing files
[2025/04/25 16:38:07] INFO: Prepared 1 files
[2025/04/25 16:38:07] INFO: Cleaning contents
[2025/04/25 16:38:07] INFO: Total cleaned files: 1
[2025/04/25 16:38:07] INFO: Cleaned project
[2025/04/25 16:38:07] INFO: ----------------------------------------------------------
[2025/04/25 16:38:07] INFO: ✅ Clean completed successfully!
[2025/04/25 16:38:07] INFO: All instrumentation code has been removed from your project.
[2025/04/25 16:38:07] INFO: You can:
[2025/04/25 16:38:07] INFO: - Review the changes using git diff or your preferred diff tool
[2025/04/25 16:38:07] INFO: - Build and test your application to verify clean up
[2025/04/25 16:38:07] INFO: - If you want to reapply instrumentation, run 'goat patch'
[2025/04/25 16:38:07] INFO: ----------------------------------------------------------


        

          
        

        
        

          

          AI 代码解读

使用 git status 查看工作区域：

git status


        

          
        

        
        

          

          AI 代码解读

状态如下，可以看到工作区已经恢复

On branch feature/additional-questions
Untracked files:
  (use "git add <file>..." to include in what will be committed)
    goat.yaml

nothing added to commit but untracked files present (use "git add" to track)


        

          
        

        
        

          

          AI 代码解读

此命令会移除项目中所有 GOAT 相关的埋点代码，确保代码干净、轻量，适合生产环境部署。

总结与应用场景

通过这个Echo问答服务示例，我们完整体验了 GOAT 工具的核心功能与工作流程：

  1. 初始化配置：使用goat init建立项目配置，精确控制追踪粒度和范围
  2. 自动代码埋点：通过goat track智能识别代码变更并自动插入追踪代码
  3. 数据实时监控：通过内置HTTP服务实时查看代码执行覆盖情况
  4. 手动埋点调整：利用goat patch灵活添加或删除特定位置的埋点

  5. 代码清理恢复：使用goat clean快速移除所有埋点代码

    GOAT 在以下场景中尤其有价值：

  • 灰度发布：监控新版本中各项功能的实际执行情况，为扩大灰度比例提供数据支持
  • 功能验证：确保增量代码在真实环境中得到充分测试和验证
  • 性能分析：精准定位代码执行路径，辅助识别性能瓶颈
  • bug排查：追踪代码执行流程，快速定位异常点
  • 代码重构：确保重构后的代码路径全面覆盖，提升代码质量

作为一款专为Go语言设计的代码追踪工具， GOAT 以其轻量、高效、精准的特性，为Go项目的质量保障和平稳发布提供了强有力的支持。它不仅简化了代码埋点的流程，还通过实时数据帮助开发团队做出更明智的决策。

无论您是单体应用还是微服务架构，是初创项目还是大型系统， GOAT 都能以最小的侵入性为您的灰度发布保驾护航。

尝试将 GOAT 集成到您的开发流程中，体验数据驱动的灰度发布新模式！

文章标签：
日志服务
监控
Go
测试技术
开发工具
git
关键词：
日志服务监控
HTTP接口代码
HTTP代码
HTTP接口
HTTP监控
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
啊逗
+关注
1文章
目录
打赏
0
34
34
3
3
分享
相关文章
蓝易云
|
2月前
|
JSON API 网络架构
HTTP常见的请求方法、响应状态码、接口规范介绍
本文详细介绍了HTTP常见的请求方法、响应状态码和接口规范。通过理解和掌握这些内容，开发者可以更好地设计和实现W
蓝易云
403 83
阿里云云原生
|
1月前
|
消息中间件 运维 监控
智能运维，由你定义：SAE自定义日志与监控解决方案
通过引入 Sidecar 容器的技术，SAE 为用户提供了更强大的自定义日志与监控解决方案，帮助用户轻松实现日志采集、监控指标收集等功能。未来，SAE 将会支持 istio 多租场景，帮助用户更高效地部署和管理服务网格。
阿里云云原生
283 51
蓝易云
|
1月前
|
Linux C语言 iOS开发
C语言结合AWTK开发HTTP接口访问界面
这样，我们就实现了在C语言中使用libcurl和AWTK来访问HTTP接口并在界面上显示结果。这只是一个基础的示例，你可以根据需要添加更多的功能和优化。例如，你可以添加错误处理机制、支持更多HTTP方法（如POST、PUT等）、优化用户界面等。
蓝易云
212 75
奔跑的数据
|
2月前
|
数据采集 运维 监控
数据采集监控与告警：错误重试、日志分析与自动化运维
本文探讨了数据采集技术从“简单采集”到自动化运维的演进。传统方式因反爬策略和网络波动常导致数据丢失，而引入错误重试、日志分析与自动化告警机制可显著提升系统稳定性与时效性。正方强调健全监控体系的重要性，反方则担忧复杂化带来的成本与安全风险。未来，结合AI与大数据技术，数据采集将向智能化、全自动方向发展，实现动态调整与智能识别反爬策略，降低人工干预需求。附带的Python示例展示了如何通过代理IP、重试策略及日志记录实现高效的数据采集程序。
奔跑的数据
115 7
数据采集监控与告警：错误重试、日志分析与自动化运维
游客mass6jalwg5qm
|
25天前
|
XML 网络协议 程序员
Apipost接口调试全解：从HTTP到gRPC，程序员必备的“协议生存指南
Apipost是一款强大的接口调试工具，支持多种主流API协议。它涵盖HTTP/HTTPS、WebSocket、Socket.IO、gRPC、GraphQL、TCP及ISO8583金融报文等冷门协议。通过Body多样化、全局参数配置、性能分析等功能优化HTTP调试；提供WebSocket多消息存档与事件监听；gRPC支持服务反射和流式调试；GraphQL可自动生成Schema；TCP报文模板专业精准；SSE配置简单。此外，Apipost还具备环境变量、脚本加持和文档生成功能，是提升开发效率的全能工具。
游客mass6jalwg5qm
58 4
流水刀客6
|
2月前
|
存储 缓存 搜索推荐
HTTP500代码怎么解决？常见的5xx网页错误及其原因
本文介绍了如何修复HTTP 500错误及常见的5xx网页错误。500错误表示服务器无法处理请求，可能由文件权限、脚本错误、数据库连接或配置问题引起。作为用户，可尝试重新加载页面、检查URL或清除缓存；作为网站所有者，需检查`.htaccess`文件、服务器日志、插件冲突及PHP版本等。此外，文章还列举了其他5xx错误（如502、503、504等）及其原因，帮助定位和解决服务器端问题，避免影响流量与搜索引擎排名。
流水刀客6
326 4
陌陌谣
|
2月前
|
存储 监控 算法
基于 PHP 语言的滑动窗口频率统计算法在公司局域网监控电脑日志分析中的应用研究
在当代企业网络架构中，公司局域网监控电脑系统需实时处理海量终端设备产生的连接日志。每台设备平均每分钟生成 3 至 5 条网络请求记录，这对监控系统的数据处理能力提出了极高要求。传统关系型数据库在应对这种高频写入场景时，性能往往难以令人满意。故而，引入特定的内存数据结构与优化算法成为必然选择。
陌陌谣
43 3
testjessie
|
2月前
|
消息中间件 运维 监控
智能运维，由你定义：SAE自定义日志与监控解决方案
SAE（Serverless应用引擎）是阿里云推出的全托管PaaS平台，致力于简化微服务应用开发与管理。为满足用户对可观测性和运维能力的更高需求，SAE引入Sidecar容器技术，实现日志采集、监控指标收集等功能扩展，且无需修改主应用代码。通过共享资源模式和独立资源模式，SAE平衡了资源灵活性与隔离性。同时，提供全链路运维能力，确保应用稳定性。未来，SAE将持续优化，支持更多场景，助力用户高效用云。
testjessie
163 2
游客dk6iqnpz2vtei
|
2月前
|
运维 监控 虚拟化
除了实时性能监控，Hyper-V还支持日志记录和警报功能你知道吗？
Hyper-V不仅支持实时性能监控，还具备强大的日志记录和警报功能。通过事件查看器可访问详细的日志文件，涵盖虚拟机管理、配置及Hypervisor事件，帮助故障排查和性能分析。警报功能支持预定义和自定义规则，可通过多种方式通知管理员，确保及时响应问题，保障虚拟化环境的稳定运行。
游客dk6iqnpz2vtei
83 4
@dailidong@
|
Web App开发
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <html><head><meta http-equiv="Cont
TCP洪水攻击（SYN Flood）的诊断和处理 Posted by  海涛  on 2013 年 7 月 11 日 Tweet1 ​1. SYN Flood介绍 前段时间网站被攻击多次，其中最猛烈的就是TCP洪水攻击，即SYN Flood。
@dailidong@
1055 0
云原生

云原生可观测
+关注

热门文章

最新文章

  • 1
    Istio on ACK集成生态(1): 集成TSDB助力可观测性存储
    1405
  • 2
    Grafana Loki，轻量级日志系统
    82
  • 3
    MCP Server 开发实战 | 大模型无缝对接 Grafana
    78
  • 4
    面对MCP"工具投毒"，我们该如何应对
    39
  • 5
    日志采集效能跃迁：iLogtail 到 LoongCollector 的全面升级
    31
  • 6
    千万级可观测数据采集器--iLogtail代码完整开源
    23
  • 7
    🎉 WatchAlert - 开源多数据源告警引擎【运维研发必备能力】
    19
  • 8
    MES系统软件体系架构及应用
    18
  • 9
    当 OpenTelemetry 遇上阿里云 Prometheus
    14
  • 10
    告别传统Log追踪！GOAT如何用HTTP接口重塑代码监控
    14
  • 1
    日志采集效能跃迁：iLogtail 到 LoongCollector 的全面升级
    31
  • 2
    面对MCP"工具投毒"，我们该如何应对
    39
  • 3
    告别传统Log追踪！GOAT如何用HTTP接口重塑代码监控
    160
  • 4
    无感改造，完美监控：Docker 多阶段构建 Go 应用无侵入观测
    99
  • 5
    MCP Server 开发实战 | 大模型无缝对接 Grafana
    923
  • 6
    不断突破极致：SPL新版数据加工能力焕新登场
    116
  • 7
    阿里云可观测 2025 年 3 月产品动态
    92
  • 8
    GraalVM 24 正式发布阿里巴巴贡献重要特性 —— 支持 Java Agent 插桩
    162
  • 9
    当实时消费遇到 SPL：让数据处理更高效、简单
    68
  • 10
    SLS 重磅升级：超大规模数据实现完全精确分析
    307

    • 相关课程

    更多
  • 日志服务SLS实现云产品可观测
  • 日志服务 SLS 可观测数据分析平台介绍
  • 大数据知识图谱系列—基于ELK+Flink日志全观测最佳实践
  • Java Web开发-Web应用、Tomcat、HTTP请求与响应
  • 场景实践-基于阿里云Quick BI 对MOOC网站日志分析
  • 云安全基础课- HTTP协议基础

    • 相关电子书

    更多
  • Python 系列直播——深入Python与日志服务，玩转大规模数据分析处理实战第二讲
  • Python第四讲——使用IPython/Jupyter Notebook与日志服务玩转超大规模数据分析与可视化
  • 大规模日志数据平台架构面临的问题与挑战

    • 相关实验场景

    更多
  • 通过轻量消息队列（原MNS）主题HTTP订阅+ARMS实现自定义数据多渠道告警
  • 使用CloudLens管理SLS日志采集
  • 使用CloudLens采集PolarDB日志并进行审计分析
  • 使用CloudLens采集RDS日志并进行审计分析
  • 使用日志服务SLS进行OSS可观测分析
  • 前端开发基础2：VS Code和Edge的联动开发
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月
    目录