opbeans/views.py

import os
import json
import time
from functools import wraps
import random

import prometheus_client
from django.http import JsonResponse, Http404, HttpResponse
from django.conf import settings
from django.core.cache import cache
from django.db import models
from django.shortcuts import get_object_or_404, render
from django.views.decorators.csrf import csrf_exempt

import elasticapm
from elasticapm.contrib.django.client import client
try:
    from elasticapm import label
except ImportError:
    # elastic-apm < 5.0
    from elasticapm import tag as label
import requests
import structlog

from opbeans import models as m
from opbeans import utils
from opbeans.utils import StreamingJsonResponse, iterlist
from opbeans import tasks

logger = structlog.get_logger(__name__)


def maybe_dt(view_func):
    """
    Either calls the view, or randomly forwards the request to another opbeans service
    """
    other_services = [s for s in os.environ.get("OPBEANS_SERVICES", "").split(",") if s and "opbeans-python" not in s]
    if other_services:
        logger.info("Registered Opbeans Services: {}".format(", ".join(other_services)))
    else:
        logger.info("dt_ping_pong_disabled", reason="no_services_discovered")
    try:
        probability = float(os.environ.get("OPBEANS_DT_PROBABILITY", 0.5))
    except ValueError:
        probability = 0.5

    def wrapped_view(request, *args, **kwargs):
        r = random.random()
        logger.info("dt_ping_pong_dice_throw", random_val=r, probability=probability, passed=bool(r < probability))
        if request.method == "GET" and other_services and r < probability:
            other_service = random.choice(other_services)
            if not other_service.startswith("http://"):
                other_service = "http://{}:3000".format(other_service)
            url = other_service + request.get_full_path()
            logger.info("dt_ping_pong_proxy", url=url)
            try:
                other_response = requests.get(url, timeout=15)
            except requests.exceptions.Timeout:
                logger.error("dt_ping_pong_timeout", service=other_service)
                raise
            except Exception:
                logger.error("dt_ping_pong_connection_failed", service=other_service)
                raise
            try:
                content_type = other_response.headers['content-type']
            except KeyError:
                logger.debug("dt_ping_pong_missing_content_type", service=other_service)
                content_type = "text/plain"
            return HttpResponse(other_response.content, status=other_response.status_code, content_type=content_type)
        return view_func(request, *args, **kwargs)
    return wraps(view_func)(wrapped_view)


@maybe_dt
def stats(request):
    from_cache = True
    data = cache.get(utils.stats.cache_key)
    if not data:
        data = utils.stats()
        cache.set(utils.stats.cache_key, data, 60)
        from_cache = False
    label(served_from_cache=from_cache)
    return JsonResponse(data, safe=False)


random_summary = prometheus_client.Summary("random_summary", "Random summary", ["a"])
random_counter = prometheus_client.Counter("random_counter", "Random counter", ["a"])
random_gauge = prometheus_client.Gauge("random_gauge", "Random gauge", ["a"])

@maybe_dt
def products(request):
    product_list = m.Product.objects.all()

    random_summary.labels(a=random.choice("xyz")).observe(random.randint(0, 100))
    random_counter.labels(a=random.choice("xyz")).inc(random.randint(0, 5))
    random_gauge.labels(a=random.choice("xzy")).set(random.random()*100)
    data = iterlist({
        'id': elem.id,
        'sku': elem.sku,
        'name': elem.name,
        'stock': elem.stock,
        'type_name': elem.product_type.name,
    } for elem in product_list)

    return StreamingJsonResponse(data, safe=False)


@maybe_dt
def top_products(request):
    products = m.Product.objects.annotate(
        sold=models.Sum('orderline__amount')
    ).order_by('-sold').values(
        'id', 'sku', 'name', 'stock', 'sold'
    )[:3]
    return JsonResponse(list(products), safe=False)


@maybe_dt
def product(request, pk):
    try:
        product_obj = m.Product.objects.select_related(
            'product_type'
        ).filter(
            pk=pk
        ).values(
            'id', 'sku', 'name', 'description', 'product_type_id',
            'product_type__name', 'stock', 'cost', 'selling_price',
        )[0]
    except IndexError:
        raise Http404()
    product_obj['type_id'] = product_obj.pop('product_type_id')
    product_obj['type_name'] = product_obj.pop('product_type__name')
    return JsonResponse(product_obj)


@maybe_dt
def product_customers(request, pk):
    try:
        limit = int(request.GET.get('count', 1000))
    except ValueError:
        limit = 1000
    customers_list = m.Customer.objects.filter(
        orders__orderline__product_id=pk
    ).distinct().values(
        'id', 'full_name', 'company_name', 'email', 'address',
        'postal_code', 'city', 'country'
    )[:limit]
    return JsonResponse(list(customers_list), safe=False)


@maybe_dt
def product_types(request):
    types = m.ProductType.objects.values('id', 'name')
    return JsonResponse(list(types), safe=False)


