[Cloud Run] Split up In-Process docs

content/en/serverless/google_cloud_run/containers.md → content/en/serverless/google_cloud_run/containers/_index.md

@@ -1,16 +1,16 @@
 ---
-title: Choosing an Instrumentation Method for Google Cloud Run Containers
+title: Choosing an Instrumentation Method for Containers
 further_reading:
   - link: "/integrations/google-cloud-run/"
     tag: "Documentation"
     text: "Google Cloud Run Integration"
   - link: 'https://www.datadoghq.com/blog/collect-traces-logs-from-cloud-run-with-datadog/'
     tag: 'Blog'
     text: 'Collect traces, logs, and custom metrics from Cloud Run services'
-  - link: "/serverless/google_cloud_run/containers_in_process/"
+  - link: "/serverless/google_cloud_run/containers/in_process/"
     tag: 'Documentation'
     text: 'Instrument your container with the in-process approach'
-  - link: "/serverless/google_cloud_run/containers_sidecar/"
+  - link: "/serverless/google_cloud_run/containers/sidecar/"
     tag: 'Documentation'
     text: 'Instrument your container with the sidecar approach'
 ---
@@ -19,7 +19,7 @@ To instrument your Google Cloud Run containers with Datadog, choose one of two o
 
 {{% google-cloud-run-container-options %}}
 
-- [**In-process**][1]: Wraps your application container with the Datadog Agent. Choose this option for a simpler setup, lower cost overhead, and direct log piping. 
+- [**In-process**][1]: Wraps your application container with the Datadog Agent. Choose this option for a simpler setup, lower cost overhead, and direct log piping.
 - [**Sidecar**][2]: Deploys the Datadog Agent in a separate container alongside your app container. Choose this option if you have multiple containers in a single service, if you prefer strict isolation of the Datadog Agent, or if you have performance-sensitive workloads.
 
 ## Comparison: in-process versus sidecar instrumentation
@@ -38,5 +38,5 @@ To instrument your Google Cloud Run containers with Datadog, choose one of two o
 
 {{< partial name="whats-next/whats-next.html" >}}
 
-[1]: /serverless/google_cloud_run/containers_in_process
-[2]: /serverless/google_cloud_run/containers_sidecar
+[1]: /serverless/google_cloud_run/containers/in_process
+[2]: /serverless/google_cloud_run/containers/sidecar

content/en/serverless/google_cloud_run/containers/in_process/_index.md

@@ -0,0 +1,14 @@
+---
+title: In-Process Instrumentation
+type: multi-code-lang
+aliases:
+  - /serverless/google_cloud_run/containers_in_process/
+---
+
+First, set up the **[Google Cloud Integration][1]** to collect metrics and logs from Google Cloud services. Remember to add the `cloud asset viewer` role to your service account and enable the Cloud Asset Inventory API in Google Cloud.
+
+Then, instrument your application using one of the following guides:
+
+{{< partial name="serverless/in-process-languages.html" >}}
+
+[1]: /integrations/google-cloud-platform/

content/en/serverless/google_cloud_run/containers/in_process/dotnet.md

