<code>optional .tensorflow.TraceOpts options = 1;</code>
341734
public org.tensorflow.distruntime.TraceOpts getOptions() {
    return options_ == null ? org.tensorflow.distruntime.TraceOpts.getDefaultInstance() : options_;
  }
805468
@SuppressWarnings("unchecked")
    protected final <O extends AbstractOption<V>, V> Optional<V> get0(AbstractOption<V> option) {
        @SuppressWarnings("rawtypes")
        final AbstractOptionValue<O, V> optionValue =
                (AbstractOptionValue<O, V>) valueMap.get(option);
        return optionValue == null ? Optional.empty() : Optional.of(optionValue.value());
    }
700161
public java.util.List<org.tensorflow.framework.OpDef.ArgDef> getInputArgList() {
    return inputArg_;
  }
948320
private int getStackOffset(@NonNull StackTraceElement[] trace) {
    checkNotNull(trace);

    for (int i = MIN_STACK_OFFSET; i < trace.length; i++) {
      StackTraceElement e = trace[i];
      String name = e.getClassName();
      if (!name.equals(LoggerPrinter.class.getName()) && !name.equals(Logger.class.getName())) {
        return --i;
      }
    }
    return -1;
  }
1211055
static TraceConfig toTraceConfigProto(TraceParams traceParams) {
    TraceConfig.Builder traceConfigProtoBuilder = TraceConfig.newBuilder();
    Sampler librarySampler = traceParams.getSampler();

    if (Samplers.alwaysSample().equals(librarySampler)) {
      traceConfigProtoBuilder.setConstantSampler(
          ConstantSampler.newBuilder().setDecision(ConstantDecision.ALWAYS_ON).build());
    } else if (Samplers.neverSample().equals(librarySampler)) {
      traceConfigProtoBuilder.setConstantSampler(
          ConstantSampler.newBuilder().setDecision(ConstantDecision.ALWAYS_OFF).build());
    } else {
      // TODO: consider exposing the sampling probability of ProbabilitySampler.
      double samplingProbability = parseSamplingProbability(librarySampler);
      traceConfigProtoBuilder.setProbabilitySampler(
          ProbabilitySampler.newBuilder().setSamplingProbability(samplingProbability).build());
    } // TODO: add support for RateLimitingSampler.

    return traceConfigProtoBuilder.build();
  }
17
def trace(fout=None, format=None, byteorder=sys.byteorder, nanosecond=False):
    
    str_check(fout or '', format or '')
    return TraceFlow(fout=fout, format=format, byteorder=byteorder, nanosecond=nanosecond)
1003774
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2861")
  public CallOptions withStreamTracerFactory(ClientStreamTracer.Factory factory) {
    CallOptions newOptions = new CallOptions(this);
    ArrayList<ClientStreamTracer.Factory> newList =
        new ArrayList<>(streamTracerFactories.size() + 1);
    newList.addAll(streamTracerFactories);
    newList.add(factory);
    newOptions.streamTracerFactories = Collections.unmodifiableList(newList);
    return newOptions;
  }
600422
def tracer_config(__init__, app, args, kwargs):
    
    __init__(*args, **kwargs)

    tracing = app.settings.get('opentracing_tracing')
    tracer_callable = app.settings.get('opentracing_tracer_callable')
    tracer_parameters = app.settings.get('opentracing_tracer_parameters', {})

    if tracer_callable is not None:
        if not callable(tracer_callable):
            tracer_callable = _get_callable_from_name(tracer_callable)

        tracer = tracer_callable(**tracer_parameters)
        tracing = TornadoTracing(tracer)

    if tracing is None:
        tracing = TornadoTracing()  # fallback to the global tracer

    app.settings['opentracing_tracing'] = tracing

    tracing._trace_all = app.settings.get('opentracing_trace_all',
                                          DEFAULT_TRACE_ALL)
    tracing._trace_client = app.settings.get('opentracing_trace_client',
                                             DEFAULT_TRACE_CLIENT)
    tracing._start_span_cb = app.settings.get('opentracing_start_span_cb',
                                              None)

    httpclient._set_tracing_enabled(tracing._trace_client)
    if tracing._trace_client:
        httpclient._set_tracing_info(tracing._tracer_obj,
                                     tracing._start_span_cb)
