def setUp(self):
"""
Set up an app to test with.
"""
FlaskTrackUsageTestCase.setUp(self)
self.storage = MongoEngineStorage(hooks=[
sumUrl,
sumRemote,
sumUserAgent,
sumLanguage,
sumServer
])
self.track_usage = TrackUsage(self.app, self.storage)
# Clean out the summary
UsageTrackerSumUrlHourly.drop_collection()
UsageTrackerSumUrlDaily.drop_collection()
UsageTrackerSumUrlMonthly.drop_collection()
UsageTrackerSumRemoteHourly.drop_collection()
UsageTrackerSumRemoteDaily.drop_collection()
UsageTrackerSumRemoteMonthly.drop_collection()
UsageTrackerSumUserAgentHourly.drop_collection()
UsageTrackerSumUserAgentDaily.drop_collection()
UsageTrackerSumUserAgentMonthly.drop_collection()
UsageTrackerSumLanguageHourly.drop_collection()
UsageTrackerSumLanguageDaily.drop_collection()
UsageTrackerSumLanguageMonthly.drop_collection()
UsageTrackerSumServerHourly.drop_collection()
UsageTrackerSumServerDaily.drop_collection()
UsageTrackerSumServerMonthly.drop_collection()
# trigger one timed summary
self.now = datetime.datetime.utcnow()
self.hour = self.now.replace(minute=0, second=0, microsecond=0)
self.day = self.now.replace(hour=0, minute=0, second=0, microsecond=0)
self.month = self.now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
self.client.get('/')
def test_neither_include_nor_exclude(self):
"""
Verify that we fail when we don't state include or exclude.
"""
self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = ''
with self.assertRaises(NotImplementedError):
TrackUsage(self.app, self.storage)
def setUp(self):
self.given_table_name = 'my_usage'
FlaskTrackUsageTestCase.setUp(self)
self.blueprint = Blueprint('blueprint', __name__)
@self.blueprint.route('/blueprint')
def blueprint():
return "blueprint"
self.app.register_blueprint(self.blueprint)
self._create_storage()
self.fake_time = datetime.datetime(
2018, 4, 15, 9, 45, 12) # Apr 15, 2018 at 9:45:12 AM UTC
self.fake_hour = datetime.datetime(2018, 4, 15, 9, 0,
0) # Apr 15, 2018 at 9:00:00 AM UTC
self.fake_day = datetime.datetime(2018, 4, 15, 0, 0,
0) # Apr 15, 2018 at 0:00:00 AM UTC
self.fake_month = datetime.datetime(
2018, 4, 1, 0, 0, 0) # Apr 1, 2018 at 0:00:00 AM UTC
self.track_usage = TrackUsage(self.app,
self.storage,
_fake_time=self.fake_time)
self.track_usage.include_blueprint(self.blueprint)
def setUp(self):
"""
Set up an app to test with.
"""
FlaskTrackUsageTestCase.setUp(self)
self.storage = TestStorage()
self.track_usage = TrackUsage(self.app, self.storage)
def setUp(self):
"""
Set up an app to test with.
"""
FlaskTrackUsageTestCase.setUp(self)
self.storage = MongoEngineStorage()
# Clean out the storage
self.storage.collection.drop_collection()
self.track_usage = TrackUsage(self.app, self.storage)
def setUp(self):
"""
Set up an app to test with.
"""
FlaskTrackUsageTestCase.setUp(self)
self.storage = MongoPiggybackStorage(collection=COLLECTION)
# Clean out the storage
self.storage.collection.drop()
self.track_usage = TrackUsage(self.app, self.storage)
def setUp(self):
"""
Set up an app to test with.
"""
FlaskTrackUsageTestCase.setUp(self)
self.storage = MongoStorage(database=DB, collection=COLL_NAME)
# Clean out the storage
self.storage.collection.drop()
self.track_usage = TrackUsage(self.app, self.storage)
def test_late_neither_include_nor_exclude(self):
"""
Make sure that if someone attempts to change the type to something
unsupported we fail
"""
self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include'
self.track_usage = TrackUsage(self.app, self.storage)
self.track_usage._type = ''
with self.assertRaises(NotImplementedError):
self.client.get('/')
def setUp(self):
"""
Create the app, track usage and init storage
"""
self.given_table_name = 'my_usage'
FlaskTrackUsageTestCase.setUp(self)
self._create_storage()
self.track_usage = TrackUsage()
self.track_usage.init_app(self.app, self.storage)
def setUp(self):
"""
Set up an app to test with.
"""
FlaskTrackUsageTestCase.setUp(self)
# self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include'
self.storage = RedisStorage()
# Clean out the storage
# self.storage.collection.drop()
self.track_usage = TrackUsage(self.app, self.storage)
def setUp(self):
self.given_table_name = 'my_usage'
FlaskTrackUsageTestCase.setUp(self)
self.blueprint = Blueprint('blueprint', __name__)
@self.blueprint.route('/blueprint')
def blueprint():
return "blueprint"
self.app.register_blueprint(self.blueprint)
self._create_storage()
self.track_usage = TrackUsage(self.app, self.storage)
self.track_usage.include_blueprint(self.blueprint)
def test_raw_blueprint(self):
"""
Verify that raw blueprints don't get modified.
"""
self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include'
tu = TrackUsage(self.app, self.storage)
# There should be no included/excluded views
assert len(tu._include_views) == 0
assert len(tu._exclude_views) == 0
# There should be no storing of data at all
for page in ('/', '/included', '/excluded'):
self.client.get(page)
with self.assertRaises(IndexError):
self.storage.get()
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(Config)
# app.redis = Redis.from_url(app.config['REDIS_URL'])
# app.task_queue = rq.Queue(connection=app.redis)
db.init_app(app)
t = TrackUsage(
app, [MongoStorage('PersonalWebsite', 'tracking', Config.MONGO_URI)])
from website.main.routes import main
from website.jobs.routes import jobs
from website.analytics.routes import analytics_bp
app.register_blueprint(main)
app.register_blueprint(jobs)
app.register_blueprint(analytics_bp)
t.include_blueprint(main)
return app
def test_include_type(self):
"""
Test that include only covers what is included.
"""
self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include'
self.track_usage = TrackUsage(self.app, self.storage)
@self.track_usage.include
@self.app.route('/included')
def included():
return "INCLUDED"
# /includeds hould give results
self.client.get('/included')
assert type(self.storage.get()) is dict
# / should not give results as it is not included
self.client.get('/')
with self.assertRaises(IndexError):
self.storage.get()
def test_exclude_type(self):
"""
Test that exclude covers anything not excluded.
"""
self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'exclude'
self.track_usage = TrackUsage(self.app, self.storage)
@self.track_usage.exclude
@self.app.route('/excluded')
def excluded():
return "INCLUDED"
# / hould give results
self.client.get('/')
assert type(self.storage.get()) is dict
# /excluded should not give results as it is excluded
self.client.get('/excluded')
with self.assertRaises(IndexError):
self.storage.get()
def test_exclude_blueprint(self):
"""
Verify that an entire blueprint can be excluded.
"""
self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'exclude'
tu = TrackUsage(self.app, self.storage)
tu.exclude_blueprint(self.blueprint)
# There should be 2 excluded views, 0 included views
assert len(tu._include_views) == 0
assert len(tu._exclude_views) == 2
# Index should store something
self.client.get('/')
assert type(self.storage.get()) is dict
# Both pages should not store anything
for page in ('/included', '/excluded'):
self.client.get(page)
with self.assertRaises(IndexError):
self.storage.get()
def test_include_blueprint(self):
"""
Verify that an entire blueprint can be included.
"""
self.app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include'
tu = TrackUsage(self.app, self.storage)
tu.include_blueprint(self.blueprint)
# There should be 2 included views, no excluded views
assert len(tu._include_views) == 2
assert len(tu._exclude_views) == 0
# Both paged should store
for page in ('/included', '/excluded'):
self.client.get(page)
assert type(self.storage.get()) is dict
# But the index (outside of the blueprint) should not
self.client.get('/')
with self.assertRaises(IndexError):
self.storage.get()
try:
from flask import Flask, g
from flask_track_usage import TrackUsage
from flask_track_usage.storage.printer import PrintWriter
from flask_track_usage.storage.output import OutputWriter
except Exception as e:
print("Some modules is missing:{}".format(e))
app = Flask(__name__)
app.config['TRACK_USAGE_USE_FREEGEOIP'] = False
app.config["TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS"] = "include"
t = TrackUsage(
app,
[PrintWriter(),
OutputWriter(transform=lambda s: "OUTPUT: " + str(s))])
@t.include
@app.route("/")
def index():
g.track_var["optional"] = "something"
return "Hello"
if __name__ == "__main__":
app.run(debug=True)
from flask import Flask, g
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
# Set the configuration items manually for the example
app.config['TRACK_USAGE_USE_FREEGEOIP'] = True
app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include'
from flask_track_usage import TrackUsage
from flask_track_usage.storage.printer import PrintWriter
from flask_track_usage.storage.output import OutputWriter
from flask_track_usage.storage.sql import SQLStorage
# Make an instance of the extension and put two writers
app.config['SECRET_KEY'] = '5791628bb0b13ce0c676dfde280ba245'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'
db = SQLAlchemy(app)
t = TrackUsage(app, SQLStorage(db=db))
# Include the view in the metrics
@t.include
@app.route('/')
def index():
#g.track_var["optional"] = "something"
return "Hello"
# Run the application!
app.run(debug=True)
def get_db():
db = getattr(g, '_database', None)
if db is None:
db = g._database = sqlite3.connect(database)
return db
# PostgreSQL Setup
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///ppt.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
sql_db = SQLAlchemy(app)
# Track Usage Setup
# mstore = MongoEngineStorage()
pstore = SQLStorage(db=sql_db)
t = TrackUsage(app, [pstore])
@app.route('/')
def home():
return render_template("homepage.html")
@app.route('/property_form', methods=['POST', 'GET'])
def property_form():
if request.method == "POST":
# Retrieve buyer citizenship
buying_status = request.form['buyAs']
# Retrieve buyer number of home
app.config['SECURITY_MANAGER'] = Security(
app, SQLAlchemyUserDatastore(manager.database, md.User, md.Role))
# Setup Flask-Session
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = manager.server
app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=100)
app.config['SESSION_MANAGER'] = Session(app)
# Setup Flask-TrackUsage
app.config['TRACK_USAGE_COOKIE'] = True
app.config['TRACK_USAGE_USE_FREEGEOIP'] = False
app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'exclude'
with app.app_context():
storage = SQLStorage(db=manager.database)
t = TrackUsage(app, storage)
# Allows compression of text assets
# If the server has automatic compression, comment this line.
compress = Compress(app)
# Setup Flask-Babel
app.config['LANGUAGES'] = ['en', 'fr']
app.config['BABEL_TRANSLATION_DIRECTORIES'] = 'translations'
babel = Babel(app)
@app.template_filter('autoversion')
def autoversion_filter(filename):
fullpath = os.path.join('', filename[1:])
try:
#
#########################
me.connect("example_website")
#########################
#
# SETUP FLASK_TRACK_USAGE
#
#########################
app.config['TRACK_USAGE_USE_FREEGEOIP'] = False
app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'exclude'
traffic_storage = MongoEngineStorage(hooks=[sumUrl, sumUserAgent])
t = TrackUsage(app, [traffic_storage])
#########################
#
# PUBLIC ROUTES
#
#########################
@app.route('/')
def index():
g.track_var["something"] = 99
return render_template('index.html')
@app.route('/page1')
def page_one():
g.track_var["something"] = 34
def create_app():
app = Flask(__name__)
# Load config from ENV is set, default otherwise.
app.config.from_object(os.getenv('FLASK_SETTINGS', 'config.Config'))
# Configuring database.
# Causes significant overhead if True.
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# Tracks cookies - used for unique visitor count
app.config['TRACK_USAGE_COOKIE'] = True
db.init_app(app)
talisman.init_app(app,
content_security_policy={
'default-src':
'\'self\'',
'img-src': [
'*',
'data: https:',
],
'font-src':
'*',
'script-src': [
'\'self\'',
'\'unsafe-inline\'',
'maxcdn.bootstrapcdn.com',
'cdnjs.cloudflare.com',
'ajax.googleapis.com',
'kit.fontawesome.com',
'cdn.quilljs.com',
],
'style-src': [
'\'self\'',
'\'unsafe-inline\'',
'maxcdn.bootstrapcdn.com',
'kit-free.fontawesome.com',
'cdn.quilljs.com',
],
})
bcrypt.init_app(app)
login_manager.init_app(app)
login_manager.login_view = 'users.login'
#mail.init_app(app)
# We need the app's context to create the db related to it.
from models import init_db, User
with app.app_context():
init_db()
# TrackUsage Setup
pstore = SQLStorage(db=db)
t = TrackUsage(app, [pstore])
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
from drug_chart.routes import drug_chart
from users.routes import users
from main.routes import main
from announcements.routes import announcements
from faq.routes import faq
from about.routes import about
from content.routes import content
from dashboard.routes import dashboard
from quiz.routes import quiz
blueprints = [
drug_chart, users, main, faq, about, announcements, content, dashboard,
quiz
]
for blueprint in blueprints:
app.register_blueprint(blueprint)
t.include_blueprint(blueprint)
@app.errorhandler(404)
def page_not_found(error):
return render_template('404.html', title='404'), 404
return app
import os
from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemy
from flask_bcrypt import Bcrypt
from flask_login import LoginManager
from flask_track_usage import TrackUsage
from flask_track_usage.storage.sql import SQLStorage
from flask_talisman import Talisman # To force an SSL connection
#from flask_mail import Mail
db = SQLAlchemy()
bcrypt = Bcrypt()
talisman = Talisman()
login_manager = LoginManager()
t = TrackUsage()
#mail = Mail()
def create_app():
app = Flask(__name__)
# Load config from ENV is set, default otherwise.
app.config.from_object(os.getenv('FLASK_SETTINGS', 'config.Config'))
# Configuring database.
# Causes significant overhead if True.
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# Tracks cookies - used for unique visitor count
app.config['TRACK_USAGE_COOKIE'] = True
db.init_app(app)
talisman.init_app(app,
db = SQLAlchemy(app,
metadata=MetaData(naming_convention=naming_convention),
model_class=BaseModel)
migrate = Migrate(app=app, db=db)
#altre magie per sqlalchemy per sqlite
with app.app_context():
if db.engine.url.drivername == 'sqlite':
migrate.init_app(app, db, render_as_batch=True)
else:
migrate.init_app(app, db)
#
# TrackUsage setup
#
track_datastore = SQLStorage(engine=db.get_engine(bind="trackusage"))
t = TrackUsage(app, [track_datastore])
from app import routes, errors, models
from app.models import Users, Roles, Tokens, TokenTypes, Apis, TokenApiCounters
from app.models import Languages, ErrorGroups, ErrorCodes, ErrorTranslations
from app.models import Area, Location, Neighborhood, Poi, PoiCategory, PoiCategoryType, Street
from app.models import FlaskUsage
from app.models import Ideas
from app.models import Errors, Feedbacks
#
# Users setup
#
user_datastore = SQLAlchemyUserDatastore(db, Users, Roles)
security = Security(app, user_datastore)
from flask import Flask, g
from pymongo import MongoClient
from flask_track_usage import TrackUsage
from flask_track_usage.summarization import sumUrl
from flask_mongoengine import MongoEngine
from flask_track_usage.storage.mongo import MongoEngineStorage
app = Flask(__name__)
# Set the configuration items manually for the example
app.config['TRACK_USAGE_USE_FREEGEOIP'] = False
# You can use a different instance of freegeoip like so
# app.config.cgf['TRACK_USAGE_FREEGEOIP_ENDPOINT'] = 'http://extreme-ip-lookup.com/json/'
app.config['TRACK_USAGE_INCLUDE_OR_EXCLUDE_VIEWS'] = 'include'
app.config['MONGODB_SETTINGS'] = {'db': 'website'}
mongo_db = MongoEngine(app)
mstore = MongoEngineStorage(hooks=[sumUrl])
# Make an instance of the extension and put two writers
t = TrackUsage(app, [mstore])
# dbs = list(db.usageTracking.find({}))
# a= len(dbs)
# print(dbs)
# Run the application!
def setUp(self):
"""
Set up an app to test with.
"""
self.fake_time1 = datetime.datetime(2018, 4, 15, 8, 45, 12) # Apr 15, 2018 at 8:45:12 AM UTC
self.fake_hour1 = datetime.datetime(2018, 4, 15, 8, 0, 0) # Apr 15, 2018 at 8:00:00 AM UTC
self.fake_day1 = datetime.datetime(2018, 4, 15, 0, 0, 0) # Apr 15, 2018 at 0:00:00 AM UTC
self.fake_month1 = datetime.datetime(2018, 4, 1, 0, 0, 0) # Apr 1, 2018 at 0:00:00 AM UTC
self.fake_time2 = datetime.datetime(2018, 4, 15, 9, 45, 12) # Apr 15, 2018 at 9:45:12 AM UTC
self.fake_hour2 = datetime.datetime(2018, 4, 15, 9, 0, 0) # Apr 15, 2018 at 9:00:00 AM UTC
self.fake_day2 = datetime.datetime(2018, 4, 15, 0, 0, 0) # Apr 15, 2018 at 0:00:00 AM UTC
self.fake_month2 = datetime.datetime(2018, 4, 1, 0, 0, 0) # Apr 1, 2018 at 0:00:00 AM UTC
self.fake_time3 = datetime.datetime(2018, 4, 16, 9, 45, 12) # Apr 16, 2018 at 9:45:12 AM UTC
self.fake_hour3 = datetime.datetime(2018, 4, 16, 9, 0, 0) # Apr 16, 2018 at 9:00:00 AM UTC
self.fake_day3 = datetime.datetime(2018, 4, 16, 0, 0, 0) # Apr 16, 2018 at 0:00:00 AM UTC
self.fake_month3 = datetime.datetime(2018, 4, 1, 0, 0, 0) # Apr 1, 2018 at 0:00:00 AM UTC
self.fake_time4 = datetime.datetime(2018, 5, 10, 9, 45, 12) # May 10, 2018 at 9:45:12 AM UTC
self.fake_hour4 = datetime.datetime(2018, 5, 10, 9, 0, 0) # May 10, 2018 at 9:00:00 AM UTC
self.fake_day4 = datetime.datetime(2018, 5, 10, 0, 0, 0) # May 10, 2018 at 0:00:00 AM UTC
self.fake_month4 = datetime.datetime(2018, 5, 1, 0, 0, 0) # May 1, 2018 at 0:00:00 AM UTC
FlaskTrackUsageTestCase.setUp(self)
self.storage = MongoEngineStorage(hooks=[
sumUrl,
sumRemote,
sumUserAgent,
sumLanguage,
sumServer
])
self.track_usage = TrackUsage(
self.app,
self.storage,
_fake_time = self.fake_time1
)
# Clean out the summary
UsageTrackerSumUrlHourly.drop_collection()
UsageTrackerSumUrlDaily.drop_collection()
UsageTrackerSumUrlMonthly.drop_collection()
UsageTrackerSumRemoteHourly.drop_collection()
UsageTrackerSumRemoteDaily.drop_collection()
UsageTrackerSumRemoteMonthly.drop_collection()
UsageTrackerSumUserAgentHourly.drop_collection()
UsageTrackerSumUserAgentDaily.drop_collection()
UsageTrackerSumUserAgentMonthly.drop_collection()
UsageTrackerSumLanguageHourly.drop_collection()
UsageTrackerSumLanguageDaily.drop_collection()
UsageTrackerSumLanguageMonthly.drop_collection()
UsageTrackerSumServerHourly.drop_collection()
UsageTrackerSumServerDaily.drop_collection()
UsageTrackerSumServerMonthly.drop_collection()
# generate four entries at different times
#
self.client.get('/')
self.track_usage._fake_time = self.fake_time2
self.client.get('/')
self.track_usage._fake_time = self.fake_time3
self.client.get('/')
self.track_usage._fake_time = self.fake_time4
self.client.get('/')
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import json
from flask import Flask
from flask_track_usage import TrackUsage
from flask_track_usage.storage.redis_db import RedisStorage
from datetime import datetime
app = Flask(__name__)
redis = RedisStorage()
track = TrackUsage(app, redis)
@app.route('/')
def index():
return "ok"
@track.exclude
@app.route('/usage')
def usage():
now = datetime.now()
yesterday = datetime.fromtimestamp(1421111101) # 2015-1-13 02:05:01
res = redis.get_usage(now, yesterday)
# res = redis.get_usage()
print res
return json.dumps(res)
app.config['PROPAGATE_EXCEPTIONS'] = True
app.run(port=8081, use_reloader=True)
