Rust App w/ OpenTelemetry Integration PoC

@Engumer480

*"Struggling with observability in Rust? Let’s build a lean PoC with OpenTelemetry, Tokio, and Jaeger/Zipkin—designed for your exact needs. I’ll instrument key traces/metrics, document everything, and deliver actionable insights. No payment until you’re thrilled, plus 20% off for taking the leap. Share your focus areas, and I’ll hit the ground running!"*

@toriquldev123

Hello Dear! I write to introduce myself. I'm Engineer Toriqul Islam. I was born and grew up in Bangladesh. I speak and write in English like native people. I am a B.S.C. Engineer of Computer Science & Engineering. I completed my graduation from Rajshahi University of Engineering & Technology ( RUET). I love to work on Web Design & Development project. Web Design & development: I am a full-stack web developer with more than 10 years of experience. My design Approach is Always Modern and simple, which attracts people towards it. I have built websites for a wide variety of industries. I have worked with a lot of companies and built astonishing websites. All Clients have good reviews about me. Client Satisfaction is my first Priority. Technologies We Use: Custom Websites Development Using ======>Full Stack Development. 1. HTML5 2. CSS3 3. Bootstrap4 4. jQuery 5. JavaScript 6. Angular JS 7. React JS 8. Node JS 9. WordPress 10. PHP 11. Ruby on Rails 12. MYSQL 13. Laravel 14. .Net 15. CodeIgniter 16. React Native 17. SQL / MySQL 18. Mobile app development 19. Python 20. MongoDB What you'll get? • Fully Responsive Website on All Devices • Reusable Components • Quick response • Clean, tested and documented code • Completely met deadlines and requirements • Clear communication You are cordially welcome to discuss your project. Thank You! Best Regards, Toriqul Islam

@GameOfWords

⚠ NO PAYMENT UNLESS YOU'RE SATISFIED ⚠ I’ve built Rust apps using Axum and integrated them with OpenTelemetry pipelines, including traces, metrics, logs, and profiling. I can wire this up with grafana/otel-lgtm using Docker Compose and validate full telemetry flow with test scenarios and dashboard exports. Do you have a preferred logging crate (like `tracing_subscriber` or `log`) or should I stick with the native tracing ecosystem?

@softsolution2000

Hi there I have extensive experience in Rust development and observability tools integration. I propose to create a simple Rust application with a REST API using Axum framework. The application will have 3-5 basic endpoints with minimal business logic, focusing on observability validation. I will integrate OpenTelemetry for structured logging, request tracing, custom metrics, and CPU/memory profiling. The project will include Docker Compose configuration for the Rust app and grafana/otel-lgtm stack. I will create basic Grafana dashboards for application metrics, log aggregation, trace visualization, and system resource usage. The deliverables will include complete source code, configuration files, Grafana dashboards, documentation, and a demo video showcasing the integration. Please go through my profile its 15 years old see the work I did over the years. ---> No Win No Fee means that your satisfaction is my utmost priority. <---- Lets discuss the job details. Moreover, I am willing to start the job and perform tasks without even being hired; it is just to show my commitment to this project. Looking forward to hear from you. Regards Shah

@HAZIQ87

I've successfully implemented OpenTelemetry tracing in a high-throughput Rust microservice, achieving 99.99% uptime and significantly improving observability. My expertise in Rust, particularly using Tokio for asynchronous programming and `opentelemetry` crate, directly addresses your Proof of Concept (PoC) requirements. My approach will involve creating a minimal, yet representative, Rust application demonstrating key functionalities. This PoC will leverage Tokio for concurrency, `opentelemetry` for instrumentation, and Jaeger or Zipkin for visualization. I'll focus on accurate span creation, attribute setting, and metric collection, ensuring comprehensive data for analysis and demonstrating the effectiveness of OpenTelemetry within your specific use case. Complete documentation and a comprehensive report detailing the implementation and results will be provided. Let's discuss this further. Could you share details about the specific metrics and traces you want to capture in this PoC, so I can ensure optimal instrumentation and tailor the solution to your exact needs?

@nnead

----------------------- ✅✅✅✅✅ Top Rate Specialist HERE ✅✅✅✅✅ ----------------------- As a seasoned developer proficient in Rust and equipped with a comprehensive understanding of the OpenTelemetry ecosystem, I am confident that I can deliver a superior result on your project, fully aligned with your requirements. My broad technical expertise has sharpened my problem-solving skills and given me a knack for streamlining processes – critical qualities given the POC nature of this project. I have extensive exposure to REST API development using Axum and have handled projects with similar endpoints and error scenarios. My mastery of OpenTelemetry will ensure the faultless integration of structured logging, request tracing, custom metrics management, and, if needed, profile integration like CPU/memory profiling. Moreover, I pride myself on producing meticulous documentation that is clear, concise, and easy to follow. An essential aspect of such projects is seamless knowledge transferability which my READMEs and code comments target to achieve. And if there are ever any issues down the line, my thorough troubleshooting guide will ensure they're swiftly resolved. With me on this project, you'll get a results-oriented professional dedicated to producing not just a high-quality product but also ensuring you have all the resources to understand and use it effectively. Looking forward to positive cooperation! (965 characters)

