Skip to content
BranchesTags

Repository files navigation

Build StatusReleased Version

OpenTracing Spring Cloud

This repository provides OpenTracing instrumentation for Spring Boot and its various extensions. It can be used with any OpenTracing compatible implementation.

It contains auto-configurations which instruments and trace following Spring Boot projects:

  • Spring Web (RestControllers, RestTemplates, WebAsyncTask, WebClient, WebFlux)
  • @Async, @Scheduled, Executors
  • WebSocket STOMP
  • Feign, HystrixFeign
  • Hystrix
  • JMS
  • JDBC
  • Mongo
  • Zuul
  • Reactor
  • RxJava
  • Redis
  • Standard logging - logs are added to active span
  • Spring Messaging - trace messages being sent through Messaging Channels
  • RabbitMQ

Compatibility table

The following table shows versions with compatible Spring Cloud releases.

opentracing-spring-cloud versionOpenTracing APISpring Cloud version
0.3.x0.32.0Finchley, Greenwhich
0.2.x0.31.0Finchley, Greenwhich
0.1.x0.31.0Dalston, Edgware

Comparison to spring-cloud-sleuth

This project is similar to spring-cloud-sleuth, both provide out of the box tracing solution for Spring Boot/Cloud. Some of the instrumentations in this package are based on original sleuth work.

However there are a couple of differences:

  • OpenTracing support in sleuth is limited to only one tracer implementation - brave-opentracing. In other words it's not possible to use arbitrary OpenTracing tracer with sleuth.
  • sleuth might support different set of instrumentations.
  • Instrumentations in sleuth might add different set of tags and logs to represent the same events.

Note on dependencies

It's worth noting that the although OpenTracing Spring Cloud contains code for instrumenting a wealth of Spring projects, it however does not pull those dependencies automatically, marking them as optional dependencies instead.

That means that for example a simple Spring Boot REST API application can include OpenTracing Spring Cloud without the fear of polluting the classpath with Spring Cloud dependencies that are otherwise unneeded

Configuration

The preferred way to use this library is via vendored starters. These starters use instrumentations from this library and expose specific tracer configuration in Spring native way:

Explicitly tracer configuration

Just add the following dependency in your pom.xml:

<dependency>
<groupId>io.opentracing.contrib</groupId>
<artifactId>opentracing-spring-cloud-starter</artifactId>
</dependency>

, and provide OpenTracing tracer bean:

@Beanpublicio.opentracing.Tracertracer() {
returnnew// tracer instance of your choice (Zipkin, Jaeger, LightStep)
}

Development

Maven checkstyle plugin is used to maintain consistent code style based on Google Style Guides

./mvnw clean install
make // to run tests including dependency tests, a specific profile can be specified by make PROFILES=nodeps

Release

Follow instructions in RELEASE

License

Apache 2.0 License.

About

Distributed tracing for Spring Boot, Cloud and other Spring projects

Resources

Readme
Apache-2.0 license
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - onobc/java-spring-cloud: Distributed tracing for Spring Boot, Cloud and other Spring projects · GitHub
Skip to content
BranchesTags
Repository files navigation
Build StatusReleased Version
OpenTracing Spring Cloud
This repository provides OpenTracing instrumentation for Spring Boot and its various extensions. It can be used with any OpenTracing
compatible implementation.
It contains auto-configurations which instruments and trace following Spring Boot projects:
  • Spring Web (RestControllers, RestTemplates, WebAsyncTask, WebClient, WebFlux)
  • @Async, @Scheduled, Executors
  • WebSocket STOMP
  • Feign, HystrixFeign
  • Hystrix
  • JMS
  • JDBC
  • Mongo
  • Zuul
  • Reactor
  • RxJava
  • Redis
  • Standard logging - logs are added to active span
  • Spring Messaging - trace messages being sent through Messaging Channels
  • RabbitMQ