703852
public OpDef getOpDefByTensorflowName(String name) {
        if(!tensorflowOpDescriptors.containsKey(name)) {
            throw new ND4JIllegalStateException("No op found with name " + name);
        }

        return tensorflowOpDescriptors.get(name);
    }
1333022
def trace():
        """"""
        def fget(self):
            return self._options.get('trace', None)

        def fset(self, value):
            self._options['trace'] = value

        return locals()
1195593
function checkOpts(next) {
        /* failsafe */
        if (options === undefined) {
          _log('error', 'no options given to .compile()');
          process.exit();
        }

        /**
         * Have we been given a custom flag for python executable?
         **/
        if (
          options.python !== 'python' &&
          options.python !== '' &&
          options.python !== undefined
        ) {
          if (isWin) {
            isPy = options.python.replace(/\//gm, '\\'); // use windows file paths, batch is sensitive.
          } else {
            isPy = options.python;
          }

          _log('set python as ' + isPy);
        } else {
          isPy = 'python';
        }

        // remove dots
        options.framework = options.framework.replace(/\./g, '');

        // set outter-scope framework variable.
        framework = options.framework;
        _log('framework => ' + framework);

        version = options.nodeVersion; // better framework vc

        // check iojs version
        if (framework === 'iojs' && version === 'latest') {
          _log('fetching iojs versions');
          mkdirp(options.nodeTempDir); // make temp dir, probably repetive.

          // create write stream so we have control over events
          var output = fs.createWriteStream(
            path.join(options.nodeTempDir, 'iojs-versions.json'),
          );

          request.get('https://iojs.org/dist/index.json').pipe(output);

          output.on('close', function() {
            _log('done');
            var f = fs.readFileSync(
              path.join(options.nodeTempDir, 'iojs-versions.json'),
            );
            f = JSON.parse(f);
            version = f[0].version.replace('v', '');

            _log('iojs latest => ' + version);

            // continue down along the async road
            next();
          });
        } else {
          next();
        }
      }
1130869
public org.tensorflow.framework.DebugOptions getDebugOptions() {
    return debugOptions_ == null ? org.tensorflow.framework.DebugOptions.getDefaultInstance() : debugOptions_;
  }
444202
public void setTraces(Trace... traces) {
        if (this.httpClient instanceof DefaultHttpClient) {
            ((DefaultHttpClient)this.httpClient).setTraces(traces);
        }
        else
            throw new UnsupportedOperationException("Invalid operation for class " + this.httpClient.getClass());
    }
974132
def _init_trace(self, n,  color, style,
                    linewidth=2.5, zorder=None, marker=None, markersize=6):
        
        while n >= len(self.traces):
            self.traces.append(LineProperties())
        line = self.traces[n]
        label = "trace %i" % (n+1)
        line.label = label
        line.drawstyle = 'default'
        if zorder     is None:
            zorder = 5 * (n+1)
        line.zorder = zorder
        if color      is not None: line.color = color
        if style      is not None: line.style = style
        if linewidth  is not None: line.linewidth = linewidth
        if marker     is not None: line.marker = marker
        if markersize is not None: line.markersize = markersize
        self.traces[n] = line
1263014
public org.tensorflow.framework.OptimizerOptions getOptimizerOptions() {
    return optimizerOptions_ == null ? org.tensorflow.framework.OptimizerOptions.getDefaultInstance() : optimizerOptions_;
  }
89962
@Override
  public Optional<HttpTracing> build(final Environment environment) {
    if (!isEnabled()) {
      LOGGER.warn("Zipkin tracing is disabled");
      return Optional.empty();
    }

    LOGGER.info("Dropping all collected spans");
    return buildTracing(environment, Reporter.NOOP);
  }
162088
public org.tensorflow.framework.TensorInfo getOutputsOrDefault(
      java.lang.String key,
      org.tensorflow.framework.TensorInfo defaultValue) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    java.util.Map<java.lang.String, org.tensorflow.framework.TensorInfo> map =
        internalGetOutputs().getMap();
    return map.containsKey(key) ? map.get(key) : defaultValue;
  }