úÎ!ŅČš      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™NoneTtracing-controlA span's sampling decision.tracing-controlA part of a trace. tracing-controlMetadata attached to a span. tracing-controlA relationship between spans.ĘThere are currently two types of references, both of which model direct causal relationships between a child and a parent. More background on references is available in the opentracing specification:  Ihttps://github.com/opentracing/specification/blob/master/specification.md. tracing-control – references imply that the parent span depends on the child span in some capacity. Note that this reference type is only valid within a single trace. tracing-control5If the parent does not depend on the child, we use a   reference.tracing-controlnA fully qualified span identifier, containing both the ID of the trace the span belongs to and the span's ID.tracing-controlA 64-bit span identifier.tracing-controlA 128-bit trace identifier.tracing-controlThe type of annotations' keys.JKeys starting with double underscores are reserved and should not be used.tracing-controlThe name of a span.tracing-controlHex-encodes a trace ID.tracing-control.Decodes a traced ID from a hex-encoded string.štracing-controlGenerates a random trace ID.tracing-controlHex-encodes a span ID.tracing-control,Decodes a span ID from a hex-encoded string.›tracing-controlGenerates a random span ID.tracing-control$Returns whether the span is sampled.tracing-control+Returns whether the span has debug enabled.# œ š›None8HV_kRĖtracing-control4An action to determine how a span should be sampled. tracing-controlA span builder.  has an ž› instance, producing a span with the given string as name, no additional references, tags, or baggages. This allows convenient creation of spans via the OverloadedStrings pragma."tracing-controlName of the generated span.#tracing-controlˆThe trace ID of the generated span. If unset, the active span's trace ID will be used if present, otherwise a new ID will be generated.$tracing-controlFThe ID of the generated span, otherwise the ID will be auto-generated.%tracing-controlSpan references.&tracing-controlInitial set of tags.'tracing-controlSpan context baggages.(tracing-control†How the span should be sampled. If unset, the active's span sampling will be used if present, otherwise the span will not be sampled.)tracing-control8A monad capable of generating and modifying trace spans.<This package currently provides two instances of this class:&, which emits spans for each trace in Ÿ( and is meant to be used in production. f, where tracing is a no-op and allows testing traced functions without any overhead or complex setup.*tracing-control]Trace an action, wrapping it inside a new span. If the action isn't currently being traced, *• should be a no-op. Otherwise, the new span should share the active span's trace ID, sampling decision, and baggages unless overridden by the input  .+tracing-control'Extracts the currently active span, or Ą# if the action is not being traced.,tracing-control0Adds information to the active span, if present.-tracing-control Returns a  9 with the given input as name and all other fields empty..tracing-control Returns a  which always samples./tracing-control Returns a  which never samples.0tracing-controlReturns a debug !. Debug spans are always sampled.1tracing-control Returns a ' which samples a span iff the input is Ē. It is equivalent to: 9sampledWhen b = if b then alwaysSampled else neverSampled2tracing-control Returns a  which randomly samples spans.3tracing-controlŒStarts a new trace, customizing the span builder. Note that the sampling input will override any sampling customization set on the builder.4tracing-controlĸStarts a new trace. For performance reasons, it is possible to customize how frequently tracing information is collected. This allows fine-grain control on the overhead induced by tracing. For example, you might only want to sample 1% of a very actively used call-path with sampledWithProbability 0.01.5tracing-controlExtends a trace, same as 6" but also customizing the builder.6tracing-controlŸExtends a trace: the active span's ID will be added as a reference to a newly created span and both spans will share the same trace ID. If no span is active, 6 is a no-op.7tracing-control$Generates a tag value from a double.8tracing-control6Generates a 64-bit integer tag value from any integer.9tracing-control#Generates a Unicode text tag value.:tracing-controlĒGenerates a log value with the time of writing as timestamp. Note that the value may be written later than it is created. For more control on the timestamp, use ;.;tracing-control)Generates a log value with a custom time.<  !"#$%&'()*+,-./0123456789:;<  )*+, !"#$%&'(-4365./210 789:;None/=?@AHMSTVX_kk’Ftracing-controlA span generation monad.Itracing-control A tracer is a producer of spans.More specifically, a tracer:runs ) actions via V,-transparently collects their generated spans,-and outputs them to a channel (available via U).oThese samples can then be consumed independently, decoupling downstream span processing from their production.Jtracing-control+A sampled span and its associated metadata.Ltracing-controlThe sampled span.Mtracing-control Tags collected during this span.Ntracing-control?Logs collected during this span, sorted in chronological order.Otracing-controlThe time the span started at.Ptracing-controlThe span's duration.Qtracing-controlA collection of span logs.Rtracing-controlA collection of span tags.Stracing-controlCreates a new I.Ttracing-controlPReturns the number of spans currently in flight (started but not yet completed).Utracing-controloReturns all newly completed spans' samples. The samples become available in the same order they are completed.Vtracing-control‚Trace an action, sampling its generated spans. This method is thread-safe and can be used to trace multiple actions concurrently.·Unless you are implementing a custom span publication backend, you should not need to call this method explicitly. Instead, prefer to use the backend's functionality directly (e.g. 3 for Zipkin). To ease debugging in certain cases,  is also available.FGHIJKLMNOPQRSTUVISVFGHUJKLMNOPRQTNone>w€ctracing-controlRuns a FĻ action, returning any collected samples alongside its output. The samples are sorted chronologically by completion time (e.g. the head is the first span to complete).·Spans which start before the action returns are guaranteed to be collected, even if they complete after (in this case collection will block until their completion). More precisely, c^ will return the first time there are no pending spans after the action is done. For example: îcollectSpanSamples $ rootSpan alwaysSampled "parent" $ do forkIO $ childSpan "child" $ threadDelay 2000000 -- Asynchronous 2 second child span. threadDelay 1000000 -- Returns after one second, but the child span will still be sampled.ccNone>MP_kÆ<*dtracing-controlSInformation about a hosted service, included in spans and visible in the Zipkin UI.ftracing-controlThe endpoint's service name.gtracing-control-The endpoint's port, if applicable and known.htracing-controlThe endpoint's IPv4 address.itracing-controlThe endpoint's IPv6 address.jtracing-control<Exportable trace information, used for cross-process traces.ltracing-controlThe span's trace ID.mtracing-controlThe span's ID.ntracing-controlWhether the span was sampled.otracing-controlLWhether the span has debug enabled (which implies that the span is sampled).ptracing-controlThe span's parent's ID, or Ą for root spans.qtracing-controlA Zipkin trace publisher.HAll publisher functionality is thread-safe. In particular it is safe to | concurrently with { , and/or {r multiple actions concurrently. Note also that all sampled spans are retained in memory until they are published.rtracing-controlq creation settings.ttracing-control*The Zipkin server's hostname, defaults to  localhost if unset.utracing-control8The port the Zipkin server is listening on, defaults to 9411 if unset.vtracing-control/Local endpoint included in all published spans.wtracing-controlJAn optional HTTP manager to use for publishing spans on the Zipkin server.xtracing-controlWIf set to a positive value, traces will be flushed in the background every such period.ytracing-controlCreates empty r&. You will typically use this (or the žH instance) as starting point to only fill in the fields you care about: ;let settings = defaultSettings { settingsPort = Just 2222 }ztracing-control Creates a q publisher for the input r.{tracing-controlRuns a Fw action, sampling spans appropriately. Note that this method does not publish spans on its own; to do so, either call |! manually or specify a positive x to publish in the background.|tracing-control0Flushes all complete spans to the Zipkin server.}tracing-controlConvenience method to start a q8, run an action, and publish all spans before returning.~tracing-controlAdds a tag to the active span.tracing-controlBAdds a tag to a builder. This is a convenience method to use with 5, for example: 3childSpanWith (addTag "key" "value") "run" $ actionjNote that there is not difference with adding the tag after the span. So the above code is equivalent to: -childSpan "run" $ tag "key" "value" >> action€tracing-control;Adds an inherited tag to a builder. Unlike a tag added via  , this tag:$will be inherited by all the span's local children.,can only be added at span construction time.:For example, to add an ID tag to all spans inside a trace: KrootSpanWith (addInheritedTag "id" "abcd-efg") alwaysSampled "run" $ actiontracing-control1Annotates the active span using the current time.‚tracing-control,Annotates the active span at the given time.ƒtracing-controlSerializes the jV to multiple headers, suitable for HTTP requests. All byte-strings are UTF-8 encoded.„tracing-controlDeserializes the j from multiple headers.…tracing-controlSerializes the jF to a single UTF-8 encoded header value. It will typically be set as  Ghttps://github.com/apache/incubator-zipkin-b3-propagation#single-header b3 header.†tracing-control*Deserializes a single header value into a j.‡tracing-controlGenerates a child span with CLIENT5 kind. This function also provides the corresponding j (or Ą› if tracing is inactive) so that it can be forwarded to the server. For example, to emit an HTTP request and forward the trace information in the headers: Æimport Network.HTTP.Simple clientSpan "api-call" $ \(Just b3) -> $ do res <- httpBS "http://host/api" & addRequestHeader "b3" (b3ToHeaderValue b3) process res -- Do something with the response.ˆtracing-controljGenerates a client span, optionally modifying the span's builder. This can be useful in combination with Ž4 if the remote server does not have tracing enabled.‰tracing-controlGenerates a child span with PRODUCER5 kind. This function also provides the corresponding j. so that it can be forwarded to the consumer.Štracing-controlGenerates a child span with SERVER kind. The client's j8 should be provided as input, for example parsed using „.‹tracing-controljGenerates a server span, optionally modifying the span's builder. This can be useful in combination with Ž4 if the remote client does not have tracing enabled.Œtracing-controlGenerates a child span with CONSUMER kind. The producer's j should be provided as input.tracing-controlAn empty endpoint.Žtracing-controlĸAdds a remote endpoint to a builder. This is mostly useful when generating cross-process spans where the remote endpoint is not already traced (otherwise Zipkin will associate the spans correctly automatically). For example when emitting a request to an outside server: 1clientSpanWith (addEndpoint "outside-api") -- ...tracing-control7Generates an endpoint with the given string as service.‘tracing-control5Generates settings with the given string as hostname.+defghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ+rstuvwxydefghiqz{|}jklmnopƒ„…†‡ˆŠ‹‰Œ~€‚Ž NoneĮĘ )./01246q )4./1206qĢ     !"#$%&&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMMNOPQRSTUVWXYZ[\]^_`abcdeefghijjklmnopqqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ›ĄĒ›ĢĪžŸĨĶ,tracing-control-0.0.6-559z8xT3PIa7ObhaiJnGi2Control.Monad.Trace.ClassControl.Monad.TraceMonitor.Tracing.LocalMonitor.Tracing.ZipkinControl.Monad.Trace.InternalTraceTruncollectSpanSamplesMonitor.TracingSamplingDecisionAlwaysNeverDebugSpanspanName spanContextspanReferencesspanSamplingDecisionValue ReferenceChildOf FollowsFromContextcontextTraceID contextSpanIDcontextBaggagesSpanIDTraceIDKeyName encodeTraceID decodeTraceID encodeSpanID decodeSpanID spanIsSampled spanIsDebugSamplingPolicyBuilder builderNamebuilderTraceID builderSpanIDbuilderReferences builderTagsbuilderBaggagesbuilderSamplingPolicy MonadTracetrace activeSpan addSpanEntrybuilder alwaysSampled neverSampled debugEnabled sampledWhensampledWithProbability rootSpanWithrootSpan childSpanWith childSpantagDoubleValue tagInt64Value tagTextValuelogValue logValueAt$fIsStringBuilder$fMonadTraceIdentity$fMonadTraceWriterT$fMonadTraceWriterT0$fMonadTraceStateT$fMonadTraceStateT0$fMonadTraceRWST$fMonadTraceRWST0$fMonadTraceReaderT$fMonadTraceExceptT traceTReaderTracerSample sampleSpan sampleTags sampleLogs sampleStartsampleDurationLogsTags newTracerpendingSpanCount spanSamples runTraceT$fMonadTraceTraceT$fMonadBaseControlbTraceT$fMonadReaderrTraceT$fFunctorTraceT$fApplicativeTraceT $fMonadTraceT$fMonadTransTraceT$fMonadWriterTraceT$fMonadStateTraceT$fMonadErrorTraceT$fMonadIOTraceT$fMonadBaseTraceTEndpointendpointService endpointPort endpointIPv4 endpointIPv6B3 b3TraceIDb3SpanID b3IsSampled b3IsDebugb3ParentSpanIDZipkinSettingssettingsHostname settingsPortsettingsEndpointsettingsManagersettingsPublishPerioddefaultSettingsnewpublishwithtagaddTagaddInheritedTagannotate annotateAt b3ToHeaders b3FromHeadersb3ToHeaderValueb3FromHeaderValue clientSpanclientSpanWithproducerSpanWith serverSpanserverSpanWithconsumerSpanWithdefaultEndpoint addEndpoint$fToJSONEndpoint$fIsStringEndpoint$fIsStringSettings$fToJSONZipkinAnnotation$fToJSONZipkinSpan$fEqB3$fOrdB3$fShowB3 $fEqEndpoint $fOrdEndpoint$fShowEndpoint randomTraceID randomSpanIDTagValueLogValuebase Data.StringIsStringghc-prim GHC.TypesIOData.Functor.IdentityIdentity GHC.MaybeNothingTrue