Compatibility table
The following table shows versions with compatible Spring Cloud releases.
opentracing-spring-cloud versionOpenTracing APISpring Cloud version
0.3.x0.32.0Finchley, Greenwhich
0.2.x0.31.0Finchley, Greenwhich
0.1.x0.31.0Dalston, Edgware
Comparison to spring-cloud-sleuth
This project is similar to spring-cloud-sleuth,
both provide out of the box tracing solution for Spring Boot/Cloud. Some of the instrumentations in this
package are based on original sleuth work.
However there are a couple of differences:
  • OpenTracing support in sleuth is limited to only one tracer implementation - brave-opentracing. In other words it's not possible to use arbitrary OpenTracing tracer with sleuth.
  • sleuth might support different set of instrumentations.
  • Instrumentations in sleuth might add different set of tags and logs to represent the same events.
Note on dependencies
It's worth noting that the although OpenTracing Spring Cloud contains code for instrumenting a wealth of Spring projects,
it however does not pull those dependencies automatically, marking them as optional dependencies instead.
That means that for example a simple Spring Boot REST API application can include OpenTracing Spring Cloud without the fear
of polluting the classpath with Spring Cloud dependencies that are otherwise unneeded
Configuration
The preferred way to use this library is via vendored starters. These starters use
instrumentations from this library and expose specific tracer configuration in Spring
native way:
Explicitly tracer configuration
Just add the following dependency in your pom.xml:
<dependency>
<groupId>io.opentracing.contrib</groupId>
<artifactId>opentracing-spring-cloud-starter</artifactId>
</dependency>
, and provide OpenTracing tracer bean:
@Beanpublicio.opentracing.Tracertracer() {
returnnew// tracer instance of your choice (Zipkin, Jaeger, LightStep)
}
Development
Maven checkstyle plugin is used to maintain consistent code style based on Google Style Guides
./mvnw clean install
make // to run tests including dependency tests, a specific profile can be specified by make PROFILES=nodeps
Release
Follow instructions in RELEASE
License
Apache 2.0 License.
About
Distributed tracing for Spring Boot, Cloud and other Spring projects
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - onobc/java-spring-cloud: Distributed tracing for Spring Boot, Cloud and other Spring projects · GitHub
Skip to content
BranchesTags
Repository files navigation
Build StatusReleased Version
OpenTracing Spring Cloud
This repository provides OpenTracing instrumentation for Spring Boot and its various extensions. It can be used with any OpenTracing
compatible implementation.
It contains auto-configurations which instruments and trace following Spring Boot projects:
  • Spring Web (RestControllers, RestTemplates, WebAsyncTask, WebClient, WebFlux)
  • @Async, @Scheduled, Executors
  • WebSocket STOMP
  • Feign, HystrixFeign
  • Hystrix
  • JMS
  • JDBC
  • Mongo
  • Zuul
  • Reactor
  • RxJava
  • Redis
  • Standard logging - logs are added to active span
  • Spring Messaging - trace messages being sent through Messaging Channels
  • RabbitMQ
Compatibility table
The following table shows versions with compatible Spring Cloud releases.
opentracing-spring-cloud versionOpenTracing APISpring Cloud version
0.3.x0.32.0Finchley, Greenwhich
0.2.x0.31.0Finchley, Greenwhich
0.1.x0.31.0Dalston, Edgware
Comparison to spring-cloud-sleuth
This project is similar to spring-cloud-sleuth,
both provide out of the box tracing solution for Spring Boot/Cloud. Some of the instrumentations in this
package are based on original sleuth work.
However there are a couple of differences:
  • OpenTracing support in sleuth is limited to only one tracer implementation - brave-opentracing. In other words it's not possible to use arbitrary OpenTracing tracer with sleuth.
  • sleuth might support different set of instrumentations.
  • Instrumentations in sleuth might add different set of tags and logs to represent the same events.
