SkyAPM是如何实现链路追踪的

原创 已于 2024-04-22 11:53:36 修改 · 1.4k 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#asp.net #skywalking

于 2024-04-20 17:00:29 首次发布

一、链路追踪的原理

链路追踪系统（可能）最早是由Goggle公开发布的一篇论文
《Dapper, a Large-Scale Distributed Systems Tracing Infrastructure》

翻译参考: https://zhuanlan.zhihu.com/p/38255020#%E6%A6%82%E8%A7%88
参考博文： https://baijiahao.baidu.com/s?id=1708807913437543359&wfr=spider&for=pc

在这里插入图片描述

总结：通过事先在日志中埋点，找出相同traceId的日志，再加上parent id和span id就可以将一条完整的请求调用链串联起来。

二、SkyAPM的使用

1、为项目添加NuGet程序包SkyAPM.Agent.AspNetCore的引用

2、在程序包管理控制台执行下面命令

dotnet tool install -g SkyAPM.DotNet.CLI  
dotnet skyapm config 服务名称 192.168.0.5:11800

执行上面命令会在项目根目录添加skyapm.json文件，并添加下以内容，其中的Servers结点的IP地址根据实际情况换成自己的服务器IP

{
  "SkyWalking": {
    "ServiceName": "服务名称",
    "Namespace": "",
    "HeaderVersions": [
      "sw6"
    ],
    "Sampling": {
      "SamplePer3Secs": -1,
      "Percentage": -1.0
    },
    "Logging": {
      "Level": "Debug",
      "FilePath": "logs/skyapm-{Date}.log"
    },
    "Transport": {
      "Interval": 3000,
      "ProtocolVersion": "v6",
      "QueueSize": 30000,
      "BatchSize": 3000,
      "gRPC": {
        "Servers": "192.168.150.134:11800",
        "Timeout": 10000,
        "ConnectTimeout": 10000,
        "ReportTimeout": 600000
      }
    }
  }
}

3、修改skyapm.json文件的属性”复制到输入目录“ 修改为 ”如果较新则复制”

4、展开项目的Properties，打开launchSettings.json文件，在其中的环境变量中加入

"SKYWALKING__SERVICENAME": "服务名称"  
"ASPNETCORE_HOSTINGSTARTUPASSEMBLIES": "SkyAPM.Agent.AspNetCore"

5、部署到IIS，在web.config中添加 environmentVariable 的配置

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <location path="." inheritInChildApplications="false">
    <system.webServer>
      <handlers>
        <add name="aspNetCore" path="*" verb="*" modules="AspNetCoreModuleV2" resourceType="Unspecified" />
      </handlers>
      <aspNetCore processPath="dotnet" arguments=".\KeyingPlatform.Api.dll" stdoutLogEnabled="false" stdoutLogFile=".\logs\stdout" hostingModel="inprocess">
         <environmentVariables>
          <environmentVariable name="ASPNETCORE_HOSTINGSTARTUPASSEMBLIES" value="SkyAPM.Agent.AspNetCore"/>
          <environmentVariable name="SKYWALKING__SERVICENAME" value="KeyingPlatform.Api"/>
        </environmentVariables>
      </aspNetCore>
    </system.webServer>
  </location>
</configuration>

三、例子分析

1、示例说明

（1）按上面SkyAPM的使用在API项目中引入SkyAPM
（2）创建两个测试项目
（3）第一个项目调用第二个项目中的接口
(4) 第二个项目中调用了其他项目的接口
代码如下：
第一个项目

		[HttpGet]
		public async Task<string> TraceTestMethod()
		{
			string body = string.Empty;
			var client = new HttpClient();
			var request = new HttpRequestMessage
			{
				Method = HttpMethod.Get,
				RequestUri = new Uri("http://localhost:11700/Trace2Test/TraceTestMethod"),
			};
			using (var response = await client.SendAsync(request))
			{
				response.EnsureSuccessStatusCode();
				body = await response.Content.ReadAsStringAsync();
				Console.WriteLine(body);
			}
			return body;
		}