@divumanocha

Hello, I am really excited about the opportunity to collaborate with you on this project! It aligns perfectly with my skill set and experience, and I’m confident I can contribute meaningfully to your vision. I genuinely enjoy working on projects like this, and I believe we can create something both functional and visually engaging. Please feel free to check out my profile to learn more about my past work and client feedback. I’d love to connect and discuss the project details further your goals, expectations, and any specific features or ideas you have in mind. The more I understand your vision, the better I can bring it to life. I am ready to get started right away and will put my full energy and focus into delivering quality results on time. My goal is not just to complete the project, but to exceed your expectations and build a long-term working relationship. Looking forward to hearing from you soon! With regards! Divya

@volodymyrkoval

Hello Emmanuel, I would love to help you create a Rust application integrated with the OpenTelemetry observability stack. With over 10 years of experience in software development, I have a strong proficiency in Rust and API development, which makes me well-suited for this project. I am skilled in Docker and can efficiently set up the Docker Compose configuration, ensuring seamless integration of the Rust application and the grafana/otel-lgtm stack. My expertise in observability tools will allow me to implement structured logging, request tracing, and custom business metrics effectively. I am committed to delivering comprehensive documentation and ensuring the application meets all project goals. Thanks, Volodymyr

@vimalbhalani

Yes emmanuellm, I have successfully worked on similar projects involving Rust applications with observability integrations. My expertise lies in creating simple REST APIs in Rust using frameworks like Axum, focusing on observability validation through proper logging, tracing, and metric implementation. In approaching this project, I recommend breaking down the work into stages: 1. Developing the core Rust application with basic REST endpoints and minimal business logic. 2. Integrating OpenTelemetry for structured logging, request tracing, and custom metrics. 3. Setting up the Docker Compose environment with the grafana/otel-lgtm stack. 4. Creating basic Grafana dashboards for visualization of telemetry data. 5. Documenting the setup, implementation details, and troubleshooting steps for future reference. To move forward, could we discuss further details over chat? Specifically, I'd like to know more about the existing tools or frameworks you prefer for this project. This will help me tailor the implementation to align with your requirements effectively.

@iradoicic04

Hi, I can deliver a minimal Rust REST API (Axum) fully wired to grafana/otel-lgtm for end-to-end observability: structured JSON logs with tracing/tracing-subscriber, distributed traces via tracing-opentelemetry + OTLP, custom metrics (request count, latency histograms, error rate) using metrics + OTEL exporter, and optional CPU/memory profiling with Pyroscope. The app will expose 3–5 GET/POST endpoints with normal and error paths, propagate trace context through middleware/handlers, and include clean error handling. I’ll provide Docker Compose for the Rust app and the full OTEL Collector pipeline (logs/metrics/traces/profiles) connected to Loki, Prometheus, Tempo, Pyroscope, and preload Grafana with a concise dashboard for RPS, p95 latency, error %, logs view, and trace explorer. Deliverables include the source code, compose files, collector config, Grafana dashboards (JSON), and a thorough README with one-command spin-up, environment variables, and a troubleshooting guide (ports, exporters, common OTLP gotchas). I’ll also add demo screenshots or a short video showing logs in Loki, traces in Tempo, metrics in Grafana/Prometheus, and (if enabled) profiles in Pyroscope. Ready to start immediately and keep the app intentionally simple so the telemetry integration is rock-solid and easy to extend. Best regards,

@Alanfox10000

I have hands-on experience building Rust microservices with Axum and integrating full observability stacks using OpenTelemetry with Grafana, Prometheus, Loki, Tempo, and Pyroscope. Your PoC goal of validating telemetry flow fits perfectly with my background. Approach: • Develop a minimal Axum REST API (3–5 endpoints, GET/POST) with basic error cases for trace testing. • Implement structured logging (INFO/WARN/ERROR), distributed tracing, and custom metrics (request counts, latencies) via OpenTelemetry SDK for Rust. • Integrate CPU/memory profiling with Pyroscope. • Configure Docker Compose to run the Rust app alongside grafana/otel-lgtm stack. • Configure OTEL Collector to route logs, traces, metrics, and profiles to the right Grafana backends. • Build basic Grafana dashboards for request rate, error rate, response times, logs, and trace visualization. • Provide a well-documented README with setup, config details, and troubleshooting tips, plus exported dashboard JSON. Quick clarifications: • Should the demo use pre-built dashboards or only minimal custom panels? • Any preference for metrics format (Prometheus text vs. OTLP)? • Do you need the PoC to run on Linux-only, or cross-platform Docker support?

@emilesd617

Hi, I am a full-stack AI developer with 8 years of experience specializing in software development. I am proficient in Rust, Axum, Docker, Prometheus, Grafana, and OpenTelemetry. I have a strong background in creating REST APIs and integrating them with modern observability tools. I have worked on projects involving structured logging, request tracing, and custom business metrics. I am confident in setting up Docker Compose configurations, configuring OpenTelemetry Collectors, and creating Grafana dashboards. I am excited about the opportunity to work on this Rust application with OpenTelemetry integration PoC project and showcase the seamless flow of telemetry data through the entire OTEL-LGTM stack. Looking forward to discussing more details. Thanks, Emile.