@@ -0,0 +1,80 @@
+---
+title: Instrumenting a .NET Cloud Run Container In-Process
+code_lang: dotnet
+type: multi-code-lang
+code_lang_weight: 50
+further_reading:
+  - link: '/tracing/trace_collection/automatic_instrumentation/dd_libraries/dotnet-core/?tab=linux'
+    tag: 'Documentation'
+    text: 'Tracing .NET Core Applications'
+  - link: '/tracing/other_telemetry/connect_logs_and_traces/dotnet/'
+    tag: 'Documentation'
+    text: 'Correlating .NET Logs and Traces'
+---
+
+## Setup
+1. **Install the Datadog .NET tracer** in your Dockerfile.
+
+   Because GitHub requests are rate limited, you must pass a GitHub token saved in the environment variable `GITHUB_TOKEN` as a [Docker build secret][1] `--secret id=github-token,env=GITHUB_TOKEN`.
+
+   {{< tabs >}}
+   {{% tab "Linux/AMD64" %}}
+{{< code-block lang="dockerfile" filename="Dockerfile" disable_copy="false" collapsible="true" >}}
+RUN --mount=type=secret,id=github-token,env=GITHUB_TOKEN \
+    chmod +x /app/dotnet.sh && /app/dotnet.sh
+{{< /code-block >}}
+   {{% /tab %}}
+
+   {{% tab "Alpine" %}}
+{{< code-block lang="dockerfile" filename="Dockerfile" disable_copy="false" collapsible="true" >}}
+# For alpine use datadog-dotnet-apm-2.57.0-musl.tar.gz
+ARG TRACER_VERSION
+ADD https://github.com/DataDog/dd-trace-dotnet/releases/download/v${TRACER_VERSION}/datadog-dotnet-apm-${TRACER_VERSION}.tar.gz /tmp/datadog-dotnet-apm.tar.gz
+
+RUN mkdir -p /dd_tracer/dotnet/ && tar -xzvf /tmp/datadog-dotnet-apm.tar.gz -C /dd_tracer/dotnet/ && rm /tmp/datadog-dotnet-apm.tar.gz
+{{< /code-block >}}
+   {{% /tab %}}
+   {{< /tabs >}}
+
+   For more information, see [Tracing .NET applications][2].
+
+2. **Install serverless-init**.
+
+   {{% gcr-install-serverless-init cmd="\"dotnet\", \"dotnet.dll\"" %}}
+
+3. **Set up logs**.
+
+   To enable logging, set the environment variable `DD_LOGS_ENABLED=true`. This allows `serverless-init` to read logs from stdout and stderr.
+
+   Datadog also recommends setting the environment variable `DD_SOURCE=csharp` to enable advanced Datadog log parsing.
+
+   If you want multiline logs to be preserved in a single log message, Datadog recommends writing your logs in JSON format. For example, you can use a third-party logging library such as `Serilog`:
+
+   {{< code-block lang="csharp" disable_copy="false" >}}
+using Serilog;
+
+builder.Host.UseSerilog((context, config) =>
+{
+    config.WriteTo.Console(new Serilog.Formatting.Json.JsonFormatter(renderMessage: true));
+});
+
+logger.LogInformation("Hello World!");
+{{< /code-block >}}
+
+   For more information, see [Correlating .NET Logs and Traces][3].
+
+4. **Configure your application**.
+
+{{% gcr-configure-env-vars language="csharp" %}}
+
+## Troubleshooting
+
+{{% gcr-troubleshooting %}}
+
+## Further reading
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: https://docs.docker.com/build/building/secrets/
+[2]: /tracing/trace_collection/automatic_instrumentation/dd_libraries/dotnet-core/?tab=linux
+[3]: /tracing/other_telemetry/connect_logs_and_traces/dotnet/

content/en/serverless/google_cloud_run/containers/in_process/go.md