Note on dependencies
It's worth noting that the although OpenTracing Spring Cloud contains code for instrumenting a wealth of Spring projects,
it however does not pull those dependencies automatically, marking them as optional dependencies instead.
That means that for example a simple Spring Boot REST API application can include OpenTracing Spring Cloud without the fear
of polluting the classpath with Spring Cloud dependencies that are otherwise unneeded
Configuration
The preferred way to use this library is via vendored starters. These starters use
instrumentations from this library and expose specific tracer configuration in Spring
native way:
Explicitly tracer configuration
Just add the following dependency in your pom.xml:
<dependency>
<groupId>io.opentracing.contrib</groupId>
<artifactId>opentracing-spring-cloud-starter</artifactId>
</dependency>
, and provide OpenTracing tracer bean:
@Beanpublicio.opentracing.Tracertracer() {
returnnew// tracer instance of your choice (Zipkin, Jaeger, LightStep)
}
Development
Maven checkstyle plugin is used to maintain consistent code style based on Google Style Guides
./mvnw clean install
make // to run tests including dependency tests, a specific profile can be specified by make PROFILES=nodeps
Release
Follow instructions in RELEASE
License
Apache 2.0 License.
About
Distributed tracing for Spring Boot, Cloud and other Spring projects
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - onobc/java-spring-cloud: Distributed tracing for Spring Boot, Cloud and other Spring projects · GitHub
Skip to content
BranchesTags
Repository files navigation
Build StatusReleased Version
OpenTracing Spring Cloud
This repository provides OpenTracing instrumentation for Spring Boot and its various extensions. It can be used with any OpenTracing
compatible implementation.
It contains auto-configurations which instruments and trace following Spring Boot projects:
  • Spring Web (RestControllers, RestTemplates, WebAsyncTask, WebClient, WebFlux)
  • @Async, @Scheduled, Executors
  • WebSocket STOMP
  • Feign, HystrixFeign
  • Hystrix
  • JMS
  • JDBC
  • Mongo
  • Zuul
  • Reactor
  • RxJava
  • Redis
  • Standard logging - logs are added to active span
  • Spring Messaging - trace messages being sent through Messaging Channels
  • RabbitMQ
Compatibility table
The following table shows versions with compatible Spring Cloud releases.
opentracing-spring-cloud versionOpenTracing APISpring Cloud version
0.3.x0.32.0Finchley, Greenwhich
0.2.x0.31.0Finchley, Greenwhich
0.1.x0.31.0Dalston, Edgware
Comparison to spring-cloud-sleuth
This project is similar to spring-cloud-sleuth,
both provide out of the box tracing solution for Spring Boot/Cloud. Some of the instrumentations in this
package are based on original sleuth work.
However there are a couple of differences:
  • OpenTracing support in sleuth is limited to only one tracer implementation - brave-opentracing. In other words it's not possible to use arbitrary OpenTracing tracer with sleuth.
  • sleuth might support different set of instrumentations.
  • Instrumentations in sleuth might add different set of tags and logs to represent the same events.
Note on dependencies
It's worth noting that the although OpenTracing Spring Cloud contains code for instrumenting a wealth of Spring projects,
it however does not pull those dependencies automatically, marking them as optional dependencies instead.
That means that for example a simple Spring Boot REST API application can include OpenTracing Spring Cloud without the fear
of polluting the classpath with Spring Cloud dependencies that are otherwise unneeded
Configuration
The preferred way to use this library is via vendored starters. These starters use
instrumentations from this library and expose specific tracer configuration in Spring
native way:
Explicitly tracer configuration
Just add the following dependency in your pom.xml:
<dependency>
<groupId>io.opentracing.contrib</groupId>
<artifactId>opentracing-spring-cloud-starter</artifactId>
</dependency>
, and provide OpenTracing tracer bean:
@Beanpublicio.opentracing.Tracertracer() {
returnnew// tracer instance of your choice (Zipkin, Jaeger, LightStep)
}
Development
Maven checkstyle plugin is used to maintain consistent code style based on Google Style Guides
./mvnw clean install
make // to run tests including dependency tests, a specific profile can be specified by make PROFILES=nodeps
Release
Follow instructions in RELEASE
License
Apache 2.0 License.
About
Distributed tracing for Spring Boot, Cloud and other Spring projects
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - onobc/java-spring-cloud: Distributed tracing for Spring Boot, Cloud and other Spring projects · GitHub
Skip to content
BranchesTags
Repository files navigation
Build StatusReleased Version
OpenTracing Spring Cloud
This repository provides OpenTracing instrumentation for Spring Boot and its various extensions. It can be used with any OpenTracing
compatible implementation.
It contains auto-configurations which instruments and trace following Spring Boot projects:
  • Spring Web (RestControllers, RestTemplates, WebAsyncTask, WebClient, WebFlux)
  • @Async, @Scheduled, Executors
  • WebSocket STOMP
  • Feign, HystrixFeign
  • Hystrix
  • JMS
  • JDBC
  • Mongo
  • Zuul
  • Reactor
  • RxJava
  • Redis
  • Standard logging - logs are added to active span
  • Spring Messaging - trace messages being sent through Messaging Channels
  • RabbitMQ