第二个项目

		/// <summary>
		/// 测试代码
		/// </summary>
		/// <returns></returns>
		[HttpGet]
		public async Task< string> TraceTestMethod()
		{
			string body = string.Empty;
			var client = new HttpClient();
			var request = new HttpRequestMessage
			{
				Method = HttpMethod.Post,
				RequestUri = new Uri("测试接口地址"),
			};
			using (var response = await client.SendAsync(request))
			{
				response.EnsureSuccessStatusCode();
				 body = await response.Content.ReadAsStringAsync();
				Console.WriteLine(body);
			}
			return body;
		}

2、trace结果

“6f71bfc22c46b1cf516b564af18d4dbc.24.17135989337850001”

调用第一个项目的接口，写trace时先写访问第二个项目的trace,再写访问第一个项目接口的trace
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3、界面展示

在这里插入图片描述

用户发起请求时所带的header信息
在这里插入图片描述

代码发起请求时所带的header信息（接口中调用远程信息）

在这里插入图片描述

四、源码分析

1、源码地址

源码： https://github.com/SkyAPM/SkyAPM-dotnet/
protocol-v3下载： https://github.com/apache/skywalking-data-collect-protocol/tree/29552022b01a55ec197641f569f19c1648d49acd
注意：
在这里插入图片描述

2、图解

程序启动时先通过环境变量的配置加载程序集：SkyAPM.Agent.AspNetCore
在这里插入图片描述

1、 InstrumentationHostedService: 程序入口,调用InstrumentStartup
    internal class InstrumentationHostedService : IHostedService
    {
        private readonly IInstrumentStartup _startup;

        public InstrumentationHostedService(IInstrumentStartup startup)
        {
            _startup = startup;
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            return _startup.StartAsync(cancellationToken);
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            return _startup.StopAsync(cancellationToken);
        }
    }
2、 InstrumentStartup：

启动服务：譬如推送trace的报告服务SegmentReportService
foreach (var service in _services)
await service.StartAsync(cancellationToken);

trace的监听：HostingTracingDiagnosticProcessor
DiagnosticListener.AllListeners.Subscribe(_observer);

    public class InstrumentStartup : IInstrumentStartup
    {
        private readonly TracingDiagnosticProcessorObserver _observer;
        private readonly IEnumerable<IExecutionService> _services;
        private readonly ILogger _logger;

        public InstrumentStartup(TracingDiagnosticProcessorObserver observer, IEnumerable<IExecutionService> services, ILoggerFactory loggerFactory)
        {
            _observer = observer;
            _services = services;
            _logger = loggerFactory.CreateLogger(typeof(InstrumentStartup));
        }

        public async Task StartAsync(CancellationToken cancellationToken = default(CancellationToken))
        {
            _logger.Information("Initializing ...");
            foreach (var service in _services)
                await service.StartAsync(cancellationToken);
            DiagnosticListener.AllListeners.Subscribe(_observer);
            _logger.Information("Started SkyAPM .NET Core Agent.");
        }

        public async Task StopAsync(CancellationToken cancellationToken = default(CancellationToken))
        {
            foreach (var service in _services)
                await service.StopAsync(cancellationToken);
            _logger.Information("Stopped SkyAPM .NET Core Agent.");
            // ReSharper disable once MethodSupportsCancellation
            await Task.Delay(TimeSpan.FromSeconds(2));
        }
    }
3、TracingDiagnosticProcessorObserver
						…………
						
    public void OnNext(DiagnosticListener listener)
    {
        foreach (var diagnosticProcessor in _tracingDiagnosticProcessors.Distinct(x => x.ListenerName))
        {
            if (listener.Name == diagnosticProcessor.ListenerName)
            {
                Subscribe(listener, diagnosticProcessor);
                _logger.Information(
                    $"Loaded diagnostic listener [{diagnosticProcessor.ListenerName}].");
            }
        }
    }

    protected virtual void Subscribe(DiagnosticListener listener,
        ITracingDiagnosticProcessor tracingDiagnosticProcessor)
    {
        var diagnosticProcessor = new TracingDiagnosticObserver(tracingDiagnosticProcessor, _loggerFactory);
        listener.Subscribe(diagnosticProcessor, diagnosticProcessor.IsEnabled);
    }


						…………