@@ -0,0 +1,75 @@
+---
+title: Instrumenting a Go Cloud Run Container In-Process
+code_lang: go
+type: multi-code-lang
+code_lang_weight: 30
+further_reading:
+  - link: '/tracing/trace_collection/automatic_instrumentation/dd_libraries/go/'
+    tag: 'Documentation'
+    text: 'Tracing Go Applications'
+  - link: '/tracing/other_telemetry/connect_logs_and_traces/go/'
+    tag: 'Documentation'
+    text: 'Correlating Go Logs and Traces'
+---
+
+## Setup
+1. **Install the Datadog Go tracer**.
+
+   1. In your main application, add the tracing library from `dd-trace-go`.
+
+      {{< code-block lang="shell" disable_copy="false" >}}
+go get github.com/DataDog/dd-trace-go/v2/ddtrace/tracer
+{{< /code-block >}}
+
+   2. Add the following to your application code to initialize the tracer:
+      {{< code-block lang="go" disable_copy="false" >}}
+tracer.Start()
+defer tracer.Stop()
+{{< /code-block >}}
+
+   You can also add additional packages:
+   {{< code-block lang="shell" disable_copy="false" >}}
+# Enable Profiling
+go get github.com/DataDog/dd-trace-go/v2/profiler
+
+# Patch /net/http
+go get github.com/DataDog/dd-trace-go/contrib/net/http/v2
+{{< /code-block >}}
+
+   For more information, see [Tracing Go Applications][1] and the [Tracer README][2].
+
+2. **Install serverless-init**.
+
+   {{% gcr-install-serverless-init cmd="./your-binary" %}}
+
+3. **Set up logs**.
+
+   To enable logging, set the environment variable `DD_LOGS_ENABLED=true`. This allows `serverless-init` to read logs from stdout and stderr.
+
+   Datadog also recommends setting the environment variable `DD_SOURCE=go` to enable advanced Datadog log parsing.
+
+   If you want multiline logs to be preserved in a single log message, Datadog recommends writing your logs in JSON format. For example, you can use a third-party logging library such as `logrus`:
+   ```go
+   logrus.SetFormatter(&logrus.JSONFormatter{})
+   logrus.AddHook(&dd_logrus.DDContextLogHook{})
+
+   logrus.WithContext(ctx).Info("Hello World!")
+   ```
+
+   For more information, see [Correlating Go Logs and Traces][3].
+
+4. **Configure your application**.
+
+{{% gcr-configure-env-vars language="go" %}}
+
+## Troubleshooting
+
+{{% gcr-troubleshooting %}}
+
+## Further reading
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: /tracing/trace_collection/automatic_instrumentation/dd_libraries/go/
+[2]: https://github.com/DataDog/dd-trace-go?tab=readme-ov-file#installing
+[3]: /tracing/other_telemetry/connect_logs_and_traces/go/

content/en/serverless/google_cloud_run/containers/in_process/java.md

@@ -0,0 +1,89 @@
+---
+title: Instrumenting a Java Cloud Run Container In-Process
+code_lang: java
+type: multi-code-lang
+code_lang_weight: 40
+further_reading:
+  - link: '/tracing/trace_collection/automatic_instrumentation/dd_libraries/java/'
+    tag: 'Documentation'
+    text: 'Tracing Java Applications'
+  - link: '/tracing/other_telemetry/connect_logs_and_traces/java/'
+    tag: 'Documentation'
+    text: 'Correlating Java Logs and Traces'
+---
+
+## Setup
+1. **Install the Datadog Java tracer**.
+
+   1. Add the Datadog Java tracer to your Dockerfile:
+
+      {{< code-block lang="dockerfile" filename="Dockerfile" disable_copy="false" collapsible="true" >}}
+ADD 'https://dtdg.co/latest-java-tracer' agent.jar
+ENV JAVA_TOOL_OPTIONS="-javaagent:agent.jar"
+{{< /code-block >}}
+
+   2. Add the tracer artifacts.
+      {{< tabs >}}
+      {{% tab "Maven" %}}
+{{< code-block lang="xml" disable_copy="false" >}}
+<dependency>
+  <groupId>com.datadoghq</groupId>
+  <artifactId>dd-trace-api</artifactId>
+  <version>DD_TRACE_JAVA_VERSION_HERE</version>
+</dependency>
+{{< /code-block >}}
+      {{% /tab %}}
+
+      {{% tab "Gradle" %}}
+{{< code-block lang="groovy" disable_copy="false" >}}
+implementation 'com.datadoghq:dd-trace-api:DD_TRACE_JAVA_VERSION_HERE'
+{{< /code-block >}}
+      {{% /tab %}}
+      {{< /tabs >}}
+
+   3. Add the `@Trace` annotation to any method you want to trace.
+
+   For more information, see [Tracing Java Applications][1].
+
+2. **Install serverless-init**.
+
+   {{% gcr-install-serverless-init cmd="\"./mvnw\", \"spring-boot:run\"" %}}
+
+3. **Set up logs**.
+
+   To enable logging, set the environment variable `DD_LOGS_ENABLED=true`. This allows `serverless-init` to read logs from stdout and stderr.
+
+   Datadog also recommends setting the environment variable `DD_SOURCE=java` to enable advanced Datadog log parsing.
+
+   If you want multiline logs to be preserved in a single log message, Datadog recommends writing your logs in *compact* JSON format. For example, you can use a third-party logging library such as `Log4j 2`:
+
+   {{< code-block lang="java" disable_copy="false" >}}
+private static final Logger logger = LogManager.getLogger(App.class);
+logger.info("Hello World!");
+{{< /code-block >}}
+
+   {{< code-block lang="xml" filename="resources/log4j2.xml" disable_copy="false" >}}
+<Configuration>
+  <Appenders>
+    <Console name="Console"><JsonLayout compact="true" eventEol="true" properties="true"/></Console>
+  </Appenders>
+  <Loggers><Root level="info"><AppenderRef ref="Console"/></Root></Loggers>
+</Configuration>
+{{< /code-block >}}
+
+   For more information, see [Correlating Java Logs and Traces][2].
+
+4. **Configure your application**.
+
+{{% gcr-configure-env-vars language="java" %}}
+
+## Troubleshooting
+
+{{% gcr-troubleshooting %}}
+
+## Further reading
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: /tracing/trace_collection/automatic_instrumentation/dd_libraries/java/
+[2]: /tracing/other_telemetry/connect_logs_and_traces/java/

