Comments (15)
opentelemetry/instrumentation-*
mongodb, redis, ioredis, express, hapi etc.
There is a discussion on how to call it: open-telemetry/opentelemetry-specification#30
from opentelemetry-js.
Are transports interestingly different because of the need to propagate context and so are a different group?
Absolutely. To me, transport
sounds more familiar when it comes to HTTP/2 and GRPC protocols. Having said that, I am fine with re-using opentelemetry/instrumentation-[transport]
name.
from opentelemetry-js.
What's the motivation for having a separate opentelemetry/transport-*
package group rather than opentelemetry/instrumentation-[transport]
like opentelementry/instrumentation-http
, etc.? Are transports interestingly different because of the need to propagate context and so are a different group?
I'm fine with it, just wanted to clarify!
from opentelemetry-js.
opentelemetry or opentelemetry/api or opentelemetry/core
It's a bit unclear where the no-op implementations are stored. Should it be a different package or should it be part of this one?
My vote goes to core
if it contains any behavior, or api
if it's only interfaces.
opentelemetry/context-propagation or opentelemetry/context-cls
As discussed in opentracing/opentracing-javascript#112 (comment), this package should be split into multiple different packages.
For example:
- opentelemetry/context-base: The base implementation that doesn't propagate the context but handles things like binding.
- opentelemetry/context-async-listener: Implementation based on @datadog/async-listener for Node <8. If our fixes for promise binding + memory leak + interoperability can be merged back into async-listener then that should be used instead.
- opentelemetry/context-async-hooks: Implementation based on async_hooks for Node >=8.
- opentelemetry/context-zones: Implementation based on Zones for the browser.
My vote goes to context-*
for the various implementations.
opentelemetry/cls-tracer or opentelemetry/automatic-tracer
My vote definitely goes to automatic-tracer
as cls
would be an implementation detail (which would probably be incorrect too).
opentelemetry/propagation-*
Where would the base classes/interfaces go?
opentelemetry/instrumentation-* / opentelemetry/transport-*
As discussed above, separating these may require patching the same module multiple times.
In general, I think the structure looks good with a few changes. The most important part I think will be to ensure that each of them can be used on its own, and have many hooks to allow altering the behavior based on vendor needs. This is one area where both OpenCensus and OpenTracing were lacking, which I think is the main reason that prevented adoption.
from opentelemetry-js.
Since a lot of the packages above could be used for the browser as well, should the name of this repo be changed to something like opentelemetry-js
?
from opentelemetry-js.
opentelemetry/context-propagation or opentelemetry/context-cls
Thinking about this a bit more, I think this could be externalized as an external project since context propagation is a generic cross-cutting concern. Maybe opencontext
?
The benefits would be that users could use this to store anything, so they could use it as a replacement for continuation-local-storage and cls-hooked. The former is no longer supported with new versions of Node and the latter only supports specific versions and has some very difficult to fix issues. None of them support the browser.
I think providing a universal implementation could be beneficial outside the realm of OpenTelemetry.
from opentelemetry-js.
I like the idea of calling this opentelemetry-js
. It will require more complex CI checks since we would want to test out the browser packages in multiple browser and the Node packages on multiple Node versions, but it would enable us to keep everything in sync much better than separate repos.
from opentelemetry-js.
opentelemetry or opentelemetry/api or opentelemetry/core
IMO this package will have api
interfaces and no-op implementations. This might look like this,
opentelemetry/core
|__ trace/
|__ propagation/
|__ samplers/
|__ metrics/
|__ stats/
|__ tags/
|__ propagation/
|__ resources/
|__ utils/
I am in favor of core
, but I think other languages(Java, Python and Go) are going with api
.
from opentelemetry-js.
Would you expect the core
implementation to be Node-specific or would it be shareable with the browser (similar to the OpenTracing tracer)?
The benefit of making it cross-platform would be code sharing, but then we need separate hooks for the platform specific parts. Alternatively, as long as the api
keeps a clean set of types that core
implements, we could have a core-web
that is optimized for the web platform but implements the same interfaces, and then core
could use Node-specific utilities as well.
It seems like with OpenTracing, the API package had shared code but was pretty lean and allowed for plugging it into either Node or web needs (see e.g. https://github.com/elastic/apm-agent-nodejs and https://github.com/elastic/apm-agent-rum-js both of which integrate with OpenTracing)
from opentelemetry-js.
I would try to keep as much code as possible shareable, and add more modules for platform specific code. Then some parent module can compose the correct modules together and register them with each other.
For example, say there is a web-tracer
. It would use automatic-tracer
and register context-zones
on it as the context propagator.
I think this approach could allow more different combinations of modules, even unrelated to the platform. This is just a theory however, so I'd like to know if anyone has used this kind of approach for this use case specifically.
from opentelemetry-js.
@crdgonzalezca is doing some experimental work to build a Zone-based tracer for the browser. You can check out some of his very early stage work here: census-instrumentation/opencensus-web#87
Since we haven't built it yet, I'm not really sure what it will take to make Zone.js do what we want. I like the idea of sharing code between the browser and Node, but I think it will require some discipline to make sure Node-specific stuff doesn't creep in since likely the Node use case will be more fully built out sooner than the web-specific one.
I think we could mitigate this by setting up a web build of the intended-to-be-shared packages very early on with some simple integration test that exercises the webpack compile+build process and makes sure it can get spans correctly in the browser.
from opentelemetry-js.
@crdgonzalezca is doing some experimental work to build a Zone-based tracer for the browser.
There was also some work done for context propagation specifically in https://github.com/opentracing/opentracing-javascript/pull/113/files#diff-e02a2e69cef841e50802298da59382a3
I think we could mitigate this by setting up a web build of the intended-to-be-shared packages very early on with some simple integration test that exercises the webpack compile+build process and makes sure it can get spans correctly in the browser.
I definitely agree with that. Otherwise, the more we wait, the more difficult it will be to support the browser because of things we won't have thought about. In general I find that tests are a lot more difficult to share between Node and the browser than the actual code, but I'm not sure that it's necessary either.
from opentelemetry-js.
As mentioned in the SIG meeting, these are the new package names I would like to advocate.
-
opentelemetry/basic-tracer -> opentelemetry-basic-sdk
By default basic-sdk contains support for all the telemetry signals i.e. tracing, metrics, logs etc. It is possible to have separate packages for each telemetry signal, but currently not covered under default SDKs(basic-sdk and node-sdk) implementation. -
opentelemetry/node-tracer -> opentelemetry-node-sdk
This package should help users/vendors to load specific plugin(s). Mostly applicable for advanced usres. -
opentelemetry-node
This package should load all the provided plugins, we expect most of the applications to use this package.
The rest should stay as it is : opentelemetry-types, opentelemetry-core, opentelemetry-exporter-, opentelemetry-plugin-.
/cc @OlivierAlbertini @vmarchaud @rochdev @hekike @draffensperger @bg451 @markwolff @danielkhan
from opentelemetry-js.
What about having opentelemetry-basic-sdk
just re-export the exported symbols from opentelemetry/basic-tracer
(and perhaps in the future opentelemetry/basic-metrics
and opentelemetry/basic-logs
, etc.)?
That way if someone wants to use e.g. just traces or just metrics as a power user they still can
from opentelemetry-js.
I'm going to close this issue via #408. Do add a comment if you think this is incorrect.
from opentelemetry-js.
Related Issues (20)
- TraceID missed after deployed the project in docker containers
- @opentelemetry/sdk-node changes size when installed from package.json HOT 1
- BatchSpanProcessor doesn't re-enable tracing after flushing HOT 7
- CI Automating of Releases
- @opentelemetry/instrumentation-http should have an option to suppress tracing on ignored outgoing requests
- @opentelemetry/sdk-trace-base - Avoid merging Resource Attributes by default on BasicTracerProvider HOT 2
- use `module.register(...)` in recommended bootstrap code for ESM support HOT 1
- Hook support for adding custom dynamic metric attributes/ dimensions
- OTLPExporterBase causes unhandled rejection on DNS resolution error HOT 2
- Exceptions are not recorded when using auto instrumentation with fetch instrumentation HOT 1
- Can I use auto-instrumentation & manual instrumentation at the same time? HOT 2
- Can ConsoleSpanExporter be used in Prod systems? HOT 2
- [@opentelemetry/instrumentation-http] Default traces have just "GET" as their name HOT 2
- TypeError: Cannot set property Tracer of #<Object> which has only a getter HOT 4
- New Labels Request - `propagator: aws:xray` and `propagator: aws:xray:lambda` HOT 1
- In-Memory Exporter for unit testing HOT 5
- Doomday85
- Widen dependency ranges for related packages for instrumentation
- TraceState does not check max items when calling set() or serialize()
- Empty `context.active()` while using `getNodeAutoInstrumentations`
Recommend Projects
-
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
-
Vue.js
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
-
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
-
TensorFlow
An Open Source Machine Learning Framework for Everyone
-
Django
The Web framework for perfectionists with deadlines.
-
Laravel
A PHP framework for web artisans
-
D3
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
-
Recommend Topics
-
javascript
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
-
web
Some thing interesting about web. New door for the world.
-
server
A server is a program made to process requests and deliver data to clients.
-
Machine learning
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
-
Visualization
Some thing interesting about visualization, use data art
-
Game
Some thing interesting about game, make everyone happy.
Recommend Org
-
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
-
Microsoft
Open source projects and samples from Microsoft.
-
Google
Google ❤️ Open Source for everyone.
-
Alibaba
Alibaba Open Source for everyone
-
D3
Data-Driven Documents codes.
-
Tencent
China tencent open source team.
from opentelemetry-js.