4、TracingDiagnosticObserver： 在执行http请求前 和 http请求后 会执行的方法
 internal class TracingDiagnosticObserver : IObserver<KeyValuePair<string, object>>
 {
     private readonly Dictionary<string, TracingDiagnosticMethod> _methodCollection;
     private readonly ILogger _logger;

     public TracingDiagnosticObserver(ITracingDiagnosticProcessor tracingDiagnosticProcessor,
         ILoggerFactory loggerFactory)
     {
         _methodCollection = new TracingDiagnosticMethodCollection(tracingDiagnosticProcessor)
             .ToDictionary(method => method.DiagnosticName);
         _logger = loggerFactory.CreateLogger(typeof(TracingDiagnosticObserver));
     }

     public bool IsEnabled(string diagnosticName)
     {
         return _methodCollection.ContainsKey(diagnosticName);
     }

     public void OnCompleted()
     {
     }

     public void OnError(Exception error)
     {
     }

     public void OnNext(KeyValuePair<string, object> value)
     {
         if (!_methodCollection.TryGetValue(value.Key, out var method))
             return;

         try
         {
             method.Invoke(value.Key, value.Value);
         }
         catch (Exception exception)
         {
             _logger.Error("Invoke diagnostic method exception.", exception);
         }
     }
 }
5、HostingTracingDiagnosticProcessor：在执行http请求前 和 http请求后添加trace的信息，请求完成后，它trace信息写入队列，等待推送到服务器
public class HostingTracingDiagnosticProcessor : ITracingDiagnosticProcessor
{
    public string ListenerName { get; } = "Microsoft.AspNetCore";

    private readonly ITracingContext _tracingContext;
    private readonly IEntrySegmentContextAccessor _segmentContextAccessor;
    private readonly IEnumerable<IHostingDiagnosticHandler> _diagnosticHandlers;
    private readonly TracingConfig _tracingConfig;

    public HostingTracingDiagnosticProcessor(IEntrySegmentContextAccessor segmentContextAccessor,
        ITracingContext tracingContext, IEnumerable<IHostingDiagnosticHandler> diagnosticHandlers,
        IConfigAccessor configAccessor)
    {
        _tracingContext = tracingContext;
        _diagnosticHandlers = diagnosticHandlers.Reverse();
        _segmentContextAccessor = segmentContextAccessor;
        _tracingConfig = configAccessor.Get<TracingConfig>();
    }

    /// <remarks>
    /// Variable name starts with an upper case, because it's used for parameter binding. In both ASP .NET Core 2.x and 3.x we get an object in which 
    /// HttpContext of the current request is available under the `HttpContext` property.
    /// </remarks>
    [DiagnosticName("Microsoft.AspNetCore.Hosting.HttpRequestIn.Start")]
    public void BeginRequest([Property] HttpContext HttpContext)
    {
        foreach (var handler in _diagnosticHandlers)
        {
            if (handler.OnlyMatch(HttpContext))
            {
                handler.BeginRequest(_tracingContext, HttpContext);
                return;
            }
        }
    }

