Building a Simple Webhook Receiver in Python

Webhooks are a powerful mechanism for real-time communication between applications. This challenge asks you to build a basic Python application that can receive and process webhook payloads from an external service. This is a fundamental skill for integrating your applications with other platforms and automating workflows.

Problem Description

You need to create a Python application using a web framework (Flask is recommended for simplicity) that can receive POST requests containing JSON data, which represents a webhook payload. The application should:

1. Receive POST Requests: Listen for incoming POST requests at a specific endpoint (e.g., /webhook).
2. Parse JSON Payload: Extract the JSON data from the request body.
3. Log the Payload: Print the received JSON payload to the console. This simulates processing the data. In a real application, you would perform more meaningful actions here (e.g., updating a database, sending an email, triggering another process).
4. Return a 200 OK Response: Always return a 200 OK HTTP status code to the sending service to acknowledge receipt of the webhook. This is crucial for ensuring the sending service doesn't retry the request.
5. Handle Invalid JSON: If the request body is not valid JSON, return a 400 Bad Request HTTP status code.

Key Requirements:

• Use a Python web framework (Flask is highly recommended).
• Handle JSON payloads.
• Implement error handling for invalid JSON.
• Return appropriate HTTP status codes.

Expected Behavior:

When a POST request with a valid JSON payload is sent to the /webhook endpoint, the application should print the payload to the console and return a 200 OK response. If the request body is not valid JSON, the application should return a 400 Bad Request response.

Examples

Example 1:

Input: POST request to /webhook with body: {"event": "user.created", "data": {"id": 123, "name": "John Doe"}}
Output: Prints: {"event": "user.created", "data": {"id": 123, "name": "John Doe"}} to the console. Returns HTTP 200 OK.
Explanation: The application successfully receives, parses, and logs the JSON payload, then confirms receipt with a 200 OK.

Example 2:

Input: POST request to /webhook with body: "This is not JSON"
Output: Returns HTTP 400 Bad Request.
Explanation: The application detects that the request body is not valid JSON and returns a 400 error.  No payload is logged.

Example 3: (Edge Case - Empty Body)

Input: POST request to /webhook with an empty body.
Output: Returns HTTP 400 Bad Request.
Explanation: An empty body is not valid JSON, so a 400 error is returned.

Constraints

• Framework: Flask is recommended, but other lightweight web frameworks are acceptable.
• JSON Handling: The payload will always be in JSON format.
• Error Handling: The application must handle invalid JSON gracefully.
• Response Codes: The application must return the correct HTTP status codes (200 OK, 400 Bad Request).
• Performance: The application should be able to handle a reasonable number of requests concurrently (e.g., 10-20). Optimization for high-volume traffic is not required for this challenge.

Notes

• Consider using try...except blocks to handle potential JSONDecodeError exceptions when parsing the request body.
• Flask's request object provides access to the request data, including the body.
• Remember to install Flask: pip install Flask
• This is a simplified example. Real-world webhook implementations often involve authentication, data validation, and more complex processing logic. Focus on the core concepts of receiving and parsing the payload.
• You don't need to implement a full-fledged web server; Flask's built-in development server is sufficient for testing.