content/en/serverless/google_cloud_run/containers/in_process/nodejs.md

@@ -0,0 +1,82 @@
+---
+title: Instrumenting a Node.js Cloud Run Container In-Process
+code_lang: nodejs
+type: multi-code-lang
+code_lang_weight: 20
+further_reading:
+- link: '/tracing/trace_collection/automatic_instrumentation/dd_libraries/nodejs/'
+  tag: 'Documentation'
+  text: 'Tracing Node.js Applications'
+- link: '/tracing/other_telemetry/connect_logs_and_traces/nodejs/'
+  tag: 'Documentation'
+  text: 'Correlating Node.js Logs and Traces'
+---
+
+## Setup
+1. **Install the Datadog Node.js tracer**.
+
+   1. In your main application, add `dd-trace-js`.
+
+      {{< code-block lang="shell" disable_copy="false" >}}
+npm install dd-trace --save
+{{< /code-block >}}
+
+   2. Add the following to your application code to initialize the tracer:
+   {{< code-block lang="javascript" disable_copy="false" >}}
+const tracer = require('dd-trace').init({
+ logInjection: true,
+});
+{{< /code-block >}}
+
+   3. Set the following environment variable to specify that the `dd-trace/init` module is required when the Node.js process starts:
+   {{< code-block lang="dockerfile" disable_copy="false" >}}
+ENV NODE_OPTIONS="--require dd-trace/init"
+{{< /code-block >}}
+
+   For more information, see [Tracing Node.js applications][1].
+
+2. **Install serverless-init**.
+
+   {{% gcr-install-serverless-init cmd="\"/nodejs/bin/node\", \"/path/to/your/app.js\"" %}}
+
+3. **Set up logs**.
+
+   To enable logging, set the environment variable `DD_LOGS_ENABLED=true`. This allows `serverless-init` to read logs from stdout and stderr.
+
+   Datadog also recommends setting the environment variable `DD_SOURCE=nodejs` to enable advanced Datadog log parsing.
+
+   If you want multiline logs to be preserved in a single log message, Datadog recommends writing your logs in JSON format. For example, you can use a third-party logging library such as `winston`:
+   {{< code-block lang="javascript" disable_copy="false" >}}
+const tracer = require('dd-trace').init({
+  logInjection: true,
+});
+const { createLogger, format, transports } = require('winston');
+
+const logger = createLogger({
+  level: 'info',
+  exitOnError: false,
+  format: format.json(),
+  transports: [
+    new transports.Console()
+  ],
+});
+
+logger.info(`Hello world!`);
+{{< /code-block >}}
+
+   For more information, see [Correlating Node.js Logs and Traces][2].
+
+4. **Configure your application**.
+
+{{% gcr-configure-env-vars language="nodejs" %}}
+
+## Troubleshooting
+
+{{% gcr-troubleshooting %}}
+
+## Further reading
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: /tracing/trace_collection/automatic_instrumentation/dd_libraries/nodejs/
+[2]: /tracing/other_telemetry/connect_logs_and_traces/nodejs/