    /// <remarks>
    /// See remarks in <see cref="BeginRequest(HttpContext)"/>.
    /// </remarks>
    [DiagnosticName("Microsoft.AspNetCore.Hosting.HttpRequestIn.Stop")]
    public void EndRequest([Property] HttpContext HttpContext)
    {
        var context = _segmentContextAccessor.Context;
        if (context == null)
        {
            return;
        }

        foreach (var handler in _diagnosticHandlers)
        {
            if (handler.OnlyMatch(HttpContext))
            {
                handler.EndRequest(context, HttpContext);
                break;
            }
        }

        _tracingContext.Release(context);
    }

}
6、DefaultHostingDiagnosticHandler:生成 trace 信息
    public class DefaultHostingDiagnosticHandler : IHostingDiagnosticHandler
    {
        private readonly HostingDiagnosticConfig _config;

        public DefaultHostingDiagnosticHandler(IConfigAccessor configAccessor)
        {
            _config = configAccessor.Get<HostingDiagnosticConfig>();
        }

        public bool OnlyMatch(HttpContext request)
        {
            return true;
        }

        public void BeginRequest(ITracingContext tracingContext, HttpContext httpContext)
        {
            var context = tracingContext.CreateEntrySegmentContext(httpContext.Request.Path,
                new HttpRequestCarrierHeaderCollection(httpContext.Request));
            context.Span.SpanLayer = SpanLayer.HTTP;
            context.Span.Component = Common.Components.ASPNETCORE;
            context.Span.Peer = new StringOrIntValue(httpContext.Connection.RemoteIpAddress.ToString());
            context.Span.AddTag(Tags.URL, httpContext.Request.GetDisplayUrl());
            context.Span.AddTag(Tags.PATH, httpContext.Request.Path);
            context.Span.AddTag(Tags.HTTP_METHOD, httpContext.Request.Method);

            if(_config.CollectCookies?.Count > 0)
            {
                var cookies = CollectCookies(httpContext, _config.CollectCookies);
                if (!string.IsNullOrEmpty(cookies))
                    context.Span.AddTag(Tags.HTTP_COOKIES, cookies);
            }

            if(_config.CollectHeaders?.Count > 0)
            {
                var headers = CollectHeaders(httpContext, _config.CollectHeaders);
                if (!string.IsNullOrEmpty(headers))
                    context.Span.AddTag(Tags.HTTP_HEADERS, headers);
            }

            if(_config.CollectBodyContentTypes?.Count > 0)
            {
                var body = CollectBody(httpContext, _config.CollectBodyLengthThreshold);
                if (!string.IsNullOrEmpty(body))
                    context.Span.AddTag(Tags.HTTP_REQUEST_BODY, body);
            }
        }

        public void EndRequest(SegmentContext segmentContext, HttpContext httpContext)
        {
            var statusCode = httpContext.Response.StatusCode;
            if (statusCode >= 400)
            {
                segmentContext.Span.ErrorOccurred();
            }

            segmentContext.Span.AddTag(Tags.STATUS_CODE, statusCode);
        }

        private string CollectCookies(HttpContext httpContext, IEnumerable<string> keys)
        {
            var sb = new StringBuilder();
            foreach (var key in keys)
            {
                if (!httpContext.Request.Cookies.TryGetValue(key, out string value))
                    continue;

                if(sb.Length > 0)
                    sb.Append("; ");

                sb.Append(key);
                sb.Append('=');
                sb.Append(value);
            }
            return sb.ToString();
        }

        private string CollectHeaders(HttpContext httpContext, IEnumerable<string> keys)
        {
            var sb = new StringBuilder();
            foreach (var key in keys)
            {
                if (!httpContext.Request.Headers.TryGetValue(key, out StringValues value))
                    continue;

                if(sb.Length > 0)
                    sb.Append('\n');

                sb.Append(key);
                sb.Append(": ");
                sb.Append(value);
            }
            return sb.ToString();
        }

        private string CollectBody(HttpContext httpContext, int lengthThreshold)
        {
            var request = httpContext.Request;

            if (string.IsNullOrEmpty(httpContext.Request.ContentType)
                || httpContext.Request.ContentLength == null
                || request.ContentLength > lengthThreshold)
            {
                return null;
            }

            var contentType = new ContentType(request.ContentType);
            if (!_config.CollectBodyContentTypes.Any(supportedType => contentType.MediaType == supportedType))
                return null;

#if NETSTANDARD2_0
            httpContext.Request.EnableRewind();
#else
            httpContext.Request.EnableBuffering();
#endif
            request.Body.Position = 0;
            try
            {
                var encoding = contentType.CharSet.ToEncoding(Encoding.UTF8);
                using (var reader = new StreamReader(request.Body, encoding, true, 1024, true))
                {
                    var body = reader.ReadToEndAsync().Result;
                    return body;
                }
            }
            finally
            {
                request.Body.Position = 0;
            }
        }
    }

