PitometerDemo.playbook.yml

PitometerDemo.playbook.yml

---
- name: Create Pitometer Demo System
  hosts: pitometer

  vars:
    - DT_BASE_URL: "https://***.live.dynatrace.com"
    - DT_AGENT_DOWNLOAD_TOKEN: "***"
    - DT_API_TOKEN: "***"
    - HOST_GROUP: "pitometerDemo"

  tasks:

  - name: Check if Dynatrace OneAgent is already installed
    stat:
      path: /opt/dynatrace/oneagent/agent/lib64/liboneagentos.so
    register: agent_installed
    tags:
      - install

  - name: Download OneAgent
    get_url:
      url: "{{ DT_BASE_URL }}/api/v1/deployment/installer/agent/unix/default/latest?Api-Token={{ DT_AGENT_DOWNLOAD_TOKEN }}&arch=x86&flavor=default"
      dest: "/tmp/dynatrace-oneagent.sh"
    when: agent_installed.stat.exists == False
    tags:
      - install
    
  - name: Install Agent
    shell: "sh /tmp/dynatrace-oneagent.sh APP_LOG_CONTENT_ACCESS=1 HOST_GROUP={{ HOST_GROUP }}"
    become: yes
    when: agent_installed.stat.exists == False
    tags:
      - install

  - name: Check whether auto tag rule exists
    uri:
      delegate_to: localhost
      url: "{{ DT_BASE_URL }}/api/config/v1/autoTags"
      method: GET
      headers:
        Authorization: "Api-Token {{ DT_API_TOKEN }}"
    register: apiCheckResult
    tags:
      - install
    
  # Set a fact called tagExists to boolean true or false depending on whether tag exists or not.
  - name: Does DT Tag Exist?
    set_fact:
      tagExists: "{{ true if (apiCheckResult.json | json_query('values[?name == `pitometerDemo`]')) else false }}"
    tags:
      - install
    
  # Create tagging rule when tag doesn't already exist.
  - name: Create Auto Tagging Rule
    uri:
      delegate_to: localhost
      url: "{{ DT_BASE_URL }}/api/config/v1/autoTags"
      method: POST
      body_format: json
      status_code: 201
      headers:
        Accept: "application/json"
        Authorization: "Api-Token {{ DT_API_TOKEN }}"
        Content-Type: "application/json"
      body: |
        {
          "name": "{{ HOST_GROUP }}",
          "rules": [{
            "type": "SERVICE",
            "enabled": true,
            "valueFormat": null,
            "propagationTypes": [],
            "conditions": [{
              "key": {
                "attribute": "HOST_GROUP_NAME"
              },
              "comparisonInfo": {
                "type": "STRING",
                "operator": "EQUALS",
                "value": "{{ HOST_GROUP }}",
                "negate": false,
                "caseSensitive": false
              }
            }]
          }]
        }
    when: tagExists == False
    tags:
      - install
    
  - name: Install Docker and Git Packages
    become: yes
    package:
      name: "{{ item }}"
      state: present
      lock_timeout: 30
    loop:
      - docker
      - git
    tags:
      - install

  - name: Install Docker Python Package
    become: true
    pip:
      name: docker
      state: present
    tags:
      - install

  - name: Add Docker Group
    group:
      name: docker
      state: present
    tags:
      - install

  - name: Add ec2-user to Docker Group
    become: yes
    user:
      name: ec2-user
      groups: docker
    tags:
      - install
    
  - name: Start Docker Service
    become: yes
    service:
      name: docker
      state: started
    tags:
      - install

  - name: Pull Waiter Docker Images
    become: yes
    docker_image:
      name: "{{ item }}"
      source: pull
    loop:
      - "adamgardnerdt/waiter:v1"
      - "adamgardnerdt/waiter:v2"
    
  - name: Run Waiter V1
    become: yes
    docker_container:
      name: waiterV1
      image: adamgardnerdt/waiter:v1
      published_ports:
        - 80:80
      state: started
    tags:
      - install
    
  - name: Create k6 Directory
    file:
      path: ~/k6
      state: directory
    tags:
      - install

  - name: Remove k6 script.js if it exists
    file:
      path: ~/k6/script.js
      state: absent
    tags:
      - install

  - name: Create k6 Load Testing Script
    shell:
      cmd: |
        cat <<EOF>> ~/k6/script.js
        import http from "k6/http";
        // Maximum 1 request per second
        export let options = {
          rps: 1,
          duration: 0
        }
        export default function() {
          http.get("http://{{ ansible_all_ipv4_addresses | ipaddr('private') | first }}");
        };
        EOF
    tags:
      - install

  - name: Run LoadGen
    become: yes
    docker_container:
      name: loadgen
      image: loadimpact/k6
      command: "run /home/ec2-user/script.js"
      volumes:
        - /home/ec2-user/k6:/home/ec2-user
    tags:
      - install

  - name: Download NVM
    get_url:
      url: https://raw.githubusercontent.com/creationix/nvm/v0.34.0/install.sh
      dest: /tmp/nvmInstall.sh
      mode: "+x"
    tags:
      - install

  - name: Install NVM
    command: /tmp/nvmInstall.sh
    tags:
      - install
    
  - name: Add +x Permission to nvm.sh
    file:
      path: ~/.nvm/nvm.sh
      mode: "+x"
    tags:
      - install

  - name: Install node and set version
    shell: "source ~/.nvm/nvm.sh && nvm install 10.15.3"
    tags:
      - install

  - name: Install NPM Modules pitometer modules
    command: "npm install -S {{ item }}"
    loop:
      - "@keptn/pitometer"
      - "@keptn/pitometer-source-dynatrace"
      - "@keptn/pitometer-grader-threshold"
    tags:
      - install

  - name: Create Pitometer Directory
    file:
      path: ~/pitometer
      state: directory
    tags:
      - install
    
  - name: Remove Existing perfspec File
    file:
      path: ~/pitometer/perfspec.json
      state: absent
    tags:
      - install
    
  - name: Create perfspec file
    shell:
      cmd: |
        cat <<EOF>> ~/pitometer/perfspec.json
        {
          "spec_version": "1.1",
          "indicators": [{
            "id": "Service_ResponseTime",
            "source": "Dynatrace",
            "query": {
              "timeseriesId": "com.dynatrace.builtin:service.responsetime",
              "aggregation": "avg",
              "tags": ["{{ HOST_GROUP }}"]
              },
              "grading": {
                "type": "Threshold",
                "thresholds": {
                  "upperSevere": 5000000,
                  "upperWarning": 3000000
                },
              "metricScore": 100,
              "metadata": {
                "playbookhints": ["autoFix.playbook.yml"],
                "keyContacts": [
                  {
                    "name": "Chris",
                    "phone": "+64123 456 789"
                  },
                  {
                    "name": "Diane",
                    "phone": "+64899 849 922"
                  }
                ]
              }
            }
          }],
          "objectives": {
            "pass": 90,
            "warning": 50
            }
          }
        EOF
    tags:
      - install

  - name: Remove Existing pitometer File
    file:
      path: ~/pitometer/pitometer.js
      state: absent
    tags:
      - install
    
  - name: Create pitometer.js
    shell:
      cmd: |
        cat <<EOF>> ~/pitometer/pitometer.js
          const Pitometer = require('@keptn/pitometer').Pitometer;
          const DynatraceSource = require('@keptn/pitometer-source-dynatrace').Source;
          const ThresholdGrader = require('@keptn/pitometer-grader-threshold').Grader;
          const pitometer = new Pitometer();
          /* Generate the epoch time in seconds now
           * Generate the epoch time "time_to_go_back" seconds ago.
           * eg. Show time 1 minute ago.
           * We'll use "epoch_seconds_now" and "epoch_seconds_back" to call the API
           */
          var seconds_per_minute = 60;
          var time_to_go_back = 1;
          var epoch_seconds_now = Math.round(Date.now()/1000);
          var epoch_seconds_back = epoch_seconds_now - (time_to_go_back * seconds_per_minute);
          // Register a source that will be used if the source ID in your Perfspec matches 'Dynatrace'
          pitometer.addSource('Dynatrace', new DynatraceSource({
            baseUrl: '{{ DT_BASE_URL }}',
            apiToken: '{{ DT_API_TOKEN }}',
            // Optional: A logger to be used for debugging API requests
            //log: console.log
          }));
          // Register a grader for thresholds that will be used if the grader type matches 'Threshold'
          pitometer.addGrader('Threshold', new ThresholdGrader());
          // Load Perfspec
          const perfspec = require('/home/ec2-user/pitometer/perfspec.json');
          // Run the Perfspec, passing in an optional context parameter 'prod
          // and log the result out to the console
          pitometer.run(perfspec, {
            timeStart: epoch_seconds_back,
            timeEnd: epoch_seconds_now,
          }).then((results) => console.log(JSON.stringify(results)))
          .catch((err) => console.error(err));
        EOF
    tags:
      - install
    
  - name: Run Pitometer
    command: node ~/pitometer/pitometer.js
    register: pitometerResults
    tags:
      - runPitometer

  - name: Pitometer Results
    debug:
      msg: "{{ pitometerResults }}"
    tags:
      - runPitometer

  - name: Stop Waiter v1
    docker_container:
      name: waiterV1
      image: adamgardnerdt/waiter:v1
      state: stopped
    tags:
      - runWaiterV2

  - name: Run Waiter v2
    docker_container:
      name: waiterV2
      image: adamgardnerdt/waiter:v2
      state: started
      published_ports:
        - 80:80
    tags:
      - runWaiterV2
    
  - name: Stop Waiter v2
    docker_container:
      name: waiterV2
      image: adamgardnerdt/waiter:v2
      state: stopped
    tags:
      - runWaiterV1

  - name: Run Waiter v1
    docker_container:
      name: waiterV1
      image: adamgardnerdt/waiter:v1
      state: started
    tags:
      - runWaiterV1