repo
stringlengths 1
191
⌀ | file
stringlengths 23
351
| code
stringlengths 0
5.32M
| file_length
int64 0
5.32M
| avg_line_length
float64 0
2.9k
| max_line_length
int64 0
288k
| extension_type
stringclasses 1
value |
|---|---|---|---|---|---|---|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/ItemContext.java
|
package org.myproject.ms.monitoring;
import java.util.Map;
public interface ItemContext {
Iterable<Map.Entry<String, String>> baggageItems();
}
| 151 | 14.2 | 52 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/ItemExtractor.java
|
package org.myproject.ms.monitoring;
public interface ItemExtractor<T> {
Item joinTrace(T carrier);
}
| 109 | 10 | 36 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/ItemInjector.java
|
package org.myproject.ms.monitoring;
public interface ItemInjector<T> {
void inject(Item span, T carrier);
}
| 116 | 10.7 | 36 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/ItemName.java
|
package org.myproject.ms.monitoring;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ItemName {
String value();
}
| 367 | 18.368421 | 44 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/ItemNamer.java
|
package org.myproject.ms.monitoring;
public interface ItemNamer {
String name(Object object, String defaultValue);
}
| 125 | 10.454545 | 49 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/ItemReporter.java
|
package org.myproject.ms.monitoring;
public interface ItemReporter {
void report(Item span);
}
| 102 | 9.3 | 36 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/ItemTextMap.java
|
package org.myproject.ms.monitoring;
import java.util.Iterator;
import java.util.Map;
public interface ItemTextMap extends Iterable<Map.Entry<String, String>> {
Iterator<Map.Entry<String,String>> iterator();
void put(String key, String value);
}
| 255 | 18.692308 | 74 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/Log.java
|
package org.myproject.ms.monitoring;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
public class Log {
private final long timestamp;
private final String event;
@JsonCreator
public Log(
@JsonProperty(value = "timestamp", required = true) long timestamp,
@JsonProperty(value = "event", required = true) String event
) {
if (event == null) throw new NullPointerException("event");
this.timestamp = timestamp;
this.event = event;
}
public long getTimestamp() {
return this.timestamp;
}
public String getEvent() {
return this.event;
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (o instanceof Log) {
Log that = (Log) o;
return (this.timestamp == that.timestamp)
&& (this.event.equals(that.event));
}
return false;
}
@Override
public int hashCode() {
int h = 1;
h *= 1000003;
h ^= (this.timestamp >>> 32) ^ this.timestamp;
h *= 1000003;
h ^= this.event.hashCode();
return h;
}
@Override public String toString() {
return "Log{" +
"timestamp=" + this.timestamp +
", event='" + this.event + '\'' +
'}';
}
}
| 1,195 | 17.6875 | 70 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/NOItemAdjuster.java
|
package org.myproject.ms.monitoring;
public class NOItemAdjuster implements ItemAdjuster {
@Override public Item adjust(Item span) {
return span;
}
}
| 158 | 13.454545 | 53 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/NOItemReporter.java
|
package org.myproject.ms.monitoring;
public class NOItemReporter implements ItemReporter {
@Override
public void report(Item span) {
}
}
| 145 | 11.166667 | 53 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/Sampler.java
|
package org.myproject.ms.monitoring;
public interface Sampler {
boolean isSampled(Item span);
}
| 103 | 9.4 | 36 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/StateItemAdjuster.java
|
package org.myproject.ms.monitoring;
public class StateItemAdjuster implements ItemAdjuster {
@Override public Item adjust(Item span) {
System.out.println("-------inside span adjuster-------:" + span.toString());
return span.toBuilder()
.tag("state", "mystate")
.name(span.getName() + "--------------------")
.build();
}
}
| 347 | 20.75 | 78 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/ContinueSpan.java
|
package org.myproject.ms.monitoring.antn;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target(value = { ElementType.METHOD, ElementType.TYPE })
public @interface ContinueSpan {
String log() default "";
}
| 416 | 19.85 | 57 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/DefaultSpanCreator.java
|
package org.myproject.ms.monitoring.antn;
import java.lang.invoke.MethodHandles;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.util.ItemNameUtil;
import org.springframework.util.StringUtils;
class DefaultSpanCreator implements SpanCreator {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private final Chainer tracer;
DefaultSpanCreator(Chainer tracer) {
this.tracer = tracer;
}
@Override public Item createSpan(MethodInvocation pjp, NewSpan newSpanAnnotation) {
String name = StringUtils.isEmpty(newSpanAnnotation.name()) ?
pjp.getMethod().getName() : newSpanAnnotation.name();
String changedName = ItemNameUtil.toLowerHyphen(name);
if (log.isDebugEnabled()) {
log.debug("For the class [" + pjp.getThis().getClass() + "] method "
+ "[" + pjp.getMethod().getName() + "] will name the span [" + changedName + "]");
}
return createSpan(changedName);
}
private Item createSpan(String name) {
if (this.tracer.isTracing()) {
return this.tracer.createSpan(name, this.tracer.getCurrentSpan());
}
return this.tracer.createSpan(name);
}
}
| 1,333 | 29.318182 | 88 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/NewSpan.java
|
package org.myproject.ms.monitoring.antn;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target(value = { ElementType.METHOD, ElementType.TYPE })
public @interface NewSpan {
@AliasFor("value")
String name() default "";
@AliasFor("name")
String value() default "";
}
| 536 | 18.888889 | 57 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/NoOpTagValueResolver.java
|
package org.myproject.ms.monitoring.antn;
class NoOpTagValueResolver implements TagValueResolver {
@Override public String resolve(Object parameter) {
return null;
}
}
| 176 | 15.090909 | 56 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/SleuthAdvisorConfig.java
|
package org.myproject.ms.monitoring.antn;
import java.lang.annotation.Annotation;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Method;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.annotation.PostConstruct;
import org.aopalliance.aop.Advice;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.aop.ClassFilter;
import org.springframework.aop.IntroductionAdvisor;
import org.springframework.aop.IntroductionInterceptor;
import org.springframework.aop.Pointcut;
import org.springframework.aop.support.AbstractPointcutAdvisor;
import org.springframework.aop.support.AopUtils;
import org.springframework.aop.support.DynamicMethodMatcherPointcut;
import org.springframework.aop.support.annotation.AnnotationClassFilter;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.util.ExceptionUtils;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.StringUtils;
class SleuthAdvisorConfig extends AbstractPointcutAdvisor implements
IntroductionAdvisor, BeanFactoryAware {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private Advice advice;
private Pointcut pointcut;
private BeanFactory beanFactory;
@PostConstruct
public void init() {
this.pointcut = buildPointcut();
this.advice = buildAdvice();
if (this.advice instanceof BeanFactoryAware) {
((BeanFactoryAware) this.advice).setBeanFactory(this.beanFactory);
}
}
@Override
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
@Override
public ClassFilter getClassFilter() {
return this.pointcut.getClassFilter();
}
@Override
public Class<?>[] getInterfaces() {
return new Class[] {};
}
@Override
public void validateInterfaces() throws IllegalArgumentException {
}
@Override
public Advice getAdvice() {
return this.advice;
}
@Override
public Pointcut getPointcut() {
return this.pointcut;
}
private Advice buildAdvice() {
return new SleuthInterceptor();
}
private Pointcut buildPointcut() {
return new AnnotationClassOrMethodOrArgsPointcut();
}
private final class AnnotationClassOrMethodOrArgsPointcut extends
DynamicMethodMatcherPointcut {
private final DynamicMethodMatcherPointcut methodResolver;
AnnotationClassOrMethodOrArgsPointcut() {
this.methodResolver = new DynamicMethodMatcherPointcut() {
@Override public boolean matches(Method method, Class<?> targetClass,
Object... args) {
if (SleuthAnnotationUtils.isMethodAnnotated(method)) {
if (log.isDebugEnabled()) {
log.debug("Found a method with Sleuth annotation");
}
return true;
}
if (SleuthAnnotationUtils.hasAnnotatedParams(method, args)) {
if (log.isDebugEnabled()) {
log.debug("Found annotated arguments of the method");
}
return true;
}
return false;
}
};
}
@Override
public boolean matches(Method method, Class<?> targetClass, Object... args) {
return getClassFilter().matches(targetClass) ||
this.methodResolver.matches(method, targetClass, args);
}
@Override public ClassFilter getClassFilter() {
return new ClassFilter() {
@Override public boolean matches(Class<?> clazz) {
return new AnnotationClassOrMethodFilter(NewSpan.class).matches(clazz) ||
new AnnotationClassOrMethodFilter(ContinueSpan.class).matches(clazz);
}
};
}
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (!(other instanceof AnnotationClassOrMethodOrArgsPointcut)) {
return false;
}
AnnotationClassOrMethodOrArgsPointcut otherAdvisor = (AnnotationClassOrMethodOrArgsPointcut) other;
return ObjectUtils.nullSafeEquals(this.methodResolver, otherAdvisor.methodResolver);
}
}
private final class AnnotationClassOrMethodFilter extends AnnotationClassFilter {
private final AnnotationMethodsResolver methodResolver;
AnnotationClassOrMethodFilter(Class<? extends Annotation> annotationType) {
super(annotationType, true);
this.methodResolver = new AnnotationMethodsResolver(annotationType);
}
@Override
public boolean matches(Class<?> clazz) {
return super.matches(clazz) || this.methodResolver.hasAnnotatedMethods(clazz);
}
}
private static class AnnotationMethodsResolver {
private Class<? extends Annotation> annotationType;
public AnnotationMethodsResolver(Class<? extends Annotation> annotationType) {
this.annotationType = annotationType;
}
public boolean hasAnnotatedMethods(Class<?> clazz) {
final AtomicBoolean found = new AtomicBoolean(false);
ReflectionUtils.doWithMethods(clazz,
new ReflectionUtils.MethodCallback() {
@Override
public void doWith(Method method) throws IllegalArgumentException,
IllegalAccessException {
if (found.get()) {
return;
}
Annotation annotation = AnnotationUtils.findAnnotation(method,
AnnotationMethodsResolver.this.annotationType);
if (annotation != null) { found.set(true); }
}
});
return found.get();
}
}
}
class SleuthInterceptor implements IntroductionInterceptor, BeanFactoryAware {
private static final Log logger = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private BeanFactory beanFactory;
private SpanCreator spanCreator;
private Chainer tracer;
private SpanTagAnnotationHandler spanTagAnnotationHandler;
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
Method method = invocation.getMethod();
if (method == null) {
return invocation.proceed();
}
Method mostSpecificMethod = AopUtils
.getMostSpecificMethod(method, invocation.getThis().getClass());
NewSpan newSpan = SleuthAnnotationUtils.findAnnotation(mostSpecificMethod, NewSpan.class);
ContinueSpan continueSpan = SleuthAnnotationUtils.findAnnotation(mostSpecificMethod, ContinueSpan.class);
if (newSpan == null && continueSpan == null) {
return invocation.proceed();
}
Item span = tracer().getCurrentSpan();
String log = log(continueSpan);
boolean hasLog = StringUtils.hasText(log);
try {
if (newSpan != null) {
span = spanCreator().createSpan(invocation, newSpan);
}
if (hasLog) {
logEvent(span, log + ".before");
}
spanTagAnnotationHandler().addAnnotatedParameters(invocation);
return invocation.proceed();
} catch (Exception e) {
if (logger.isDebugEnabled()) {
logger.debug("Exception occurred while trying to continue the pointcut", e);
}
if (hasLog) {
logEvent(span, log + ".afterFailure");
}
tracer().addTag(Item.SPAN_ERROR_TAG_NAME, ExceptionUtils.getExceptionMessage(e));
throw e;
} finally {
if (span != null) {
if (hasLog) {
logEvent(span, log + ".after");
}
if (newSpan != null) {
tracer().close(span);
}
}
}
}
private void logEvent(Item span, String name) {
if (span == null) {
logger.warn("You were trying to continue a span which was null. Please "
+ "remember that if two proxied methods are calling each other from "
+ "the same class then the aspect will not be properly resolved");
return;
}
span.logEvent(name);
}
private String log(ContinueSpan continueSpan) {
if (continueSpan != null) {
return continueSpan.log();
}
return "";
}
private Chainer tracer() {
if (this.tracer == null) {
this.tracer = this.beanFactory.getBean(Chainer.class);
}
return this.tracer;
}
private SpanCreator spanCreator() {
if (this.spanCreator == null) {
this.spanCreator = this.beanFactory.getBean(SpanCreator.class);
}
return this.spanCreator;
}
private SpanTagAnnotationHandler spanTagAnnotationHandler() {
if (this.spanTagAnnotationHandler == null) {
this.spanTagAnnotationHandler = new SpanTagAnnotationHandler(this.beanFactory);
}
return this.spanTagAnnotationHandler;
}
@Override public boolean implementsInterface(Class<?> intf) {
return true;
}
@Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
}
}
| 8,553 | 27.898649 | 107 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/SleuthAnnotatedParameter.java
|
package org.myproject.ms.monitoring.antn;
class SleuthAnnotatedParameter {
int parameterIndex;
SpanTag annotation;
Object argument;
SleuthAnnotatedParameter(int parameterIndex, SpanTag annotation,
Object argument) {
this.parameterIndex = parameterIndex;
this.annotation = annotation;
this.argument = argument;
}
}
| 336 | 15.047619 | 65 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/SleuthAnnotationAutoConfiguration.java
|
package org.myproject.ms.monitoring.antn;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.atcfg.TraceAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@ConditionalOnBean(Chainer.class)
@ConditionalOnProperty(name = "spring.sleuth.annotation.enabled", matchIfMissing = true)
@AutoConfigureAfter(TraceAutoConfiguration.class)
@EnableConfigurationProperties(SleuthAnnotationProperties.class)
public class SleuthAnnotationAutoConfiguration {
@Bean
@ConditionalOnMissingBean
SpanCreator spanCreator(Chainer tracer) {
return new DefaultSpanCreator(tracer);
}
@Bean
@ConditionalOnMissingBean
TagValueExpressionResolver spelTagValueExpressionResolver() {
return new SpelTagValueExpressionResolver();
}
@Bean
@ConditionalOnMissingBean
TagValueResolver noOpTagValueResolver() {
return new NoOpTagValueResolver();
}
@Bean
SleuthAdvisorConfig sleuthAdvisorConfig() {
return new SleuthAdvisorConfig();
}
}
| 1,439 | 30.304348 | 88 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/SleuthAnnotationProperties.java
|
package org.myproject.ms.monitoring.antn;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties("spring.sleuth.annotation")
public class SleuthAnnotationProperties {
private boolean enabled = true;
public boolean isEnabled() {
return this.enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
}
| 384 | 17.333333 | 75 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/SleuthAnnotationUtils.java
|
package org.myproject.ms.monitoring.antn;
import java.lang.annotation.Annotation;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.core.annotation.AnnotationUtils;
class SleuthAnnotationUtils {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
static boolean isMethodAnnotated(Method method) {
return findAnnotation(method, NewSpan.class) != null ||
findAnnotation(method, ContinueSpan.class) != null;
}
static boolean hasAnnotatedParams(Method method, Object[] args) {
return !findAnnotatedParameters(method, args).isEmpty();
}
static List<SleuthAnnotatedParameter> findAnnotatedParameters(Method method, Object[] args) {
Annotation[][] parameters = method.getParameterAnnotations();
List<SleuthAnnotatedParameter> result = new ArrayList<>();
int i = 0;
for (Annotation[] parameter : parameters) {
for (Annotation parameter2 : parameter) {
if (parameter2 instanceof SpanTag) {
result.add(new SleuthAnnotatedParameter(i, (SpanTag) parameter2, args[i]));
}
}
i++;
}
return result;
}
static <T extends Annotation> T findAnnotation(Method method, Class<T> clazz) {
T annotation = AnnotationUtils.findAnnotation(method, clazz);
if (annotation == null) {
try {
annotation = AnnotationUtils.findAnnotation(
method.getDeclaringClass().getMethod(method.getName(),
method.getParameterTypes()), clazz);
} catch (NoSuchMethodException | SecurityException e) {
if (log.isDebugEnabled()) {
log.debug("Exception occurred while tyring to find the annotation", e);
}
}
}
return annotation;
}
}
| 1,814 | 28.754098 | 94 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/SpanCreator.java
|
package org.myproject.ms.monitoring.antn;
import org.aopalliance.intercept.MethodInvocation;
import org.myproject.ms.monitoring.Item;
public interface SpanCreator {
Item createSpan(MethodInvocation methodInvocation, NewSpan newSpan);
}
| 245 | 16.571429 | 69 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/SpanTag.java
|
package org.myproject.ms.monitoring.antn;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Target(value = { ElementType.PARAMETER })
public @interface SpanTag {
@AliasFor("key")
String value() default "";
@AliasFor("value")
String key() default "";
String expression() default "";
Class<? extends TagValueResolver> resolver() default NoOpTagValueResolver.class;
}
| 641 | 17.882353 | 81 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/SpanTagAnnotationHandler.java
|
package org.myproject.ms.monitoring.antn;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.factory.BeanFactory;
import org.myproject.ms.monitoring.Chainer;
import org.springframework.util.StringUtils;
class SpanTagAnnotationHandler {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private final BeanFactory beanFactory;
private Chainer tracer;
SpanTagAnnotationHandler(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
void addAnnotatedParameters(MethodInvocation pjp) {
try {
Method method = pjp.getMethod();
Method mostSpecificMethod = AopUtils.getMostSpecificMethod(method,
pjp.getThis().getClass());
List<SleuthAnnotatedParameter> annotatedParameters =
SleuthAnnotationUtils.findAnnotatedParameters(mostSpecificMethod, pjp.getArguments());
getAnnotationsFromInterfaces(pjp, mostSpecificMethod, annotatedParameters);
mergeAnnotatedMethodsIfNecessary(pjp, method, mostSpecificMethod,
annotatedParameters);
addAnnotatedArguments(annotatedParameters);
} catch (SecurityException e) {
log.error("Exception occurred while trying to add annotated parameters", e);
}
}
private void getAnnotationsFromInterfaces(MethodInvocation pjp,
Method mostSpecificMethod,
List<SleuthAnnotatedParameter> annotatedParameters) {
Class<?>[] implementedInterfaces = pjp.getThis().getClass().getInterfaces();
if (implementedInterfaces.length > 0) {
for (Class<?> implementedInterface : implementedInterfaces) {
for (Method methodFromInterface : implementedInterface.getMethods()) {
if (methodsAreTheSame(mostSpecificMethod, methodFromInterface)) {
List<SleuthAnnotatedParameter> annotatedParametersForActualMethod =
SleuthAnnotationUtils.findAnnotatedParameters(methodFromInterface, pjp.getArguments());
mergeAnnotatedParameters(annotatedParameters, annotatedParametersForActualMethod);
}
}
}
}
}
private boolean methodsAreTheSame(Method mostSpecificMethod, Method method1) {
return method1.getName().equals(mostSpecificMethod.getName()) &&
Arrays.equals(method1.getParameterTypes(), mostSpecificMethod.getParameterTypes());
}
private void mergeAnnotatedMethodsIfNecessary(MethodInvocation pjp, Method method,
Method mostSpecificMethod, List<SleuthAnnotatedParameter> annotatedParameters) {
// that can happen if we have an abstraction and a concrete class that is
// annotated with @NewSpan annotation
if (!method.equals(mostSpecificMethod)) {
List<SleuthAnnotatedParameter> annotatedParametersForActualMethod = SleuthAnnotationUtils.findAnnotatedParameters(
method, pjp.getArguments());
mergeAnnotatedParameters(annotatedParameters, annotatedParametersForActualMethod);
}
}
private void mergeAnnotatedParameters(List<SleuthAnnotatedParameter> annotatedParametersIndices,
List<SleuthAnnotatedParameter> annotatedParametersIndicesForActualMethod) {
for (SleuthAnnotatedParameter container : annotatedParametersIndicesForActualMethod) {
final int index = container.parameterIndex;
boolean parameterContained = false;
for (SleuthAnnotatedParameter parameterContainer : annotatedParametersIndices) {
if (parameterContainer.parameterIndex == index) {
parameterContained = true;
break;
}
}
if (!parameterContained) {
annotatedParametersIndices.add(container);
}
}
}
private void addAnnotatedArguments(List<SleuthAnnotatedParameter> toBeAdded) {
for (SleuthAnnotatedParameter container : toBeAdded) {
String tagValue = resolveTagValue(container.annotation, container.argument);
tracer().addTag(container.annotation.value(), tagValue);
}
}
String resolveTagValue(SpanTag annotation, Object argument) {
if (argument == null) {
return "";
}
if (annotation.resolver() != NoOpTagValueResolver.class) {
TagValueResolver tagValueResolver = this.beanFactory.getBean(annotation.resolver());
return tagValueResolver.resolve(argument);
} else if (StringUtils.hasText(annotation.expression())) {
return this.beanFactory.getBean(TagValueExpressionResolver.class)
.resolve(annotation.expression(), argument);
}
return argument.toString();
}
private Chainer tracer() {
if (this.tracer == null) {
this.tracer = this.beanFactory.getBean(Chainer.class);
}
return this.tracer;
}
}
| 4,638 | 36.112 | 117 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/SpelTagValueExpressionResolver.java
|
package org.myproject.ms.monitoring.antn;
import java.lang.invoke.MethodHandles;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
class SpelTagValueExpressionResolver implements TagValueExpressionResolver {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
@Override
public String resolve(String expression, Object parameter) {
try {
ExpressionParser expressionParser = new SpelExpressionParser();
Expression expressionToEvaluate = expressionParser.parseExpression(expression);
return expressionToEvaluate.getValue(parameter, String.class);
} catch (Exception e) {
log.error("Exception occurred while tying to evaluate the SPEL expression [" + expression + "]", e);
}
return parameter.toString();
}
}
| 986 | 33.034483 | 103 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/TagValueExpressionResolver.java
|
package org.myproject.ms.monitoring.antn;
public interface TagValueExpressionResolver {
String resolve(String expression, Object parameter);
}
| 153 | 11.833333 | 53 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/antn/TagValueResolver.java
|
package org.myproject.ms.monitoring.antn;
public interface TagValueResolver {
String resolve(Object parameter);
}
| 122 | 11.3 | 41 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/atcfg/SleuthProperties.java
|
package org.myproject.ms.monitoring.atcfg;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties("spring.sleuth")
public class SleuthProperties {
private boolean enabled = true;
private boolean traceId128 = false;
public boolean isEnabled() {
return this.enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public boolean isTraceId128() {
return this.traceId128;
}
public void setTraceId128(boolean traceId128) {
this.traceId128 = traceId128;
}
}
| 551 | 16.806452 | 75 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/atcfg/TraceAutoConfiguration.java
|
package org.myproject.ms.monitoring.atcfg;
import java.util.Random;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.myproject.ms.monitoring.DefaultItemNamer;
import org.myproject.ms.monitoring.NOItemAdjuster;
import org.myproject.ms.monitoring.NOItemReporter;
import org.myproject.ms.monitoring.Sampler;
import org.myproject.ms.monitoring.ItemAdjuster;
import org.myproject.ms.monitoring.ItemNamer;
import org.myproject.ms.monitoring.ItemReporter;
//import org.myproject.ms.monitoring.StateSpanAdjuster;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.lgger.ItemLogger;
import org.myproject.ms.monitoring.spl.NeverSampler;
import org.myproject.ms.monitoring.trace.DChainer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@ConditionalOnProperty(value="spring.sleuth.enabled", matchIfMissing=true)
@EnableConfigurationProperties({ChainKeys.class, SleuthProperties.class})
public class TraceAutoConfiguration {
@Autowired
SleuthProperties properties;
@Bean
@ConditionalOnMissingBean
public Random randomForSpanIds() {
return new Random();
}
@Bean
@ConditionalOnMissingBean
public Sampler defaultTraceSampler() {
return NeverSampler.INSTANCE;
}
@Bean
@ConditionalOnMissingBean(Chainer.class)
public DChainer sleuthTracer(Sampler sampler, Random random,
ItemNamer spanNamer, ItemLogger spanLogger,
ItemReporter spanReporter, ChainKeys traceKeys) {
return new DChainer(sampler, random, spanNamer, spanLogger,
spanReporter, this.properties.isTraceId128(), traceKeys);
}
@Bean
@ConditionalOnMissingBean
public ItemNamer spanNamer() {
return new DefaultItemNamer();
}
@Bean
@ConditionalOnMissingBean
public ItemReporter defaultSpanReporter() {
return new NOItemReporter();
}
@Bean
@ConditionalOnMissingBean
public ItemAdjuster defaultSpanAdjuster() {
return new NOItemAdjuster();
// return new StateSpanAdjuster();
}
}
| 2,299 | 29.263158 | 81 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/atcfg/TraceEnvironmentPostProcessor.java
|
package org.myproject.ms.monitoring.atcfg;
import java.util.HashMap;
import java.util.Map;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.env.EnvironmentPostProcessor;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.MapPropertySource;
import org.springframework.core.env.MutablePropertySources;
import org.springframework.core.env.PropertySource;
public class TraceEnvironmentPostProcessor implements EnvironmentPostProcessor {
private static final String PROPERTY_SOURCE_NAME = "defaultProperties";
@Override
public void postProcessEnvironment(ConfigurableEnvironment environment,
SpringApplication application) {
Map<String, Object> map = new HashMap<String, Object>();
// This doesn't work with all logging systems but it's a useful default so you see
// traces in logs without having to configure it.
map.put("logging.pattern.level",
"%5p [${spring.zipkin.service.name:${spring.application.name:-}},%X{X-B3-TraceId:-},%X{X-B3-SpanId:-},%X{X-Span-Export:-}]");
map.put("spring.aop.proxyTargetClass", "true");
addOrReplace(environment.getPropertySources(), map);
}
private void addOrReplace(MutablePropertySources propertySources,
Map<String, Object> map) {
MapPropertySource target = null;
if (propertySources.contains(PROPERTY_SOURCE_NAME)) {
PropertySource<?> source = propertySources.get(PROPERTY_SOURCE_NAME);
if (source instanceof MapPropertySource) {
target = (MapPropertySource) source;
for (String key : map.keySet()) {
if (!target.containsProperty(key)) {
target.getSource().put(key, map.get(key));
}
}
}
}
if (target == null) {
target = new MapPropertySource(PROPERTY_SOURCE_NAME, map);
}
if (!propertySources.contains(PROPERTY_SOURCE_NAME)) {
propertySources.addLast(target);
}
}
}
| 1,876 | 33.127273 | 129 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/async/ACAtcfg.java
|
package org.myproject.ms.monitoring.instrument.async;
import org.myproject.ms.monitoring.instrument.schedl.TSAConf;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
@Configuration
@ConditionalOnBean(AsyncConfigurer.class)
@AutoConfigureBefore(ADAtcfg.class)
@ConditionalOnProperty(value = "spring.sleuth.async.enabled", matchIfMissing = true)
@AutoConfigureAfter(TSAConf.class)
public class ACAtcfg implements BeanPostProcessor {
@Autowired
private BeanFactory beanFactory;
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
if (bean instanceof AsyncConfigurer) {
AsyncConfigurer configurer = (AsyncConfigurer) bean;
return new LTACus(this.beanFactory, configurer);
}
return bean;
}
}
| 1,502 | 33.159091 | 84 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/async/ADAtcfg.java
|
package org.myproject.ms.monitoring.instrument.async;
import java.util.concurrent.Executor;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.AsyncConfigurerSupport;
import org.springframework.scheduling.annotation.EnableAsync;
@EnableAsync
@Configuration
@ConditionalOnProperty(value = "spring.sleuth.async.enabled", matchIfMissing = true)
@ConditionalOnBean(Chainer.class)
@AutoConfigureAfter(ACAtcfg.class)
public class ADAtcfg {
@Autowired private BeanFactory beanFactory;
@Configuration
@ConditionalOnMissingBean(AsyncConfigurer.class)
@ConditionalOnProperty(value = "spring.sleuth.async.configurer.enabled", matchIfMissing = true)
static class DefaultAsyncConfigurerSupport extends AsyncConfigurerSupport {
@Autowired private BeanFactory beanFactory;
@Override
public Executor getAsyncExecutor() {
return new LTExec(this.beanFactory, new SimpleAsyncTaskExecutor());
}
}
@Bean
public TAAsp traceAsyncAspect(Chainer tracer, ChainKeys traceKeys) {
return new TAAsp(tracer, traceKeys, this.beanFactory);
}
@Bean
public EBPProc executorBeanPostProcessor() {
return new EBPProc(this.beanFactory);
}
}
| 1,889 | 33.363636 | 96 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/async/EBPProc.java
|
package org.myproject.ms.monitoring.instrument.async;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.concurrent.Executor;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.framework.ProxyFactoryBean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.ReflectionUtils;
class EBPProc implements BeanPostProcessor {
private final BeanFactory beanFactory;
EBPProc(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
if (bean instanceof Executor && !(bean instanceof ThreadPoolTaskExecutor)) {
Method execute = ReflectionUtils.findMethod(bean.getClass(), "execute", Runnable.class);
boolean methodFinal = Modifier.isFinal(execute.getModifiers());
boolean classFinal = Modifier.isFinal(bean.getClass().getModifiers());
boolean cglibProxy = !methodFinal && !classFinal;
Executor executor = (Executor) bean;
ProxyFactoryBean factory = new ProxyFactoryBean();
factory.setProxyTargetClass(cglibProxy);
factory.addAdvice(new ExecutorMethodInterceptor(executor, this.beanFactory));
factory.setTarget(bean);
return factory.getObject();
}
return bean;
}
}
class ExecutorMethodInterceptor implements MethodInterceptor {
private final Executor delegate;
private final BeanFactory beanFactory;
ExecutorMethodInterceptor(Executor delegate, BeanFactory beanFactory) {
this.delegate = delegate;
this.beanFactory = beanFactory;
}
@Override public Object invoke(MethodInvocation invocation)
throws Throwable {
LTExec executor = new LTExec(this.beanFactory, this.delegate);
Method methodOnTracedBean = getMethod(invocation, executor);
if (methodOnTracedBean != null) {
return methodOnTracedBean.invoke(executor, invocation.getArguments());
}
return invocation.proceed();
}
private Method getMethod(MethodInvocation invocation, Object object) {
Method method = invocation.getMethod();
return ReflectionUtils
.findMethod(object.getClass(), method.getName(), method.getParameterTypes());
}
}
| 2,561 | 31.846154 | 91 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/async/LCTCall.java
|
package org.myproject.ms.monitoring.instrument.async;
import java.util.concurrent.Callable;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ItemNamer;
import org.myproject.ms.monitoring.ChainCallable;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.ChainKeys;
public class LCTCall<V> extends ChainCallable<V> {
protected static final String ASYNC_COMPONENT = "async";
private final ChainKeys traceKeys;
public LCTCall(Chainer tracer, ChainKeys traceKeys,
ItemNamer spanNamer, Callable<V> delegate) {
super(tracer, spanNamer, delegate);
this.traceKeys = traceKeys;
}
public LCTCall(Chainer tracer, ChainKeys traceKeys,
ItemNamer spanNamer, String name, Callable<V> delegate) {
super(tracer, spanNamer, delegate, name);
this.traceKeys = traceKeys;
}
@Override
public V call() throws Exception {
Item span = startSpan();
try {
return this.getDelegate().call();
}
finally {
close(span);
}
}
@Override
protected Item startSpan() {
Item span = getTracer().createSpan(getSpanName(), getParent());
getTracer().addTag(Item.SPAN_LOCAL_COMPONENT_TAG_NAME, ASYNC_COMPONENT);
getTracer().addTag(this.traceKeys.getAsync().getPrefix() +
this.traceKeys.getAsync().getThreadNameKey(), Thread.currentThread().getName());
return span;
}
}
| 1,345 | 24.884615 | 84 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/async/LCTRun.java
|
package org.myproject.ms.monitoring.instrument.async;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ItemNamer;
import org.myproject.ms.monitoring.ChainRunnable;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.ChainKeys;
public class LCTRun extends ChainRunnable {
protected static final String ASYNC_COMPONENT = "async";
private final ChainKeys traceKeys;
public LCTRun(Chainer tracer, ChainKeys traceKeys,
ItemNamer spanNamer, Runnable delegate) {
super(tracer, spanNamer, delegate);
this.traceKeys = traceKeys;
}
public LCTRun(Chainer tracer, ChainKeys traceKeys,
ItemNamer spanNamer, Runnable delegate, String name) {
super(tracer, spanNamer, delegate, name);
this.traceKeys = traceKeys;
}
@Override
public void run() {
Item span = startSpan();
try {
this.getDelegate().run();
}
finally {
close(span);
}
}
@Override
protected Item startSpan() {
Item span = getTracer().createSpan(getSpanName(), getParent());
getTracer().addTag(Item.SPAN_LOCAL_COMPONENT_TAG_NAME, ASYNC_COMPONENT);
getTracer().addTag(this.traceKeys.getAsync().getPrefix() +
this.traceKeys.getAsync().getThreadNameKey(), Thread.currentThread().getName());
return span;
}
}
| 1,268 | 24.38 | 84 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/async/LTACus.java
|
package org.myproject.ms.monitoring.instrument.async;
import java.util.concurrent.Executor;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.AsyncConfigurerSupport;
public class LTACus extends AsyncConfigurerSupport {
private final BeanFactory beanFactory;
private final AsyncConfigurer delegate;
public LTACus(BeanFactory beanFactory, AsyncConfigurer delegate) {
this.beanFactory = beanFactory;
this.delegate = delegate;
}
@Override
public Executor getAsyncExecutor() {
return new LTExec(this.beanFactory, this.delegate.getAsyncExecutor());
}
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return this.delegate.getAsyncUncaughtExceptionHandler();
}
}
| 912 | 25.852941 | 74 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/async/LTExec.java
|
package org.myproject.ms.monitoring.instrument.async;
import java.lang.invoke.MethodHandles;
import java.util.concurrent.Executor;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.myproject.ms.monitoring.DefaultItemNamer;
import org.myproject.ms.monitoring.ItemNamer;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
public class LTExec implements Executor {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private Chainer tracer;
private final BeanFactory beanFactory;
private final Executor delegate;
private ChainKeys traceKeys;
private ItemNamer spanNamer;
public LTExec(BeanFactory beanFactory, Executor delegate) {
this.beanFactory = beanFactory;
this.delegate = delegate;
}
@Override
public void execute(Runnable command) {
if (this.tracer == null) {
try {
this.tracer = this.beanFactory.getBean(Chainer.class);
}
catch (NoSuchBeanDefinitionException e) {
this.delegate.execute(command);
return;
}
}
this.delegate.execute(new SCTRun(this.tracer, traceKeys(), spanNamer(), command));
}
// due to some race conditions trace keys might not be ready yet
private ChainKeys traceKeys() {
if (this.traceKeys == null) {
try {
this.traceKeys = this.beanFactory.getBean(ChainKeys.class);
}
catch (NoSuchBeanDefinitionException e) {
log.warn("TraceKeys bean not found - will provide a manually created instance");
return new ChainKeys();
}
}
return this.traceKeys;
}
// due to some race conditions trace keys might not be ready yet
private ItemNamer spanNamer() {
if (this.spanNamer == null) {
try {
this.spanNamer = this.beanFactory.getBean(ItemNamer.class);
}
catch (NoSuchBeanDefinitionException e) {
log.warn("SpanNamer bean not found - will provide a manually created instance");
return new DefaultItemNamer();
}
}
return this.spanNamer;
}
}
| 2,121 | 26.921053 | 88 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/async/LTTPTExec.java
|
package org.myproject.ms.monitoring.instrument.async;
import java.lang.invoke.MethodHandles;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.myproject.ms.monitoring.DefaultItemNamer;
import org.myproject.ms.monitoring.ItemNamer;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.concurrent.ListenableFuture;
@SuppressWarnings("serial")
public class LTTPTExec extends ThreadPoolTaskExecutor {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private Chainer tracer;
private final BeanFactory beanFactory;
private final ThreadPoolTaskExecutor delegate;
private ChainKeys traceKeys;
private ItemNamer spanNamer;
public LTTPTExec(BeanFactory beanFactory,
ThreadPoolTaskExecutor delegate) {
this.beanFactory = beanFactory;
this.delegate = delegate;
}
@Override
public void execute(Runnable task) {
this.delegate.execute(new SCTRun(tracer(), traceKeys(), spanNamer(), task));
}
@Override
public void execute(Runnable task, long startTimeout) {
this.delegate.execute(new SCTRun(tracer(), traceKeys(), spanNamer(), task), startTimeout);
}
@Override
public Future<?> submit(Runnable task) {
return this.delegate.submit(new SCTRun(tracer(), traceKeys(), spanNamer(), task));
}
@Override
public <T> Future<T> submit(Callable<T> task) {
return this.delegate.submit(new SCTCall<>(tracer(), traceKeys(), spanNamer(), task));
}
@Override
public ListenableFuture<?> submitListenable(Runnable task) {
return this.delegate.submitListenable(new SCTRun(tracer(), traceKeys(), spanNamer(), task));
}
@Override
public <T> ListenableFuture<T> submitListenable(Callable<T> task) {
return this.delegate.submitListenable(new SCTCall<>(tracer(), traceKeys(), spanNamer(), task));
}
@Override
public ThreadPoolExecutor getThreadPoolExecutor() throws IllegalStateException {
return this.delegate.getThreadPoolExecutor();
}
public void destroy() {
this.delegate.destroy();
super.destroy();
}
@Override
public void afterPropertiesSet() {
this.delegate.afterPropertiesSet();
super.afterPropertiesSet();
}
private Chainer tracer() {
if (this.tracer == null) {
this.tracer = this.beanFactory.getBean(Chainer.class);
}
return this.tracer;
}
private ChainKeys traceKeys() {
if (this.traceKeys == null) {
try {
this.traceKeys = this.beanFactory.getBean(ChainKeys.class);
}
catch (NoSuchBeanDefinitionException e) {
log.warn("TraceKeys bean not found - will provide a manually created instance");
return new ChainKeys();
}
}
return this.traceKeys;
}
private ItemNamer spanNamer() {
if (this.spanNamer == null) {
try {
this.spanNamer = this.beanFactory.getBean(ItemNamer.class);
}
catch (NoSuchBeanDefinitionException e) {
log.warn("SpanNamer bean not found - will provide a manually created instance");
return new DefaultItemNamer();
}
}
return this.spanNamer;
}
}
| 3,366 | 27.533898 | 97 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/async/SCTCall.java
|
package org.myproject.ms.monitoring.instrument.async;
import java.util.concurrent.Callable;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ItemNamer;
import org.myproject.ms.monitoring.ChainCallable;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
public class SCTCall<V> extends ChainCallable<V> {
private final LCTCall<V> traceCallable;
public SCTCall(Chainer tracer, ChainKeys traceKeys,
ItemNamer spanNamer, Callable<V> delegate) {
super(tracer, spanNamer, delegate);
this.traceCallable = new LCTCall<>(tracer, traceKeys, spanNamer, delegate);
}
public SCTCall(Chainer tracer, ChainKeys traceKeys,
ItemNamer spanNamer, String name, Callable<V> delegate) {
super(tracer, spanNamer, delegate, name);
this.traceCallable = new LCTCall<>(tracer, traceKeys, spanNamer, name, delegate);
}
@Override
public V call() throws Exception {
Item span = startSpan();
try {
return this.getDelegate().call();
}
finally {
close(span);
}
}
@Override
protected Item startSpan() {
Item span = this.getParent();
if (span == null) {
return this.traceCallable.startSpan();
}
return continueSpan(span);
}
@Override protected void close(Item span) {
if (this.getParent() == null) {
super.close(span);
} else {
super.detachSpan(span);
}
}
}
| 1,367 | 22.586207 | 83 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/async/SCTRun.java
|
package org.myproject.ms.monitoring.instrument.async;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ItemNamer;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.ChainRunnable;
import org.myproject.ms.monitoring.Chainer;
public class SCTRun extends ChainRunnable {
private final LCTRun traceRunnable;
public SCTRun(Chainer tracer, ChainKeys traceKeys,
ItemNamer spanNamer, Runnable delegate) {
super(tracer, spanNamer, delegate);
this.traceRunnable = new LCTRun(tracer, traceKeys, spanNamer, delegate);
}
public SCTRun(Chainer tracer, ChainKeys traceKeys,
ItemNamer spanNamer, Runnable delegate, String name) {
super(tracer, spanNamer, delegate, name);
this.traceRunnable = new LCTRun(tracer, traceKeys, spanNamer, delegate, name);
}
@Override
public void run() {
Item span = startSpan();
try {
this.getDelegate().run();
}
finally {
close(span);
}
}
@Override
protected Item startSpan() {
Item span = this.getParent();
if (span == null) {
return this.traceRunnable.startSpan();
}
return continueSpan(span);
}
@Override protected void close(Item span) {
if (this.getParent() == null) {
super.close(span);
} else {
super.detachSpan(span);
}
}
}
| 1,280 | 21.875 | 80 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/async/TAAsp.java
|
package org.myproject.ms.monitoring.instrument.async;
import java.lang.reflect.Method;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.BeanFactory;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.util.ItemNameUtil;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.ReflectionUtils;
@Aspect
public class TAAsp {
private static final String ASYNC_COMPONENT = "async";
private final Chainer tracer;
private final ChainKeys traceKeys;
private final BeanFactory beanFactory;
public TAAsp(Chainer tracer, ChainKeys traceKeys, BeanFactory beanFactory) {
this.tracer = tracer;
this.traceKeys = traceKeys;
this.beanFactory = beanFactory;
}
@Around("execution (@org.springframework.scheduling.annotation.Async * *.*(..))")
public Object traceBackgroundThread(final ProceedingJoinPoint pjp) throws Throwable {
Item span = this.tracer.createSpan(
ItemNameUtil.toLowerHyphen(pjp.getSignature().getName()));
this.tracer.addTag(Item.SPAN_LOCAL_COMPONENT_TAG_NAME, ASYNC_COMPONENT);
this.tracer.addTag(this.traceKeys.getAsync().getPrefix() +
this.traceKeys.getAsync().getClassNameKey(), pjp.getTarget().getClass().getSimpleName());
this.tracer.addTag(this.traceKeys.getAsync().getPrefix() +
this.traceKeys.getAsync().getMethodNameKey(), pjp.getSignature().getName());
try {
return pjp.proceed();
} finally {
this.tracer.close(span);
}
}
@Around("execution (* org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor.*(..))")
public Object traceThreadPoolTaskExecutor(final ProceedingJoinPoint pjp) throws Throwable {
LTTPTExec executor = new LTTPTExec(this.beanFactory,
(ThreadPoolTaskExecutor) pjp.getTarget());
Method methodOnTracedBean = getMethod(pjp, executor);
if (methodOnTracedBean != null) {
return methodOnTracedBean.invoke(executor, pjp.getArgs());
}
return pjp.proceed();
}
private Method getMethod(ProceedingJoinPoint pjp, Object object) {
MethodSignature signature = (MethodSignature) pjp.getSignature();
Method method = signature.getMethod();
return ReflectionUtils
.findMethod(object.getClass(), method.getName(), method.getParameterTypes());
}
}
| 2,494 | 34.642857 | 96 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/async/TCCall.java
|
package org.myproject.ms.monitoring.instrument.async;
import java.util.concurrent.Callable;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ItemNamer;
import org.myproject.ms.monitoring.ChainCallable;
import org.myproject.ms.monitoring.Chainer;
@Deprecated
public class TCCall<V> extends ChainCallable<V> implements Callable<V> {
public TCCall(Chainer tracer, ItemNamer spanNamer, Callable<V> delegate) {
super(tracer, spanNamer, delegate);
}
@Override
protected Item startSpan() {
return getTracer().continueSpan(getParent());
}
@Override
protected void close(Item span) {
if (getTracer().isTracing()) {
getTracer().detach(span);
}
}
}
| 693 | 20.6875 | 75 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/async/TEServ.java
|
package org.myproject.ms.monitoring.instrument.async;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.springframework.beans.factory.BeanFactory;
import org.myproject.ms.monitoring.ItemNamer;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
public class TEServ implements ExecutorService {
ExecutorService delegate;
Chainer tracer;
private final String spanName;
ChainKeys traceKeys;
ItemNamer spanNamer;
BeanFactory beanFactory;
public TEServ(final ExecutorService delegate, final Chainer tracer,
ChainKeys traceKeys, ItemNamer spanNamer) {
this(delegate, tracer, traceKeys, spanNamer, null);
}
public TEServ(BeanFactory beanFactory, final ExecutorService delegate) {
this.delegate = delegate;
this.beanFactory = beanFactory;
this.spanName = null;
}
public TEServ(final ExecutorService delegate, final Chainer tracer,
ChainKeys traceKeys, ItemNamer spanNamer, String spanName) {
this.delegate = delegate;
this.tracer = tracer;
this.spanName = spanName;
this.traceKeys = traceKeys;
this.spanNamer = spanNamer;
}
@Override
public void execute(Runnable command) {
final Runnable r = new LCTRun(tracer(), traceKeys(),
spanNamer(), command, this.spanName);
this.delegate.execute(r);
}
@Override
public void shutdown() {
this.delegate.shutdown();
}
@Override
public List<Runnable> shutdownNow() {
return this.delegate.shutdownNow();
}
@Override
public boolean isShutdown() {
return this.delegate.isShutdown();
}
@Override
public boolean isTerminated() {
return this.delegate.isTerminated();
}
@Override
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
return this.delegate.awaitTermination(timeout, unit);
}
@Override
public <T> Future<T> submit(Callable<T> task) {
Callable<T> c = new SCTCall<>(tracer(), traceKeys(),
spanNamer(), this.spanName, task);
return this.delegate.submit(c);
}
@Override
public <T> Future<T> submit(Runnable task, T result) {
Runnable r = new SCTRun(tracer(), traceKeys(),
spanNamer(), task, this.spanName);
return this.delegate.submit(r, result);
}
@Override
public Future<?> submit(Runnable task) {
Runnable r = new LCTRun(tracer(), traceKeys(),
spanNamer(), task, this.spanName);
return this.delegate.submit(r);
}
@Override
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
return this.delegate.invokeAll(wrapCallableCollection(tasks));
}
@Override
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
throws InterruptedException {
return this.delegate.invokeAll(wrapCallableCollection(tasks), timeout, unit);
}
@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
return this.delegate.invokeAny(wrapCallableCollection(tasks));
}
@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
return this.delegate.invokeAny(wrapCallableCollection(tasks), timeout, unit);
}
private <T> Collection<? extends Callable<T>> wrapCallableCollection(Collection<? extends Callable<T>> tasks) {
List<Callable<T>> ts = new ArrayList<>();
for (Callable<T> task : tasks) {
if (!(task instanceof SCTCall)) {
ts.add(new SCTCall<>(tracer(), traceKeys(),
spanNamer(), this.spanName, task));
}
}
return ts;
}
Chainer tracer() {
if (this.tracer == null && this.beanFactory != null) {
this.tracer = this.beanFactory.getBean(Chainer.class);
}
return this.tracer;
}
ChainKeys traceKeys() {
if (this.traceKeys == null && this.beanFactory != null) {
this.traceKeys = this.beanFactory.getBean(ChainKeys.class);
}
return this.traceKeys;
}
ItemNamer spanNamer() {
if (this.spanNamer == null && this.beanFactory != null) {
this.spanNamer = this.beanFactory.getBean(ItemNamer.class);
}
return this.spanNamer;
}
}
| 4,392 | 27.160256 | 114 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/async/TSEServ.java
|
package org.myproject.ms.monitoring.instrument.async;
import java.util.concurrent.Callable;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import org.myproject.ms.monitoring.ItemNamer;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.ChainKeys;
public class TSEServ extends TEServ implements ScheduledExecutorService {
public TSEServ(ScheduledExecutorService delegate,
Chainer tracer, ChainKeys traceKeys, ItemNamer spanNamer) {
super(delegate, tracer, traceKeys, spanNamer);
}
private ScheduledExecutorService getScheduledExecutorService() {
return (ScheduledExecutorService) this.delegate;
}
@Override
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
Runnable r = new SCTRun(this.tracer, this.traceKeys, this.spanNamer, command);
return getScheduledExecutorService().schedule(r, delay, unit);
}
@Override
public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
Callable<V> c = new SCTCall<>(this.tracer, this.traceKeys, this.spanNamer, callable);
return getScheduledExecutorService().schedule(c, delay, unit);
}
@Override
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
Runnable r = new SCTRun(this.tracer, this.traceKeys, this.spanNamer, command);
return getScheduledExecutorService().scheduleAtFixedRate(r, initialDelay, period, unit);
}
@Override
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
Runnable r = new SCTRun(this.tracer, this.traceKeys, this.spanNamer, command);
return getScheduledExecutorService().scheduleWithFixedDelay(r, initialDelay, delay, unit);
}
}
| 1,848 | 35.254902 | 115 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/messaging/websocket/TWSAConf.java
|
package org.myproject.ms.monitoring.instrument.messaging.websocket;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.instrument.msg.MSTMExtra;
import org.myproject.ms.monitoring.instrument.msg.MSTMInject;
import org.myproject.ms.monitoring.instrument.msg.TCInter;
import org.myproject.ms.monitoring.instrument.msg.TSMAConf;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.ChannelRegistration;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.config.annotation.AbstractWebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.DelegatingWebSocketMessageBrokerConfiguration;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
@Component
@Configuration
@AutoConfigureAfter(TSMAConf.class)
@ConditionalOnClass(DelegatingWebSocketMessageBrokerConfiguration.class)
@ConditionalOnBean(Chainer.class)
@ConditionalOnProperty(value = "spring.sleuth.integration.websockets.enabled", matchIfMissing = true)
public class TWSAConf
extends AbstractWebSocketMessageBrokerConfigurer {
@Autowired
Chainer tracer;
@Autowired
ChainKeys traceKeys;
@Autowired
MSTMExtra spanExtractor;
@Autowired
MSTMInject spanInjector;
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
// The user must register their own endpoints
}
@Override
public void configureClientOutboundChannel(ChannelRegistration registration) {
registration.setInterceptors(new TCInter(this.tracer,
this.traceKeys, this.spanExtractor, this.spanInjector));
}
@Override
public void configureClientInboundChannel(ChannelRegistration registration) {
registration.setInterceptors(new TCInter(this.tracer,
this.traceKeys, this.spanExtractor, this.spanInjector));
}
}
| 2,265 | 39.464286 | 102 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/msg/ATCInter.java
|
package org.myproject.ms.monitoring.instrument.msg;
import java.lang.invoke.MethodHandles;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ItemTextMap;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.util.ItemNameUtil;
import org.springframework.integration.channel.AbstractMessageChannel;
import org.springframework.integration.context.IntegrationObjectSupport;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.support.ChannelInterceptorAdapter;
import org.springframework.messaging.support.ExecutorChannelInterceptor;
import org.springframework.util.ClassUtils;
abstract class ATCInter extends ChannelInterceptorAdapter
implements ExecutorChannelInterceptor {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
protected static final String MESSAGE_COMPONENT = "message";
private final Chainer tracer;
private final ChainKeys traceKeys;
private final MSTMExtra spanExtractor;
private final MSTMInject spanInjector;
protected ATCInter(Chainer tracer, ChainKeys traceKeys,
MSTMExtra spanExtractor,
MSTMInject spanInjector) {
this.tracer = tracer;
this.traceKeys = traceKeys;
this.spanExtractor = spanExtractor;
this.spanInjector = spanInjector;
}
protected Chainer getTracer() {
return this.tracer;
}
protected ChainKeys getTraceKeys() {
return this.traceKeys;
}
protected MSTMInject getSpanInjector() {
return this.spanInjector;
}
protected Item buildSpan(ItemTextMap carrier) {
try {
return this.spanExtractor.joinTrace(carrier);
} catch (Exception e) {
log.error("Exception occurred while trying to extract span from carrier", e);
return null;
}
}
String getChannelName(MessageChannel channel) {
String name = null;
if (ClassUtils.isPresent(
"org.springframework.integration.context.IntegrationObjectSupport",
null)) {
if (channel instanceof IntegrationObjectSupport) {
name = ((IntegrationObjectSupport) channel).getComponentName();
}
if (name == null && channel instanceof AbstractMessageChannel) {
name = ((AbstractMessageChannel) channel).getFullChannelName();
}
}
if (name == null) {
name = channel.toString();
}
return name;
}
String getMessageChannelName(MessageChannel channel) {
return ItemNameUtil.shorten(MESSAGE_COMPONENT + ":" + getChannelName(channel));
}
}
| 2,564 | 28.482759 | 88 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/msg/HBMExtra.java
|
package org.myproject.ms.monitoring.instrument.msg;
import java.util.Map;
import java.util.Random;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ItemTextMap;
import org.myproject.ms.monitoring.util.TextMapUtil;
public class HBMExtra implements MSTMExtra {
@Override
public Item joinTrace(ItemTextMap textMap) {
Map<String, String> carrier = TextMapUtil.asMap(textMap);
if (Item.SPAN_SAMPLED.equals(carrier.get(TMHead.SPAN_FLAGS_NAME))) {
String traceId = generateTraceIdIfMissing(carrier);
if (!carrier.containsKey(TMHead.SPAN_ID_NAME)) {
carrier.put(TMHead.SPAN_ID_NAME, traceId);
}
} else if (!hasHeader(carrier, TMHead.SPAN_ID_NAME)
|| !hasHeader(carrier, TMHead.TRACE_ID_NAME)) {
return null;
// TODO: Consider throwing IllegalArgumentException;
}
return extractSpanFromHeaders(carrier, Item.builder());
}
private String generateTraceIdIfMissing(Map<String, String> carrier) {
if (!hasHeader(carrier, TMHead.TRACE_ID_NAME)) {
carrier.put(TMHead.TRACE_ID_NAME, Item.idToHex(new Random().nextLong()));
}
return carrier.get(TMHead.TRACE_ID_NAME);
}
private Item extractSpanFromHeaders(Map<String, String> carrier, Item.SpanBuilder spanBuilder) {
String traceId = carrier.get(TMHead.TRACE_ID_NAME);
spanBuilder = spanBuilder
.traceIdHigh(traceId.length() == 32 ? Item.hexToId(traceId, 0) : 0)
.traceId(Item.hexToId(traceId))
.spanId(Item.hexToId(carrier.get(TMHead.SPAN_ID_NAME)));
String flags = carrier.get(TMHead.SPAN_FLAGS_NAME);
if (Item.SPAN_SAMPLED.equals(flags)) {
spanBuilder.exportable(true);
} else {
spanBuilder.exportable(
Item.SPAN_SAMPLED.equals(carrier.get(TMHead.SAMPLED_NAME)));
}
String processId = carrier.get(TMHead.PROCESS_ID_NAME);
String spanName = carrier.get(TMHead.SPAN_NAME_NAME);
if (spanName != null) {
spanBuilder.name(spanName);
}
if (processId != null) {
spanBuilder.processId(processId);
}
setParentIdIfApplicable(carrier, spanBuilder, TMHead.PARENT_ID_NAME);
spanBuilder.remote(true);
for (Map.Entry<String, String> entry : carrier.entrySet()) {
if (entry.getKey().startsWith(Item.SPAN_BAGGAGE_HEADER_PREFIX + TMHead.HEADER_DELIMITER)) {
spanBuilder.baggage(unprefixedKey(entry.getKey()), entry.getValue());
}
}
return spanBuilder.build();
}
boolean hasHeader(Map<String, String> message, String name) {
return message.containsKey(name);
}
private void setParentIdIfApplicable(Map<String, String> carrier, Item.SpanBuilder spanBuilder,
String spanParentIdHeader) {
String parentId = carrier.get(spanParentIdHeader);
if (parentId != null) {
spanBuilder.parent(Item.hexToId(parentId));
}
}
private String unprefixedKey(String key) {
return key.substring(key.indexOf(TMHead.HEADER_DELIMITER) + 1);
}
}
| 2,818 | 32.559524 | 97 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/msg/HBMInject.java
|
package org.myproject.ms.monitoring.instrument.msg;
import java.util.List;
import java.util.Map;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ItemTextMap;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.util.TextMapUtil;
import org.springframework.util.StringUtils;
public class HBMInject implements MSTMInject {
private final ChainKeys traceKeys;
public HBMInject(ChainKeys traceKeys) {
this.traceKeys = traceKeys;
}
@Override
public void inject(Item span, ItemTextMap carrier) {
Map<String, String> map = TextMapUtil.asMap(carrier);
if (span == null) {
if (!isSampled(map, TMHead.SAMPLED_NAME)) {
carrier.put(TMHead.SAMPLED_NAME, Item.SPAN_NOT_SAMPLED);
return;
}
return;
}
addHeaders(span, carrier);
}
private boolean isSampled(Map<String, String> initialMessage, String sampledHeaderName) {
return Item.SPAN_SAMPLED.equals(initialMessage.get(sampledHeaderName));
}
private void addHeaders(Item span, ItemTextMap textMap) {
addHeader(textMap, TMHead.TRACE_ID_NAME, span.traceIdString());
addHeader(textMap, TMHead.SPAN_ID_NAME, Item.idToHex(span.getSpanId()));
if (span.isExportable()) {
addAnnotations(this.traceKeys, textMap, span);
Long parentId = getFirst(span.getParents());
if (parentId != null) {
addHeader(textMap, TMHead.PARENT_ID_NAME, Item.idToHex(parentId));
}
addHeader(textMap, TMHead.SPAN_NAME_NAME, span.getName());
addHeader(textMap, TMHead.PROCESS_ID_NAME, span.getProcessId());
addHeader(textMap, TMHead.SAMPLED_NAME, Item.SPAN_SAMPLED);
}
else {
addHeader(textMap, TMHead.SAMPLED_NAME, Item.SPAN_NOT_SAMPLED);
}
for (Map.Entry<String, String> entry : span.baggageItems()) {
textMap.put(prefixedKey(entry.getKey()), entry.getValue());
}
}
private void addAnnotations(ChainKeys traceKeys, ItemTextMap spanTextMap, Item span) {
Map<String, String> map = TextMapUtil.asMap(spanTextMap);
for (String name : traceKeys.getMessage().getHeaders()) {
if (map.containsKey(name)) {
String key = traceKeys.getMessage().getPrefix() + name.toLowerCase();
Object value = map.get(name);
if (value == null) {
value = "null";
}
// TODO: better way to serialize?
tagIfEntryMissing(span, key, value.toString());
}
}
addPayloadAnnotations(traceKeys, map, span);
}
private void addPayloadAnnotations(ChainKeys traceKeys, Map<String, String> map, Item span) {
if (map.containsKey(traceKeys.getMessage().getPayload().getType())) {
tagIfEntryMissing(span, traceKeys.getMessage().getPayload().getType(),
map.get(traceKeys.getMessage().getPayload().getType()));
tagIfEntryMissing(span, traceKeys.getMessage().getPayload().getSize(),
map.get(traceKeys.getMessage().getPayload().getSize()));
}
}
private void tagIfEntryMissing(Item span, String key, String value) {
if (!span.tags().containsKey(key)) {
span.tag(key, value);
}
}
private void addHeader(ItemTextMap textMap, String name, String value) {
if (StringUtils.hasText(value)) {
textMap.put(name, value);
}
}
private Long getFirst(List<Long> parents) {
return parents.isEmpty() ? null : parents.get(0);
}
private String prefixedKey(String key) {
if (key.startsWith(Item.SPAN_BAGGAGE_HEADER_PREFIX + TMHead.HEADER_DELIMITER )) {
return key;
}
return Item.SPAN_BAGGAGE_HEADER_PREFIX + TMHead.HEADER_DELIMITER + key;
}
}
| 3,434 | 30.805556 | 94 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/msg/ITCInter.java
|
package org.myproject.ms.monitoring.instrument.msg;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.springframework.integration.channel.ChannelInterceptorAware;
import org.springframework.integration.channel.interceptor.VetoCapableInterceptor;
import org.springframework.messaging.support.ChannelInterceptor;
class ITCInter extends TCInter implements VetoCapableInterceptor {
public ITCInter(Chainer tracer, ChainKeys traceKeys,
MSTMExtra spanExtractor,
MSTMInject spanInjector) {
super(tracer, traceKeys, spanExtractor, spanInjector);
}
@Override
public boolean shouldIntercept(String beanName, ChannelInterceptorAware channel) {
for (ChannelInterceptor interceptor : channel.getChannelInterceptors()) {
if (interceptor instanceof ATCInter) {
return false;
}
}
return true;
}
}
| 870 | 26.21875 | 83 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/msg/MSTMExtra.java
|
package org.myproject.ms.monitoring.instrument.msg;
import org.myproject.ms.monitoring.ItemExtractor;
import org.myproject.ms.monitoring.ItemTextMap;
public interface MSTMExtra extends ItemExtractor<ItemTextMap> {
}
| 219 | 23.444444 | 63 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/msg/MSTMInject.java
|
package org.myproject.ms.monitoring.instrument.msg;
import org.myproject.ms.monitoring.ItemInjector;
import org.myproject.ms.monitoring.ItemTextMap;
public interface MSTMInject extends ItemInjector<ItemTextMap> {
}
| 218 | 23.333333 | 63 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/msg/MTMap.java
|
package org.myproject.ms.monitoring.instrument.msg;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.myproject.ms.monitoring.ItemTextMap;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.messaging.support.MessageHeaderAccessor;
import org.springframework.messaging.support.NativeMessageHeaderAccessor;
import org.springframework.util.StringUtils;
class MTMap implements ItemTextMap {
private final MessageBuilder delegate;
public MTMap(MessageBuilder delegate) {
this.delegate = delegate;
}
@Override
public Iterator<Map.Entry<String, String>> iterator() {
Map<String, String> map = new HashMap<>();
for (Map.Entry<String, Object> entry : this.delegate.build().getHeaders()
.entrySet()) {
map.put(entry.getKey(), String.valueOf(entry.getValue()));
}
return map.entrySet().iterator();
}
@Override
@SuppressWarnings("unchecked")
public void put(String key, String value) {
if (!StringUtils.hasText(value)) {
return;
}
Message<?> initialMessage = this.delegate.build();
MessageHeaderAccessor accessor = MessageHeaderAccessor
.getMutableAccessor(initialMessage);
accessor.setHeader(key, value);
if (accessor instanceof NativeMessageHeaderAccessor) {
NativeMessageHeaderAccessor nativeAccessor = (NativeMessageHeaderAccessor) accessor;
nativeAccessor.setNativeHeader(key, value);
}
this.delegate.copyHeaders(accessor.toMessageHeaders());
}
}
| 1,525 | 28.346154 | 87 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/msg/TCInter.java
|
package org.myproject.ms.monitoring.instrument.msg;
import org.myproject.ms.monitoring.Log;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.spl.NeverSampler;
import org.myproject.ms.monitoring.util.ExceptionUtils;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;
import org.springframework.messaging.support.GenericMessage;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.messaging.support.MessageHeaderAccessor;
public class TCInter extends ATCInter {
public TCInter(Chainer tracer, ChainKeys traceKeys,
MSTMExtra spanExtractor,
MSTMInject spanInjector) {
super(tracer, traceKeys, spanExtractor, spanInjector);
}
@Override
public void afterSendCompletion(Message<?> message, MessageChannel channel, boolean sent, Exception ex) {
Item currentSpan = getTracer().getCurrentSpan();
if (containsServerReceived(currentSpan)) {
currentSpan.logEvent(Item.SERVER_SEND);
} else if (currentSpan != null) {
currentSpan.logEvent(Item.CLIENT_RECV);
}
addErrorTag(ex);
getTracer().close(currentSpan);
}
private boolean containsServerReceived(Item span) {
if (span == null) {
return false;
}
for (Log log : span.logs()) {
if (Item.SERVER_RECV.equals(log.getEvent())) {
return true;
}
}
return false;
}
@Override
public Message<?> preSend(Message<?> message, MessageChannel channel) {
MessageBuilder<?> messageBuilder = MessageBuilder.fromMessage(message);
Item parentSpan = getTracer().isTracing() ? getTracer().getCurrentSpan()
: buildSpan(new MTMap(messageBuilder));
String name = getMessageChannelName(channel);
Item span = startSpan(parentSpan, name, message);
if (message.getHeaders().containsKey(TMHead.MESSAGE_SENT_FROM_CLIENT)) {
span.logEvent(Item.SERVER_RECV);
} else {
span.logEvent(Item.CLIENT_SEND);
messageBuilder.setHeader(TMHead.MESSAGE_SENT_FROM_CLIENT, true);
}
getSpanInjector().inject(span, new MTMap(messageBuilder));
MessageHeaderAccessor headers = MessageHeaderAccessor.getMutableAccessor(message);
headers.copyHeaders(messageBuilder.build().getHeaders());
return new GenericMessage<Object>(message.getPayload(), headers.getMessageHeaders());
}
private Item startSpan(Item span, String name, Message<?> message) {
if (span != null) {
return getTracer().createSpan(name, span);
}
if (Item.SPAN_NOT_SAMPLED.equals(message.getHeaders().get(TMHead.SAMPLED_NAME))) {
return getTracer().createSpan(name, NeverSampler.INSTANCE);
}
return getTracer().createSpan(name);
}
@Override
public Message<?> beforeHandle(Message<?> message, MessageChannel channel,
MessageHandler handler) {
Item spanFromHeader = getTracer().getCurrentSpan();
if (spanFromHeader!= null) {
spanFromHeader.logEvent(Item.SERVER_RECV);
}
getTracer().continueSpan(spanFromHeader);
return message;
}
@Override
public void afterMessageHandled(Message<?> message, MessageChannel channel,
MessageHandler handler, Exception ex) {
Item spanFromHeader = getTracer().getCurrentSpan();
if (spanFromHeader!= null) {
spanFromHeader.logEvent(Item.SERVER_SEND);
addErrorTag(ex);
}
// related to #447
if (getTracer().isTracing()) {
getTracer().detach(spanFromHeader);
}
}
private void addErrorTag(Exception ex) {
if (ex != null) {
getTracer().addTag(Item.SPAN_ERROR_TAG_NAME, ExceptionUtils.getExceptionMessage(ex));
}
}
}
| 3,620 | 31.330357 | 106 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/msg/TMHead.java
|
package org.myproject.ms.monitoring.instrument.msg;
public class TMHead {
public static final String SPAN_ID_NAME = "spanId";
public static final String SAMPLED_NAME = "spanSampled";
public static final String PROCESS_ID_NAME = "spanProcessId";
public static final String PARENT_ID_NAME = "spanParentSpanId";
public static final String TRACE_ID_NAME = "spanTraceId";
public static final String SPAN_NAME_NAME = "spanName";
public static final String SPAN_FLAGS_NAME = "spanFlags";
static final String MESSAGE_SENT_FROM_CLIENT = "messageSent";
static final String HEADER_DELIMITER = "_";
private TMHead() {}
}
| 626 | 28.857143 | 64 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/msg/TSIAConf.java
|
package org.myproject.ms.monitoring.instrument.msg;
import java.util.Random;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.atcfg.TraceAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.config.GlobalChannelInterceptor;
@Configuration
@ConditionalOnClass(GlobalChannelInterceptor.class)
@ConditionalOnBean(Chainer.class)
@AutoConfigureAfter({ TraceAutoConfiguration.class,
TSMAConf.class })
@ConditionalOnProperty(value = "spring.sleuth.integration.enabled", matchIfMissing = true)
@EnableConfigurationProperties(ChainKeys.class)
public class TSIAConf {
@Bean
@GlobalChannelInterceptor(patterns = "${spring.sleuth.integration.patterns:*}")
public TCInter traceChannelInterceptor(Chainer tracer,
ChainKeys traceKeys, Random random, MSTMExtra spanExtractor,
MSTMInject spanInjector) {
return new ITCInter(tracer, traceKeys, spanExtractor,
spanInjector);
}
}
| 1,457 | 36.384615 | 90 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/msg/TSMAConf.java
|
package org.myproject.ms.monitoring.instrument.msg;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.Message;
@Configuration
@ConditionalOnClass(Message.class)
@ConditionalOnBean(Chainer.class)
public class TSMAConf {
@Bean
@ConditionalOnMissingBean
public MSTMExtra messagingSpanExtractor() {
return new HBMExtra();
}
@Bean
@ConditionalOnMissingBean
public MSTMInject messagingSpanInjector(ChainKeys traceKeys) {
return new HBMInject(traceKeys);
}
}
| 894 | 26.96875 | 81 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/rest/SHAConf.java
|
package org.myproject.ms.monitoring.instrument.rest;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.atcfg.TraceAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.netflix.hystrix.HystrixCommand;
@Configuration
@AutoConfigureAfter(TraceAutoConfiguration.class)
@ConditionalOnClass(HystrixCommand.class)
@ConditionalOnBean(Chainer.class)
@ConditionalOnProperty(value = "spring.sleuth.hystrix.strategy.enabled", matchIfMissing = true)
public class SHAConf {
@Bean
SHCStra sleuthHystrixConcurrencyStrategy(Chainer tracer, ChainKeys traceKeys) {
return new SHCStra(tracer, traceKeys);
}
}
| 1,060 | 35.586207 | 95 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/rest/SHCStra.java
|
package org.myproject.ms.monitoring.instrument.rest;
import java.lang.invoke.MethodHandles;
import java.util.concurrent.Callable;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import com.netflix.hystrix.strategy.HystrixPlugins;
import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy;
import com.netflix.hystrix.strategy.eventnotifier.HystrixEventNotifier;
import com.netflix.hystrix.strategy.executionhook.HystrixCommandExecutionHook;
import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher;
import com.netflix.hystrix.strategy.properties.HystrixPropertiesStrategy;
public class SHCStra extends HystrixConcurrencyStrategy {
private static final String HYSTRIX_COMPONENT = "hystrix";
private static final Log log = LogFactory
.getLog(SHCStra.class);
private final Chainer tracer;
private final ChainKeys traceKeys;
private HystrixConcurrencyStrategy delegate;
public SHCStra(Chainer tracer, ChainKeys traceKeys) {
this.tracer = tracer;
this.traceKeys = traceKeys;
try {
this.delegate = HystrixPlugins.getInstance().getConcurrencyStrategy();
if (this.delegate instanceof SHCStra) {
// Welcome to singleton hell...
return;
}
HystrixCommandExecutionHook commandExecutionHook = HystrixPlugins
.getInstance().getCommandExecutionHook();
HystrixEventNotifier eventNotifier = HystrixPlugins.getInstance()
.getEventNotifier();
HystrixMetricsPublisher metricsPublisher = HystrixPlugins.getInstance()
.getMetricsPublisher();
HystrixPropertiesStrategy propertiesStrategy = HystrixPlugins.getInstance()
.getPropertiesStrategy();
logCurrentStateOfHysrixPlugins(eventNotifier, metricsPublisher,
propertiesStrategy);
HystrixPlugins.reset();
HystrixPlugins.getInstance().registerConcurrencyStrategy(this);
HystrixPlugins.getInstance()
.registerCommandExecutionHook(commandExecutionHook);
HystrixPlugins.getInstance().registerEventNotifier(eventNotifier);
HystrixPlugins.getInstance().registerMetricsPublisher(metricsPublisher);
HystrixPlugins.getInstance().registerPropertiesStrategy(propertiesStrategy);
}
catch (Exception e) {
log.error("Failed to register Sleuth Hystrix Concurrency Strategy", e);
}
}
private void logCurrentStateOfHysrixPlugins(HystrixEventNotifier eventNotifier,
HystrixMetricsPublisher metricsPublisher,
HystrixPropertiesStrategy propertiesStrategy) {
if (log.isDebugEnabled()) {
log.debug("Current Hystrix plugins configuration is [" + "concurrencyStrategy ["
+ this.delegate + "]," + "eventNotifier [" + eventNotifier + "],"
+ "metricPublisher [" + metricsPublisher + "]," + "propertiesStrategy ["
+ propertiesStrategy + "]," + "]");
log.debug("Registering Sleuth Hystrix Concurrency Strategy.");
}
}
@Override
public <T> Callable<T> wrapCallable(Callable<T> callable) {
if (callable instanceof HystrixTraceCallable) {
return callable;
}
Callable<T> wrappedCallable = this.delegate != null
? this.delegate.wrapCallable(callable) : callable;
if (wrappedCallable instanceof HystrixTraceCallable) {
return wrappedCallable;
}
return new HystrixTraceCallable<>(this.tracer, this.traceKeys, wrappedCallable);
}
// Visible for testing
static class HystrixTraceCallable<S> implements Callable<S> {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private Chainer tracer;
private ChainKeys traceKeys;
private Callable<S> callable;
private Item parent;
public HystrixTraceCallable(Chainer tracer, ChainKeys traceKeys,
Callable<S> callable) {
this.tracer = tracer;
this.traceKeys = traceKeys;
this.callable = callable;
this.parent = tracer.getCurrentSpan();
}
@Override
public S call() throws Exception {
Item span = this.parent;
boolean created = false;
if (span != null) {
span = this.tracer.continueSpan(span);
if (log.isDebugEnabled()) {
log.debug("Continuing span " + span);
}
}
else {
span = this.tracer.createSpan(HYSTRIX_COMPONENT);
created = true;
if (log.isDebugEnabled()) {
log.debug("Creating new span " + span);
}
}
if (!span.tags().containsKey(Item.SPAN_LOCAL_COMPONENT_TAG_NAME)) {
this.tracer.addTag(Item.SPAN_LOCAL_COMPONENT_TAG_NAME, HYSTRIX_COMPONENT);
}
String asyncKey = this.traceKeys.getAsync().getPrefix()
+ this.traceKeys.getAsync().getThreadNameKey();
if (!span.tags().containsKey(asyncKey)) {
this.tracer.addTag(asyncKey, Thread.currentThread().getName());
}
try {
return this.callable.call();
}
finally {
if (created) {
if (log.isDebugEnabled()) {
log.debug("Closing span since it was created" + span);
}
this.tracer.close(span);
}
else if(this.tracer.isTracing()) {
if (log.isDebugEnabled()) {
log.debug("Detaching span since it was continued " + span);
}
this.tracer.detach(span);
}
}
}
}
}
| 5,136 | 32.575163 | 89 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/rest/TComm.java
|
package org.myproject.ms.monitoring.instrument.rest;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.ChainKeys;
import com.netflix.hystrix.HystrixCommand;
public abstract class TComm<R> extends HystrixCommand<R> {
private static final String HYSTRIX_COMPONENT = "hystrix";
private final Chainer tracer;
private final ChainKeys traceKeys;
private final Item parentSpan;
protected TComm(Chainer tracer, ChainKeys traceKeys, Setter setter) {
super(setter);
this.tracer = tracer;
this.traceKeys = traceKeys;
this.parentSpan = tracer.getCurrentSpan();
}
@Override
protected R run() throws Exception {
String commandKeyName = getCommandKey().name();
Item span = startSpan(commandKeyName);
this.tracer.addTag(Item.SPAN_LOCAL_COMPONENT_TAG_NAME, HYSTRIX_COMPONENT);
this.tracer.addTag(this.traceKeys.getHystrix().getPrefix() +
this.traceKeys.getHystrix().getCommandKey(), commandKeyName);
this.tracer.addTag(this.traceKeys.getHystrix().getPrefix() +
this.traceKeys.getHystrix().getCommandGroup(), getCommandGroup().name());
this.tracer.addTag(this.traceKeys.getHystrix().getPrefix() +
this.traceKeys.getHystrix().getThreadPoolKey(), getThreadPoolKey().name());
try {
return doRun();
}
finally {
close(span);
}
}
private Item startSpan(String commandKeyName) {
Item span = this.parentSpan;
if (span == null) {
return this.tracer.createSpan(commandKeyName, this.parentSpan);
}
return this.tracer.continueSpan(span);
}
private void close(Item span) {
if (this.parentSpan == null) {
this.tracer.close(span);
} else {
this.tracer.detach(span);
}
}
public abstract R doRun() throws Exception;
}
| 1,749 | 26.34375 | 79 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/schedl/SSProp.java
|
package org.myproject.ms.monitoring.instrument.schedl;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties("spring.sleuth.scheduled")
public class SSProp {
private boolean enabled = true;
private String skipPattern = "";
public boolean isEnabled() {
return this.enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public String getSkipPattern() {
return this.skipPattern;
}
public void setSkipPattern(String skipPattern) {
this.skipPattern = skipPattern;
}
}
| 566 | 17.290323 | 75 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/schedl/TSAConf.java
|
package org.myproject.ms.monitoring.instrument.schedl;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.atcfg.TraceAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import java.util.regex.Pattern;
@Configuration
@EnableAspectJAutoProxy
@ConditionalOnProperty(value = "spring.sleuth.scheduled.enabled", matchIfMissing = true)
@ConditionalOnBean(Chainer.class)
@AutoConfigureAfter(TraceAutoConfiguration.class)
@EnableConfigurationProperties(SSProp.class)
public class TSAConf {
@ConditionalOnClass(name = "org.aspectj.lang.ProceedingJoinPoint")
@Bean
public TSAspect traceSchedulingAspect(Chainer tracer, ChainKeys traceKeys,
SSProp sleuthSchedulingProperties) {
return new TSAspect(tracer, traceKeys, Pattern.compile(sleuthSchedulingProperties.getSkipPattern()));
}
}
| 1,390 | 38.742857 | 103 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/schedl/TSAspect.java
|
package org.myproject.ms.monitoring.instrument.schedl;
import java.util.regex.Pattern;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.util.ItemNameUtil;
@Aspect
public class TSAspect {
private static final String SCHEDULED_COMPONENT = "scheduled";
private final Chainer tracer;
private final ChainKeys traceKeys;
private final Pattern skipPattern;
public TSAspect(Chainer tracer, ChainKeys traceKeys, Pattern skipPattern) {
this.tracer = tracer;
this.traceKeys = traceKeys;
this.skipPattern = skipPattern;
}
@Around("execution (@org.springframework.scheduling.annotation.Scheduled * *.*(..))")
public Object traceBackgroundThread(final ProceedingJoinPoint pjp) throws Throwable {
if (this.skipPattern.matcher(pjp.getTarget().getClass().getName()).matches()) {
return pjp.proceed();
}
String spanName = ItemNameUtil.toLowerHyphen(pjp.getSignature().getName());
Item span = this.tracer.createSpan(spanName);
this.tracer.addTag(Item.SPAN_LOCAL_COMPONENT_TAG_NAME, SCHEDULED_COMPONENT);
this.tracer.addTag(this.traceKeys.getAsync().getPrefix() +
this.traceKeys.getAsync().getClassNameKey(), pjp.getTarget().getClass().getSimpleName());
this.tracer.addTag(this.traceKeys.getAsync().getPrefix() +
this.traceKeys.getAsync().getMethodNameKey(), pjp.getSignature().getName());
try {
return pjp.proceed();
}
finally {
this.tracer.close(span);
}
}
}
| 1,655 | 30.846154 | 93 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/HSExtra.java
|
package org.myproject.ms.monitoring.instrument.web;
import org.myproject.ms.monitoring.ItemExtractor;
import org.myproject.ms.monitoring.ItemTextMap;
public interface HSExtra extends ItemExtractor<ItemTextMap> {
}
| 217 | 23.222222 | 61 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/HSInject.java
|
package org.myproject.ms.monitoring.instrument.web;
import org.myproject.ms.monitoring.ItemInjector;
import org.myproject.ms.monitoring.ItemTextMap;
public interface HSInject extends ItemInjector<ItemTextMap> {
}
| 216 | 23.111111 | 61 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/HSRTMap.java
|
package org.myproject.ms.monitoring.instrument.web;
import javax.servlet.http.HttpServletRequest;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.myproject.ms.monitoring.ItemTextMap;
import org.springframework.web.util.UrlPathHelper;
class HSRTMap implements ItemTextMap {
private final HttpServletRequest delegate;
private final Map<String, String> additionalHeaders = new HashMap<>();
HSRTMap(HttpServletRequest delegate) {
this.delegate = delegate;
UrlPathHelper urlPathHelper = new UrlPathHelper();
this.additionalHeaders.put(ZHSExtra.URI_HEADER,
urlPathHelper.getPathWithinApplication(delegate));
}
@Override
public Iterator<Map.Entry<String, String>> iterator() {
Map<String, String> map = new HashMap<>();
Enumeration<String> headerNames = this.delegate.getHeaderNames();
while (headerNames != null && headerNames.hasMoreElements()) {
String name = headerNames.nextElement();
map.put(name, this.delegate.getHeader(name));
}
map.putAll(this.additionalHeaders);
return map.entrySet().iterator();
}
@Override
public void put(String key, String value) {
this.additionalHeaders.put(key, value);
}
}
| 1,219 | 26.727273 | 71 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/HTKInject.java
|
package org.myproject.ms.monitoring.instrument.web;
import java.net.URI;
import java.util.Collection;
import java.util.Map;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.springframework.util.StringUtils;
public class HTKInject {
private final Chainer tracer;
private final ChainKeys traceKeys;
public HTKInject(Chainer tracer, ChainKeys traceKeys) {
this.tracer = tracer;
this.traceKeys = traceKeys;
}
public void addRequestTags(String url, String host, String path, String method) {
this.tracer.addTag(this.traceKeys.getHttp().getUrl(), url);
this.tracer.addTag(this.traceKeys.getHttp().getHost(), host);
this.tracer.addTag(this.traceKeys.getHttp().getPath(), path);
this.tracer.addTag(this.traceKeys.getHttp().getMethod(), method);
}
public void addRequestTags(Item span, String url, String host, String path, String method) {
tagSpan(span, this.traceKeys.getHttp().getUrl(), url);
tagSpan(span, this.traceKeys.getHttp().getHost(), host);
tagSpan(span, this.traceKeys.getHttp().getPath(), path);
tagSpan(span, this.traceKeys.getHttp().getMethod(), method);
}
public void addRequestTags(Item span, URI uri, String method) {
addRequestTags(span, uri.toString(), uri.getHost(), uri.getPath(), method);
}
public void addRequestTags(String url, String host, String path, String method,
Map<String, ? extends Collection<String>> headers) {
addRequestTags(url, host, path, method);
addRequestTagsFromHeaders(headers);
}
public void tagSpan(Item span, String key, String value) {
if (span != null && span.isExportable()) {
span.tag(key, value);
}
}
private void addRequestTagsFromHeaders(Map<String, ? extends Collection<String>> headers) {
for (String name : this.traceKeys.getHttp().getHeaders()) {
for (Map.Entry<String, ? extends Collection<String>> entry : headers.entrySet()) {
addTagForEntry(name, entry.getValue());
}
}
}
private void addTagForEntry(String name, Collection<String> list) {
String key = this.traceKeys.getHttp().getPrefix() + name.toLowerCase();
String value = list.size() == 1 ? list.iterator().next()
: StringUtils.collectionToDelimitedString(list, ",", "'", "'");
this.tracer.addTag(key, value);
}
}
| 2,319 | 30.351351 | 93 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/SWProp.java
|
package org.myproject.ms.monitoring.instrument.web;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.NestedConfigurationProperty;
@ConfigurationProperties("spring.sleuth.web")
public class SWProp {
public static final String DEFAULT_SKIP_PATTERN =
"/api-docs.*|/autoconfig|/configprops|/dump|/health|/info|/metrics.*|/mappings|/trace|/swagger.*|.*\\.png|.*\\.css|.*\\.js|.*\\.html|/favicon.ico|/hystrix.stream";
private boolean enabled = true;
private String skipPattern = DEFAULT_SKIP_PATTERN;
private Client client;
public boolean isEnabled() {
return this.enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public String getSkipPattern() {
return this.skipPattern;
}
public void setSkipPattern(String skipPattern) {
this.skipPattern = skipPattern;
}
public Client getClient() {
return this.client;
}
public void setClient(Client client) {
this.client = client;
}
public static class Client {
private boolean enabled = true;
public boolean isEnabled() {
return this.enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
}
public static class Async {
@NestedConfigurationProperty
private AsyncClient client;
public AsyncClient getClient() {
return this.client;
}
public void setClient(AsyncClient client) {
this.client = client;
}
}
public static class AsyncClient {
private boolean enabled;
@NestedConfigurationProperty
private Template template;
public boolean isEnabled() {
return this.enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public Template getTemplate() {
return this.template;
}
public void setTemplate(Template template) {
this.template = template;
}
}
public static class Template {
private boolean enabled;
public boolean isEnabled() {
return this.enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
}
}
| 2,079 | 17.571429 | 166 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/ServletUtils.java
|
package org.myproject.ms.monitoring.instrument.web;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
class ServletUtils {
static String getHeader(HttpServletRequest request, HttpServletResponse response,
String name) {
String value = request.getHeader(name);
return value != null ? value : response.getHeader(name);
}
}
| 380 | 20.166667 | 82 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/SsLogSetter.java
|
package org.myproject.ms.monitoring.instrument.web;
import java.lang.invoke.MethodHandles;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.myproject.ms.monitoring.Item;
class SsLogSetter {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
static void annotateWithServerSendIfLogIsNotAlreadyPresent(Item span) {
if (span == null) {
return;
}
for (org.myproject.ms.monitoring.Log log1 : span.logs()) {
if (Item.SERVER_SEND.equals(log1.getEvent())) {
if (log.isTraceEnabled()) {
log.trace("Span was already annotated with SS, will not do it again");
}
return;
}
}
if (log.isTraceEnabled()) {
log.trace("Will set SS on the span");
}
span.logEvent(Item.SERVER_SEND);
}
}
| 806 | 22.735294 | 88 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/TFilter.java
|
package org.myproject.ms.monitoring.instrument.web;
import java.io.IOException;
import java.lang.invoke.MethodHandles;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.regex.Pattern;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ItemReporter;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.spl.AlwaysSampler;
import org.myproject.ms.monitoring.spl.NeverSampler;
import org.myproject.ms.monitoring.util.ExceptionUtils;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.util.StringUtils;
import org.springframework.web.context.request.async.WebAsyncUtils;
import org.springframework.web.filter.GenericFilterBean;
import org.springframework.web.util.UrlPathHelper;
@Order(TFilter.ORDER)
public class TFilter extends GenericFilterBean {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private static final String HTTP_COMPONENT = "http";
public static final int ORDER = Ordered.HIGHEST_PRECEDENCE + 5;
protected static final String TRACE_REQUEST_ATTR = TFilter.class.getName()
+ ".TRACE";
protected static final String TRACE_ERROR_HANDLED_REQUEST_ATTR = TFilter.class.getName()
+ ".ERROR_HANDLED";
protected static final String TRACE_CLOSE_SPAN_REQUEST_ATTR = TFilter.class.getName()
+ ".CLOSE_SPAN";
@Deprecated
public static final String DEFAULT_SKIP_PATTERN = SWProp.DEFAULT_SKIP_PATTERN;
private final Chainer tracer;
private final ChainKeys traceKeys;
private final Pattern skipPattern;
private final ItemReporter spanReporter;
private final HSExtra spanExtractor;
private final HTKInject httpTraceKeysInjector;
private UrlPathHelper urlPathHelper = new UrlPathHelper();
public TFilter(Chainer tracer, ChainKeys traceKeys, ItemReporter spanReporter,
HSExtra spanExtractor,
HTKInject httpTraceKeysInjector) {
this(tracer, traceKeys, Pattern.compile(SWProp.DEFAULT_SKIP_PATTERN), spanReporter,
spanExtractor, httpTraceKeysInjector);
}
public TFilter(Chainer tracer, ChainKeys traceKeys, Pattern skipPattern,
ItemReporter spanReporter, HSExtra spanExtractor,
HTKInject httpTraceKeysInjector) {
this.tracer = tracer;
this.traceKeys = traceKeys;
this.skipPattern = skipPattern;
this.spanReporter = spanReporter;
this.spanExtractor = spanExtractor;
this.httpTraceKeysInjector = httpTraceKeysInjector;
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
FilterChain filterChain) throws IOException, ServletException {
if (!(servletRequest instanceof HttpServletRequest) || !(servletResponse instanceof HttpServletResponse)) {
throw new ServletException("Filter just supports HTTP requests");
}
HttpServletRequest request = (HttpServletRequest) servletRequest;
HttpServletResponse response = (HttpServletResponse) servletResponse;
String uri = this.urlPathHelper.getPathWithinApplication(request);
boolean skip = this.skipPattern.matcher(uri).matches()
|| Item.SPAN_NOT_SAMPLED.equals(ServletUtils.getHeader(request, response, Item.SAMPLED_NAME));
Item spanFromRequest = getSpanFromAttribute(request);
if (spanFromRequest != null) {
continueSpan(request, spanFromRequest);
}
if (log.isDebugEnabled()) {
log.debug("Received a request to uri [" + uri + "] that should not be sampled [" + skip + "]");
}
// in case of a response with exception status a exception controller will close the span
if (!httpStatusSuccessful(response) && isSpanContinued(request)) {
Item parentSpan = parentSpan(spanFromRequest);
processErrorRequest(filterChain, request, new THSResp(response, parentSpan), spanFromRequest);
return;
}
String name = HTTP_COMPONENT + ":" + uri;
Throwable exception = null;
try {
spanFromRequest = createSpan(request, skip, spanFromRequest, name);
filterChain.doFilter(request, new THSResp(response, spanFromRequest));
} catch (Throwable e) {
exception = e;
this.tracer.addTag(Item.SPAN_ERROR_TAG_NAME, ExceptionUtils.getExceptionMessage(e));
throw e;
} finally {
if (isAsyncStarted(request) || request.isAsyncStarted()) {
if (log.isDebugEnabled()) {
log.debug("The span " + spanFromRequest + " will get detached by a HandleInterceptor");
}
// TODO: how to deal with response annotations and async?
return;
}
spanFromRequest = createSpanIfRequestNotHandled(request, spanFromRequest, name, skip);
detachOrCloseSpans(request, response, spanFromRequest, exception);
}
}
private Item parentSpan(Item span) {
if (span == null) {
return null;
}
if (span.hasSavedSpan()) {
return span.getSavedSpan();
}
return span;
}
private void processErrorRequest(FilterChain filterChain, HttpServletRequest request,
HttpServletResponse response, Item spanFromRequest)
throws IOException, ServletException {
if (log.isDebugEnabled()) {
log.debug("The span " + spanFromRequest + " was already detached once and we're processing an error");
}
try {
filterChain.doFilter(request, response);
} finally {
request.setAttribute(TRACE_ERROR_HANDLED_REQUEST_ATTR, true);
addResponseTags(response, null);
if (request.getAttribute(TRAttr.ERROR_HANDLED_SPAN_REQUEST_ATTR) == null) {
this.tracer.close(spanFromRequest);
}
}
}
private void continueSpan(HttpServletRequest request, Item spanFromRequest) {
this.tracer.continueSpan(spanFromRequest);
request.setAttribute(TRAttr.SPAN_CONTINUED_REQUEST_ATTR, "true");
if (log.isDebugEnabled()) {
log.debug("There has already been a span in the request " + spanFromRequest);
}
}
// This method is a fallback in case if handler interceptors didn't catch the request.
// In that case we are creating an artificial span so that it can be visible in Zipkin.
private Item createSpanIfRequestNotHandled(HttpServletRequest request,
Item spanFromRequest, String name, boolean skip) {
if (!requestHasAlreadyBeenHandled(request)) {
spanFromRequest = this.tracer.createSpan(name);
request.setAttribute(TRACE_REQUEST_ATTR, spanFromRequest);
if (log.isDebugEnabled() && !skip) {
log.debug("The request with uri [" + request.getRequestURI() + "] hasn't been handled by any of Sleuth's components. "
+ "That means that most likely you're using custom HandlerMappings and didn't add Sleuth's TraceHandlerInterceptor. "
+ "Sleuth will create a span to ensure that the graph of calls remains valid in Zipkin");
}
}
return spanFromRequest;
}
private boolean requestHasAlreadyBeenHandled(HttpServletRequest request) {
return request.getAttribute(TRAttr.HANDLED_SPAN_REQUEST_ATTR) != null;
}
private void detachOrCloseSpans(HttpServletRequest request,
HttpServletResponse response, Item spanFromRequest, Throwable exception) {
Item span = spanFromRequest;
if (span != null) {
addResponseTags(response, exception);
if (span.hasSavedSpan() && requestHasAlreadyBeenHandled(request)) {
recordParentSpan(span.getSavedSpan());
} else if (!requestHasAlreadyBeenHandled(request)) {
span = this.tracer.close(span);
}
recordParentSpan(span);
// in case of a response with exception status will close the span when exception dispatch is handled
// checking if tracing is in progress due to async / different order of view controller processing
if (httpStatusSuccessful(response) && this.tracer.isTracing()) {
if (log.isDebugEnabled()) {
log.debug("Closing the span " + span + " since the response was successful");
}
this.tracer.close(span);
} else if (errorAlreadyHandled(request) && this.tracer.isTracing()) {
if (log.isDebugEnabled()) {
log.debug(
"Won't detach the span " + span + " since error has already been handled");
}
} else if (shouldCloseSpan(request) && this.tracer.isTracing() && stillTracingCurrentSapn(span)) {
if (log.isDebugEnabled()) {
log.debug(
"Will close span " + span + " since some component marked it for closure");
}
this.tracer.close(span);
} else if (this.tracer.isTracing()) {
if (log.isDebugEnabled()) {
log.debug("Detaching the span " + span + " since the response was unsuccessful");
}
this.tracer.detach(span);
}
}
}
private boolean stillTracingCurrentSapn(Item span) {
return this.tracer.getCurrentSpan().equals(span);
}
private void recordParentSpan(Item parent) {
if (parent == null) {
return;
}
if (parent.isRemote()) {
if (log.isDebugEnabled()) {
log.debug("Trying to send the parent span " + parent + " to Zipkin");
}
parent.stop();
// should be already done by HttpServletResponse wrappers
SsLogSetter.annotateWithServerSendIfLogIsNotAlreadyPresent(parent);
this.spanReporter.report(parent);
} else {
// should be already done by HttpServletResponse wrappers
SsLogSetter.annotateWithServerSendIfLogIsNotAlreadyPresent(parent);
}
}
private boolean httpStatusSuccessful(HttpServletResponse response) {
if (response.getStatus() == 0) {
return false;
}
HttpStatus.Series httpStatusSeries = HttpStatus.Series.valueOf(response.getStatus());
return httpStatusSeries == HttpStatus.Series.SUCCESSFUL || httpStatusSeries == HttpStatus.Series.REDIRECTION;
}
private Item getSpanFromAttribute(HttpServletRequest request) {
return (Item) request.getAttribute(TRACE_REQUEST_ATTR);
}
private boolean errorAlreadyHandled(HttpServletRequest request) {
return Boolean.valueOf(
String.valueOf(request.getAttribute(TRACE_ERROR_HANDLED_REQUEST_ATTR)));
}
private boolean shouldCloseSpan(HttpServletRequest request) {
return Boolean.valueOf(
String.valueOf(request.getAttribute(TRACE_CLOSE_SPAN_REQUEST_ATTR)));
}
private boolean isSpanContinued(HttpServletRequest request) {
return getSpanFromAttribute(request) != null;
}
private void addRequestTagsForParentSpan(HttpServletRequest request, Item spanFromRequest) {
if (spanFromRequest.getName().contains("parent")) {
addRequestTags(spanFromRequest, request);
}
}
private Item createSpan(HttpServletRequest request,
boolean skip, Item spanFromRequest, String name) {
if (spanFromRequest != null) {
if (log.isDebugEnabled()) {
log.debug("Span has already been created - continuing with the previous one");
}
return spanFromRequest;
}
Item parent = this.spanExtractor.joinTrace(new HSRTMap(request));
if (parent != null) {
if (log.isDebugEnabled()) {
log.debug("Found a parent span " + parent + " in the request");
}
addRequestTagsForParentSpan(request, parent);
spanFromRequest = parent;
this.tracer.continueSpan(spanFromRequest);
if (parent.isRemote()) {
parent.logEvent(Item.SERVER_RECV);
}
request.setAttribute(TRACE_REQUEST_ATTR, spanFromRequest);
if (log.isDebugEnabled()) {
log.debug("Parent span is " + parent + "");
}
} else {
if (skip) {
spanFromRequest = this.tracer.createSpan(name, NeverSampler.INSTANCE);
}
else {
String header = request.getHeader(Item.SPAN_FLAGS);
if (Item.SPAN_SAMPLED.equals(header)) {
spanFromRequest = this.tracer.createSpan(name, new AlwaysSampler());
} else {
spanFromRequest = this.tracer.createSpan(name);
}
}
spanFromRequest.logEvent(Item.SERVER_RECV);
request.setAttribute(TRACE_REQUEST_ATTR, spanFromRequest);
if (log.isDebugEnabled()) {
log.debug("No parent span present - creating a new span");
}
}
return spanFromRequest;
}
protected void addRequestTags(Item span, HttpServletRequest request) {
String uri = this.urlPathHelper.getPathWithinApplication(request);
this.httpTraceKeysInjector.addRequestTags(span, getFullUrl(request),
request.getServerName(), uri, request.getMethod());
for (String name : this.traceKeys.getHttp().getHeaders()) {
Enumeration<String> values = request.getHeaders(name);
if (values.hasMoreElements()) {
String key = this.traceKeys.getHttp().getPrefix() + name.toLowerCase();
ArrayList<String> list = Collections.list(values);
String value = list.size() == 1 ? list.get(0)
: StringUtils.collectionToDelimitedString(list, ",", "'", "'");
this.httpTraceKeysInjector.tagSpan(span, key, value);
}
}
}
protected void addResponseTags(HttpServletResponse response, Throwable e) {
int httpStatus = response.getStatus();
if (httpStatus == HttpServletResponse.SC_OK && e != null) {
// Filter chain threw exception but the response status may not have been set
// yet, so we have to guess.
this.tracer.addTag(this.traceKeys.getHttp().getStatusCode(),
String.valueOf(HttpServletResponse.SC_INTERNAL_SERVER_ERROR));
}
// only tag valid http statuses
else if (httpStatus >= 100 && (httpStatus < 200) || (httpStatus > 399)) {
this.tracer.addTag(this.traceKeys.getHttp().getStatusCode(),
String.valueOf(response.getStatus()));
}
}
protected boolean isAsyncStarted(HttpServletRequest request) {
return WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted();
}
private String getFullUrl(HttpServletRequest request) {
StringBuffer requestURI = request.getRequestURL();
String queryString = request.getQueryString();
if (queryString == null) {
return requestURI.toString();
} else {
return requestURI.append('?').append(queryString).toString();
}
}
}
| 13,852 | 36.239247 | 123 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/THAConf.java
|
package org.myproject.ms.monitoring.instrument.web;
import java.util.regex.Pattern;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.atcfg.TraceAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@ConditionalOnBean(Chainer.class)
@AutoConfigureAfter(TraceAutoConfiguration.class)
@EnableConfigurationProperties({ ChainKeys.class, SWProp.class })
public class THAConf {
@Bean
@ConditionalOnMissingBean
public HTKInject httpTraceKeysInjector(Chainer tracer, ChainKeys traceKeys) {
return new HTKInject(tracer, traceKeys);
}
@Bean
@ConditionalOnMissingBean
public HSExtra httpSpanExtractor(SWProp sleuthWebProperties) {
return new ZHSExtra(Pattern.compile(sleuthWebProperties.getSkipPattern()));
}
@Bean
@ConditionalOnMissingBean
public HSInject httpSpanInjector() {
return new ZHSInject();
}
}
| 1,294 | 30.585366 | 81 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/THInter.java
|
package org.myproject.ms.monitoring.instrument.web;
import java.lang.invoke.MethodHandles;
import java.util.concurrent.atomic.AtomicReference;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.boot.autoconfigure.web.ErrorController;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.util.ExceptionUtils;
import org.myproject.ms.monitoring.util.ItemNameUtil;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
public class THInter extends HandlerInterceptorAdapter {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private final BeanFactory beanFactory;
private Chainer tracer;
private ChainKeys traceKeys;
private AtomicReference<ErrorController> errorController;
public THInter(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object handler) throws Exception {
String spanName = spanName(handler);
boolean continueSpan = getRootSpanFromAttribute(request) != null;
Item span = continueSpan ? getRootSpanFromAttribute(request) : getTracer().createSpan(spanName);
if (log.isDebugEnabled()) {
log.debug("Handling span " + span);
}
addClassMethodTag(handler, span);
addClassNameTag(handler, span);
setSpanInAttribute(request, span);
if (!continueSpan) {
setNewSpanCreatedAttribute(request, span);
}
return true;
}
private boolean isErrorControllerRelated(HttpServletRequest request) {
return getErrorController() != null && getErrorController().getErrorPath()
.equals(request.getRequestURI());
}
private void addClassMethodTag(Object handler, Item span) {
if (handler instanceof HandlerMethod) {
String methodName = ((HandlerMethod) handler).getMethod().getName();
getTracer().addTag(getTraceKeys().getMvc().getControllerMethod(), methodName);
if (log.isDebugEnabled()) {
log.debug("Adding a method tag with value [" + methodName + "] to a span " + span);
}
}
}
private void addClassNameTag(Object handler, Item span) {
String className;
if (handler instanceof HandlerMethod) {
className = ((HandlerMethod) handler).getBeanType().getSimpleName();
} else {
className = handler.getClass().getSimpleName();
}
if (log.isDebugEnabled()) {
log.debug("Adding a class tag with value [" + className + "] to a span " + span);
}
getTracer().addTag(getTraceKeys().getMvc().getControllerClass(), className);
}
private String spanName(Object handler) {
if (handler instanceof HandlerMethod) {
return ItemNameUtil.toLowerHyphen(((HandlerMethod) handler).getMethod().getName());
}
return ItemNameUtil.toLowerHyphen(handler.getClass().getSimpleName());
}
@Override
public void afterConcurrentHandlingStarted(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {
Item spanFromRequest = getNewSpanFromAttribute(request);
Item rootSpanFromRequest = getRootSpanFromAttribute(request);
if (log.isDebugEnabled()) {
log.debug("Closing the span " + spanFromRequest + " and detaching its parent " + rootSpanFromRequest + " since the request is asynchronous");
}
getTracer().close(spanFromRequest);
getTracer().detach(rootSpanFromRequest);
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) throws Exception {
if (isErrorControllerRelated(request)) {
if (log.isDebugEnabled()) {
log.debug("Skipping closing of a span for error controller processing");
}
return;
}
Item span = getRootSpanFromAttribute(request);
if (ex != null) {
String errorMsg = ExceptionUtils.getExceptionMessage(ex);
if (log.isDebugEnabled()) {
log.debug("Adding an error tag [" + errorMsg + "] to span " + span + "");
}
getTracer().addTag(Item.SPAN_ERROR_TAG_NAME, errorMsg);
}
if (getNewSpanFromAttribute(request) != null) {
if (log.isDebugEnabled()) {
log.debug("Closing span " + span);
}
Item newSpan = getNewSpanFromAttribute(request);
getTracer().continueSpan(newSpan);
getTracer().close(newSpan);
clearNewSpanCreatedAttribute(request);
}
}
private Item getNewSpanFromAttribute(HttpServletRequest request) {
return (Item) request.getAttribute(TRAttr.NEW_SPAN_REQUEST_ATTR);
}
private Item getRootSpanFromAttribute(HttpServletRequest request) {
return (Item) request.getAttribute(TFilter.TRACE_REQUEST_ATTR);
}
private void setSpanInAttribute(HttpServletRequest request, Item span) {
request.setAttribute(TRAttr.HANDLED_SPAN_REQUEST_ATTR, span);
}
private void setNewSpanCreatedAttribute(HttpServletRequest request, Item span) {
request.setAttribute(TRAttr.NEW_SPAN_REQUEST_ATTR, span);
}
private void clearNewSpanCreatedAttribute(HttpServletRequest request) {
request.removeAttribute(TRAttr.NEW_SPAN_REQUEST_ATTR);
}
private Chainer getTracer() {
if (this.tracer == null) {
this.tracer = this.beanFactory.getBean(Chainer.class);
}
return this.tracer;
}
private ChainKeys getTraceKeys() {
if (this.traceKeys == null) {
this.traceKeys = this.beanFactory.getBean(ChainKeys.class);
}
return this.traceKeys;
}
ErrorController getErrorController() {
if (this.errorController == null) {
try {
ErrorController errorController = this.beanFactory.getBean(ErrorController.class);
this.errorController = new AtomicReference<>(errorController);
} catch (NoSuchBeanDefinitionException e) {
if (log.isTraceEnabled()) {
log.trace("ErrorController bean not found");
}
this.errorController = new AtomicReference<>();
}
}
return this.errorController.get();
}
}
| 6,133 | 32.889503 | 144 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/THSResp.java
|
package org.myproject.ms.monitoring.instrument.web;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.invoke.MethodHandles;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.myproject.ms.monitoring.Item;
class THSResp extends HttpServletResponseWrapper {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private final Item span;
THSResp(HttpServletResponse response, Item span) {
super(response);
this.span = span;
}
@Override public void flushBuffer() throws IOException {
if (log.isTraceEnabled()) {
log.trace("Will annotate SS once the response is flushed");
}
SsLogSetter.annotateWithServerSendIfLogIsNotAlreadyPresent(this.span);
super.flushBuffer();
}
@Override public ServletOutputStream getOutputStream() throws IOException {
return new TSOStr(super.getOutputStream(), this.span);
}
@Override public PrintWriter getWriter() throws IOException {
return new TPWriter(super.getWriter(), this.span);
}
}
| 1,200 | 26.295455 | 88 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/TPWriter.java
|
package org.myproject.ms.monitoring.instrument.web;
import java.io.PrintWriter;
import java.lang.invoke.MethodHandles;
import java.util.Locale;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.myproject.ms.monitoring.Item;
class TPWriter extends PrintWriter {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private final PrintWriter delegate;
private final Item span;
TPWriter(PrintWriter delegate, Item span) {
super(delegate);
this.delegate = delegate;
this.span = span;
}
@Override public void flush() {
if (log.isTraceEnabled()) {
log.trace("Will annotate SS once the response is flushed");
}
SsLogSetter.annotateWithServerSendIfLogIsNotAlreadyPresent(this.span);
this.delegate.flush();
}
@Override public void close() {
if (log.isTraceEnabled()) {
log.trace("Will annotate SS once the stream is closed");
}
SsLogSetter.annotateWithServerSendIfLogIsNotAlreadyPresent(this.span);
this.delegate.close();
}
@Override public boolean checkError() {
return this.delegate.checkError();
}
@Override public void write(int c) {
this.delegate.write(c);
}
@Override public void write(char[] buf, int off, int len) {
this.delegate.write(buf, off, len);
}
@Override public void write(char[] buf) {
this.delegate.write(buf);
}
@Override public void write(String s, int off, int len) {
this.delegate.write(s, off, len);
}
@Override public void write(String s) {
this.delegate.write(s);
}
@Override public void print(boolean b) {
this.delegate.print(b);
}
@Override public void print(char c) {
this.delegate.print(c);
}
@Override public void print(int i) {
this.delegate.print(i);
}
@Override public void print(long l) {
this.delegate.print(l);
}
@Override public void print(float f) {
this.delegate.print(f);
}
@Override public void print(double d) {
this.delegate.print(d);
}
@Override public void print(char[] s) {
this.delegate.print(s);
}
@Override public void print(String s) {
this.delegate.print(s);
}
@Override public void print(Object obj) {
this.delegate.print(obj);
}
@Override public void println() {
this.delegate.println();
}
@Override public void println(boolean x) {
this.delegate.println(x);
}
@Override public void println(char x) {
this.delegate.println(x);
}
@Override public void println(int x) {
this.delegate.println(x);
}
@Override public void println(long x) {
this.delegate.println(x);
}
@Override public void println(float x) {
this.delegate.println(x);
}
@Override public void println(double x) {
this.delegate.println(x);
}
@Override public void println(char[] x) {
this.delegate.println(x);
}
@Override public void println(String x) {
this.delegate.println(x);
}
@Override public void println(Object x) {
this.delegate.println(x);
}
@Override public PrintWriter printf(String format, Object... args) {
return this.delegate.printf(format, args);
}
@Override public PrintWriter printf(Locale l, String format, Object... args) {
return this.delegate.printf(l, format, args);
}
@Override public PrintWriter format(String format, Object... args) {
return this.delegate.format(format, args);
}
@Override public PrintWriter format(Locale l, String format, Object... args) {
return this.delegate.format(l, format, args);
}
@Override public PrintWriter append(CharSequence csq) {
return this.delegate.append(csq);
}
@Override public PrintWriter append(CharSequence csq, int start, int end) {
return this.delegate.append(csq, start, end);
}
@Override public PrintWriter append(char c) {
return this.delegate.append(c);
}
}
| 3,727 | 20.80117 | 88 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/TRAttr.java
|
package org.myproject.ms.monitoring.instrument.web;
public final class TRAttr {
public static final String HANDLED_SPAN_REQUEST_ATTR = TRAttr.class.getName()
+ ".TRACE_HANDLED";
public static final String ERROR_HANDLED_SPAN_REQUEST_ATTR = TRAttr.class.getName()
+ ".ERROR_TRACE_HANDLED";
public static final String NEW_SPAN_REQUEST_ATTR = TRAttr.class.getName()
+ ".TRACE_HANDLED_NEW_SPAN";
public static final String SPAN_CONTINUED_REQUEST_ATTR = TRAttr.class.getName()
+ ".TRACE_CONTINUED";
private TRAttr() {}
}
| 551 | 20.230769 | 84 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/TSDBPProcess.java
|
package org.myproject.ms.monitoring.instrument.web;
import javax.servlet.http.HttpServletRequest;
import java.lang.invoke.MethodHandles;
import java.util.Collections;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.data.rest.webmvc.support.DelegatingHandlerMapping;
import org.springframework.web.servlet.HandlerExecutionChain;
import org.springframework.web.servlet.HandlerMapping;
class TSDBPProcess implements BeanPostProcessor {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private final BeanFactory beanFactory;
public TSDBPProcess(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
if (bean instanceof DelegatingHandlerMapping && !(bean instanceof TraceDelegatingHandlerMapping)) {
if (log.isDebugEnabled()) {
log.debug("Wrapping bean [" + beanName + "] of type [" + bean.getClass().getSimpleName() +
"] in its trace representation");
}
return new TraceDelegatingHandlerMapping((DelegatingHandlerMapping) bean,
this.beanFactory);
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
return bean;
}
private static class TraceDelegatingHandlerMapping extends DelegatingHandlerMapping {
private final DelegatingHandlerMapping delegate;
private final BeanFactory beanFactory;
public TraceDelegatingHandlerMapping(DelegatingHandlerMapping delegate,
BeanFactory beanFactory) {
super(Collections.<HandlerMapping>emptyList());
this.delegate = delegate;
this.beanFactory = beanFactory;
}
@Override
public int getOrder() {
return this.delegate.getOrder();
}
@Override
public HandlerExecutionChain getHandler(HttpServletRequest request)
throws Exception {
HandlerExecutionChain handlerExecutionChain = this.delegate.getHandler(request);
if (handlerExecutionChain == null) {
return null;
}
handlerExecutionChain.addInterceptor(new THInter(this.beanFactory));
return handlerExecutionChain;
}
}
}
| 2,386 | 29.602564 | 101 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/TSOStr.java
|
package org.myproject.ms.monitoring.instrument.web;
import java.io.IOException;
import java.lang.invoke.MethodHandles;
import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.myproject.ms.monitoring.Item;
class TSOStr extends ServletOutputStream {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private final ServletOutputStream delegate;
private final Item span;
TSOStr(ServletOutputStream delegate, Item span) {
this.delegate = delegate;
this.span = span;
}
@Override public boolean isReady() {
return this.delegate.isReady();
}
@Override public void setWriteListener(WriteListener listener) {
this.delegate.setWriteListener(listener);
}
@Override public void write(int b) throws IOException {
this.delegate.write(b);
}
@Override public void print(String s) throws IOException {
this.delegate.print(s);
}
@Override public void print(boolean b) throws IOException {
this.delegate.print(b);
}
@Override public void print(char c) throws IOException {
this.delegate.print(c);
}
@Override public void print(int i) throws IOException {
this.delegate.print(i);
}
@Override public void print(long l) throws IOException {
this.delegate.print(l);
}
@Override public void print(float f) throws IOException {
this.delegate.print(f);
}
@Override public void print(double d) throws IOException {
this.delegate.print(d);
}
@Override public void println() throws IOException {
this.delegate.println();
}
@Override public void println(String s) throws IOException {
this.delegate.println(s);
}
@Override public void println(boolean b) throws IOException {
this.delegate.println(b);
}
@Override public void println(char c) throws IOException {
this.delegate.println(c);
}
@Override public void println(int i) throws IOException {
this.delegate.println(i);
}
@Override public void println(long l) throws IOException {
this.delegate.println(l);
}
@Override public void println(float f) throws IOException {
this.delegate.println(f);
}
@Override public void println(double d) throws IOException {
this.delegate.println(d);
}
@Override public void write(byte[] b) throws IOException {
this.delegate.write(b);
}
@Override public void write(byte[] b, int off, int len) throws IOException {
this.delegate.write(b, off, len);
}
@Override public void flush() throws IOException {
if (log.isTraceEnabled()) {
log.trace("Will annotate SS once the stream is flushed");
}
SsLogSetter.annotateWithServerSendIfLogIsNotAlreadyPresent(this.span);
this.delegate.flush();
}
@Override public void close() throws IOException {
if (log.isTraceEnabled()) {
log.trace("Will annotate SS once the stream is closed");
}
SsLogSetter.annotateWithServerSendIfLogIsNotAlreadyPresent(this.span);
this.delegate.close();
}
}
| 2,980 | 23.235772 | 88 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/TWAConf.java
|
package org.myproject.ms.monitoring.instrument.web;
import java.util.regex.Pattern;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.boot.actuate.autoconfigure.ManagementServerProperties;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.myproject.ms.monitoring.ItemNamer;
import org.myproject.ms.monitoring.ItemReporter;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import static javax.servlet.DispatcherType.ASYNC;
import static javax.servlet.DispatcherType.ERROR;
import static javax.servlet.DispatcherType.FORWARD;
import static javax.servlet.DispatcherType.INCLUDE;
import static javax.servlet.DispatcherType.REQUEST;
@Configuration
@ConditionalOnProperty(value = "spring.sleuth.web.enabled", matchIfMissing = true)
@ConditionalOnWebApplication
@ConditionalOnBean(Chainer.class)
@AutoConfigureAfter(THAConf.class)
public class TWAConf {
@Configuration
@ConditionalOnClass(WebMvcConfigurerAdapter.class)
@Import(TWMConf.class)
protected static class TraceWebMvcAutoConfiguration {
}
@Bean
public TWAsp traceWebAspect(Chainer tracer, ChainKeys traceKeys,
ItemNamer spanNamer) {
return new TWAsp(tracer, spanNamer, traceKeys);
}
@Bean
@ConditionalOnClass(name = "org.springframework.data.rest.webmvc.support.DelegatingHandlerMapping")
public TSDBPProcess traceSpringDataBeanPostProcessor(
BeanFactory beanFactory) {
return new TSDBPProcess(beanFactory);
}
@Bean
public FilterRegistrationBean traceWebFilter(TFilter traceFilter) {
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(
traceFilter);
filterRegistrationBean.setDispatcherTypes(ASYNC, ERROR, FORWARD, INCLUDE,
REQUEST);
filterRegistrationBean.setOrder(TFilter.ORDER);
return filterRegistrationBean;
}
@Bean
public TFilter traceFilter(Chainer tracer, ChainKeys traceKeys,
SkipPatternProvider skipPatternProvider, ItemReporter spanReporter,
HSExtra spanExtractor,
HTKInject httpTraceKeysInjector) {
return new TFilter(tracer, traceKeys, skipPatternProvider.skipPattern(),
spanReporter, spanExtractor, httpTraceKeysInjector);
}
@Configuration
@ConditionalOnClass(ManagementServerProperties.class)
@ConditionalOnMissingBean(SkipPatternProvider.class)
@EnableConfigurationProperties(SWProp.class)
protected static class SkipPatternProviderConfig {
@Bean
@ConditionalOnBean(ManagementServerProperties.class)
public SkipPatternProvider skipPatternForManagementServerProperties(
final ManagementServerProperties managementServerProperties,
final SWProp sleuthWebProperties) {
return new SkipPatternProvider() {
@Override
public Pattern skipPattern() {
return getPatternForManagementServerProperties(
managementServerProperties,
sleuthWebProperties);
}
};
}
static Pattern getPatternForManagementServerProperties(
ManagementServerProperties managementServerProperties,
SWProp sleuthWebProperties) {
String skipPattern = sleuthWebProperties.getSkipPattern();
if (StringUtils.hasText(skipPattern)
&& StringUtils.hasText(managementServerProperties.getContextPath())) {
return Pattern.compile(skipPattern + "|"
+ managementServerProperties.getContextPath() + ".*");
}
else if (StringUtils.hasText(managementServerProperties.getContextPath())) {
return Pattern
.compile(managementServerProperties.getContextPath() + ".*");
}
return defaultSkipPattern(skipPattern);
}
@Bean
@ConditionalOnMissingBean(ManagementServerProperties.class)
public SkipPatternProvider defaultSkipPatternBeanIfManagementServerPropsArePresent(SWProp sleuthWebProperties) {
return defaultSkipPatternProvider(sleuthWebProperties.getSkipPattern());
}
}
@Bean
@ConditionalOnMissingClass("org.springframework.boot.actuate.autoconfigure.ManagementServerProperties")
@ConditionalOnMissingBean(SkipPatternProvider.class)
public SkipPatternProvider defaultSkipPatternBean(SWProp sleuthWebProperties) {
return defaultSkipPatternProvider(sleuthWebProperties.getSkipPattern());
}
private static SkipPatternProvider defaultSkipPatternProvider(
final String skipPattern) {
return new SkipPatternProvider() {
@Override
public Pattern skipPattern() {
return defaultSkipPattern(skipPattern);
}
};
}
private static Pattern defaultSkipPattern(String skipPattern) {
return StringUtils.hasText(skipPattern) ? Pattern.compile(skipPattern)
: Pattern.compile(SWProp.DEFAULT_SKIP_PATTERN);
}
interface SkipPatternProvider {
Pattern skipPattern();
}
}
| 5,548 | 35.748344 | 114 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/TWAsp.java
|
package org.myproject.ms.monitoring.instrument.web;
import java.lang.reflect.Field;
import java.util.concurrent.Callable;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ItemNamer;
import org.myproject.ms.monitoring.ChainKeys;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.instrument.async.SCTCall;
import org.myproject.ms.monitoring.util.ExceptionUtils;
import org.springframework.web.context.request.async.WebAsyncTask;
@Aspect
public class TWAsp {
private static final Log log = org.apache.commons.logging.LogFactory
.getLog(TWAsp.class);
private final Chainer tracer;
private final ItemNamer spanNamer;
private final ChainKeys traceKeys;
public TWAsp(Chainer tracer, ItemNamer spanNamer, ChainKeys traceKeys) {
this.tracer = tracer;
this.spanNamer = spanNamer;
this.traceKeys = traceKeys;
}
@Pointcut("@within(org.springframework.web.bind.annotation.RestController)")
private void anyRestControllerAnnotated() { }// NOSONAR
@Pointcut("@within(org.springframework.stereotype.Controller)")
private void anyControllerAnnotated() { } // NOSONAR
@Pointcut("execution(public java.util.concurrent.Callable *(..))")
private void anyPublicMethodReturningCallable() { } // NOSONAR
@Pointcut("(anyRestControllerAnnotated() || anyControllerAnnotated()) && anyPublicMethodReturningCallable()")
private void anyControllerOrRestControllerWithPublicAsyncMethod() { } // NOSONAR
@Pointcut("execution(public org.springframework.web.context.request.async.WebAsyncTask *(..))")
private void anyPublicMethodReturningWebAsyncTask() { } // NOSONAR
@Pointcut("execution(public * org.springframework.web.servlet.HandlerExceptionResolver.resolveException(..)) && args(request, response, handler, ex)")
private void anyHandlerExceptionResolver(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) { } // NOSONAR
@Pointcut("(anyRestControllerAnnotated() || anyControllerAnnotated()) && anyPublicMethodReturningWebAsyncTask()")
private void anyControllerOrRestControllerWithPublicWebAsyncTaskMethod() { } // NOSONAR
@Around("anyControllerOrRestControllerWithPublicAsyncMethod()")
@SuppressWarnings("unchecked")
public Object wrapWithCorrelationId(ProceedingJoinPoint pjp) throws Throwable {
Callable<Object> callable = (Callable<Object>) pjp.proceed();
if (this.tracer.isTracing()) {
if (log.isDebugEnabled()) {
log.debug("Wrapping callable with span [" + this.tracer.getCurrentSpan() + "]");
}
return new SCTCall<>(this.tracer, this.traceKeys, this.spanNamer, callable);
}
else {
return callable;
}
}
@Around("anyControllerOrRestControllerWithPublicWebAsyncTaskMethod()")
public Object wrapWebAsyncTaskWithCorrelationId(ProceedingJoinPoint pjp) throws Throwable {
final WebAsyncTask<?> webAsyncTask = (WebAsyncTask<?>) pjp.proceed();
if (this.tracer.isTracing()) {
try {
if (log.isDebugEnabled()) {
log.debug("Wrapping callable with span [" + this.tracer.getCurrentSpan()
+ "]");
}
Field callableField = WebAsyncTask.class.getDeclaredField("callable");
callableField.setAccessible(true);
callableField.set(webAsyncTask, new SCTCall<>(this.tracer,
this.traceKeys, this.spanNamer, webAsyncTask.getCallable()));
} catch (NoSuchFieldException ex) {
log.warn("Cannot wrap webAsyncTask's callable with TraceCallable", ex);
}
}
return webAsyncTask;
}
@Around("anyHandlerExceptionResolver(request, response, handler, ex)")
public Object markRequestForSpanClosing(ProceedingJoinPoint pjp,
HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Throwable {
Item currentSpan = this.tracer.getCurrentSpan();
try {
if (!currentSpan.tags().containsKey(Item.SPAN_ERROR_TAG_NAME)) {
this.tracer.addTag(Item.SPAN_ERROR_TAG_NAME, ExceptionUtils.getExceptionMessage(ex));
}
return pjp.proceed();
} finally {
if (log.isDebugEnabled()) {
log.debug("Marking span " + currentSpan + " for closure by Trace Filter");
}
request.setAttribute(TFilter.TRACE_CLOSE_SPAN_REQUEST_ATTR, true);
}
}
}
| 4,468 | 38.201754 | 151 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/TWMConf.java
|
package org.myproject.ms.monitoring.instrument.web;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
@Configuration
class TWMConf extends WebMvcConfigurerAdapter {
@Autowired BeanFactory beanFactory;
@Bean
public THInter traceHandlerInterceptor(BeanFactory beanFactory) {
return new THInter(beanFactory);
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(this.beanFactory.getBean(THInter.class));
}
}
| 806 | 28.888889 | 81 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/ZHSExtra.java
|
package org.myproject.ms.monitoring.instrument.web;
import java.lang.invoke.MethodHandles;
import java.util.Map;
import java.util.Random;
import java.util.regex.Pattern;
import org.apache.commons.logging.LogFactory;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ItemTextMap;
import org.myproject.ms.monitoring.util.TextMapUtil;
import org.springframework.util.StringUtils;
public class ZHSExtra implements HSExtra {
private static final org.apache.commons.logging.Log log = LogFactory.getLog(
MethodHandles.lookup().lookupClass());
private static final String HEADER_DELIMITER = "-";
static final String URI_HEADER = "X-Span-Uri";
private static final String HTTP_COMPONENT = "http";
private final Pattern skipPattern;
public ZHSExtra(Pattern skipPattern) {
this.skipPattern = skipPattern;
}
@Override
public Item joinTrace(ItemTextMap textMap) {
Map<String, String> carrier = TextMapUtil.asMap(textMap);
boolean debug = Item.SPAN_SAMPLED.equals(carrier.get(Item.SPAN_FLAGS));
if (debug) {
// we're only generating Trace ID since if there's no Span ID will assume
// that it's equal to Trace ID
generateIdIfMissing(carrier, Item.TRACE_ID_NAME);
} else if (carrier.get(Item.TRACE_ID_NAME) == null) {
// can't build a Span without trace id
return null;
}
try {
String uri = carrier.get(URI_HEADER);
boolean skip = this.skipPattern.matcher(uri).matches()
|| Item.SPAN_NOT_SAMPLED.equals(carrier.get(Item.SAMPLED_NAME));
long spanId = spanId(carrier);
return buildParentSpan(carrier, uri, skip, spanId);
} catch (Exception e) {
log.error("Exception occurred while trying to extract span from carrier", e);
return null;
}
}
private void generateIdIfMissing(Map<String, String> carrier, String key) {
if (!carrier.containsKey(key)) {
carrier.put(key, Item.idToHex(new Random().nextLong()));
}
}
private long spanId(Map<String, String> carrier) {
String spanId = carrier.get(Item.SPAN_ID_NAME);
if (spanId == null) {
if (log.isDebugEnabled()) {
log.debug("Request is missing a span id but it has a trace id. We'll assume that this is "
+ "a root span with span id equal to the lower 64-bits of the trace id");
}
return Item.hexToId(carrier.get(Item.TRACE_ID_NAME));
} else {
return Item.hexToId(spanId);
}
}
private Item buildParentSpan(Map<String, String> carrier, String uri, boolean skip, long spanId) {
String traceId = carrier.get(Item.TRACE_ID_NAME);
Item.SpanBuilder span = Item.builder()
.traceIdHigh(traceId.length() == 32 ? Item.hexToId(traceId, 0) : 0)
.traceId(Item.hexToId(traceId))
.spanId(spanId);
String processId = carrier.get(Item.PROCESS_ID_NAME);
String parentName = carrier.get(Item.SPAN_NAME_NAME);
if (StringUtils.hasText(parentName)) {
span.name(parentName);
} else {
span.name(HTTP_COMPONENT + ":/parent" + uri);
}
if (StringUtils.hasText(processId)) {
span.processId(processId);
}
if (carrier.containsKey(Item.PARENT_ID_NAME)) {
span.parent(Item.hexToId(carrier.get(Item.PARENT_ID_NAME)));
}
span.remote(true);
boolean debug = Item.SPAN_SAMPLED.equals(carrier.get(Item.SPAN_FLAGS));
if (debug) {
span.exportable(true);
} else if (skip) {
span.exportable(false);
}
for (Map.Entry<String, String> entry : carrier.entrySet()) {
if (entry.getKey().startsWith(Item.SPAN_BAGGAGE_HEADER_PREFIX + HEADER_DELIMITER)) {
span.baggage(unprefixedKey(entry.getKey()), entry.getValue());
}
}
return span.build();
}
private String unprefixedKey(String key) {
return key.substring(key.indexOf(HEADER_DELIMITER) + 1);
}
}
| 3,661 | 31.990991 | 99 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/ZHSInject.java
|
package org.myproject.ms.monitoring.instrument.web;
import java.util.Map;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.ItemTextMap;
import org.springframework.util.StringUtils;
public class ZHSInject implements HSInject {
private static final String HEADER_DELIMITER = "-";
@Override
public void inject(Item span, ItemTextMap carrier) {
setHeader(carrier, Item.TRACE_ID_NAME, span.traceIdString());
setIdHeader(carrier, Item.SPAN_ID_NAME, span.getSpanId());
setHeader(carrier, Item.SAMPLED_NAME, span.isExportable() ? Item.SPAN_SAMPLED : Item.SPAN_NOT_SAMPLED);
setHeader(carrier, Item.SPAN_NAME_NAME, span.getName());
setIdHeader(carrier, Item.PARENT_ID_NAME, getParentId(span));
setHeader(carrier, Item.PROCESS_ID_NAME, span.getProcessId());
for (Map.Entry<String, String> entry : span.baggageItems()) {
carrier.put(prefixedKey(entry.getKey()), entry.getValue());
}
}
private String prefixedKey(String key) {
if (key.startsWith(Item.SPAN_BAGGAGE_HEADER_PREFIX + HEADER_DELIMITER)) {
return key;
}
return Item.SPAN_BAGGAGE_HEADER_PREFIX + HEADER_DELIMITER + key;
}
private Long getParentId(Item span) {
return !span.getParents().isEmpty() ? span.getParents().get(0) : null;
}
private void setIdHeader(ItemTextMap carrier, String name, Long value) {
if (value != null) {
setHeader(carrier, name, Item.idToHex(value));
}
}
private void setHeader(ItemTextMap carrier, String name, String value) {
if (StringUtils.hasText(value)) {
carrier.put(name, value);
}
}
}
| 1,559 | 29.588235 | 105 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/client/ATHRInter.java
|
package org.myproject.ms.monitoring.instrument.web.client;
import java.lang.invoke.MethodHandles;
import java.net.URI;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.myproject.ms.monitoring.instrument.web.HSInject;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.instrument.web.HTKInject;
import org.myproject.ms.monitoring.util.ItemNameUtil;
import org.springframework.http.HttpRequest;
abstract class ATHRInter {
protected static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
protected final Chainer tracer;
protected final HSInject spanInjector;
protected final HTKInject keysInjector;
protected ATHRInter(Chainer tracer,
HSInject spanInjector, HTKInject keysInjector) {
this.tracer = tracer;
this.spanInjector = spanInjector;
this.keysInjector = keysInjector;
}
protected void publishStartEvent(HttpRequest request) {
URI uri = request.getURI();
String spanName = getName(uri);
Item newSpan = this.tracer.createSpan(spanName);
this.spanInjector.inject(newSpan, new HRTMap(request));
addRequestTags(request);
newSpan.logEvent(Item.CLIENT_SEND);
if (log.isDebugEnabled()) {
log.debug("Starting new client span [" + newSpan + "]");
}
}
private String getName(URI uri) {
return ItemNameUtil.shorten(uriScheme(uri) + ":" + uri.getPath());
}
private String uriScheme(URI uri) {
return uri.getScheme() == null ? "http" : uri.getScheme();
}
protected void addRequestTags(HttpRequest request) {
this.keysInjector.addRequestTags(request.getURI().toString(),
request.getURI().getHost(),
request.getURI().getPath(),
request.getMethod().name(),
request.getHeaders());
}
public void finish() {
if (!isTracing()) {
return;
}
currentSpan().logEvent(Item.CLIENT_RECV);
this.tracer.close(this.currentSpan());
}
protected Item currentSpan() {
return this.tracer.getCurrentSpan();
}
protected boolean isTracing() {
return this.tracer.isTracing();
}
}
| 2,090 | 25.1375 | 90 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/client/HRTMap.java
|
package org.myproject.ms.monitoring.instrument.web.client;
import java.util.AbstractMap;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.myproject.ms.monitoring.ItemTextMap;
import org.springframework.http.HttpRequest;
import org.springframework.util.StringUtils;
class HRTMap implements ItemTextMap {
private final HttpRequest delegate;
HRTMap(HttpRequest delegate) {
this.delegate = delegate;
}
@Override
public Iterator<Map.Entry<String, String>> iterator() {
final Iterator<Map.Entry<String, List<String>>> iterator = this.delegate.getHeaders()
.entrySet().iterator();
return new Iterator<Map.Entry<String, String>>() {
@Override public boolean hasNext() {
return iterator.hasNext();
}
@Override public Map.Entry<String, String> next() {
Map.Entry<String, List<String>> next = iterator.next();
List<String> value = next.getValue();
return new AbstractMap.SimpleEntry<>(next.getKey(), value.isEmpty() ? "" : value.get(0));
}
};
}
@Override
public void put(String key, String value) {
if (!StringUtils.hasText(value)) {
return;
}
this.delegate.getHeaders().put(key, Collections.singletonList(value));
}
}
| 1,241 | 24.346939 | 93 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/client/SWCEnable.java
|
package org.myproject.ms.monitoring.instrument.web.client;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD})
@Documented
@ConditionalOnProperty(value = "spring.sleuth.web.client.enabled", matchIfMissing = true)
@interface SWCEnable {
}
| 385 | 26.571429 | 89 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/client/TACHRFW.java
|
package org.myproject.ms.monitoring.instrument.web.client;
import java.io.IOException;
import java.net.URI;
import org.myproject.ms.monitoring.instrument.web.HSInject;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.instrument.web.HTKInject;
import org.springframework.core.task.AsyncListenableTaskExecutor;
import org.springframework.http.HttpMethod;
import org.springframework.http.client.AsyncClientHttpRequest;
import org.springframework.http.client.AsyncClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpRequest;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
public class TACHRFW extends ATHRInter
implements ClientHttpRequestFactory, AsyncClientHttpRequestFactory {
final AsyncClientHttpRequestFactory asyncDelegate;
final ClientHttpRequestFactory syncDelegate;
public TACHRFW(Chainer tracer,
HSInject spanInjector,
AsyncClientHttpRequestFactory asyncDelegate,
HTKInject httpTraceKeysInjector) {
super(tracer, spanInjector, httpTraceKeysInjector);
this.asyncDelegate = asyncDelegate;
this.syncDelegate = asyncDelegate instanceof ClientHttpRequestFactory ?
(ClientHttpRequestFactory) asyncDelegate : defaultClientHttpRequestFactory();
}
public TACHRFW(Chainer tracer,
HSInject spanInjector, HTKInject httpTraceKeysInjector) {
super(tracer, spanInjector, httpTraceKeysInjector);
SimpleClientHttpRequestFactory simpleClientHttpRequestFactory = defaultClientHttpRequestFactory();
this.asyncDelegate = simpleClientHttpRequestFactory;
this.syncDelegate = simpleClientHttpRequestFactory;
}
public TACHRFW(Chainer tracer,
HSInject spanInjector,
AsyncClientHttpRequestFactory asyncDelegate,
ClientHttpRequestFactory syncDelegate,
HTKInject httpTraceKeysInjector) {
super(tracer, spanInjector, httpTraceKeysInjector);
this.asyncDelegate = asyncDelegate;
this.syncDelegate = syncDelegate;
}
private SimpleClientHttpRequestFactory defaultClientHttpRequestFactory() {
SimpleClientHttpRequestFactory simpleClientHttpRequestFactory = new SimpleClientHttpRequestFactory();
simpleClientHttpRequestFactory.setTaskExecutor(asyncListenableTaskExecutor(this.tracer));
return simpleClientHttpRequestFactory;
}
private AsyncListenableTaskExecutor asyncListenableTaskExecutor(Chainer tracer) {
ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
threadPoolTaskScheduler.initialize();
return new TALTExec(threadPoolTaskScheduler, tracer);
}
@Override
public AsyncClientHttpRequest createAsyncRequest(URI uri, HttpMethod httpMethod)
throws IOException {
AsyncClientHttpRequest request = this.asyncDelegate
.createAsyncRequest(uri, httpMethod);
addRequestTags(request);
publishStartEvent(request);
return request;
}
@Override
public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod)
throws IOException {
ClientHttpRequest request = this.syncDelegate.createRequest(uri, httpMethod);
addRequestTags(request);
publishStartEvent(request);
return request;
}
}
| 3,221 | 35.613636 | 103 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/client/TALTExec.java
|
package org.myproject.ms.monitoring.instrument.web.client;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import org.myproject.ms.monitoring.Chainer;
import org.springframework.core.task.AsyncListenableTaskExecutor;
import org.springframework.util.concurrent.ListenableFuture;
public class TALTExec implements AsyncListenableTaskExecutor {
private final AsyncListenableTaskExecutor delegate;
private final Chainer tracer;
TALTExec(AsyncListenableTaskExecutor delegate,
Chainer tracer) {
this.delegate = delegate;
this.tracer = tracer;
}
@Override
public ListenableFuture<?> submitListenable(Runnable task) {
return this.delegate.submitListenable(this.tracer.wrap(task));
}
@Override
public <T> ListenableFuture<T> submitListenable(Callable<T> task) {
return this.delegate.submitListenable(this.tracer.wrap(task));
}
@Override
public void execute(Runnable task, long startTimeout) {
this.delegate.execute(this.tracer.wrap(task), startTimeout);
}
@Override
public Future<?> submit(Runnable task) {
return this.delegate.submit(this.tracer.wrap(task));
}
@Override
public <T> Future<T> submit(Callable<T> task) {
return this.delegate.submit(this.tracer.wrap(task));
}
@Override
public void execute(Runnable task) {
this.delegate.execute(this.tracer.wrap(task));
}
}
| 1,344 | 23.907407 | 68 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/client/TARTemp.java
|
package org.myproject.ms.monitoring.instrument.web.client;
import java.lang.invoke.MethodHandles;
import java.net.URI;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.util.ExceptionUtils;
import org.springframework.core.task.AsyncListenableTaskExecutor;
import org.springframework.http.HttpMethod;
import org.springframework.http.client.AsyncClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.util.concurrent.FailureCallback;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;
import org.springframework.util.concurrent.SuccessCallback;
import org.springframework.web.client.AsyncRequestCallback;
import org.springframework.web.client.AsyncRestTemplate;
import org.springframework.web.client.ResponseExtractor;
import org.springframework.web.client.RestClientException;
import org.springframework.web.client.RestTemplate;
public class TARTemp extends AsyncRestTemplate {
private final Chainer tracer;
public TARTemp(Chainer tracer) {
super();
this.tracer = tracer;
}
public TARTemp(AsyncListenableTaskExecutor taskExecutor, Chainer tracer) {
super(taskExecutor);
this.tracer = tracer;
}
public TARTemp(AsyncClientHttpRequestFactory asyncRequestFactory,
Chainer tracer) {
super(asyncRequestFactory);
this.tracer = tracer;
}
public TARTemp(AsyncClientHttpRequestFactory asyncRequestFactory,
ClientHttpRequestFactory syncRequestFactory, Chainer tracer) {
super(asyncRequestFactory, syncRequestFactory);
this.tracer = tracer;
}
public TARTemp(AsyncClientHttpRequestFactory requestFactory,
RestTemplate restTemplate, Chainer tracer) {
super(requestFactory, restTemplate);
this.tracer = tracer;
}
@Override
protected <T> ListenableFuture<T> doExecute(URI url, HttpMethod method,
AsyncRequestCallback requestCallback, ResponseExtractor<T> responseExtractor)
throws RestClientException {
final ListenableFuture<T> future = super.doExecute(url, method, requestCallback, responseExtractor);
final Item span = this.tracer.getCurrentSpan();
future.addCallback(new TraceListenableFutureCallback<>(this.tracer, span));
// potential race can happen here
if (span != null && span.equals(this.tracer.getCurrentSpan())) {
this.tracer.detach(span);
}
return new ListenableFuture<T>() {
@Override public boolean cancel(boolean mayInterruptIfRunning) {
return future.cancel(mayInterruptIfRunning);
}
@Override public boolean isCancelled() {
return future.isCancelled();
}
@Override public boolean isDone() {
return future.isDone();
}
@Override public T get() throws InterruptedException, ExecutionException {
return future.get();
}
@Override public T get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
return future.get(timeout, unit);
}
@Override
public void addCallback(ListenableFutureCallback<? super T> callback) {
future.addCallback(new TraceListenableFutureCallbackWrapper<>(TARTemp.this.tracer, span, callback));
}
@Override public void addCallback(SuccessCallback<? super T> successCallback,
FailureCallback failureCallback) {
future.addCallback(
new TraceSuccessCallback<>(TARTemp.this.tracer, span, successCallback),
new TraceFailureCallback(TARTemp.this.tracer, span, failureCallback));
}
};
}
private static class TraceSuccessCallback<T> implements SuccessCallback<T> {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private final Chainer tracer;
private final Item parent;
private final SuccessCallback<T> delegate;
private TraceSuccessCallback(Chainer tracer, Item parent,
SuccessCallback<T> delegate) {
this.tracer = tracer;
this.parent = parent;
this.delegate = delegate;
}
@Override public void onSuccess(T result) {
continueSpan();
if (log.isDebugEnabled()) {
log.debug("Calling on success of the delegate");
}
this.delegate.onSuccess(result);
finish();
}
private void continueSpan() {
this.tracer.continueSpan(this.parent);
}
private void finish() {
this.tracer.detach(currentSpan());
}
private Item currentSpan() {
return this.tracer.getCurrentSpan();
}
}
private static class TraceFailureCallback implements FailureCallback {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private final Chainer tracer;
private final Item parent;
private final FailureCallback delegate;
private TraceFailureCallback(Chainer tracer, Item parent,
FailureCallback delegate) {
this.tracer = tracer;
this.parent = parent;
this.delegate = delegate;
}
@Override public void onFailure(Throwable ex) {
continueSpan();
if (log.isDebugEnabled()) {
log.debug("Calling on failure of the delegate");
}
this.delegate.onFailure(ex);
finish();
}
private void continueSpan() {
this.tracer.continueSpan(this.parent);
}
private void finish() {
this.tracer.detach(currentSpan());
}
private Item currentSpan() {
return this.tracer.getCurrentSpan();
}
}
private static class TraceListenableFutureCallbackWrapper<T> implements ListenableFutureCallback<T> {
private final Chainer tracer;
private final Item parent;
private final ListenableFutureCallback<T> delegate;
private TraceListenableFutureCallbackWrapper(Chainer tracer, Item parent,
ListenableFutureCallback<T> delegate) {
this.tracer = tracer;
this.parent = parent;
this.delegate = delegate;
}
@Override public void onFailure(Throwable ex) {
new TraceFailureCallback(this.tracer, this.parent, this.delegate).onFailure(ex);
}
@Override public void onSuccess(T result) {
new TraceSuccessCallback<>(this.tracer, this.parent, this.delegate).onSuccess(result);
}
}
private static class TraceListenableFutureCallback<T> implements ListenableFutureCallback<T> {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private final Chainer tracer;
private final Item parent;
private TraceListenableFutureCallback(Chainer tracer, Item parent) {
this.tracer = tracer;
this.parent = parent;
}
@Override
public void onFailure(Throwable ex) {
continueSpan();
if (log.isDebugEnabled()) {
log.debug("The callback failed - will close the span");
}
this.tracer.addTag(Item.SPAN_ERROR_TAG_NAME, ExceptionUtils.getExceptionMessage(ex));
finish();
}
@Override
public void onSuccess(T result) {
continueSpan();
if (log.isDebugEnabled()) {
log.debug("The callback succeeded - will close the span");
}
finish();
}
private void continueSpan() {
this.tracer.continueSpan(this.parent);
}
private void finish() {
if (!isTracing()) {
return;
}
currentSpan().logEvent(Item.CLIENT_RECV);
this.tracer.close(currentSpan());
}
private Item currentSpan() {
return this.tracer.getCurrentSpan();
}
private boolean isTracing() {
return this.tracer.isTracing();
}
}
}
| 7,454 | 27.238636 | 104 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/client/THResp.java
|
package org.myproject.ms.monitoring.instrument.web.client;
import java.io.IOException;
import java.io.InputStream;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.client.ClientHttpResponse;
public class THResp implements ClientHttpResponse {
private final ClientHttpResponse delegate;
private final TRTInter interceptor;
public THResp(TRTInter interceptor,
ClientHttpResponse delegate) {
this.interceptor = interceptor;
this.delegate = delegate;
}
@Override
public HttpHeaders getHeaders() {
return this.delegate.getHeaders();
}
@Override
public InputStream getBody() throws IOException {
return this.delegate.getBody();
}
@Override
public HttpStatus getStatusCode() throws IOException {
return this.delegate.getStatusCode();
}
@Override
public int getRawStatusCode() throws IOException {
return this.delegate.getRawStatusCode();
}
@Override
public String getStatusText() throws IOException {
return this.delegate.getStatusText();
}
@Override
public void close() {
try {
this.delegate.close();
}
finally {
this.interceptor.finish();
}
}
}
| 1,179 | 19 | 58 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/client/TRTInter.java
|
package org.myproject.ms.monitoring.instrument.web.client;
import java.io.IOException;
import org.myproject.ms.monitoring.instrument.web.HSInject;
import org.myproject.ms.monitoring.Item;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.instrument.web.HTKInject;
import org.myproject.ms.monitoring.util.ExceptionUtils;
import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;
public class TRTInter extends ATHRInter
implements ClientHttpRequestInterceptor {
public TRTInter(Chainer tracer, HSInject spanInjector,
HTKInject httpTraceKeysInjector) {
super(tracer, spanInjector, httpTraceKeysInjector);
}
@Override
public ClientHttpResponse intercept(HttpRequest request, byte[] body,
ClientHttpRequestExecution execution) throws IOException {
publishStartEvent(request);
return response(request, body, execution);
}
private ClientHttpResponse response(HttpRequest request, byte[] body,
ClientHttpRequestExecution execution) throws IOException {
try {
return new THResp(this, execution.execute(request, body));
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug("Exception occurred while trying to execute the request. Will close the span [" + currentSpan() + "]", e);
}
this.tracer.addTag(Item.SPAN_ERROR_TAG_NAME, ExceptionUtils.getExceptionMessage(e));
finish();
throw e;
}
}
}
| 1,564 | 31.604167 | 120 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/client/TWACAConf.java
|
package org.myproject.ms.monitoring.instrument.web.client;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.myproject.ms.monitoring.instrument.web.HSInject;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.instrument.web.HTKInject;
import org.myproject.ms.monitoring.instrument.web.TWAConf;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.AsyncListenableTaskExecutor;
import org.springframework.http.client.AsyncClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.web.client.AsyncRestTemplate;
@Configuration
@SWCEnable
@ConditionalOnProperty(value = "spring.sleuth.web.async.client.enabled", matchIfMissing = true)
@ConditionalOnClass(AsyncRestTemplate.class)
@ConditionalOnBean(HTKInject.class)
@AutoConfigureAfter(TWAConf.class)
public class TWACAConf {
@Autowired Chainer tracer;
@Autowired private HTKInject httpTraceKeysInjector;
@Autowired private HSInject spanInjector;
@Autowired(required = false) private ClientHttpRequestFactory clientHttpRequestFactory;
@Autowired(required = false) private AsyncClientHttpRequestFactory asyncClientHttpRequestFactory;
private TACHRFW traceAsyncClientHttpRequestFactory() {
ClientHttpRequestFactory clientFactory = this.clientHttpRequestFactory;
AsyncClientHttpRequestFactory asyncClientFactory = this.asyncClientHttpRequestFactory;
if (clientFactory == null) {
clientFactory = defaultClientHttpRequestFactory(this.tracer);
}
if (asyncClientFactory == null) {
asyncClientFactory = clientFactory instanceof AsyncClientHttpRequestFactory ?
(AsyncClientHttpRequestFactory) clientFactory : defaultClientHttpRequestFactory(this.tracer);
}
return new TACHRFW(this.tracer, this.spanInjector,
asyncClientFactory, clientFactory, this.httpTraceKeysInjector);
}
private SimpleClientHttpRequestFactory defaultClientHttpRequestFactory(Chainer tracer) {
SimpleClientHttpRequestFactory simpleClientHttpRequestFactory = new SimpleClientHttpRequestFactory();
simpleClientHttpRequestFactory.setTaskExecutor(asyncListenableTaskExecutor(tracer));
return simpleClientHttpRequestFactory;
}
private AsyncListenableTaskExecutor asyncListenableTaskExecutor(Chainer tracer) {
ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
threadPoolTaskScheduler.initialize();
return new TALTExec(threadPoolTaskScheduler, tracer);
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(value = "spring.sleuth.web.async.client.template.enabled", matchIfMissing = true)
public AsyncRestTemplate traceAsyncRestTemplate() {
return new TARTemp(traceAsyncClientHttpRequestFactory(), this.tracer);
}
}
| 3,350 | 44.90411 | 105 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/instrument/web/client/TWCAConf.java
|
package org.myproject.ms.monitoring.instrument.web.client;
import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.myproject.ms.monitoring.instrument.web.HSInject;
import org.myproject.ms.monitoring.Chainer;
import org.myproject.ms.monitoring.instrument.web.HTKInject;
import org.myproject.ms.monitoring.instrument.web.TWAConf;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.web.client.RestTemplate;
@Configuration
@SWCEnable
@ConditionalOnClass(RestTemplate.class)
@ConditionalOnBean(HTKInject.class)
@AutoConfigureAfter(TWAConf.class)
public class TWCAConf {
@Bean
@ConditionalOnMissingBean
public TRTInter traceRestTemplateInterceptor(Chainer tracer,
HSInject spanInjector,
HTKInject httpTraceKeysInjector) {
return new TRTInter(tracer, spanInjector, httpTraceKeysInjector);
}
@Configuration
protected static class TraceInterceptorConfiguration {
@Autowired(required = false)
private Collection<RestTemplate> restTemplates;
@Autowired
private TRTInter traceRestTemplateInterceptor;
@PostConstruct
public void init() {
if (this.restTemplates != null) {
for (RestTemplate restTemplate : this.restTemplates) {
List<ClientHttpRequestInterceptor> interceptors = new ArrayList<ClientHttpRequestInterceptor>(
restTemplate.getInterceptors());
interceptors.add(this.traceRestTemplateInterceptor);
restTemplate.setInterceptors(interceptors);
}
}
}
}
}
| 2,019 | 31.580645 | 99 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/lgger/ItemLogger.java
|
package org.myproject.ms.monitoring.lgger;
import org.myproject.ms.monitoring.Item;
public interface ItemLogger {
void logStartedSpan(Item parent, Item span);
void logContinuedSpan(Item span);
void logStoppedSpan(Item parent, Item span);
}
| 257 | 12.578947 | 45 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/lgger/LogAtcfg.java
|
package org.myproject.ms.monitoring.lgger;
import org.slf4j.MDC;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@ConditionalOnProperty(value="spring.sleuth.enabled", matchIfMissing=true)
public class LogAtcfg {
@Configuration
@ConditionalOnClass(MDC.class)
@EnableConfigurationProperties(Slf4jProps.class)
protected static class Slf4jConfiguration {
@Bean
@ConditionalOnProperty(value = "spring.sleuth.log.slf4j.enabled", matchIfMissing = true)
@ConditionalOnMissingBean
public ItemLogger slf4jSpanLogger(Slf4jProps sleuthSlf4jProperties) {
// Sets up MDC entries X-B3-TraceId and X-B3-SpanId
return new Slf4jItemLogger(sleuthSlf4jProperties.getNameSkipPattern());
}
@Bean
@ConditionalOnProperty(value = "spring.sleuth.log.slf4j.enabled", havingValue = "false")
@ConditionalOnMissingBean
public ItemLogger noOpSlf4jSpanLogger() {
return new NoItemLogger();
}
}
@Bean
@ConditionalOnMissingClass("org.slf4j.MDC")
@ConditionalOnMissingBean
public ItemLogger defaultLoggedSpansHandler() {
return new NoItemLogger();
}
}
| 1,549 | 31.978723 | 90 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/lgger/NoItemLogger.java
|
package org.myproject.ms.monitoring.lgger;
import org.myproject.ms.monitoring.Item;
public class NoItemLogger implements ItemLogger {
@Override
public void logStartedSpan(Item parent, Item span) {
}
@Override
public void logContinuedSpan(Item span) {
}
@Override
public void logStoppedSpan(Item parent, Item span) {
}
}
| 339 | 13.166667 | 53 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/lgger/Slf4jItemLogger.java
|
package org.myproject.ms.monitoring.lgger;
import java.util.regex.Pattern;
import org.slf4j.Logger;
import org.slf4j.MDC;
import org.myproject.ms.monitoring.Item;
public class Slf4jItemLogger implements ItemLogger {
private final Logger log;
private final Pattern nameSkipPattern;
public Slf4jItemLogger(String nameSkipPattern) {
this.nameSkipPattern = Pattern.compile(nameSkipPattern);
this.log = org.slf4j.LoggerFactory.getLogger(Slf4jItemLogger.class);
}
Slf4jItemLogger(String nameSkipPattern, Logger log) {
this.nameSkipPattern = Pattern.compile(nameSkipPattern);
this.log = log;
}
@Override
public void logStartedSpan(Item parent, Item span) {
MDC.put(Item.SPAN_ID_NAME, Item.idToHex(span.getSpanId()));
MDC.put(Item.SPAN_EXPORT_NAME, String.valueOf(span.isExportable()));
MDC.put(Item.TRACE_ID_NAME, span.traceIdString());
log("Starting span: {}", span);
if (parent != null) {
log("With parent: {}", parent);
MDC.put(Item.PARENT_ID_NAME, Item.idToHex(parent.getSpanId()));
}
}
@Override
public void logContinuedSpan(Item span) {
MDC.put(Item.SPAN_ID_NAME, Item.idToHex(span.getSpanId()));
MDC.put(Item.TRACE_ID_NAME, span.traceIdString());
MDC.put(Item.SPAN_EXPORT_NAME, String.valueOf(span.isExportable()));
setParentIdIfPresent(span);
log("Continued span: {}", span);
}
private void setParentIdIfPresent(Item span) {
if (!span.getParents().isEmpty()) {
MDC.put(Item.PARENT_ID_NAME, Item.idToHex(span.getParents().get(0)));
}
}
@Override
public void logStoppedSpan(Item parent, Item span) {
if (span != null) {
log("Stopped span: {}", span);
}
if (span != null && parent != null) {
log("With parent: {}", parent);
MDC.put(Item.SPAN_ID_NAME, Item.idToHex(parent.getSpanId()));
MDC.put(Item.SPAN_EXPORT_NAME, String.valueOf(parent.isExportable()));
setParentIdIfPresent(parent);
}
else {
MDC.remove(Item.SPAN_ID_NAME);
MDC.remove(Item.SPAN_EXPORT_NAME);
MDC.remove(Item.TRACE_ID_NAME);
MDC.remove(Item.PARENT_ID_NAME);
}
}
private void log(String text, Item span) {
if (span != null && this.nameSkipPattern.matcher(span.getName()).matches()) {
return;
}
if (this.log.isTraceEnabled()) {
this.log.trace(text, span);
}
}
}
| 2,257 | 26.204819 | 79 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/lgger/Slf4jProps.java
|
package org.myproject.ms.monitoring.lgger;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties("spring.sleuth.log.slf4j")
public class Slf4jProps {
private boolean enabled = true;
private String nameSkipPattern = "";
public boolean isEnabled() {
return this.enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public String getNameSkipPattern() {
return this.nameSkipPattern;
}
public void setNameSkipPattern(String nameSkipPattern) {
this.nameSkipPattern = nameSkipPattern;
}
}
| 586 | 17.935484 | 75 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/mtc/CSBSMRep.java
|
package org.myproject.ms.monitoring.mtc;
import org.springframework.boot.actuate.metrics.CounterService;
public class CSBSMRep implements ItemMetricReporter {
private final String acceptedSpansMetricName;
private final String droppedSpansMetricName;
private final CounterService counterService;
public CSBSMRep(String acceptedSpansMetricName,
String droppedSpansMetricName, CounterService counterService) {
this.acceptedSpansMetricName = acceptedSpansMetricName;
this.droppedSpansMetricName = droppedSpansMetricName;
this.counterService = counterService;
}
@Override
public void incrementAcceptedSpans(long quantity) {
for (int i = 0; i < quantity; i++) {
this.counterService.increment(this.acceptedSpansMetricName);
}
}
@Override
public void incrementDroppedSpans(long quantity) {
for (int i = 0; i < quantity; i++) {
this.counterService.increment(this.droppedSpansMetricName);
}
}
}
| 924 | 28.83871 | 66 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/mtc/ChainMetricsAtcfg.java
|
package org.myproject.ms.monitoring.mtc;
import java.lang.invoke.MethodHandles;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.boot.actuate.metrics.CounterService;
import org.springframework.boot.autoconfigure.condition.ConditionOutcome;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
import org.springframework.boot.autoconfigure.condition.SpringBootCondition;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.type.AnnotatedTypeMetadata;
@Configuration
@Conditional(ChainMetricsAtcfg.PickMetricIfMetricsIsMissing.class)
@EnableConfigurationProperties
public class ChainMetricsAtcfg {
@Bean
@ConditionalOnMissingBean
public SMProp sleuthMetricProperties() {
return new SMProp();
}
@Configuration
@ConditionalOnClass(CounterService.class)
@ConditionalOnMissingBean(ItemMetricReporter.class)
protected static class CounterServiceSpanReporterConfig {
@Bean
@ConditionalOnBean(CounterService.class)
public ItemMetricReporter spanReporterCounterService(CounterService counterService,
SMProp sleuthMetricProperties) {
return new CSBSMRep(sleuthMetricProperties.getSpan().getAcceptedName(),
sleuthMetricProperties.getSpan().getDroppedName(), counterService);
}
@Bean
@ConditionalOnMissingBean(CounterService.class)
public ItemMetricReporter noOpSpanReporterCounterService() {
return new NOIMRep();
}
}
@Bean
@ConditionalOnMissingClass("org.springframework.boot.actuate.metrics.CounterService")
@ConditionalOnMissingBean(ItemMetricReporter.class)
public ItemMetricReporter noOpSpanReporterCounterService() {
return new NOIMRep();
}
static class PickMetricIfMetricsIsMissing extends SpringBootCondition {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
static final String DEPRECATED_SPRING_SLEUTH_METRICS_ENABLED = "spring.sleuth.metrics.enabled";
static final String SPRING_SLEUTH_METRIC_ENABLED = "spring.sleuth.metric.enabled";
@Override
public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
Boolean oldValue = context.getEnvironment().getProperty(DEPRECATED_SPRING_SLEUTH_METRICS_ENABLED, Boolean.class);
Boolean newValue = context.getEnvironment().getProperty(SPRING_SLEUTH_METRIC_ENABLED, Boolean.class);
if (oldValue != null) {
log.warn("You're using an old version of the metrics property. Instead of using [" +
DEPRECATED_SPRING_SLEUTH_METRICS_ENABLED + "] please use [" + SPRING_SLEUTH_METRIC_ENABLED + "]");
return matchCondition(oldValue, DEPRECATED_SPRING_SLEUTH_METRICS_ENABLED);
}
if (newValue != null) {
return matchCondition(newValue, SPRING_SLEUTH_METRIC_ENABLED);
}
return ConditionOutcome.match("No property was passed - assuming that metrics are enabled.");
}
private ConditionOutcome matchCondition(Boolean value, String property) {
if (Boolean.TRUE.equals(value)) {
return ConditionOutcome.match();
}
return ConditionOutcome.noMatch("Property [" + property + "] is set to false.");
}
}
}
| 3,658 | 39.208791 | 116 |
java
|
train-ticket
|
train-ticket-master/old-docs/Lib/ms-monitoring-core/src/main/java/org/myproject/ms/monitoring/mtc/ItemMetricReporter.java
|
package org.myproject.ms.monitoring.mtc;
public interface ItemMetricReporter {
void incrementAcceptedSpans(long quantity);
void incrementDroppedSpans(long quantity);
}
| 178 | 13.916667 | 44 |
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.