7、AsyncQueueSegmentDispatcher：trace入队、定时推送trace信息

    public class AsyncQueueSegmentDispatcher : ISegmentDispatcher
    {
        private readonly ILogger _logger;
        private readonly TransportConfig _config;
        private readonly ISegmentReporter _segmentReporter;
        private readonly ISegmentContextMapper _segmentContextMapper;
        private readonly ConcurrentQueue<SegmentRequest> _segmentQueue;
        private readonly IRuntimeEnvironment _runtimeEnvironment;
        private readonly CancellationTokenSource _cancellation;
        private int _offset;

        public AsyncQueueSegmentDispatcher(IConfigAccessor configAccessor,
            ISegmentReporter segmentReporter, IRuntimeEnvironment runtimeEnvironment,
            ISegmentContextMapper segmentContextMapper, ILoggerFactory loggerFactory)
        {
            _segmentReporter = segmentReporter;
            _segmentContextMapper = segmentContextMapper;
            _runtimeEnvironment = runtimeEnvironment;
            _logger = loggerFactory.CreateLogger(typeof(AsyncQueueSegmentDispatcher));
            _config = configAccessor.Get<TransportConfig>();
            _segmentQueue = new ConcurrentQueue<SegmentRequest>();
            _cancellation = new CancellationTokenSource();
        }

        public bool Dispatch(SegmentContext segmentContext)
        {
            if (!_runtimeEnvironment.Initialized || segmentContext == null || !segmentContext.Sampled)
                return false;

            // todo performance optimization for ConcurrentQueue
            if (_config.QueueSize < _offset || _cancellation.IsCancellationRequested)
                return false;

            var segment = _segmentContextMapper.Map(segmentContext);

            if (segment == null)
                return false;

            _segmentQueue.Enqueue(segment);

            Interlocked.Increment(ref _offset);

            _logger.Debug($"Dispatch trace segment. [SegmentId]={segmentContext.SegmentId}.");
            return true;
        }

        public Task Flush(CancellationToken token = default(CancellationToken))
        {
            // todo performance optimization for ConcurrentQueue
            //var queued = _segmentQueue.Count;
            //var limit = queued <= _config.PendingSegmentLimit ? queued : _config.PendingSegmentLimit;
            var limit = _config.BatchSize;
            var index = 0;
            var segments = new List<SegmentRequest>(limit);
            while (index++ < limit && _segmentQueue.TryDequeue(out var request))
            {
                segments.Add(request);
                Interlocked.Decrement(ref _offset);
            }

            // send async
            if (segments.Count > 0)
                _segmentReporter.ReportAsync(segments, token);

            Interlocked.Exchange(ref _offset, _segmentQueue.Count);

            return Task.CompletedTask;
        }

        public void Close()
        {
            _cancellation.Cancel();
        }
    }
