About

New Relic it’s a powerful tool that handles application monitoring.

Configuration

It is a good practice setting environment variables to define and configure our NewRelic parameters.

newrelic.ini example:

[newrelic]

# You must specify the license key associated with your New
# Relic account. This key binds the Python Agent's data to your
# account in the New Relic service.
license_key = YOUR_LICENSE_KEY

# The application name. Set this to be the name of your
# application as you would like it to show up in New Relic UI.
# The UI will then auto-map instances of your application into a
# entry on your home dashboard page.
app_name = YOU_APP_NAME

# When "true", the agent collects performance data about your
# application and reports this data to the New Relic UI at
# newrelic.com. This global switch is normally overridden for
# each environment below.
monitor_mode = false
developer_mode = true

# Sets the name of a file to log agent messages to. Useful for
# debugging any issues with the agent. This is not set by
# default as it is not known in advance what user your web
# application processes will run as and where they have
# permission to write to. Whatever you set this to you must
# ensure that the permissions for the containing directory and
# the file itself are correct, and that the user that your web
# application runs as can write to the file. If not able to
# write out a log file, it is also possible to say "stderr" and
# output to standard error output. This would normally result in
# output appearing in your web server log.
log_file = stderr

# Sets the level of detail of messages sent to the log file, if
# a log file location has been provided. Possible values, in
# increasing order of detail, are: "critical", "error", "warning",
# "info" and "debug". When reporting any agent issues to New
# Relic technical support, the most useful setting for the
# support engineers is "debug". However, this can generate a lot
# of information very quickly, so it is best not to keep the
# agent at this level for longer than it takes to reproduce the
# problem you are experiencing.
log_level = info

# The Python Agent communicates with the New Relic service using
# SSL by default. Note that this does result in an increase in
# CPU overhead, over and above what would occur for a non SSL
# connection, to perform the encryption involved in the SSL
# communication. This work is though done in a distinct thread
# to those handling your web requests, so it should not impact
# response times. You can if you wish revert to using a non SSL
# connection, but this will result in information being sent
# over a plain socket connection and will not be as secure.
ssl = true

# High Security Mode enforces certain security settings, and
# prevents them from being overridden, so that no sensitive data
# is sent to New Relic. Enabling High Security Mode means that
# SSL is turned on, request parameters are not collected, and SQL
# can not be sent to New Relic in its raw form. To activate High
# Security Mode, it must be set to 'true' in this local .ini
# configuration file AND be set to 'true' in the server-side
# configuration in the New Relic user interface. For details, see
# https://docs.newrelic.com/docs/subscriptions/high-security
high_security = false

# The Python Agent will attempt to connect directly to the New
# Relic service. If there is an intermediate firewall between
# your host and the New Relic service that requires you to use a
# HTTP proxy, then you should set both the "proxy_host" and
# "proxy_port" settings to the required values for the HTTP
# proxy. The "proxy_user" and "proxy_pass" settings should
# additionally be set if proxy authentication is implemented by
# the HTTP proxy. The "proxy_scheme" setting dictates what
# protocol scheme is used in talking to the HTTP proxy. This
# would normally always be set as "http" which will result in the
# agent then using a SSL tunnel through the HTTP proxy for end to
# end encryption.
# proxy_scheme = http
# proxy_host = hostname
# proxy_port = 8080
# proxy_user =
# proxy_pass =

# Capturing request parameters is off by default. To enable the
# capturing of request parameters, first ensure that the setting
# "attributes.enabled" is set to "true" (the default value), and
# then add "request.parameters.*" to the "attributes.include"
# setting. For details about attributes configuration, please
# consult the documentation.
attributes.include = request.parameters.*

# ---------------------------------------------------------------------------

#
# The application environments. These are specific settings which
# override the common environment settings. The settings related to a
# specific environment will be used when the environment argument to the
# newrelic.agent.initialize() function has been defined to be either
# "development", "pytest", "preprod" or "production".
#