Compatibility table
The following table shows versions with compatible Spring Cloud releases.
opentracing-spring-cloud versionOpenTracing APISpring Cloud version
0.3.x0.32.0Finchley, Greenwhich
0.2.x0.31.0Finchley, Greenwhich
0.1.x0.31.0Dalston, Edgware
Comparison to spring-cloud-sleuth
This project is similar to spring-cloud-sleuth,
both provide out of the box tracing solution for Spring Boot/Cloud. Some of the instrumentations in this
package are based on original sleuth work.
However there are a couple of differences:
  • OpenTracing support in sleuth is limited to only one tracer implementation - brave-opentracing. In other words it's not possible to use arbitrary OpenTracing tracer with sleuth.
  • sleuth might support different set of instrumentations.
  • Instrumentations in sleuth might add different set of tags and logs to represent the same events.
Note on dependencies
It's worth noting that the although OpenTracing Spring Cloud contains code for instrumenting a wealth of Spring projects,
it however does not pull those dependencies automatically, marking them as optional dependencies instead.
That means that for example a simple Spring Boot REST API application can include OpenTracing Spring Cloud without the fear
of polluting the classpath with Spring Cloud dependencies that are otherwise unneeded
Configuration
The preferred way to use this library is via vendored starters. These starters use
instrumentations from this library and expose specific tracer configuration in Spring
native way:
Explicitly tracer configuration
Just add the following dependency in your pom.xml:
<dependency>
<groupId>io.opentracing.contrib</groupId>
<artifactId>opentracing-spring-cloud-starter</artifactId>
</dependency>
, and provide OpenTracing tracer bean:
@Beanpublicio.opentracing.Tracertracer() {
returnnew// tracer instance of your choice (Zipkin, Jaeger, LightStep)
}
Development
Maven checkstyle plugin is used to maintain consistent code style based on Google Style Guides
./mvnw clean install
make // to run tests including dependency tests, a specific profile can be specified by make PROFILES=nodeps
Release
Follow instructions in RELEASE
License
Apache 2.0 License.
About
Distributed tracing for Spring Boot, Cloud and other Spring projects
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - onobc/java-spring-cloud: Distributed tracing for Spring Boot, Cloud and other Spring projects · GitHub
Skip to content
BranchesTags
Repository files navigation
Build StatusReleased Version
OpenTracing Spring Cloud
This repository provides OpenTracing instrumentation for Spring Boot and its various extensions. It can be used with any OpenTracing
compatible implementation.
It contains auto-configurations which instruments and trace following Spring Boot projects:
  • Spring Web (RestControllers, RestTemplates, WebAsyncTask, WebClient, WebFlux)
  • @Async, @Scheduled, Executors
  • WebSocket STOMP
  • Feign, HystrixFeign
  • Hystrix
  • JMS
  • JDBC
  • Mongo
  • Zuul
  • Reactor
  • RxJava
  • Redis
  • Standard logging - logs are added to active span
  • Spring Messaging - trace messages being sent through Messaging Channels
  • RabbitMQ