如何实现分布式调用跟踪？
悟已往之不谏，知来者之可追
09-23 426
分布式服务拆分以后，系统变得日趋复杂，业务的调用链也越来越长，如何快速定位线上故障，就需要依赖分布式调用跟踪技术。下面我们一起来看下分布式调用链相关的实现。 文章目录为什么需要分布式调用跟踪分布式调用跟踪的业务场景分布式调用跟踪实现原理分布式调用跟踪的选型Google 的 DrapperTwitter 的 Zipkin阿里的 EagleEye 为什么需要分布式调用跟踪 随着分布式服务架构的流行，特别是微服务等设计理念在系统中的应用，系统架构变得越来越分散， 左侧是集中式架构，右侧是分布式微服务框架。 如下图
揭秘C#微服务链路追踪：从理论到实践的全方位解析
墨夶的博客
02-28 358
Apache SkyWalking是一个集成了分布式追踪、度量聚合及可视化于一体的平台，特别适合用于构建复杂的微服务环境。接下来，我们将演示如何在.NET Core项目中集成SkyWalking。// Program.cs 文件中的配置// 设置必要的环境变量以启用SkyWalking代理// Program.cs 文件中的配置 public class Program {
APM —全链路追踪
热门推荐
Think In JAVA—Max
08-01 1万+
全链路追踪目的 微服务背景下 1.故障快速定位 跨语言实现开发中在业务日志中添加调用链ID，可以通过调用链结合业务日志快速定位错误信息。 2.各个调用环节的性能分析 分析调用链的各个环节耗时，分析系统的性能瓶颈，找到系统的薄弱环节针对性优化 3.数据分析 分析用户的行为路径，经过了哪些服务器上的哪个服务加以应用。 4.调用拓扑图 Trace系统设计目标...
Skywalking链路追踪
qq_48721706的博客
01-17 9184
APM（Application Performance Monitoring）系统是一种用于监控和管理应用程序性能的工具。它可以帮助开发人员和运维团队实时监控应用程序的性能指标、识别潜在的性能问题，并提供性能优化建议。APM系统可以帮助用户及时发现和解决应用程序的性能问题，提升用户体验和系统稳定性。它可以应用于各种类型的应用程序，包括Web应用、移动应用、微服务架构等。SkyWalking是一个开源的应用性能监控（APM）系统，用于监控和管理分布式系统的性能。
微服务架构的APM全链路追踪中TraceID跨服务传递原理
最新发布
码到三十五
07-05 1万+
摘要：本文详细解析了Java微服务架构中TraceID的跨服务传递机制，涵盖其核心作用、生成策略（UUID/雪花算法），以及在不同场景下的实现方式：HTTP/RPC同步调用通过请求头传递，异步消息队列通过消息属性传递，数据库调用借助ThreadLocal实现。同时介绍了W3C TraceContext和OpenTelemetry等标准化协议，以及SkyWalking、Jaeger等主流APM工具的支持。通过MDC机制和实际案例，展示了TraceID在日志追踪中的具体应用，为分布式系统全链路追踪提供了完整解决
Skywalking 链路追踪
程序猿进阶
01-20 1万+
Skywalking 链路追踪 Skywalking 根据官方的解释，Skywalking是一个可观测性平台（Observability Analysis Platform简称 OAP）和应用性能管理系统（Application Performance Management 简称 APM）。提供分布式链路追踪、服务网格（Service Mesh）遥测分析、度量（Metric）聚合和可视化一体化解决方案。 一、APM 系统概述 APM（Application Performance Monitoring
APM 监控链路追踪 Skywalking
墨笙弘一
08-29 554
前期使用TLog来做微服务之间的链路追踪，后期在做skywalking的切入
SpringCloud分布式微服务链路追踪方案：Skywalking
lucky_fd的博客
06-27 1753
SkyWalking架构设计整个架构，分成上、下、左、右四部分：考虑到让描述更简单，我们舍弃掉 Metric 指标相关，而着重在 Tracing 链路相关功能。上部分 Agent ：负责从应用中，收集链路信息，发送给 SkyWalking OAP 服务器。目前支持 SkyWalking、Zikpin、Jaeger 等提供的 Tracing 数据信息。而我们目前采用的是，SkyWalking Agent 收集 SkyWalking Tracing 数据，传递给服务器。
【NET6】微服务接入Skywalking（数据存储：Elasticsearch）实现链路追踪
技术分享博客，工作经验，技能学习分享（多做一些不会的，会有意向不到的收获，IT高手不可能永远只做会的）
02-20 757
【NET6】微服务接入Skywalking（数据存储：Elasticsearch）实现链路追踪
SkyApm.Transport.Grpc.Protocol.rar
05-29
总的来说，SkyApm.Transport.Grpc.Protocol是SkyWalking.NETCore实现分布式追踪的关键组件，它使用gRPC进行通信。当遇到编译异常时，可能是由于组件版本不兼容或者下载的包存在问题，替换正确的组件并重新编译可以...
手把手搭建Skywalking，玩转分布式链路追踪
qq_45455361的博客
11-24 2753
什么是Skywalking Skywalking是一个适用于分布式系统的性能监控工具 文档地址：https://skyapm.github.io/document-cn-translation-of-skywalking/ 功能： 服务，服务实例，端点指标分析 根本原因分析 服务拓扑图分析 服务，服务实例和端点依赖性分析 检测到慢速服务和端点 性能优化 分布式跟踪和上下文传播 数据库访问指标 告警 安装单机版Skywalking 下载 前往https://archive.apache.org/di
微服务下的APM全链路监控
11-08
微服务下的APM全链路监控微服务下的APM全链路监控微服务下的APM全链路监控微服务下的APM全链路监控
链路追踪：SkyWalking
一条没有梦想的闲鱼的博客
01-30 1万+
目录 一、前言 二、SkyWalking是什么 三、链路追踪框架对比 四、主要功能特性 五、服务端搭建 六、SkyWalking接入微服务 七、SkyWalking跨多个微服务跟踪 八、持久化 基于mysql持久化 九、自定义链路追踪 十、性能剖析 十一、SkyWalking集成日志框架 SkyWalking通过grpc上报日志（需要v.8.4.0+） 十二、告警 告警规则 Webhook（网络钩子） 邮件告警功能实践 十三、SkyWalking高可用 一、前言 ..
快速学习-Sleuth--链路追踪
逍遥云恋
08-28 926
Sleuth–链路追踪 6.1 链路追踪介绍 在大型系统的微服务化构建中，一个系统被拆分成了许多模块。这些模块负责不同的功能，组合成 系统，最终可以提供丰富的功能。在这种架构中，一次请求往往需要涉及到多个服务。互联网应用构建 在不同的软件模块集上，这些软件模块，有可能是由不同的团队开发、可能使用不同的编程语言来实 现、有可能布在了几千台服务器，横跨多个不同的数据中心，也就意味着这种架构形式也会存在一些问 题： 如何快速发现问题？ 如何判断故障影响范围？ 如何梳理服务依赖以及依赖的合理性？ 如何分析链路性能
十、SkyWalking链路追踪
eternal_tc的博客
07-10 780
SkyWalking链路追踪
【运维】SkyWalking链路监控（追踪）
在这里你大概率会有所收获，欢迎指错||纠正||建议||水评+点赞&&评论&&关注&&转发
04-03 2800
skywalking支持dubbo，SpringCloud，SpringBoot集成，代码无侵入，通信方式采用GRPC，性能较好，实现方式是java探针，支持告警，支持JVM监控，支持全局调用统计等等，功能较完善。 分布式系统的应用程序性能监视工具，专为微服务、云原生架构和基于容器（Docker、K8s、Mesos）架构而设计。 提供分布式追踪、服务网格遥测分析、度量聚合和可视化一体化解决方案。
SkyWalking 微服务链路追踪
Vinjcent
06-04 5560
对于一个大型的几十个、几百个微服务构成的微服务架构系统，通常会遇到下面一些问题：Skywalking 是一个国产开源框架，2015年由吴晟开源，2017年加入 Apache 孵化器。Skywalking 是分布式系统的应用程序性能监视工具，专为微服务、云原生架构和基于容器（Docker、K8s、Mesos）架构而设计。它是一款优秀的 APM（Application Performance Management）工具，包括了分布式追踪、性能指标分析、应用和服务以来分析等官网：https://skywalkin
RestCloud API监控平台，APM全链路跟踪
RestCloud的博客
08-24 856
RestCloud API监控平台，通过监控中心可以实时的了解和分析API的运行状况和性能数据，同时作为微服务的统一监控中心实时收集所有微服务实例的运行性能数据，所有微服务实例通过心跳或日志的方式汇总监控数据，监控中心通过统一的监控图表或面板进行分析和统计，是专门为微服务或API打造的实时监控中心。 一、API监控中心主要特点 1、实时分析和统计所有API及微服务实例的性能； 2、实时获取JVM的运行数据包括内存及线程使用情况； 3、监控微服务的熔断情况； 4、监控分布式事务数据、异常服务数据； .
docker-compose部署单点apm链路追踪
jialiu111111的博客
06-14 1326
7.下载客https://repo1.maven.org/maven2/co/elastic/apm/elastic-apm-agent/二.APM组件介绍 https://blog.csdn.net/u013613428/article/details/86667240。三,APM-Server 部署安装及使用示例。一.docker-compose 安装下载。8.启动客户端java接入apm服务。
ASP.NET Core集成Zipkin：实现链路跟踪指南
"本文将介绍如何在ASP.NET ...通过以上步骤，开发者可以在ASP.NET Core应用中实现对微服务链路的高效监控，从而优化性能、定位问题。Zipkin因其简洁的设计和广泛的社区支持，成为了开发者在链路跟踪领域的可靠选择。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值