qqq 0.1.1 → 0.1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 901963455ef035a7b1055749513102b79fa568304c668038a585dcff606f73b8
-  data.tar.gz: 7de4aa5267b50b0d62b8815237ad61e36111d0859a0f7379f5d83388dc03ebf8
+  metadata.gz: bb0807569101ac3a9dd5bcb582dbcaced669fd5b71d298b75edb3fa18652aae1
+  data.tar.gz: 484588c403f56496c7cfd884c60b47c1a7d72f36167bc4c5ad7693a8b52a150c
 SHA512:
-  metadata.gz: f3739b7a3fcbc083cf1017e64c5fc0182e120afb6b6e9736c69bfd6f175497ecbb8a79971e749e689622367f3b77df12802ad088f22f259403ba2da6fea4cfc2
-  data.tar.gz: 471fc79d97ac7583978b2582eaa4bb77366e58e9cd445abf750069f399ec308e7232a175f1aaeac8e482262f1efb949dc945797213906abcae847fc10d8e488b
+  metadata.gz: 4e6c7a27bfd72b2b42808136f4cd026d00f88a702286e0a9ace78ee9d201a8a7f61e8f4773f716e52d22dd0d9d947c7bbf2bc8c7616b81fa44fdbc0c3ccca91a
+  data.tar.gz: 562a4bff7546705caf92a099b66e36c3e241479a633c2d799cd35f82af41ac73370dd702e30f3002629edc35633f17c2cbe181e999c6c4b668989a6f543dc1ac

data/CHANGELOG.org

@@ -1,59 +1,160 @@
+* Upcoming 0.2.0 - Woodworking
 
-* Version 0.1.0 - Milestone I
+"Do one thing well"
 
-"Better than puts"
+Slim down all the extras. Focus on print debugging from anywhere in ruby.
+
+** 0.1.2
+
+- [X] Simplify dashboard, easier to read
+- [X] remove send... for now. 
+- [X] remove payload command for only tail
+- [X] mark command can optionally repeat
+
+** 0.1.1 
+
+- [X] Hack around fakeredis to get redis connection, if enabled
+- [X] Remove messages in favor of richer Event structure 
+
+* DONE 0.1.0 - A Thing
+
+"It's doing /something/"
 
 features
-- [X] recorded timestamp and uuid recorded in db
-- [X] record in a database
+- [X] recorded timestamp and uuid recorded in db through app
+- [X] record message in a database
 - [X] send to an api
 - [X] timestamps 
 - [X] send message from command line
 - [X] tail and mark from command line
 
 dev
-- [ ] simplify dashboard 
-- [X] create rudimentary uh... dashboard/orchestration
-- [X] Tighten e2e.sh test.
+- [X] Create rudimentary uh... dashboard/orchestration
+- [X] Create e2e.sh
 
-** 0.1.1 
+* Roadmap 
 
-table stakes
-- [ ] some sort of supervisor around cli, etc. e.g. api send dies if server not up yet. should hang out and retry
-- [ ] update documentation
-- [ ] general presentation polish
+** Table stakes / cleanup
+- [ ] Add enough documentation to hello, world (and understand what qqq is) 
+- [ ] get someone else to install it, use it
+- [ ] Supervisor around cli, etc. e.g. api send dies if server not up yet
+- [ ] Cut out redis for ruby pubsub? generate servers for every lang..? just make them..?  https://blog.appsignal.com/2018/08/28/push-and-pubsub-in-ruby.html
 - [ ] more tests? CI?
+- [ ] Remove payload/messages dichotomy
 
