code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
private static ViewData createInternal(
View view,
Map<List</*@Nullable*/ TagValue>, AggregationData> aggregationMap,
AggregationWindowData window,
Timestamp start,
Timestamp end) {
@SuppressWarnings("nullness")
Map<List<TagValue>, AggregationData> map = aggregationMap;
return new AutoValue_ViewData(view, map, window, start, end);
}
|
java
|
static Endpoint produceLocalEndpoint(String serviceName) {
Endpoint.Builder builder = Endpoint.newBuilder().serviceName(serviceName);
try {
Enumeration<NetworkInterface> nics = NetworkInterface.getNetworkInterfaces();
if (nics == null) {
return builder.build();
}
while (nics.hasMoreElements()) {
NetworkInterface nic = nics.nextElement();
Enumeration<InetAddress> addresses = nic.getInetAddresses();
while (addresses.hasMoreElements()) {
InetAddress address = addresses.nextElement();
if (address.isSiteLocalAddress()) {
builder.ip(address);
break;
}
}
}
} catch (Exception e) {
// don't crash the caller if there was a problem reading nics.
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE, "error reading nics", e);
}
}
return builder.build();
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public AttributeValue[] createAttributeValues(Data data) {
return getAttributeValues(data.size, data.attributeType);
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public Map<String, AttributeValue> createAttributeMap(Data data) {
Map<String, AttributeValue> attributeMap = new HashMap<>(data.size);
for (int i = 0; i < data.size; i++) {
attributeMap.put(data.attributeKeys[i], data.attributeValues[i]);
}
return attributeMap;
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public Annotation createAnnotation(Data data) {
return Annotation.fromDescriptionAndAttributes(ANNOTATION_DESCRIPTION, data.attributeMap);
}
|
java
|
static MetricFamilySamples createMetricFamilySamples(Metric metric, String namespace) {
MetricDescriptor metricDescriptor = metric.getMetricDescriptor();
String name = getNamespacedName(metricDescriptor.getName(), namespace);
Type type = getType(metricDescriptor.getType());
List<String> labelNames = convertToLabelNames(metricDescriptor.getLabelKeys());
List<Sample> samples = Lists.newArrayList();
for (io.opencensus.metrics.export.TimeSeries timeSeries : metric.getTimeSeriesList()) {
for (io.opencensus.metrics.export.Point point : timeSeries.getPoints()) {
samples.addAll(getSamples(name, labelNames, timeSeries.getLabelValues(), point.getValue()));
}
}
return new MetricFamilySamples(name, type, metricDescriptor.getDescription(), samples);
}
|
java
|
static MetricFamilySamples createDescribableMetricFamilySamples(
MetricDescriptor metricDescriptor, String namespace) {
String name = getNamespacedName(metricDescriptor.getName(), namespace);
Type type = getType(metricDescriptor.getType());
List<String> labelNames = convertToLabelNames(metricDescriptor.getLabelKeys());
if (containsDisallowedLeLabelForHistogram(labelNames, type)) {
throw new IllegalStateException(
"Prometheus Histogram cannot have a label named 'le', "
+ "because it is a reserved label for bucket boundaries. "
+ "Please remove this key from your view.");
}
if (containsDisallowedQuantileLabelForSummary(labelNames, type)) {
throw new IllegalStateException(
"Prometheus Summary cannot have a label named 'quantile', "
+ "because it is a reserved label. Please remove this key from your view.");
}
return new MetricFamilySamples(
name, type, metricDescriptor.getDescription(), Collections.<Sample>emptyList());
}
|
java
|
@VisibleForTesting
static List<String> convertToLabelNames(List<LabelKey> labelKeys) {
final List<String> labelNames = new ArrayList<String>(labelKeys.size());
for (LabelKey labelKey : labelKeys) {
labelNames.add(Collector.sanitizeMetricName(labelKey.getKey()));
}
return labelNames;
}
|
java
|
static TraceConfig getCurrentTraceConfig(io.opencensus.trace.config.TraceConfig traceConfig) {
TraceParams traceParams = traceConfig.getActiveTraceParams();
return toTraceConfigProto(traceParams);
}
|
java
|
static TraceParams getUpdatedTraceParams(
UpdatedLibraryConfig config, io.opencensus.trace.config.TraceConfig traceConfig) {
TraceParams currentParams = traceConfig.getActiveTraceParams();
TraceConfig traceConfigProto = config.getConfig();
return fromTraceConfigProto(traceConfigProto, currentParams);
}
|
java
|
@SuppressWarnings("nullness")
public static void createAndRegister(
ElasticsearchTraceConfiguration elasticsearchTraceConfiguration)
throws MalformedURLException {
synchronized (monitor) {
Preconditions.checkState(handler == null, "Elasticsearch exporter already registered.");
Preconditions.checkArgument(
elasticsearchTraceConfiguration != null, "Elasticsearch " + "configuration not set.");
Preconditions.checkArgument(
elasticsearchTraceConfiguration.getElasticsearchIndex() != null,
"Elasticsearch index not specified");
Preconditions.checkArgument(
elasticsearchTraceConfiguration.getElasticsearchType() != null,
"Elasticsearch type not specified");
Preconditions.checkArgument(
elasticsearchTraceConfiguration.getElasticsearchUrl() != null,
"Elasticsearch URL not specified");
handler = new ElasticsearchTraceHandler(elasticsearchTraceConfiguration);
register(Tracing.getExportComponent().getSpanExporter(), handler);
}
}
|
java
|
public boolean isEnabled(String featurePath) {
checkArgument(!Strings.isNullOrEmpty(featurePath));
return config.getConfig(featurePath).getBoolean("enabled");
}
|
java
|
synchronized void sendInitialMessage(Node node) {
io.opencensus.proto.trace.v1.TraceConfig currentTraceConfigProto =
TraceProtoUtils.getCurrentTraceConfig(traceConfig);
// First config must have Node set.
CurrentLibraryConfig firstConfig =
CurrentLibraryConfig.newBuilder().setNode(node).setConfig(currentTraceConfigProto).build();
sendCurrentConfig(firstConfig);
}
|
java
|
private synchronized void sendCurrentConfig() {
// Bouncing back CurrentLibraryConfig to Agent.
io.opencensus.proto.trace.v1.TraceConfig currentTraceConfigProto =
TraceProtoUtils.getCurrentTraceConfig(traceConfig);
CurrentLibraryConfig currentLibraryConfig =
CurrentLibraryConfig.newBuilder().setConfig(currentTraceConfigProto).build();
sendCurrentConfig(currentLibraryConfig);
}
|
java
|
private synchronized void sendCurrentConfig(CurrentLibraryConfig currentLibraryConfig) {
if (isCompleted() || currentConfigObserver == null) {
return;
}
try {
currentConfigObserver.onNext(currentLibraryConfig);
} catch (Exception e) { // Catch client side exceptions.
onComplete(e);
}
}
|
java
|
public static void main(String[] args) throws IOException, InterruptedException {
// Register the view. It is imperative that this step exists,
// otherwise recorded metrics will be dropped and never exported.
View view =
View.create(
Name.create("task_latency_distribution"),
"The distribution of the task latencies.",
LATENCY_MS,
Aggregation.Distribution.create(LATENCY_BOUNDARIES),
Collections.<TagKey>emptyList());
// Create the view manager
ViewManager viewManager = Stats.getViewManager();
// Then finally register the views
viewManager.registerView(view);
// [START setup_exporter]
// Enable OpenCensus exporters to export metrics to Stackdriver Monitoring.
// Exporters use Application Default Credentials to authenticate.
// See https://developers.google.com/identity/protocols/application-default-credentials
// for more details.
StackdriverStatsExporter.createAndRegister();
// [END setup_exporter]
// Record 100 fake latency values between 0 and 5 seconds.
Random rand = new Random();
for (int i = 0; i < 100; i++) {
long ms = (long) (TimeUnit.MILLISECONDS.convert(5, TimeUnit.SECONDS) * rand.nextDouble());
System.out.println(String.format("Latency %d: %d", i, ms));
STATS_RECORDER.newMeasureMap().put(LATENCY_MS, ms).record();
}
// The default export interval is 60 seconds. The thread with the StackdriverStatsExporter must
// live for at least the interval past any metrics that must be collected, or some risk being
// lost if they are recorded after the last export.
System.out.println(
String.format(
"Sleeping %d seconds before shutdown to ensure all records are flushed.",
EXPORT_INTERVAL));
Thread.sleep(TimeUnit.MILLISECONDS.convert(EXPORT_INTERVAL, TimeUnit.SECONDS));
}
|
java
|
synchronized void onExport(ExportTraceServiceRequest request) {
if (isCompleted() || exportRequestObserver == null) {
return;
}
try {
exportRequestObserver.onNext(request);
} catch (Exception e) { // Catch client side exceptions.
onComplete(e);
}
}
|
java
|
public static Duration create(long seconds, int nanos) {
if (seconds < -MAX_SECONDS) {
throw new IllegalArgumentException(
"'seconds' is less than minimum (" + -MAX_SECONDS + "): " + seconds);
}
if (seconds > MAX_SECONDS) {
throw new IllegalArgumentException(
"'seconds' is greater than maximum (" + MAX_SECONDS + "): " + seconds);
}
if (nanos < -MAX_NANOS) {
throw new IllegalArgumentException(
"'nanos' is less than minimum (" + -MAX_NANOS + "): " + nanos);
}
if (nanos > MAX_NANOS) {
throw new IllegalArgumentException(
"'nanos' is greater than maximum (" + MAX_NANOS + "): " + nanos);
}
if ((seconds < 0 && nanos > 0) || (seconds > 0 && nanos < 0)) {
throw new IllegalArgumentException(
"'seconds' and 'nanos' have inconsistent sign: seconds=" + seconds + ", nanos=" + nanos);
}
return new AutoValue_Duration(seconds, nanos);
}
|
java
|
static Node getNodeInfo(String serviceName) {
String jvmName = ManagementFactory.getRuntimeMXBean().getName();
Timestamp censusTimestamp = Timestamp.fromMillis(System.currentTimeMillis());
return Node.newBuilder()
.setIdentifier(getProcessIdentifier(jvmName, censusTimestamp))
.setLibraryInfo(getLibraryInfo(OpenCensusLibraryInformation.VERSION))
.setServiceInfo(getServiceInfo(serviceName))
.build();
}
|
java
|
@VisibleForTesting
static LibraryInfo getLibraryInfo(String currentOcJavaVersion) {
return LibraryInfo.newBuilder()
.setLanguage(Language.JAVA)
.setCoreLibraryVersion(currentOcJavaVersion)
.setExporterVersion(OC_AGENT_EXPORTER_VERSION)
.build();
}
|
java
|
@VisibleForTesting
static ServiceInfo getServiceInfo(String serviceName) {
return ServiceInfo.newBuilder().setName(serviceName).build();
}
|
java
|
public HttpRequestContext handleStart(C carrier, Q request) {
checkNotNull(carrier, "carrier");
checkNotNull(request, "request");
SpanBuilder spanBuilder = null;
String spanName = getSpanName(request, extractor);
// de-serialize the context
SpanContext spanContext = null;
try {
spanContext = textFormat.extract(carrier, getter);
} catch (SpanContextParseException e) {
// TODO: Currently we cannot distinguish between context parse error and missing context.
// Logging would be annoying so we just ignore this error and do not even log a message.
}
if (spanContext == null || publicEndpoint) {
spanBuilder = tracer.spanBuilder(spanName);
} else {
spanBuilder = tracer.spanBuilderWithRemoteParent(spanName, spanContext);
}
Span span = spanBuilder.setSpanKind(Kind.SERVER).startSpan();
if (publicEndpoint && spanContext != null) {
span.addLink(Link.fromSpanContext(spanContext, Type.PARENT_LINKED_SPAN));
}
if (span.getOptions().contains(Options.RECORD_EVENTS)) {
addSpanRequestAttributes(span, request, extractor);
}
return getNewContext(span, tagger.getCurrentTagContext());
}
|
java
|
private Map<String, StatsSnapshot> getStatsSnapshots(boolean isReceived) {
SortedMap<String, StatsSnapshot> map = Maps.newTreeMap(); // Sorted by method name.
if (isReceived) {
getStatsSnapshots(map, SERVER_RPC_CUMULATIVE_VIEWS);
getStatsSnapshots(map, SERVER_RPC_MINUTE_VIEWS);
getStatsSnapshots(map, SERVER_RPC_HOUR_VIEWS);
} else {
getStatsSnapshots(map, CLIENT_RPC_CUMULATIVE_VIEWS);
getStatsSnapshots(map, CLIENT_RPC_MINUTE_VIEWS);
getStatsSnapshots(map, CLIENT_RPC_HOUR_VIEWS);
}
return map;
}
|
java
|
private static double getDurationInSecs(
ViewData.AggregationWindowData.CumulativeData cumulativeData) {
return toDoubleSeconds(cumulativeData.getEnd().subtractTimestamp(cumulativeData.getStart()));
}
|
java
|
public static void main(String[] args) throws InterruptedException {
TagContextBuilder tagContextBuilder =
tagger.currentBuilder().put(FRONTEND_KEY, TagValue.create("mobile-ios9.3.5"));
SpanBuilder spanBuilder =
tracer
.spanBuilder("my.org/ProcessVideo")
.setRecordEvents(true)
.setSampler(Samplers.alwaysSample());
viewManager.registerView(VIDEO_SIZE_VIEW);
LoggingTraceExporter.register();
// Process video.
// Record the processed video size.
try (Scope scopedTags = tagContextBuilder.buildScoped();
Scope scopedSpan = spanBuilder.startScopedSpan()) {
tracer.getCurrentSpan().addAnnotation("Start processing video.");
// Sleep for [0,10] milliseconds to fake work.
Thread.sleep(new Random().nextInt(10) + 1);
statsRecorder.newMeasureMap().put(VIDEO_SIZE, 25 * MiB).record();
tracer.getCurrentSpan().addAnnotation("Finished processing video.");
} catch (Exception e) {
tracer.getCurrentSpan().addAnnotation("Exception thrown when processing video.");
tracer.getCurrentSpan().setStatus(Status.UNKNOWN);
logger.severe(e.getMessage());
}
logger.info("Wait longer than the reporting duration...");
// Wait for a duration longer than reporting duration (5s) to ensure spans are exported.
// TODO(songya): remove the gap once we add a shutdown hook for exporting unflushed spans.
Thread.sleep(5100);
ViewData viewData = viewManager.getView(VIDEO_SIZE_VIEW_NAME);
logger.info(
String.format("Recorded stats for %s:\n %s", VIDEO_SIZE_VIEW_NAME.asString(), viewData));
}
|
java
|
@VisibleForTesting
public static TagKey[] createTagKeys(int size, String name) {
TagKey[] keys = new TagKey[size];
for (int i = 0; i < size; i++) {
keys[i] = TagKey.create(name + i);
}
return keys;
}
|
java
|
@VisibleForTesting
public static TagValue[] createTagValues(int size, String name) {
TagValue[] values = new TagValue[size];
for (int i = 0; i < size; i++) {
values[i] = TagValue.create(name + i);
}
return values;
}
|
java
|
@VisibleForTesting
public static TagContext createTagContext(TagContextBuilder tagsBuilder, int numTags) {
for (int i = 0; i < numTags; i++) {
tagsBuilder.put(TAG_KEYS.get(i), TAG_VALUES.get(i), UNLIMITED_PROPAGATION);
}
return tagsBuilder.build();
}
|
java
|
private static DisruptorEventQueue create() {
// Create new Disruptor for processing. Note that Disruptor creates a single thread per
// consumer (see https://github.com/LMAX-Exchange/disruptor/issues/121 for details);
// this ensures that the event handler can take unsynchronized actions whenever possible.
Disruptor<DisruptorEvent> disruptor =
new Disruptor<>(
DisruptorEventFactory.INSTANCE,
DISRUPTOR_BUFFER_SIZE,
new DaemonThreadFactory("OpenCensus.Disruptor"),
ProducerType.MULTI,
new SleepingWaitStrategy(0, 1000 * 1000));
disruptor.handleEventsWith(new DisruptorEventHandler[] {DisruptorEventHandler.INSTANCE});
disruptor.start();
final RingBuffer<DisruptorEvent> ringBuffer = disruptor.getRingBuffer();
DisruptorEnqueuer enqueuer =
new DisruptorEnqueuer() {
@Override
public void enqueue(Entry entry) {
long sequence = ringBuffer.next();
try {
DisruptorEvent event = ringBuffer.get(sequence);
event.setEntry(entry);
} finally {
ringBuffer.publish(sequence);
}
}
};
return new DisruptorEventQueue(disruptor, enqueuer);
}
|
java
|
@Override
public void shutdown() {
enqueuer =
new DisruptorEnqueuer() {
final AtomicBoolean logged = new AtomicBoolean(false);
@Override
public void enqueue(Entry entry) {
if (!logged.getAndSet(true)) {
logger.log(Level.INFO, "Attempted to enqueue entry after Disruptor shutdown.");
}
}
};
disruptor.shutdown();
}
|
java
|
public final Span getCurrentSpan() {
Span currentSpan = CurrentSpanUtils.getCurrentSpan();
return currentSpan != null ? currentSpan : BlankSpan.INSTANCE;
}
|
java
|
public static void unregister() {
synchronized (monitor) {
checkState(handler != null, "Zipkin exporter is not registered.");
unregister(Tracing.getExportComponent().getSpanExporter());
handler = null;
}
}
|
java
|
@javax.annotation.Nullable
static Span getCurrentSpan() {
SpanContext currentSpanContext = CURRENT_SPAN.get();
return currentSpanContext != null ? currentSpanContext.span : null;
}
|
java
|
static void setCurrentSpan(Span span) {
if (log.isTraceEnabled()) {
log.trace("Setting current span " + span);
}
push(span, /* autoClose= */ false);
}
|
java
|
static void close(SpanFunction spanFunction) {
SpanContext current = CURRENT_SPAN.get();
while (current != null) {
spanFunction.apply(current.span);
current = removeCurrentSpanInternal(current.parent);
if (current == null || !current.autoClose) {
return;
}
}
}
|
java
|
static void push(Span span, boolean autoClose) {
if (isCurrent(span)) {
return;
}
setSpanContextInternal(new SpanContext(span, autoClose));
}
|
java
|
public static void main(String... args) {
// Step 1. Enable OpenCensus Metrics.
try {
setupOpenCensusAndPrometheusExporter();
} catch (IOException e) {
System.err.println("Failed to create and register OpenCensus Prometheus Stats exporter " + e);
return;
}
BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
while (true) {
try {
readEvaluateProcessLine(stdin);
} catch (IOException e) {
System.err.println("EOF bye " + e);
return;
} catch (Exception e) {
recordTaggedStat(KEY_METHOD, "repl", M_ERRORS, new Long(1));
return;
}
}
}
|
java
|
@javax.annotation.Nullable
public String get(String key) {
for (Entry entry : getEntries()) {
if (entry.getKey().equals(key)) {
return entry.getValue();
}
}
return null;
}
|
java
|
private static boolean validateValue(String value) {
if (value.length() > VALUE_MAX_SIZE || value.charAt(value.length() - 1) == ' ' /* '\u0020' */) {
return false;
}
for (int i = 0; i < value.length(); i++) {
char c = value.charAt(i);
if (c == ',' || c == '=' || c < ' ' /* '\u0020' */ || c > '~' /* '\u007E' */) {
return false;
}
}
return true;
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public TagContext timeNestedTagContext(Data data) {
return TagsBenchmarksUtil.createTagContext(
data.tagger.toBuilder(data.baseTagContext), data.numTags);
}
|
java
|
public static void createAndRegister(final String thriftEndpoint, final String serviceName) {
synchronized (monitor) {
checkState(handler == null, "Jaeger exporter is already registered.");
final SpanExporter.Handler newHandler = newHandler(thriftEndpoint, serviceName);
JaegerTraceExporter.handler = newHandler;
register(Tracing.getExportComponent().getSpanExporter(), newHandler);
}
}
|
java
|
public static void createWithSender(final ThriftSender sender, final String serviceName) {
synchronized (monitor) {
checkState(handler == null, "Jaeger exporter is already registered.");
final SpanExporter.Handler newHandler = newHandlerWithSender(sender, serviceName);
JaegerTraceExporter.handler = newHandler;
register(Tracing.getExportComponent().getSpanExporter(), newHandler);
}
}
|
java
|
private static void performWork(Span parent) {
SpanBuilder spanBuilder =
tracer
.spanBuilderWithExplicitParent("internal_work", parent)
.setRecordEvents(true)
.setSampler(Samplers.alwaysSample());
try (Scope scope = spanBuilder.startScopedSpan()) {
Span span = tracer.getCurrentSpan();
span.putAttribute("my_attribute", AttributeValue.stringAttributeValue("blue"));
span.addAnnotation("Performing work.");
sleepFor(20); // Working hard here.
span.addAnnotation("Done work.");
}
}
|
java
|
@SuppressWarnings("deprecation")
private static void emitTraceParamsTable(TraceParams params, PrintWriter out) {
out.write(
"<b class=\"title\">Active tracing parameters:</b><br>\n"
+ "<table class=\"small\" rules=\"all\">\n"
+ " <tr>\n"
+ " <td class=\"col_headR\">Name</td>\n"
+ " <td class=\"col_head\">Value</td>\n"
+ " </tr>\n");
out.printf(
" <tr>%n <td>Sampler</td>%n <td>%s</td>%n </tr>%n",
params.getSampler().getDescription());
out.printf(
" <tr>%n <td>MaxNumberOfAttributes</td>%n <td>%d</td>%n </tr>%n",
params.getMaxNumberOfAttributes());
out.printf(
" <tr>%n <td>MaxNumberOfAnnotations</td>%n <td>%d</td>%n </tr>%n",
params.getMaxNumberOfAnnotations());
out.printf(
" <tr>%n <td>MaxNumberOfNetworkEvents</td>%n <td>%d</td>%n </tr>%n",
params.getMaxNumberOfNetworkEvents());
out.printf(
" <tr>%n <td>MaxNumberOfLinks</td>%n <td>%d</td>%n </tr>%n",
params.getMaxNumberOfLinks());
out.write("</table>\n");
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public Span putAttribute(Data data) {
data.span.putAttribute(ATTRIBUTE_KEY, AttributeValue.stringAttributeValue(ATTRIBUTE_VALUE));
return data.span;
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public Span addAnnotation(Data data) {
data.span.addAnnotation(ANNOTATION_DESCRIPTION);
return data.span;
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public Span addMessageEvent(Data data) {
data.span.addMessageEvent(
io.opencensus.trace.MessageEvent.builder(Type.RECEIVED, 1)
.setUncompressedMessageSize(3)
.build());
return data.span;
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public Span addLink(Data data) {
data.span.addLink(
Link.fromSpanContext(data.linkedSpan.getContext(), Link.Type.PARENT_LINKED_SPAN));
return data.span;
}
|
java
|
static OcAgentMetricsServiceExportRpcHandler create(MetricsServiceStub stub) {
OcAgentMetricsServiceExportRpcHandler exportRpcHandler =
new OcAgentMetricsServiceExportRpcHandler();
ExportResponseObserver exportResponseObserver = new ExportResponseObserver(exportRpcHandler);
try {
StreamObserver<ExportMetricsServiceRequest> exportRequestObserver =
stub.export(exportResponseObserver);
exportRpcHandler.setExportRequestObserver(exportRequestObserver);
} catch (StatusRuntimeException e) {
exportRpcHandler.onComplete(e);
}
return exportRpcHandler;
}
|
java
|
public static Timestamp create(long seconds, int nanos) {
if (seconds < -MAX_SECONDS) {
throw new IllegalArgumentException(
"'seconds' is less than minimum (" + -MAX_SECONDS + "): " + seconds);
}
if (seconds > MAX_SECONDS) {
throw new IllegalArgumentException(
"'seconds' is greater than maximum (" + MAX_SECONDS + "): " + seconds);
}
if (nanos < 0) {
throw new IllegalArgumentException("'nanos' is less than zero: " + nanos);
}
if (nanos > MAX_NANOS) {
throw new IllegalArgumentException(
"'nanos' is greater than maximum (" + MAX_NANOS + "): " + nanos);
}
return new AutoValue_Timestamp(seconds, nanos);
}
|
java
|
public static Timestamp fromMillis(long epochMilli) {
long secs = floorDiv(epochMilli, MILLIS_PER_SECOND);
int mos = (int) floorMod(epochMilli, MILLIS_PER_SECOND);
return create(secs, (int) (mos * NANOS_PER_MILLI)); // Safe int * NANOS_PER_MILLI
}
|
java
|
private Timestamp plus(long secondsToAdd, long nanosToAdd) {
if ((secondsToAdd | nanosToAdd) == 0) {
return this;
}
long epochSec = TimeUtils.checkedAdd(getSeconds(), secondsToAdd);
epochSec = TimeUtils.checkedAdd(epochSec, nanosToAdd / NANOS_PER_SECOND);
nanosToAdd = nanosToAdd % NANOS_PER_SECOND;
long nanoAdjustment = getNanos() + nanosToAdd; // safe int + NANOS_PER_SECOND
return ofEpochSecond(epochSec, nanoAdjustment);
}
|
java
|
private static long floorDiv(long x, long y) {
return BigDecimal.valueOf(x).divide(BigDecimal.valueOf(y), 0, RoundingMode.FLOOR).longValue();
}
|
java
|
private static Map<String, String> initializeAwsIdentityDocument() {
InputStream stream = null;
try {
stream = openStream(AWS_INSTANCE_IDENTITY_DOCUMENT_URI);
String awsIdentityDocument = slurp(new InputStreamReader(stream, Charset.forName("UTF-8")));
return parseAwsIdentityDocument(awsIdentityDocument);
} catch (IOException e) {
// Cannot connect to http://169.254.169.254/latest/dynamic/instance-identity/document.
// Not on an AWS EC2 instance.
} finally {
if (stream != null) {
try {
stream.close();
} catch (IOException e) {
// Do nothing.
}
}
}
return Collections.emptyMap();
}
|
java
|
private static Set<View> filterExportedViews(Collection<View> allViews) {
Set<View> views = Sets.newHashSet();
for (View view : allViews) {
if (view.getWindow() instanceof View.AggregationWindow.Cumulative) {
views.add(view);
}
}
return Collections.unmodifiableSet(views);
}
|
java
|
synchronized void record(TagContext tags, MeasureMapInternal stats, Timestamp timestamp) {
Iterator<Measurement> iterator = stats.iterator();
Map<String, AttachmentValue> attachments = stats.getAttachments();
while (iterator.hasNext()) {
Measurement measurement = iterator.next();
Measure measure = measurement.getMeasure();
if (!measure.equals(registeredMeasures.get(measure.getName()))) {
// unregistered measures will be ignored.
continue;
}
Collection<MutableViewData> viewDataCollection = mutableMap.get(measure.getName());
for (MutableViewData viewData : viewDataCollection) {
viewData.record(
tags, RecordUtils.getDoubleValueFromMeasurement(measurement), timestamp, attachments);
}
}
}
|
java
|
synchronized void clearStats() {
for (Entry<String, Collection<MutableViewData>> entry : mutableMap.asMap().entrySet()) {
for (MutableViewData mutableViewData : entry.getValue()) {
mutableViewData.clearStats();
}
}
}
|
java
|
synchronized void resumeStatsCollection(Timestamp now) {
for (Entry<String, Collection<MutableViewData>> entry : mutableMap.asMap().entrySet()) {
for (MutableViewData mutableViewData : entry.getValue()) {
mutableViewData.resumeStatsCollection(now);
}
}
}
|
java
|
@VisibleForTesting
static ProcessIdentifier getProcessIdentifier(String jvmName, Timestamp censusTimestamp) {
String hostname;
int pid;
// jvmName should be something like '<pid>@<hostname>', at least in Oracle and OpenJdk JVMs
int delimiterIndex = jvmName.indexOf('@');
if (delimiterIndex < 1) {
// Not the expected format, generate a random number.
try {
hostname = InetAddress.getLocalHost().getHostName();
} catch (UnknownHostException e) {
hostname = "localhost";
}
// Generate a random number as the PID.
pid = new SecureRandom().nextInt();
} else {
hostname = jvmName.substring(delimiterIndex + 1, jvmName.length());
try {
pid = Integer.parseInt(jvmName.substring(0, delimiterIndex));
} catch (NumberFormatException e) {
// Generate a random number as the PID if format is unexpected.
pid = new SecureRandom().nextInt();
}
}
return ProcessIdentifier.newBuilder()
.setHostName(hostname)
.setPid(pid)
.setStartTimestamp(MetricsProtoUtils.toTimestampProto(censusTimestamp))
.build();
}
|
java
|
public static void main(String[] args) throws InterruptedException {
configureAlwaysSample(); // Always sample for demo purpose. DO NOT use in production.
registerAllViews();
LongGauge gauge = registerGauge();
String endPoint = getStringOrDefaultFromArgs(args, 0, DEFAULT_ENDPOINT);
registerAgentExporters(endPoint);
try (Scope scope = tracer.spanBuilder("root").startScopedSpan()) {
int iteration = 1;
while (true) {
doWork(iteration, random.nextInt(10), gauge);
iteration++;
Thread.sleep(5000);
}
} catch (InterruptedException e) {
logger.info("Thread interrupted, exiting in 5 seconds.");
Thread.sleep(5000); // Wait 5s so that last batch will be exported.
}
}
|
java
|
public State get() {
InternalState internalState = currentInternalState.get();
while (!internalState.isRead) {
// Slow path, the state is first time read. Change the state only if no other changes
// happened between the moment initialState is read and this moment. This ensures that this
// method only changes the isRead part of the internal state.
currentInternalState.compareAndSet(
internalState,
internalState.state == State.ENABLED
? InternalState.ENABLED_READ
: InternalState.DISABLED_READ);
internalState = currentInternalState.get();
}
return internalState.state;
}
|
java
|
public boolean set(State state) {
while (true) {
InternalState internalState = currentInternalState.get();
checkState(!internalState.isRead, "State was already read, cannot set state.");
if (state == internalState.state) {
return false;
} else {
if (!currentInternalState.compareAndSet(
internalState,
state == State.ENABLED
? InternalState.ENABLED_NOT_READ
: InternalState.DISABLED_NOT_READ)) {
// The state was changed between the moment the internalState was read and this point.
// Some conditions may be not correct, reset at the beginning and recheck all conditions.
continue;
}
return true;
}
}
}
|
java
|
private static int encodeTag(Tag tag, StringBuilder stringBuilder) {
String key = tag.getKey().getName();
String value = tag.getValue().asString();
int charsOfTag = key.length() + value.length();
// This should never happen with our current constraints (<= 255 chars) on tags.
checkArgument(
charsOfTag <= TAG_SERIALIZED_SIZE_LIMIT,
"Serialized size of tag " + tag + " exceeds limit " + TAG_SERIALIZED_SIZE_LIMIT);
// TODO(songy23): do we want to encode TagMetadata?
stringBuilder.append(key).append(TAG_KEY_VALUE_DELIMITER).append(value);
return charsOfTag;
}
|
java
|
private static void decodeTag(String stringTag, Map<TagKey, TagValueWithMetadata> tags) {
String keyWithValue;
int firstPropertyIndex = stringTag.indexOf(TAG_PROPERTIES_DELIMITER);
if (firstPropertyIndex != -1) { // Tag with properties.
keyWithValue = stringTag.substring(0, firstPropertyIndex);
// TODO(songya): support decoding tag properties.
} else { // Tag without properties.
keyWithValue = stringTag;
}
List<String> keyValuePair = TAG_KEY_VALUE_SPLITTER.splitToList(keyWithValue);
checkArgument(keyValuePair.size() == 2, "Malformed tag " + stringTag);
TagKey key = TagKey.create(keyValuePair.get(0).trim());
TagValue value = TagValue.create(keyValuePair.get(1).trim());
TagValueWithMetadata valueWithMetadata =
TagValueWithMetadata.create(value, METADATA_UNLIMITED_PROPAGATION);
tags.put(key, valueWithMetadata);
}
|
java
|
private static void emitSpans(PrintWriter out, Formatter formatter, Collection<SpanData> spans) {
out.write("<pre>\n");
formatter.format("%-23s %18s%n", "When", "Elapsed(s)");
out.write("-------------------------------------------\n");
for (SpanData span : spans) {
tracer
.getCurrentSpan()
.addAnnotation(
"Render span.",
ImmutableMap.<String, AttributeValue>builder()
.put(
"SpanId",
AttributeValue.stringAttributeValue(
BaseEncoding.base16()
.lowerCase()
.encode(span.getContext().getSpanId().getBytes())))
.build());
emitSingleSpan(formatter, span);
}
out.write("</pre>\n");
}
|
java
|
private void emitSummaryTable(PrintWriter out, Formatter formatter)
throws UnsupportedEncodingException {
if (runningSpanStore == null || sampledSpanStore == null) {
return;
}
RunningSpanStore.Summary runningSpanStoreSummary = runningSpanStore.getSummary();
SampledSpanStore.Summary sampledSpanStoreSummary = sampledSpanStore.getSummary();
out.write("<table style='border-spacing: 0;\n");
out.write("border-left:1px solid #3D3D3D;border-right:1px solid #3D3D3D;'>\n");
emitSummaryTableHeader(out, formatter);
Set<String> spanNames = new TreeSet<>(runningSpanStoreSummary.getPerSpanNameSummary().keySet());
spanNames.addAll(sampledSpanStoreSummary.getPerSpanNameSummary().keySet());
boolean zebraColor = true;
for (String spanName : spanNames) {
out.write("<tr class=\"border\">\n");
if (!zebraColor) {
out.write("<tr class=\"border\">\n");
} else {
formatter.format("<tr class=\"border\" style=\"background: %s\">%n", ZEBRA_STRIPE_COLOR);
}
zebraColor = !zebraColor;
formatter.format("<td>%s</td>%n", htmlEscaper().escape(spanName));
// Running
out.write("<td class=\"borderRL\"> </td>");
RunningSpanStore.PerSpanNameSummary runningSpanStorePerSpanNameSummary =
runningSpanStoreSummary.getPerSpanNameSummary().get(spanName);
// subtype ignored for running requests.
emitSingleCell(
out,
formatter,
spanName,
runningSpanStorePerSpanNameSummary == null
? 0
: runningSpanStorePerSpanNameSummary.getNumRunningSpans(),
RequestType.RUNNING,
0);
SampledSpanStore.PerSpanNameSummary sampledSpanStorePerSpanNameSummary =
sampledSpanStoreSummary.getPerSpanNameSummary().get(spanName);
// Latency based samples
out.write("<td class=\"borderLC\"> </td>");
Map<LatencyBucketBoundaries, Integer> latencyBucketsSummaries =
sampledSpanStorePerSpanNameSummary != null
? sampledSpanStorePerSpanNameSummary.getNumbersOfLatencySampledSpans()
: null;
int subtype = 0;
for (LatencyBucketBoundaries latencyBucketsBoundaries : LatencyBucketBoundaries.values()) {
if (latencyBucketsSummaries != null) {
int numSamples =
latencyBucketsSummaries.containsKey(latencyBucketsBoundaries)
? latencyBucketsSummaries.get(latencyBucketsBoundaries)
: 0;
emitSingleCell(out, formatter, spanName, numSamples, RequestType.FINISHED, subtype++);
} else {
// numSamples < -1 means "Not Available".
emitSingleCell(out, formatter, spanName, -1, RequestType.FINISHED, subtype++);
}
}
// Error based samples.
out.write("<td class=\"borderRL\"> </td>");
if (sampledSpanStorePerSpanNameSummary != null) {
Map<CanonicalCode, Integer> errorBucketsSummaries =
sampledSpanStorePerSpanNameSummary.getNumbersOfErrorSampledSpans();
int numErrorSamples = 0;
for (Map.Entry<CanonicalCode, Integer> it : errorBucketsSummaries.entrySet()) {
numErrorSamples += it.getValue();
}
// subtype 0 means all;
emitSingleCell(out, formatter, spanName, numErrorSamples, RequestType.FAILED, 0);
} else {
// numSamples < -1 means "Not Available".
emitSingleCell(out, formatter, spanName, -1, RequestType.FAILED, 0);
}
out.write("</tr>\n");
}
out.write("</table>");
}
|
java
|
public static int getVarInt(byte[] src, int offset, int[] dst) {
int result = 0;
int shift = 0;
int b;
do {
if (shift >= 32) {
// Out of range
throw new IndexOutOfBoundsException("varint too long");
}
// Get 7 bits from next byte
b = src[offset++];
result |= (b & 0x7F) << shift;
shift += 7;
} while ((b & 0x80) != 0);
dst[0] = result;
return offset;
}
|
java
|
public static int getVarInt(ByteBuffer src) {
int tmp;
if ((tmp = src.get()) >= 0) {
return tmp;
}
int result = tmp & 0x7f;
if ((tmp = src.get()) >= 0) {
result |= tmp << 7;
} else {
result |= (tmp & 0x7f) << 7;
if ((tmp = src.get()) >= 0) {
result |= tmp << 14;
} else {
result |= (tmp & 0x7f) << 14;
if ((tmp = src.get()) >= 0) {
result |= tmp << 21;
} else {
result |= (tmp & 0x7f) << 21;
result |= (tmp = src.get()) << 28;
while (tmp < 0) {
// We get into this loop only in the case of overflow.
// By doing this, we can call getVarInt() instead of
// getVarLong() when we only need an int.
tmp = src.get();
}
}
}
}
return result;
}
|
java
|
public static void putVarInt(int v, ByteBuffer sink) {
while (true) {
int bits = v & 0x7f;
v >>>= 7;
if (v == 0) {
sink.put((byte) bits);
return;
}
sink.put((byte) (bits | 0x80));
}
}
|
java
|
public static int getVarInt(InputStream inputStream) throws IOException {
int result = 0;
int shift = 0;
int b;
do {
if (shift >= 32) {
// Out of range
throw new IndexOutOfBoundsException("varint too long");
}
// Get 7 bits from next byte
b = inputStream.read();
result |= (b & 0x7F) << shift;
shift += 7;
} while ((b & 0x80) != 0);
return result;
}
|
java
|
public static void putVarInt(int v, OutputStream outputStream) throws IOException {
byte[] bytes = new byte[varIntSize(v)];
putVarInt(v, bytes, 0);
outputStream.write(bytes);
}
|
java
|
public static long getVarLong(ByteBuffer src) {
long tmp;
if ((tmp = src.get()) >= 0) {
return tmp;
}
long result = tmp & 0x7f;
if ((tmp = src.get()) >= 0) {
result |= tmp << 7;
} else {
result |= (tmp & 0x7f) << 7;
if ((tmp = src.get()) >= 0) {
result |= tmp << 14;
} else {
result |= (tmp & 0x7f) << 14;
if ((tmp = src.get()) >= 0) {
result |= tmp << 21;
} else {
result |= (tmp & 0x7f) << 21;
if ((tmp = src.get()) >= 0) {
result |= tmp << 28;
} else {
result |= (tmp & 0x7f) << 28;
if ((tmp = src.get()) >= 0) {
result |= tmp << 35;
} else {
result |= (tmp & 0x7f) << 35;
if ((tmp = src.get()) >= 0) {
result |= tmp << 42;
} else {
result |= (tmp & 0x7f) << 42;
if ((tmp = src.get()) >= 0) {
result |= tmp << 49;
} else {
result |= (tmp & 0x7f) << 49;
if ((tmp = src.get()) >= 0) {
result |= tmp << 56;
} else {
result |= (tmp & 0x7f) << 56;
result |= ((long) src.get()) << 63;
}
}
}
}
}
}
}
}
return result;
}
|
java
|
public static void putVarLong(long v, ByteBuffer sink) {
while (true) {
int bits = ((int) v) & 0x7f;
v >>>= 7;
if (v == 0) {
sink.put((byte) bits);
return;
}
sink.put((byte) (bits | 0x80));
}
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public Span createRootSpan(Data data) {
Span span =
data.tracer
.spanBuilderWithExplicitParent("RootSpan", null)
.setRecordEvents(data.recorded)
.setSampler(data.sampled ? Samplers.alwaysSample() : Samplers.neverSample())
.startSpan();
span.end();
return span;
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public Link createLink(Data data) {
return Link.fromSpanContext(
SpanContext.create(
TraceId.fromBytes(new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0}),
SpanId.fromBytes(new byte[] {1, 2, 3, 4, 5, 6, 7, 0}),
TraceOptions.DEFAULT,
TRACESTATE_DEFAULT),
Link.Type.PARENT_LINKED_SPAN);
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public MessageEvent createMessageEvent(Data data) {
return MessageEvent.builder(MessageEvent.Type.SENT, MESSAGE_ID).build();
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public Span getCurrentSpan(Data data) {
return data.tracer.getCurrentSpan();
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public byte[] encodeSpanBinary(Data data) {
return data.propagation.getBinaryFormat().toByteArray(data.spanToEncode.getContext());
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public SpanContext decodeSpanBinary(Data data) throws SpanContextParseException {
return data.propagation.getBinaryFormat().fromByteArray(data.spanToDecodeBinary);
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public String encodeSpanText(Data data) {
return encodeSpanContextText(
data.propagation.getTraceContextFormat(), data.spanToEncode.getContext());
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public SpanContext decodeSpanText(Data data) throws SpanContextParseException {
return data.propagation.getTraceContextFormat().extract(data.spanToDecodeText, textGetter);
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public Span setStatus(Data data) {
data.spanToSet.setStatus(STATUS_OK);
return data.spanToSet;
}
|
java
|
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public Span endSpan(Data data) {
data.spanToEnd.end();
return data.spanToEnd;
}
|
java
|
public static void createAndRegisterWithCredentialsAndProjectId(
Credentials credentials, String projectId) throws IOException {
StackdriverTraceExporter.createAndRegister(
StackdriverTraceConfiguration.builder()
.setCredentials(credentials)
.setProjectId(projectId)
.build());
}
|
java
|
public static void createAndRegisterWithProjectId(String projectId) throws IOException {
StackdriverTraceExporter.createAndRegister(
StackdriverTraceConfiguration.builder()
.setCredentials(GoogleCredentials.getApplicationDefault())
.setProjectId(projectId)
.build());
}
|
java
|
static List<DataPoint> adapt(Metric metric) {
MetricDescriptor metricDescriptor = metric.getMetricDescriptor();
MetricType metricType = getType(metricDescriptor.getType());
if (metricType == null) {
return Collections.emptyList();
}
DataPoint.Builder shared = DataPoint.newBuilder();
shared.setMetric(metricDescriptor.getName());
shared.setMetricType(metricType);
ArrayList<DataPoint> datapoints = Lists.newArrayList();
for (TimeSeries timeSeries : metric.getTimeSeriesList()) {
DataPoint.Builder builder = shared.clone();
builder.addAllDimensions(
createDimensions(metricDescriptor.getLabelKeys(), timeSeries.getLabelValues()));
List<Point> points = timeSeries.getPoints();
datapoints.ensureCapacity(datapoints.size() + points.size());
for (Point point : points) {
datapoints.add(builder.setValue(createDatum(point.getValue())).build());
}
}
return datapoints;
}
|
java
|
@SuppressWarnings("unused")
public void setSmtpAuth(String userName, String password) {
setSmtpUsername(userName);
setSmtpPassword(password);
}
|
java
|
private Object readResolve() throws ObjectStreamException {
if (triggerScript != null && secureTriggerScript == null) {
this.secureTriggerScript = new SecureGroovyScript(triggerScript, false, null);
this.secureTriggerScript.configuring(ApprovalContext.create());
triggerScript = null;
}
return this;
}
|
java
|
private String renderTemplate(Run<?, ?> build, FilePath workspace, TaskListener listener, InputStream templateStream)
throws IOException {
String result;
final Map<String, Object> binding = new HashMap<>();
ExtendedEmailPublisherDescriptor descriptor = Jenkins.getActiveInstance().getDescriptorByType(ExtendedEmailPublisherDescriptor.class);
binding.put("build", build);
binding.put("listener", listener);
binding.put("it", new ScriptContentBuildWrapper(build));
binding.put("rooturl", descriptor.getHudsonUrl());
binding.put("project", build.getParent());
binding.put("workspace", workspace);
try {
String text = IOUtils.toString(templateStream);
boolean approvedScript = false;
if (templateStream instanceof UserProvidedContentInputStream && !AbstractEvalContent.isApprovedScript(text, GroovyLanguage.get())) {
approvedScript = false;
ScriptApproval.get().configuring(text, GroovyLanguage.get(), ApprovalContext.create().withItem(build.getParent()));
} else {
approvedScript = true;
}
// we add the binding to the SimpleTemplateEngine instead of the shell
GroovyShell shell = createEngine(descriptor, Collections.<String, Object>emptyMap(), !approvedScript);
SimpleTemplateEngine engine = new SimpleTemplateEngine(shell);
Template tmpl;
synchronized (templateCache) {
Reference<Template> templateR = templateCache.get(text);
tmpl = templateR == null ? null : templateR.get();
if (tmpl == null) {
tmpl = engine.createTemplate(text);
templateCache.put(text, new SoftReference<>(tmpl));
}
}
final Template tmplR = tmpl;
if (approvedScript) {
//The script has been approved by an admin, so run it as is
result = tmplR.make(binding).toString();
} else {
//unapproved script, so run in sandbox
StaticProxyInstanceWhitelist whitelist = new StaticProxyInstanceWhitelist(build, "templates-instances.whitelist");
result = GroovySandbox.runInSandbox(new Callable<String>() {
@Override
public String call() throws Exception {
return tmplR.make(binding).toString(); //TODO there is a PrintWriter instance created in make and bound to out
}
}, new ProxyWhitelist(
Whitelist.all(),
new TaskListenerInstanceWhitelist(listener),
new PrintStreamInstanceWhitelist(listener.getLogger()),
new EmailExtScriptTokenMacroWhitelist(),
whitelist));
}
} catch(Exception e) {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
e.printStackTrace(pw);
result = "Exception raised during template rendering: " + e.getMessage() + "\n\n" + sw.toString();
}
return result;
}
|
java
|
private String executeScript(Run<?, ?> build, FilePath workspace, TaskListener listener, InputStream scriptStream)
throws IOException {
String result = "";
Map binding = new HashMap<>();
ExtendedEmailPublisherDescriptor descriptor = Jenkins.getActiveInstance().getDescriptorByType(ExtendedEmailPublisherDescriptor.class);
Item parent = build.getParent();
binding.put("build", build);
binding.put("it", new ScriptContentBuildWrapper(build));
binding.put("project", parent);
binding.put("rooturl", descriptor.getHudsonUrl());
binding.put("workspace", workspace);
PrintStream logger = listener.getLogger();
binding.put("logger", logger);
String scriptContent = IOUtils.toString(scriptStream, descriptor.getCharset());
if (scriptStream instanceof UserProvidedContentInputStream) {
ScriptApproval.get().configuring(scriptContent, GroovyLanguage.get(), ApprovalContext.create().withItem(parent));
}
if (scriptStream instanceof UserProvidedContentInputStream && !AbstractEvalContent.isApprovedScript(scriptContent, GroovyLanguage.get())) {
//Unapproved script, run it in the sandbox
GroovyShell shell = createEngine(descriptor, binding, true);
Object res = GroovySandbox.run(shell, scriptContent, new ProxyWhitelist(
Whitelist.all(),
new PrintStreamInstanceWhitelist(logger),
new EmailExtScriptTokenMacroWhitelist()
));
if (res != null) {
result = res.toString();
}
} else {
if (scriptStream instanceof UserProvidedContentInputStream) {
ScriptApproval.get().using(scriptContent, GroovyLanguage.get());
}
//Pre approved script, so run as is
GroovyShell shell = createEngine(descriptor, binding, false);
Script script = shell.parse(scriptContent);
Object res = script.run();
if (res != null) {
result = res.toString();
}
}
return result;
}
|
java
|
private void addUpstreamCommittersTriggeringBuild(Run<?, ?> build, Set<InternetAddress> to, Set<InternetAddress> cc, Set<InternetAddress> bcc, EnvVars env, final ExtendedEmailPublisherContext context, RecipientProviderUtilities.IDebug debug) {
debug.send("Adding upstream committer from job %s with build number %s", build.getParent().getDisplayName(), build.getNumber());
List<ChangeLogSet<?>> changeSets = new ArrayList<>();
if(build instanceof AbstractBuild<?,?>) {
AbstractBuild<?,?> b = (AbstractBuild<?,?>)build;
changeSets.add(b.getChangeSet());
} else {
try {
// check for getChangeSets which WorkflowRun has
Method m = build.getClass().getMethod("getChangeSets");
changeSets = (List<ChangeLogSet<? extends ChangeLogSet.Entry>>)m.invoke(build);
} catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
context.getListener().getLogger().print("Could not add upstream committers, build type does not provide change set");
}
}
if(!changeSets.isEmpty()) {
for(ChangeLogSet<? extends ChangeLogSet.Entry> changeSet : changeSets) {
for(ChangeLogSet.Entry change : changeSet) {
addUserFromChangeSet(change, to, cc, bcc, env, context, debug);
}
}
}
}
|
java
|
private void addUserFromChangeSet(ChangeLogSet.Entry change, Set<InternetAddress> to, Set<InternetAddress> cc, Set<InternetAddress> bcc, EnvVars env, final ExtendedEmailPublisherContext context, RecipientProviderUtilities.IDebug debug) {
User user = change.getAuthor();
RecipientProviderUtilities.addUsers(Collections.singleton(user), context, env, to, cc, bcc, debug);
}
|
java
|
private String fetchStyles(Document doc) {
Elements els = doc.select(STYLE_TAG);
StringBuilder styles = new StringBuilder();
for (Element e : els) {
if (e.attr("data-inline").equals("true")) {
styles.append(e.data());
e.remove();
}
}
return styles.toString();
}
|
java
|
public String process(String input) {
Document doc = Jsoup.parse(input);
// check if the user wants to inline the data
Elements elements = doc.getElementsByAttributeValue(DATA_INLINE_ATTR, "true");
if (elements.isEmpty()) {
return input;
}
extractStyles(doc);
applyStyles(doc);
inlineImages(doc);
doc.outputSettings(doc.outputSettings().syntax(Document.OutputSettings.Syntax.xml).prettyPrint(false).escapeMode(Entities.EscapeMode.extended));
return StringEscapeUtils.unescapeHtml(doc.outerHtml());
}
|
java
|
public static String unescapeString(String escapedString) {
StringBuilder sb = new StringBuilder();
for (int i = 1; i < escapedString.length() - 1; ++i) {
char c = escapedString.charAt(i);
if (c == '\\') {
++i;
sb.append(unescapeChar(escapedString.charAt(i)));
} else {
sb.append(c);
}
}
return sb.toString();
}
|
java
|
public static void printf(StringBuffer buf, String formatString, PrintfSpec printfSpec) {
for (int i = 0; i < formatString.length(); ++i) {
char c = formatString.charAt(i);
if ((c == '%') && (i + 1 < formatString.length())) {
++i;
char code = formatString.charAt(i);
if (code == '%') {
buf.append('%');
} else {
boolean handled = printfSpec.printSpec(buf, code);
if (!handled) {
buf.append('%');
buf.append(code);
}
}
} else if ((c == '\\') && (i + 1 < formatString.length())) {
++i;
buf.append(Util.unescapeChar(formatString.charAt(i)));
} else {
buf.append(c);
}
}
}
|
java
|
private ClassLoader expandClasspath(ExtendedEmailPublisherContext context, ClassLoader loader) throws IOException {
List<ClasspathEntry> classpathList = new ArrayList<>();
if (classpath != null && !classpath.isEmpty()) {
transformToClasspathEntries(classpath, context, classpathList);
}
List<GroovyScriptPath> globalClasspath = getDescriptor().getDefaultClasspath();
if (globalClasspath != null && !globalClasspath.isEmpty()) {
transformToClasspathEntries(globalClasspath, context, classpathList);
}
boolean useSecurity = Jenkins.getActiveInstance().isUseSecurity();
if (!classpathList.isEmpty()) {
GroovyClassLoader gloader = new GroovyClassLoader(loader);
gloader.setShouldRecompile(true);
for (ClasspathEntry entry : classpathList) {
if (useSecurity) {
ScriptApproval.get().using(entry);
}
gloader.addURL(entry.getURL());
}
loader = gloader;
}
if (useSecurity) {
return GroovySandbox.createSecureClassLoader(loader);
} else {
return loader;
}
}
|
java
|
protected int getNumFailures(Run<?, ?> build) {
AbstractTestResultAction a = build.getAction(AbstractTestResultAction.class);
if (a instanceof AggregatedTestResultAction) {
int result = 0;
AggregatedTestResultAction action = (AggregatedTestResultAction) a;
for (ChildReport cr : action.getChildReports()) {
if (cr == null || cr.child == null || cr.child.getParent() == null) {
continue;
}
if (cr.child.getParent().equals(build.getParent())) {
if (cr.result instanceof TestResult) {
TestResult tr = (TestResult) cr.result;
result += tr.getFailCount();
}
}
}
if (result == 0 && action.getFailCount() > 0) {
result = action.getFailCount();
}
return result;
}
return a.getFailCount();
}
|
java
|
private Run<?, ?> getPreviousRun(Run<?, ?> build, TaskListener listener) {
Run<?, ?> prevBuild = ExtendedEmailPublisher.getPreviousRun(build, listener);
// Skip ABORTED builds
if (prevBuild != null && prevBuild.getResult() == Result.ABORTED) {
return getPreviousRun(prevBuild, listener);
}
return prevBuild;
}
|
java
|
public static void setDnsCache(long expireMillis, String host, String... ips) {
try {
InetAddressCacheUtil.setInetAddressCache(host, ips, System.currentTimeMillis() + expireMillis);
} catch (Exception e) {
final String message = String.format("Fail to setDnsCache for host %s ip %s expireMillis %s, cause: %s",
host, Arrays.toString(ips), expireMillis, e.toString());
throw new DnsCacheManipulatorException(message, e);
}
}
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.