[newrelic:staging]
app_name = YOU_APP_NAME (Staging)
monitor_mode = true
developer_mode = false

[newrelic:production]
monitor_mode = true
developer_mode = false

# ---------------------------------------------------------------------------

As you can see I have all the common settings under the [newrelic] tag and by default I set monitor_mode = false and developer_mode = true.

2 environments have been declared on that file, production and staging, so if I wanna use production I just need to declare NEW_RELIC_ENVIRONMENT and I’m good to go.

NEW_RELIC_ENVIRONMENT=production
NEW_RELIC_CONFIG_FILE=conf/newrelic.ini

export NEW_RELIC_ENVIRONMENT
export NEW_RELIC_CONFIG_FILE

Finally run New Relic as documented on their manuals.

# Example: Python agent
newrelic-admin run-program YOUR_COMMAND_OPTIONS

Requirements

• Ubuntu 16.04 or Ubuntu 18.04
• PostgreSQL 10
• 2 servers (a master and a slave)

In case you don’t know how to install PostgreSQL you can follow this tutorial from DigitalOcean.

Setup

It’s highly recommended to use two servers that can communicate via on a private interface.

• Master server: 192.168.123.10
• Slave server: 192.168.123.11

Master server configuration

Create a role dedicated to the replication, you can freely choose the username and password that you like.

su - postgres psql

CREATE ROLE replication WITH ENCRYPTED PASSWORD 'password';
ALTER ROLE replication WITH REPLICATION;

Modify the /etc/postgresql/10/main/postgresql.conf

listen_addresses = 'localhost, 127.0.0.1, 192.168.123.10'
wal_level = replica
max_wal_senders = 3 # max number of walsender processes
wal_keep_segments = 64 # in logfile segments, 16MB each; 0 disables

Modify the /etc/postgresql/10/main/pg_hba.conf file to allow access from the Slave server.

host    replication    replicate    192.168.123.11/24    md5

Restart PostgreSQL.

service postgresql restart

Slave server configuration

Modify the /etc/postgresql/10/main/postgresql.conf

listen_addresses = 'localhost, 127.0.0.1, 192.168.123.11'
wal_level = replica
max_wal_senders = 3 # max number of walsender processes
wal_keep_segments = 64 # in logfile segments, 16MB each; 0 disables
hot_standby = on

Modify the /etc/postgresql/10/main/pg_hba.conf file to allow access from the Slave server.

host    replication    replicate    192.168.123.10/24    md5

Stop PostgreSQL

service postgresql stop

Delete all the files inside the PGDATA folder. Keep in mind that this folder may change, you may wanna check your postgresql.conf file and lookup for the data_directory setting.