-features
-- [ ] a way to specifiy redis config (my qqq's in tests are getting lost to a fake redis)
-
-* Milestone II
-
-features
+** user features
+- [ ] file worker (append to /tmp/qqq)
+- [ ] a way to specifiy redis config
 - [ ] did not run (no wondering if line didn't run)... possible?
 - [ ] increments if run multiple times..
 - [ ] start / stop 'marks' 
 - [ ] some recent history (last 100?) when I start tailing
 - [ ] q, qq, qqq levels
-- [ ] file worker (append to /tmp/qqq)
 - [ ] plugin arch for worker 
 - [ ] updated development documentation 
 - [ ] api key to follow me around (~/.qqq.conf or whatever) 
 - [ ] updating webapp (websockets) 
 - [ ] handles complex object printing
-- [ ] rich data
+- [ ] accept payloads, rich data, rich data
 - [ ] metaprogramming / reflection
 - [ ] config panel to turn on/off 'q steams'
 
-
-dev
-- [ ] some sort of handshake system for handling processes
+** dev
+- [ ] how can i test this whole system
+- [ ] system log channel, 
+- [ ] perhaps.. handshake system for handling processes, testing?
 - [ ] local gem dev - de-req rake install loop 
 - [ ] split out configuration (yaml?) for 'service' interaction
-- [ ] split the development panel / user panel 
+- [ ] split the development panel / user panel
 
-* Beyond
+** brewing ideas
 
+- get off redis... https://faye.jcoglan.com/ruby/clients.html
 - move to a ruby only actor model? (https://github.com/ntl/actor)
-- consider other options?
-- electron app for dashboard? get away from shell stuff
+- other langs, javascript?
+- electron app for dashboard? get away from shell stuff... 
+
+restreaming
+- qqq.restream(:my_event) do |event| 
+    ...
+  end
+
+- log to the standard log with a link to the specific log
+ 
+check out https://github.com/janlelis/debugging
+
+*** Writing a program to generate the apis...
+
+ Could I write some sort of program that could.. create these clients? 
+
+ #+begin_src lisp
+   (namespace :QQQ :CLI
+     (define-cli
+       (define-task "tail"
+         (qqq/subscribe (key message-channel) print-event-to-screen)))
+
+     (define-function print-event-to-screen (event)
+       (system-output-command
+        (brackets (:timestamp event))
+        (space)
+        (brackets (:uuid event))
+        (space)
+        (brackets (:message event))
+        (newline))))
+
+   (namespace
+    :QQQ :API
+    (define-function :publish (message)
+      (redis :publish (key event-channel)
+             (marshall-to-json (create-event
+                                (create-uuid
+                                 create-timestamp
+                                 message)))))
+
+   (namespace
+    :QQQ :API
+    (define-function :subscribe (function_or_callable)
+      (redis :subscribe (key event-channel)
+             (lambda (event) (call function_or_callable event)))))
+ #+end_src
+
+
+ Could potentially use org-mode/tangle to do multi-lang well
+
+ (After qqq, do developer user interviews screen share to find real patterns...)
+
+ Under heading * Ruby ** Define Module
+
+ #+value: module-name
+ #+value: content
+ #+begin_src ruby
+ defmodule #{module-name}
+    #{content}
+ end
+ #+end_src
+
+ I bet that could done reasonably in ruby...
+
+
+ #+begin_src ruby
+   class Generator
+     attr_reader :lang
+     def define_namespace (name, &content_block)
+       #render :erb, "path/to/_module.erb", name, content_block.render
+   <<-END
+   defmodule #{name}
+     #{content_block.render}
+   end
+   END
+     end
+
+
+   define_namespace(:QQQ) do
+     define_module(:CLI) do 
+       define_func(:echo, :argument_vector) do |messages|
+         Generated::Formatters::ForHumans.format(messages)
+         Generated::Library::QQQ::publish 
+       end
+     end
+   end
+ #+end_src

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    qqq (0.1.1)
+    qqq (0.1.1.1)
       activerecord
       faraday
       json

data/lib/qqq/api.rb

@@ -2,6 +2,15 @@ require 'faraday'
 
 module QQQ
   module API
+
+    # desc :send, "Sends message to a remote server"
+    # def send
+    #   QQQ.subscribe do |event|
+    #     puts "Remotely publishing: #{event.message}"
+    #     API.publish(event)
+    #   end
+    # end
+
     def self.publish(event)
       conn = Faraday.new(:url => "http://localhost:3600")
       resp = conn.post '/events', { :event => event.as_json }

data/lib/qqq/cli.rb

@@ -1,52 +1,40 @@
 require 'thor'
-require 'json'
 
 module QQQ
   class CLI < Thor
-    default_task :tail
+    default_task "tail"
 
-    desc :tail, "Tails the qqq log"
+    desc "tail", "Tails the qqq log"
     def tail
-      QQQ.subscribe do |event|
-        puts event.message
+      qqq.subscribe do |event|
+        puts event.for_humans
       end
     end
 
-    desc :payload, "For now- separate tail"
-    def payload
-      QQQ.subscribe do |event|
-        puts event.to_s
+    desc "mark [repeat_interval]", "Marks the log (optionally every X seconds)"
+    def mark(repeat_interval)
+      repeat_interval = repeat_interval.to_i rescue 0
+      loop do
+        qqq.mark
+
+        if repeat_interval > 0
+          sleep repeat_interval
+        else
+          break
+        end
       end
     end
 
-    desc :mark, "Marks the log"
-    def mark
-      QQQ.publish("MARK: --MARK--")
-    end
-
-    desc "echo [messages]", "Simple echo"
+    desc "echo [messages]", "Log a message"
     def echo(*messages)
-      QQQ.publish("ECHO: #{messages.join(" ")}")
-    end
-
-    desc :send, "Sends message to a remote server"
-    def send
-      QQQ.subscribe do |event|
-        puts "Remotely publishing: #{event.message}"
-        API.publish(event)
-      end
+      QQQ.publish("#{messages.join(" ")}")
     end
 
-    desc :version, "Publishes the version number"
+    desc :version, "Logs the version number"
     def version
-      puts "QQQ Version #{QQQ::VERSION}"
+      puts "QQQ version: #{QQQ::VERSION}"
       QQQ.publish(QQQ::VERSION)
     end
-
-    # desc :server, "Starts server to receive message"
-    # def server
-    #   Sinatra....how?
-    # end
   end
 end
 

data/lib/qqq/{event.rb → events.rb}

@@ -3,16 +3,25 @@ module QQQ
 
     attr_reader :uuid, :message, :recorded_at
 
-    def self.from(json_string:)
+    def self.from_message(message)
+      timestamp = Time.now
+      uuid = UUIDTools::UUID.random_create().to_s
+      Event.new(uuid: uuid, message: message, recorded_at: timestamp)
+    end
+
+    def self.from_json_string(json_string)
       payload = JSON.parse json_string
-      puts payload
       Event.new(uuid: payload["uuid"], message: payload["message"], recorded_at: payload["recorded_at"])
     end
 
     def initialize(uuid:, message:, recorded_at:)
       @uuid = uuid
-      @message = message
       @recorded_at = recorded_at
+      @message = message
+    end
+
+    def for_humans
+      "[#{@uuid}] [#{@recorded_at}] #{@message}"
     end
 
     def as_json(options={})
@@ -27,4 +36,5 @@ module QQQ
     end
 
   end
+
 end

data/lib/qqq/keys.rb

@@ -1,6 +1,6 @@
 module QQQ
   module Keys
-    MESSAGES_CHANNEL_KEY = "qqq::messages_channel"
-    EVENT_CHANNEL_KEY = "qqq::payload_channel"
+    SYSTEM_CHANNEL_KEY = "qqq::channel::system"
+    EVENT_CHANNEL_KEY = "qqq::channel::event"
   end
-end
+end

data/lib/qqq/version.rb

@@ -1,3 +1,3 @@
 module QQQ
-  VERSION = "0.1.1"
+  VERSION = "0.1.1.1"
 end

data/lib/qqq.rb

@@ -1,57 +1,76 @@
+# Gems
 require 'redis'
 require 'json'
+require 'uuidtools'
 
 # Lib
-require 'qqq/event'
+require 'qqq/events'
 require 'qqq/api'
 require 'qqq/cli'
 require 'qqq/keys'
 require 'qqq/version'
 
-require 'uuidtools'
 
-module QQQ
-  class Error < StandardError; end
 
-  # message = "hello world"
-  def self.qqq(message)
-    publish(message)
+module Kernel
+  private
+  def q(message=nil)
+    @qqq_developer ||= QQQ::Developer.new
+    message ? @qqq_developer.publish(message) : @qqq_developer.mark
+    @qqq_developer
   end
 
-  def self.publish(message)
-    uuid = UUIDTools::UUID.random_create().to_s
-    timestamp = Time.now
+  def qqq(message=nil)
+    @qqq_developer ||= QQQ::Developer.new
+    message ? @qqq_developer.publish(message) : @qqq_developer.mark
+    @qqq_developer
+  end
+end
 
-    message_for_humans = "[#{uuid}] [#{timestamp}] #{message}"
-    redis.publish(Keys::MESSAGES_CHANNEL_KEY, message_for_humans.to_json)
+module QQQ
+  class Error < StandardError; end
 
-    event = Event.new(uuid: uuid, message: message, recorded_at: timestamp)
-    redis.publish(Keys::EVENT_CHANNEL_KEY, event.to_json)
-  end
+  #
+  # Developer log channels
+  #
+  class Developer
 
-  def self.subscribe &block
-    redis.subscribe Keys::EVENT_CHANNEL_KEY do |on|
-      puts "Connected..."
+    def initialize
+      @mark_counter = 0
+    end
+
+    def mark
+      @mark_counter += 1
+      publish("MARK: --MARK-- (#{@mark_counter})")
+    end
+
+    def publish(message)
+      event = Event.from_message(message)
+      redis.publish(Keys::EVENT_CHANNEL_KEY, event.to_json)
+    end
 
-      on.message do |channel, event_json_string|
-        event = Event.from(json_string: event_json_string)
-        block.call(event)
+    def subscribe &block
+      redis.subscribe Keys::EVENT_CHANNEL_KEY do |on|
+        on.message do |channel, event_json_string|
+          event = Event.from_json_string(event_json_string)
+          block.call(event)
+        end
       end
     end
-  end
 
-  private
+    private
 
-  def self.redis
-    puts "wha hoo"
-    if defined?(FakeRedis) && FakeRedis.enabled?
-      FakeRedis.disable
-      @redis ||= Redis.new
-      FakeRedis.enable
-    else
-      @redis ||= Redis.new
+    def redis
+      if defined?(FakeRedis) && FakeRedis.enabled?
+        FakeRedis.disable
+        @redis ||= Redis.new
+        FakeRedis.enable
+      else
+        @redis ||= Redis.new
+      end
+
+      @redis
     end
   end
-
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qqq
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.1.1
 platform: ruby
 authors:
 - Jon Skulski
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-24 00:00:00.000000000 Z
+date: 2019-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -203,7 +203,7 @@ files:
 - lib/qqq.rb
 - lib/qqq/api.rb
 - lib/qqq/cli.rb
-- lib/qqq/event.rb
+- lib/qqq/events.rb
 - lib/qqq/keys.rb
 - lib/qqq/version.rb
 - qqq.gemspec