[IA] Update Assisted and Automatic Instrumentation

content/en/docs/automatic/_index.md

@@ -0,0 +1,17 @@
+---
+title: Automatic & Assisted Instrumentation
+aliases: [/docs/zero-code]
+redirects:
+  - { from: /docs/instrumentation/*, to: ':splat' } # Only for `en`
+  - { from: 'net/*', to: 'dotnet/:splat' }
+weight: 260
+---
+
+Besides **code-based** instrumentation using the
+[language-specific APIs and SDKs](/docs/languages/) the OpenTelemetry project
+provides a set of solutions for **automatic** (or **zero-code**) and
+**assisted** instrumentation.
+
+You can learn about the difference between code-based, automatic and assisted instrumentation, and about their
+different use cases on the
+[concept page about Instrumentation](/concepts/instrumentation/).

content/en/docs/automatic/injector.md

@@ -0,0 +1,12 @@
+---
+title: OpenTelemetry Injector
+linkTitle: Injector
+description:
+  Injects OpenTelemetry Auto Instrumentation into applications to capture and
+  report traces, logs and metrics.
+weight: 20
+---
+
+The OpenTelemetry Injector is currently under development. You can learn more
+about it in the
+[opentelemetry-injector repository](https://github.com/open-telemetry/opentelemetry-injector/).

content/en/docs/automatic/languages/_index.md

@@ -0,0 +1,4 @@
+---
+title: Language specific
+weight: 10
+---

content/en/docs/zero-code/dotnet/_index.md → content/en/docs/automatic/languages/dotnet/_index.md

@@ -1,5 +1,5 @@
 ---
-title: .NET zero-code instrumentation
+title: .NET automatic instrumentation
 description: Send traces and metrics from .NET applications and services.
 linkTitle: .NET
 aliases: [net]

content/en/docs/automatic/languages/go/_index.md

@@ -0,0 +1,4 @@
+---
+title: Go automatic and assisted instrumentation
+linkTitle: Go
+---

content/en/docs/automatic/languages/go/automatic.md

@@ -0,0 +1,14 @@
+---
+title: Go automatic instrumentation using eBPF
+linkTitle: Automatic using eBPF
+weight: 16
+alias: [go]
+---
+
+Automatic instrumentation for Go provides a way to instrument any Go application
+and capture telemetry data from many popular libraries and frameworks without
+any code changes.
+
+This project is currently work in progress and you can visit the
+[opentelemetry-go-instrumentation repository](https://github.com/open-telemetry/opentelemetry-go-instrumentation/)
+to learn more.

content/en/docs/zero-code/go.md → content/en/docs/automatic/languages/go/compile-time.md

@@ -1,7 +1,8 @@
 ---
-title: Go zero-code instrumentation
-linkTitle: Go
+title: Go compile-time instrumentation
+linkTitle: Go compile-time
 weight: 16
+alias: [go]
 ---
 
 Zero-code instrumentation for Go provides a way to instrument any Go application

content/en/docs/automatic/languages/java/_index.md

@@ -0,0 +1,16 @@
+---
+title: Java automatic and assisted instrumentation
+linkTitle: Java
+aliases:
+  - /docs/java/automatic_instrumentation
+  - /docs/languages/java/automatic_instrumentation
+cascade:
+  vers:
+    instrumentation: 2.16.0
+    otel: 1.51.0
+---
+
+Common options for automatic and assisted instrumentation with Java are the Java
+agent JAR, Spring Boot Starter, and the Quarkus OpenTelemetry Extension. To
+learn how to manually instrument your service or app code, see
+[Manual instrumentation](/docs/languages/java/instrumentation/).

content/en/docs/zero-code/java/agent/_index.md → content/en/docs/automatic/languages/java/agent/_index.md

@@ -1,6 +1,5 @@
 ---
 title: Java Agent
-linkTitle: Agent
 aliases:
   - /docs/java/automatic_instrumentation
   - /docs/languages/java/automatic_instrumentation

content/en/docs/zero-code/js/_index.md → content/en/docs/automatic/languages/js/_index.md

@@ -1,12 +1,12 @@
 ---
-title: JavaScript zero-code instrumentation
+title: JavaScript automatic instrumentation
 linkTitle: JavaScript
 description:
   Capture telemetry from your application with zero source code modifications
 aliases: [/docs/languages/js/automatic]
 ---
 
-Zero-code instrumentation for JavaScript provides a way to instrument any
+Automatic instrumentation for JavaScript provides a way to instrument any
 Node.js application and capture telemetry data from many popular libraries and
 frameworks without any code changes.
 

content/en/docs/zero-code/php.md → content/en/docs/automatic/languages/php.md

@@ -1,5 +1,5 @@
 ---
-title: PHP zero-code instrumentation
+title: PHP automatic instrumentation
 linkTitle: PHP
 weight: 30
 aliases: [/docs/languages/php/automatic]

content/en/docs/zero-code/python/_index.md → content/en/docs/automatic/languages/python/_index.md

@@ -1,5 +1,5 @@
 ---
-title: Python zero-code instrumentation
+title: Python agent
 linkTitle: Python
 weight: 30
 aliases: [/docs/languages/python/automatic]

content/en/docs/automatic/obi.md

@@ -0,0 +1,12 @@
+---
+title: OpenTelemetry eBPF Instrumentation
+linkTitle: eBPF Instrumentation
+description:
+  A lightweight and efficient way to collect telemetry data using eBPF for
+  user-space applications.
+weight: 30
+---
+
+The OpenTelemetry eBPF Instrumentation, or OBI, is currently under
+development. You can learn more about it in the
+[opentelemetry-ebpf-instrumentation repository](https://github.com/open-telemetry/opentelemetry-ebpf-instrumentation/).

content/en/docs/automatic/platform-specific.md

@@ -0,0 +1,12 @@
+---
+title: Platform specific Automatic & assisted instrumentation
+linkTitle: Platform specific
+weight: 15
+---
+
+OpenTelemetry is available for a variety of platforms and environments, ensuring
+seamless observability in hybrid systems. Solutions for these provide platform
+specific automatic and assisted instrumentation:
+
+- [Injecting Automatic Instrumentation using the OpenTelemetry Operator for Kubernetes](/docs/platforms/kubernetes/operator/automatic/)
+- [Automatically instrument your Lambdas with OpenTelemetry](lambda-auto-instrument/)

content/en/docs/automatic/profiler.md

@@ -0,0 +1,12 @@
+---
+title: OpenTelemetry eBPF Profiler
+linkTitle: Profiler
+description:
+  A whole-system, cross-language profiler for Linux through eBPF, implementing the
+  profiling signal.
+weight: 40
+---
+
+The OpenTelemetry eBPF Profiler is currently under development. You can learn
+more about it in the
+[opentelemetry-ebpf-profiler repository](https://github.com/open-telemetry/opentelemetry-ebpf-profiler/).

content/en/docs/concepts/glossary.md

@@ -360,6 +360,10 @@ Responsible for creating [Spans](#span). See [Tracer].
 
 See [Distributed Tracing](#distributed-tracing).
 
+### Zero-Code Instrumentation
+
+See [Automatic Instrumentation](#automatic-instrumentation).
+
 ### zPages
 
 An in-process alternative to external exporters. When included, they collect and

content/en/docs/concepts/instrumentation/_index.md

@@ -9,24 +9,52 @@ For a system to be [observable], it must be **instrumented**: that is, code from
 the system's components must emit [signals], such as [traces], [metrics], and
 [logs].
 
-Using OpenTelemetry, you can instrument your code in two primary ways:
+Using OpenTelemetry, you can instrument your code in three primary ways:
 
 1. [Code-based solutions](code-based/) via official
    [APIs and SDKs for most languages](/docs/languages/)
-2. [Zero-code solutions](zero-code/)
+2. [Assisted solutions](assisted/)
+3. [Automatic solutions](automatic/) (or **Zero-Code solutions**)
 
 **Code-based** solutions allow you to get deeper insight and rich telemetry from
 your application itself. They let you use the OpenTelemetry API to generate
 telemetry from your application, which acts as an essential complement to the
 telemetry generated by zero-code solutions.
 
-**Zero-code** solutions are great for getting started, or when you can't modify
-the application you need to get telemetry out of. They provide rich telemetry
-from libraries you use and/or the environment your application runs in. Another
-way to think of it is that they provide information about what's happening _at
-the edges_ of your application.
+**Assisted** solutions sit between code-based and automatic solutions. They can
+be provided through language specific convenience packages, or through
+compile-time instrumentations. Different to automatic/zero-code solutions they
+require some configuration or code changes.
 
-You can use both solutions simultaneously.
+**Automatic** (or **Zero-Code**) solutions are great for getting started, or
+when you can't modify the application you need to get telemetry out of. They
+provide rich telemetry from libraries you use and/or the environment your
+application runs in. Another way to think of it is that they provide information
+about what's happening _at the edges_ of your application.
+
+You can use all solutions simultaneously.
+
+{{% alert title="Note" %}}
+
+Which solution is right for you, depends on your role and requirements. While
+**automatic** and **assisted** are great to add Observability to your
+application quickly, they are not able to provide deep code-specific telemetry,
+which can be accomplished with **code-based** instrumentation.
+
+Additionally, there is no clear boundary between the three solutions presented
+above:
+
+- [Language specific implementations of the API & SDK](/docs/languages) often
+  provide convenience functions, which can assist and automate instrumentation
+  for a developer.
+- An [instrumentation library](/docs/concepts/libraries) is a _code-based_
+  instrumentation by the library author, but can be consumed with _zero code
+  changes_ by the consumer of the library.
+- Compile-time instrumentation is _automatic_ in the sense that a developer does
+  not need to touch their code, yet it's different from runtime instrumentation,
+  which can be used by Ops without support from a developer.
+
+{{% /alert %}}
 
 ## Additional OpenTelemetry Benefits
 

content/en/docs/concepts/instrumentation/assisted.md

@@ -0,0 +1,27 @@
+---
+title: Assisted
+description: >-
+  Learn about ways to simplify the process of instrumenting your code.
+weight: 30
+---
+
+Different to
+[Automatic Instrumentation](/docs/concepts/instrumentation/automatic/) an
+**Assisted Instrumentation** requires configuration or code changes, yet they
+provide a convenient way to quickly add OpenTelemetry to your application.
+
+An example for a technology that assists instrumentation are
+[**Instrumentation Libraries**](/docs/concepts/instrumentation/libaries), which
+are added by a developer to their application to extract telemetry from their
+dependencies. By using them, they are no longer required to write a wrapper
+themselves. Although they are an intermediate solution, until the libraries
+provide out of the box support for OpenTelemetry.
+
+Another example are language or framework specific packages, that simplify the
+setup and usage of OpenTelemetry:
+
+- For Spring Boot you can use the **Spring Boot Starter**, which will allow you
+  to instrument **Spring Boot Native images** and has less overhead compared to
+  the Java agent.
+- For Go you can use the **compile-time** instrumentation, which will inject
+  OpenTelemetry instrumentation while your application is built.

content/en/docs/concepts/instrumentation/zero-code/index.md → content/en/docs/concepts/instrumentation/automatic/index.md

@@ -1,10 +1,10 @@
 ---
-title: Zero-code
+title: Automatic
 description: >-
   Learn how to add observability to an application without the need to write
   code
 weight: 10
-aliases: [automatic]
+aliases: [zero-code]
 ---
 
 As [ops](/docs/getting-started/ops/) you might want to add observability to one
@@ -13,25 +13,25 @@ quickly gain some observability for a service without having to use the
 OpenTelemetry API & SDK for
 [code-based instrumentation](/docs/concepts/instrumentation/code-based).
 
-![Zero Code](./zero-code.svg)
+![Automatic Solutions bundle SDK, Instrumentation Libraries and Exporters for you and inject them into the application](./automatic.svg)
 
-Zero-code instrumentation adds the OpenTelemetry API and SDK capabilities to
-your application typically as an agent or agent-like installation. The specific
-mechanisms involved may differ by language, ranging from bytecode manipulation,
-monkey patching, or eBPF to inject calls to the OpenTelemetry API and SDK into
-your application.
+**Automatic instrumentation** (or **Zero-Code Instrumentation**) adds the
+OpenTelemetry API and SDK capabilities to your application typically as an agent
+or agent-like installation. The specific mechanisms involved may differ by
+language, ranging from bytecode manipulation, monkey patching, or eBPF to inject
+calls to the OpenTelemetry API and SDK into your application.
 
-Typically, zero-code instrumentation adds instrumentation for the libraries
+Typically, automatic instrumentation adds instrumentation for the libraries
 you're using. This means that requests and responses, database calls, message
 queue calls, and so forth are what are instrumented. Your application's code,
 however, is not typically instrumented. To instrument your code, you'll need to
 use [code-based instrumentation](/docs/concepts/instrumentation/code-based).
 
-Additionally, zero-code instrumentation lets you configure the
+Additionally, automatic instrumentation lets you configure the
 [Instrumentation Libraries](/docs/concepts/instrumentation/libraries) and
 [exporters](/docs/concepts/components/#exporters) loaded.
 
-You can configure zero-code instrumentation through environment variables and
+You can configure automatic instrumentation through environment variables and
 other language-specific mechanisms, such as system properties or arguments
 passed to initialization methods. To get started, you only need a service name
 configured so that you can identify the service in the observability backend of
@@ -44,11 +44,6 @@ Other configuration options are available, including:
 - Propagator configuration
 - Resource configuration
 
-Automatic instrumentation is available for the following languages:
-
-- [.NET](/docs/zero-code/dotnet/)
-- [Go](/docs/zero-code/go)
-- [Java](/docs/zero-code/java/)
-- [JavaScript](/docs/zero-code/js/)
-- [PHP](/docs/zero-code/php/)
-- [Python](/docs/zero-code/python/)
+The OpenTelemetry project provides Automatic Instrumentation solutions for many
+technologies, you can learn more about these on the page
+[Automatic & Assisted Instrumentation](/automatic)