rm -rf /var/lib/postgresql/10/main/*

Now we will copy all the data from the master with the pg_basebackup command. You must run this command as the postgresql user.

su - postgresql
pg_basebackup -h 192.168.123.10 -D /var/lib/postgresql/10/main/ -P -U replicate --wal-method=stream

You can press CTRL + D to leave the postgresql user and create a file named recovery.conf on your PGDATA folder

nano /var/lib/postgresql/10/main/recovery.conf

standby_mode          = 'on'
primary_conninfo      = 'host=192.168.123.10 port=5432 user=replicate password=password'
trigger_file = '/tmp/MasterNow'
#restore_command = 'cp /home/postgresql_wal/%f "%p"'

Here is an explanation for each line:

• standby_mode=on: specifies that the server must start as a standby server
• primary_conninfo: the parameters to use to connect to the master
• trigger_file: if this file exists, the server will stop the replication and act as a master
• restore_command: this command is only needed if you have used the archive_command on the master

Start PostgreSQL.

service postgresql start

Finally

You can see the replicate user on the Master server.

su - postgresql psql

SELECT * FROM pg_stat_activity WHERE usename = 'replicate';

Your database is ready.

Captura de la URL de la página falsa en Facebook.

Ahora veamos como se ve la URL de la página oficial es: https://www.facebook.com/BBVAContinental/.

Captura de la URL de la página oficial en Facebook.

¿Cuál es la diferencia?

La igualdad gráfica entre la “I” (i – vocal) mayúscula y la “l” (L – ele) minúscula.

¿Debería Facebook normalizar la URL de las páginas a minúsculas?

No, porque más importante que el cambio de mayúsculas a minúsculas son los filtros para empresas que anuncian en Facebook. Diariamente cientos páginas de Facebook fraudulentas que poseen el mismo nombre de las páginas a las cuales replican publican anuncios con un fin maligno.

Mejor control:

• Páginas que poseen el mismo nombre que páginas verificadas no deberían ser autorizados a publicar anuncio alguno.
• No es posible reportar anuncios como posible suplantación o fraude.

Opciones actuales para el reporte de anuncios.

• El reporte o denuncia de posibles fan pages falsos no permite que la página sea revisada por el personal de Facebook. Este punto es sumamente importante pues actualmente el proceso de reporte es de dos pasos y no permite reportarlo al personal de Facebook.

Next time, you’ll know it.

class PostViewSet(viewsets.ModelViewSet):
  queryset         = Post.objects.all()
  serializer_class = serializers.PostSerializer

  def perform_create(self, serializer):
    kwargs = {
      'user': self.request.user # Change 'user' to you model user field.
    }

    serializer.save(**kwargs)

As usual my recommendation is to create “Mixin” like this one:

class UserCreateMixin(object):
  """
  By default the user field is "user" you can change it
  to your model "user" field.

  Usage:
  class PostViewSet(UserCreateMixin, viewsets.ModelViewSet):
    # ViewsSet required info...
    user_field = 'creator'
  """
  user_field = 'user'

  def get_user_field(self):
    """
    You can dynamically change the user field
    """
    return self.user_field

  def perform_create(self, serializer):
    kwargs = {
      self.get_user_field(): self.request.user
    }

    serializer.save(**kwargs)

If you think that there is a better way, let us know in the comments bellow.

On the client side, on my angular app:

angular.controller('ImageUploadFormCtrl', function($scope, Photo){
  $scope.submitForm = function(isValid){
    if(isValid){
      f = new FileReader(); // or $window.FileReader()
      
      f.onload = function () {
        $scope.formData.image = f.result; // This is a base64 string

        Photo.save({}, $scope.formData).$promise.then(function(data){
          // 200 Response
          alert('Client image successfully updated.');
        }, function(error){
          // 400 Response
          console.log('Error', error);
          alert('An error has ocurred.');
        })
      };      
      
      // Read the file selected on the field with ID "image-field"
      f.readAsDataURL(document.getElementById('image-field').files[0]);
    }
  }
});

On the server side on my Django app, specifically on the serializers.py file:

import base64, uuid
from django.core.files.base import ContentFile

class Base64ImageField(serializers.ImageField):
  def to_internal_value(self, data):
    if isinstance(data, basestring) and data.startswith('data:'): # You can change "data:" to "data/image:"
      format, imgstr = data.split(';base64,')
      ext  = format.split('/')[-1]
      id   = uuid.uuid4()
      data = ContentFile(base64.b64decode(imgstr), name=id.urn[9:])

    return super(Base64ImageField, self).to_internal_value(data)

class PhotoSerializer(serializers.ModelSerializer):
  image = Base64ImageField(allow_empty_file=False)
  
  class Meta:
    fields           = ('id', 'image')
    model            = Photo
    read_only_fields = ('id', )

I found out that this is the cleaner way to do this. If you have another alternative, please share it.

export PIP_REQUIRE_VIRTUALENV=true
# define a "global pip" function to use outside virtualenv:
gpip(){
    PIP_REQUIRE_VIRTUALENV="" pip "$@"
}

After that, reload the source file with this command source ~/.bash_profile.

Really, that’s it! and you are good to go.

I’m in love with Django and as a love we should be able to know how to scale Django properly that’s why I’m sharing this video with you. So you can make your Django deployment “greater again” (no pun intended).