Compatibility table
The following table shows versions with compatible Spring Cloud releases.
opentracing-spring-cloud versionOpenTracing APISpring Cloud version
0.3.x0.32.0Finchley, Greenwhich
0.2.x0.31.0Finchley, Greenwhich
0.1.x0.31.0Dalston, Edgware
Comparison to spring-cloud-sleuth
This project is similar to spring-cloud-sleuth,
both provide out of the box tracing solution for Spring Boot/Cloud. Some of the instrumentations in this
package are based on original sleuth work.
However there are a couple of differences:
  • OpenTracing support in sleuth is limited to only one tracer implementation - brave-opentracing. In other words it's not possible to use arbitrary OpenTracing tracer with sleuth.
  • sleuth might support different set of instrumentations.
  • Instrumentations in sleuth might add different set of tags and logs to represent the same events.
Note on dependencies
It's worth noting that the although OpenTracing Spring Cloud contains code for instrumenting a wealth of Spring projects,
it however does not pull those dependencies automatically, marking them as optional dependencies instead.
That means that for example a simple Spring Boot REST API application can include OpenTracing Spring Cloud without the fear
of polluting the classpath with Spring Cloud dependencies that are otherwise unneeded
Configuration
The preferred way to use this library is via vendored starters. These starters use
instrumentations from this library and expose specific tracer configuration in Spring
native way:
Explicitly tracer configuration
Just add the following dependency in your pom.xml:
<dependency>
<groupId>io.opentracing.contrib</groupId>
<artifactId>opentracing-spring-cloud-starter</artifactId>
</dependency>
, and provide OpenTracing tracer bean:
@Beanpublicio.opentracing.Tracertracer() {
returnnew// tracer instance of your choice (Zipkin, Jaeger, LightStep)
}
Development
Maven checkstyle plugin is used to maintain consistent code style based on Google Style Guides
./mvnw clean install
make // to run tests including dependency tests, a specific profile can be specified by make PROFILES=nodeps
Release
Follow instructions in RELEASE
License
Apache 2.0 License.
About
Distributed tracing for Spring Boot, Cloud and other Spring projects
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - onobc/java-spring-cloud: Distributed tracing for Spring Boot, Cloud and other Spring projects · GitHub
Skip to content
BranchesTags
Repository files navigation
Build StatusReleased Version
OpenTracing Spring Cloud
This repository provides OpenTracing instrumentation for Spring Boot and its various extensions. It can be used with any OpenTracing
compatible implementation.
It contains auto-configurations which instruments and trace following Spring Boot projects:
  • Spring Web (RestControllers, RestTemplates, WebAsyncTask, WebClient, WebFlux)
  • @Async, @Scheduled, Executors
  • WebSocket STOMP
  • Feign, HystrixFeign
  • Hystrix
  • JMS
  • JDBC
  • Mongo
  • Zuul
  • Reactor
  • RxJava
  • Redis
  • Standard logging - logs are added to active span
  • Spring Messaging - trace messages being sent through Messaging Channels
  • RabbitMQ
Compatibility table
The following table shows versions with compatible Spring Cloud releases.
opentracing-spring-cloud versionOpenTracing APISpring Cloud version
0.3.x0.32.0Finchley, Greenwhich
0.2.x0.31.0Finchley, Greenwhich
0.1.x0.31.0Dalston, Edgware
Comparison to spring-cloud-sleuth
This project is similar to spring-cloud-sleuth,
both provide out of the box tracing solution for Spring Boot/Cloud. Some of the instrumentations in this
package are based on original sleuth work.
However there are a couple of differences:
  • OpenTracing support in sleuth is limited to only one tracer implementation - brave-opentracing. In other words it's not possible to use arbitrary OpenTracing tracer with sleuth.
  • sleuth might support different set of instrumentations.
  • Instrumentations in sleuth might add different set of tags and logs to represent the same events.