@ahmaddar2970

Hello Emmanuel, I am excited about the opportunity to work on your Rust Application with OpenTelemetry Integration proof of concept. With over 3 years of experience as a Full Stack Developer, I have a profound understanding of RESTful APIs, Docker, and OpenTelemetry which makes me an excellent fit for this project. I will develop a simple Rust REST API using Axum, ensuring smooth observability with 3-5 endpoints focused on thorough error tracing and structured logging. My expertise in Docker Compose will ensure proper integration between the Rust application and the grafana/otel-lgtm stack, creating a seamless observability setup. The deliverables will include comprehensive documentation, configuration files, and a demo showcasing the successful integration. I can assure you that this proof of concept will not only validate observability but also demonstrate a clear flow of telemetry data throughout the stack. How do you envision testing the observability features once the proof of concept is established? Thanks, Muhammad Ahmad

@XRProConnect

"This project caught my eye right away! I see you're looking for a Rust developer to integrate OpenTelemetry with a clean, professional setup. I’ve successfully completed similar projects, emphasizing clear communication and fast turnaround. Let me know if you'd like to see examples or are available for a quick chat! Regards, Aashiq"

@FizzaNadeemK

Hello, I can build a Rust proof-of-concept application fully integrated with the Grafana/otel-lgtm observability stack. The REST API will include 3–5 basic endpoints with minimal business logic, while structured logging, request tracing, and custom metrics ensure complete telemetry visibility. I’ll also provide Docker Compose setup linking the Rust app to the full OTEL-LGTM stack, Grafana dashboards for metrics, logs, and traces, along with clear documentation and setup instructions to demonstrate the end-to-end integration. Regards, Fizza Nadeem K

@TechWagger2026

Hello, With 14+ years in software development and strong expertise in Rust, observability stacks, and Dockerized deployments, I can deliver your Rust + OpenTelemetry proof of concept efficiently. Approach: Core App: Minimal Axum-based REST API with 3–5 endpoints, including error scenarios. Observability: Full OpenTelemetry integration for logs, traces, metrics, and profiling (CPU/memory) using tracing, opentelemetry, and prometheus crates. Infrastructure: Docker Compose setup for Rust app + grafana/otel-lgtm stack with proper collector configuration. Dashboards: Grafana panels for request rates, error rates, latency, logs, traces, and profiling data. Docs & Demo: Step-by-step README, configuration documentation, and screenshots/video of working integration. Questions: Should we containerize the Rust app in the same network as OTEL-LGTM or keep it separate for modularity? Do you require automated load testing to validate metrics flow? Should dashboards be pre-configured or minimal defaults? Let’s connect on Freelancer to finalize scope and timelines. Best regards, Arun

@mandolucas04

Your project deserves more than just completion—it deserves to stand out. I’m here to make that happen. I understand the essence of your request, which is to showcase a seamless Rust application integrated with the complete observability stack using grafana/otel-lgtm. This proof of concept aims to validate the smooth flow of telemetry data within the Rust application. Although I’m new to Freelancer, I’ve spent years refining my craft and have completed similar projects beyond this platform—with care and consistency. I’d genuinely love to learn more about what you're building and how I can help make it happen—At the very least, you gain valuable insights from a free consultation. I’d be pleased to discuss your ideas in more detail! Armando Lucas

@Igshaanj

We are a global team that is a perfect fit for your project. Our expertise lies in creating clean, professional, and seamlessly integrated applications. Our team has tons of experience delivering projects and has successfully completed many off-site projects. Let's engage about your requirements, and we look forward to collaborating with you! Regards, Igshaan

@olegn3

Hello, I'm Oleg, a Full‑Stack Developer with expertise in Python, AI, Web, Bots, and Blockchain. While new to freelancing, I bring a strong technical background and a passion for delivering high-quality solutions. Understanding Your Needs: You're seeking a developer to: Integrate OpenTelemetry into a Rust application. Implement tracing, metrics, and logs. Export telemetry data to an observability backend. Proposed Approach: Set Up OpenTelemetry in Rust: Utilize the opentelemetry and opentelemetry-otlp crates for instrumentation and exporting telemetry data. Configure the OpenTelemetry SDK to collect traces, metrics, and logs. Implement Tracing: Use the tracing crate to create spans and events within the application. Ensure proper context propagation across asynchronous tasks. Export Telemetry Data: Configure an OTLP exporter to send telemetry data to a backend of your choice (e.g., Jaeger, Prometheus, Datadog). Testing and Validation: Run the application and verify that telemetry data is correctly emitted and received by the observability backend. Ensure that traces, metrics, and logs are properly visualized. Reference Projects: OpenTelemetry Rust GitHub Repository: Official repository with examples and documentation. OpenTelemetry Rust Getting Started Guide: Step-by-step guide to instrumenting a Rust application. Looking forward to the opportunity to contribute to your project's success. Best regards, Oleg