@maybe_dt
def product_type(request, pk):
    product_type = get_object_or_404(m.ProductType, pk=pk)
    products = m.Product.objects.filter(product_type=product_type).values(
        'id', 'name'
    )
    data = {
        'id': product_type.pk,
        'name': product_type.name,
        'products': list(products),
    }
    return JsonResponse(data)


@maybe_dt
def customers(request):
    customer_list = m.Customer.objects.values(
        'id', 'full_name', 'company_name', 'email', 'address',
        'postal_code', 'city', 'country'
    )
    return JsonResponse(list(customer_list), safe=False)


@maybe_dt
def customer(request, pk):
    try:
        customer_obj = m.Customer.objects.filter(pk=pk).values(
            'id', 'full_name', 'company_name', 'email', 'address',
            'postal_code', 'city', 'country'
        )[0]
    except IndexError:
        logger.warning('customer_not_found', customer_id=pk, exc_info=True)
        raise Http404()
    return JsonResponse(customer_obj)


@csrf_exempt
def orders(request):
    if request.method == 'POST':
        # set transaction name to post_order
        elasticapm.set_transaction_name('POST opbeans.views.post_order')
        return post_order(request)
    order_list = list(m.Order.objects.all()[:1000])
    with elasticapm.capture_span("iterate_orders"):
        orders = [
            {"id": order.id,
             "customer_id": order.customer_id,
             "customer_name": order.customer.full_name,
             "created_at": order.created_at
             } for order in order_list
        ]
    return JsonResponse(orders, safe=False)

line_item_counter = prometheus_client.Counter("opbeans_python_line_items", "Counter of line items")
order_summary = prometheus_client.Summary("opbeans_python_orders", "Summary of orders and total order values")


def post_order(request):
    data = json.loads(request.body)
    if 'customer_id' not in data:
        return HttpResponse(status=400)
    customer_obj = get_object_or_404(m.Customer, pk=data['customer_id'])
    order_obj = m.Order.objects.create(customer=customer_obj)

    total_amount = 0
    for line in data['lines']:
        product_obj = get_object_or_404(m.Product, pk=line['id'])
        m.OrderLine.objects.create(
            order=order_obj,
            product=product_obj,
            amount=line['amount']
        )
        total_amount += line['amount'] * product_obj.selling_price

    # store lines count in and total amount in tags
    label(
        lines_count=len(data['lines']),
        total_amount=total_amount / 100.0,
    )
    line_item_counter.inc(len(data['lines']))
    order_summary.observe(total_amount / 100.0)

    # store customer in transaction custom data
    elasticapm.set_custom_context({
        'customer_name': customer_obj.full_name,
        'customer_email': customer_obj.email,
    })
    tasks.update_stats.delay()
    return JsonResponse({'id': order_obj.pk})


@csrf_exempt
def post_order_csv(request):
    customer_id = request.POST['customer']
    customer_obj = get_object_or_404(m.Customer, pk=customer_id)
    order_obj = m.Order.objects.create(customer=customer_obj)
    total_amount = 0
    i = 0
    for i, line in enumerate(request.FILES['file']):
        product_id, amount = map(int, line.decode('utf8').split(','))
        product_obj = get_object_or_404(m.Product, pk=product_id)
        m.OrderLine.objects.create(
            order=order_obj,
            product=product_obj,
            amount=amount
        )
        total_amount += amount * product_obj.selling_price
    label(
        lines_count=i,
        total_amount=total_amount / 100.0,
    )
    return HttpResponse('OK')


def order(request, pk):
    order_obj = get_object_or_404(m.Order, pk=pk)
    lines = list(order_obj.orderline_set.values(
        'product_id', 'amount', 'product__sku', 'product__name', 'product__description', 'product__product_type_id',
        'product__stock', 'product__cost', 'product__selling_price',
    ))
    for line in lines:
        line['id'] = line.pop('product_id')
        line['sku'] = line.pop('product__sku')
        line['name'] = line.pop('product__name')
        line['description'] = line.pop('product__description')
        line['type_id'] = line.pop('product__product_type_id')
        line['stock'] = line.pop('product__stock')
        line['cost'] = line.pop('product__cost')
        line['selling_price'] = line.pop('product__selling_price')
    data = {
        'id': order_obj.pk,
        'created_at': order_obj.created_at,
        'customer_id': order_obj.customer_id,
        'lines': lines,
    }
    return JsonResponse(data)


def oopsie(request):
    client.capture_message('About to blow up!')
    try:
        1 / 0
    except ZeroDivisionError:
        try:
            1 + "a"
        except TypeError:
            raise AssertionError("oh no")



def home(request):
    with elasticapm.capture_span("hard-home-work"):
        time.sleep(random.random() / 2.0)
    return render(request, "index.html")


def label_with_delay(request):
    labels = {}
    for k, v in request.GET.items():
        if k != "delay":
            labels[k] = v
    with elasticapm.capture_span("delayed-and-labeled", labels=labels):
        if "delay" in request.GET:
            time.sleep(float(request.GET["delay"]) / 1000.0)
    return HttpResponse("OK")