Note on dependencies
It's worth noting that the although OpenTracing Spring Cloud contains code for instrumenting a wealth of Spring projects,
it however does not pull those dependencies automatically, marking them as optional dependencies instead.
That means that for example a simple Spring Boot REST API application can include OpenTracing Spring Cloud without the fear
of polluting the classpath with Spring Cloud dependencies that are otherwise unneeded
Configuration
The preferred way to use this library is via vendored starters. These starters use
instrumentations from this library and expose specific tracer configuration in Spring
native way:
Explicitly tracer configuration
Just add the following dependency in your pom.xml:
<dependency>
<groupId>io.opentracing.contrib</groupId>
<artifactId>opentracing-spring-cloud-starter</artifactId>
</dependency>
, and provide OpenTracing tracer bean:
@Beanpublicio.opentracing.Tracertracer() {
returnnew// tracer instance of your choice (Zipkin, Jaeger, LightStep)
}
Development
Maven checkstyle plugin is used to maintain consistent code style based on Google Style Guides
./mvnw clean install
make // to run tests including dependency tests, a specific profile can be specified by make PROFILES=nodeps
Release
Follow instructions in RELEASE
License
Apache 2.0 License.
About
Distributed tracing for Spring Boot, Cloud and other Spring projects
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - onobc/java-spring-cloud: Distributed tracing for Spring Boot, Cloud and other Spring projects · GitHub
Skip to content
BranchesTags
Repository files navigation
Build StatusReleased Version
OpenTracing Spring Cloud
This repository provides OpenTracing instrumentation for Spring Boot and its various extensions. It can be used with any OpenTracing
compatible implementation.
It contains auto-configurations which instruments and trace following Spring Boot projects:
  • Spring Web (RestControllers, RestTemplates, WebAsyncTask, WebClient, WebFlux)
  • @Async, @Scheduled, Executors
  • WebSocket STOMP
  • Feign, HystrixFeign
  • Hystrix
  • JMS
  • JDBC
  • Mongo
  • Zuul
  • Reactor
  • RxJava
  • Redis
  • Standard logging - logs are added to active span
  • Spring Messaging - trace messages being sent through Messaging Channels
  • RabbitMQ
Compatibility table
The following table shows versions with compatible Spring Cloud releases.
opentracing-spring-cloud versionOpenTracing APISpring Cloud version
0.3.x0.32.0Finchley, Greenwhich
0.2.x0.31.0Finchley, Greenwhich
0.1.x0.31.0Dalston, Edgware
Comparison to spring-cloud-sleuth
This project is similar to spring-cloud-sleuth,
both provide out of the box tracing solution for Spring Boot/Cloud. Some of the instrumentations in this
package are based on original sleuth work.
However there are a couple of differences:
  • OpenTracing support in sleuth is limited to only one tracer implementation - brave-opentracing. In other words it's not possible to use arbitrary OpenTracing tracer with sleuth.
  • sleuth might support different set of instrumentations.
  • Instrumentations in sleuth might add different set of tags and logs to represent the same events.
Note on dependencies
It's worth noting that the although OpenTracing Spring Cloud contains code for instrumenting a wealth of Spring projects,
it however does not pull those dependencies automatically, marking them as optional dependencies instead.
That means that for example a simple Spring Boot REST API application can include OpenTracing Spring Cloud without the fear
of polluting the classpath with Spring Cloud dependencies that are otherwise unneeded
Configuration
The preferred way to use this library is via vendored starters. These starters use
instrumentations from this library and expose specific tracer configuration in Spring
native way:
Explicitly tracer configuration
Just add the following dependency in your pom.xml:
<dependency>
<groupId>io.opentracing.contrib</groupId>
<artifactId>opentracing-spring-cloud-starter</artifactId>
</dependency>
, and provide OpenTracing tracer bean:
@Beanpublicio.opentracing.Tracertracer() {
returnnew// tracer instance of your choice (Zipkin, Jaeger, LightStep)
}
Development
Maven checkstyle plugin is used to maintain consistent code style based on Google Style Guides
./mvnw clean install
make // to run tests including dependency tests, a specific profile can be specified by make PROFILES=nodeps
Release
Follow instructions in RELEASE
License
Apache 2.0 License.
About
Distributed tracing for Spring Boot, Cloud and other Spring projects
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages