adding the sample for gcp cloud function (#71)

Author: karthikeyangs9

python/fastapi/README.md

@@ -65,7 +65,7 @@ opentelemetry-instrument python app.py
 - GET `/` - Hello World
 - GET `/items/:id` - Get items by ID
 
-6. Sign in to [Last9 Dashboard](https://app.last9.io) and visit the APM
-   dashboard to see the traces and metrics in action.
+7. Sign in to [Last9 Dashboard](https://app.last9.io) and visit the APM
+   dashboard to see the traces in action.
 
 ![Traces](./traces.png)

python/gcp_cloud_function/README.md

@@ -0,0 +1,45 @@
+# Instrumentating Google cloud function using OpenTelemetry
+
+This example demonstrates how to instrument a Google cloud function with OpenTelemetry.
+
+1. Create a virtual environment and install the dependencies:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+```
+
+2. Install the Auto Instrumentation packages using the `opentelemetry-bootstrap`
+   tool:
+
+```bash
+opentelemetry-bootstrap -a requirements
+```
+It will output the packages that you can add to `requirements.txt`.
+
+```bash
+opentelemetry-api>=1.15.0
+opentelemetry-sdk>=1.15.0
+opentelemetry-exporter-otlp>=1.15.0
+opentelemetry-distro==0.48b0
+opentelemetry-instrumentation==0.51b0
+opentelemetry-instrumentation-aiohttp-client==0.51b0
+opentelemetry-instrumentation-asyncio==0.51b0
+```
+
+3. Obtain the OTLP Auth Header from the [Last9 dashboard](https://app.last9.io) and update the code.
+
+4. Run the application:
+
+```bash
+functions-framework --target http_handler --debug
+```
+
+5. Once the server is running, you can access the application at
+   `http://127.0.0.1:8080` by default. 
+
+6. Sign in to [Last9 Dashboard](https://app.last9.io) and visit the APM
+   dashboard to see the traces in action.
+
+![Traces](./traces.png)

python/gcp_cloud_function/Traces.png

@@ -0,0 +1,91 @@
+import asyncio
+import functions_framework
+from flask import Request, jsonify
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.semconv.resource import ResourceAttributes
+from opentelemetry.instrumentation.asyncio import AsyncioInstrumentor
+
+# Initialize OpenTelemetry components
+def initialize_tracing():
+    # Create a resource with service information
+    resource = Resource.create({
+        ResourceAttributes.SERVICE_NAME: "cloud-function",
+        ResourceAttributes.SERVICE_VERSION: "0.1.0",
+    })
+
+    # Set up tracer provider with the resource
+    provider = TracerProvider(resource=resource)
+    trace.set_tracer_provider(provider)
+
+    # Configure the OTLP exporter
+    otlp_exporter = OTLPSpanExporter(
+        endpoint={{ .Logs.WriteURL }},
+        headers={
+            "authorization":"{{ .Logs.AuthValue }}",
+        }
+    )
+
+    #span_processor = BatchSpanProcessor(ConsoleSpanExporter())
+    span_processor = BatchSpanProcessor((otlp_exporter))
+    provider.add_span_processor(span_processor)
+
+    AsyncioInstrumentor().instrument()
+
+    return trace.get_tracer(__name__)
+
+tracer = initialize_tracing()
+
+async def process_request(request_data):
+    with tracer.start_as_current_span("process_request") as span:
+        span.set_attribute("request.data_size", len(str(request_data)))
+
+        await asyncio.sleep(1)
+
+        result = {"message": "Processed asynchronously", "data": request_data}
+        return result
+
+@functions_framework.http
+def http_handler(request: Request):
+    with tracer.start_as_current_span("http_handler", kind=trace.SpanKind.SERVER) as span:
+        span.set_attribute("http.method", request.method)
+        span.set_attribute("http.url", request.url)
+        span.set_attribute("http.route", request.path)
+
+        if request.is_json:
+            request_data = request.get_json()
+        else:
+            request_data = request.form.to_dict() if request.form else request.args.to_dict()
+
+        with tracer.start_as_current_span("extract_headers") as header_span:
+            headers = dict(request.headers)
+            header_span.set_attribute("request.header_count", len(headers))
+
+            if 'traceparent' in headers:
+                header_span.set_attribute("trace.parent_id", headers['traceparent'])
+
+        try:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            result = loop.run_until_complete(process_request(request_data))
+            loop.close()
+
+            return jsonify(result)
+        except Exception as e:
+            with tracer.start_as_current_span("error_handler") as error_span:
+                error_span.set_attribute("error.type", str(type(e).__name__))
+                error_span.set_attribute("error.message", str(e))
+                error_span.record_exception(e)
+
+            return jsonify({"error": str(e)}), 500
+
+# For local testing
+if __name__ == "__main__":
+    import os
+
+    # Run the app locally with functions-framework
+    # Use: functions-framework --target http_handler --debug
+    print("Run with: functions-framework --target http_handler --debug")

python/gcp_cloud_function/main.py

@@ -0,0 +1,9 @@
+flask==3.0.3
+functions-framework==3.8.2
+opentelemetry-api>=1.15.0
+opentelemetry-sdk>=1.15.0
+opentelemetry-exporter-otlp>=1.15.0
+opentelemetry-distro==0.48b0
+opentelemetry-instrumentation==0.51b0
+opentelemetry-instrumentation-aiohttp-client==0.51b0
+opentelemetry-instrumentation-asyncio==0.51b0